File Coverage

blib/lib/Tree/Simple/View.pm

Criterion	Covered	Total	%
statement	47	47	100.0
branch	16	18	88.8
condition	6	9	66.6
subroutine	17	17	100.0
pod	11	11	100.0
total	97	102	95.1

package Tree::Simple::View;

use strict;
use warnings;

our $VERSION = '0.180001';

use Scalar::Util qw(blessed);

use Tree::Simple::View::Exceptions;

sub new {
    my ($_class, $tree, %configuration) = @_;
    my $class = ref($_class) || $_class;
    ($class ne 'Tree::Simple::View')
        || throw Tree::Simple::View::AbstractClass "Tree::Simple::View is an abstract class, try Tree::Simple::View::HTML or Tree::Simple::View::DHTML instead";
    my $tree_view = bless{
        tree                  => undef,
        config                => {},
        include_trunk         => undef,
        ppath_comparison_func => undef
    } => $class;
    $tree_view->_init($tree, %configuration);
    return $tree_view;
}

sub _init {
    my ($self, $tree, %config) = @_;
    (blessed($tree) && $tree->isa("Tree::Simple"))
        || throw Tree::Simple::View::InsufficientArguments "tree argument must be a Tree::Simple object";
    $self->{tree}                 = $tree;
    $self->{config}               = \%config if %config;
    $self->{include_trunk}        = 0;
    $self->{path_comparison_func} = undef;
}

sub getTree   { (shift)->{tree}   }
sub getConfig { (shift)->{config} }

sub includeTrunk {
    my ($self, $boolean) = @_;
    $self->{include_trunk} = ($boolean ? 1 : 0) if defined $boolean;
    return $self->{include_trunk};
}

sub setPathComparisonFunction {
    my ($self, $code) = @_;
    (defined($code) && ref($code) eq "CODE")
        || throw Tree::Simple::View::InsufficientArguments "Path comparison must be a function";
    $self->{path_comparison_func} = $code;
}

sub expandPath {
    my ($self, @path) = @_;
    return $self->expandPathComplex($self->{tree}, $self->{config}, @path) if (keys %{$self->{config}});
    return $self->expandPathSimple($self->{tree}, @path);
}

# override these method
sub expandPathSimple  { throw Tree::Simple::View::AbstractMethod "Method Not Implemented" }
sub expandPathComplex { throw Tree::Simple::View::AbstractMethod "Method Not Implemented" }

sub expandAll {
    my ($self) = @_;
    return $self->expandAllComplex($self->{config}) if (keys %{$self->{config}});
    return $self->expandAllSimple();
}

# override these method
sub expandAllSimple  { throw Tree::Simple::View::AbstractMethod "Method Not Implemented" }
sub expandAllComplex { throw Tree::Simple::View::AbstractMethod "Method Not Implemented" }

## private methods

sub _compareNodeToPath {
    my ($self, $current_path, $current_tree) = @_;
    # default to normal node-path comparison ...
    return $current_path eq $current_tree->getNodeValue()
        unless defined $self->{path_comparison_func};
    # unless we have a path_comparison_func in place
    # in which case we use that
    return $self->{path_comparison_func}->($current_path, $current_tree);
}

1;

__END__