File Coverage

blib/lib/SVN/Dumpfile/Node/Content.pm

Criterion	Covered	Total	%
statement	72	83	86.7
branch	14	26	53.8
condition	6	15	40.0
subroutine	19	19	100.0
pod	11	11	100.0
total	122	154	79.2

################################################################################
# Copyright (c) 2008 Martin Scharrer
# This is open source software under the GPL v3 or later.
#
# $Id: Content.pm 103 2008-10-14 21:11:21Z martin $
################################################################################
package SVN::Dumpfile::Node::Content;
use IO::File;
use Carp;
use strict;
use warnings;
use Readonly;
Readonly my $NL => chr(10);

our $VERSION = do { '$Rev: 103 $' =~ /\$Rev: (\d+) \$/; '0.13' . ".$1" };

use overload
    '""'     => \&as_string,
    fallback => 1;

sub new {
    my $class  = shift;
    my $scalar = shift;
    my $self   = bless \$scalar, ref $class || $class;
    return $self;
}

sub exists {
    my $self = shift;
    return ( defined $$self and $$self ne '' );
}

sub delete {
    my $self = shift;
    $$self = undef;
    return;
}

sub value : lvalue {
    my $self     = shift;
    my $newvalue = shift;
    $$self = $newvalue
        if defined $newvalue;
    $$self;
}

sub as_string {
    my $self = shift;
    return ( ( defined $$self ) ? $$self : '' );
}

*to_string = \&as_string;

sub read {
    my ( $self, $fh, $length ) = @_;
    return $fh->read( $$self, $length );
}

sub write {
    my $self = shift;
    my $fh   = shift;

    unless ( eval { $fh->isa('IO::Handle') }
        || ref $fh  eq 'GLOB'
        || ref \$fh eq 'GLOB' )
    {
        croak "Given argument is no valid file handle.";
    }

    return ($$self) ? $fh->print($$self) : '0 but true';
}

sub save {
    my ( $self, $fr ) = @_;
    my $fh;
    return unless defined $fr and defined $$self;

    # $fr can be filename or handle
    if ( !ref $fr ) {
        $fh = eval { new IO::File $fr, '>' };
        if ( !$fh ) {
            carp("Can't print to given filename!");
            return;
        }
        $fh->binmode;
    }
    elsif ( eval { $fr->can('print') } ) {
        $fh = $fr;
    }
    else {
        carp("Can't print to given handle!");
        return;
    }
    return $fh->print($$self);
}

sub load {
    use bytes;
    my ( $self, $fr ) = @_;
    my $fh;

    # $fr can be filename or handle
    if ( !ref $fr ) {
        $fh = eval { new IO::File $fr, '<' };
        return unless $fh;
        $fh->binmode;
    }
    elsif ( eval { $fr->can('getlines') } ) {
        $fh = $fr;
    }
    else {
        carp "Can't print to given handle!";
        return;
    }

    $$self = join '', $fh->getlines;
    return bytes::length($$self);
}

sub lines {
    my $self  = shift;
    my $lines = 0;
    $lines = ( $self =~ tr/\012// );
    $lines++ if $self !~ /$NL\Z/m;
    return $lines;    # Count lines
}

sub length {
    use bytes;
    my $self = shift;
    return 0 unless defined $$self;
    return bytes::length $$self;
}

1;
__END__