File Coverage

blib/lib/Net/Disqus.pm

Criterion	Covered	Total	%
statement	32	84	38.1
branch	5	34	14.7
condition	1	13	7.6
subroutine	9	14	64.2
pod	4	4	100.0
total	51	149	34.2

use warnings;
use strict;
package Net::Disqus;
BEGIN {
  $Net::Disqus::VERSION = '1.19';
}
use Try::Tiny;
use Net::Disqus::UserAgent;
use Net::Disqus::Interfaces;
use Net::Disqus::Exception;
use base 'Class::Accessor';

__PACKAGE__->mk_ro_accessors(qw(api_key api_secret api_url ua pass_api_errors));
__PACKAGE__->mk_accessors(qw(interfaces rate_limit rate_limit_remaining rate_limit_reset fragment path));

our $AUTOLOAD;

sub new {
    my $class = shift;

    die Net::Disqus::Exception->new({ code => 500, text => '"new" is not an instance method'}) if(ref($class));

    my %args = (
        secure => 0,
        pass_api_errors => 0,
        ua_args => {},
        (@_ == 1 && ref $_[0] eq 'HASH') ? %{$_[0]} : @_,
        interfaces => {},
        api_url => 'http://disqus.com/api/3.0',
        );

    die Net::Disqus::Exception->new({ code => 500, text => "missing required argument 'api_secret'"}) unless $args{'api_secret'};

    $args{'ua'} = Net::Disqus::UserAgent->new(%{$args{'ua_args'}});
    $args{'api_url'} = 'https://secure.disqus.com/api/3.0' if($args{'secure'});
    my $self = $class->SUPER::new({%args});

    $self->interfaces(Net::Disqus::Interfaces->INTERFACES());
    return $self;
}

sub fetch {
    my $self = shift;
    my $url  = shift;
    my $t = $self;

    $url =~ s/^\///;
    my @url = split(/\//, $url);
    my $last = pop(@url);

    $t = $t->$_() for(@url);
    return $t->$last(@_);
}

sub rate_limit_resets_in {
    my $self = shift;
    my $now = time();

    return ($now > $self->rate_limit_reset)
        ? undef
        : $self->rate_limit_reset - $now;
}

sub rate_limit_wait {
    my $self = shift;
    my $now = time();
    my $reset = $self->rate_limit_reset || 0;

    return undef unless($reset > 0);
    return undef if($now > $reset);

    my $diff = $reset - $now;
    my $remaining = $self->rate_limit_remaining;

    return undef if($diff == 0 || $remaining == 0);

    # we can do X requests every Y seconds to fill it up right
    # to the reset time
    my $wait = int($diff/$remaining);
    $wait-- if($wait * $remaining > $diff);
    return $wait;
}

sub _mk_request {
    my $self = shift;
    my $fragment = $self->fragment;
    my %args = (@_);

    $self->fragment(undef);

    my $url = sprintf('%s%s.json', $self->api_url, $self->path);
    my $method = lc($fragment->{method});
    my $required = $fragment->{required} || [];

    for(@$required) {
        die Net::Disqus::Exception->new({ code => 500, text => "missing required argument '$_'"}) unless($args{$_});
    }
    $args{'api_secret'} = $self->api_secret;

    # and there we are.
    my ($json, $rate) = $self->ua->request($method, $url, %args);
    die Net::Disqus::Exception->new({ code => $json->{code}, text => $json->{response}}) if(!$self->pass_api_errors && $json->{code} != 0);

    $self->rate_limit($rate->{'X-Ratelimit-Limit'});
    $self->rate_limit_remaining($rate->{'X-Ratelimit-Remaining'});
    $self->rate_limit_reset($rate->{'X-Ratelimit-Reset'});
    return $json;
}

sub AUTOLOAD {
    my $self = shift;
    my $fragment = ((($_ = $AUTOLOAD) =~ s/.*://) ? $_ : "");
    return if($fragment eq uc($fragment));

    unless($self->fragment) {
        $self->fragment($self->interfaces);
        $self->path('');
    }
    $self->path($self->path . '/' . $fragment);
    if($self->fragment->{$fragment}) {
        $self->fragment($self->fragment->{$fragment});
        return ($self->fragment->{method})
            ? $self->_mk_request(@_)
            : $self;
    } else {
        $self->fragment(undef);
        my $path = $self->path and $self->path(undef);
        die Net::Disqus::Exception->new({ code => 500, text => "No such API endpoint"});
    }
}

1;
__END__