File Coverage

blib/lib/Text/CSV/BulkData.pm

Criterion	Covered	Total	%
statement	99	110	90.0
branch	33	40	82.5
condition	13	17	76.4
subroutine	15	17	88.2
pod	0	9	0.0
total	160	193	82.9

package Text::CSV::BulkData;

use strict;
use vars qw($VERSION);
our $VERSION = '0.06';

use Carp;

sub new {
    my ($class, $output_file, $format) = @_;
    bless {
        output_file   => $output_file,
        format        => $format,
        residue_loop  => 1,
    }, $class;
}

sub set_residue_loop_off {
    my ($self, $output_file) = @_;
    $self->{residue_loop} = 0;
    return $self;
}

sub set_output_file {
    my ($self, $output_file) = @_;
    $self->{output_file} = $output_file;
    return $self;
}

sub set_format {
    my ($self, $format) = @_;
    $self->{format} = $format;
    return $self;
}

sub set_pattern {
    my $self = shift;
    $self->{pattern} = shift;
    return $self;
}

sub set_start {
    my ($self, $start) = @_;
    $self->{start} = $start;
    return $self;
}

sub set_end {
    my ($self, $end) = @_;
    $self->{end} = $end;
    return $self;
}

sub initialize {
    my $self = shift;
    my $output_file = $self->{output_file};
    unlink $output_file or croak $! if -f $output_file;
    return $self;
}

sub make {
    my $self = shift;
    my ($output_file, $start, $end, $format, $pattern ) =
        ( $self->{output_file}, $self->{start}, $self->{end}, $self->{format}, $self->{pattern} );
    my $debug_ary_ref;

    open FH, ">> $output_file" or croak $!;
    for (my $i = $start; $i <= $end; $i++){
        my @input = ();
        for (my $j = 0; $j < ($format =~ s/%/%/g); $j++) {
            my $pattern = $$pattern[$j];
            if ( ! defined $pattern ) {
                push @input, $i;
                next;
            } elsif ( $pattern !~ m/^[%\/\*\+-]/ ) {
                push @input, $pattern;
                next;
            }
            push @input, $self->_calculate($pattern, $i, 0);
        }
        $self->{debug}
            ? push @$debug_ary_ref, sprintf $format, @input
            : printf FH $format, @input;
    }
    close FH;

    $self->{debug}
        ? return $debug_ary_ref
        : return $self;
}

sub _calculate {
    my ($self, $pattern, $i, $flag) = @_;
    if ( ! $flag && $self->_is_recursive_start($pattern) ) {
        $pattern =~ m{^(\d+)[^0-9]};
        $self->{pattern} = $pattern;
        $self->{before} = $1;
        $pattern =~ s{^\d+([^0-9])}{$1};
        return $self->_calculate($pattern, $i, 1);
    }

    if ( $pattern =~ m{\*(\d+)} ) {
        if ( $flag eq 1) {
            my $res = $self->{before} * $1;
            $res = $self->_recursive_calc($res);
            $pattern = $self->_return_substituted('^\d+\*\d+', $res);
        } else {
            my $res = $i * $1;
            $pattern =~ s{\*\d+}{$res};
        }
        $self->_calculate($pattern, $i, 0);
    } elsif ( $pattern =~ m{/(\d+)} ) {
        if ( $flag eq 1) {
            my $res = int($self->{before} / $1);
            $res = $self->_recursive_calc($res);
            $pattern = $self->_return_substituted('^\d+/\d+', $res);
        } else {
            my $res = int($i / $1);
            $pattern =~ s{/\d+}{$res};
        }
        $self->_calculate($pattern, $i, 0);
    } elsif ( $pattern =~ m{%(\d+)} ) {
        $self->{residue_loop} = $1 if $self->{residue_loop};
        if ( $flag eq 1) {
            my $res = $self->{before} % $1;
            $res = $self->_recursive_calc($res);
            $pattern = $self->_return_substituted('^\d+%\d+', $res);
        } else {
            my $res = $i % $1;
            $pattern =~ s{%\d+}{$res};
        }
        $self->_calculate($pattern, $i, 0);
    } elsif ( $pattern =~ m{\+(\d+)} ) {
        if ( $flag eq 1) {
            my $res = $self->{before} + $1;
            $res = $self->_recursive_calc($res);
            $pattern = $self->_return_substituted('^\d+\+\d+', $res);
        } else {
            my $res = $i + $1;
            $pattern =~ s{\+\d+}{$res};
        }
        $self->_calculate($pattern, $i, 0);
    } elsif ( $pattern =~ m{-(\d+)} ) {
        if ( $flag eq 1) {
            my $res = $self->{before} - $1;
            $res = $self->_recursive_calc($res);
            $pattern = $self->_return_substituted('^\d+-\d+', $res);
        } else {
            my $res = $i - $1;
            $pattern =~ s{-\d+}{$res};
        }
        $self->_calculate($pattern, $i, 0);
    } else {
        delete $self->{pattern}, $self->{before};
        $self->{residue_loop} = 1;
        return $pattern;
    }
}

sub _recursive_calc {
    my ($self, $res) = @_;
    if ( defined $self->{residue_loop}
         && $self->{residue_loop} > 1
         && ($res < 0 || $res > $self->{residue_loop})
       ) {
        $res += $self->{residue_loop};
    }
    return $res;
}

sub _return_substituted {
    my ($self, $regexp, $res) = @_;
    $self->{pattern} =~ s{$regexp}{$res};
    return $self->{pattern};
}

sub _is_recursive_start {
    my $self = shift;
    my $pattern = shift;
    ( $pattern =~ /^\d+/ && $pattern !~ /^\d+$/ ) ? return 1 : return 0;
}

sub _set_debug {
    my $self = shift;
    $self->{debug} = 1;
    return $self;
}

1;
__END__