File Coverage

blib/lib/OpenOffice/Parse/SXC.pm

Criterion	Covered	Total	%
statement	10	12	83.3
branch			n/a
condition			n/a
subroutine	4	4	100.0
pod			n/a
total	14	16	87.5

package OpenOffice::Parse::SXC;

use 5.006;
use strict;
use warnings;
use XML::Parser;
use IO::File;
require Exporter;

our @ISA = qw(Exporter);

# Items to export into callers namespace by default. Note: do not export
# names by default without a very good reason. Use EXPORT_OK instead.
# Do not simply export all your public functions/methods/constants.

# This allows declaration	use OpenOffice::Parse::SXC ':all';
# If you do not need this, moving things directly into @EXPORT or @EXPORT_OK
# will save memory.
our %EXPORT_TAGS = ( 'all' => [ qw(
	parse_sxc csv_quote dump_sxc_file
) ] );

our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );

our @EXPORT = qw(
);
our $VERSION = '0.03';

my %valid_options	= ( worksheets	=> 1,
			    no_trim	=> 1,
			  );

##################################################################
# EXPORT_OK methods:

sub csv_quote {
  my $text		= shift;
  return ""		if( ! defined $text );
  $text =~ s/\n//g;	# Remove all newlines!
  $text =~ s/\"/\"\"/g;
  if( $text =~ /[,"']/ ) {
    $text		= "\"$text\"";
  }
  return $text;
}

sub parse_sxc {
  my $sxc_filename		= shift;
  my %options			= @_;
  my $SXC			= OpenOffice::Parse::SXC->new( %options );
  # OpenOffice::Parse::SXC implements the 'data_handler' interface, so we can
  # create an object to use itself as a data handler.
  $SXC->set_data_handler( $SXC );
  $SXC->parse_file( $sxc_filename );
  return $SXC->parse_sxc_rows;
}

# Used for debugging, dump_sxc_file parses a file and dumps the resultant objects
# onto STDOUT.  This is a good way to view just what's going on behind the scenes.

sub dump_sxc_file {
  my $filename		= shift;
  my $Parser		= XML::Parser->new( Style	=> "Objects" );

  my $results		= $Parser->parsefile( $filename );
  print Dumper( $results );
}

##################################################################
# The data_handler routines:
#
# These are provided to provide the simple interface parse_sxc()
#
# See parse_sxc() for more details

sub row {
  my $self		= shift;
  shift;
  my $row		= shift;
  push @{$self->{parse_sxc_rows}}, $row;
#  print join(",", @$row ),"\n";
}

sub worksheet {
  my $self		= shift;
  shift;
  my $worksheet		= shift;
  if( ! $self->{parse_sxc_rows} ) {
    $self->{parse_sxc_rows}	= [];
  }
#  print "IN WORKSHEET '$worksheet'.\n";
}

sub workbook {
  my $self		= shift;
  shift;
  my $workbook		= shift;
#  print "IN WORKBOOK '$workbook'.\n";
}

sub parse_sxc_rows {
  my $self		= shift;
  return @{$self->{parse_sxc_rows}};
}

sub clear_parse_sxc_rows {
  my $self		= shift;
  $self->{parse_sxc_rows}	= [];
}


# End data_handler routines
##################################################################

##################################################################
# Main OpenOffice::Parse::SXC methods:

sub new {
  my $type		= shift;
  my $self		= { options	=> {},
			  };
  bless $self, $type;
  my %options		= @_;
  $self->set_options( %options )	if( %options );
  $self->repeat_following_cell( 1 );	# Times the cell is to be repeated
  $self->repeat_following_row( 1 );	# Times the row is to be repeated
  $self->reset_cell_list;		# Clear out the cell list
  # If the user hasn't supplied a row handler, set up a default one for
  # him which prints out the data to STDOUT.
  if( ! $self->get_data_handler ) {
    $self->set_data_handler( $self );
  }
  $self->accept_rows( 0 );		# By default, start off accepting NOTHING
  $self->accept_cells( 0 );
  $self->accept_text( 0 );
  return $self;
}

# PUBLIC parse() accepts a filehandle

sub parse {
  my $self		= shift;

  my $SXC_FH		= shift;	# Data source

  # We need to use closures to provide a true object-oriented way of doing things.  This can
  # be considered a memory leak, but only a few bytes per parse call:
  my $Parser		= XML::Parser->new
    ( Handlers	=> { Start	=> sub { $self->start_handler( @_ ); },
		     Char	=> sub { $self->char_handler( @_ ); },
		     End	=> sub { $self->end_handler( @_ ); },
		   },
    );
  my $results		= $Parser->parse( $SXC_FH );
  return $results;
}

# PUBLIC calls parse() after opening a filehandle

sub parse_file {
  my $self		= shift;
  my $filename		= shift || die "No file to parse";

  if( ! -f $filename ) {
    die "Could not find file '$filename' to parse";
  }
  my $SXC_FH		= IO::File->new( "unzip -p $filename content.xml|" )
    || die "Could not open pipe: 'unzip -p $filename content.xml'";
  $self->get_data_handler->workbook( $self, $filename );
  return $self->parse( $SXC_FH );
}

# The XML::Parser handler for ending of tags.
# It's used to trigger the end of cell and end of row actions.

sub end_handler {
  my $self		= shift;

  my $Expat		= shift;
  my $type		= shift;

  if( $type eq "table:table-row" ) {
    if( $self->accept_rows ) {
      $self->accept_cells( 0 );
      $self->end_row;			# The row is done
    }
  }
  elsif( $type eq "table:table-cell" ) {
    if( $self->accept_cells ) {
      if( $self->accept_text ) {
	$self->end_cell;		# The cell is done
      }
      $self->accept_text( 0 );
    }
  }
  elsif( $type eq "text:p" ) {
    # Kludging along to infinity...  The data in each cell
    # comes in  tags.  Each is assumed to NOT end in
    # a newline, however, if a newline is added () it ends
    # the previous  block and starts a new one.
    #
    # I'll add a newline after the end of each  tag, and then
    # remove the last newline on the list when the cell is 'closed'.
    if( $self->accept_text ) {
      $self->append_cell_data( "\n" );
    }
  }
}

# E() implements an "Object O Exists in list L" boolean function

sub E {
  my $item	= shift;
  my @set	= @_;
  for( @set ) {
    return 1	if( $item eq $_ );
  }
  return 0;
}

# The start_handler for XML::Parser.
# It's responsible for things such as the following:
#
# - Locking and allowing the parsing of worksheets, rows, and cells.
# -

sub start_handler {
  my $self		= shift;
  my $Expat	= shift;

  my $type	= shift;
  my %args	= @_;
  if( $type eq "table:table" ) {
    # Restrict processing of a 'worksheet' if the user has specified worksheets that he wants:
    if( ! $self->get_option( "worksheets" ) or E( $args{"table:name"}, @{$self->get_option( "worksheets" )} ) ) {
      # Ok, we process this worksheet:
      $self->accept_rows( 1 );	# Accept rows
      $self->set_current_worksheet_name( $args{"table:name"} );
      $self->get_data_handler->worksheet( $self, $args{"table:name"} );
    }
    else {
      $self->accept_rows( 0 );	# Do not accept row data
    }
  }
  elsif( $type eq "table:table-row" ) {		# ROW

    if( $self->accept_rows ) {
      if( $args{"table:number-rows-repeated"} ) {
	# Cause next row to be repeated...
	$self->repeat_following_row( $args{"table:number-rows-repeated"} );
      }
      $self->accept_cells( 1 );
    }
  }
  elsif( $type eq "table:table-cell" ) {	# CELL

    if( $self->accept_cells ) {
      # Cell repeat
      if( $args{"table:number-columns-repeated"} ) {
	$self->repeat_following_cell( $args{"table:number-columns-repeated"} );
      }
      $self->accept_text( 1 );
    }
  }
  elsif( $type eq "text:s" ) {			# TEXT
    # NOTE: Text type 'text:s' = space, I assume!  OpenOffice uses this tag to
    # represent spaces that are longer than 2 characters.  There may be other
    # special 'text' elements, but I'm unaware of them currently.  This is the
    # routine to modify to handle them though!
    if( $self->accept_text ) {
      my $multiplier	= $args{"text:c"} || 1;				# Number of characters
      $self->append_cell_data( " " x $multiplier );
    }
  }
  elsif( $type eq "text:p" ) {
    # Yikes, I initially wrote this without text:p in the start handler, instead
    # relying on char_handler.  I SHOULD change the restrictions layer to handle
    # accept_text_p... maybe when I have the energy
  }
}

# The XML::Parser character handler.  It builds up cells piece by piece

sub char_handler {
  my $self		= shift;

  if( $self->accept_text ) {
    my $Expat		= shift;
    my $text		= shift;
    $self->append_cell_data( $text );	# Build up cell data from multiple bits of text
  }
}

##################################################################
# These routines restrict what gets processed.  They each
# take a boolean value, turning the switch on or off.  There
# are 3 levels of restriction: rows, cells, and text.

sub accept_cells {
  my $self		= shift;
  my $value		= shift;
  if( ! defined $value ) {
    return $self->{accept_cells};
  }
  else {
    $self->{accept_cells}	= $value;
  }
}
sub accept_rows {
  my $self		= shift;
  my $value		= shift;
  if( ! defined $value ) {
    return $self->{accept_rows};
  }
  else {
    $self->{accept_rows}	= $value;
  }
}
sub accept_text {
  my $self		= shift;
  my $value		= shift;
  if( ! defined $value ) {
    return $self->{accept_text};
  }
  else {
    $self->{accept_text}	= $value;
  }
}

##################################################################

sub set_current_worksheet_name {
  my $self		= shift;
  $self->{current_worksheet_name}	= shift;
}

# PUBLIC, returns the name of the current worksheet.

sub get_current_worksheet_name {
  my $self		= shift;
  return $self->{current_worksheet_name};
}


# Reset the list of cells to the empty list

sub reset_cell_list {
  my $self		= shift;
  $self->{cells}	= [];
}

# PUBLIC Set some options via a hash

sub set_options {
  my $self			= shift;
  my %options			= @_;

  # Check to ensure the options are valid
  for( keys %options ) {
    if( ! $valid_options{$_} ) {
      die "Invalid option: '$_' ($options{$_}) passed as an option to ".ref $self."->set_options()";
    }
  }

  $self->{options}		= { %{$self->{options}}, %options };
}

# PUBLIC Get an option

sub get_option {
  my $self			= shift;
  my $opt_name			= shift;
  return $self->{options}{$opt_name};
}

sub append_cell_data {
  my $self			= shift;
  $self->{current_cell_data}	.= shift;
}

sub clear_cell {
  my $self			= shift;
  $self->{current_cell_data}	= "";
}

# Specify that a cell is to be repeated N times.  N is usually 1.

sub repeat_following_cell {
  my $self		= shift;
  $self->{cell_repeat}	= shift;
}

# See repeat_following_cell()

sub repeat_following_row {
  my $self		= shift;
  $self->{row_repeat}	= shift;
}

# The data_handler is how we use this module.

sub set_data_handler {
  my $self		= shift;
  my $data_handler	= shift || die "No row handler provided";

  $self->{data_handler}	= $data_handler;
}

sub get_data_handler {
  my $self		= shift;
  return $self->{data_handler};
}

# The end of the row has been reached, we call the data_handler:

sub end_row {
  my $self		= shift;
  my $cells		= $self->{cells};

  # OpenOffice actually specifies ALL the cells in the spreadsheet, some 32000 of
  # them, but using a repeat.  This bit of code detects the repeat, and can either
  # ignore it, since there likely won't be any data after a long repeat value, or
  # print them all out, if the "no_trim" option has been supplied.
  if( $self->{row_repeat} < 500 or $self->get_option( "no_trim" ) ) {
    for( 1 .. $self->{row_repeat} ) {
      $self->get_data_handler->row( $self, $cells );	# Assume the row handler is an object
    }
  }
  $self->repeat_following_row( 1 );	# Default 1
  $self->reset_cell_list;		# Clear out cells
}

# Ends the current cell.  It will be added to the cell list.

sub end_cell {
  my $self		= shift;
  chomp $self->{current_cell_data};	# remove the last newline
  for( 1 .. $self->{cell_repeat} ) {
    push @{$self->{cells}}, $self->{current_cell_data};
  }
  $self->repeat_following_cell( 1 );	# Default to 1
  $self->clear_cell;
}


1;
__END__