File Coverage

blib/lib/Data/Pager.pm

Criterion	Covered	Total	%
statement	88	90	97.7
branch	21	30	70.0
condition	13	17	76.4
subroutine	15	15	100.0
pod	5	6	83.3
total	142	158	89.8

package Data::Pager;
use strict;
use Carp;
use POSIX qw(ceil);
use vars qw($VERSION);

$VERSION = '0.01';

sub new {
    my $class = shift;
    my $data  = shift;
    my $self  = {};

    $class ne __PACKAGE__
      and croak "class " . __PACKAGE__ . " constructor is not static";

    $self->{data}{fields} = $data;

    bless $self, $class;

    $self->__init($data);

    return $self;
}

sub __init {
    my $self = shift;
    my $data = shift || {};

    my $current = $data->{'current'} || 1;
    my $offset  = $data->{'offset'}  || 10;
    my $links   = $data->{'perpage'} || 10;
    my $limit   = $data->{'limit'}   || 0;

    $self->{'tmp'} = { links => $links };

    $links % 2 or $links += 1;

    my $middle = int( $links / 2 );
    my %pager  = ();
    my %tmp    = ();
    my @pager  = ();

    return undef
      if $current * $offset - $offset + 1 > $limit;

    for my $i ( $current .. $current + $middle ) {
        $pager{$i}++ if $i * $offset - $offset < $limit;
    }
    for my $i ( $current - $middle .. $current ) {
        $pager{$i}++ if $i > 0;
    }

    if ( scalar keys %pager < $links and $current < 5 ) {
        while ( $middle++ < $links - 1 ) {
            $middle > $limit
              and last;
            exists( $pager{$middle} )
              or $pager{$middle}++;
        }
    }

    %tmp   = %pager;
    %pager = ();

    for my $pos ( sort { $a <=> $b } keys %tmp ) {
        $pos == $current
          and $pager{'current'} = $pos;
        $pager{$pos} = {
            'prev' => $pos - 1 ? $pos - 1 : undef,
            'next' => $pos * $offset >= $limit ? undef: $pos + 1,
            'from' => $offset * $pos - $offset,
            'to'   => $offset * $pos,
        };
        push @pager, $pos;
    }

    $pager{'limit'}  = $limit;
    $pager{'list'}   = \@pager;
    $pager{'last'}   = $pager[-1];
    $pager{'first'}  = $pager[0];
    $pager{'start'}  = 1;
    $pager{'end'}    = $self->final;
    $pager{'offset'} = $offset;
    $pager{'links'}  = $self->{'tmp'}->{'links'};
    $pager{'prev'}   = $pager{ $pager{'current'} }->{'prev'} || undef;
    $pager{'next'}   = $pager{ $pager{'current'} }->{'next'} || undef;

    $self->{'data'} = \%pager;

}

sub list {
    no strict 'refs';
    my $self = shift;
    wantarray
      ? @{ $self->{data}{list} }
      : \@{ $self->{data}{list} };
}

for my $method (qw(start first last set_current current prev next offset limit links))
{
    no strict 'refs';
    *$method = sub {
        my $self  = shift;
        my $value = shift;
        if ( $method eq 'set_current' ) {
            if ( $value > 0 ) {
                $self->{data}{current} = $value;
                $self->__init( $self->{data} );
				if ( $self->current eq $value ) {
					return $self;
				}
				else {
					return undef;
				}
            }
        }
        return $self->{data}{$method};
    };
}

sub from {
	my $self = shift;
    $self->{'data'}->{ $self->current }{'from'};
}

sub to {
	my $self = shift;
    $self->{'data'}->{ $self->current }{'to'};
}

sub final {
    my $self = shift;
	no warnings;
    return eval { ceil( $self->limit / $self->offset ) };
}

sub end { shift->final }

1;

__END__