File Coverage

blib/lib/Telegram/Bot/Object/Base.pm

Criterion	Covered	Total	%
statement	37	71	52.1
branch	13	36	36.1
condition	1	2	50.0
subroutine	6	7	85.7
pod	4	4	100.0
total	61	120	50.8

package Telegram::Bot::Object::Base;
$Telegram::Bot::Object::Base::VERSION = '0.023';
# ABSTRACT: The base class for all Telegram::Bot::Object objects.


use Mojo::Base -base;

has '_brain'; # a reference to our brain


sub arrays { qw// }  # override if needed
sub _field_is_array {
  my $self = shift;
  my $field = shift;
  if (grep /^$field$/, $self->arrays) {
    return 1;
  }
  return;
}


sub array_of_arrays { qw// } #override if needed
sub _field_is_array_of_arrays {
  my $self = shift;
  my $field = shift;
  if (grep /^$field$/, $self->array_of_arrays) {
    return 1;
  }
  return;
}


# create an object from a hash. Needs to deal with the nested types, and
# arrays
sub create_from_hash {
  my $class = shift;
  my $hash  = shift;
  my $brain = shift || die "no brain supplied";
  my $obj   = $class->new(_brain => $brain);

  # deal with each type of field
  foreach my $type (keys %{ $class->fields }) {
    my @fields_of_this_type = @{ $class->fields->{$type} };

    foreach my $field (@fields_of_this_type) {

      # ignore fields for which we have no value in the hash
      next if (! defined $hash->{$field} );

      if ($type eq 'scalar') {
        if ($obj->_field_is_array($field)) {
          # simple scalar array ref, so just copy it
          my $val = $hash->{$field};
          # deal with boolean stuff so we don't pollute our object
          # with JSON
          if (ref($val) eq 'JSON::PP::Boolean') {
            $val = !!$val;
          }
          $obj->$field($val);
        }
        elsif ($obj->_field_is_array_of_arrays) {
          die "not yet implemented for scalars";
        }
        else {
          my $val = $hash->{$field};
          if (ref($val) eq 'JSON::PP::Boolean') {
            $val = 0+$val;

          }
          $obj->$field($val);
        }
      }

      else {
        if ($obj->_field_is_array($field)) {
          my @sub_array;
          foreach my $data ( @{ $hash->{$field} } ) {
            push @sub_array, $type->create_from_hash($data, $brain);
          }
          $obj->$field(\@sub_array);
        }
        elsif ($obj->_field_is_array_of_arrays($field)) {
          die "not yet implemented for objects";
        }
        else {
          $obj->$field($type->create_from_hash($hash->{$field}, $brain));
        }

      }
    }
  }

  return $obj;
}


sub as_hashref {
  my $self = shift;
  my $hash = {};

  foreach my $type ( keys %{ $self->fields }) {
    my @fields = @{ $self->fields->{$type} };
    foreach my $field (@fields) {

      # add the simple scalar values
      if ($type eq 'scalar') {

        # TODO support scalar arrays?
        $hash->{$field} = $self->$field
          if defined $self->$field;
      }
      else {
        if ($self->_field_is_array($field)) {

          # skip if it's not defined, though I'm not sure if there are cases
          # where we should be sending an empty array instead?
          next if (! defined $self->$field);

          $hash->{$field} = [
            map { $_->as_hashref } @{ $self->$field }
          ];
        }
        elsif ($self->_field_is_array_of_arrays($field)) {

          next if (! defined $self->$field);

          # lets not nest maps
          my $a_of_a = [];
          foreach my $outer ( @{ $self->$field } ) {
            my $inner = [ map { $_->as_hashref } @$outer ];
            push @$a_of_a, $inner;
          }
          $hash->{$field} = $a_of_a;
        }
        else {

          # non array, non scalar
          if (defined $self->$field) {
            my $hashref = $self->$field->as_hashref;
            $hash->{$field} = $hashref
              unless ! $hashref;
          }
        }
      }
    }
  }
  return $hash;
}

1;

__END__