File Coverage

blib/lib/Data/Page.pm

Criterion	Covered	Total	%
statement	79	79	100.0
branch	35	36	97.2
condition	6	6	100.0
subroutine	18	18	100.0
pod	14	14	100.0
total	152	153	99.3

package Data::Page; # git description: 090534c
use Carp;
use strict;
use base 'Class::Accessor::Chained::Fast';
__PACKAGE__->mk_accessors(qw(total_entries entries_per_page current_page));

our $VERSION = '2.03';

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;
    my $entries_per_page = $_[0];
    if (@_) {
        croak("Fewer than one entry per page!") if $entries_per_page < 1;
        return $self->_entries_per_page_accessor(@_);
    }
    return $self->_entries_per_page_accessor();
}

sub current_page {
    my $self = shift;
    if (@_) {
        return $self->_current_page_accessor(@_);
    }
    return $self->first_page unless defined $self->_current_page_accessor;
    return $self->first_page
        if $self->_current_page_accessor < $self->first_page;
    return $self->last_page
        if $self->_current_page_accessor > $self->last_page;
    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 == 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 / $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 first {
    my $self = shift;

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

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 previous_page {
    my $self = shift;

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

sub next_page {
    my $self = shift;

    $self->current_page < $self->last_page ? $self->current_page + 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;
    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__