File Coverage

blib/lib/Data/Page/Balanced.pm

Criterion	Covered	Total	%
statement	61	65	93.8
branch	20	22	90.9
condition	7	8	87.5
subroutine	11	11	100.0
pod	4	4	100.0
total	103	110	93.6

# $Id: Balanced.pm 2 2007-10-27 22:08:58Z kim $

package Data::Page::Balanced;

use warnings;
use strict;
use Carp;
use POSIX qw(ceil floor);
use base qw(Class::Accessor::Chained::Fast Data::Page);
use version; our $VERSION = qv('1.0.0');

__PACKAGE__->mk_accessors(qw(flexibility));

sub new {
	my ($class, $arg_ref) = @_;
	my $self = {};

	croak('total_entries and entries_per_page must be supplied.')
		if  !defined $arg_ref->{'total_entries'}
		||  !defined $arg_ref->{'entries_per_page'};

	croak( sprintf 'There must be at least one entry per page. %d is too small.', $arg_ref->{'entries_per_page'} )
		if $arg_ref->{'entries_per_page'} < 1;

	bless $self, $class;

	# flexibility can be 0, which is false, so can't use ||-assignment
	my $flexibility = exists $arg_ref->{flexibility} ? $arg_ref->{flexibility} : floor($arg_ref->{entries_per_page} / 2);

	$self->_flexibility_accessor(       $flexibility                    );
	$self->_total_entries_accessor(     $arg_ref->{total_entries}       );
	$self->_current_page_accessor(      $arg_ref->{current_page} || 1   );
	$self->_entries_per_page_accessor(  $arg_ref->{entries_per_page}    );
	$self->_entries_per_page_accessor(  $self->_get_balanced_epp()      );

	return $self;
}

# Calculate the entries_per_page (expected_epp) within the limits of the flexibility
sub _get_balanced_epp {
	my ($self) = @_;

	my $flexibility         = $self->flexibility();
	my $total_entries       = $self->total_entries();
	my $entries_per_page    = $self->entries_per_page();

	return $entries_per_page
		if $flexibility     == 0
		|| $total_entries   == 0;

	return $entries_per_page
	    if $total_entries < $entries_per_page;

	my $pages           = ceil($total_entries / $entries_per_page);
	my $expected_epp    = $total_entries / $pages;

	ENTRIES: while ( $expected_epp < $entries_per_page ) {
		$pages--;

		if ( $pages < 1 ) {
		    $pages = 1;
		}

		$expected_epp = $total_entries / $pages;

		if ( $expected_epp > $entries_per_page + $flexibility ) {
			$expected_epp = $entries_per_page;
			last ENTRIES;
		}
	}

	return ceil($expected_epp);
}

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

	if ( defined $total_entries ) {
		my $accessor = $self->_total_entries_accessor($total_entries);
		$self->_entries_per_page_accessor( $self->_get_balanced_epp() );
		return $accessor;
	}

	return $self->_total_entries_accessor();
}

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

	if ( defined $entries_per_page ) {
		croak( sprintf 'There must be at least one entry per page. %d is too small.', $entries_per_page )
		    if $entries_per_page < 1;

		$self->_entries_per_page_accessor($entries_per_page);
		return $self->_entries_per_page_accessor( $self->_get_balanced_epp() );
	}

	return $self->_entries_per_page_accessor();
}

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

	if ( defined $flexibility ) {
		my $accessor = $self->_flexibility_accessor($flexibility);
		$self->_entries_per_page_accessor( $self->_get_balanced_epp() );
		return $accessor;
	}

	return $self->_flexibility_accessor();
}


1;
__END__