File Coverage

blib/lib/Net/Easypost/Address.pm

Criterion	Covered	Total	%
statement	52	52	100.0
branch	2	2	100.0
condition			n/a
subroutine	17	17	100.0
pod	4	5	80.0
total	75	76	98.6

package Net::Easypost::Address;
$Net::Easypost::Address::VERSION = '0.20';
use Carp qw/croak/;
use JSON::MaybeXS;
use Scalar::Util;
use overload
    '""'     => sub { $_[0]->as_string },
    '0+'     => sub { Scalar::Util::refaddr($_[0]) },
    fallback => 1;
use Types::Standard qw(Bool Enum HashRef InstanceOf Str Undef);


use Moo;
with qw/Net::Easypost::PostOnBuild/;
with qw/Net::Easypost::Resource/;
use namespace::autoclean;

has [qw/street1
     street2
     city
     state
     zip
     country
     carrier_facility
     name
     company
     phone
     email
     federal_tax_id
     state_tax_id/
] => (
    is  => 'rw',
    isa => Str|Undef
);

has 'residential' => (
    is     => 'rw',
    isa    => Bool|InstanceOf['JSON::PP::Boolean'],
    coerce => sub { $_[0] ? JSON->true : JSON->false }
);

has 'verifications' => (
    is  => 'rw',
    isa => HashRef
);

has 'verify_adress' => (
    is  => 'rw',
    isa => Enum[qw/zip4 delivery/]
);

sub _build_fieldnames {
    return [
	qw/
	street1
	street2
	city
	state
	zip
	country
	residential
	carrier_facility
	name
	company
	phone
	email
	federal_tax_id
	state_tax_id
	/
    ];
}

sub _build_role { 'address' }
sub _build_operation { '/addresses' }

sub clone {
    my ($self) = @_;

    return Net::Easypost::Address->new(
       map  { $_ => $self->$_ }
       grep { defined $self->$_ } @{ $self->fieldnames }
    );
}

sub serialize {
   my ($self) = @_;

   # want a hashref of e.g., address[name] => foo from all defined attributes
   # verify[]=zip4|delivery - verify an address
   return {
       # (defined $self->verify_address ? "verify[]" => $self->verify : ()),
       (map  { $self->role . "[$_]" => $self->$_ }
       grep { defined $self->$_ } @{ $self->fieldnames })
   };
}

sub as_string {
    my ($self) = @_;

    return join "\n",
        (map  { $self->$_ }
            grep { defined $self->$_ } qw(name phone street1 street2)),
        join " ",
            (map  { $self->$_ }
                grep { defined $self->$_ } qw(city state zip));
}

sub merge {
    my ($self, $old, $fields) = @_;

    map { $self->$_($old->$_) }
        grep { defined $old->$_ }
            @$fields;

    return $self;
}

sub verify {
    my ($self) = @_;

    my $verify_response =
       $self->requester->get(
          join '/', $self->operation, $self->id, 'verify'
       );

    croak 'Unable to verify address, failed with message: '
        . $verify_response->{error}
    if $verify_response->{error};

    my $new_address = Net::Easypost::Address->new(
        $verify_response->{address}
    );

    return $new_address->merge($self, [qw(phone name)]);
}

1;

__END__