File Coverage

blib/lib/Data/Pagination.pm

Criterion	Covered	Total	%
statement	3	39	7.6
branch	0	16	0.0
condition			n/a
subroutine	1	2	50.0
pod	1	1	100.0
total	5	58	8.6

package Data::Pagination;

use strict;

our $VERSION = '0.44';

# {{{ new()

# Constructor.
# Making all calculations and storing results at class properties.
# Param int $total_entries Total number of entries (>= 1)
# Param int $entries_per_page Number of entries per page (>= 1)
# Param int $pages_per_set Number of pages per set (>= 1)
# Param int $current_page Current number of page

sub new {
    my ($class, $total_entries, $entries_per_page, $pages_per_set, $current_page) = @_;

    my $self = bless {} => $class;

    # total number of entries (>= 1) (copied from arguments)
    $self->{total_entries} = $total_entries;

    # number of entries per page (>= 1) (copied from arguments)
    $self->{entries_per_page} = $entries_per_page;

    # number of pages per set (>= 1) (copied from arguments)
    $self->{pages_per_set} = $pages_per_set;

    # total number of pages (>= 1)
    $self->{total_pages} = int(($self->{total_entries} - 1) / $self->{entries_per_page}) + 1;

    # current number of page (>= 1) (corrected)
    $self->{current_page} = $current_page;
    if ($self->{current_page} < 1) {
        $self->{current_page} = 1;
    } elsif ($self->{current_page} > $self->{total_pages}) {
        $self->{current_page} = $self->{total_pages};
    }

    # previous number of page (>= 1 or undef)
    $self->{prev_page} = $self->{current_page} - 1;
    if ($self->{prev_page} < 1) {
        $self->{prev_page} = undef;
    }

    # next number of page (>= 1 or undef)
    $self->{next_page} = $self->{current_page} + 1;
    if ($self->{next_page} > $self->{total_pages}) {
        $self->{next_page} = undef;
    }

    # start position of current set (>= 1)
    $self->{start_of_set} = int(($self->{current_page} - 1) / $self->{pages_per_set}) * $self->{pages_per_set} + 1;

    # end position of current set (>= 1)
    $self->{end_of_set} = $self->{start_of_set} + $self->{pages_per_set} - 1;
    if ($self->{end_of_set} > $self->{total_pages}) {
        $self->{end_of_set} = $self->{total_pages};
    }

    # numbers of set (one or more numbers in array)
    $self->{numbers_of_set} = [];
    for (my $i = $self->{start_of_set}; $i <= $self->{end_of_set}; ++$i) {
        push(@{$self->{numbers_of_set}}, $i);
    }

    # nearest page number of the previous set (>= 1 or undef)
    $self->{page_of_prev_set} = $self->{start_of_set} - 1;
    if ($self->{page_of_prev_set} < 1) {
        $self->{page_of_prev_set} = undef;
    }

    # nearest page number of the next set (>= 1 or undef)
    $self->{page_of_next_set} = $self->{end_of_set} + 1;
    if ($self->{page_of_next_set} > $self->{total_pages}) {
        $self->{page_of_next_set} = undef;
    }

    # starting position of the slice (>= 0)
    $self->{start_of_slice} = ($self->{current_page} - 1) * $self->{entries_per_page};

    # ending position of the slice (>= 0)
    $self->{end_of_slice} = $self->{start_of_slice} + $self->{entries_per_page} - 1;
    if ($self->{end_of_slice} > $self->{total_entries} - 1) {
        $self->{end_of_slice} = $self->{total_entries} - 1;
    }

    # length of the slice (>= 1)
    $self->{length_of_slice} = $self->{end_of_slice} - $self->{start_of_slice} + 1;

    return $self;
}

# }}}

1;

__END__