File Coverage

lib/HTTP/Tiny/Mech.pm

Criterion	Covered	Total	%
statement	42	42	100.0
branch	14	14	100.0
condition			n/a
subroutine	10	10	100.0
pod	4	4	100.0
total	70	70	100.0

use 5.006;    # pragmas, our
use strict;
use warnings;

package HTTP::Tiny::Mech;

our $VERSION = '1.001001';

# ABSTRACT: Wrap a WWW::Mechanize instance in an HTTP::Tiny compatible interface.

our $AUTHORITY = 'cpan:KENTNL'; # AUTHORITY

use parent 'HTTP::Tiny';

sub new {
  my ( $self, %args ) = @_;
  my ( $mechua, $has_mechua );
  if ( exists $args{mechua} ) {
    $has_mechua = 1;
    $mechua     = delete $args{mechua};
  }
  my $instance = $self->SUPER::new(%args);
  if ($has_mechua) {
    $instance->{mechua} = $mechua;
  }
  return bless $instance, $self;
}

## no critic (Subroutines::RequireArgUnpacking)
sub mechua {
  my ( $self, $new_mechua, $has_new_mechua ) = ( $_[0], $_[1], @_ > 1 );
  if ($has_new_mechua) {
    $self->{mechua} = $new_mechua;
  }
  return $self->{mechua} if exists $self->{mechua};
  require WWW::Mechanize;
  return ( $self->{mechua} = WWW::Mechanize->new() );
}
## use critic










sub _unwrap_response {
  my ( undef, $response ) = @_;
  return {
    status  => $response->code,
    reason  => $response->message,
    headers => $response->headers,
    success => $response->is_success,
    content => $response->content,
  };
}

sub _wrap_request {
  my ( undef, $method, $uri, $opts ) = @_;
  require HTTP::Request;
  my $req = HTTP::Request->new( $method, $uri );
  $req->headers( $opts->{headers} ) if $opts->{headers};
  $req->content( $opts->{content} ) if $opts->{content};
  return $req;
}









sub get {
  my ( $self, $uri, $opts ) = @_;
  return $self->_unwrap_response( $self->mechua->get( $uri, ( $opts ? %{$opts} : () ) ) );
}







sub request {
  my ( $self, @request ) = @_;
  my $req      = $self->_wrap_request(@request);
  my $response = $self->mechua->request($req);
  return $self->_unwrap_response($response);
}




































1;

__END__