File Coverage

blib/lib/Data/Record/Serialize/Role/Sink/Stream.pm

Criterion	Covered	Total	%
statement	40	41	97.5
branch	14	18	77.7
condition	9	18	50.0
subroutine	9	9	100.0
pod	1	1	100.0
total	73	87	83.9

package Data::Record::Serialize::Role::Sink::Stream;

# ABSTRACT: output encoded data to a stream.

use v5.12;
use Scalar::Util;
use Moo::Role;

use Data::Record::Serialize::Error { errors => [ '::create', '::parameter', '::internal' ] }, -all;
use Types::Standard qw[ Bool ];

our $VERSION = '2.02';

use IO::File;

use namespace::clean;

## no critic( NamingConventions::ProhibitAmbiguousNames )
## no critic( Subroutines::ProhibitBuiltinHomonyms )






























has output => (
    is      => 'ro',
    default => q{-},
    isa     => sub {
        defined $_[0]
          or error( '::parameter', q{'output' parameter must be defined} );
        my $ref = ref $_[0];
        return if $ref eq 'GLOB' or $ref eq 'SCALAR';

        if ( $ref eq q{} ) {
            $ref = ref( \$_[0] );    # turn plain *STDOUT into \*STDOUT
            return if $ref eq 'GLOB';
            return if length $_[0];
            error( '::parameter', q{string 'output' parameter must not be empty} );
        }

        return
          if Scalar::Util::blessed $_[0]
          and $_[0]->isa( 'IO::Handle' ) || $_[0]->isa( 'FileHandle' );
        error( '::parameter', q{illegal value for 'output' parameter} );
    },
);







has fh => (
    is        => 'lazy',
    init_arg  => undef,
    clearer   => 1,
    predicate => 1,
);







has _passed_fh => (
    is       => 'rwp',
    init_arg => undef,
    default  => 1,
);

sub _build_fh {
    my $self = shift;

    my $output = $self->output;
    my $ref    = ref $output;

    # filename
    if ( $ref eq q{} ) {
        return $output  if ref( \$output ) eq 'GLOB';
        return \*STDOUT if $output eq q{-};

        $self->_set__passed_fh( 0 );
        if ( $self->create_output_dir ) {
            require Path::Tiny;
            my $dir = Path::Tiny::path( $output )->parent;
            eval { $dir->mkdir; } or error( '::create', "unable to create output directory '$dir': $@" );
        }
        return (
            IO::File->new( $output, 'w' )
              or error( '::create', "unable to create output file: '$output'" ) );
    }

    return $output
      if $ref eq 'GLOB'
      or Scalar::Util::blessed( $output )
      && ( $output->isa( 'IO::Handle' ) || $output->isa( 'FileHandle' ) );

    $self->_set__passed_fh( 0 );
    return (
        IO::File->new( $output, 'w' )
          or error( '::create', q{unable to open scalar for output} ) ) if $ref eq 'SCALAR';

    error( '::internal', q{can't get here} );
}








has create_output_dir => (
    is      => 'ro',
    isa     => Bool,
    default => 0,
);

























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

    # don't bother closing the FH in global destruction (it'll be done
    # on its own) or if we were passed a file handle in the output
    # attribute.
    return if $in_global_destruction or $self->_passed_fh;

    # fh is lazy, so the object may close without every using it, so
    # don't inadvertently create it.
    $self->fh->close if $self->has_fh;
    $self->clear_fh;
}

1;

#
# This file is part of Data-Record-Serialize
#
# This software is Copyright (c) 2017 by Smithsonian Astrophysical Observatory.
#
# This is free software, licensed under:
#
#   The GNU General Public License, Version 3, June 2007
#

__END__