Data::Paginator - Pagination with Moose

    use Data::Paginator;

    my $pager = Data::Paginator->new(
        current_page => 1,
        entries_per_page => 10
        total_entries => 100,
    );

    print "First page: ".$page->first_page."\n";
    print "Last page: ".$page->last_page."\n";
    print "First entry on page: ".$page->first."\n";
    print "Last entry on page: ".$page->last."\n";

package Data::Paginator;
use Moose;

use Data::Paginator::Types qw(PositiveInt);
use MooseX::Types::Moose qw(Maybe);

our $VERSION = '0.04';

has current_page => (
    is => 'ro',
    isa => 'Num',
    default => 1
);

has current_set => (
    is => 'ro',
    isa => Maybe[PositiveInt],
    lazy_build => 1
);

has entries_per_page => (
    is => 'ro',
    isa => PositiveInt,
    required => 1
);

has last_page => (
    is => 'ro',
    isa => PositiveInt,
    lazy_build => 1
);

has next_set => (
    is => 'ro',
    isa => Maybe[PositiveInt],
    lazy_build => 1
);

has pages_per_set => (
    is => 'ro',
    isa => Maybe[PositiveInt],
    predicate => 'has_pages_per_set'
);

has previous_set => (
    is => 'ro',
    isa => Maybe[PositiveInt],
    lazy_build => 1
);

has total_entries => (
    is => 'ro',
    isa => PositiveInt,
    required => 1
);

# This facilitates incorrect page numbers.
around 'current_page' => sub {
    my ($orig, $self) = @_;

    my $val = $self->meta->find_attribute_by_name('current_page')->get_value($self);
    if(!defined($val)) {
        $self->meta->get_attribute('current_page')->set_value($self, 1);
        return 1
    } elsif($val < 1) {
        $self->meta->get_attribute('current_page')->set_value($self, 1);
        return 1;
    } elsif($val > $self->last_page) {
        $self->meta->get_attribute('current_page')->set_value($self, $self->last_page);
        return $self->last_page;
    }

    return $val;
};

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

    return $self->set_for($self->current_page);
}

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

    my $pages = $self->total_entries / $self->entries_per_page;
    my $last_page;

    if ($pages == int $pages) {
        $last_page = $pages;
    } else {
        $last_page = 1 + int($pages);
    }

    $last_page = 1 if $last_page < 1;
    return $last_page;
}

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

    return undef unless $self->pages_per_set;

    my $next = $self->current_set * ($self->pages_per_set * $self->entries_per_page) + 1;
    return undef if $next > $self->total_entries;
    return $next;
}

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

    return undef unless $self->pages_per_set;
    my $cset = $self->current_set;
    return undef if $cset == 1;

    return ($cset - 2) * $self->pages_per_set * $self->entries_per_page + 1;
}

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

    if ($self->total_entries == 0) {
        return 0;
    } else {
        return $self->last - $self->first + 1;
    }
}

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

    if ($self->total_entries == 0) {
        return 0;
    } else {
        return (($self->current_page - 1) * $self->entries_per_page) + 1;
    }
}

sub first_page {
    my ($self) = @_;
    return 1;
}

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

    if($self->has_pages_per_set) {
        return 1;
    }

    return undef;
}

sub last {
    my $self = shift;

    if ($self->current_page == $self->last_page) {
        return $self->total_entries;
    } else {
        return ($self->current_page * $self->entries_per_page);
    }
}

sub next_page {
    my $self = shift;

    $self->current_page < $self->last_page ? $self->current_page + 1 : undef;
}

sub page_for {
    my ($self, $num) = @_;

    return undef if $num > $self->total_entries || $num < 1;

    my $page = $num / $self->entries_per_page;
    if($page > int($page)) {
        return int($page) + 1;
    }

    return $page;
}

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

    if ($self->current_page > 1) {
        return $self->current_page - 1;
    } else {
        return undef;
    }
}

sub set_for {
    my ($self, $num) = @_;

    return undef unless $self->has_pages_per_set;

    my $set = $num / $self->pages_per_set;
    if(int($set) != $set) {
        return int($set) + 1;
    }

    return $set;
}

sub skipped {
    my $self = shift;

    my $skipped = $self->first - 1;
    return 0 if $skipped < 0;
    return $skipped;
}

sub splice {
    my ($self, $array) = @_;

    my $top = @$array > $self->last ? $self->last : @$array;
    return () if $top == 0;    # empty
    return @{$array}[ $self->first - 1 .. $top - 1 ];
}

1;