File Coverage

lib/Spreadsheet/Engine/Fn/base.pm

Criterion	Covered	Total	%
statement	101	103	98.0
branch	38	46	82.6
condition	20	24	83.3
subroutine	18	19	94.7
pod	7	7	100.0
total	184	199	92.4

package Spreadsheet::Engine::Fn::base;

use strict;
use warnings;

use Carp;
use Class::Struct;
use Encode;

use Spreadsheet::Engine::Value;
use Spreadsheet::Engine::Error;
use Spreadsheet::Engine::Fn::Operand;
use Spreadsheet::Engine::Sheet qw/ copy_function_args lookup_result_type
  operand_value_and_type operand_as_number operand_as_text
  top_of_stack_value_and_type /;

struct(__PACKAGE__,
  {
    fname      => '$',
    operand    => '$',
    errortext  => '$',
    typelookup => '$',
    sheetdata  => '$',
    _opstore   => '@',
  }
);

sub execute {
  my $self = shift;

  my $result = eval {

    # make sure we check args even for functions that don't need any
    # TODO rearrange this logic
    my @foperand = $self->foperand;
    $self->result;
  };

  if ($@) {
    die $@ unless ref $@;
    $result = $@;
    $result = $@;
  }

  push @{ $self->operand }, { type => $result->type, value => $result->value }
    if $result;
  return;
}

sub foperand {
  my $self = shift;
  return $self->{_foperand} if defined $self->{_foperand};

  copy_function_args($self->operand, \my @foperand);

  if ($self->can('argument_count') or $self->can('signature')) {
    my ($min_args, $max_args) =
      $self->can('argument_count')
      ? ($self->argument_count)
      : (0 + @{ [ $self->signature ] });
    my $have_args = scalar @foperand;

    if ( ($min_args < 0 and $have_args < -$min_args)
      or ($min_args >= 0 and $have_args != $min_args)
      or (defined $max_args and $have_args > $max_args)) {
      die Spreadsheet::Engine::Error->val(
        sprintf('Incorrect arguments to function "%s". ', $self->fname),
      );
    }
  }

  return ($self->{_foperand} = \@foperand);
}

sub _opvals { map $_->value, shift->_ops }

sub _ops {
  my $self = shift;
  if (@{ $self->_opstore } == 0) {
    my $numargs = scalar @{ $self->foperand };
    my @argdef  = $self->signature;

    my @operands = ();

    # Loop over args, not defs, so that optional args don't fail
    for my $sig (@argdef[ 0 .. $numargs - 1 ]) {
      my $op;

      if ($sig eq 'n') {    # any number - was 0
        $op = $self->next_operand_as_number;
      } elsif ($sig eq 't') {    # any string - was 1
        $op = $self->next_operand_as_text;
      } elsif ($sig eq '*') {    # anything at all
        $op = $self->next_operand;
      } elsif ($sig eq 'r') {    # range
                                 # TODO refactor this into Range object
                                 # For now we'll just hijack an op
        $op = Spreadsheet::Engine::Fn::Operand->new(
          type  => 'r',
          value => pop @{ $self->foperand },
        );
        die Spreadsheet::Engine::Error->val('Incorrect arguments')
          unless $op->value->{type} eq 'range';
      } else {
        croak 'Missing signature value in ' . $self->fname unless $sig;
        $op = $self->next_operand_as_number;
        my @tests = (ref $sig eq 'ARRAY') ? @{$sig} : $sig;
        foreach my $check (@tests) {
          if (ref $check eq 'CODE') {
            die Spreadsheet::Engine::Error->val('Invalid arguments')
              unless $check->($op->value);
          } elsif ($check =~ /^([!<>]=?)(-?\d+)/) {    # >=0 <1 etc.
            my ($test, $num) = ($1, $2);
            my $val = $op->value;
            die Spreadsheet::Engine::Error->val('Invalid arguments')
              unless eval "$val $test $num";
          } else {
            croak "Error in signature ($check) of " . $self->fname;
          }
        }
      }

      die $op if $op->is_error and not $self->_error_ops_ok;
      push @operands, $op;
    }
    $self->_opstore(\@operands);
  }
  return @{ $self->_opstore };
}

# Usually, when extracting the operands based on the signature, any
# operand that is of type 'error' will cause the entire function to die
# with that error. Subclassing this method to return a true value will
# allow that error to be passed through as-is.

sub _error_ops_ok { 0 }

sub next_operand {
  my $self  = shift;
  my $value =
    operand_value_and_type($self->sheetdata, $self->foperand,
    $self->errortext, \my $tostype);
  return Spreadsheet::Engine::Fn::Operand->new(
    value => $value,
    type  => $tostype
  );
}

sub next_operand_as_number {
  my $self  = shift;
  my $value =
    operand_as_number($self->sheetdata, $self->foperand, $self->errortext,
    \my $tostype);
  return Spreadsheet::Engine::Fn::Operand->new(
    value => $value,
    type  => $tostype
  );
}

sub next_operand_as_text {
  my $self  = shift;
  my $value =
    operand_as_text($self->sheetdata, $self->foperand, $self->errortext,
    \my $tostype);
  return Spreadsheet::Engine::Fn::Operand->new(
    value => decode(utf8 => $value),
    type  => $tostype
  );
}

sub top_of_stack {
  my $self = shift;
  my ($value, $type) =
    top_of_stack_value_and_type($self->sheetdata, $self->foperand,
    $self->errortext);
  return unless $type;
  return Spreadsheet::Engine::Fn::Operand->new(
    value => $value,
    type  => $type
  );
}

sub optype {
  my ($self, $operation, @op) = @_;

  my $tl = $self->typelookup->{$operation};

  my $first = shift @op;
  my $type  = $first->type;

  # Check against self if no others supplied
  push @op, $first if $operation eq 'oneargnumeric' and not @op;

  while (my $next = shift @op) {
    $type = lookup_result_type($type, (ref $next ? $next->type : $next), $tl);
  }
  return Spreadsheet::Engine::Value->new(type => $type, value => 0);
}

1;

__END__