File Coverage

blib/lib/DigitalOcean/Collection.pm

Criterion	Covered	Total	%
statement	9	56	16.0
branch	0	16	0.0
condition	0	9	0.0
subroutine	3	9	33.3
pod	2	2	100.0
total	14	92	15.2

use strict;
package DigitalOcean::Collection;
use Mouse;
use DigitalOcean::Types;

#ABSTRACT: Represents a Collection object in the DigitalOcean API

has DigitalOcean => (
    is => 'rw',
    isa => 'DigitalOcean',
    required => 1,
);

has type_name => (
    is => 'rw',
    isa => 'Str',
    required => 1,
);

has json_key => (
    is => 'rw',
    isa => 'Str',
    required => 1,
);


has objects => (
    is => 'rw',
    isa => 'ArrayRef[Any]',
    default => sub { [] },
);


has cur_page => (
    is => 'rw',
    isa => 'Int',
    default => 0,
);


has last_page => (
    is => 'rw',
    isa => 'Int',
    default => 1,
);


has params => (
    is => 'rw',
    isa => 'Undef|HashRef',
    default => undef,
);

has response => (
    is => 'rw',
    isa => 'DigitalOcean::Response',
    required => 1,
);


has pages => (
    is => 'rw',
    isa => 'DigitalOcean::Pages',
);


has next_element => (
    is => 'rw',
    isa => 'Int',
    default => 0,
);


has total => (
    is => 'rw',
    isa => 'Int',
);


has init_objects => (
    is => 'rw',
    isa => 'ArrayRef[ArrayRef]',
    default => sub { [] },
);

sub BUILD {
    my ($self) = @_;
    $self->_update;
}

sub _update {
    my ($self) = @_;

    #if no request have been made yet, just set current page to 1
    if($self->cur_page == 0) {
        $self->cur_page($self->cur_page + 1);
    }
    #otherwise, set to our next page
    elsif($self->pages->next) {
        my ($path, $cur_page) = $self->_get_path_and_page($self->pages->next);
        $self->cur_page($cur_page);
    }

    #get returned objects
    $self->objects($self->DigitalOcean->_decode_many($self->type_name, $self->response->json->{$self->json_key}));

    $self->_init_obj;

    if($self->response->links and $self->response->links->pages) {
        $self->pages($self->response->links->pages);
    }

    #only if last page was returned
    if($self->pages and $self->pages->last) {
        my ($path, $last_page) = $self->_get_path_and_page($self->pages->last);

        $self->last_page($last_page);
    }

    $self->next_element(0);

    $self->total($self->response->meta->total);
}

sub _init_obj {
    my ($self) = @_;
    return unless $self->init_objects;

    for my $obj (@{$self->objects}) {
        for my $arr (@{$self->init_objects}) {
            my ($init_obj_name, $init_obj) = @$arr;
            $obj->$init_obj_name($init_obj);
        }
    }
}


sub next {
    my ($self) = @_;

    my $object;

    my $next_element = $self->next_element;
    my $last_index = $#{$self->objects};

    #if next element is within the array of objects we already have, just return the object
    if($next_element <= $last_index) {
        $object = $self->objects->[$next_element];
    }
    #if we are out of elements in this set of objects and we are not on the last page, request the next page of objects
    elsif($self->cur_page < $self->last_page and $self->pages->next) {
        $self->_request_next_page;
        $object = $self->objects->[$self->next_element];
    }
    #otherwise we are out of total elements. and will return undef

    $self->next_element($self->next_element + 1);
    return $object;
}

sub _request_next_page {
    my ($self) = @_;
    return unless $self->pages->next;

    my ($path, $cur_page) = $self->_get_path_and_page($self->pages->next);
    $self->params->{page} = $cur_page;

    #request next set of objects
    my $do_response = $self->DigitalOcean->_GET(path => $path, params => $self->params);
    $self->response($do_response);

    $self->_update;
}

sub _get_path_and_page {
    my ($self, $url) = @_;

    my $uri = URI->new($url);
    my $path = substr($uri->path, 4);
    my %form = $uri->query_form;

    return ($path, $form{page});
}


__PACKAGE__->meta->make_immutable();

1;

__END__