File Coverage

blib/lib/Data/Pageset/Exponential.pm

Criterion	Covered	Total	%
statement	133	133	100.0
branch	21	22	95.4
condition			n/a
subroutine	28	28	100.0
pod	9	12	75.0
total	191	195	97.9

package Data::Pageset::Exponential;

# ABSTRACT: Page numbering for very large page numbers

use v5.20;

use Moo;

use List::Util 1.33 qw( all min );
use PerlX::Maybe    qw( maybe );
use POSIX           qw( ceil floor );
use MooX::Aliases;
use MooX::TypeTiny;
use Types::Common 2.000000 qw( is_Int Int ArrayRef is_HashRef PositiveOrZeroInt PositiveInt );

use experimental qw( postderef signatures );


use asa 'Data::Page';

use namespace::autoclean;

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

our $VERSION = 'v0.4.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($val) { floor( $val // 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($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($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( $next, $self, @args ) {

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

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

    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($self) {
    if ( $self->total_entries ) {
        return $self->last - $self->first + 1;
    }
    else {
        return 0;
    }
}


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


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


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


sub previous_page($self) {
    my $page = $self->current_page;

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


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

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


sub splice( $self, $items ) {
    my $last = min( $self->last, scalar( $items->@* ) );

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


sub skipped($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( $next, $self, @args ) {
    if (@args) {

        my ($value) = @args;

        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($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($self) {
    my $page = $self->current_page - ( 2 * $self->pages_per_exponent ) - 1;
    return $page < $self->first_page
      ? undef
      : $page;
}


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


sub change_entries_per_page( $self, $value ) {
    $self->entries_per_page($value);

    return $self->current_page;
}


sub BUILDARGS( $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__