File Coverage

blib/lib/HTTP/Thin/UserAgent.pm

Criterion	Covered	Total	%
statement	62	125	49.6
branch	0	12	0.0
condition	1	2	50.0
subroutine	21	37	56.7
pod	2	9	22.2
total	86	185	46.4

package HTTP::Thin::UserAgent;
$HTTP::Thin::UserAgent::VERSION = '0.016';
use 5.12.1;
use warnings;

# ABSTRACT: A Thin UserAgent around some useful modules.


{
    package
        HTTP::Thin::UserAgent::HTTPExceptionWithResponse;
    use Moo::Role;
    has response => ( is => 'ro' );
}

{
    package
        HTTP::Thin::UserAgent::Error::UnexpectedResponse;

    use Moo;
    extends qw(Throwable::Error);
    with qw(HTTP::Thin::UserAgent::HTTPExceptionWithResponse);

}

{
    package
        HTTP::Thin::UserAgent::HTTP::Throwable::Factory;
        use Moo;

        extends qw(HTTP::Throwable::Factory);

        sub extra_roles {
            return qw(
                HTTP::Throwable::Role::TextBody
                HTTP::Thin::UserAgent::HTTPExceptionWithResponse
            );
        }
}

{

    package
        HTTP::Thin::UserAgent::Client;

    use Moo;
    use MooX::late;
    use MooX::ChainedAttributes;
    use HTTP::Thin;
    use JSON::Any;
    use Try::Tiny;
    use Scalar::Util qw/weaken/;
    use Carp qw(confess);

    use constant TRACE => $ENV{TRACE} // 0;
    use constant UnexpectedResponse => 'HTTP::Thin::UserAgent::Error::UnexpectedResponse';
    use constant HTTPException => 'HTTP::Thin::UserAgent::HTTP::Throwable::Factory';

    has ua => (
        is      => 'ro',
        default => sub { HTTP::Thin->new() },
    );

    has request => (
        is => 'ro',
        required => 1,
    );

    has on_error => (
        is      => 'rw',
        default => sub { sub { confess "$_" } },
        chained => 1,
    );

    has decoder => (
        is => 'rw',
        chained => 1,
        default => sub {
            sub { shift->decoded_content }
        },
    );

    sub decoded_content {
        my $self = shift;
        return $self->decoder->( $self->response );
    }

    sub decode { warn 'decode is deprecated, please call decoded_content instead'; shift->decoded_content }

    has response => (
        is      => 'ro',
        lazy    => 1,
        builder => '_build_response',
        handles => { 'content' => 'decoded_content' },
    );

    sub _build_response {
        my $self    = shift;
        my $ua      = $self->ua;
        my $request = $self->request;

        warn $request->dump if TRACE;
        my $res = $ua->request($request);
        warn $res->dump if TRACE;

        if ( $res->is_error ) {
            my $e;
            try {
                $e = HTTPException->new_exception(
                    $res->code => {
                        additional_headers => [ $res->headers->flatten() ],
                        response           => $res,
                    }
                );
            }
            catch {
                $e = HTTPException->new_exception(
                    {
                        status_code        => $res->code,
                        reason             => $res->message,
                        additional_headers => [ $res->headers->flatten(), ],
                        response           => $res,
                    }
                );
            };
            for ($e) { $self->on_error->($e) }
        }

        return $res;
    }

    sub as_json {
        my $self = shift;

        my $request = $self->request;

        $request->header(
            'Accept'       => 'application/json',
            'Content-Type' => 'application/json',
        );

        if ( my $data = shift ) {
            $request->content( JSON::Any->encode($data) );
        }

        weaken($self);
        $self->decoder(
            sub {
                my $res          = shift;
                my $content_type = $res->header('Content-Type');
                my $data         = try {
                    die "Content-Type was $content_type not application/json"
                        unless $content_type =~ m'application/json';
                    JSON::Any->decode( $res->decoded_content );
                }
                catch {
                    my $error = UnexpectedResponse->new(
                        message  => $_,
                        response => $res,
                    );
                    for ($error) {
                        $self->on_error->($error);
                    }
                };
            }
        );
        return $self;
    }

    sub dump { require Data::Dumper; return Data::Dumper::Dumper(shift) }

    sub scraper {
        my ( $self, $scraper ) = @_;

        weaken($self);
        $self->decoder(
            sub {
                my $res = shift;
                my $data = try { $scraper->scrape( $res->decoded_content ) }
                catch {
                    my $error = UnexpectedResponse->new(
                        message  => $_,
                        response => $res
                    );
                    for ($error) { $self->on_error->($error); }
                };
                return $data;
            }
        );
        return $self;
    }

    sub tree {
        my ($self) = @_;
        my $t = HTML::TreeBuilder::XPath->new;
        $t->store_comments(1) if ( $t->can('store_comments') );
        $t->ignore_unknown(0);
        $t->parse( $self->content );
        return $t;
    }

    sub find {
        my ( $self, $exp ) = @_;

        my $xpath =
            $exp =~ m!^(?:/|id\()!
          ? $exp
          : HTML::Selector::XPath::selector_to_xpath($exp);

        my @nodes = try { $self->tree->findnodes($xpath) }
        catch {
            for ($_) { $self->on_error($_) }
        };
        return unless @nodes;
        return \@nodes;
    }

}

use parent qw(Exporter);
use Import::Into;
use HTTP::Request::Common;
use Web::Scraper;

our @EXPORT = qw(http);

sub import {
    shift->export_to_level(1);
    HTTP::Request::Common->import::into( scalar caller );
    Web::Scraper->import::into( scalar caller );
}

sub http { HTTP::Thin::UserAgent::Client->new( request => shift ) }

1;

__END__