File Coverage

blib/lib/Data/Tabulate.pm

Criterion	Covered	Total	%
statement	99	99	100.0
branch	38	38	100.0
condition	27	27	100.0
subroutine	16	16	100.0
pod	10	10	100.0
total	190	190	100.0

package Data::Tabulate;

use warnings;
use strict;
use Carp;

# ABSTRACT: Table generation!

our $VERSION = 0.09;


sub new {
    my ($class) = @_;

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

    $self->max_columns(100_000);
    $self->min_columns(1);

    return $self;
}


sub render {
    my ($self,$module,$atts) = @_;

    if ( !$self->{tabulated} and ! (
        defined $atts and ref($atts) eq 'HASH' and
        exists $atts->{data} and ref($atts->{data}) eq 'ARRAY'
    ) ) {
        croak "no data given";
    }

    if ( !$module ) {
        croak "no renderer module given";
    }

    my @data = @{$atts->{data} || []};
    my $tmp  = $module;
    $module  = 'Data::Tabulate::Plugin::'.$module;

    $self->_load_module($module);

    my @table = $self->tabulate(@data) if @data;

    if ( !@table ) {
        @table = @{ $self->{tabulated} || [] };
    }

    my $plugin_obj = $module->new();

    for my $method(@{$self->{method_calls}->{$tmp}}){
        if(!$plugin_obj->can($method->[0])){
            croak 'renderer does not know ' . $method->[0];
        }
        else {
            no strict 'refs';
            my $method_name = $method->[0];
            my @params      = @{$method->[1]};
            $plugin_obj->$method_name(@params);
        }

    }

    if ( !$plugin_obj->can('output') ) {
        croak "renderer $module does not have an output method";
    }

    return $plugin_obj->output(@table);
}


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

    $self->{tabulated} = undef;

    return if !@data;

    my $nr   = scalar @data;
    my $cols = int sqrt $nr;

    # the calculated number of columns should not exceed the maximum
    # number of columns that the user has specified
    if($cols > $self->max_columns){
        $cols = $self->max_columns;
    }

    # the calculated number of columns should be greater the minimum
    # number of columns that the user has specified
    if($cols < $self->min_columns){
        $cols = $self->min_columns;
    }

    $self->{cols} = $cols;

    my $index = $cols - 1;

    # tabulate data
    my @tmp_data;
    while ( $index < $nr ) {
        my $start = $index - $cols + 1;
        push @tmp_data, [ @data[ $start .. $index ] ];
        $index += $cols;
    }

    my $fill_value = $self->{fill_value};

    my $rest = ($cols - ($nr % $cols)) % $cols;
    $self->{rest} = $rest;
    if($rest > 0){

        my $start = $nr - ($cols - $rest);
        my $end   = $nr - 1;

        push @tmp_data, [
            @data[$start..$end],
            ($fill_value) x $rest,
        ];
    }

    $self->{rows} = scalar @tmp_data;
    $self->{tabulated} = \@tmp_data;

    return @tmp_data;
}


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

    $self->{fill_value} = $value;
}


sub cols{
    my ($self) = @_;
    return $self->{cols};
}


sub rows{
    my ($self) = @_;
    return $self->{rows};
}


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

    $self->{max_cols} = $value if defined $value and $value =~ /^[1-9]\d*$/;

    my $caller = (caller(1))[3];
    if ( !( ($caller and $caller =~ /min_columns/) or not defined $self->min_columns) ) {
        $self->min_columns($self->{max_cols}) if $self->{max_cols} < $self->min_columns;
    }

    return $self->{max_cols};
}


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

    $self->{min_cols} = $value if defined $value and $value =~ /^[1-9]\d*$/;

    my $caller = (caller(1))[3];
    if ( !( $caller and $caller =~ /max_columns/) ){
        $self->max_columns($self->{min_cols}) if $self->{min_cols} > $self->max_columns;
    }

    return $self->{min_cols};
}


sub do_func{
    my ($self,$module,$method,@params) = @_;

    push @{$self->{method_calls}->{$module}},[$method,[@params]];
}


sub reset_func{
    my ($self,$module) = @_;
    delete $self->{method_calls}->{$module};
}


#------------------------------------------------------------------------------#
#                      "private" methods                                       #
#------------------------------------------------------------------------------#

sub _load_module {
    my ($self,$module) = @_;
    eval "use $module";
    croak "could not load $module" if $@;
}

1; # End of Data::Tabulate

__END__