merge

1 files changed, 173 insertions, 419 deletions

diff --git a/lib/MooseX/Net/API.pm b/lib/MooseX/Net/API.pm
index 872d83d..2dcfc13 100644
--- a/lib/MooseX/Net/API.pm
+++ b/lib/MooseX/Net/API.pm
@@ -1,424 +1,169 @@
 package MooseX::Net::API;
 
-use URI;
-use Try::Tiny;
-use HTTP::Request;
-
 use Moose;
 use Moose::Exporter;
 
-use MooseX::Net::API::Error;
-
-use MooseX::Net::API::Meta::Class;
-use MooseX::Net::API::Meta::Method;
-
-use MooseX::Net::API::Role::Serialize;
-use MooseX::Net::API::Role::Deserialize;
-
-our $VERSION = '0.10';
+our $VERSION = '0.11';
 
-my $list_content_type = {
-    'json' => 'application/json',
-    'yaml' => 'text/x-yaml',
-    'xml'  => 'text/xml',
-};
+Moose::Exporter->setup_import_methods(
+    with_meta => [qw/net_api_method net_api_declare/],
+    also      => [qw/Moose/]
+);
 
-my ( $do_auth, $base_url, $auth_method, $deserialize_method );
+sub net_api_method {
+    my $meta = shift;
+    my $name = shift;
+    $meta->add_net_api_method($name, @_);
+}
 
-Moose::Exporter->setup_import_methods(
-    with_caller => [qw/net_api_method net_api_declare/], );
+sub net_api_declare {
+    my $meta = shift;
+    my $name = shift;
+    $meta->add_net_api_declare($name, @_);
+}
 
 sub init_meta {
-    my ( $me, %options ) = @_;
+    my ($class, %options) = @_;
 
     my $for = $options{for_class};
-    Moose::Util::MetaRole::apply_metaroles(
+    Moose->init_meta(%options);
+
+    my $meta = Moose::Util::MetaRole::apply_metaroles(
         for_class       => $for,
         metaclass_roles => ['MooseX::Net::API::Meta::Class'],
     );
+
+    Moose::Util::MetaRole::apply_base_class_roles(
+        for   => $for,
+        roles => [
+            qw/
+              MooseX::Net::API::Role::UserAgent
+              MooseX::Net::API::Role::Format
+              MooseX::Net::API::Role::Authentication
+              MooseX::Net::API::Role::Serialization
+              MooseX::Net::API::Role::Request
+              /
+        ],
+    );
+
+    $meta;
 }
 
-sub net_api_declare {
-    my $caller  = shift;
-    my $name    = shift;
-    my %options = @_;
-
-    my $class = Moose::Meta::Class->initialize($caller);
-
-    $class->add_attribute(
-        'api_base_url',
-        is      => 'rw',
-        isa     => 'Str',
-        lazy    => 1,
-        default => delete $options{base_url} || ''
+1;
+
+__END__
+
+=head1 NAME
+
+MooseX::Net::API - Easily create client for net API
+
+=head1 SYNOPSIS
+
+    package My::Net::API;
+    use MooseX::Net::API;
+
+    # we declare an API, the base_url is http://exemple.com/api
+    # the format is json and it will be append to the query
+    # You can set api_base_url later, calling $obj->api_base_url('http://..')
+    net_api_declare my_api => (
+        api_base_url    => 'http://exemple.com/api',
+        api_format      => 'json',
+        api_format_mode => 'append',
     );
 
-    if ( !$options{format} ) {
-        die MooseX::Net::API::Error->new(
-            reason => "format is missing in your api declaration" );
-    }
-    elsif ( !$list_content_type->{ $options{format} } ) {
-        die MooseX::Net::API::Error->new(
-            reason => "format is not recognised. It must be "
-                . join( " or ", keys %$list_content_type ) );
-    }
-    else {
-        $class->add_attribute(
-            'api_format',
-            is      => 'ro',
-            isa     => 'Str',
-            lazy    => 1,
-            default => delete $options{format}
-        );
-    }
+    # declaring a users method
+    # calling $obj->users will call http://exemple.com/api/users/france
+    net_api_method users => (
+        description => 'this get a list of users',
+        method      => 'GET',
+        path        => '/users/:country',
+        params      => [qw/country/],
+    );
 
-    if ( !$options{format_mode} ) {
-        die MooseX::Net::API::Error->new(
-            reason => "format_mode is not set" );
-    }
-    elsif ( $options{format_mode} !~ /^(?:append|content\-type)$/ ) {
-        die MooseX::Net::API::Error->new(
-            reason => "format_mode must be append or content-type" );
-    }
-    else {
-        $class->add_attribute(
-            'api_format_mode',
-            is      => 'ro',
-            isa     => 'Str',
-            lazy    => 1,
-            default => delete $options{format_mode}
-        );
-    }
+    # you can create your own useragent (it must be a LWP::UserAgent object)
+    net_api_declare my_api => (
+        ...
+        useragent => sub {
+            my $ua = LWP::UserAgent->new;
+            $ua->agent('MyUberAgent/0.23');
+            return $ua
+        },
+        ...
+    );
 
-    if ( !$options{useragent} ) {
-        _add_useragent($class);
-    }
-    else {
-        my $method = $options{useragent};
-        if ( ref $method ne 'CODE' ) {
-            die MooseX::Net::API::Error->new(
-                reason => "useragent must be a CODE ref" );
-        }
-        else {
-            _add_useragent( $class, delete $options{useragent} );
-        }
-    }
+    # if the API require authentification, the module will handle basic
+    # authentication for you
+    net_api_declare my_api => (
+        ...
+        authentication => 1,
+        ...
+    );
 
-    if ( $options{authentication} ) {
-        $do_auth = delete $options{authentication};
-    }
+    # if the authentication is more complex, you can delegate to your own method
 
-    if ( $options{username} ) {
-        $class->add_attribute(
-            'api_username',
-            is      => 'ro',
-            isa     => 'Str',
-            lazy    => 1,
-            default => delete $options{username}
-        );
-        if ( $options{password} ) {
-            $class->add_attribute(
-                'api_password',
-                is      => 'ro',
-                isa     => 'Str',
-                lazy    => 1,
-                default => delete $options{password}
-            );
-        }
-    }
-    if ( $options{authentication_method} ) {
-        $auth_method = delete $options{authentication_method};
-    }
+    1;
 
-    if ( $options{deserialisation} ) {
-        $deserialize_method = delete $options{deserialize_order};
-    }
-    else {
-        MooseX::Net::API::Role::Deserialize->meta->apply( $caller->meta );
-    }
+    my $obj = My::Net::API->new();
+    $obj->api_base_url('http://...');
+    $obj->foo(user => $user);
 
-    if ( $options{serialisation} ) {
-        $deserialize_method = delete $options{serialize_order};
-    }
-    else {
-        MooseX::Net::API::Role::Serialize->meta->apply( $caller->meta );
-    }
-}
+=head1 DESCRIPTION
 
-sub net_api_method {
-    my $caller  = shift;
-    my $name    = shift;
-    my %options = ( authentication => $do_auth, @_ );
+MooseX::Net::API is a module to help to easily create a client for a web API.
 
-    if ( !$options{params} && $options{required} ) {
-        die MooseX::Net::API::Error->new( reason =>
-                "you can't require a param that have not been declared" );
-    }
+This module is heavily inspired by what L<Net::Twitter> does.
 
-    if ( $options{required} ) {
-        foreach my $required ( @{ $options{required} } ) {
-            die MooseX::Net::API::Error->new( reason =>
-                    "$required is required but is not declared in params" )
-                if ( !grep { $_ eq $required } @{ $options{params} } );
-        }
-    }
+B<THIS MODULE IS IN ITS BETA QUALITY. THE API MAY CHANGE IN THE FUTURE>
 
-    my $class = Moose::Meta::Class->initialize($caller);
-
-    my $code;
-    if ( !$options{code} ) {
-        $code = sub {
-            my $self = shift;
-            my %args = @_;
-
-            my $meta = $self->meta;
-
-            if ( $auth_method && !$meta->find_method_by_name($auth_method) ) {
-                die MooseX::Net::API::Error->new( reason =>
-                        "you provided $auth_method as an authentication method, but it's not available in your object"
-                );
-            }
-
-            if ( $deserialize_method
-                && !$meta->find_method_by_name($deserialize_method) )
-            {
-                die MooseX::Net::API::Error->new( reason =>
-                        "you provided $deserialize_method for deserialisation, but the method is not available in your object"
-                );
-            }
-
-            # check if there is no undeclared param
-            foreach my $arg ( keys %args ) {
-                if ( !grep { $arg eq $_ } @{ $options{params} } ) {
-                    die MooseX::Net::API::Error->new(
-                        reason => "$arg is not declared as a param" );
-                }
-            }
-
-            # check if all our params declared as required are present
-            foreach my $required ( @{ $options{required} } ) {
-                if ( !grep { $required eq $_ } keys %args ) {
-                    die MooseX::Net::API::Error->new( reason =>
-                            "$required is declared as required, but is not present"
-                    );
-                }
-            }
-
-            my $path = $options{path};
-
-            # replace all args in the url
-            my $max_iter = keys %args;
-            my $i        = 0;
-            while ($path =~ /\$(\w+)/g) {
-                my $match = $1;
-                if (my $value = delete $args{$match}) {
-                    $path =~ s/\$$match/$value/;
-                }
-                if (++$i > $max_iter) {
-                    $path =~ s/\$(\w+)//;
-                    last;
-                }
-            }
-
-            $path .= '/' if ( $self->api_base_url !~ m!/^! );
-            my $url = $self->api_base_url . $path;
-
-            my $format = $self->api_format();
-            $url .= "." . $format if ( $self->api_format_mode() eq 'append' );
-            my $uri = URI->new($url);
-
-            my $res = _request( $self, $format, \%options, $uri, \%args );
-            if ( $options{expected} ) {
-                if ( !grep { $_ eq $res->code } @{ $options{expected} } ) {
-                    die MooseX::Net::API::Error->new(
-                        reason     => "unexpected code",
-                        http_error => $res
-                    );
-                }
-            }
-
-            my $content_type = $res->headers->{"content-type"};
-            $content_type =~ s/(;.+)$//;
-
-            my @deserialize_order
-                = ( $content_type, $format, keys %$list_content_type );
-
-            my $content;
-            if ($deserialize_method) {
-                $content = $self->$deserialize_method( $res->content,
-                    @deserialize_order );
-            }
-            else {
-                $content = $self->_do_deserialization( $res->content,
-                    @deserialize_order );
-            }
-
-            if ( $res->is_success ) {
-                if (wantarray) {
-                    return ( $content, $res );
-                }
-                else {
-                    return $content;
-                }
-            }
-
-            die MooseX::Net::API::Error->new(
-                http_error => $res,
-                reason     => $content
-            );
-        };
-    }
-    else {
-        $code = $options{code};
-    }
+The following roles are added to your class:
 
-    $class->add_method(
-        $name,
-        MooseX::Net::API::Meta::Method->new(
-            name         => $name,
-            package_name => $caller,
-            body         => $code,
-            %options,
-        ),
-    );
-    $class->_add_api_method($name);
-}
+=over 4
 
-sub _add_useragent {
-    my $class = shift;
-    my $code  = shift;
-
-    if ( !$code ) {
-        try { require LWP::UserAgent; }
-        catch {
-            die MooseX::Net::API::Error->new( reason =>
-                    "no useragent defined and LWP::UserAgent is not available"
-            );
-        };
-
-        $code = sub {
-            my $ua = LWP::UserAgent->new();
-            $ua->agent("MooseX::Net::API/$VERSION (Perl)");
-            $ua->env_proxy;
-            return $ua;
-        };
-    }
-    $class->add_attribute(
-        'api_useragent',
-        is      => 'rw',
-        isa     => 'Any',
-        lazy    => 1,
-        default => $code,
-    );
-}
+=item B<MooseX::Net::API::Role::UserAgent>
 
-sub _request {
-    my ( $self, $format, $options, $uri, $args ) = @_;
+=item B<MooseX::Net::API::Role::Format>
 
-    my $req;
-    my $method = $options->{method};
+=item B<MooseX::Net::API::Role::Authentication>
 
-    if ( $method =~ /^(?:GET|DELETE)$/ || $options->{params_in_url} ) {
-        $uri->query_form(%$args);
-        $req = HTTP::Request->new( $method => $uri );
-    }
-    elsif ( $method =~ /^(?:POST|PUT)$/ ) {
-        $req = HTTP::Request->new( $method => $uri );
-        my $content = $self->_do_serialization( $args, $format );
-        $req->content($content);
-    }
-    else {
-        die MooseX::Net::API::Error->new(
-            reason => "$method is not defined" );
-    }
+=item B<MooseX::Net::API::Role::Serialization>
 
-    $req->header( 'Content-Type' => $list_content_type->{$format} )
-        if $self->api_format_mode eq 'content-type';
+=item B<MooseX::Net::API::Role::Request>
 
-    if ( $do_auth || $options->{authentication} ) {
-        if ($auth_method) {
-            $req = $self->$auth_method($req);
-        }
-        else {
-            $req = _do_authentication( $self, $req );
-        }
-    }
+=back
 
-    return $self->api_useragent->request($req);
-}
+The following attributes are added to your class:
 
-sub _do_authentication {
-    my ( $caller, $req ) = @_;
-    $req->headers->authorization_basic( $caller->api_username,
-        $caller->api_password )
-        if ( $caller->api_username && $caller->api_password );
-    return $req;
-}
+=over 4
 
-1;
-__END__
+=item B<api_base_url>
 
-=head1 NAME
+=item B<api_format>
 
-MooseX::Net::API - Easily create client for net API
+=item B<api_username>
 
-=head1 SYNOPSIS
+=item B<api_passord>
 
-  package My::Net::API;
-  use Moose;
-  use MooseX::Net::API;
-
-  # we declare an API, the base_url is http://exemple.com/api
-  # the format is json and it will be happened to the query
-  # You can set base_url later, calling $obj->api_base_url('http://..')
-  net_api_declare my_api => (
-    base_url   => 'http://exemple.com/api',
-    format     => 'json',
-    format_api => 'append',
-  );
+=item B<authentication>
 
-  # calling $obj->foo will call http://exemple.com/api/foo?user=$user&group=$group
-  net_api_method foo => (
-    description => 'this get foo',
-    method      => 'GET',
-    path        => '/foo/',
-    params      => [qw/user group/],
-    required    => [qw/user/],
-  );
+=item B<authentication_method>
 
-  # you can create your own useragent
-  net_api_declare my_api => (
-    ...
-    useragent => sub {
-      my $ua = LWP::UserAgent->new;
-      $ua->agent('MyUberAgent/0.23');
-      return $ua
-    },
-    ...
-  );
+=back
 
-  # if the API require authentification, the module will handle basic
-  # authentication for you
-  net_api_declare my_api => (
-    ...
-    authentication => 1,
-    ...
-  );
+The following methods are added to your class:
 
-  # if the authentication is more complex, you can delegate to your own method
+=over 4
 
-  1;
+=item B<http_request>
 
-  my $obj = My::Net::API->new();
-  $obj->api_base_url('http://...');
-  $obj->foo(user => $user);
+=item B<get_content>
 
-=head1 DESCRIPTION
+=item B<serialize>
 
-MooseX::Net::API is module to help to easily create a client for a web API.
-This module is heavily inspired by what L<Net::Twitter> does.
+=item B<deserialize>
 
-B<THIS MODULE IS IN ITS BETA QUALITY. THE API MAY CHANGE IN THE FUTURE>
+=item B<content_type>
+
+=back
 
 =head2 METHODS
 
@@ -426,46 +171,61 @@ B<THIS MODULE IS IN ITS BETA QUALITY. THE API MAY CHANGE IN THE FUTURE>
 
 =item B<net_api_declare>
 
-  net_api_declare backtype => (
-    base_url    => 'http://api....',
-    format      => 'json',
-    format_mode => 'append',
-  );
+    net_api_declare backtype => (
+        base_url    => 'http://api....',
+        format      => 'json',
+        format_mode => 'append',
+    );
+
+=over 2
+
+=item B<api_base_url>
+
+The base url for all the API's calls. This will set the B<api_base_url> attribut in your class. Can be set at the object creation or before calling an API method.
+
+=item B<api_format>
+
+The format for the API's calls. This will set the B<api_format> attribut to your class. Value can be:
 
 =over 2
 
-=item B<base_url> (required)
+=item B<json>
+
+=item B<yaml>
+
+=item B<xml>
 
-The base url for all the API's calls. This will add an B<api_base_url>
-attribut to your class.
+=back
+
+=item B<api_format_mode>
 
-=item B<format> (required, must be either xml, json or yaml)
+How the format is handled. B<append> will add B<.$format> to the query, B<content-type> will set the content-type information to the header of the request. Should be one the following value:
 
-The format for the API's calls. This will add an B<api_format> attribut to
-your class.
+=over 2
 
-=item B<format_mode> (required, must be 'append' or 'content-type')
+=item B<content-type>
 
-How the format is handled. B<append> will add B<.json> to the query,
-B<content-type> will add the content-type information to the header of the
-request.
+=item B<append>
 
-=item B<useragent> (optional, by default it's a LWP::UserAgent object)
+=back
 
-  useragent => sub {
-    my $ua = LWP::UserAgent->new;
-    $ua->agent( "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.1.1) Gecko/20061204 Firefox/2.0.0.1");
-     return $ua;
-  },
+=item B<api_useragent>
+
+A L<LWP::UserAgent> object.
+
+    useragent => sub {
+        my $ua = LWP::UserAgent->new;
+        $ua->agent( "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.1.1) Gecko/20061204 Firefox/2.0.0.1");
+        return $ua;
+    }
 
-=item B<authentication> (optional)
+=item B<authentication>
 
 This is a boolean to tell if we must authenticate to use this API.
 
-=item B<authentication_method> (optional)
+=item B<authentication_method>
 
-The default authentication method only set an authorization header using the
-Basic Authentication Scheme. You can write your own authentication method:
+The default authentication method only set an authorization header using the Basic Authentication Scheme. You can write your own authentication method:
 
   net_api_declare foo => (
     ...
@@ -476,7 +236,6 @@ Basic Authentication Scheme. You can write your own authentication method:
   sub my_auth_method {
     my ($self, $req) = @_; #$req is an HTTP::Request object
     ...
-    return $req;
   }
 
 =back
@@ -485,51 +244,46 @@ Basic Authentication Scheme. You can write your own authentication method:
 
 =over 2
 
-=item B<description> [string]
+=item B<description>
 
-description of the method (this is a documentation)
+A string to describe the method (this is a documentation)
 
-=item B<method> [string]
+=item B<method>
 
 HTTP method (GET, POST, PUT, DELETE)
 
-=item B<path> [string]
+=item B<path>
 
 path of the query.
 
 If you defined your path and params like this
 
-  net_api_method user_comments => (
-    ...
-    path => '/user/$user/list/$date/',
-    params => [qw/user date foo bar/],
-    ...
-  );
+    net_api_method user_comments => (
+      ...
+      path => '/user/:user/list/:date',
+      params => [qw/user date foo bar/],
+      ...
+    );
 
 and you call
 
-  $obj->user_comments(user => 'franck', date => 'today', foo => 1, bar => 2);
-
-the url generetad will look like
-
-  /user/franck/list/today/?foo=1&bar=2
+    $obj->user_comments(user => 'franck', date => 'today', foo => 1, bar => 2);
 
-=item B<params> [arrayref]
+the url generated will look like
 
-list of params.
+    /user/franck/list/today/?foo=1&bar=2
 
-=item B<required> [arrayref]
+=item B<params>
 
-list of required params.
+Arrayref of params.
 
-=item B<authentication> (optional)
+=item B<required>
 
-should we do an authenticated call
+Arrayref of required params.
 
-=item B<params_in_url> (optional)
+=item B<params_in_url>
 
-When you do a post, the content may have to be sent as arguments in the url,
-and not as content in the header.
+When you do a post, the content may have to be sent as arguments in the url, and not as content in the header.
 
 =back