File Coverage

blib/lib/Pithub/Base.pm

Criterion	Covered	Total	%
statement	123	124	99.1
branch	58	60	96.6
condition	12	14	85.7
subroutine	20	21	95.2
pod	3	3	100.0
total	216	222	97.3

package Pithub::Base;
our $AUTHORITY = 'cpan:PLU';

# ABSTRACT: Github v3 base class for all Pithub modules

use Moo;

our $VERSION = '0.01041';

use Carp           qw( croak );
use HTTP::Headers  ();
use HTTP::Request  ();
use JSON::MaybeXS  qw( JSON );
use LWP::UserAgent ();
use Pithub::Result ();
use URI            ();

with 'Pithub::Result::SharedCache';


has 'auto_pagination' => (
    default => sub { 0 },
    is      => 'rw',
);


has 'api_uri' => (
    default => sub { URI->new('https://api.github.com') },
    is      => 'rw',
    trigger => sub {
        my ( $self, $uri ) = @_;
        $self->{api_uri} = URI->new("$uri");
    },
);


has 'jsonp_callback' => (
    clearer   => 'clear_jsonp_callback',
    is        => 'rw',
    predicate => 'has_jsonp_callback',
    required  => 0,
);


has 'per_page' => (
    clearer   => 'clear_per_page',
    is        => 'rw',
    predicate => 'has_per_page',
    default   => 100,
    required  => 0,
);


has 'prepare_request' => (
    clearer   => 'clear_prepare_request',
    is        => 'rw',
    predicate => 'has_prepare_request',
    required  => 0,
);


has 'repo' => (
    clearer   => 'clear_repo',
    is        => 'rw',
    predicate => 'has_repo',
    required  => 0,
);


has 'token' => (
    clearer   => 'clear_token',
    is        => 'rw',
    predicate => '_has_token',
    required  => 0,
);


has 'ua' => (
    builder => '_build_ua',
    is      => 'ro',
    lazy    => 1,
);


has 'user' => (
    clearer   => 'clear_user',
    is        => 'rw',
    predicate => 'has_user',
    required  => 0,
);


has 'utf8' => (
    is      => 'ro',
    default => 1,
);

has '_json' => (
    builder => '_build__json',
    is      => 'ro',
    lazy    => 1,
);

my @TOKEN_REQUIRED = (
    'DELETE /user/emails',
    'GET /user',
    'GET /user/emails',
    'GET /user/followers',
    'GET /user/following',
    'GET /user/keys',
    'GET /user/repos',
    'PATCH /user',
    'POST /user/emails',
    'POST /user/keys',
    'POST /user/repos',
);

my @TOKEN_REQUIRED_REGEXP = (
    qr{^DELETE },
    qr{^GET /gists/starred$},
    qr{^GET /gists/[^/]+/star$},
    qr{^GET /issues$},
    qr{^GET /orgs/[^/]+/members/.*$},
    qr{^GET /orgs/[^/]+/teams$},
    qr{^GET /repos/[^/]+/[^/]+/collaborators$},
    qr{^GET /repos/[^/]+/[^/]+/collaborators/.*$},
    qr{^GET /repos/[^/]+/[^/]+/hooks$},
    qr{^GET /repos/[^/]+/[^/]+/hooks/.*$},
    qr{^GET /repos/[^/]+/[^/]+/keys$},
    qr{^GET /repos/[^/]+/[^/]+/keys/.*$},
    qr{^GET /teams/.*$},
    qr{^GET /teams/[^/]+/members$},
    qr{^GET /teams/[^/]+/members/.*$},
    qr{^GET /teams/[^/]+/repos$},
    qr{^GET /teams/[^/]+/repos/.*$},
    qr{^GET /user/following/.*$},
    qr{^GET /user/keys/.*$},
    qr{^GET /user/orgs$},
    qr{^GET /user/starred/[^/]+/.*$},
    qr{^GET /user/watched$},
    qr{^GET /user/watched/[^/]+/.*$},
    qr{^GET /users/[^/]+/events/orgs/.*$},
    qr{^PATCH /gists/.*$},
    qr{^PATCH /gists/[^/]+/comments/.*$},
    qr{^PATCH /orgs/.*$},
    qr{^PATCH /repos/[^/]+/.*$},
    qr{^PATCH /repos/[^/]+/[^/]+/comments/.*$},
    qr{^PATCH /repos/[^/]+/[^/]+/git/refs/.*$},
    qr{^PATCH /repos/[^/]+/[^/]+/hooks/.*$},
    qr{^PATCH /repos/[^/]+/[^/]+/issues/.*$},
    qr{^PATCH /repos/[^/]+/[^/]+/issues/comments/.*$},
    qr{^PATCH /repos/[^/]+/[^/]+/keys/.*$},
    qr{^PATCH /repos/[^/]+/[^/]+/labels/.*$},
    qr{^PATCH /repos/[^/]+/[^/]+/milestones/.*$},
    qr{^PATCH /repos/[^/]+/[^/]+/pulls/.*$},
    qr{^PATCH /repos/[^/]+/[^/]+/releases/.*$},
    qr{^PATCH /repos/[^/]+/[^/]+/pulls/comments/.*$},
    qr{^PATCH /teams/.*$},
    qr{^PATCH /user/keys/.*$},
    qr{^PATCH /user/repos/.*$},
    qr{^POST /repos/[^/]+/[^/]+/releases/[^/]+/assets.*$},
    qr{^POST /gists/[^/]+/comments$},
    qr{^POST /orgs/[^/]+/repos$},
    qr{^POST /orgs/[^/]+/teams$},
    qr{^POST /repos/[^/]+/[^/]+/commits/[^/]+/comments$},
    qr{^POST /repos/[^/]+/[^/]+/downloads$},
    qr{^POST /repos/[^/]+/[^/]+/forks},
    qr{^POST /repos/[^/]+/[^/]+/git/blobs$},
    qr{^POST /repos/[^/]+/[^/]+/git/commits$},
    qr{^POST /repos/[^/]+/[^/]+/git/refs},
    qr{^POST /repos/[^/]+/[^/]+/git/tags$},
    qr{^POST /repos/[^/]+/[^/]+/git/trees$},
    qr{^POST /repos/[^/]+/[^/]+/hooks$},
    qr{^POST /repos/[^/]+/[^/]+/hooks/[^/]+/test$},
    qr{^POST /repos/[^/]+/[^/]+/issues$},
    qr{^POST /repos/[^/]+/[^/]+/issues/[^/]+/comments},
    qr{^POST /repos/[^/]+/[^/]+/issues/[^/]+/labels$},
    qr{^POST /repos/[^/]+/[^/]+/keys$},
    qr{^POST /repos/[^/]+/[^/]+/labels$},
    qr{^POST /repos/[^/]+/[^/]+/milestones$},
    qr{^POST /repos/[^/]+/[^/]+/pulls$},
    qr{^POST /repos/[^/]+/[^/]+/releases$},
    qr{^POST /repos/[^/]+/[^/]+/pulls/[^/]+/comments$},
    qr{^POST /repos/[^/]+/[^/]+/pulls/[^/]+/requested_reviewers$},
    qr{^PUT /gists/[^/]+/star$},
    qr{^PUT /orgs/[^/]+/public_members/.*$},
    qr{^PUT /repos/[^/]+/[^/]+/collaborators/.*$},
    qr{^PUT /repos/[^/]+/[^/]+/issues/[^/]+/labels$},
    qr{^PUT /repos/[^/]+/[^/]+/pulls/[^/]+/merge$},
    qr{^PUT /teams/[^/]+/members/.*$},
    qr{^PUT /teams/[^/]+/memberships/.*$},
    qr{^PUT /teams/[^/]+/repos/.*$},
    qr{^PUT /user/following/.*$},
    qr{^PUT /user/starred/[^/]+/.*$},
    qr{^PUT /user/watched/[^/]+/.*$},
);


sub request {
    my ( $self, %args ) = @_;

    my $method = delete $args{method}
        || croak 'Missing mandatory key in parameters: method';
    my $path = delete $args{path}
        || croak 'Missing mandatory key in parameters: path';
    my $data    = delete $args{data};
    my $options = delete $args{options};
    my $params  = delete $args{params};

    croak "Invalid method: $method"
        unless grep $_ eq $method, qw(DELETE GET PATCH POST PUT);

    my $uri = $self->_uri_for($path);

    if ( my $host = delete $args{host} ) {
        $uri->host($host);
    }

    if ( my $query = delete $args{query} ) {
        $uri->query_form(%$query);
    }

    my $request = $self->_request_for( $method, $uri, $data );

    if ( my $headers = delete $args{headers} ) {
        foreach my $header ( keys %$headers ) {
            $request->header( $header, $headers->{$header} );
        }
    }

    if ( $self->_token_required( $method, $path )
        && !$self->has_token($request) ) {
        croak sprintf 'Access token required for: %s %s (%s)', $method,
            $path, $uri;
    }

    if ($options) {
        croak 'The key options must be a hashref'
            unless ref $options eq 'HASH';
        croak
            'The key prepare_request in the options hashref must be a coderef'
            if $options->{prepare_request}
            && ref $options->{prepare_request} ne 'CODE';

        if ( $options->{prepare_request} ) {
            $options->{prepare_request}->($request);
        }
    }

    if ($params) {
        croak 'The key params must be a hashref' unless ref $params eq 'HASH';
        my %query = ( $request->uri->query_form, %$params );
        $request->uri->query_form(%query);
    }

    my $response = $self->_make_request($request);

    return Pithub::Result->new(
        auto_pagination => $self->auto_pagination,
        response        => $response,
        utf8            => $self->utf8,
        _request        => sub { $self->request(@_) },
    );
}

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

    my $cache_key = $request->uri->as_string;
    if ( my $cached_response = $self->shared_cache->get($cache_key) ) {

        # Add the If-None-Match header from the cache's ETag
        # and make the request
        $request->header(
            'If-None-Match' => $cached_response->header('ETag') );
        my $response = $self->ua->request($request);

        # Got 304 Not Modified, cache is still valid
        return $cached_response if ( $response->code || 0 ) == 304;

        # The response changed, cache it and return it.
        $self->shared_cache->set( $cache_key, $response );
        return $response;
    }

    my $response = $self->ua->request($request);
    $self->shared_cache->set( $cache_key, $response );
    return $response;
}


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

    # If we have one specified in the object, return true
    return 1 if $self->_has_token;

    # If no request object here, we don't have a token
    return 0 unless $request;

    return 1 if $request->header('Authorization');
    return 0;
}


sub rate_limit {
    return shift->request( method => 'GET', path => '/rate_limit' );
}

sub _build__json {
    my ($self) = @_;
    return JSON->new->utf8( $self->utf8 );
}

sub _build_ua {
    my ($self) = @_;
    return LWP::UserAgent->new;
}

sub _get_user_repo_args {
    my ( $self, $args ) = @_;
    $args->{user} = $self->user unless defined $args->{user};
    $args->{repo} = $self->repo unless defined $args->{repo};
    return $args;
}

## no critic (Subroutines::ProhibitUnusedPrivateSubroutines)
sub _create_instance {
    my ( $self, $class, @args ) = @_;

    my %args = (
        api_uri         => $self->api_uri,
        auto_pagination => $self->auto_pagination,
        ua              => $self->ua,
        utf8            => $self->utf8,
        @args,
    );

    for my $attr (qw(repo token user per_page jsonp_callback prepare_request))
    {
        # Allow overrides to set attributes to undef
        next if exists $args{$attr};

        my $has_attr = "has_$attr";
        $args{$attr} = $self->$attr if $self->$has_attr;
    }

    return $class->new(%args);
}
## use critic

sub _request_for {
    my ( $self, $method, $uri, $data ) = @_;

    my $headers = HTTP::Headers->new;

    if ( $self->has_token ) {
        $headers->header(
            'Authorization' => sprintf( 'token %s', $self->token ) );
    }

    my $request = HTTP::Request->new( $method, $uri, $headers );

    if ($data) {
        $data = $self->_json->encode($data) if ref $data;
        $request->content($data);
    }

    $request->header( 'Content-Length' => length $request->content );

    if ( $self->has_prepare_request ) {
        $self->prepare_request->($request);
    }

    return $request;
}

my %TOKEN_REQUIRED = map { ( $_ => 1 ) } @TOKEN_REQUIRED;

sub _token_required {
    my ( $self, $method, $path ) = @_;

    my $key = "${method} ${path}";

    return 1 if $TOKEN_REQUIRED{$key};

    foreach my $regexp (@TOKEN_REQUIRED_REGEXP) {
        return 1 if $key =~ /$regexp/;
    }

    return 0;
}

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

    my $uri       = $self->api_uri->clone;
    my $base_path = $uri->path;
    $path =~ s/^$base_path//;
    my @parts;
    push @parts, split qr{/+}, $uri->path;
    push @parts, split qr{/+}, $path;
    $uri->path( join '/', grep { $_ } @parts );

    if ( $self->has_per_page ) {
        my %query = ( $uri->query_form, per_page => $self->per_page );
        $uri->query_form(%query);
    }

    if ( $self->has_jsonp_callback ) {
        my %query = ( $uri->query_form, callback => $self->jsonp_callback );
        $uri->query_form(%query);
    }

    return $uri;
}

## no critic (Subroutines::ProhibitUnusedPrivateSubroutines)
sub _validate_user_repo_args {
    my ( $self, $args ) = @_;
    $args = $self->_get_user_repo_args($args);
    croak 'Missing key in parameters: user' unless $args->{user};
    croak 'Missing key in parameters: repo' unless $args->{repo};
}
## use critic

1;

__END__