File Coverage

blib/lib/WWW/ARDB.pm

Criterion	Covered	Total	%
statement	110	112	98.2
branch	19	26	73.0
condition			n/a
subroutine	33	33	100.0
pod	17	17	100.0
total	179	188	95.2

package WWW::ARDB;
our $AUTHORITY = 'cpan:GETTY';

# ABSTRACT: Perl client for the ARC Raiders Database API (ardb.app)

use Moo;
use LWP::UserAgent;
use JSON::MaybeXS qw( decode_json );
use Carp qw( croak );
use namespace::clean;

our $VERSION = '0.002';
our $DEBUG = $ENV{WWW_ARDB_DEBUG};

use WWW::ARDB::Cache;
use WWW::ARDB::Request;
use WWW::ARDB::Result::Item;
use WWW::ARDB::Result::Quest;
use WWW::ARDB::Result::ArcEnemy;


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


sub _build_ua {
    my $self = shift;
    return LWP::UserAgent->new(
        agent   => 'WWW-ARDB/' . $VERSION,
        timeout => 30,
    );
}

has request => (
    is      => 'ro',
    lazy    => 1,
    default => sub { WWW::ARDB::Request->new },
);


has cache => (
    is      => 'ro',
    lazy    => 1,
    builder => '_build_cache',
);


sub _build_cache {
    my $self = shift;
    return WWW::ARDB::Cache->new(
        $self->cache_dir ? (cache_dir => $self->cache_dir) : ()
    );
}

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


has cache_dir => (
    is => 'ro',
);


has debug => (
    is      => 'ro',
    default => sub { $DEBUG // 0 },
);


# Items

sub items {
    my ($self, %params) = @_;
    my $data = $self->_fetch('items', $self->request->items(%params), %params);
    return $self->_to_objects($data, 'WWW::ARDB::Result::Item');
}


sub items_raw {
    my ($self, %params) = @_;
    return $self->_fetch('items', $self->request->items(%params), %params);
}


sub item {
    my ($self, $id, %params) = @_;
    my $data = $self->_fetch("items/$id", $self->request->item($id, %params), %params);
    return $self->_to_object($data, 'WWW::ARDB::Result::Item');
}


sub item_raw {
    my ($self, $id, %params) = @_;
    return $self->_fetch("items/$id", $self->request->item($id, %params), %params);
}


# Quests

sub quests {
    my ($self, %params) = @_;
    my $data = $self->_fetch('quests', $self->request->quests(%params), %params);
    return $self->_to_objects($data, 'WWW::ARDB::Result::Quest');
}


sub quests_raw {
    my ($self, %params) = @_;
    return $self->_fetch('quests', $self->request->quests(%params), %params);
}


sub quest {
    my ($self, $id, %params) = @_;
    my $data = $self->_fetch("quests/$id", $self->request->quest($id, %params), %params);
    return $self->_to_object($data, 'WWW::ARDB::Result::Quest');
}


sub quest_raw {
    my ($self, $id, %params) = @_;
    return $self->_fetch("quests/$id", $self->request->quest($id, %params), %params);
}


# ARC Enemies

sub arc_enemies {
    my ($self, %params) = @_;
    my $data = $self->_fetch('arc-enemies', $self->request->arc_enemies(%params), %params);
    return $self->_to_objects($data, 'WWW::ARDB::Result::ArcEnemy');
}


sub arc_enemies_raw {
    my ($self, %params) = @_;
    return $self->_fetch('arc-enemies', $self->request->arc_enemies(%params), %params);
}


sub arc_enemy {
    my ($self, $id, %params) = @_;
    my $data = $self->_fetch("arc-enemies/$id", $self->request->arc_enemy($id, %params), %params);
    return $self->_to_object($data, 'WWW::ARDB::Result::ArcEnemy');
}


sub arc_enemy_raw {
    my ($self, $id, %params) = @_;
    return $self->_fetch("arc-enemies/$id", $self->request->arc_enemy($id, %params), %params);
}


# Helper methods

sub find_item_by_name {
    my ($self, $name) = @_;
    my $items = $self->items;
    my $lc_name = lc($name);
    for my $item (@$items) {
        return $item if lc($item->name) eq $lc_name;
    }
    return;
}


sub find_item_by_id {
    my ($self, $id) = @_;
    return $self->item($id);
}


sub find_quest_by_title {
    my ($self, $title) = @_;
    my $quests = $self->quests;
    my $lc_title = lc($title);
    for my $quest (@$quests) {
        return $quest if lc($quest->title) eq $lc_title;
    }
    return;
}


sub find_arc_enemy_by_name {
    my ($self, $name) = @_;
    my $enemies = $self->arc_enemies;
    my $lc_name = lc($name);
    for my $enemy (@$enemies) {
        return $enemy if lc($enemy->name) eq $lc_name;
    }
    return;
}


sub clear_cache {
    my ($self, $endpoint) = @_;
    $self->cache->clear($endpoint);
}


# Internal methods

sub _fetch {
    my ($self, $endpoint, $http_request, %params) = @_;

    if ($self->use_cache) {
        my $cached = $self->cache->get($endpoint, \%params);
        if ($cached) {
            $self->_debug("Cache hit for $endpoint");
            return $cached;
        }
    }

    $self->_debug("Fetching $endpoint from API");
    my $response = $self->ua->request($http_request);

    unless ($response->is_success) {
        croak "API request failed: " . $response->status_line;
    }

    my $data = decode_json($response->decoded_content);

    if ($self->use_cache) {
        $self->cache->set($endpoint, \%params, $data);
    }

    return $data;
}

sub _to_objects {
    my ($self, $data, $class) = @_;
    return [] unless $data;
    return [] unless ref($data) eq 'ARRAY';
    return [ map { $class->from_hashref($_) } @$data ];
}

sub _to_object {
    my ($self, $data, $class) = @_;
    return unless $data;
    return unless ref($data) eq 'HASH';
    return $class->from_hashref($data);
}

sub _debug {
    my ($self, $msg) = @_;
    return unless $self->debug;
    warn "[WWW::ARDB] $msg\n";
}


1;

__END__