File Coverage

blib/lib/Data/LineBuffer.pm

Criterion	Covered	Total	%
statement	38	40	95.0
branch	14	18	77.7
condition	2	6	33.3
subroutine	10	11	90.9
pod	4	5	80.0
total	68	80	85.0

package Data::LineBuffer;

use strict;
use warnings;

our $VERSION = '0.01';

sub new
{
  my $class = shift;
  $class = ref($class) || $class;

  my $self = bless { cache => [],
		     line => 1 }, $class;



  # we use closures like mad here to make a uniform definition
  # of the  get method possible.

  # Don't shift next argument; need to get a reference
  # to it if it's a scalar.

  my $what = $_[0];

  # scalar? split on newlines
  unless  ( ref $_[0]  )
  {
    my $sref = \$_[0];

    pos( $$sref ) = 0;

    $self->{next} =
      sub {
	defined pos($$sref) ? scalar $$sref =~ /^(.*)$/mg && $1 : undef
      };
  }

  # array? grab the next element
  elsif ( 'ARRAY'  eq ref($what)  )
  {
    my $idx = 0;
    $self->{next} =
      sub { $idx == @$what ? undef : $what->[$idx++] };
  }

  # glob (we're assuming file glob)? read next line
  elsif ( 'GLOB'   eq ref($what)  )
  {
    $self->{next} = sub { scalar <$what> };
  }

  # subroutine? call it
  elsif ( 'CODE'   eq ref($what)  )
  {
    $self->{next} = $what;
  }

  # file handle? read next line
  elsif ( UNIVERSAL::isa($what, 'IO::File')  )
  {
    $self->{next} = sub { scalar <$what> };
  }

  else
  {
    undef $self;
  }

  $self;
}

sub pos { $_[0]->{line} }

sub unget
{
  my $self = shift;
  push @{$self->{cache}}, @_;

  $self->{line} -= @_;
}

sub get
{
  my $self = shift;

  my $ret = pop @{$self->{cache}};

  $ret = &{$self->{next}}
    unless defined $ret;

  if ( defined $ret )
  {
    $self->{line}++;
    chomp $ret;
  }

  $ret;
}

sub cache { $_[0]->{cache} };



1;
__END__