File Coverage

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

Criterion	Covered	Total	%
statement	54	54	100.0
branch	12	12	100.0
condition	7	9	77.7
subroutine	21	21	100.0
pod	8	8	100.0
total	102	104	98.0

package Tree::Simple::Visitor::Sort;

use strict;
use warnings;

our $VERSION = '0.16';

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();
}

sub REVERSE              { sub ($$) { $_[1]->getNodeValue()     cmp $_[0]->getNodeValue()     }};
sub NUMERIC              { sub ($$) { $_[0]->getNodeValue()     <=> $_[1]->getNodeValue()     }};
sub REVERSE_NUMERIC      { sub ($$) { $_[1]->getNodeValue()     <=> $_[0]->getNodeValue()     }};
sub ALPHABETICAL         { sub ($$) { lc($_[0]->getNodeValue()) cmp lc($_[1]->getNodeValue()) }};
sub REVERSE_ALPHABETICAL { sub ($$) { lc($_[1]->getNodeValue()) cmp lc($_[0]->getNodeValue()) }};

sub setSortFunction {
    my ($self, $sort_function) = @_;
    (defined($sort_function) && ref($sort_function) eq "CODE")
        || die "Insufficient Arguments : You must supply a CODE reference for the sort function";
    $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";

    # No childs, nothing to sort
    return if $tree->isLeaf();

    my $sort_function;
    if ($self->{sort_function}) {
        $sort_function = $self->{sort_function};
    }
    else {
        # get the node filter
        my $filter_func = $self->getNodeFilter();
        if ($filter_func) {
            $sort_function = sub { $filter_func->($a) cmp $filter_func->($b) };
        }
        else {
            $sort_function = sub { $a->getNodeValue() cmp $b->getNodeValue() };
        }
    }

    # otherwise sort them
    $self->_sortTree($sort_function, $tree);
}

sub _sortTree {
    my ($self, $sort_function, $tree) = @_;

    # sort children, using the sort filter
    my @childs = sort { $sort_function->($a, $b) } $tree->getAllChildren();

    # Create the new sequence
    foreach my $child (@childs) {
        # get the removed child
        $child = $tree->removeChild($child);
        # and be sure that is the one
        # we re-insert
        $tree->addChild($child);
        # only sort the child if
        # it is not a leaf
        $self->_sortTree($sort_function, $child) unless $child->isLeaf();
    }
}

1;

__END__