File Coverage

blib/lib/Directory/Iterator/PP.pm

Criterion	Covered	Total	%
statement	68	68	100.0
branch	26	32	81.2
condition	5	6	83.3
subroutine	14	14	100.0
pod	9	9	100.0
total	122	129	94.5

package Directory::Iterator::PP;

use strict;
use Carp;
use File::Spec;

our $VERSION = '1.001004';

sub new {
    my $class = shift;
    my $dir = shift;

    my $sep = File::Spec->join('x','x');
    $dir =~ s:$sep$::;

    $sep =~ y/x//d;
    my %self = (file=>undef, dir=>$dir, dirs=>[], ds=>$sep, recurse=>1);
    opendir($self{dh},$dir) or croak "$dir: $!";
    bless \%self, $class;
}

sub show_dotfiles {
    my $self = shift;
    my $arg = shift;
    $self->{show_dotfiles} = $arg? 1 : 0;
}

sub show_directories {
    my $self = shift;
    my $arg = shift;
    $self->{show_directories} = $arg? 1 : 0;
}

sub recursive {
	my $self = shift;
	my $arg = shift;
	$self->{recurse} = $arg;
}

sub get {
    my $self = shift;
    return $self->{file};
}

sub _scan {
    my $self = shift;
    while (my $de = readdir $self->{dh}) {
		if ($self->{show_dotfiles}) {
			next if ($de eq '.' or $de eq '..');
		} else {
			next if ( $de =~ m/^\./ );
		}
		my $path = File::Spec->join("$self->{dir}", $de);
		return undef unless lstat($path);
		if ( -d _ and ! -l _ ) {
			push @{$self->{dirs}}, $path
			  if $self->{recurse};

			if ($self->{show_directories}) {
				$self->{is_dir} = 1;
				return $self->{file} = $path;
			}
		}
		elsif ( -f _ ) {
			$self->{is_dir} = undef;
			return $self->{file} = $path;
		}
	}
    return undef;
}

sub is_directory {
	return $_[0]{is_dir};
}

sub prune_directory {
	my $self = shift;
	pop @{$self->{dirs}};
}

sub next {
  my $self = shift;

  if ($self->{dh}) {
    my $rv = $self->_scan;
    if( defined $rv ) {
      return $rv;
    }
    else {
      $self->{dh} = undef;
    }
  }

  while ( @{ $self->{dirs} } ) {
    $self->{dir} = pop @{ $self->{dirs} };
    opendir( $self->{dh}, $self->{dir} ) or carp "$self->{dir}: $!";
    if ( $self->{dh} ) {
      my $rv = $self->_scan;
      return $rv if defined $rv;
    }
  }
  return undef;
}

sub prune {
    my $self = shift;
    undef $self->{dh};

    # while ($self->{dirs}[-1] =~ m/$self->{dir}$self->{sep}/) {
	# 	pop @{ $self->{dirs} };
    # }
}

use overload '<>' => \&next, '""' => \&get;
1;

__END__