Merge lp:~noskcaj/ubuntu/vivid/libtree-perl/1.05 into lp:ubuntu/vivid/libtree-perl

[Jackson Doak]

New upstream release. Package might be better RMed though

[Daniel Holbach (dholbach)]

Thanks. Uploaded.

review: Approve

Unmerged revisions

4. By Jackson Doak on 2014-12-12

New upstream release.

=== modified file 'Build.PL'
--- Build.PL	2008-01-17 12:56:58 +0000
+++ Build.PL	2014-12-12 23:08:52 +0000
@@ -2,39 +2,43 @@
 
 use 5.6.0;
 
-use strict;
 use warnings;
 
-eval "use Tree::Binary;";
-unless ($@) {
-    if ( (my $version = Tree::Binary->VERSION) <= 0.07 ) {
-        my $tree_binary_msg = "You currently have Tree::Binary version $version installed.\nThis distribution will install an incompatible Tree::Binary module on top of it.\nDo you wish for me to continue?";
-
-        if ( !Module::Build->y_n( $tree_binary_msg, 'n' ) ) {
-            exit;
-        }
-    }
-}
-
-my $build = Module::Build->new(
-    module_name => 'Tree',
-    license => 'perl',
-    requires => {
-        'perl'               => '5.6.0',
-        'Scalar::Util'       => '1.10',
-    },
-    build_requires => {
-        'Scalar::Util'         => '1.10',
-        'Test::Deep'           => '0.088',
-        'Test::Exception'      => '0.15',
-        'Test::More'           => '0.47',
-        'Test::Warn'           => '0.08',
-    },
-    create_makefile_pl => 'traditional',
-    recursive_test_files => 1,
-    add_to_cleanup => [
-        'META.yml', '*.bak', '*.gz', 'Makefile.PL',
-    ],
-);
-
-$build->create_build_script;
+
+Module::Build -> new
+(
+	dist_abstract => 'An N-ary tree',
+	module_name   => 'Tree',
+	license       => 'artistic_2',
+	requires      =>
+	{
+		perl        => '5.6.0',
+		Scalar::Util => 1.10,
+	},
+	configure_requires =>
+	{
+		Module::Build => 0.40,
+	},
+	build_requires =>
+	{
+		base                => 0,
+		constant            => 0,
+		Data::Dumper        => 2.136,
+		Exporter            => 5.66,
+		overload            => 0,
+		Scalar::Util        => 1.10,
+		strict              => 0,
+		Test::Deep          => 0.088,
+		Test::Exception     => 0.15,
+#		Test::Pod           => 1.45, # Make it optional. See t/pod.t
+#		Test::Pod::Coverage => 1.08, # Make it optional. See t/pod.t
+		Test::More          => 0.47,
+		Test::Warn          => 0.08,
+		warnings            => 0,
+	},
+	recursive_test_files => 1,
+	add_to_cleanup       =>
+	[
+		'META.yml', '*.bak', '*.gz', 'Makefile.PL',
+	],
+) -> create_build_script;

=== added file 'Changelog.ini'
--- Changelog.ini	1970-01-01 00:00:00 +0000
+++ Changelog.ini	2014-12-12 23:08:52 +0000
@@ -0,0 +1,70 @@
+[Module]
+Name=Tree
+Changelog.Creator=Module::Metadata::Changes V 2.05
+Changelog.Parser=Config::IniFiles V 2.78
+
+[V 1.05]
+Date=2013-06-05T08:34:00
+Comments= <<EOT
+- No code changes.
+- For pre-reqs base, constant and overload, which ship with Perl, set the version # to 0.
+Requested by Andreas Mock. Actually, I should have done this with version 1.04.
+- Rename CHANGES to Changes as per CPAN::Changes::Spec.
+EOT
+
+[V 1.04]
+Date=2012-11-08T12:38:00
+Comments= <<EOT
+- No code changes.
+- For pre-reqs such as strict, warnings, etc, which ship with Perl, set the version # to 0.
+Reported as RT#80663 by Father Chrysostomos for Tree::DAG_Node.
+- Add README.
+EOT
+
+[V 1.03]
+Date=2012-11-02T09:34:00
+Comments= <<EOT
+- Rename Tree::Binary to Tree::Binary2 so it no longer clashes with the Tree::Binary shipped in the
+Tree-Binary distro. MetaCPAN was getting confused, and automatically redirected links to this
+module's Tree:Binary to the other one.
+EOT
+
+[V 1.02]
+Date=2012-10-04T12:10:00
+Comments= <<EOT
+- Ron Savage is now co-maint.
+- Patch Tree::Fast's value() to accept a defained value so the node's value can be set with
+$n -> value($new_value).
+- Patch Tree::Fast's meta() to accept a hashref so metadata can be set with $n -> meta({key => value}),
+as well as by directly accessing the internal hashref '_meta'.
+- Patch t/Tree/001_root_node.t to test the above.
+- Rename Changes to CHANGES.
+- Use ini.report.pl (shipped with Module::Metadata::Changes) to add Changelog.ini to the distro.
+- Reformat the dates in this file.
+- Change lib/Tree/Fast.pm to Unix line endings.
+- Clean up the POD.
+- Re-work Makefile.PL rather than have Build.PL generate it.
+- Update pre-reqs in Build.PL and Makefile.PL.
+- Move t/tests.pm to t/lib/Tests.pm.
+EOT
+
+[V 1.01]
+Date=2007-10-18T12:00:00
+Comments= <<EOT
+- Fixed Changes file
+- Right distro name.
+- 1.00 release noted
+- Cleaned up 5.6.0 -> 5.006
+- Fix for RT# 16889 (clone broken for Tree::Binary)
+- Patch submitted by HDP
+- Fix for other miscellenous bugs
+- Patch submitted by HDP
+EOT
+
+[V 1.00]
+Date=2005-11-08T12:00:00
+Comments=- Initial release
+
+[V 0.99]
+Date=2005-10-24T10:30:00
+Comments=- Initial revision

=== modified file 'Changes'
--- Changes	2008-01-17 12:56:58 +0000
+++ Changes	2014-12-12 23:08:52 +0000
@@ -1,17 +1,50 @@
-Revision history for Perl distribution Tree
-
-1.01 Oct 18, 2007
-  - Fixed Changes file
-    - Right distro name.
-    - 1.00 release noted
-  - Cleaned up 5.6.0 -> 5.006
-  - Fix for RT# 16889 (clone broken for Tree::Binary)
-    - Patch submitted by HDP
-  - Fix for other miscellenous bugs
-    - Patch submitted by HDP
-
-1.00 Nov 08, 2005
-  - Initial release
-
-0.99_01 Mon 24 Oct 2005 10:30:00
-  - Initial revision
+Revision history for Perl distribution Tree.
+
+1.05  Wed Jun  5 08:34:00 2013
+	- No code changes.
+	- For pre-reqs base, constant and overload, which ship with Perl, set the version # to 0.
+		Requested by Andreas Mock. Actually, I should have done this with version 1.04.
+	- Rename CHANGES to Changes as per CPAN::Changes::Spec.
+
+1.04  Thu Nov  8 12:38:00 2012
+	- No code changes.
+	- For pre-reqs such as strict, warnings, etc, which ship with Perl, set the version # to 0.
+		Reported as RT#80663 by Father Chrysostomos for Tree::DAG_Node.
+	- Add README.
+
+1.03  Fri Nov  2 09:34:00 2012
+	- Rename Tree::Binary to Tree::Binary2 so it no longer clashes with the Tree::Binary shipped in the
+		Tree-Binary distro. MetaCPAN was getting confused, and automatically redirected links to this
+		module's Tree:Binary to the other one.
+
+1.02  Thu Oct  4 12:10:00 2012
+	- Ron Savage is now co-maint.
+	- Patch Tree::Fast's value() to accept a defained value so the node's value can be set with
+		$n -> value($new_value).
+	- Patch Tree::Fast's meta() to accept a hashref so metadata can be set with $n -> meta({key => value}),
+		as well as by directly accessing the internal hashref '_meta'.
+	- Patch t/Tree/001_root_node.t to test the above.
+	- Rename Changes to CHANGES.
+	- Use ini.report.pl (shipped with Module::Metadata::Changes) to add Changelog.ini to the distro.
+	- Reformat the dates in this file.
+	- Change lib/Tree/Fast.pm to Unix line endings.
+	- Clean up the POD.
+	- Re-work Makefile.PL rather than have Build.PL generate it.
+	- Update pre-reqs in Build.PL and Makefile.PL.
+	- Move t/tests.pm to t/lib/Tests.pm.
+
+1.01  Thu Oct 18 12:00:00 2007
+	- Fixed Changes file
+	- Right distro name.
+	- 1.00 release noted
+	- Cleaned up 5.6.0 -> 5.006
+	- Fix for RT# 16889 (clone broken for Tree::Binary)
+	- Patch submitted by HDP
+	- Fix for other miscellenous bugs
+	- Patch submitted by HDP
+
+1.00  Tue Nov 08 12:00:00 2005
+	- Initial release
+
+0.99  Mon Oct 24 10:30:00 2005
+	- Initial revision

=== modified file 'MANIFEST'
--- MANIFEST	2008-01-17 12:56:58 +0000
+++ MANIFEST	2014-12-12 23:08:52 +0000
@@ -1,10 +1,17 @@
 Build.PL
+Changelog.ini
 Changes
+lib/Tree.pm
+lib/Tree/Binary2.pm
+lib/Tree/Fast.pm
 Makefile.PL
 MANIFEST			This list of files
-lib/Tree.pm
-lib/Tree/Binary.pm
-lib/Tree/Fast.pm
+META.json
+META.yml
+README
+t/lib/Tests.pm
+t/pod.t
+t/pod_coverage.t
 t/Tree/000_interface.t
 t/Tree/001_root_node.t
 t/Tree/002_null_object.t
@@ -26,7 +33,3 @@
 t/Tree_Binary/001_mirror.t
 t/Tree_Binary/002_clone.t
 t/Tree_Fast/001_clone.t
-t/pod.t
-t/pod_coverage.t
-t/tests.pm
-META.yml

=== added file 'META.json'
--- META.json	1970-01-01 00:00:00 +0000
+++ META.json	2014-12-12 23:08:52 +0000
@@ -0,0 +1,72 @@
+{
+   "abstract" : "An N-ary tree",
+   "author" : [
+      "Rob Kinyon E<lt>[e-mail]<gt>",
+      "Stevan Little E<lt>[e-mail]<gt>",
+      "Co-maintenance since V 1.02 is by Ron Savage <[e-mail]>."
+   ],
+   "dynamic_config" : 1,
+   "generated_by" : "Module::Build version 0.4005, CPAN::Meta::Converter version 2.120921",
+   "license" : [
+      "artistic_2"
+   ],
+   "meta-spec" : {
+      "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec",
+      "version" : "2"
+   },
+   "name" : "Tree",
+   "prereqs" : {
+      "build" : {
+         "requires" : {
+            "Data::Dumper" : "2.136",
+            "Exporter" : "5.66",
+            "Scalar::Util" : "1.1",
+            "Test::Deep" : "0.088",
+            "Test::Exception" : "0.15",
+            "Test::More" : "0.47",
+            "Test::Warn" : "0.08",
+            "base" : "0",
+            "constant" : "0",
+            "overload" : "0",
+            "strict" : "0",
+            "warnings" : "0"
+         }
+      },
+      "configure" : {
+         "requires" : {
+            "Module::Build" : "0.4"
+         }
+      },
+      "runtime" : {
+         "requires" : {
+            "Scalar::Util" : "1.1",
+            "perl" : "v5.6.0"
+         }
+      }
+   },
+   "provides" : {
+      "Tree" : {
+         "file" : "lib/Tree.pm",
+         "version" : "1.05"
+      },
+      "Tree::Binary2" : {
+         "file" : "lib/Tree/Binary2.pm",
+         "version" : "1.05"
+      },
+      "Tree::Fast" : {
+         "file" : "lib/Tree/Fast.pm",
+         "version" : "1.05"
+      },
+      "Tree::Null" : {
+         "file" : "lib/Tree/Fast.pm",
+         "version" : 0
+      }
+   },
+   "release_status" : "stable",
+   "resources" : {
+      "license" : [
+         "http://www.perlfoundation.org/artistic_license_2_0"
+      ]
+   },
+   "version" : "1.05"
+}

=== added file 'META.yml'
--- META.yml	1970-01-01 00:00:00 +0000
+++ META.yml	2014-12-12 23:08:52 +0000
@@ -0,0 +1,47 @@
+---
+abstract: 'An N-ary tree'
+author:
+  - 'Rob Kinyon E<lt>[e-mail]<gt>'
+  - 'Stevan Little E<lt>[e-mail]<gt>'
+  - 'Co-maintenance since V 1.02 is by Ron Savage <[e-mail]>.'
+build_requires:
+  Data::Dumper: 2.136
+  Exporter: 5.66
+  Scalar::Util: 1.1
+  Test::Deep: 0.088
+  Test::Exception: 0.15
+  Test::More: 0.47
+  Test::Warn: 0.08
+  base: 0
+  constant: 0
+  overload: 0
+  strict: 0
+  warnings: 0
+configure_requires:
+  Module::Build: 0.4
+dynamic_config: 1
+generated_by: 'Module::Build version 0.4005, CPAN::Meta::Converter version 2.120921'
+license: artistic_2
+meta-spec:
+  url: http://module-build.sourceforge.net/META-spec-v1.4.html
+  version: 1.4
+name: Tree
+provides:
+  Tree:
+    file: lib/Tree.pm
+    version: 1.05
+  Tree::Binary2:
+    file: lib/Tree/Binary2.pm
+    version: 1.05
+  Tree::Fast:
+    file: lib/Tree/Fast.pm
+    version: 1.05
+  Tree::Null:
+    file: lib/Tree/Fast.pm
+    version: 0
+requires:
+  Scalar::Util: 1.1
+  perl: v5.6.0
+resources:
+  license: http://www.perlfoundation.org/artistic_license_2_0
+version: 1.05

=== added file 'Makefile.PL'
--- Makefile.PL	1970-01-01 00:00:00 +0000
+++ Makefile.PL	2014-12-12 23:08:52 +0000
@@ -0,0 +1,43 @@
+use warnings;
+
+require 5.006000;
+
+use ExtUtils::MakeMaker;
+
+# ----------------------
+
+WriteMakefile
+(
+	($] ge '5.005') ?
+	(
+		AUTHOR   => 'Rob Kinyin ([e-mail])',
+		ABSTRACT => 'Persist multiple trees in a single db table, preserving child order',
+	) : (),
+	NAME         => 'Tree',
+	LICENSE   => 'artistic_2',
+	VERSION_FROM => 'lib/Tree.pm',
+	PREREQ_PM    =>
+	{
+		base                => 0,
+		constant            => 0,
+		Data::Dumper        => 2.136,
+		Exporter            => 5.66,
+		overload            => 0,
+		Scalar::Util        => 1.10,
+		strict              => 0,
+		Test::Deep          => 0.088,
+		Test::Exception     => 0.15,
+#		Test::Pod           => 1.45, # Make it optional. See t/pod.t
+#		Test::Pod::Coverage => 1.08, # Make it optional. See t/pod.t
+		Test::More          => 0.47,
+		Test::Warn          => 0.08,
+		warnings            => 0,
+	},
+	INSTALLDIRS => 'site',
+	EXE_FILES   => [],
+	PL_FILES    => {},
+	test        =>
+	{
+		TESTS => 't/*.t t/Tree_Binary/*.t t/Tree/*.t t/Tree_Fast/*.t',
+	},
+);

=== added file 'README'
--- README	1970-01-01 00:00:00 +0000
+++ README	2014-12-12 23:08:52 +0000
@@ -0,0 +1,49 @@
+README file for Tree.
+
+See also: CHANGES and Changelog.ini.
+
+Warning: WinZip 8.1 and 9.0 both contain an 'accidental' bug which stops
+them recognizing POSIX-style directory structures in valid tar files.
+You are better off using a reliable tool such as InfoZip:
+ftp://ftp.info-zip.org/pub/infozip/
+
+1 Installing from a Unix-like distro
+------------------------------------
+shell>gunzip Tree-1.03.tgz
+shell>tar mxvf Tree-1.03.tar
+
+On Unix-like systems, assuming you have installed Module::Build V 0.25+:
+
+shell>perl Build.PL
+shell>./Build
+shell>./Build test
+shell>./Build install
+
+On MS Windows-like systems, assuming you have installed Module::Build V 0.25+:
+
+shell>perl Build.PL
+shell>perl Build
+shell>perl Build test
+shell>perl Build install
+
+Alternately, without Module::Build, you do this:
+
+Note: 'make' on MS Windows-like systems may be called 'nmake' or 'dmake'.
+
+shell>perl Makefile.PL
+shell>make
+shell>make test
+shell>su              (for Unix-like systems)
+shell>make install
+shell>exit            (for Unix-like systems)
+
+On all systems:
+
+Run Tree.pm through your favourite pod2html translator.
+
+2 Installing from an ActiveState distro
+---------------------------------------
+shell>unzip Tree-1.03.zip
+shell>ppm install --location=. Tree
+shell>del Tree-1.03.ppd
+shell>del PPM-Tree-1.03.tar.gz

=== modified file 'debian/changelog'
--- debian/changelog	2010-02-09 20:55:43 +0000
+++ debian/changelog	2014-12-12 23:08:52 +0000
@@ -1,3 +1,9 @@
+libtree-perl (1.05-0ubuntu1) vivid; urgency=medium
+
+  * New upstream release.
+
+ -- Jackson Doak <[e-mail]>  Sat, 13 Dec 2014 08:10:01 +1100
+
 libtree-perl (1.01-0ubuntu2) lucid; urgency=low
 
   * debian/control:

=== modified file 'lib/Tree.pm'
--- lib/Tree.pm	2008-01-17 12:56:58 +0000
+++ lib/Tree.pm	2014-12-12 23:08:52 +0000
@@ -5,7 +5,7 @@
 use strict;
 use warnings FATAL => 'all';
 
-our $VERSION = '1.01';
+our $VERSION = '1.05';
 
 use Scalar::Util qw( blessed refaddr weaken );
 
@@ -32,9 +32,9 @@
     },
 );
 
-sub QUIET { return $error_handlers{ 'quiet' } } 
-sub WARN  { return $error_handlers{ 'warn' } } 
-sub DIE   { return $error_handlers{ 'die' } } 
+sub QUIET { return $error_handlers{ 'quiet' } }
+sub WARN  { return $error_handlers{ 'warn' } }
+sub DIE   { return $error_handlers{ 'die' } }
 
 # The default error handler is quiet
 my $ERROR_HANDLER = $error_handlers{ 'quiet' };
@@ -381,7 +381,7 @@
 
 =head1 NAME
 
-Tree - an N-ary tree
+Tree - An N-ary tree
 
 =head1 SYNOPSIS
 
@@ -419,6 +419,9 @@
       value        => sub { ... },
   });
 
+  my $old_default_error_handler = $tree->error_handler(Tree->DIE);
+  my $old_object_error_handler  = $tree->error_handler($tree->DIE);
+
 =head1 DESCRIPTION
 
 This is meant to be a full-featured N-ary tree representation with
@@ -428,39 +431,35 @@
 
 =head1 METHODS
 
-=head2 Constructor
-
-=over 4
-
-=item B<new([$value])>
-
-This will return a Tree object. It will accept one parameter which, if passed,
-will become the value (accessible by C<value()>). All other parameters will be
+=head2 Constructors
+
+=head2 new([$value])
+
+Here, [] indicate an optional parameter.
+
+This will return a C<Tree> object. It will accept one parameter which, if passed,
+will become the I<value> (accessible by C<value()>). All other parameters will be
 ignored.
 
-If you call C<$tree-E<gt>new([$value])>, it will instead call C<clone()>, then set
-the value of the clone to $value.
+If you call C<< $tree->new([$value]) >>, it will instead call C<clone()>, then set
+the I<value> of the clone to $value.
 
-=item B<clone()>
+=head2 clone()
 
 This will return a clone of C<$tree>. The clone will be a root tree, but all
 children will be cloned.
 
-If you call L<Tree-E<gt>clone([$value])>, it will instead call C<new()>.
+If you call C<< Tree->clone([$value]) >>, it will instead call C<new($value)>.
 
 B<NOTE:> the value is merely a shallow copy. This means that all references
 will be kept.
 
-=back
-
 =head2 Behaviors
 
-=over 4
-
-=item B<add_child([$options], @nodes)>
+=head2 add_child([$options], @nodes)
 
 This will add all the C<@nodes> as children of C<$tree>. $options is a optional
-unblessed hashref that specifies options for add_child(). The optional
+unblessed hashref that specifies options for C<add_child()>. The optional
 parameters are:
 
 =over 4
@@ -469,11 +468,17 @@
 
 This specifies the index to add C<@nodes> at. If specified, this will be passed
 into splice(). The only exceptions are if this is 0, it will act as an
-unshift(). If it is unset or undefined, it will act as a push().
+unshift(). If it is unset or undefined, it will act as a push(). Lastly, if it is out of range
+(too negative or too big [beyond the number of children]) the child is not added, and an error msg
+will be available in L</last_error()>.
 
 =back
 
-=item B<remove_child([$options], @nodes)>
+add_child() resets last_error() upon entry.
+
+=head2 remove_child([$options], @nodes)
+
+Here, [] indicate an optional parameter.
 
 This will remove all the C<@nodes> from the children of C<$tree>. You can either
 pass in the actual child object you wish to remove, the index of the child you
@@ -482,16 +487,23 @@
 $options is a optional unblessed hashref that specifies parameters for
 remove_child(). Currently, no parameters are used.
 
-=item B<mirror()>
+remove_child() resets last_error() upon entry.
+
+=head2 mirror()
 
 This will modify the tree such that it is a mirror of what it was before. This
 means that the order of all children is reversed.
 
 B<NOTE>: This is a destructive action. It I<will> modify the tree's internal
 structure. If you wish to get a mirror, yet keep the original tree intact, use
-C<my $mirror = $tree-E<gt>clone-E<gt>mirror;>
-
-=item B<traverse( [$order] )>
+C<< my $mirror = $tree->clone->mirror >>.
+
+mirror() does not reset last_error() because it (mirror() ) is implemented in L<Tree::Fast>,
+which has no error handling.
+
+=head2 traverse([$order])
+
+Here, [] indicate an optional parameter.
 
 This will return a list of the nodes in the given traversal order. The default
 traversal order is pre-order.
@@ -500,65 +512,63 @@
 
 =over 4
 
-=item * Pre-order (aka Prefix traversal)
+=item * Pre-order
 
 This will return the node, then the first sub tree in pre-order traversal,
 then the next sub tree, etc.
 
-Use C<$tree-E<gt>PRE_ORDER> as the C<$order>.
+Use C<< $tree->PRE_ORDER >> as the C<$order>.
 
-=item * Post-order (aka Prefix traversal)
+=item * Post-order
 
 This will return the each sub-tree in post-order traversal, then the node.
 
-Use C<$tree-E<gt>POST_ORDER> as the C<$order>.
+Use C<< $tree->POST_ORDER >> as the C<$order>.
 
-=item * Level-order (aka Prefix traversal)
+=item * Level-order
 
 This will return the node, then the all children of the node, then all
 grandchildren of the node, etc.
 
-Use C<$tree-E<gt>LEVEL_ORDER> as the C<$order>.
-
-=back
-
-=back
-
-All behaviors will reset last_error().
+Use C<< $tree->LEVEL_ORDER >> as the C<$order>.
+
+=back
+
+traverse() does not reset last_error() because it (traverse() ) is implemented in L<Tree::Fast>,
+which has no error handling.
 
 =head2 State Queries
 
-=over 4
-
-=item * B<is_root()>
-
-This will return true is C<$tree> has no parent and false otherwise.
-
-=item * B<is_leaf()>
-
-This will return true is C<$tree> has no children and false otherwise.
-
-=item * B<has_child(@nodes)>
-
-This will return true is C<$tree> has each of the C<@nodes> as a child.
+=head2 is_root()
+
+This will return true if C<$tree> has no parent and false otherwise.
+
+=head2 is_leaf()
+
+This will return true if C<$tree> has no children and false otherwise.
+
+=head2 has_child(@nodes)
+
+This will return true if C<$tree> has each of the C<@nodes> as a child.
 Otherwise, it will return false.
 
-=item * B<get_index_for(@nodes)>
-
-This will return the index into the children list for each of the C<@nodes>
+The test to see if a node is in the tree uses refaddr() from L<Scalar::Util>, not the I<value> of the node.
+This means C<@nodes> must be an array of C<Tree> objects.
+
+=head2 get_index_for(@nodes)
+
+This will return the index into the children list of C<$tree> for each of the C<@nodes>
 passed in.
 
-=back
-
 =head2 Accessors
 
-=over 4
-
-=item * B<parent()>
+=head2 parent()
 
 This will return the parent of C<$tree>.
 
-=item * B<children( [ $idx, [$idx, ..] ] )>
+=head2 children( [ $idx, [$idx, ..] ] )
+
+Here, [] indicate optional parameters.
 
 This will return the children of C<$tree>. If called in list context, it will
 return all the children. If called in scalar context, it will return the
@@ -568,22 +578,22 @@
 children in the order you asked for them. This is very much like an
 arrayslice.
 
-=item * B<root()>
+=head2 root()
 
 This will return the root node of the tree that C<$tree> is in. The root of
 the root node is itself.
 
-=item * B<height()>
+=head2 height()
 
 This will return the height of C<$tree>. A leaf has a height of 1. A parent
 has a height of its tallest child, plus 1.
 
-=item * B<width()>
+=head2 width()
 
 This will return the width of C<$tree>. A leaf has a width of 1. A parent has
 a width equal to the sum of all the widths of its children.
 
-=item * B<depth()>
+=head2 depth()
 
 This will return the depth of C<$tree>. A root has a depth of 0. A child has
 the depth of its parent, plus 1.
@@ -591,21 +601,25 @@
 This is the distance from the root. It's useful for things like
 pretty-printing the tree.
 
-=item * B<size()>
+=head2 size()
 
 This will return the number of nodes within C<$tree>. A leaf has a size of 1.
 A parent has a size equal to the 1 plus the sum of all the sizes of its
 children.
 
-=item * B<value()>
+=head2 value()
 
 This will return the value stored in the node.
 
-=item * B<set_value([$value])>
-
-This will set the value stored in the node to $value, then return $self.
-
-=item * B<meta()>
+=head2 set_value([$value])
+
+Here, [] indicate an optional parameter.
+
+This will set the I<value> stored in the node to $value, then return $self.
+
+If C<$value> is not provided, undef is used.
+
+=head2 meta()
 
 This will return a hashref that can be used to store whatever metadata the
 client wishes to store. For example, L<Tree::Persist::DB> uses this to store
@@ -616,8 +630,6 @@
 this, using a unique key for each persistence layer associated with that tree.
 This will help prevent clobbering of metadata.
 
-=back
-
 =head1 ERROR HANDLING
 
 Describe what the default error handlers do and what a custom error handler is
@@ -625,9 +637,7 @@
 
 =head2 Error-related methods
 
-=over 4
-
-=item * B<error_handler( [ $handler ] )>
+=head2 error_handler( [ $handler ] )
 
 This will return the current error handler for the tree. If a value is passed
 in, then it will be used to set the error handler for the tree.
@@ -635,19 +645,17 @@
 If called as a class method, this will instead work with the default error
 handler.
 
-=item * B<error( $error, [ arg1 [, arg2 ...] ] )>
+=head2 error( $error, [ arg1 [, arg2 ...] ] )
 
 Call this when you wish to report an error using the currently defined
 error_handler for the tree. The only guaranteed parameter is an error string
 describing the issue. There may be other arguments, and you may certainly
 provide other arguments in your subclass to be passed to your custom handler.
 
-=item * B<last_error()>
+=head2 last_error()
 
 If an error occurred during the last behavior, this will return the error
-string. It is reset only when a behavior is called.
-
-=back
+string. It is reset only by add_child() and remove_child().
 
 =head2 Default error handlers
 
@@ -656,7 +664,7 @@
 =item QUIET
 
 Use this error handler if you want to have quiet error-handling. The
-last_error method will retrieve the error from the last operation, if there
+L</last_error()> method will retrieve the error from the last operation, if there
 was one. If an error occurs, the operation will return undefined.
 
 =item WARN
@@ -667,7 +675,7 @@
 
 =head1 EVENT HANDLING
 
-Forest provides for basic event handling. You may choose to register one or
+Tree provides for basic event handling. You may choose to register one or
 more callbacks to be called when the appropriate event occurs. The events
 are:
 
@@ -675,14 +683,14 @@
 
 =item * add_child
 
-This event will trigger as the last step in an L<add_child()> call.
+This event will trigger as the last step in an L</add_child([$options], @nodes)> call.
 
 The parameters will be C<( $self, @args )> where C<@args> is the arguments
 passed into the add_child() call.
 
 =item * remove_child
 
-This event will trigger as the last step in an L<remove_child()> call.
+This event will trigger as the last step in an L</remove_child([$options], @nodes)> call.
 
 The parameters will be C<( $self, @args )> where C<@args> is the arguments
 passed into the remove_child() call.
@@ -699,14 +707,12 @@
 
 =head2 Event handling methods
 
-=over 4
-
-=item * B<add_event_handler( $type => $callback [, $type => $callback, ... ])>
+=head2 add_event_handler( {$type => $callback [, $type => $callback, ... ]} )
 
 You may choose to add event handlers for any known type. Callbacks must be
 references to subroutines. They will be called in the order they are defined.
 
-=item * B<event( $type, $actor, @args )>
+=head2 event( $type, $actor, @args )
 
 This will trigger an event of type C<$type>. All event handlers registered on
 C<$tree> will be called with parameters of C<($actor, @args)>. Then, the
@@ -716,14 +722,12 @@
 This allows you specify an event handler on the root and be guaranteed that it
 will fire every time the appropriate event occurs anywhere in the tree.
 
-=back
-
 =head1 NULL TREE
 
 If you call C<$self-E<gt>parent> on a root node, it will return a Tree::Null
 object. This is an implementation of the Null Object pattern optimized for
 usage with L<Tree>. It will evaluate as false in every case (using
-L<overload>) and all methods called on it will return a Tree::Null object.
+I<overload>) and all methods called on it will return a Tree::Null object.
 
 =head2 Notes
 
@@ -754,11 +758,13 @@
 
 Please q.v. L<Forest> for more info on this topic.
 
-=head1 WHAT'S NOT HERE
-
-=over 4
-
-=item * The Visitor pattern
+=head1 FAQ
+
+=head2 Which is the best tree processing module?
+
+L<Tree::DAG_Node>. More details: L</SEE ALSO>.
+
+=head2 How do I implement the visitor pattern?
 
 I have deliberately chosen to not implement the Visitor pattern as described
 by Gamma et al. Given a sufficiently powerful C<traverse()> and Perl's
@@ -787,10 +793,42 @@
       }
   }
 
+=head2 Should I implement the visitor pattern?
+
+No. You're better off using the L<Tree::DAG_Node/walk_down($options)> method.
+
+=head1 SEE ALSO
+
+=over 4
+
+=item o L<Tree::Binary>
+
+Lightweight.
+
+=item o L<Tree::DAG_Node>
+
+Lightweight, and with a long list of methods.
+
+=item o L<Tree::DAG_Node::Persist>
+
+Lightweight.
+
+=item o L<Tree::Persist>
+
+Lightweight.
+
+=item o L<Forest>
+
+Uses L<Moose>.
+
 =back
 
+C<Tree> itself is also lightweight.
+
 =head1 CODE COVERAGE
 
+These statistics are as of V 1.01.
+
 We use L<Devel::Cover> to test the code coverage of our tests. Below is the
 L<Devel::Cover> report on this module's test suite.
 
@@ -824,6 +862,9 @@
 
 Thanks to Infinity Interactive for generously donating our time.
 
+Co-maintenance since V 1.02 is by Ron Savage <[e-mail]>.
+Uses of 'I' in previous versions is not me, but will be hereafter.
+
 =head1 COPYRIGHT AND LICENSE
 
 Copyright 2004, 2005 by Infinity Interactive, Inc.
@@ -831,6 +872,6 @@
 L<http://www.iinteractive.com>
 
 This library is free software; you can redistribute it and/or modify it under
-the same terms as Perl itself. 
+the same terms as Perl itself.
 
 =cut

=== removed file 'lib/Tree/Binary.pm'
--- lib/Tree/Binary.pm	2008-01-17 12:56:58 +0000
+++ lib/Tree/Binary.pm	1970-01-01 00:00:00 +0000
@@ -1,330 +0,0 @@
-package Tree::Binary;
-
-use 5.006;
-
-use strict;
-use warnings FATAL => 'all';
-
-use Scalar::Util qw( blessed );
-
-use base qw( Tree );
-
-our $VERSION = '1.01';
-
-sub _init {
-    my $self = shift;
-    $self->SUPER::_init( @_ );
-
-    # Make this class a complete binary tree,
-    # filling in with Tree::Null as appropriate.
-    $self->{_children}->[$_] = $self->_null
-        for 0 .. 1;
-
-    return $self;
-}
-
-sub left {
-    my $self = shift;
-    return $self->_set_get_child( 0, @_ );
-}
-
-sub right {
-    my $self = shift;
-    return $self->_set_get_child( 1, @_ );
-}
-
-sub _set_get_child {
-    my $self = shift;
-    my $index = shift;
-
-    if ( @_ ) {
-        my $node = shift;
-        $node = $self->_null unless $node;
-
-        my $old = $self->children->[$index];
-        $self->children->[$index] = $node;
-
-        if ( $node ) {
-            $node->_set_parent( $self );
-            $node->_set_root( $self->root );
-            $node->_fix_depth;
-        }
-
-        if ( $old ) {
-            $old->_set_parent( $old->_null );
-            $old->_set_root( $old->_null );
-            $old->_fix_depth;
-        }
-
-        $self->_fix_height;
-        $self->_fix_width;
-
-        return $self;
-    }
-    else {
-        return $self->children->[$index];
-    }
-}
-
-sub _clone_children {
-    my ($self, $clone) = @_;
-
-    @{ $clone->{_children} } = ();
-    $clone->add_child({}, map { $_->clone } @{ $self->{_children} });
-}
-
-sub children {
-    my $self = shift;
-    if ( @_ ) {
-        my @idx = @_;
-        return @{$self->{_children}}[@idx];
-    }
-    else {
-        if ( caller->isa( __PACKAGE__ ) || $self->isa( scalar(caller) ) ) {
-            return wantarray ? @{$self->{_children}} : $self->{_children};
-        }
-        else {
-            return grep { $_ } @{$self->{_children}};
-        }
-    }
-}
-
-use constant IN_ORDER => 4;
-
-# One of the things we have to do in a traversal is to remove all of the
-# Tree::Null elements that are appended to the tree to make this a complete
-# binary tree. The user isn't going to expect them, because they're an
-# internal nicety.
-
-sub traverse {
-    my $self = shift;
-    my $order = shift;
-    $order = $self->PRE_ORDER unless $order;
-
-    if ( wantarray ) {
-        if ( $order == $self->IN_ORDER ) {
-            return grep { $_ } (
-                $self->left->traverse( $order ),
-                $self,
-                $self->right->traverse( $order ),
-            );
-        }
-        else {
-            return grep { $_ } $self->SUPER::traverse( $order );
-        }
-    }
-    else {
-        my $closure;
-
-        if ( $order eq $self->IN_ORDER ) {
-            my @list = $self->traverse( $order );
-
-            $closure = sub {
-                return unless @list;
-                return shift @list;
-            };
-        }
-        elsif ( $order eq $self->PRE_ORDER ) {
-            my $next_node = $self;
-            my @stack = ( $self );
-            my @next_meth = ( 0 );
-
-            my @meths = qw( left right );
-            $closure = sub {
-                my $node = $next_node;
-                return unless $node;
-                $next_node = undef;
-
-                while ( @stack && !$next_node ) {
-                    while ( @next_meth && $next_meth[0] == 2 ) {
-                        shift @stack;
-                        shift @next_meth;
-                    }
-
-                    if ( @stack ) {
-                        my $meth = $meths[ $next_meth[0]++ ];
-                        $next_node = $stack[0]->$meth;
-                        next unless $next_node;
-                        unshift @stack, $next_node;
-                        unshift @next_meth, 0;
-                    }
-                }
-
-                return $node;
-            };
-        }
-        elsif ( $order eq $self->POST_ORDER ) {
-            my @list = $self->traverse( $order );
-
-            $closure = sub {
-                return unless @list;
-                return shift @list;
-            };
-            #my @stack = ( $self );
-            #my @next_idx = ( 0 );
-            #while ( @{ $stack[0]->{_children} } ) {
-            #    unshift @stack, $stack[0]->{_children}[0];
-            #    unshift @next_idx, 0;
-            #}
-            #
-            #$closure = sub {
-            #    my $node = $stack[0] || return;
-            #
-            #    shift @stack; shift @next_idx;
-            #    $next_idx[0]++;
-            #
-            #    while ( @stack && exists $stack[0]->{_children}[ $next_idx[0] ] ) {
-            #        unshift @stack, $stack[0]->{_children}[ $next_idx[0] ];
-            #        unshift @next_idx, 0;
-            #    }
-            #
-            #    return $node;
-            #};
-        }
-        elsif ( $order eq $self->LEVEL_ORDER ) {
-            my @nodes = ($self);
-            $closure = sub {
-                my $node = shift @nodes;
-                return unless $node;
-                push @nodes, grep { $_ } @{$node->{_children}};
-                return $node;
-            };
-        }
-        else {
-            return $self->error( "traverse(): '$order' is an illegal traversal order" );
-        }
-
-        return $closure;
-    }
-}
-
-1;
-__END__
-
-=head1 NAME
-
-Tree::Binary - An implementation of a binary tree
-
-=head1 SYNOPSIS
-
-  my $tree = Tree::Binary->new( 'root' );
-
-  my $left = Tree::Binary->new( 'left' );
-  $tree->left( $left );
-
-  my $right = Tree::Binary->new( 'left' );
-  $tree->right( $right );
-
-  my $right_child = $tree->right;
-
-  $tree->right( undef ); # Unset the right child.
-
-  my @nodes = $tree->traverse( $tree->POST_ORDER );
-
-  my $traversal = $tree->traverse( $tree->IN_ORDER );
-  while ( my $node = $traversal->() ) {
-      # Do something with $node here
-  }
-
-=head1 DESCRIPTION
-
-This is an implementation of a binary tree. This class inherits from L<Tree>,
-which is an N-ary tree implemenation. Because of this, this class actually
-provides an implementation of a complete binary tree vs. a sparse binary tree.
-The empty nodes are instances of Tree::Null, which is described in L<Tree>.
-This should have no effect on your usage of this class.
-
-=head1 METHODS
-
-In addition to the methods provided by L<Tree>, the following items are
-provided or overriden.
-
-=over 4
-
-=item * C<left([$child])> / C<right([$child])>
-
-These access the left and right children, respectively. They are mutators,
-which means that their behavior changes depending on if you pass in a value.
-
-If you do not pass in any parameters, then it will act as a getter for the
-specific child, return the child (if set) or undef (if not).
-
-If you pass in a child, it will act as a setter for the specific child,
-setting the child to the passed-in value and returning the $tree. (Thus, this
-method chains.)
-
-If you wish to unset the child, do C<$treeE<gt>left( undef );>
-
-=item * C<children()>
-
-This will return the children of the tree.
-
-B<NOTE:> There will be two children, always. Tree::Binary implements a
-complete binary tree, filling in missing children with Tree::Null objects.
-(Please see L<Tree::Fast> for more information on Tree::Null.)
-
-=item * B<traverse( [$order] )>
-
-When called in list context (C<my @traversal = $tree-E<gt>traverse()>), this will
-return a list of the nodes in the given traversal order. When called in scalar
-context (C<my $traversal = $tree-E<gt>traverse()>), this will return a closure
-that will, over successive calls, iterate over the nodes in the given
-traversal order. When finished it will return false.
-
-The default traversal order is pre-order.
-
-In addition to the traversal orders provided by L<Tree>, Tree::Binary provides
-in-order traversals.
-
-=over 4
-
-=item * In-order
-
-This will return the result of an in-order traversal on the left node (if
-any), then the node, then the result of an in-order traversal on the right
-node (if any).
-
-=back
-
-=back
-
-B<NOTE:> You have access to all the methods provided by L<Tree>, but it is not
-recommended that you use many of them, unless you know what you're doing. This
-list includes C<add_child()> and C<remove_child()>.
-
-=head1 TODO
-
-=over 4
-
-=item * Make in-order closure traversal work iteratively
-
-=item * Make post-order closure traversal work iteratively
-
-=back
-
-=head1 CODE COVERAGE
-
-Please see the relevant sections of L<Tree>.
-
-=head1 SUPPORT
-
-Please see the relevant sections of L<Tree>.
-
-=head1 AUTHORS
-
-Rob Kinyon E<lt>[e-mail]<gt>
-
-Stevan Little E<lt>[e-mail]<gt>
-
-Thanks to Infinity Interactive for generously donating our time.
-
-=head1 COPYRIGHT AND LICENSE
-
-Copyright 2004, 2005 by Infinity Interactive, Inc.
-
-L<http://www.iinteractive.com>
-
-This library is free software; you can redistribute it and/or modify it under
-the same terms as Perl itself.
-
-=cut

=== added file 'lib/Tree/Binary2.pm'
--- lib/Tree/Binary2.pm	1970-01-01 00:00:00 +0000
+++ lib/Tree/Binary2.pm	2014-12-12 23:08:52 +0000
@@ -0,0 +1,330 @@
+package Tree::Binary2;
+
+use 5.006;
+
+use strict;
+use warnings FATAL => 'all';
+
+use Scalar::Util qw( blessed );
+
+use base qw( Tree );
+
+our $VERSION = '1.05';
+
+sub _init {
+    my $self = shift;
+    $self->SUPER::_init( @_ );
+
+    # Make this class a complete binary tree,
+    # filling in with Tree::Null as appropriate.
+    $self->{_children}->[$_] = $self->_null
+        for 0 .. 1;
+
+    return $self;
+}
+
+sub left {
+    my $self = shift;
+    return $self->_set_get_child( 0, @_ );
+}
+
+sub right {
+    my $self = shift;
+    return $self->_set_get_child( 1, @_ );
+}
+
+sub _set_get_child {
+    my $self = shift;
+    my $index = shift;
+
+    if ( @_ ) {
+        my $node = shift;
+        $node = $self->_null unless $node;
+
+        my $old = $self->children->[$index];
+        $self->children->[$index] = $node;
+
+        if ( $node ) {
+            $node->_set_parent( $self );
+            $node->_set_root( $self->root );
+            $node->_fix_depth;
+        }
+
+        if ( $old ) {
+            $old->_set_parent( $old->_null );
+            $old->_set_root( $old->_null );
+            $old->_fix_depth;
+        }
+
+        $self->_fix_height;
+        $self->_fix_width;
+
+        return $self;
+    }
+    else {
+        return $self->children->[$index];
+    }
+}
+
+sub _clone_children {
+    my ($self, $clone) = @_;
+
+    @{ $clone->{_children} } = ();
+    $clone->add_child({}, map { $_->clone } @{ $self->{_children} });
+}
+
+sub children {
+    my $self = shift;
+    if ( @_ ) {
+        my @idx = @_;
+        return @{$self->{_children}}[@idx];
+    }
+    else {
+        if ( caller->isa( __PACKAGE__ ) || $self->isa( scalar(caller) ) ) {
+            return wantarray ? @{$self->{_children}} : $self->{_children};
+        }
+        else {
+            return grep { $_ } @{$self->{_children}};
+        }
+    }
+}
+
+use constant IN_ORDER => 4;
+
+# One of the things we have to do in a traversal is to remove all of the
+# Tree::Null elements that are appended to the tree to make this a complete
+# binary tree. The user isn't going to expect them, because they're an
+# internal nicety.
+
+sub traverse {
+    my $self = shift;
+    my $order = shift;
+    $order = $self->PRE_ORDER unless $order;
+
+    if ( wantarray ) {
+        if ( $order == $self->IN_ORDER ) {
+            return grep { $_ } (
+                $self->left->traverse( $order ),
+                $self,
+                $self->right->traverse( $order ),
+            );
+        }
+        else {
+            return grep { $_ } $self->SUPER::traverse( $order );
+        }
+    }
+    else {
+        my $closure;
+
+        if ( $order eq $self->IN_ORDER ) {
+            my @list = $self->traverse( $order );
+
+            $closure = sub {
+                return unless @list;
+                return shift @list;
+            };
+        }
+        elsif ( $order eq $self->PRE_ORDER ) {
+            my $next_node = $self;
+            my @stack = ( $self );
+            my @next_meth = ( 0 );
+
+            my @meths = qw( left right );
+            $closure = sub {
+                my $node = $next_node;
+                return unless $node;
+                $next_node = undef;
+
+                while ( @stack && !$next_node ) {
+                    while ( @next_meth && $next_meth[0] == 2 ) {
+                        shift @stack;
+                        shift @next_meth;
+                    }
+
+                    if ( @stack ) {
+                        my $meth = $meths[ $next_meth[0]++ ];
+                        $next_node = $stack[0]->$meth;
+                        next unless $next_node;
+                        unshift @stack, $next_node;
+                        unshift @next_meth, 0;
+                    }
+                }
+
+                return $node;
+            };
+        }
+        elsif ( $order eq $self->POST_ORDER ) {
+            my @list = $self->traverse( $order );
+
+            $closure = sub {
+                return unless @list;
+                return shift @list;
+            };
+            #my @stack = ( $self );
+            #my @next_idx = ( 0 );
+            #while ( @{ $stack[0]->{_children} } ) {
+            #    unshift @stack, $stack[0]->{_children}[0];
+            #    unshift @next_idx, 0;
+            #}
+            #
+            #$closure = sub {
+            #    my $node = $stack[0] || return;
+            #
+            #    shift @stack; shift @next_idx;
+            #    $next_idx[0]++;
+            #
+            #    while ( @stack && exists $stack[0]->{_children}[ $next_idx[0] ] ) {
+            #        unshift @stack, $stack[0]->{_children}[ $next_idx[0] ];
+            #        unshift @next_idx, 0;
+            #    }
+            #
+            #    return $node;
+            #};
+        }
+        elsif ( $order eq $self->LEVEL_ORDER ) {
+            my @nodes = ($self);
+            $closure = sub {
+                my $node = shift @nodes;
+                return unless $node;
+                push @nodes, grep { $_ } @{$node->{_children}};
+                return $node;
+            };
+        }
+        else {
+            return $self->error( "traverse(): '$order' is an illegal traversal order" );
+        }
+
+        return $closure;
+    }
+}
+
+1;
+__END__
+
+=head1 NAME
+
+Tree::Binary2 - An implementation of a binary tree
+
+=head1 SYNOPSIS
+
+  my $tree = Tree::Binary2->new( 'root' );
+
+  my $left = Tree::Binary2->new( 'left' );
+  $tree->left( $left );
+
+  my $right = Tree::Binary2->new( 'left' );
+  $tree->right( $right );
+
+  my $right_child = $tree->right;
+
+  $tree->right( undef ); # Unset the right child.
+
+  my @nodes = $tree->traverse( $tree->POST_ORDER );
+
+  my $traversal = $tree->traverse( $tree->IN_ORDER );
+  while ( my $node = $traversal->() ) {
+      # Do something with $node here
+  }
+
+=head1 DESCRIPTION
+
+This is an implementation of a binary tree. This class inherits from L<Tree>,
+which is an N-ary tree implemenation. Because of this, this class actually
+provides an implementation of a complete binary tree vs. a sparse binary tree.
+The empty nodes are instances of Tree::Null, which is described in L<Tree>.
+This should have no effect on your usage of this class.
+
+=head1 METHODS
+
+In addition to the methods provided by L<Tree>, the following items are
+provided or overriden.
+
+=over 4
+
+=item * C<left([$child])> / C<right([$child])>
+
+These access the left and right children, respectively. They are mutators,
+which means that their behavior changes depending on if you pass in a value.
+
+If you do not pass in any parameters, then it will act as a getter for the
+specific child, return the child (if set) or undef (if not).
+
+If you pass in a child, it will act as a setter for the specific child,
+setting the child to the passed-in value and returning the $tree. (Thus, this
+method chains.)
+
+If you wish to unset the child, do C<$treeE<gt>left( undef );>
+
+=item * C<children()>
+
+This will return the children of the tree.
+
+B<NOTE:> There will be two children, always. Tree::Binary2 implements a
+complete binary tree, filling in missing children with Tree::Null objects.
+(Please see L<Tree::Fast> for more information on Tree::Null.)
+
+=item * B<traverse( [$order] )>
+
+When called in list context (C<my @traversal = $tree-E<gt>traverse()>), this will
+return a list of the nodes in the given traversal order. When called in scalar
+context (C<my $traversal = $tree-E<gt>traverse()>), this will return a closure
+that will, over successive calls, iterate over the nodes in the given
+traversal order. When finished it will return false.
+
+The default traversal order is pre-order.
+
+In addition to the traversal orders provided by L<Tree>, Tree::Binary2 provides
+in-order traversals.
+
+=over 4
+
+=item * In-order
+
+This will return the result of an in-order traversal on the left node (if
+any), then the node, then the result of an in-order traversal on the right
+node (if any).
+
+=back
+
+=back
+
+B<NOTE:> You have access to all the methods provided by L<Tree>, but it is not
+recommended that you use many of them, unless you know what you're doing. This
+list includes C<add_child()> and C<remove_child()>.
+
+=head1 TODO
+
+=over 4
+
+=item * Make in-order closure traversal work iteratively
+
+=item * Make post-order closure traversal work iteratively
+
+=back
+
+=head1 CODE COVERAGE
+
+Please see the relevant sections of L<Tree>.
+
+=head1 SUPPORT
+
+Please see the relevant sections of L<Tree>.
+
+=head1 AUTHORS
+
+Rob Kinyon E<lt>[e-mail]<gt>
+
+Stevan Little E<lt>[e-mail]<gt>
+
+Thanks to Infinity Interactive for generously donating our time.
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright 2004, 2005 by Infinity Interactive, Inc.
+
+L<http://www.iinteractive.com>
+
+This library is free software; you can redistribute it and/or modify it under
+the same terms as Perl itself.
+
+=cut

=== modified file 'lib/Tree/Fast.pm' (properties changed: +x to -x)
--- lib/Tree/Fast.pm	2008-01-17 12:56:58 +0000
+++ lib/Tree/Fast.pm	2014-12-12 23:08:52 +0000
@@ -1,543 +1,547 @@
-package Tree::Fast;
-
-use 5.006;
-
-use strict;
-use warnings FATAL => 'all';
-
-our $VERSION = '1.01';
-
-use Scalar::Util qw( blessed weaken );
-
-sub new {
-    my $class = shift;
-
-    return $class->clone( @_ )
-        if blessed $class;
-
-    my $self = bless {}, $class;
-
-    $self->_init( @_ );
-
-    return $self;
-}
-
-sub _init {
-    my $self = shift;
-    my ($value) = @_;
-
-    $self->{_parent} = $self->_null,
-    $self->{_children} = [];
-    $self->{_value} = $value,
-
-    $self->{_meta} = {};
-
-    return $self;
-}
-
-sub _clone_self {
-    my $self = shift;
-
-    my $value = @_ ? shift : $self->value;
-    my $clone = blessed($self)->new( $value );
-    return blessed($self)->new( $value );
-}
-
-sub _clone_children {
-    my ($self, $clone) = @_;
-
-    if ( my @children = @{$self->{_children}} ) {
-        $clone->add_child({}, map { $_->clone } @children );
-    }
-}
-
-sub clone {
-    my $self = shift;
-
-    return $self->new(@_) unless blessed $self;
-
-    my $clone = $self->_clone_self(@_);
-    $self->_clone_children($clone);
-
-    return $clone;
-}
-
-sub add_child {
-    my $self = shift;
-    my ( $options, @nodes ) = @_;
-
-    for my $node ( @nodes ) {
-        $node->_set_parent( $self );
-    }
-
-    if ( defined $options->{at} ) {
-        if ( $options->{at} ) {
-            splice @{$self->{_children}}, $options->{at}, 0, @nodes;
-        }
-        else {
-            unshift @{$self->{_children}}, @nodes;
-        }
-    }
-    else {
-        push @{$self->{_children}}, @nodes;
-    }
-
-    return $self;
-}
-
-sub remove_child {
-    my $self = shift;
-    my ($options, @indices) = @_;
-
-    my @return;
-    for my $idx (sort { $b <=> $a } @indices) {
-        my $node = splice @{$self->{_children}}, $idx, 1;
-        $node->_set_parent( $node->_null );
-
-        push @return, $node;
-    }
-
-    return @return;
-}
-
-sub parent {
-    my $self = shift;
-    return $self->{_parent};
-}
-
-sub _set_parent {
-    my $self = shift;
-
-    $self->{_parent} = shift;
-    weaken( $self->{_parent} );
-
-    return $self;
-}
-
-sub children {
-    my $self = shift;
-    if ( @_ ) {
-        my @idx = @_;
-        return @{$self->{_children}}[@idx];
-    }
-    else {
-        if ( caller->isa( __PACKAGE__ ) || $self->isa( scalar(caller) ) ) {
-            return wantarray ? @{$self->{_children}} : $self->{_children};
-        }
-        else {
-            return @{$self->{_children}};
-        }
-    }
-}
-
-sub value {
-    my $self = shift;
-    return $self->{_value};
-}
-
-sub set_value {
-    my $self = shift;
-
-    $self->{_value} = $_[0];
-
-    return $self;
-}
-
-sub meta {
-    my $self = shift;
-    return $self->{_meta};
-}
-
-sub mirror {
-    my $self = shift;
-
-    @{$self->{_children}} = reverse @{$self->{_children}};
-    $_->mirror for @{$self->{_children}};
-
-    return $self;
-}
-
-use constant PRE_ORDER   => 1;
-use constant POST_ORDER  => 2;
-use constant LEVEL_ORDER => 3;
-
-sub traverse {
-    my $self = shift;
-    my $order = shift;
-    $order = $self->PRE_ORDER unless $order;
-
-    if ( wantarray ) {
-        my @list;
-
-        if ( $order eq $self->PRE_ORDER ) {
-            @list = ($self);
-            push @list, map { $_->traverse( $order ) } @{$self->{_children}};
-        }
-        elsif ( $order eq $self->POST_ORDER ) {
-            @list = map { $_->traverse( $order ) } @{$self->{_children}};
-            push @list, $self;
-        }
-        elsif ( $order eq $self->LEVEL_ORDER ) {
-            my @queue = ($self);
-            while ( my $node = shift @queue ) {
-                push @list, $node;
-                push @queue, @{$node->{_children}};
-            }
-        }
-        else {
-            return $self->error( "traverse(): '$order' is an illegal traversal order" );
-        }
-
-        return @list;
-    }
-    else {
-        my $closure;
-
-        if ( $order eq $self->PRE_ORDER ) {
-            my $next_node = $self;
-            my @stack = ( $self );
-            my @next_idx = ( 0 );
-
-            $closure = sub {
-                my $node = $next_node;
-                return unless $node;
-                $next_node = undef;
-
-                while ( @stack && !$next_node ) {
-                    while ( @stack && !exists $stack[0]->{_children}[ $next_idx[0] ] ) {
-                        shift @stack;
-                        shift @next_idx;
-                    }
-
-                    if ( @stack ) {
-                        $next_node = $stack[0]->{_children}[ $next_idx[0]++ ];
-                        unshift @stack, $next_node;
-                        unshift @next_idx, 0;
-                    }
-                }
-
-                return $node;
-            };
-        }
-        elsif ( $order eq $self->POST_ORDER ) {
-            my @stack = ( $self );
-            my @next_idx = ( 0 );
-            while ( @{ $stack[0]->{_children} } ) {
-                unshift @stack, $stack[0]->{_children}[0];
-                unshift @next_idx, 0;
-            }
-
-            $closure = sub {
-                my $node = $stack[0];
-                return unless $node;
-
-                shift @stack; shift @next_idx;
-                $next_idx[0]++;
-
-                while ( @stack && exists $stack[0]->{_children}[ $next_idx[0] ] ) {
-                    unshift @stack, $stack[0]->{_children}[ $next_idx[0] ];
-                    unshift @next_idx, 0;
-                }
-
-                return $node;
-            };
-        }
-        elsif ( $order eq $self->LEVEL_ORDER ) {
-            my @nodes = ($self);
-            $closure = sub {
-                my $node = shift @nodes;
-                return unless $node;
-                push @nodes, @{$node->{_children}};
-                return $node;
-            };
-        }
-        else {
-            return $self->error( "traverse(): '$order' is an illegal traversal order" );
-        }
-
-        return $closure;
-    }
-}
-
-sub _null {
-    return Tree::Null->new;
-}
-
-package Tree::Null;
-
-#XXX Add this in once it's been thought out
-#our @ISA = qw( Tree );
-
-# You want to be able to interrogate the null object as to
-# its class, so we don't override isa() as we do can()
-
-use overload
-    '""' => sub { return "" },
-    '0+' => sub { return 0 },
-    'bool' => sub { return },
-        fallback => 1,
-;
-
-{
-    my $singleton = bless \my($x), __PACKAGE__;
-    sub new { return $singleton }
-    sub AUTOLOAD { return $singleton }
-    sub can { return sub { return $singleton } }
-}
-
-# The null object can do anything
-sub isa {
-    my ($proto, $class) = @_;
-
-    if ( $class =~ /^Tree(?:::.*)?$/ ) {
-        return 1;
-    }
-
-    return $proto->SUPER::isa( $class );
-}
-
-1;
-__END__
-
-=head1 NAME
-
-Tree::Fast - the fastest possible implementation of a tree in pure Perl
-
-=head1 SYNOPSIS
-
-  my $tree = Tree->new( 'root' );
-  my $child = Tree->new( 'child' );
-  $tree->add_child( {}, $child );
-
-  $tree->add_child( { at => 0 }, Tree->new( 'first child' ) );
-  $tree->add_child( { at => -1 }, Tree->new( 'last child' ) );
-
-  my @children = $tree->children;
-  my @some_children = $tree->children( 0, 2 );
-
-  $tree->remove_child( 0 );
-
-  my @nodes = $tree->traverse( $tree->POST_ORDER );
-
-  my $traversal = $tree->traverse( $tree->POST_ORDER );
-  while ( my $node = $traversal->() ) {
-      # Do something with $node here
-  }
-
-  my $clone = $tree->clone;
-  my $mirror = $tree->clone->mirror;
-
-=head1 DESCRIPTION
-
-This is meant to be the core implementation for L<Tree>, stripped down as much
-as possible. There is no error-checking, bounds-checking, event-handling,
-convenience methods, or anything else of the sort. If you want something fuller-
-featured, please look at L<Tree>, which is a wrapper around Tree::Fast.
-
-=head1 METHODS
-
-=head2 Constructor
-
-=over 4
-
-=item B<new([$value])>
-
-This will return a Tree object. It will accept one parameter which, if passed,
-will become the value (accessible by L<value()>). All other parameters will be
-ignored.
-
-If you call C<$tree-E<gt>new([$value])>, it will instead call C<clone()>, then set
-the value of the clone to $value.
-
-=item B<clone()>
-
-This will return a clone of C<$tree>. The clone will be a root tree, but all
-children will be cloned.
-
-If you call C<Tree-E<gt>clone([$value])>, it will instead call C<new()>.
-
-B<NOTE:> the value is merely a shallow copy. This means that all references
-will be kept.
-
-=back
-
-=head2 Behaviors
-
-=over 4
-
-=item B<add_child($options, @nodes)>
-
-This will add all the @nodes as children of C<$tree>. $options is a required
-hashref that specifies options for add_child(). The optional parameters are:
-
-=over 4
-
-=item * at
-
-This specifies the index to add @nodes at. If specified, this will be passed
-into splice(). The only exceptions are if this is 0, it will act as an
-unshift(). If it is unset or undefined, it will act as a push().
-
-=back
-
-=item B<remove_child($options, @nodes)>
-
-This will remove all the @nodes from the children of C<$tree>. You can either
-pass in the actual child object you wish to remove, the index of the child you
-wish to remove, or a combination of both.
-
-$options is a required hashref that specifies parameters for remove_child().
-Currently, no parameters are used.
-
-=item B<mirror()>
-
-This will modify the tree such that it is a mirror of what it was before. This
-means that the order of all children is reversed.
-
-B<NOTE>: This is a destructive action. It I<will> modify the tree's internal
-structure. If you wish to get a mirror, yet keep the original tree intact, use
-C<my $mirror = $tree-E<gt>clone-E<gt>mirror;>
-
-=item B<traverse( [$order] )>
-
-When called in list context (C<my @traversal = $tree-E<gt>traverse()>), this will
-return a list of the nodes in the given traversal order. When called in scalar
-context (C<my $traversal = $tree-E<gt>traverse()>), this will return a closure
-that will, over successive calls, iterate over the nodes in the given
-traversal order. When finished it will return false.
-
-The default traversal order is pre-order.
-
-The various traversal orders do the following steps:
-
-=over 4
-
-=item * Pre-order (aka Prefix traversal)
-
-This will return the node, then the first sub tree in pre-order traversal,
-then the next sub tree, etc.
-
-Use C<$tree-E<gt>PRE_ORDER> as the C<$order>.
-
-=item * Post-order (aka Prefix traversal)
-
-This will return the each sub-tree in post-order traversal, then the node.
-
-Use C<$tree-E<gt>POST_ORDER> as the C<$order>.
-
-=item * Level-order (aka Prefix traversal)
-
-This will return the node, then the all children of the node, then all
-grandchildren of the node, etc.
-
-Use C<$tree-E<gt>LEVEL_ORDER> as the C<$order>.
-
-=back
-
-=back
-
-=head2 Accessors
-
-=over 4
-
-=item * B<parent()>
-
-This will return the parent of C<$tree>.
-
-=item * B<children( [ $idx, [$idx, ..] ] )>
-
-This will return the children of C<$tree>. If called in list context, it will
-return all the children. If called in scalar context, it will return the
-number of children.
-
-You may optionally pass in a list of indices to retrieve. This will return the
-children in the order you asked for them. This is very much like an
-arrayslice.
-
-=item * B<value()>
-
-This will return the value stored in the node.
-
-=item * B<set_value([$value])>
-
-This will set the value stored in the node to $value, then return $self.
-
-=item * B<meta()>
-
-This will return a hashref that can be used to store whatever metadata the client
-wishes to store. For example, L<Tree::Persist::DB> uses this to store database
-row ids.
-
-It is recommended that you store your metadata in a subhashref and not in the
-top-level metadata hashref, keyed by your package name. L<Tree::Persist> does
-this, using a unique key for each persistence layer associated with that tree.
-This will help prevent clobbering of metadata.
-
-=back
-
-=head1 NULL TREE
-
-If you call C<$self-E<gt>parent> on a root node, it will return a Tree::Null
-object. This is an implementation of the Null Object pattern optimized for
-usage with L<Forest>. It will evaluate as false in every case (using
-L<overload>) and all methods called on it will return a Tree::Null object.
-
-=head2 Notes
-
-=over 4
-
-=item *
-
-Tree::Null does B<not> inherit from anything. This is so that all the
-methods will go through AUTOLOAD vs. the actual method.
-
-=item *
-
-However, calling isa() on a Tree::Null object will report that it is-a
-any object that is either Tree or in the Tree:: hierarchy.
-
-=item *
-
-The Tree::Null object is a singleton.
-
-=item *
-
-The Tree::Null object I<is> defined, though. I couldn't find a way to
-make it evaluate as undefined. That may be a good thing.
-
-=back
-
-=head1 CODE COVERAGE
-
-Please see the relevant sections of L<Tree>.
-
-=head1 SUPPORT
-
-Please see the relevant sections of L<Tree>.
-
-=head1 ACKNOWLEDGEMENTS
-
-=over 4
-
-=item * Stevan Little for writing L<Tree::Simple>, upon which Tree is based.
-
-=back
-
-=head1 AUTHORS
-
-Rob Kinyon E<lt>[e-mail]<gt>
-
-Stevan Little E<lt>[e-mail]<gt>
-
-Thanks to Infinity Interactive for generously donating our time.
-
-=head1 COPYRIGHT AND LICENSE
-
-Copyright 2004, 2005 by Infinity Interactive, Inc.
-
-L<http://www.iinteractive.com>
-
-This library is free software; you can redistribute it and/or modify it under
-the same terms as Perl itself. 
-
-=cut
+package Tree::Fast;
+
+use 5.006;
+
+use strict;
+use warnings FATAL => 'all';
+
+our $VERSION = '1.05';
+
+use Scalar::Util qw( blessed weaken );
+
+sub new {
+    my $class = shift;
+
+    return $class->clone( @_ )
+        if blessed $class;
+
+    my $self = bless {}, $class;
+
+    $self->_init( @_ );
+
+    return $self;
+}
+
+sub _init {
+    my $self = shift;
+    my ($value) = @_;
+
+    $self->{_parent} = $self->_null,
+    $self->{_children} = [];
+    $self->{_value} = $value,
+
+    $self->{_meta} = {};
+
+    return $self;
+}
+
+sub _clone_self {
+    my $self = shift;
+
+    my $value = @_ ? shift : $self->value;
+    my $clone = blessed($self)->new( $value );
+    return blessed($self)->new( $value );
+}
+
+sub _clone_children {
+    my ($self, $clone) = @_;
+
+    if ( my @children = @{$self->{_children}} ) {
+        $clone->add_child({}, map { $_->clone } @children );
+    }
+}
+
+sub clone {
+    my $self = shift;
+
+    return $self->new(@_) unless blessed $self;
+
+    my $clone = $self->_clone_self(@_);
+    $self->_clone_children($clone);
+
+    return $clone;
+}
+
+sub add_child {
+    my $self = shift;
+    my ( $options, @nodes ) = @_;
+
+    for my $node ( @nodes ) {
+        $node->_set_parent( $self );
+    }
+
+    if ( defined $options->{at} ) {
+        if ( $options->{at} ) {
+            splice @{$self->{_children}}, $options->{at}, 0, @nodes;
+        }
+        else {
+            unshift @{$self->{_children}}, @nodes;
+        }
+    }
+    else {
+        push @{$self->{_children}}, @nodes;
+    }
+
+    return $self;
+}
+
+sub remove_child {
+    my $self = shift;
+    my ($options, @indices) = @_;
+
+    my @return;
+    for my $idx (sort { $b <=> $a } @indices) {
+        my $node = splice @{$self->{_children}}, $idx, 1;
+        $node->_set_parent( $node->_null );
+
+        push @return, $node;
+    }
+
+    return @return;
+}
+
+sub parent {
+    my $self = shift;
+    return $self->{_parent};
+}
+
+sub _set_parent {
+    my $self = shift;
+
+    $self->{_parent} = shift;
+    weaken( $self->{_parent} );
+
+    return $self;
+}
+
+sub children {
+    my $self = shift;
+    if ( @_ ) {
+        my @idx = @_;
+        return @{$self->{_children}}[@idx];
+    }
+    else {
+        if ( caller->isa( __PACKAGE__ ) || $self->isa( scalar(caller) ) ) {
+            return wantarray ? @{$self->{_children}} : $self->{_children};
+        }
+        else {
+            return @{$self->{_children}};
+        }
+    }
+}
+
+sub value {
+    my $self        = shift;
+	my $value       = shift;
+	$self->{_value} = $value if (defined $value);
+
+    return $self->{_value};
+}
+
+sub set_value {
+    my $self = shift;
+
+    $self->{_value} = $_[0];
+
+    return $self;
+}
+
+sub meta {
+    my $self       = shift;
+    my $meta       = shift;
+    $self->{_meta} = {%{$self->{_meta} }, %$meta} if ($meta && !blessed($meta) && ref($meta) eq 'HASH');
+
+    return $self->{_meta};
+}
+
+sub mirror {
+    my $self = shift;
+
+    @{$self->{_children}} = reverse @{$self->{_children}};
+    $_->mirror for @{$self->{_children}};
+
+    return $self;
+}
+
+use constant PRE_ORDER   => 1;
+use constant POST_ORDER  => 2;
+use constant LEVEL_ORDER => 3;
+
+sub traverse {
+    my $self = shift;
+    my $order = shift;
+    $order = $self->PRE_ORDER unless $order;
+
+    if ( wantarray ) {
+        my @list;
+
+        if ( $order eq $self->PRE_ORDER ) {
+            @list = ($self);
+            push @list, map { $_->traverse( $order ) } @{$self->{_children}};
+        }
+        elsif ( $order eq $self->POST_ORDER ) {
+            @list = map { $_->traverse( $order ) } @{$self->{_children}};
+            push @list, $self;
+        }
+        elsif ( $order eq $self->LEVEL_ORDER ) {
+            my @queue = ($self);
+            while ( my $node = shift @queue ) {
+                push @list, $node;
+                push @queue, @{$node->{_children}};
+            }
+        }
+        else {
+            return $self->error( "traverse(): '$order' is an illegal traversal order" );
+        }
+
+        return @list;
+    }
+    else {
+        my $closure;
+
+        if ( $order eq $self->PRE_ORDER ) {
+            my $next_node = $self;
+            my @stack = ( $self );
+            my @next_idx = ( 0 );
+
+            $closure = sub {
+                my $node = $next_node;
+                return unless $node;
+                $next_node = undef;
+
+                while ( @stack && !$next_node ) {
+                    while ( @stack && !exists $stack[0]->{_children}[ $next_idx[0] ] ) {
+                        shift @stack;
+                        shift @next_idx;
+                    }
+
+                    if ( @stack ) {
+                        $next_node = $stack[0]->{_children}[ $next_idx[0]++ ];
+                        unshift @stack, $next_node;
+                        unshift @next_idx, 0;
+                    }
+                }
+
+                return $node;
+            };
+        }
+        elsif ( $order eq $self->POST_ORDER ) {
+            my @stack = ( $self );
+            my @next_idx = ( 0 );
+            while ( @{ $stack[0]->{_children} } ) {
+                unshift @stack, $stack[0]->{_children}[0];
+                unshift @next_idx, 0;
+            }
+
+            $closure = sub {
+                my $node = $stack[0];
+                return unless $node;
+
+                shift @stack; shift @next_idx;
+                $next_idx[0]++;
+
+                while ( @stack && exists $stack[0]->{_children}[ $next_idx[0] ] ) {
+                    unshift @stack, $stack[0]->{_children}[ $next_idx[0] ];
+                    unshift @next_idx, 0;
+                }
+
+                return $node;
+            };
+        }
+        elsif ( $order eq $self->LEVEL_ORDER ) {
+            my @nodes = ($self);
+            $closure = sub {
+                my $node = shift @nodes;
+                return unless $node;
+                push @nodes, @{$node->{_children}};
+                return $node;
+            };
+        }
+        else {
+            return $self->error( "traverse(): '$order' is an illegal traversal order" );
+        }
+
+        return $closure;
+    }
+}
+
+sub _null {
+    return Tree::Null->new;
+}
+
+package Tree::Null;
+
+#XXX Add this in once it's been thought out
+#our @ISA = qw( Tree );
+
+# You want to be able to interrogate the null object as to
+# its class, so we don't override isa() as we do can()
+
+use overload
+    '""' => sub { return "" },
+    '0+' => sub { return 0 },
+    'bool' => sub { return },
+        fallback => 1,
+;
+
+{
+    my $singleton = bless \my($x), __PACKAGE__;
+    sub new { return $singleton }
+    sub AUTOLOAD { return $singleton }
+    sub can { return sub { return $singleton } }
+}
+
+# The null object can do anything
+sub isa {
+    my ($proto, $class) = @_;
+
+    if ( $class =~ /^Tree(?:::.*)?$/ ) {
+        return 1;
+    }
+
+    return $proto->SUPER::isa( $class );
+}
+
+1;
+__END__
+
+=head1 NAME
+
+Tree::Fast - the fastest possible implementation of a tree in pure Perl
+
+=head1 SYNOPSIS
+
+  my $tree = Tree->new( 'root' );
+  my $child = Tree->new( 'child' );
+  $tree->add_child( {}, $child );
+
+  $tree->add_child( { at => 0 }, Tree->new( 'first child' ) );
+  $tree->add_child( { at => -1 }, Tree->new( 'last child' ) );
+
+  my @children = $tree->children;
+  my @some_children = $tree->children( 0, 2 );
+
+  $tree->remove_child( 0 );
+
+  my @nodes = $tree->traverse( $tree->POST_ORDER );
+
+  my $traversal = $tree->traverse( $tree->POST_ORDER );
+  while ( my $node = $traversal->() ) {
+      # Do something with $node here
+  }
+
+  my $clone = $tree->clone;
+  my $mirror = $tree->clone->mirror;
+
+=head1 DESCRIPTION
+
+This is meant to be the core implementation for L<Tree>, stripped down as much
+as possible. There is no error-checking, bounds-checking, event-handling,
+convenience methods, or anything else of the sort. If you want something fuller-featured,
+please look at L<Tree>, which is a wrapper around Tree::Fast.
+
+=head1 METHODS
+
+=head2 Constructors
+
+=head2 new([$value])
+
+Here, [] indicate an optional parameter.
+
+This will return a C<Tree> object. It will accept one parameter which, if passed,
+will become the I<value> (accessible by C<value()>). All other parameters will be
+ignored.
+
+If you call C<< $tree->new([$value]) >>, it will instead call C<clone()>, then set
+the I<value> of the clone to $value.
+
+=head2 clone()
+
+This will return a clone of C<$tree>. The clone will be a root tree, but all
+children will be cloned.
+
+If you call C<< Tree->clone([$value]) >>, it will instead call C<new()>.
+
+B<NOTE:> the value is merely a shallow copy. This means that all references
+will be kept.
+
+=head2 Behaviors
+
+=head2 add_child($options, @nodes)
+
+This will add all the C<@nodes> as children of C<$tree>. C<$options> is a required
+hashref that specifies options for C<add_child()>. The optional parameters are:
+
+=over 4
+
+=item * at
+
+This specifies the index to add C<@nodes> at. If specified, this will be passed
+into splice(). The only exceptions are if this is 0, it will act as an
+unshift(). If it is unset or undefined, it will act as a push().
+
+=back
+
+=head2 remove_child($options, @nodes)
+
+This will remove all the C<@nodes> from the children of C<$tree>. You can either
+pass in the actual child object you wish to remove, the index of the child you
+wish to remove, or a combination of both.
+
+$options is a required hashref that specifies parameters for remove_child().
+Currently, no parameters are used.
+
+=head2 mirror()
+
+This will modify the tree such that it is a mirror of what it was before. This
+means that the order of all children is reversed.
+
+B<NOTE>: This is a destructive action. It I<will> modify the tree's internal
+structure. If you wish to get a mirror, yet keep the original tree intact, use
+C<< my $mirror = $tree->clone->mirror >>.
+
+=head2 traverse( [$order] )
+
+Here, [] indicate an optional parameter.
+
+When called in list context (C<< my @traversal = $tree->traverse() >>), this will
+return a list of the nodes in the given traversal order. When called in scalar
+context (C<< my $traversal = $tree->traverse() >>), this will return a closure
+that will, over successive calls, iterate over the nodes in the given
+traversal order. When finished it will return false.
+
+The default traversal order is pre-order.
+
+The various traversal orders do the following steps:
+
+=over 4
+
+=item * Pre-order
+
+This will return the node, then the first sub tree in pre-order traversal,
+then the next sub tree, etc.
+
+Use C<< $tree->PRE_ORDER >> as the C<$order>.
+
+=item * Post-order
+
+This will return the each sub-tree in post-order traversal, then the node.
+
+Use C<< $tree->POST_ORDER >> as the C<$order>.
+
+=item * Level-order
+
+This will return the node, then the all children of the node, then all
+grandchildren of the node, etc.
+
+Use C<< $tree->LEVEL_ORDER >> as the C<$order>.
+
+=back
+
+=head2 Accessors
+
+=head2 parent()
+
+This will return the parent of C<$tree>.
+
+=head2 children( [ $idx, [$idx, ..] ] )
+
+Here, [] indicate optional parameters.
+
+This will return the children of C<$tree>. If called in list context, it will
+return all the children. If called in scalar context, it will return the
+number of children.
+
+You may optionally pass in a list of indices to retrieve. This will return the
+children in the order you asked for them. This is very much like an
+arrayslice.
+
+=head2 value()
+
+This will return the value stored in the node.
+
+=head2 set_value([$value])
+
+Here, [] indicate an optional parameter.
+
+This will set the I<value> stored in the node to $value, then return $self.
+
+If C<$value> is not provided, undef is used.
+
+=head2 meta()
+
+This will return a hashref that can be used to store whatever metadata the client
+wishes to store. For example, L<Tree::Persist::DB> uses this to store database
+row ids.
+
+It is recommended that you store your metadata in a subhashref and not in the
+top-level metadata hashref, keyed by your package name. L<Tree::Persist> does
+this, using a unique key for each persistence layer associated with that tree.
+This will help prevent clobbering of metadata.
+
+=head1 NULL TREE
+
+If you call C<< $self->parent >> on a root node, it will return a Tree::Null
+object. This is an implementation of the Null Object pattern optimized for
+usage with L<Tree>. It will evaluate as false in every case (using
+I<overload>) and all methods called on it will return a Tree::Null object.
+
+=head2 Notes
+
+=over 4
+
+=item *
+
+Tree::Null does B<not> inherit from anything. This is so that all the
+methods will go through AUTOLOAD vs. the actual method.
+
+=item *
+
+However, calling isa() on a Tree::Null object will report that it is-a
+any object that is either Tree or in the Tree:: hierarchy.
+
+=item *
+
+The Tree::Null object is a singleton.
+
+=item *
+
+The Tree::Null object I<is> defined, though. I couldn't find a way to
+make it evaluate as undefined. That may be a good thing.
+
+=back
+
+=head1 CODE COVERAGE
+
+Please see the relevant sections of L<Tree>.
+
+=head1 SUPPORT
+
+Please see the relevant sections of L<Tree>.
+
+=head1 ACKNOWLEDGEMENTS
+
+=over 4
+
+=item * Stevan Little for writing L<Tree::Simple>, upon which Tree is based.
+
+=back
+
+=head1 AUTHORS
+
+Rob Kinyon E<lt>[e-mail]<gt>
+
+Stevan Little E<lt>[e-mail]<gt>
+
+Thanks to Infinity Interactive for generously donating our time.
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright 2004, 2005 by Infinity Interactive, Inc.
+
+L<http://www.iinteractive.com>
+
+This library is free software; you can redistribute it and/or modify it under
+the same terms as Perl itself.
+
+=cut

=== modified file 't/Tree/001_root_node.t'
--- t/Tree/001_root_node.t	2008-01-17 12:56:58 +0000
+++ t/Tree/001_root_node.t	2014-12-12 23:08:52 +0000
@@ -1,11 +1,12 @@
+use lib 't/lib';
 use strict;
 use warnings;
 
 use Test::More;
 
-use t::tests qw( %runs );
+use Tests qw( %runs );
 
-plan tests => 25 + 3 * $runs{stats}{plan};
+plan tests => 26 + 3 * $runs{stats}{plan};
 
 my $CLASS = 'Tree';
 use_ok( $CLASS )
@@ -39,7 +40,10 @@
     is( $tree->root, $tree, "... and doesn't change the value" );
 
     $tree->meta->{foo} = 1;
-    is( $tree->meta->{foo}, 1, "Meta works." );
+    is( $tree->meta->{foo}, 1, "Meta works via in-situ update." );
+
+    $tree->meta({baa => 2});
+    is( ${$tree->meta}{baa}, 2, "Meta works via method call." );
 }
 
 {

=== modified file 't/Tree/003_child_node.t'
--- t/Tree/003_child_node.t	2008-01-17 12:56:58 +0000
+++ t/Tree/003_child_node.t	2014-12-12 23:08:52 +0000
@@ -1,9 +1,10 @@
+use lib 't/lib';
 use strict;
 use warnings;
 
 use Test::More;
 
-use t::tests qw( %runs );
+use Tests qw( %runs );
 
 plan tests => 22 + 4 * $runs{stats}{plan};
 

=== modified file 't/Tree/004_multiple_children.t'
--- t/Tree/004_multiple_children.t	2008-01-17 12:56:58 +0000
+++ t/Tree/004_multiple_children.t	2014-12-12 23:08:52 +0000
@@ -1,9 +1,10 @@
+use lib 't/lib';
 use strict;
 use warnings;
 
 use Test::More;
 
-use t::tests qw( %runs );
+use Tests qw( %runs );
 
 plan tests => 27 + 15 * $runs{stats}{plan};
 

=== modified file 't/Tree/005_multilevel_tree.t'
--- t/Tree/005_multilevel_tree.t	2008-01-17 12:56:58 +0000
+++ t/Tree/005_multilevel_tree.t	2014-12-12 23:08:52 +0000
@@ -1,9 +1,10 @@
+use lib 't/lib';
 use strict;
 use warnings;
 
 use Test::More;
 
-use t::tests qw( %runs );
+use Tests qw( %runs );
 
 plan tests => 41 + 3 * $runs{stats}{plan};
 

=== modified file 't/Tree/010_errors_addchild.t'
--- t/Tree/010_errors_addchild.t	2008-01-17 12:56:58 +0000
+++ t/Tree/010_errors_addchild.t	2014-12-12 23:08:52 +0000
@@ -1,9 +1,10 @@
+use lib 't/lib';
 use strict;
 use warnings;
 
 use Test::More;
 
-use t::tests qw( %runs );
+use Tests qw( %runs );
 
 plan tests => 1 + 12 * $runs{error}{plan};
 

=== modified file 't/Tree/011_errors_removechild.t'
--- t/Tree/011_errors_removechild.t	2008-01-17 12:56:58 +0000
+++ t/Tree/011_errors_removechild.t	2014-12-12 23:08:52 +0000
@@ -1,9 +1,10 @@
+use lib 't/lib';
 use strict;
 use warnings;
 
 use Test::More;
 
-use t::tests qw( %runs );
+use Tests qw( %runs );
 
 plan tests => 1 + 6 * $runs{error}{plan};
 

=== modified file 't/Tree/016_events.t'
--- t/Tree/016_events.t	2008-01-17 12:56:58 +0000
+++ t/Tree/016_events.t	2014-12-12 23:08:52 +0000
@@ -1,9 +1,10 @@
+use lib 't/lib';
 use strict;
 use warnings;
 
 use Test::More;
 
-#use t::tests qw( %runs );
+#use Tests qw( %runs );
 
 plan tests => 8;
 

=== modified file 't/Tree_Binary/000_binary_trees.t'
--- t/Tree_Binary/000_binary_trees.t	2008-01-17 12:56:58 +0000
+++ t/Tree_Binary/000_binary_trees.t	2014-12-12 23:08:52 +0000
@@ -1,13 +1,14 @@
+use lib 't/lib';
 use strict;
 use warnings;
 
 use Test::More;
 
-use t::tests qw( %runs );
+use Tests qw( %runs );
 
 plan tests => 28 + 15 * $runs{stats}{plan};
 
-my $CLASS = 'Tree::Binary';
+my $CLASS = 'Tree::Binary2';
 use_ok( $CLASS )
     or Test::More->builder->BAILOUT( "Cannot load $CLASS" );
 

=== modified file 't/Tree_Binary/001_mirror.t'
--- t/Tree_Binary/001_mirror.t	2008-01-17 12:56:58 +0000
+++ t/Tree_Binary/001_mirror.t	2014-12-12 23:08:52 +0000
@@ -5,7 +5,7 @@
 
 plan tests => 16;
 
-my $CLASS = 'Tree::Binary';
+my $CLASS = 'Tree::Binary2';
 use_ok( $CLASS )
     or Test::More->builder->BAILOUT( "Cannot load $CLASS" );
 

=== modified file 't/Tree_Binary/002_clone.t'
--- t/Tree_Binary/002_clone.t	2008-01-17 12:56:58 +0000
+++ t/Tree_Binary/002_clone.t	2014-12-12 23:08:52 +0000
@@ -7,11 +7,11 @@
 
 use Test::More tests => 6;
 
-use_ok( 'Tree::Binary' );
+use_ok( 'Tree::Binary2' );
 
-my $tree = Tree::Binary->new('root');
-$tree->left(Tree::Binary->new('left'));
-$tree->right(Tree::Binary->new('right'));
+my $tree = Tree::Binary2->new('root');
+$tree->left(Tree::Binary2->new('left'));
+$tree->right(Tree::Binary2->new('right'));
 
 my $clone = $tree->clone;
 

=== added directory 't/lib'
=== added file 't/lib/Tests.pm'
--- t/lib/Tests.pm	1970-01-01 00:00:00 +0000
+++ t/lib/Tests.pm	2014-12-12 23:08:52 +0000
@@ -0,0 +1,61 @@
+package Tests;
+
+use strict;
+use warnings;
+
+use Test::More;
+
+my @stats = qw( height width depth size is_root is_leaf );
+
+use base 'Exporter';
+
+our @EXPORT_OK = qw( %runs );
+our $VERSION   = '1.05';
+
+our %runs = (
+    stats => {
+        plan => scalar @stats,
+        func => \&stat_check,
+    },
+    error => {
+        plan => 3,
+        func => \&error_check,
+    },
+);
+
+sub stat_check {
+    my $tree = shift;
+    my %opts = @_;
+
+    foreach my $stat (@stats) {
+        if ( $stat =~ /^is_(.*)/ ) {
+            if ( $opts{$stat} ) {
+                ok( $tree->$stat, "The tree is a $1" );
+            }
+            else {
+                ok( !$tree->$stat, "The tree is not a $1" );
+            }
+        }
+        else {
+            cmp_ok(
+                $tree->$stat, '==', $opts{$stat},
+                "The tree has a $stat of $opts{$stat}",
+            );
+        }
+    }
+}
+
+sub error_check {
+    my $tree = shift;
+    my %opts = @_;
+
+    my $func = $opts{func};
+    my $validator = $opts{validator};
+
+    is( $tree->$func(@{$opts{args} || []}), undef, "$func(): error testing ..." );
+    is( $tree->last_error, $opts{error}, "... and the error is good" );
+    cmp_ok( $tree->$validator, '==', $opts{value}, "... and there was no change" );
+}
+
+1;
+__END__

=== modified file 't/pod.t'
--- t/pod.t	2008-01-17 12:56:58 +0000
+++ t/pod.t	2014-12-12 23:08:52 +0000
@@ -3,7 +3,7 @@
 
 use Test::More;
 
-eval "use Test::Pod 1.14";
-plan skip_all => "Test::Pod 1.14 required for testing POD" if $@;
+eval "use Test::Pod 1.45";
+plan skip_all => "Test::Pod 1.45 required for testing POD" if $@;
 
 all_pod_files_ok();

=== modified file 't/pod_coverage.t'
--- t/pod_coverage.t	2008-01-17 12:56:58 +0000
+++ t/pod_coverage.t	2014-12-12 23:08:52 +0000
@@ -3,8 +3,8 @@
 
 use Test::More;
 
-eval "use Test::Pod::Coverage 1.04";
-plan skip_all => "Test::Pod::Coverage 1.04 required for testing POD coverage" if $@;
+eval "use Test::Pod::Coverage 1.08";
+plan skip_all => "Test::Pod::Coverage 1.08 required for testing POD coverage" if $@;
 
 all_pod_coverage_ok({
     also_private => [],

=== removed file 't/tests.pm'
--- t/tests.pm	2008-01-17 12:56:58 +0000
+++ t/tests.pm	1970-01-01 00:00:00 +0000
@@ -1,60 +0,0 @@
-package t::tests;
-
-use strict;
-use warnings;
-
-use Test::More;
-
-my @stats = qw( height width depth size is_root is_leaf );
-
-use base 'Exporter';
-
-our @EXPORT_OK = qw( %runs );
-
-our %runs = (
-    stats => {
-        plan => scalar @stats,
-        func => \&stat_check,
-    },
-    error => {
-        plan => 3,
-        func => \&error_check,
-    },
-);
-
-sub stat_check {
-    my $tree = shift;
-    my %opts = @_;
-
-    foreach my $stat (@stats) {
-        if ( $stat =~ /^is_(.*)/ ) {
-            if ( $opts{$stat} ) {
-                ok( $tree->$stat, "The tree is a $1" );
-            }
-            else {
-                ok( !$tree->$stat, "The tree is not a $1" );
-            }
-        }
-        else {
-            cmp_ok(
-                $tree->$stat, '==', $opts{$stat},
-                "The tree has a $stat of $opts{$stat}",
-            );
-        }
-    }
-}
-
-sub error_check {
-    my $tree = shift;
-    my %opts = @_;
-
-    my $func = $opts{func};
-    my $validator = $opts{validator};
-
-    is( $tree->$func(@{$opts{args} || []}), undef, "$func(): error testing ..." );
-    is( $tree->last_error, $opts{error}, "... and the error is good" );
-    cmp_ok( $tree->$validator, '==', $opts{value}, "... and there was no change" );
-}
-
-1;
-__END__