File Coverage

blib/lib/WebService/Simple.pm

Criterion	Covered	Total	%
statement	153	181	84.5
branch	44	76	57.8
condition	18	43	41.8
subroutine	25	29	86.2
pod	8	9	88.8
total	248	338	73.3

package WebService::Simple;
use strict;
use warnings;
use base qw(LWP::UserAgent Class::Data::ConfigHash);
use Class::Inspector;
use Data::Dumper ();
use Digest::MD5  ();
use URI::Escape;
use URI::QueryParam;
use HTTP::Message;
use Hash::MultiValue;
use WebService::Simple::Response;
use UNIVERSAL::require;

our $VERSION = '0.25';

__PACKAGE__->config(
    base_url        => '',
    response_parser => { module => "XML::Simple" },
);

sub new {
    my $class    = shift;
    my %args     = @_;
    my $base_url = delete $args{base_url}
      || $class->config->{base_url}
      || Carp::croak("base_url is required");
    $base_url = URI->new($base_url);
    my $basic_params = delete $args{params} || delete $args{param} || {};
    my $debug = delete $args{debug} || 0;

    my $response_parser = delete $args{response_parser}
      || $class->config->{response_parser};
    if (   !$response_parser
        || !eval { $response_parser->isa('WebService::Simple::Parser') } )
    {
        my $config = $response_parser || $class->config->{response_parser};
        if ( !ref $config ) {
            $config = { module => $config };
        }
        my $module = $config->{module};
        if ( $module !~ s/^\+// ) {
            $module = __PACKAGE__ . "::Parser::$module";
        }
        if ( !Class::Inspector->loaded($module) ) {
            $module->require or die;
        }
        $response_parser = $module->new( %{ $config->{args} || {} } );
    }

    my $cache = delete $args{cache};
    if ( !$cache || ref $cache eq 'HASH' ) {
        my $config = ref $cache eq 'HASH' ? $cache : $class->config->{cache};
        if ($config) {
            if ( !ref $config ) {
                $config = { module => $config };
            }

            my $module = $config->{module};
            if ( !Class::Inspector->loaded($module) ) {
                $module->require or die;
            }
            $cache =
              $module->new( $config->{hashref_args}
                ? $config->{args}
                : %{ $config->{args} } );
        }
    }

    my $self = $class->SUPER::new(%args);
    $self->{base_url}        = $base_url;
    $self->{basic_params}    = $basic_params;
    $self->{response_parser} = $response_parser;
    $self->{cache}           = $cache;
    $self->{compression}     = delete $args{compression};
    $self->{content_type}    = delete $args{content_type};
    $self->{croak}           = delete $args{croak};
    $self->{debug}           = $debug;

    if($self->{content_type} && $self->{content_type} eq 'application/json'){
	$self->__init_request_parser_json();
    }else{
        $self->{request_parser} = sub { return \$_[0] };
    }

    return $self;
}

sub _agent       { "libwww-perl/$LWP::VERSION+". __PACKAGE__ .'/'.$VERSION }

sub base_url        { $_[0]->{base_url} }
sub basic_params    { $_[0]->{basic_params} }
sub response_parser { $_[0]->{response_parser} }
sub request_parser  { $_[0]->{request_parser} }
sub cache           { $_[0]->{cache} }

sub __cache_get {
    my $self  = shift;
    my $cache = $self->cache;
    return unless $cache;

    my $key = $self->__cache_key(shift);
    return $cache->get( $key, @_ );
}

sub __cache_set {
    my $self  = shift;
    my $cache = $self->cache;
    return unless $cache;

    my $key = $self->__cache_key(shift);
    return $cache->set( $key, @_ );
}

sub __cache_remove {
    my $self  = shift;
    my $cache = $self->cache;
    return unless $cache;

    my $key = $self->__cache_key(shift);
    return $cache->remove( $key, @_ );
}

sub __cache_key {
    my $self = shift;
    local $Data::Dumper::Indent   = 1;
    local $Data::Dumper::Terse    = 1;
    local $Data::Dumper::Sortkeys = 1;
    return Digest::MD5::md5_hex( Data::Dumper::Dumper( $_[0] ) );
}

sub __init_request_parser_json {
    my $self = shift;
    require WebService::Simple::Parser::JSON;
    my $json_parser = WebService::Simple::Parser::JSON->new();
    $self->{request_parser_json} = sub { $json_parser->parse_request(@_); }
}

sub request_url {
    my $self = shift;
    my %args = @_;

    my $uri = ref($args{url}) =~ m/^URI/ ? $args{url}->clone() : URI->new($args{url});
    if ( my $extra_path = $args{extra_path} ) {
        $extra_path =~ s!^/!!;
        $uri->path( $uri->path . $extra_path );
    }
    if($args{params}) {
        if(ref $args{params} eq 'Hash::MultiValue') {
            for my $key ($args{params}->keys) {
                $uri->query_param_append($key, $args{params}->get($key));
            }
        }else{
            $uri->query_form(%{$args{params}});
        }
    }
    return $uri;
}

sub get {
    my $self = shift;
    my ($url, $extra) = ("", {});

    if ( ref $_[0] eq 'HASH' ) {
        $extra = shift @_;
    }
    else {
        $url = shift @_;
        if ( ref $_[0] eq 'HASH' ) {
            $extra = shift @_;
        }
    }

    my $uri = $self->request_url(
        url => $self->base_url,
        extra_path => $url,
        params => Hash::MultiValue->new(%{$self->basic_params}, %$extra),
    );

    warn "Request URL is $uri\n" if $self->{debug};

    my @headers = @_;
    unless(defined($self->{compression}) && !$self->{compression}){
        my $can_accept = HTTP::Message::decodable();
        push @headers, ('Accept-Encoding' => $can_accept) ;
    }

    my $response;
    $response = $self->__cache_get( [ $uri, @headers ] );
    if ($response) {
        if ($response->isa('WebService::Simple::Response')) { # backward compatibility
            return $response;
        } else {
            return WebService::Simple::Response->new_from_response(
                response => $response,
                parser => $self->response_parser
            );
        }
    }

    $response = $self->SUPER::get( $uri, @headers );

    if ( $response->is_success ) {
        $self->__cache_set( [ $uri, @headers ], $response );
        $response = WebService::Simple::Response->new_from_response(
            response => $response,
            parser   => $self->response_parser
        );
    }else{
        Carp::croak("request to $uri failed") unless defined($self->{croak}) && !$self->{croak};
    }

    return $response;
}

sub post {
    my $self = shift;
    my ( $url, $extra ) = ( '', {} );

    if ( ref $_[0] eq 'HASH' ) { # post(\%arg [, @header ])
        $extra = shift @_;
    }
    elsif ( ref $_[1] eq 'HASH' ) { # post($url, \%arg [, @header ])
        $url = shift @_;
        $extra = shift @_;
    }
    elsif ( @_ % 2 ) { # post($url [, @header ])
        $url = shift @_;
    }

    my @headers = @_;
    unless(defined($self->{compression}) && !$self->{compression}){
        my $can_accept = HTTP::Message::decodable();
        push @headers, ('Accept-Encoding' => $can_accept) ;
    }
    my %headers = @headers;

    # Content-Type tells us where "extra params" go: form-urlencoded -> $uri / json/xml -> $content
    my ($uri,$response);

    if( ($self->{content_type} && $self->{content_type} eq 'application/json') || ($headers{'Content-Type'} && $headers{'Content-Type'} eq 'application/json') ){
	$self->__init_request_parser_json() unless $self->{request_parser_json};

        $uri = $self->request_url(
	    url => $self->base_url,
            extra_path => $url,
            # params => Hash::MultiValue->new(%{$self->basic_params}, %$extra), # this'll go to content
        );
        # $uri->query_form(undef); # we'll leave all params on the url

        my $req = HTTP::Request->new(POST => $uri, \@headers);
        $req->content_type('application/json');
        $req->content($self->{request_parser_json}->({ %{$self->basic_params}, %$extra }));
        $response = $self->SUPER::request($req);
    }else{
        $uri = $self->request_url(
	    url => $self->base_url,
            extra_path => $url,
            params => Hash::MultiValue->new(%{$self->basic_params}, %$extra),
        );
        my $content = $uri->query_form_hash();
        $uri->query_form(undef);

	push(@headers, 'Content-Type' => $self->{content_type}) if $self->{content_type};

        $response = $self->SUPER::post( $uri, $content, @headers );
    }

    if ( $response->is_success ) {
        $response = WebService::Simple::Response->new_from_response(
            response => $response,
            parser   => $self->response_parser
        );
    }else{
        Carp::croak("request to $uri failed") unless defined($self->{croak}) && !$self->{croak};
    }

    return $response;
}

1;

__END__