File Coverage

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

Criterion	Covered	Total	%
statement	46	46	100.0
branch	17	18	94.4
condition	9	11	81.8
subroutine	9	9	100.0
pod	3	3	100.0
total	84	87	96.5

package Tree::Simple::Visitor::FromNestedArray;

use strict;
use warnings;

our $VERSION = '0.14';

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->{array_tree} = undef;
    $self->SUPER::_init();
}

sub setArrayTree {
    my ($self, $array_tree) = @_;
    (defined($array_tree) && ref($array_tree) eq 'ARRAY')
        || die "Insufficient Arguments : You must supply a valid ARRAY reference";
    # validate the tree ...
    # it must not be empty
    (scalar @{$array_tree} != 0)
        || die "Insufficient Arguments : The array tree provided is empty";
    # it's first element must not be an array
    (ref($array_tree->[0]) ne 'ARRAY')
        || die "Incorrect Object Type : The first value in the array tree is an array reference";
    # and it must be a single rooted tree
    (ref($array_tree->[1]) eq 'ARRAY')
        || die "Incorrect Object Type : The second value in the array tree must be an array reference"
            if defined($array_tree->[1]);
    $self->{array_tree} = $array_tree;
}

sub visit {
	my ($self, $tree) = @_;
	(blessed($tree) && $tree->isa("Tree::Simple"))
		|| die "Insufficient Arguments : You must supply a valid Tree::Simple object";
	$self->_buildTree(
                $tree,
                # our array tree
                $self->{array_tree},
                # get a node filter if we have one
                $self->getNodeFilter(),
                # pass the value of includeTrunk too
                $self->includeTrunk()
                );
}

sub _buildTree {
    my ($self, $tree, $array, $node_filter, $include_trunk) = @_;
    my $i = 0;
    while ($i < scalar @{$array}) {
        my $node = $array->[$i];
        # check to make sure we have a well formed tree
        (ref($node) ne 'ARRAY')
            || die "Incorrect Object Type : The node value should never be an array reference";
        # filter the node if necessary
        $node = $node_filter->($node) if defined($node_filter);
        # create the new tree
        my $new_tree;
        if ($include_trunk) {
            $tree->setNodeValue($node);
            $new_tree = $tree;
        }
        else {
            $new_tree = Tree::Simple->new($node);
            $tree->addChild($new_tree);
        }
        # increment the index value
        $i++;
        # NOTE:
        # the value of include trunk is only
        # passed in the recursion, so that
        # the trunk/root can be populated,
        # we have no more need for it after
        # that time.
        $self->_buildTree($new_tree, $array->[$i++], $node_filter)
            if ref($array->[$i]) eq 'ARRAY';
    }
}

1;

__END__