File Coverage

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

Criterion	Covered	Total	%
statement	41	41	100.0
branch	11	12	91.6
condition	7	9	77.7
subroutine	9	9	100.0
pod	3	3	100.0
total	71	74	95.9

package Tree::Simple::Visitor::FromNestedHash;

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

sub setHashTree {
    my ($self, $hash_tree) = @_;
    (defined($hash_tree) && ref($hash_tree) eq 'HASH')
        || die "Insufficient Arguments : You must supply a valid HASH reference";
    # validate the tree ...
    # it must not be empty
    (scalar keys %{$hash_tree} == 1)
        || die "Insufficient Arguments : The hash tree provided must be a single rooted tree";
    $self->{hash_tree} = $hash_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,
                    $self->{hash_tree},
                    $self->getNodeFilter(),
                    $self->includeTrunk()
                    );
}

sub _buildTree {
    my ($self, $tree, $hash, $node_filter, $include_trunk) = @_;
    foreach my $key (sort keys %{$hash}) {
        my $node = $key;
        $node = $node_filter->($node) if $node_filter;
        my $new_tree;
        if ($include_trunk) {
            $tree->setNodeValue($node);
            $new_tree = $tree;
        }
        else {
            $new_tree = Tree::Simple->new($node);
            $tree->addChild($new_tree);
        }
        $self->_buildTree($new_tree, $hash->{$key}, $node_filter)
            if ref($hash->{$key}) eq 'HASH';
    }
}

1;

__END__