File Coverage

blib/lib/Tree/Simple/Visitor/LoadDirectoryTree.pm

Criterion	Covered	Total	%
statement	59	59	100.0
branch	25	28	89.2
condition	23	26	88.4
subroutine	14	14	100.0
pod	5	5	100.0
total	126	132	95.4

package Tree::Simple::Visitor::LoadDirectoryTree;

use strict;
use warnings;

our $VERSION = '0.14';

use File::Spec;
use Scalar::Util qw(blessed);

use base qw(Tree::Simple::Visitor);

sub new {
    my ($_class) = @_;
    my $class = ref($_class) || $_class;
    my $visitor = {};
    bless($visitor, $class);
    $visitor->_init();
    return $visitor;
}

sub _init {
    my ($self) = @_;
    $self->{sort_function} = undef;
    $self->SUPER::_init();
}

# pre-built sort functions
sub SORT_FILES_FIRST {
    return sub ($$$) {
        my ($path, $left, $right) = @_;
        $left  = File::Spec->catdir($path, $left);
        $right = File::Spec->catdir($path, $right);
        return ((-d $left && -f $right) ? 1 :       # file beats directory
                (-d $right && -f $left) ? -1 :    # file beats directory
                    (lc($left) cmp lc($right)))     # otherwise just sort 'em
    }
}

sub SORT_DIRS_FIRST {
    return sub ($$$) {
        my ($path, $left, $right) = @_;
        $left  = File::Spec->catdir($path, $left);
        $right = File::Spec->catdir($path, $right);
        return ((-d $left && -f $right) ? -1 :      # directory beats file
                (-d $right && -f $left) ? 1 :     # directory beats file
                    (lc($left) cmp lc($right)))     # otherwise just sort 'em
    }
}

sub setSortStyle {
    my ($self, $sort_function) = @_;
	(defined($sort_function) && ref($sort_function) eq "CODE")
		|| die "Insufficient Arguments : sort function argument must be a subroutine reference";
    $self->{sort_function} = $sort_function;
}

sub visit {
	my ($self, $tree) = @_;
	(blessed($tree) && $tree->isa("Tree::Simple"))
		|| die "Insufficient Arguments : You must supply a valid Tree::Simple object";
    # it must be a leaf
    ($tree->isLeaf()) || die "Illegal Operation : The tree must be a leaf node to load a directory";
    # check that our directory is valid
    my $root_dir = $tree->getNodeValue();
    (-e $root_dir && -d $root_dir)
        || die "Incorrect Type : The tree's node value must be a valid directory";
    # and load it recursively
    $self->_recursiveLoad($tree, $root_dir);
}

sub _recursiveLoad {
	my ($self, $t, $path) = @_;
    # get a node filter if we have one
    my $filter = $self->getNodeFilter();

    # get the contents of the directory
    opendir(DIR, $path) || die "IO Error : Could not open directory : $!";
    # avoid the . and .. symbolic links
    my @dir_contents = grep {
                        $_ ne File::Spec->curdir() && $_ ne File::Spec->updir()
                        } readdir(DIR);
    close(DIR);

    # sort them if we need to with full paths
    @dir_contents = sort {
                        $self->{sort_function}->($path, $a, $b)
                    } @dir_contents if $self->{sort_function};

    # now traverse ...
	foreach my $item (@dir_contents) {
        # filter based on the item name
        $filter->($item) || next if defined($filter);
        # get the full path for checking
        # the item type and recursion
        my $full_path = File::Spec->catdir($path, $item);
		if (-d $full_path) {
            my $new_tree = $t->new($item);
            $t->addChild($new_tree);
            $self->_recursiveLoad($new_tree, $full_path);
		}
		elsif (-f $full_path) {
            $t->addChild($t->new($item));
		}
	}
}

1;

__END__