File Coverage

blib/lib/Data/Page.pm

Criterion	Covered	Total	%
statement	83	83	100.0
branch	33	34	97.0
condition	6	6	100.0
subroutine	19	19	100.0
pod	14	14	100.0
total	155	156	99.3

package Data::Page; # git description: v2.04-3-gaabb6e5
# ABSTRACT: Help when paging through sets of results
use Carp ();
use strict;
use warnings;
use base 'Class::Accessor::Chained::Fast';
__PACKAGE__->mk_accessors(qw(total_entries entries_per_page current_page));

our $VERSION = '2.05'; # TRIAL

sub new {
    my $class = shift;
    my $self  = {};
    bless( $self, $class );

    my ( $total_entries, $entries_per_page, $current_page ) = @_;
    $self->total_entries( $total_entries       || 0 );
    $self->entries_per_page( $entries_per_page || 10 );
    $self->current_page( $current_page         || 1 );
    return $self;
}

sub entries_per_page {
    my $self             = shift;
    if (@_) {
        Carp::croak("Fewer than one entry per page!") if $_[0] < 1;
        return $self->_entries_per_page_accessor(@_);
    }
    return $self->_entries_per_page_accessor();
}

sub current_page {
    my $self = shift;
    if (@_) {
        my $cp = $_[0];
        my $fp = $self->first_page;
        return $self->_current_page_accessor($fp) if $cp < $fp;
        my $lp = $self->last_page;
        return $self->_current_page_accessor($lp) if $cp > $lp;
        return $self->_current_page_accessor(@_);
    }
    return $self->_current_page_accessor;
}

sub total_entries {
    my $self = shift;
    if (@_) {
        return $self->_total_entries_accessor(@_);
    }
    return $self->_total_entries_accessor;
}

sub entries_on_this_page {
    my $self = shift;

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

sub first_page {
    my $self = shift;

    return 1;
}

sub last_page {
    my $self = shift;

    my $pages = $self->_total_entries_accessor / $self->_entries_per_page_accessor;
    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 first {
    my $self = shift;

    if ( $self->_total_entries_accessor == 0 ) {
        return 0;
    } else {
        return ( ( $self->_current_page_accessor - 1 ) * $self->_entries_per_page_accessor ) + 1;
    }
}

sub last {
    my $self = shift;

    if ( $self->_current_page_accessor == $self->last_page ) {
        return $self->_total_entries_accessor;
    } else {
        return ( $self->_current_page_accessor * $self->_entries_per_page_accessor );
    }
}

sub previous_page {
    my $self = shift;

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

sub next_page {
    my $self = shift;

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

# This method would probably be better named 'select' or 'slice' or
# something, because it doesn't modify the array the way
# CORE::splice() does.
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 ];
}

sub skipped {
    my $self = shift;

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

sub change_entries_per_page {
    my ( $self, $new_epp ) = @_;

    use integer;
    Carp::croak("Fewer than one entry per page!") if $new_epp < 1;
    my $new_page = 1 + ( $self->first / $new_epp );
    $self->entries_per_page($new_epp);
    $self->current_page($new_page);
}

1;

__END__