File Coverage

blib/lib/Data/Pageset/Exponential.pm

Criterion	Covered	Total	%
statement	103	103	100.0
branch	21	22	95.4
condition			n/a
subroutine	28	28	100.0
pod	9	12	75.0
total	161	165	97.5

package Data::Pageset::Exponential;

# ABSTRACT: Page numbering for very large page numbers

use v5.10.1;

use Moo;

use List::Util 1.33 qw/ all min /;
use PerlX::Maybe;
use POSIX qw/ ceil floor /;
use MooX::Aliases;
use MooX::TypeTiny;
use Types::Common::Numeric qw/ PositiveOrZeroInt PositiveInt /;
use Types::Standard qw/ is_Int Int ArrayRef is_HashRef /;


use asa 'Data::Page';

use namespace::autoclean;

# RECOMMEND PREREQ: Type::Tiny::XS
# RECOMMEND PREREQ: Ref::Util::XS

our $VERSION = 'v0.3.1';


has total_entries => (
    is      => 'rw',
    isa     => PositiveOrZeroInt,
    default => 0,
);


has entries_per_page => (
    is      => 'rw',
    isa     => PositiveInt,
    default => 10,
);


has first_page => (
    is      => 'ro',
    isa     => Int,
    default => 1,
);


has current_page => (
    is      => 'rw',
    isa     => Int,
    lazy    => 1,
    default => \&first_page,
    coerce  => sub { floor( $_[0] // 0 ) },
);


has exponent_base => (
    is      => 'ro',
    isa     => PositiveInt,
    default => 10,
);


has exponent_max => (
    is      => 'ro',
    isa     => PositiveInt,
    default => 3,
);


has pages_per_exponent => (
    is      => 'ro',
    isa     => PositiveInt,
    default => 3,
);


has pages_per_set => (
    is      => 'lazy',
    isa     => PositiveInt,
    alias   => 'max_pages_per_set',
    builder => sub {
        my ($self) = @_;
        use integer;
        my $n = $self->pages_per_exponent * ( $self->exponent_max + 1 );
        return ($n - 1) * 2 + 1;
    },
);


has series => (
    is      => 'lazy',
    isa     => ArrayRef [Int],
    builder => sub {
        my ($self) = @_;

        use integer;

        my @series;

        my $n = $self->exponent_base;
        my $m = $self->exponent_max;

        my $j = 0;
        while ( $j <= $m ) {

            my $i = $n**$j;
            my $a = $i;
            my $p = $self->pages_per_exponent;

            while ( $p-- ) {
                push @series, $a - 1;
                $a += $i;
            }

            $j++;

        }

        my @prevs = map { -$_ } reverse @series[1..$#series];


        return [@prevs, @series];
    },
);

around current_page => sub {
    my $next = shift;
    my $self = shift;

    # N.B. unlike Data::Page, setting a value outside the first_page
    # or last_page will not return that value.

    my $page = $self->$next(@_);

    return $self->first_page if $page < $self->first_page;

    return $self->last_page if $page > $self->last_page;

    return $page;
};


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

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


sub last_page {
    my ($self) = @_;
    return $self->total_entries
      ? ceil( $self->total_entries / $self->entries_per_page )
      : $self->first_page;
}


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


sub last {
    my ($self) = @_;
    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) = @_;
    my $page = $self->current_page;

    return $page > $self->first_page
      ? $page - 1
      : undef;
}


sub next_page {
    my ($self) = @_;
    my $page = $self->current_page;

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


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

    my $last = min( $self->last, scalar(@$items) );

    return $last
      ? @{$items}[ $self->first - 1 .. $last - 1 ]
      : ();
}


sub skipped {
    my ($self) = @_;
    return $self->total_entries
        ? $self->first - 1
        : 0;
}

# Ideally, we'd use a trigger instead, but Moo does not pass the old
# value to a trigger.

around entries_per_page => sub {
    my $next = shift;
    my $self = shift;

    if (@_) {

        my $value = shift;

        my $first = $self->first;

        $self->$next($value);

        $self->current_page( $self->first_page + $first / $value );

        return $value;
    }
    else {

        return $self->$next;

    }
};


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

    use integer;

    my $first = $self->first_page;
    my $last  = $self->last_page;
    my $page  = $self->current_page;

    return [
        grep { $first <= $_ && $_ <= $last }
        map { $page + $_ } @{ $self->series }
    ];
}


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

    my $page = $self->current_page - (2 * $self->pages_per_exponent) - 1;
    return $page < $self->first_page
        ? undef
        : $page;
}


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

    my $page = $self->current_page + (2 * $self->pages_per_exponent) - 1;
    return $page > $self->last_page
        ? undef
        : $page;
}


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

    $self->entries_per_page($value);

    return $self->current_page;
}


sub BUILDARGS {
    my ( $class, @args ) = @_;

    if (@args == 1 && is_HashRef(@args)) {
        return $args[0];
    }

    if ( @args && ( @args <= 3 ) && all { is_Int($_) } @args ) {

        return {
                  total_entries    => $args[0],
            maybe entries_per_page => $args[1],
            maybe current_page     => $args[2],
        };

    }

    return {@args};
}


1;

__END__