File Coverage

blib/lib/Mojo/CSV.pm

Criterion	Covered	Total	%
statement	74	75	98.6
branch	24	34	70.5
condition	5	9	55.5
subroutine	17	17	100.0
pod	7	7	100.0
total	127	142	89.4

package Mojo::CSV;

use Carp qw/croak/;
use Mojo::Collection qw/c/;
use Text::CSV;
use Scalar::Util qw/reftype/;

use Moo;
use MooX::ChainedAttributes;
use strictures 2;
use namespace::clean;

our $VERSION = '1.001004'; # VERSION

has in  => (
    is      => 'rw',
    chained => 1,
    coerce => sub { __get_fh( $_[0], '<' ); }
);
has out  => (
    is      => 'rw',
    chained => 1,
    coerce => sub { __get_fh( $_[0], '>' ); }
);
has _obj => (
    is      => 'ro',
    default => sub { Text::CSV->new({ binary => 1 }) },
);

sub __get_fh {
    my ( $what, $how ) = @_;;

    my $fh;
    if ( ref $what eq 'Mojo::Asset::File' ) {
        $fh = $what->handle;
    }
    elsif ( ref $what eq 'Mojo::Asset::Memory' ) {
        open $fh, $how, \ $what->slurp or die $!;
    }
    elsif ( ref $what ) {
        $fh = $what;
    }
    elsif ( defined $what ) {
        open $fh, $how, $what or croak "Failed to open CSV file ($what): $!";
    }
    else {
        croak 'Could not figure out how to access resource';
    }

    return $fh;
}

sub flush {
    my $self = shift;
    close $self->out;

    $self;
}

sub row {
    my $self = shift;
    my $in = $self->in or croak 'You must specify what to read from';
    my $row = $self->_obj->getline( $in ) or return;
    return $row;
}

sub slurp {
    my $self = shift;
    @_ and $self->in( shift );

    my @rows;
    while ( my $r = $self->row ) {
        push @rows, $r;
    }

    return c @rows;
}

sub slurp_body {
    my $self = shift;
    my $r = $self->slurp( @_ );
    return c @$r[ 1 .. $r->size-1 ];
}

sub spurt {
    my $self = shift;
    my $what = shift;
    @_ and $self->out( shift );
    $self->trickle( $_ ) for @$what;
    $self->flush;

    $self;
}

sub text {
    my $self = shift;
    my $what = shift or return '';

    my @out;
    my $obj = $self->_obj;
    if (    reftype $what
            and reftype $what eq 'ARRAY'
            and reftype $what->[0]
            and reftype $what->[0] eq 'ARRAY'
    ) {
        for my $row ( @$what ) {
            $obj->combine( @$row ) or next;
            push @out, $obj->string;
        }
    }
    else {
        $obj->combine( @$what ) and push @out, $obj->string;
    }

    return join "\n", @out;
}

sub trickle {
    my $self = shift;
    my $what = shift or return $self;
    my $out = $self->out or croak 'You must specify where to write';
    my $obj = $self->_obj;
    $obj->combine( @$what ) or return $self;
    print $out $obj->string . "\n";

    $self;
}

q|
    Computers are like air conditioners.
    They work fine until you start opening windows.
|;

__END__