File Coverage

blib/lib/Data/Tabulate.pm

Criterion	Covered	Total	%
statement	59	90	65.5
branch	16	28	57.1
condition	13	24	54.1
subroutine	11	16	68.7
pod	10	10	100.0
total	109	168	64.8

package Data::Tabulate;

use warnings;
use strict;
use Carp;

# ABSTRACT: Table generation!

our $VERSION = '0.07';


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) = @_;

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

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

    $self->_load_module($module);

    @data          = $self->_data() unless @data;
    my @table      = $self->tabulate(@data);
    my $plugin_obj = $module->new();

    for my $method(@{$self->{method_calls}->{$tmp}}){
        if($plugin_obj->can($method->[0])){
            no strict 'refs';
            my $method_name = $method->[0];
            my @params      = @{$method->[1]};
            $plugin_obj->$method_name(@params);
        }
    }

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


sub tabulate {
    my ($self,@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;

    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];
    unless( ($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];
    unless( $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 $@;
}

sub _data{
    my ($self,@data) = @_;
    $self->{data} = [@data] if @data;
    return @{$self->{data}};
}

1; # End of Data::Tabulate

__END__