This is an automated email from the git hooks/post-receive script.

gregoa pushed a commit to branch master
in repository libtree-simple-perl.

commit ce4376db1128370f1d959105b83b93d29e057c1d
Author: gregor herrmann <gre...@debian.org>
Date:   Sun Nov 29 14:05:51 2015 +0100

    Imported Upstream version 1.26
---
 Build.PL                   |  36 -----
 Changelog.ini              | 267 +++++++++++++++-----------------
 Changes                    | 370 +++++++++++++++++++++------------------------
 LICENSE                    | 340 +++++++++++++++++++++++++++++++++++++++++
 MANIFEST                   |   4 +-
 MANIFEST.SKIP              |  45 ++++++
 META.json                  |  40 +++--
 META.yml                   |  30 ++--
 Makefile.PL                |  20 ++-
 lib/Tree/Simple.pm         |  82 +++++-----
 lib/Tree/Simple/Visitor.pm |  76 +++++++---
 t/10_Tree_Simple_test.t    | 324 +++++++++++++++++++--------------------
 xt/author/changes.t        |   9 ++
 13 files changed, 1000 insertions(+), 643 deletions(-)

diff --git a/Build.PL b/Build.PL
deleted file mode 100644
index c423bda..0000000
--- a/Build.PL
+++ /dev/null
@@ -1,36 +0,0 @@
-use 5.006;
-use strict;
-use warnings;
-
-use Module::Build;
-
-Module::Build -> new
-(
-       dist_abstract  => 'A simple tree object',
-       dist_author    => 'Stevan Little <ste...@cpan.org>',
-       license        => 'perl',
-       module_name    => 'Tree::Simple',
-       build_requires =>
-       {
-               'Test::Exception' => '0.15',
-               'Test::More'      => '0.47',
-       },
-       configure_requires =>
-       {
-               'Module::Build' => 0.40,
-       },
-       requires =>
-       {
-               'constant'     => 0,
-               'Scalar::Util' => '1.18',
-               'strict'       => 0,
-               'warnings'     => 0,
-       },
-       meta_merge => {
-               resources => {
-                       repository => 'https://github.com/stevan/tree-simple',
-                       bugtracker => 
'https://github.com/stevan/tree-simple/issues',
-                       license    => 
'https://www.gnu.org/licenses/license-list.html#PerlLicense',
-               },
-       },
-) -> create_build_script;
diff --git a/Changelog.ini b/Changelog.ini
index 0703f47..9bf1334 100644
--- a/Changelog.ini
+++ b/Changelog.ini
@@ -1,7 +1,22 @@
 [Module]
 Name=Tree::Simple
-Changelog.Creator=Module::Metadata::Changes V 2.05
-Changelog.Parser=Config::IniFiles V 2.83
+Changelog.Creator=Module::Metadata::Changes V 2.06
+Changelog.Parser=Config::IniFiles V 2.88
+
+[V 1.26]
+Date=2015-11-28T09:30:00
+Comments= <<EOT
+- No code changes.
+- Accept patches from Manwar via github. See 
https://github.com/stevan/tree-simple/pull/10.
+- I (Ron) followed github's advice on handling merge conflicts from the 
command line, but could
+not see the patches after the merge.
+- So, create github repo https://github.com/ronsavage/Tree-Simple.
+- Remove Build.PL.
+- Reformat dates in this file.
+- Oops. Can't get Test::Stream to work in 10_Tree_Simple_test.t. Logged issue, 
but it's
+probably a problem with the way I tried to use Test::Stream. Revert to 
Test::More.
+- Add xt/author/changes.t to MANIFEST.
+EOT
 
 [V 1.25]
 Date=2014-01-13T08:51:00
@@ -13,8 +28,8 @@ EOT
 [V 1.24]
 Date=2014-09-06T09:27:00
 Comments= <<EOT
-- Abandon Test::Version and hence delete t/version.t. Putting version.t in 
xt/author/ is not a solution,
-because Test::Version has problems with Test::EOL and Test::Builder.
+- Abandon Test::Version and hence delete t/version.t. Putting version.t in 
xt/author/ is not a
+solution, because Test::Version has problems with Test::EOL and Test::Builder.
 Thanx to Kent Fredric for the github issue which started me investigating this 
issue.
 EOT
 
@@ -29,7 +44,10 @@ EOT
 
 [V 1.22]
 Date=2013-09-30T08:35:00
-Comments=- Metadata fixes in Build.PL and correct bugtracker queue in 
Makefile.PL. Thanx to dsteinbrunner (via github).
+Comments= <<EOT
+- Metadata fixes in Build.PL and correct bugtracker queue in Makefile.PL. 
Thanx to dsteinbrunner
+(via github).
+EOT
 
 [V 1.21]
 Date=2013-09-26T13:08:00
@@ -53,11 +71,11 @@ Comments= <<EOT
 - Reformat Build.PL and Makefile.PL.
 - Move t/pod* into xt/author/.
 - Minor doc patches.
-- Add t/17_Tree_Simple_width_test.t. This code was attached to RT#40407, to 
demonstrate a bug in keeping a
-running total of the width (leaf count) of a tree during node additions to 
leaves.
+- Add t/17_Tree_Simple_width_test.t. This code was attached to RT#40407, to 
demonstrate a bug in
+keeping a running total of the width (leaf count) of a tree during node 
additions to leaves.
 Thanx to David Cryer for the test code and patch.
-- Add t/21_Tree_Simple_Visitor_test.t. This code was attached to RT#30032, to 
demonstrate a bug in including
-the root in a traversal after calling $visitor -> includeTruck(1).
+- Add t/21_Tree_Simple_Visitor_test.t. This code was attached to RT#30032, to 
demonstrate a bug
+in including the root in a traversal after calling $visitor -> includeTruck(1).
 - RT#30032: Adopt patch from Moses Amaro. With thanx.
 - RT#38607: Reject. Suppressing deep recursion warnings should not normally be 
done. Sub-class!
 - RT#40407: Adopt patch from David Cryer. With thanx.
@@ -66,174 +84,147 @@ EOT
 
 [V 1.18]
 Date=2007-11-11T12:00:00
-Comments= <<EOT
-- fixing version string to not choke on 5.10
-(RT #29746)
-EOT
+Comments=- fixing version string to not choke on 5.10 (RT #29746).
 
 [V 1.17]
 Date=2006-10-23T12:00:00
 Comments= <<EOT
-- make loading of Scalar::Util::weaken, completely
-optional
-- added a $post_func optional arg to &traverse. Thanks
-to Mark Lawrence for the patch, docs and tests :)
+- Make loading of Scalar::Util::weaken, completely optional
+- Added a $post_func optional arg to &traverse. Thanks to Mark Lawrence for 
the patch, docs and
+tests :).
 EOT
 
 [V 1.16]
 Date=2006-02-06T12:00:00
 Comments= <<EOT
-- converted to use Module::Build (Rob Kinyon)
-- refactored &addChild and &addChildren to be
-implemented in terms of &insertChild and
+- Converted to use Module::Build (Rob Kinyon)
+- Refactored &addChild and &addChildren to be implemented in terms of 
&insertChild and
 &insertChildren (Rob Kinyon)
-- other misc. refactorings (Rob Kinyon)
-- updated Scalar::Util version dependency (Stevan Little)
-- updated copyrights for the new year (Stevan Little)
+- Other misc. refactorings (Rob Kinyon)
+- Updated Scalar::Util version dependency (Stevan Little)
+- Updated copyrights for the new year (Stevan Little)
 EOT
 
 [V 1.15]
 Date=2005-05-26T12:00:00
 Comments= <<EOT
-- added optional use of weakened parent references
-and improved the old circular reference DESTROY
-model to make more sense. See the documantation
-for more info.
-- fixed bug in the fixDepth() function
+- Added optional use of weakened parent references and improved the old 
circular reference
+DESTROY model to make more sense. See the documentation for more info.
+- Fixed bug in the fixDepth() function.
 EOT
 
 [V 1.14]
 Date=2004-11-18T12:00:00
 Comments= <<EOT
-- now using Scalar::Util::blessed() instead of
-the convoluted UNIVERSAL::isa() stuff.
-- added Scalar::Util as a dependency
+- Now using Scalar::Util::blessed() instead of the convoluted UNIVERSAL::isa() 
stuff.
+- Added Scalar::Util as a dependency.
 EOT
 
 [V 1.13]
 Date=2004-11-15T12:00:00
 Comments= <<EOT
-- added width functionality (with getWidth),
-thanks to Mark Thomas for his insight/suggestions
-- added tests for this
-- added documentation for this
-- improved the height functionality, thanks again
-to Mark Thomas for his insight/suggestions
-- deprecated the 'height' method in favor
-of the more consistent 'getHeight' method
-- added tests for this
-- added documentation for this
-- added some info in the docs to explain the depth
-value for ROOT trees.
-- cleaned up and improved the following test files
-> 11_Tree_Simple_fixDepth_test.t
-> 13_Tree_Simple_clone_test.t
+- Added width functionality (with getWidth). Thanks to Mark Thomas for his 
insight/suggestions.
+- Added tests for this.
+- Added documentation for this.
+- Improved the height functionality, thanks again to Mark Thomas for his 
insight/suggestions.
+- Deprecated the 'height' method in favor of the more consistent 'getHeight' 
method.
+- Added tests for this.
+- Added documentation for this.
+- Added some info in the docs to explain the depth value for ROOT trees.
+- Cleaned up and improved the following test files:
+11_Tree_Simple_fixDepth_test.t
+13_Tree_Simple_clone_test.t
 EOT
 
 [V 1.12]
 Date=2004-10-07T12:00:00
 Comments= <<EOT
-- fixed the clone method, it was not correctly
-cloning parental relationships
-- added tests and docs for this
-- improved clone and cloneShallow with the addition
-of the _cloneNode utility function, we now deep
-clone the nodes
-- added test and docs for this
+- Fixed the clone method, it was not correctly cloning parental relationships.
+- Added tests and docs for this.
+- Improved clone and cloneShallow with the addition of the _cloneNode utility 
function, we now
+deep clone the nodes.
+- Added test and docs for this.
 EOT
 
 [V 1.11]
 Date=2004-10-04T12:00:00
-Comments=- some documentation changes, no code changes
+Comments=- Some documentation changes, no code changes.
 
 [V 1.10]
 Date=2004-08-31T12:00:00
 Comments= <<EOT
-- streamlined the DESTROY method to avoid method
-calls as this can sometimes cause issues during
-global destruction with subclasses.
+- Streamlined the DESTROY method to avoid method calls as this can sometimes 
cause issues
+during global destruction with subclasses.
 EOT
 
 [V 1.09]
 Date=2004-08-31T12:00:00
 Comments= <<EOT
-- Fixed DESTROY to avoid memory leaks (RT-BUG: #7512)
-- added documentation to explain when to call
-the DESTROY method to properly clean up any
-circular references
-- added test (14_Tree_Simple_leak_test.t) to
-verify this fix (needs Test::Memory::Cycle to run)
+- Fixed DESTROY to avoid memory leaks (RT-BUG: #7512).
+- Added documentation to explain when to call the DESTROY method to properly 
clean up any
+circular references.
+- Added test (14_Tree_Simple_leak_test.t) to verify this fix. Needs 
Test::Memory::Cycle to run.
 EOT
 
 [V 1.08]
 Date=2004-08-25T12:00:00
 Comments= <<EOT
-- added the 'height' and 'size' methods
-- added tests for these
-- added documentation for these
+- Added the 'height' and 'size' methods.
+- Added tests for these.
+- Added documentation for these.
 EOT
 
 [V 1.07]
 Date=2004-07-28T12:00:00
 Comments= <<EOT
-- Added the getUID and setUID methods to Tree::Simple, thanks
-to Brett Nuske for that suggestion.
-- added documentation for these methods
-- added tests for those methods
-- added t/pod.t and t/pod_coverage.t to the test suite
+- Added the getUID and setUID methods to Tree::Simple. Thanks to Brett Nuske 
for that
+suggestion.
+- Added documentation for these methods.
+- Added tests for those methods.
+- Added t/pod.t and t/pod_coverage.t to the test suite.
 EOT
 
 [V 1.06]
 Date=2004-07-06T12:00:00
 Comments= <<EOT
-- Changed what the Tree::Simple accept method accepts
-- added tests for this
-- Completely Revised the Tree::Simple::Visitor object
-so that it is a better base class. This coincides with
-the release of the Tree::Simple::VisitorFactory collection
-of Visitor objects.
-- added tests for this
+- Changed what the Tree::Simple accept method accepts.
+- Added tests for this.
+- Completely Revised the Tree::Simple::Visitor object so that it is a better 
base class.
+This coincides with the release of the Tree::Simple::VisitorFactory collection 
of Visitor
+objects.
+- Added tests for this.
 EOT
 
 [V 1.05]
 Date=2004-06-06T12:00:00
 Comments= <<EOT
-- Fixed some vagueness in the documentation as well
-as made sure that the ROOT constant could be given
-as a the $parent argument.
+- Fixed some vagueness in the documentation as well as made sure that the ROOT 
constant could
+be given as a the $parent argument.
 EOT
 
 [V 1.04]
 Date=2004-05-18T12:00:00
 Comments= <<EOT
-- The second argument to the Tree::Simple constructor
-was a parent, and that argument was not getting
-properly type checked before attempting to call
-'addChild' on it. Now it is properly type checked
-and will throw an exception if it is not correct.
+- The second argument to the Tree::Simple constructor was a parent, and that 
argument was not
+getting properly type checked before attempting to call 'addChild' on it. Now 
it is
+properly type checked and will throw an exception if it is not correct.
 EOT
 
 [V 1.03]
 Date=2004-05-09T12:00:00
 Comments= <<EOT
-- I have added a new method 'getIndex', which will
-fetch the index of the current tree within it's
-parent's child list. I have also added documentation
-and tests for this.
+- I have added a new method 'getIndex', which will fetch the index of the 
current tree within
+it's parent's child list. I have also added documentation and tests for this.
 EOT
 
 [V 1.02]
 Date=2004-05-02T12:00:00
 Comments= <<EOT
-- I thought about the API change, and I decided that
-the new method (removeChildAt($index)) did not make
-sense. It made more sense for removeChild to accept
-both $child and an $index, and do the right thing
-based upon which one was given. This of course
-is how it works anyway since I maintained backwards
-compatibility. But take note, removeChildAt($index)
-will not be supported. The method is still there,
-but it will very soon go away.
+- I thought about the API change, and I decided that the new method 
(removeChildAt($index) )
+did not make sense. It made more sense for removeChild to accept both $child 
and an $index,
+and do the right thing based upon which one was given. This of course is how 
it works
+anyway since I maintained backwards compatibility. But take note, 
removeChildAt($index)
+will not be supported. The method is still there, but it will very soon go 
away.
 I think this is a cleaner way to do this in the end.
 EOT
 
@@ -241,54 +232,44 @@ EOT
 Date=2004-04-28T12:00:00
 Comments= <<EOT
 - Made API change:
-- removeChild($index) is now removeChildAt($index)
-and removeChild($child) has replaced it. See the
-documentation for more info.
-- backwards compatibility maintained under change.
-- new tests written to test the new code and to
-test the backwards compatibility
-- Test suite is not at 99% coverage (with 415 tests)
-- Moved object initialization code from Tree::Simple::Visitor::new
-to Tree::Simple::Visitor::_init. This keeps in line with the
-Tree::Simple code and the seperation of object creation and
-initialization.
+- removeChild($index) is now removeChildAt($index) and removeChild($child) has 
replaced it.
+See the documentation for more info.
+- Backwards compatibility maintained under change.
+- New tests written to test the new code and to test the backwards 
compatibility.
+- Test suite is not at 99% coverage (with 415 tests).
+- Moved object initialization code from Tree::Simple::Visitor::new to
+Tree::Simple::Visitor::_init. This keeps in line with the Tree::Simple code 
and the
+seperation of object creation and initialization.
 EOT
 
 [V 1.00]
 Date=2004-04-05T12:00:00
 Comments= <<EOT
-- I dont know why, but I was wary of calling this 1.0
-but that is really what it is. I think too many modules
-avoid that number, but I am not gonna do that. So here
-goes, its 1.0 baby!!
-- Note: Being new to this versioning thing, I was actually going
-for a "minor" version thing with the jump from 0.3 to 0.14. I
-realized that was not only dumb, but incorrect. But in realizing
-this, I decided this is really 1.0 code anyway and took the plunge.
+- I dont know why, but I was wary of calling this 1.0 but that is really what 
it is. I think
+too many module        avoid that number, but I am not gonna do that. So here 
goes, its 1.0 baby!!
+- Note: Being new to this versioning thing, I was actually going for a "minor" 
version thing
+with the jump from 0.3 to 0.14. I realized that was not only dumb, but 
incorrect. But in
+realizing this, I decided this is really 1.0 code anyway and took the plunge.
 EOT
 
 [V 0.15]
 Date=2004-04-05T12:00:00
 Comments= <<EOT
 - Made a few adjustments:
-- changed to UNIVERSAL::isa($object, "Class") so as to
-avoid warnings if non-object refs are passed
-- added more tests to the Tree::Simple::Visitor object
-- added more tests to check for non-object-refs passed
-where they shouldnt be.
+- Changed to UNIVERSAL::isa($object, "Class") so as to avoid warnings if 
non-object refs are
+passed.
+- Added more tests to the Tree::Simple::Visitor object.
+- Added more tests to check for non-object-refs passed where they shouldn't be.
 EOT
 
 [V 0.14]
 Date=2004-04-04T12:00:00
 Comments= <<EOT
-- I feel this module is ready for serious use. I have been
-using it in production environments for almost 2 years now,
-and I have recently beefed up the test suite as well. It now
-has 371 tests with approx. 95% code coverage. I feel the code
-is solid as is the API (although some people dont like my
-Java-esque naming style, but hey whatta ya do). Most of this
-release is just tweaking and fine tuning of code, and updating
-of the documentation.
+- I feel this module is ready for serious use. I have been using it in 
production environments
+for almost 2 years now, and I have recently beefed up the test suite as well. 
It now
+has 371 tests with approx. 95% code coverage. I feel the code is solid as is 
the API
+(although some people dont like my Java-esque naming style, but hey whatta ya 
do). Most of
+this release is just tweaking and fine tuning of code, and updating of the 
documentation.
 EOT
 
 [V 0.03]
@@ -296,26 +277,22 @@ Date=2004-04-01T12:00:00
 Deploy.Action=Upgrade
 Deploy.Reason=Security
 Comments= <<EOT
-- Like an idiot I forgot to change the version number
-from version 0.01 to 0.02 and because of CPAN's security-type
-restriction about uploading files with a duplicate name
-I have to up the version number.
+- Like an idiot I forgot to change the version number from version 0.01 to 
0.02 and because of
+CPAN's security-type restriction about uploading files with a duplicate name I 
have to up
+the version number.
 EOT
 
 [V 0.02]
 Date=2004-04-01T12:00:00
 Comments= <<EOT
-- first revision:
-- fixed a few bugs
-- improved error messages
-- added tests:
-- test for exceptions
-- checked test coverage with Devel::Cover
+- First revision:
+- Fixed a few bugs.
+- Improved error messages.
+- Added tests:
+- Test for exceptions.
+- Checked test coverage with Devel::Cover.
 EOT
 
 [V 0.01]
 Date=2004-03-11T10:46:33
-Comments= <<EOT
-- original version; created by h2xs 1.22 with options
--X -n Tree::Simple
-EOT
+Comments=- Original version; created by h2xs 1.22 with options -X -n 
Tree::Simple.
diff --git a/Changes b/Changes
index 3365a34..8a52269 100644
--- a/Changes
+++ b/Changes
@@ -1,32 +1,45 @@
 Revision history for Perl extension Tree::Simple.
 
-1.25  Tue Jan 13 08:51:00 2014
+1.26  2015-11-28T09:30:00
+       - No code changes.
+       - Accept patches from Manwar via github. See 
https://github.com/stevan/tree-simple/pull/10.
+       - I (Ron) followed github's advice on handling merge conflicts from the 
command line, but could
+               not see the patches after the merge.
+       - So, create github repo https://github.com/ronsavage/Tree-Simple.
+       - Remove Build.PL.
+       - Reformat dates in this file.
+       - Oops. Can't get Test::Stream to work in 10_Tree_Simple_test.t. Logged 
issue, but it's
+               probably a problem with the way I tried to use Test::Stream. 
Revert to Test::More.
+       - Add xt/author/changes.t to MANIFEST.
+
+1.25  2014-01-13T08:51:00
        - Fix logic in sub DESTROY for when children are/are not present. 
Reported by astortz.
                See https://github.com/stevan/tree-simple/issues/8.
 
-1.24  Sat Sep  6 09:27:00 2014
-       - Abandon Test::Version and hence delete t/version.t. Putting version.t 
in xt/author/ is not a solution,
-               because Test::Version has problems with Test::EOL and 
Test::Builder.
+1.24  2014-09-06T09:27:00
+       - Abandon Test::Version and hence delete t/version.t. Putting version.t 
in xt/author/ is not a
+               solution, because Test::Version has problems with Test::EOL and 
Test::Builder.
                Thanx to Kent Fredric for the github issue which started me 
investigating this issue.
 
-1.23  Sat Nov  9 10:43:00 2013
+1.23  2013-11-09T10:43:00
        - No code changes.
        - Accept spelling corrections from the Debian Perl Group, with thanx. 
See RT#90171.
                Note: The change to lib/Tree/Simple/Visitor.pm had already been 
made.
        - Add t/version.t, which uses Test::Version, to cross-check version #s.
 
-1.22  Mon Sep 30 08:35:00 2013
-       - Metadata fixes in Build.PL and correct bugtracker queue in 
Makefile.PL. Thanx to dsteinbrunner (via github).
+1.22  2013-09-30T08:35:00
+       - Metadata fixes in Build.PL and correct bugtracker queue in 
Makefile.PL. Thanx to dsteinbrunner
+               (via github).
 
-1.21  Thu Sep 26 13:08:00 2013
+1.21  2013-09-26T13:08:00
        - Fix syntax error in Makefile.PL.
 
-1.20  Thu Sep 26 11:16:00 2013
+1.20  2013-09-26T11:16:00
        - Merge source from https://github.com/stevan/tree-simple.
        - Close github issues.
        - Add bugtracker and license to Build.PL and Makefile.PL.
 
-1.19  Mon Sep 23 08:26:00 2013
+1.19  2013-09-23T08:26:00
        - Maintenance now by Ron Savage.
        - Rectify datestamp format in this file.
        - Add Changelog.ini.
@@ -34,196 +47,159 @@ Revision history for Perl extension Tree::Simple.
        - Reformat Build.PL and Makefile.PL.
        - Move t/pod* into xt/author/.
        - Minor doc patches.
-       - Add t/17_Tree_Simple_width_test.t. This code was attached to 
RT#40407, to demonstrate a bug in keeping a
-               running total of the width (leaf count) of a tree during node 
additions to leaves.
+       - Add t/17_Tree_Simple_width_test.t. This code was attached to 
RT#40407, to demonstrate a bug in
+               keeping a running total of the width (leaf count) of a tree 
during node additions to leaves.
                Thanx to David Cryer for the test code and patch.
-       - Add t/21_Tree_Simple_Visitor_test.t. This code was attached to 
RT#30032, to demonstrate a bug in including
-               the root in a traversal after calling $visitor -> 
includeTruck(1).
+       - Add t/21_Tree_Simple_Visitor_test.t. This code was attached to 
RT#30032, to demonstrate a bug
+               in including the root in a traversal after calling $visitor -> 
includeTruck(1).
        - RT#30032: Adopt patch from Moses Amaro. With thanx.
        - RT#38607: Reject. Suppressing deep recursion warnings should not 
normally be done. Sub-class!
        - RT#40407: Adopt patch from David Cryer. With thanx.
        - RT#84797: Reject. Changing the return value of setUID could break any 
amount of code.
 
-1.18  Sun Nov 11 12:00:00 2007
-    - fixing version string to not choke on 5.10
-      (RT #29746)
-
-1.17  Mon Oct 23 12:00:00 2006
-    - make loading of Scalar::Util::weaken, completely
-      optional
-    - added a $post_func optional arg to &traverse. Thanks
-      to Mark Lawrence for the patch, docs and tests :)
-
-1.16  Mon Feb  6 12:00:00 2006
-    - converted to use Module::Build (Rob Kinyon)
-    - refactored &addChild and &addChildren to be
-      implemented in terms of &insertChild and
-      &insertChildren (Rob Kinyon)
-    - other misc. refactorings (Rob Kinyon)
-    - updated Scalar::Util version dependency (Stevan Little)
-    - updated copyrights for the new year (Stevan Little)
-
-1.15  Thu May 26 12:00:00 2005
-    - added optional use of weakened parent references
-      and improved the old circular reference DESTROY
-      model to make more sense. See the documantation
-      for more info.
-    - fixed bug in the fixDepth() function
-
-1.14  Thu Nov 18 12:00:00 2004
-    - now using Scalar::Util::blessed() instead of
-      the convoluted UNIVERSAL::isa() stuff.
-      - added Scalar::Util as a dependency
-
-1.13  Mon Nov 15 12:00:00 2004
-    - added width functionality (with getWidth),
-      thanks to Mark Thomas for his insight/suggestions
-        - added tests for this
-        - added documentation for this
-    - improved the height functionality, thanks again
-      to Mark Thomas for his insight/suggestions
-        - deprecated the 'height' method in favor
-          of the more consistent 'getHeight' method
-        - added tests for this
-        - added documentation for this
-    - added some info in the docs to explain the depth
-      value for ROOT trees.
-    - cleaned up and improved the following test files
-       > 11_Tree_Simple_fixDepth_test.t
-        > 13_Tree_Simple_clone_test.t
-
-1.12  Thu Oct  7 12:00:00 2004
-    - fixed the clone method, it was not correctly
-      cloning parental relationships
-        - added tests and docs for this
-    - improved clone and cloneShallow with the addition
-      of the _cloneNode utility function, we now deep
-      clone the nodes
-        - added test and docs for this
-
-1.11  Mon Oct  4 12:00:00 2004
-    - some documentation changes, no code changes
-
-1.10  Tue Aug 31 12:00:00 2004
-    - streamlined the DESTROY method to avoid method
-      calls as this can sometimes cause issues during
-      global destruction with subclasses.
-
-1.09  Tue Aug 31 12:00:00 2004
-    - Fixed DESTROY to avoid memory leaks (RT-BUG: #7512)
-        - added documentation to explain when to call
-          the DESTROY method to properly clean up any
-          circular references
-        - added test (14_Tree_Simple_leak_test.t) to
-          verify this fix (needs Test::Memory::Cycle to run)
-
-1.08  Wed Aug 25 12:00:00 2004
-    - added the 'height' and 'size' methods
-        - added tests for these
-        - added documentation for these
-
-1.07  Wed Jul 28 12:00:00 2004
-    - Added the getUID and setUID methods to Tree::Simple, thanks
-      to Brett Nuske for that suggestion.
-      - added documentation for these methods
-      - added tests for those methods
-    - added t/pod.t and t/pod_coverage.t to the test suite
-
-1.06  Mon Jul  6 12:00:00 2004
-    - Changed what the Tree::Simple accept method accepts
-        - added tests for this
-    - Completely Revised the Tree::Simple::Visitor object
-      so that it is a better base class. This coincides with
-      the release of the Tree::Simple::VisitorFactory collection
-      of Visitor objects.
-        - added tests for this
-
-1.05  Sun Jun  6 12:00:00 2004
-    - Fixed some vagueness in the documentation as well
-      as made sure that the ROOT constant could be given
-      as a the $parent argument.
-
-1.04  Tue May 18 12:00:00 2004
-    - The second argument to the Tree::Simple constructor
-      was a parent, and that argument was not getting
-      properly type checked before attempting to call
-      'addChild' on it. Now it is properly type checked
-      and will throw an exception if it is not correct.
-
-1.03  Sun May  9 12:00:00 2004
-    - I have added a new method 'getIndex', which will
-      fetch the index of the current tree within it's
-      parent's child list. I have also added documentation
-      and tests for this.
-
-1.02  Sun May  2 12:00:00 2004
-    - I thought about the API change, and I decided that
-      the new method (removeChildAt($index)) did not make
-      sense. It made more sense for removeChild to accept
-      both $child and an $index, and do the right thing
-      based upon which one was given. This of course
-      is how it works anyway since I maintained backwards
-      compatibility. But take note, removeChildAt($index)
-      will not be supported. The method is still there,
-      but it will very soon go away.
-      I think this is a cleaner way to do this in the end.
-
-1.01  Wed Apr 28 12:00:00 2004
-    - Made API change:
-        - removeChild($index) is now removeChildAt($index)
-          and removeChild($child) has replaced it. See the
-          documentation for more info.
-        - backwards compatibility maintained under change.
-        - new tests written to test the new code and to
-          test the backwards compatibility
-    - Test suite is not at 99% coverage (with 415 tests)
-    - Moved object initialization code from Tree::Simple::Visitor::new
-      to Tree::Simple::Visitor::_init. This keeps in line with the
-      Tree::Simple code and the seperation of object creation and
-      initialization.
-
-1.00  Mon Apr  5 12:00:00 2004
-    - I dont know why, but I was wary of calling this 1.0
-         but that is really what it is. I think too many modules
-         avoid that number, but I am not gonna do that. So here
-         goes, its 1.0 baby!!
-       - Note: Being new to this versioning thing, I was actually going
-               for a "minor" version thing with the jump from 0.3 to 0.14. I
-               realized that was not only dumb, but incorrect. But in realizing
-               this, I decided this is really 1.0 code anyway and took the 
plunge.
-
-0.15  Mon Apr  5 12:00:00 2004
-    - Made a few adjustments:
-         - changed to UNIVERSAL::isa($object, "Class") so as to
-           avoid warnings if non-object refs are passed
-       - added more tests to the Tree::Simple::Visitor object
-       - added more tests to check for non-object-refs passed
-         where they shouldnt be.
-
-0.14  Sun Apr  4 12:00:00 2004
-    - I feel this module is ready for serious use. I have been
-         using it in production environments for almost 2 years now,
-         and I have recently beefed up the test suite as well. It now
-         has 371 tests with approx. 95% code coverage. I feel the code
-         is solid as is the API (although some people dont like my
-         Java-esque naming style, but hey whatta ya do). Most of this
-         release is just tweaking and fine tuning of code, and updating
-         of the documentation.
-
-0.03  Thu Apr  1 12:00:00 2004
-       - Like an idiot I forgot to change the version number
-         from version 0.01 to 0.02 and because of CPAN's security-type
-         restriction about uploading files with a duplicate name
-         I have to up the version number.
-
-0.02  Thu Apr  1 12:00:00 2004
-    - first revision:
-           - fixed a few bugs
-               - improved error messages
-               - added tests:
-                       - test for exceptions
-                       - checked test coverage with Devel::Cover
-
-0.01  Thu Mar 11 10:46:33 2004
-       - original version; created by h2xs 1.22 with options
-               -X -n Tree::Simple
+1.18  2007-11-11T12:00:00
+       - fixing version string to not choke on 5.10 (RT #29746).
+
+1.17  2006-10-23T12:00:00
+       - Make loading of Scalar::Util::weaken, completely optional
+       - Added a $post_func optional arg to &traverse. Thanks to Mark Lawrence 
for the patch, docs and
+               tests :).
+
+1.16  2006-02-06T12:00:00
+       - Converted to use Module::Build (Rob Kinyon)
+       - Refactored &addChild and &addChildren to be implemented in terms of 
&insertChild and
+               &insertChildren (Rob Kinyon)
+       - Other misc. refactorings (Rob Kinyon)
+       - Updated Scalar::Util version dependency (Stevan Little)
+       - Updated copyrights for the new year (Stevan Little)
+
+1.15  2005-05-26T12:00:00
+       - Added optional use of weakened parent references and improved the old 
circular reference
+               DESTROY model to make more sense. See the documentation for 
more info.
+       - Fixed bug in the fixDepth() function.
+
+1.14  2004-11-18T12:00:00
+       - Now using Scalar::Util::blessed() instead of the convoluted 
UNIVERSAL::isa() stuff.
+       - Added Scalar::Util as a dependency.
+
+1.13  2004-11-15T12:00:00
+       - Added width functionality (with getWidth). Thanks to Mark Thomas for 
his insight/suggestions.
+       - Added tests for this.
+       - Added documentation for this.
+       - Improved the height functionality, thanks again to Mark Thomas for 
his insight/suggestions.
+       - Deprecated the 'height' method in favor of the more consistent 
'getHeight' method.
+       - Added tests for this.
+       - Added documentation for this.
+       - Added some info in the docs to explain the depth value for ROOT trees.
+       - Cleaned up and improved the following test files:
+               11_Tree_Simple_fixDepth_test.t
+               13_Tree_Simple_clone_test.t
+
+1.12  2004-10-07T12:00:00
+       - Fixed the clone method, it was not correctly cloning parental 
relationships.
+       - Added tests and docs for this.
+       - Improved clone and cloneShallow with the addition of the _cloneNode 
utility function, we now
+               deep clone the nodes.
+       - Added test and docs for this.
+
+1.11  2004-10-04T12:00:00
+       - Some documentation changes, no code changes.
+
+1.10  2004-08-31T12:00:00
+       - Streamlined the DESTROY method to avoid method calls as this can 
sometimes cause issues
+               during global destruction with subclasses.
+
+1.09  2004-08-31T12:00:00
+       - Fixed DESTROY to avoid memory leaks (RT-BUG: #7512).
+       - Added documentation to explain when to call the DESTROY method to 
properly clean up any
+               circular references.
+       - Added test (14_Tree_Simple_leak_test.t) to verify this fix. Needs 
Test::Memory::Cycle to run.
+
+1.08  2004-08-25T12:00:00
+       - Added the 'height' and 'size' methods.
+       - Added tests for these.
+       - Added documentation for these.
+
+1.07  2004-07-28T12:00:00
+       - Added the getUID and setUID methods to Tree::Simple. Thanks to Brett 
Nuske for that
+               suggestion.
+       - Added documentation for these methods.
+       - Added tests for those methods.
+       - Added t/pod.t and t/pod_coverage.t to the test suite.
+
+1.06  2004-07-06T12:00:00
+       - Changed what the Tree::Simple accept method accepts.
+       - Added tests for this.
+       - Completely Revised the Tree::Simple::Visitor object so that it is a 
better base class.
+               This coincides with the release of the 
Tree::Simple::VisitorFactory collection of Visitor
+               objects.
+       - Added tests for this.
+
+1.05  2004-06-06T12:00:00
+       - Fixed some vagueness in the documentation as well as made sure that 
the ROOT constant could
+               be given as a the $parent argument.
+
+1.04  2004-05-18T12:00:00
+       - The second argument to the Tree::Simple constructor was a parent, and 
that argument was not
+               getting properly type checked before attempting to call 
'addChild' on it. Now it is
+               properly type checked and will throw an exception if it is not 
correct.
+
+1.03  2004-05-09T12:00:00
+       - I have added a new method 'getIndex', which will fetch the index of 
the current tree within
+               it's parent's child list. I have also added documentation and 
tests for this.
+
+1.02  2004-05-02T12:00:00
+       - I thought about the API change, and I decided that the new method 
(removeChildAt($index) )
+               did not make sense. It made more sense for removeChild to 
accept both $child and an $index,
+               and do the right thing based upon which one was given. This of 
course is how it works
+               anyway since I maintained backwards compatibility. But take 
note, removeChildAt($index)
+               will not be supported. The method is still there, but it will 
very soon go away.
+               I think this is a cleaner way to do this in the end.
+
+1.01  2004-04-28T12:00:00
+       - Made API change:
+       - removeChild($index) is now removeChildAt($index) and 
removeChild($child) has replaced it.
+               See the documentation for more info.
+       - Backwards compatibility maintained under change.
+       - New tests written to test the new code and to test the backwards 
compatibility.
+       - Test suite is not at 99% coverage (with 415 tests).
+       - Moved object initialization code from Tree::Simple::Visitor::new to
+               Tree::Simple::Visitor::_init. This keeps in line with the 
Tree::Simple code and the
+               seperation of object creation and initialization.
+
+1.00  2004-04-05T12:00:00
+       - I dont know why, but I was wary of calling this 1.0 but that is 
really what it is. I think
+               too many module avoid that number, but I am not gonna do that. 
So here goes, its 1.0 baby!!
+       - Note: Being new to this versioning thing, I was actually going for a 
"minor" version thing
+               with the jump from 0.3 to 0.14. I realized that was not only 
dumb, but incorrect. But in
+               realizing this, I decided this is really 1.0 code anyway and 
took the plunge.
+
+0.15  2004-04-05T12:00:00
+       - Made a few adjustments:
+       - Changed to UNIVERSAL::isa($object, "Class") so as to avoid warnings 
if non-object refs are
+               passed.
+       - Added more tests to the Tree::Simple::Visitor object.
+       - Added more tests to check for non-object-refs passed where they 
shouldn't be.
+
+0.14  2004-04-04T12:00:00
+       - I feel this module is ready for serious use. I have been using it in 
production environments
+               for almost 2 years now, and I have recently beefed up the test 
suite as well. It now
+               has 371 tests with approx. 95% code coverage. I feel the code 
is solid as is the API
+               (although some people dont like my Java-esque naming style, but 
hey whatta ya do). Most of
+               this release is just tweaking and fine tuning of code, and 
updating of the documentation.
+
+0.03  2004-04-01T12:00:00
+       - Like an idiot I forgot to change the version number from version 0.01 
to 0.02 and because of
+               CPAN's security-type restriction about uploading files with a 
duplicate name I have to up
+               the version number.
+
+0.02  2004-04-01T12:00:00
+       - First revision:
+       - Fixed a few bugs.
+       - Improved error messages.
+       - Added tests:
+       - Test for exceptions.
+       - Checked test coverage with Devel::Cover.
+
+0.01  2004-03-11T10:46:33
+       - Original version; created by h2xs 1.22 with options -X -n 
Tree::Simple.
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..8cdb845
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,340 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc., <http://fsf.org/>
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    {description}
+    Copyright (C) {year}  {fullname}
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  {signature of Ty Coon}, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
+
diff --git a/MANIFEST b/MANIFEST
index 798482e..90d70b0 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -1,10 +1,11 @@
-Build.PL
 Changelog.ini
 Changes
 lib/Tree/Simple.pm
 lib/Tree/Simple/Visitor.pm
+LICENSE
 Makefile.PL
 MANIFEST
+MANIFEST.SKIP
 META.json
 META.yml
 README
@@ -19,5 +20,6 @@ t/16_Tree_Simple_width_test.t
 t/17_Tree_Simple_width_test.t
 t/20_Tree_Simple_Visitor_test.t
 t/21_Tree_Simple_Visitor_test.t
+xt/author/changes.t
 xt/author/pod.t
 xt/author/pod_coverage.t
diff --git a/MANIFEST.SKIP b/MANIFEST.SKIP
new file mode 100644
index 0000000..b2dd104
--- /dev/null
+++ b/MANIFEST.SKIP
@@ -0,0 +1,45 @@
+# Avoid version control files.
+,v$
+\B\.cvsignore$
+\B\.git\b
+\B\.gitignore\b
+\B\.svn\b
+\bCVS\b
+\bRCS\b
+
+# Avoid Makemaker generated and utility files.
+\bblib
+\bblibdirs$
+\bpm_to_blib$
+\bMakefile$
+\bMakeMaker-\d
+
+# Avoid Module::Build generated and utility files.
+\b_build
+\bBuild$
+\bBuild.bat$
+
+# Avoid Devel::Cover generated files
+\bcover_db
+
+# Avoid temp and backup files.
+~$
+\#$
+\.#
+\.bak$
+\.old$
+\.rej$
+\.tmp$
+
+# Avoid OS-specific files/dirs
+#   Mac OSX metadata
+\B\.DS_Store
+#   Mac OSX SMB mount metadata files
+\B\._
+
+# Avoid UltraEdit files.
+\.prj$
+\.pui$
+
+^MYMETA.yml$
+^MYMETA\.json$
diff --git a/META.json b/META.json
index fcfa8c9..8297475 100644
--- a/META.json
+++ b/META.json
@@ -4,58 +4,52 @@
       "Stevan Little <ste...@cpan.org>"
    ],
    "dynamic_config" : 1,
-   "generated_by" : "Module::Build version 0.421",
+   "generated_by" : "ExtUtils::MakeMaker version 7.06, CPAN::Meta::Converter 
version 2.143240",
    "license" : [
-      "perl_5"
+      "artistic_2"
    ],
    "meta-spec" : {
       "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec";,
       "version" : "2"
    },
    "name" : "Tree-Simple",
+   "no_index" : {
+      "directory" : [
+         "t",
+         "inc"
+      ]
+   },
    "prereqs" : {
       "build" : {
          "requires" : {
-            "Test::Exception" : "0.15",
-            "Test::More" : "0.47"
+            "ExtUtils::MakeMaker" : "0"
          }
       },
       "configure" : {
          "requires" : {
-            "Module::Build" : "0.4"
+            "ExtUtils::MakeMaker" : "0"
          }
       },
       "runtime" : {
          "requires" : {
             "Scalar::Util" : "1.18",
+            "Test::Exception" : "0.15",
+            "Test::More" : "1.001014",
             "constant" : "0",
             "strict" : "0",
             "warnings" : "0"
          }
       }
    },
-   "provides" : {
-      "Tree::Simple" : {
-         "file" : "lib/Tree/Simple.pm",
-         "version" : "1.25"
-      },
-      "Tree::Simple::Visitor" : {
-         "file" : "lib/Tree/Simple/Visitor.pm",
-         "version" : "1.25"
-      }
-   },
    "release_status" : "stable",
    "resources" : {
       "bugtracker" : {
-         "web" : "https://github.com/stevan/tree-simple/issues";
+         "web" : 
"https://rt.cpan.org/Public/Dist/Display.html?Name=Tree-Simple";
       },
       "license" : [
-         "http://dev.perl.org/licenses/";,
-         "https://www.gnu.org/licenses/license-list.html#PerlLicense";
-      ],
-      "repository" : {
-         "url" : "https://github.com/stevan/tree-simple";
-      }
+         "http://www.perlfoundation.org/artistic_license_2_0";
+      ]
    },
-   "version" : "1.25"
+   "version" : "1.26"
 }
+
diff --git a/META.yml b/META.yml
index 3623f40..c01fce5 100644
--- a/META.yml
+++ b/META.yml
@@ -3,31 +3,29 @@ abstract: 'A simple tree object'
 author:
   - 'Stevan Little <ste...@cpan.org>'
 build_requires:
-  Test::Exception: '0.15'
-  Test::More: '0.47'
+  ExtUtils::MakeMaker: '0'
 configure_requires:
-  Module::Build: '0.4'
+  ExtUtils::MakeMaker: '0'
 dynamic_config: 1
-generated_by: 'Module::Build version 0.421, CPAN::Meta::Converter version 
2.142060'
-license: perl
+generated_by: 'ExtUtils::MakeMaker version 7.06, CPAN::Meta::Converter version 
2.143240'
+license: artistic_2
 meta-spec:
   url: http://module-build.sourceforge.net/META-spec-v1.4.html
   version: '1.4'
 name: Tree-Simple
-provides:
-  Tree::Simple:
-    file: lib/Tree/Simple.pm
-    version: '1.25'
-  Tree::Simple::Visitor:
-    file: lib/Tree/Simple/Visitor.pm
-    version: '1.25'
+no_index:
+  directory:
+    - t
+    - inc
 requires:
   Scalar::Util: '1.18'
+  Test::Exception: '0.15'
+  Test::More: '1.001014'
   constant: '0'
   strict: '0'
   warnings: '0'
 resources:
-  bugtracker: https://github.com/stevan/tree-simple/issues
-  license: http://dev.perl.org/licenses/
-  repository: https://github.com/stevan/tree-simple
-version: '1.25'
+  bugtracker: https://rt.cpan.org/Public/Dist/Display.html?Name=Tree-Simple
+  license: http://www.perlfoundation.org/artistic_license_2_0
+version: '1.26'
+
diff --git a/Makefile.PL b/Makefile.PL
index 64cb0fe..f55496b 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -4,6 +4,8 @@ use warnings;
 
 use ExtUtils::MakeMaker;
 
+# ----------------
+
 my(%params) =
 (
        ($] ge '5.005') ?
@@ -13,7 +15,7 @@ my(%params) =
        ) : (),
        clean =>
        {
-               FILES => 'blib/* Makefile MANIFEST Tree-Simple-*'
+               FILES => 'blib/* Makefile Tree-Simple-*'
        },
        dist =>
        {
@@ -25,12 +27,12 @@ my(%params) =
        PL_FILES  => {},
        PREREQ_PM =>
        {
-               'constant'        => 0,
-               'Scalar::Util'    => '1.18',
-               'strict'          => 0,
+               'constant' => 0,
+               'Scalar::Util' => '1.18',
+               'strict' => 0,
                'Test::Exception' => '0.15',
-               'Test::More'      => '0.47',
-               'warnings'        => 0,
+               'Test::More' => 1.001014,
+               'warnings' => 0,
        },
        VERSION_FROM => 'lib/Tree/Simple.pm',
 );
@@ -48,6 +50,12 @@ if ($ExtUtils::MakeMaker::VERSION ge '6.46')
                {
                        bugtracker => 
'https://rt.cpan.org/Public/Dist/Display.html?Name=Tree-Simple',
                        license    => 
'http://www.perlfoundation.org/artistic_license_2_0',
+                       repository =>
+                       {
+                               type => 'git',
+                               url  => 
'https://github.com/ronsavage/Tree-Simple.git',
+                               web  => 
'https://github.com/ronsavage/Tree-Simple',
+                       },
                },
        };
 }
diff --git a/lib/Tree/Simple.pm b/lib/Tree/Simple.pm
index 0b3f479..4a6c166 100644
--- a/lib/Tree/Simple.pm
+++ b/lib/Tree/Simple.pm
@@ -3,7 +3,7 @@ package Tree::Simple;
 use strict;
 use warnings;
 
-our $VERSION = '1.25';
+our $VERSION = '1.26';
 
 use Scalar::Util qw(blessed);
 
@@ -146,7 +146,8 @@ sub _insertChildAt {
     # against the index given
     my $max = $self->getChildCount();
     ($index <= $max)
-        || die "Index Out of Bounds : got ($index) expected no more than (" . 
$self->getChildCount() . ")";
+        || die "Index Out of Bounds : got ($index) expected no more than ("
+        . $self->getChildCount() . ")";
 
     (@trees)
         || die "Insufficient Arguments : no tree(s) to insert";
@@ -198,7 +199,8 @@ sub removeChildAt {
     # check the bounds of our children
     # against the index given
     ($index < $self->getChildCount())
-        || die "Index Out of Bounds : got ($index) expected no more than (" . 
$self->getChildCount() . ")";
+        || die "Index Out of Bounds : got ($index) expected no more than ("
+        . $self->getChildCount() . ")";
     my $removed_child;
     # if index is zero, use this optimization
     if ($index == 0) {
@@ -657,7 +659,7 @@ been in use on a few production systems for approx. 2 years 
now with no issue.
 The only difference is that the code has been cleaned up a bit, comments added 
and
 the thorough tests written for its public release. I am confident it behaves as
 I would expect it to, and is (as far as I know) bug-free. I have not 
stress-tested
-it under extreme duress, but I don't so much intend for it to be used in that
+it under extreme duress, but I do not so much intend for it to be used in that
 type of situation. If this module cannot keep up with your Tree needs, i 
suggest
 switching to one of the modules listed in the L<OTHER TREE MODULES> section 
below.
 
@@ -684,7 +686,7 @@ The constructor accepts two arguments a C<$node> value and 
an optional C<$parent
 The C<$node> value can be any scalar value (which includes references and 
objects).
 The optional C<$parent> value must be a B<Tree::Simple> object, or an object
 derived from B<Tree::Simple>. Setting this value implies that your new tree is 
a
-child of the parent tree, and therefore adds it to the parent's children. If 
the
+child of the parent tree, and therefore adds it to the children of that 
parent. If the
 C<$parent> is not specified then its value defaults to ROOT.
 
 =back
@@ -701,9 +703,9 @@ C<$node_value> is not defined.
 =item B<setUID ($uid)>
 
 This allows you to set your own unique ID for this specific Tree::Simple 
object.
-A default value derived from the object's hex address is provided for you, so 
use
+A default value derived from the hex address of the object is provided for 
you, so use
 of this method is entirely optional. It is the responsibility of the user to
-ensure the value's uniqueness, all that is tested by this method is that 
C<$uid>
+ensure the value has uniqueness, all that is tested by this method is that 
C<$uid>
 is a true value (evaluates to true in a boolean context). For even more 
information
 about the Tree::Simple UID see the C<getUID> method.
 
@@ -711,7 +713,7 @@ about the Tree::Simple UID see the C<getUID> method.
 
 This method accepts only B<Tree::Simple> objects or objects derived from
 B<Tree::Simple>, an exception is thrown otherwise. This method will append
-the given C<$tree> to the end of it's children list, and set up the correct
+the given C<$tree> to the end of the children list, and set up the correct
 parent-child relationships. This method is set up to return its invocant so
 that method call chaining can be possible. Such as:
 
@@ -728,7 +730,7 @@ Or the more complex:
 =item B<addChildren (@trees)>
 
 This method accepts an array of B<Tree::Simple> objects, and adds them to
-it's children list. Like C<addChild> this method will return its invocant
+the children list. Like C<addChild> this method will return its invocant
 to allow for method call chaining.
 
 =item B<insertChild ($index, $tree)>
@@ -737,7 +739,7 @@ This method accepts a numeric C<$index> and a 
B<Tree::Simple> object (C<$tree>),
 and inserts the C<$tree> into the children list at the specified C<$index>.
 This results in the shifting down of all children after the C<$index>. The
 C<$index> is checked to be sure it is the bounds of the child list, if it
-out of bounds an exception is thrown. The C<$tree> argument's type is
+out of bounds an exception is thrown. The C<$tree> argument is
 verified to be a B<Tree::Simple> or B<Tree::Simple> derived object, if
 this condition fails, an exception is thrown.
 
@@ -757,14 +759,14 @@ no match is found, and exception is thrown. If a 
non-B<Tree::Simple> object
 is given as the C<$child> argument, an exception is thrown.
 
 This method also accepts a numeric C<$index> and removes the child found at
-that index from it's list of children. The C<$index> is bounds checked, if
+that index within the list of children. The C<$index> is bounds checked, if
 this condition fail, an exception is thrown.
 
 When a child is removed, it results in the shifting up of all children after
 it, and the removed child is returned. The removed child is properly
 disconnected from the tree and all its references to its old parent are
 removed. However, in order to properly clean up and circular references
-the removed child might have, it is advised to call it's C<DESTROY> method.
+the removed child might have, it is advised to call the C<DESTROY> method.
 See the L<CIRCULAR REFERENCES> section for more information.
 
 =item B<addSibling ($tree)>
@@ -795,7 +797,7 @@ The same effect can be achieved by manual upwards traversal.
 
 =item B<getNodeValue>
 
-This returns the value stored in the object's node field.
+This returns the value stored in the node field of the object.
 
 =item B<getUID>
 
@@ -822,21 +824,21 @@ It will return an array reference in scalar context.
 =item B<getAllSiblings>
 
 Much like C<addSibling> and C<addSiblings>, these two methods simply call
-C<getChild> and C<getAllChildren> on the invocant's parent.
+C<getChild> and C<getAllChildren> on the parent of the invocant.
 
 =item B<getDepth>
 
-Returns a number representing the invocant's depth within the hierarchy of
+Returns a number representing the depth of the invocant within the hierarchy of
 B<Tree::Simple> objects.
 
 B<NOTE:> A C<ROOT> tree has the depth of -1. This be because Tree::Simple
-assumes that a tree's root will usually not contain data, but just be an
+assumes that a root node will usually not contain data, but just be an
 anchor for the data-containing branches. This may not be intuitive in all
 cases, so I mention it here.
 
 =item B<getParent>
 
-Returns the invocant's parent, which could be either B<ROOT> or a
+Returns the parent of the invocant, which could be either B<ROOT> or a
 B<Tree::Simple> object.
 
 =item B<getHeight>
@@ -855,7 +857,7 @@ Returns the number of children the invocant contains.
 
 =item B<getIndex>
 
-Returns the index of this tree within its parent's child list. Returns -1 if
+Returns the index of this tree within its sibling list. Returns -1 if
 the tree is the root.
 
 =back
@@ -870,7 +872,7 @@ Returns true (1) if the invocant does not have any 
children, false (0) otherwise
 
 =item B<isRoot>
 
-Returns true (1) if the invocant's "parent" field is B<ROOT>, returns false
+Returns true (1) if the invocant has a "parent" of B<ROOT>, returns false
 (0) otherwise.
 
 =back
@@ -886,7 +888,7 @@ C<$postfunc>. If the argument C<$func> is not defined then 
an exception
 is thrown. If C<$func> or C<$postfunc> are not in fact CODE references
 then an exception is thrown. The function C<$func> is then applied
 recursively to all the children of the invocant. If given, the function
-C<$postfunc> will be applied to each child after the child's children
+C<$postfunc> will be applied to each child after the children of the child
 have been traversed.
 
 Here is an example of a traversal function that will print out the
@@ -935,7 +937,7 @@ more efficient and usable.
 It accepts either a B<Tree::Simple::Visitor> object (which includes classes 
derived
     from B<Tree::Simple::Visitor>), or an object who has the C<visit> method 
available
     (tested with C<$visitor-E<gt>can('visit')>). If these qualifications are 
not met,
-    and exception will be thrown. We then run the Visitor's C<visit> method 
giving the
+    and exception will be thrown. We then run the Visitor C<visit> method 
giving the
     current tree as its argument.
 
 I have also created a number of Visitor objects and packaged them into the
@@ -999,24 +1001,24 @@ section on L<CIRCULAR REFERENCES> for more information.
 
 =item B<fixDepth>
 
-Tree::Simple will manage your tree's depth field for you using this method. You
+Tree::Simple will manage the depth field for you using this method. You
 should never need to call it on your own, however if you ever did need to, here
-is it. Running this method will traverse your all the invocant's sub-trees
+is it. Running this method will traverse your all the sub-trees of the 
invocant,
 correcting the depth as it goes.
 
 =item B<fixHeight>
 
-Tree::Simple will manage your tree's height field for you using this method.
+Tree::Simple will manage the height field for you using this method.
 You should never need to call it on your own, however if you ever did need to,
 here is it. Running this method will correct the heights of the current tree
-and all it's ancestors.
+and all ancestors heights too.
 
 =item B<fixWidth>
 
-Tree::Simple will manage your tree's width field for you using this method. You
+Tree::Simple will manage the width field for you using this method. You
 should never need to call it on your own, however if you ever did need to,
 here is it. Running this method will correct the widths of the current tree
-and all it's ancestors.
+and all ancestors widths too.
 
 =back
 
@@ -1030,7 +1032,7 @@ Tree::Simple, here they are.
 =item B<_init ($node, $parent, $children)>
 
 This method is here largely to facilitate subclassing. This method is called by
-new to initialize the object, where new's primary responsibility is creating
+new to initialize the object, where new has the primary responsibility of 
creating
 the instance.
 
 =item B<_setParent ($parent)>
@@ -1055,8 +1057,8 @@ I feel is a more consistent and sane way.
 Circular references are now managed with the simple idea that the parent makes
 the decisions for the child. This means that child-to-parent references are
 weak, while parent-to-child references are strong. So if a parent is destroyed
-it will force all it's children to detach from it, however, if a child is
-destroyed it will not be detached from it's parent.
+it will force all the children to detach from it, however, if a child is
+destroyed it will not be detached from the parent.
 
 =head2 Optional Weak References
 
@@ -1069,7 +1071,7 @@ setting like this:
   use Tree::Simple 'use_weak_refs';
 
 And from that point on Tree::Simple will use weak references to allow for
-perl's reference counting to clean things up properly.
+ reference counting to clean things up properly.
 
 For those who are unfamiliar with weak references, and how they affect the
 reference counts, here is a simple illustration. First is the normal model
@@ -1126,7 +1128,7 @@ to fix it.
 =head1 CODE COVERAGE
 
 I use L<Devel::Cover> to test the code coverage of my tests, below
-is the L<Devel::Cover> report on this module's test suite.
+is the L<Devel::Cover> report on the test suite.
 
  ---------------------------- ------ ------ ------ ------ ------ ------ ------
  File                           stmt branch   cond    sub    pod   time  total
@@ -1144,13 +1146,13 @@ module, they are describes below and available on CPAN.
 
 =over 4
 
-=item L<Tree::Parser> - A module for parsing formatted files into Tree::Simple 
hierarchies.
+=item L<Tree::Parser> - A module for parsing formatted files into Tree::Simple 
hierarchies
 
-=item L<Tree::Simple::View> - A set of classes for viewing Tree::Simple 
hierarchies in various output formats.
+=item L<Tree::Simple::View> - For viewing Tree::Simple hierarchies in various 
output formats
 
-=item L<Tree::Simple::VisitorFactory> - A set of several useful Visitor 
objects for Tree::Simple objects.
+=item L<Tree::Simple::VisitorFactory> - Useful Visitor objects for 
Tree::Simple objects
 
-=item L<Tree::Binary> - If you are looking for a binary tree, this you might 
want to check this one out.
+=item L<Tree::Binary> - If you are looking for a binary tree, check this one 
out
 
 =back
 
@@ -1190,7 +1192,7 @@ specialized in purpose.
 =item L<Tree::DAG_Node>
 
 This module seems pretty stable and very robust with a lot of functionality.
-However, B<Tree::DAG_Node> does not come with any automated tests. It's
+However, B<Tree::DAG_Node> does not come with any automated tests.
 I<test.pl> file simply checks the module loads and nothing else. While I
 am sure the author tested his code, I would feel better if I was able to
 see that. The module is approx. 3000 lines with POD, and 1,500 without the
@@ -1224,7 +1226,7 @@ that there is currently no way to remove a child node.
 
 It is a (somewhat) direct translation of the N-ary tree from the GLIB
 library, and the API is based on that. GLIB is a C library, which means
-this is a very C-ish API. That doesn't appeal to me, it might to you, to
+this is a very C-ish API. That does not appeal to me, it might to you, to
 each their own.
 
 This module is similar in intent to B<Tree::Simple>. It implements a tree
@@ -1270,7 +1272,7 @@ Is a wrapper around a C library, again B<Tree::Simple> is 
pure-perl. The author
 describes FAT-trees as a combination of a Tree and an array. It looks like a
 pretty mean and lean module, and good if you need speed and are implementing a
 custom data-store of some kind. The author points out too that the module is
-designed for embedding and there is not default embedding, so you can't really
+designed for embedding and there is not default embedding, so you cannot really
 use it "out of the box".
 
 =back
@@ -1303,7 +1305,7 @@ Ron Savage E<lt>r...@savage.net.aue<gt> has taken over 
maintenance as of V 1.19.
 
 =head1 REPOSITORY
 
-L<https://github.com/stevan/tree-simple>.
+L<https://github.com/ronsavage/Tree-Simple>.
 
 =head1 COPYRIGHT AND LICENSE
 
diff --git a/lib/Tree/Simple/Visitor.pm b/lib/Tree/Simple/Visitor.pm
index 7718a36..24d3a71 100644
--- a/lib/Tree/Simple/Visitor.pm
+++ b/lib/Tree/Simple/Visitor.pm
@@ -3,7 +3,7 @@ package Tree::Simple::Visitor;
 use strict;
 use warnings;
 
-our $VERSION = '1.25';
+our $VERSION = '1.26';
 
 use Scalar::Util qw(blessed);
 
@@ -18,7 +18,8 @@ sub new {
        my ($_class, $func, $depth) = @_;
        if (defined($depth)){
                ($depth =~ /\d+/ && ($depth == RECURSIVE || $depth == 
CHILDREN_ONLY))
-                       || die "Insufficient Arguments : Depth arguement must 
be either RECURSIVE or CHILDREN_ONLY";
+                    || die "Insufficient Arguments : Depth arguement must be 
either ".
+                    "RECURSIVE or CHILDREN_ONLY";
        }
        my $class = ref($_class) || $_class;
     # if we have not supplied a $func
@@ -66,7 +67,7 @@ sub clearNodeFilter {
 sub setNodeFilter {
     my ($self, $filter_function) = @_;
        (defined($filter_function) && ref($filter_function) eq "CODE")
-               || die "Insufficient Arguments : filter function argument must 
be a subroutine reference";
+            || die "Insufficient Arguments : filter function argument must be 
a subroutine reference";
        $self->{_filter_function} = $filter_function;
 }
 
@@ -89,7 +90,7 @@ sub getResults {
 sub visit {
        my ($self, $tree) = @_;
        (blessed($tree) && $tree->isa("Tree::Simple"))
-               || die "Insufficient Arguments : You must supply a valid 
Tree::Simple object";
+            || die "Insufficient Arguments : You must supply a valid 
Tree::Simple object";
     # get all things set up
        my @results;
        my $func;
@@ -166,9 +167,13 @@ Tree::Simple::Visitor - Visitor object for Tree::Simple 
objects
 
 =head1 DESCRIPTION
 
-This object has been revised into what I think is more intelligent approach to 
Visitor objects. This is now a more suitable base class for building your own 
Visitors. It is also the base class for the visitors found in the 
B<Tree::Simple::VisitorFactory> distribution, which includes a number of useful 
pre-built Visitors.
+This object has been revised into what I think is more intelligent approach to 
Visitor objects.
+This is now a more suitable base class for building your own Visitors. It is 
also the base class
+for the visitors found in the B<Tree::Simple::VisitorFactory> distribution, 
which includes a
+number of useful pre-built Visitors.
 
-While I have changed a number of things about this module, I have kept it 
backwards compatible to the old way of using it. So the original example code 
still works:
+While I have changed a number of things about this module, I have kept it 
backwards compatible
+to the old way of using it. So the original example code still works:
 
   my @accumulator;
   my $visitor = Tree::Simple::Visitor->new(sub {
@@ -187,7 +192,8 @@ But is better expressed as this:
   $tree->accept($visitor);
   print join ", ", $visitor->getResults();  # prints "1.0, 2.0, 2.1.0, 3.0"
 
-This object is still pretty much a wrapper around the Tree::Simple C<traverse> 
method, and can be thought of as a depth-first traversal Visitor object.
+This object is still pretty much a wrapper around the Tree::Simple C<traverse> 
method,
+and can be thought of as a depth-first traversal Visitor object.
 
 =head1 METHODS
 
@@ -195,15 +201,34 @@ This object is still pretty much a wrapper around the 
Tree::Simple C<traverse> m
 
 =item B<new ($func, $depth)>
 
-The new style interface means that all arguments to the constructor are now 
optional. As a means of defining the usage of the old and new, when no 
arguments are sent to the constructor, it is assumed that the new style 
interface is being used. In the new style, the C<$depth> is always assumed to 
be equivalent to C<RECURSIVE> and the C<$func> argument can be set with 
C<setNodeFilter> instead. This is the recommended way of doing things now. If 
you have been using the old way, it is still  [...]
+The new style interface means that all arguments to the constructor are now 
optional.
+As a means of defining the usage of the old and new, when no arguments are 
sent to the
+constructor, it is assumed that the new style interface is being used. In the 
new style,
+the C<$depth> is always assumed to be equivalent to C<RECURSIVE> and the 
C<$func> argument
+can be set with C<setNodeFilter> instead. This is the recommended way of doing 
things now.
+If you have been using the old way, it is still there, and I will maintain 
backwards
+compatibility for a few more version before removing it entirely. If you are 
using this
+module (and I do not even know if anyone actually is) you have been warned. 
Please contact
+me if this will be a problem.
 
 The old style constructor documentation is retained her for reference:
 
-The first argument to the constructor is a code reference to a function which 
expects a B<Tree::Simple> object as its only argument. The second argument is 
optional, it can be used to set the depth to which the function is applied. If 
no depth is set, the function is applied to the current B<Tree::Simple> 
instance. If C<$depth> is set to C<CHILDREN_ONLY>, then the function will be 
applied to the current B<Tree::Simple> instance and all its immediate children. 
If C<$depth> is set to C<REC [...]
+The first argument to the constructor is a code reference to a function which 
expects a
+B<Tree::Simple> object as its only argument. The second argument is optional, 
it can be
+used to set the depth to which the function is applied. If no depth is set, 
the function
+is applied to the current B<Tree::Simple> instance. If C<$depth> is set to 
C<CHILDREN_ONLY>,
+then the function will be applied to the current B<Tree::Simple> instance and 
all its
+immediate children. If C<$depth> is set to C<RECURSIVE>, then the function 
will be applied
+to the current B<Tree::Simple> instance and all its immediate children, and 
all of their
+children recursively on down the tree. If no C<$depth> is passed to the 
constructor,
+then the function will only be applied to the current B<Tree::Simple> object 
and none
+ of its children.
 
 =item B<includeTrunk ($boolean)>
 
-Based upon the value of C<$boolean>, this will tell the visitor to collect the 
trunk of the tree as well. It is defaulted to false (C<0>) in the new style 
interface, but is defaulted to true (C<1>) in the old style interface.
+Based upon the value of C<$boolean>, this will tell the visitor to collect the 
trunk of the
+tree as well. It is defaulted to false (C<0>) in the new style interface, but 
is defaulted
+to true (C<1>) in the old style interface.
 
 =item B<getNodeFilter>
 
@@ -215,7 +240,10 @@ This method clears node filter field.
 
 =item B<setNodeFilter ($filter_function)>
 
-This method accepts a CODE reference as its C<$filter_function> argument. This 
code reference is used to filter the tree nodes as they are collected. This can 
be used to customize output, or to gather specific information from a more 
complex tree node. The filter function should accept a single argument, which 
is the current Tree::Simple object.
+This method accepts a CODE reference as its C<$filter_function> argument. This 
code reference
+is used to filter the tree nodes as they are collected. This can be used to 
customize output,
+or to gather specific information from a more complex tree node. The filter 
function should
+accept a single argument, which is the current Tree::Simple object.
 
 =item B<getResults>
 
@@ -223,11 +251,15 @@ This method returns the accumulated results of the 
application of the node filte
 
 =item B<setResults>
 
-This method should not really be used outside of this class, as it just would 
not make any sense to. It is included in this class and in this documentation 
to facilitate subclassing of this class for your own needs. If you desire to 
clear the results, then you can simply call C<setResults> with no argument.
+This method should not really be used outside of this class, as it just would 
not make any sense
+to. It is included in this class and in this documentation to facilitate 
subclassing of this
+class for your own needs. If you desire to clear the results, then you can 
simply call
+C<setResults> with no argument.
 
 =item B<visit ($tree)>
 
-The C<visit> method accepts a B<Tree::Simple> and applies the function set in 
C<new> or C<setNodeFilter> appropriately. The results of this application can 
be retrieved with C<getResults>
+The C<visit> method accepts a B<Tree::Simple> and applies the function set in 
C<new> or
+C<setNodeFilter> appropriately. The results of this application can be 
retrieved with C<getResults>
 
 =back
 
@@ -239,26 +271,36 @@ These constants are part of the old-style interface, and 
therefore will eventual
 
 =item B<RECURSIVE>
 
-If passed this constant in the constructor, the function will be applied 
recursively down the hierarchy of B<Tree::Simple> objects.
+If passed this constant in the constructor, the function will be applied 
recursively down the
+hierarchy of B<Tree::Simple> objects.
 
 =item B<CHILDREN_ONLY>
 
-If passed this constant in the constructor, the function will be applied to 
the immediate children of the B<Tree::Simple> object.
+If passed this constant in the constructor, the function will be applied to 
the immediate children
+of the B<Tree::Simple> object.
 
 =back
 
 =head1 BUGS
 
-None that I am aware of. The code is pretty thoroughly tested (see B<CODE 
COVERAGE> section in B<Tree::Simple>) and is based on an (non-publicly 
released) module which I had used in production systems for about 2 years 
without incident. Of course, if you find a bug, let me know, and I will be sure 
to fix it.
+None that I am aware of. The code is pretty thoroughly tested (see B<CODE 
COVERAGE> section in
+B<Tree::Simple>) and is based on an (non-publicly released) module which I had 
used in production
+systems for about 2 years without incident. Of course, if you find a bug, let 
me know, and I will
+be sure to fix it.
 
 =head1 SEE ALSO
 
-I have written a set of pre-built Visitor objects, available on CPAN as 
B<Tree::Simple::VisitorFactory>.
+I have written a set of pre-built Visitor objects, available on CPAN as
+B<Tree::Simple::VisitorFactory>.
 
 =head1 AUTHOR
 
 stevan little, E<lt>ste...@iinteractive.come<gt>
 
+=head1 REPOSITORY
+
+L<https://github.com/ronsavage/Tree-Simple>.
+
 =head1 COPYRIGHT AND LICENSE
 
 Copyright 2004-2006 by Infinity Interactive, Inc.
diff --git a/t/10_Tree_Simple_test.t b/t/10_Tree_Simple_test.t
index 7c23276..507e7bb 100644
--- a/t/10_Tree_Simple_test.t
+++ b/t/10_Tree_Simple_test.t
@@ -5,8 +5,8 @@ use warnings;
 
 use Test::More tests => 292;
 
-BEGIN { 
-       use_ok('Tree::Simple'); 
+BEGIN {
+       use_ok('Tree::Simple');
 };
 
 ## ----------------------------------------------------------------------------
@@ -14,10 +14,10 @@ BEGIN {
 ## ----------------------------------------------------------------------------
 # NOTE:
 # This test checks the base functionality of the Tree::Simple object. The test
-# is so large because (at the moment) each test relies upon the tree created 
+# is so large because (at the moment) each test relies upon the tree created
 # by the previous tests. It is not the most efficient or sensible thing to do
-# i know, but its how it is for now. There are close to 300 tests here, so 
-# splitting them up would be a chore. 
+# i know, but its how it is for now. There are close to 300 tests here, so
+# splitting them up would be a chore.
 ## ----------------------------------------------------------------------------
 
 # check that we have a constructor
@@ -92,13 +92,13 @@ cmp_ok($tree->getIndex(), '==', -1, '... root trees have no 
index');
 can_ok($tree, 'getUID');
 
 is($tree->getUID(), $tree->getUID(), '... UIDs match for the same object');
-is("$tree", "Tree::Simple=HASH(" . $tree->getUID() . ")", '... our UID is 
derived from our hex address'); 
+is("$tree", "Tree::Simple=HASH(" . $tree->getUID() . ")", '... our UID is 
derived from our hex address');
 
 can_ok($tree, 'setUID');
 $tree->setUID("This is our unique identifier");
 
 is($tree->getUID(), 'This is our unique identifier', '... UIDs match what we 
have set it to');
-isnt("$tree", "Tree::Simple=HASH(" . $tree->getUID() . ")", '... our UID is no 
longer derived from our hex address'); 
+isnt("$tree", "Tree::Simple=HASH(" . $tree->getUID() . ")", '... our UID is no 
longer derived from our hex address');
 
 ## ----------------------------------------------------------------------------
 ## testing adding children
@@ -111,13 +111,13 @@ isa_ok($sub_tree, 'Tree::Simple');
 # check the node value
 is($sub_tree->getNodeValue(), "1.0", '... this tree is 1.0');
 
-# since we have not assigned a parent it 
+# since we have not assigned a parent it
 # will still be considered a root
 ok($sub_tree->isRoot());
 
 # and since it has no children
 # it is also a leaf node
-ok($sub_tree->isLeaf());       
+ok($sub_tree->isLeaf());
 
 # now add the child to our root
 $tree->addChild($sub_tree);
@@ -136,7 +136,7 @@ cmp_ok($sub_tree->getDepth(), '==', 0, '... depth should be 
0 now');
 # check the index
 cmp_ok($sub_tree->getIndex(), '==', 0, '... index should be 0 now');
 
-# check the child count, 
+# check the child count,
 # it should be one now
 cmp_ok($tree->getChildCount(), '==', 1, '... we should have 1 children now');
 
@@ -150,13 +150,13 @@ my $sub_tree_parent = $sub_tree->getParent();
 
 # now test that the parent of
 # our sub_tree is the same as
-# our root     
+# our root
 is($tree, $sub_tree_parent, '... make sure our sub_tree parent is tree');
 
 ## ----------------------------------------------------------------------------
 ## testing adding siblings
 ## ----------------------------------------------------------------------------
-       
+
 # create another sub_tree
 my $sub_tree_2 = Tree::Simple->new("2.0");
 isa_ok($sub_tree_2, 'Tree::Simple');
@@ -164,7 +164,7 @@ isa_ok($sub_tree_2, 'Tree::Simple');
 # check its node value
 is($sub_tree_2->getNodeValue(), "2.0", '... this tree is 2.0');
 
-# since we have not assigned a parent to 
+# since we have not assigned a parent to
 # the new sub_tree it will still be
 # considered a root
 ok($sub_tree_2->isRoot());
@@ -178,7 +178,7 @@ ok($sub_tree_2->isLeaf());
 $sub_tree->addSibling($sub_tree_2);
 
 # now that we have assigned a parent to
-# the new sub_tree, it will no longer be 
+# the new sub_tree, it will no longer be
 # considered a root
 ok(!$sub_tree_2->isRoot());
 
@@ -188,33 +188,33 @@ cmp_ok($sub_tree_2->getDepth(), '==', 0, '... depth 
should be 0 now');
 # check the index
 cmp_ok($sub_tree_2->getIndex(), '==', 1, '... index should be 1');
 
-# make sure that we now have 2 children in our root    
-cmp_ok($tree->getChildCount(), '==', 2, '... we should have 2 children now');  
+# make sure that we now have 2 children in our root
+cmp_ok($tree->getChildCount(), '==', 2, '... we should have 2 children now');
 
 # and verify that the child at index 1
-# is actually our second sub_tree      
-is($tree->getChild(1), $sub_tree_2, '... make sure our sub_tree is 
fetchable');        
-       
+# is actually our second sub_tree
+is($tree->getChild(1), $sub_tree_2, '... make sure our sub_tree is fetchable');
+
 # get the parent of our second sub_tree
 my $sub_tree_2_parent = $sub_tree_2->getParent();
 
-# and make sure that it is the 
+# and make sure that it is the
 # same as our root
 is($tree, $sub_tree_2_parent, '... make sure our sub_tree_2 parent is tree');
-       
+
 ## ----------------------------------------------------------------------------
 ## test adding child by giving parent as a constructor argument
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 
 # we create our new sub_tree and attach it
 # to our root through its constructor
-my $sub_tree_4 = Tree::Simple->new("4.0", $tree);      
+my $sub_tree_4 = Tree::Simple->new("4.0", $tree);
 
 # check its node value
 is($sub_tree_4->getNodeValue(), "4.0", '... this tree is 4.0');
 
 # since we have assigned a parent to
-# the new sub_tree, it will no longer be 
+# the new sub_tree, it will no longer be
 # considered a root
 ok(!$sub_tree_4->isRoot());
 
@@ -228,28 +228,28 @@ cmp_ok($sub_tree_4->getIndex(), '==', 2, '... index 
should be 2 now');
 # it is also a leaf node
 ok($sub_tree_4->isLeaf());
 
-# make sure that we now have 3 children in our root    
+# make sure that we now have 3 children in our root
 cmp_ok($tree->getChildCount(), '==', 3, '... we should have 3 children now');
 
 # and verify that the child at index 2
-# is actually our latest sub_tree      
-is($tree->getChild(2), $sub_tree_4, '... make sure our sub_tree is 
fetchable');        
+# is actually our latest sub_tree
+is($tree->getChild(2), $sub_tree_4, '... make sure our sub_tree is fetchable');
 
 # and make sure that the new sub-trees
 # parent is the same as our root
 is($tree, $sub_tree_4->getParent(), '... make sure our sub_tree_4 parent is 
tree');
 
 ## ----------------------------------------------------------------------------
-## test inserting child 
-## 
----------------------------------------------------------------------------    
    
+## test inserting child
+## ----------------------------------------------------------------------------
 
-# we create our new sub_tree 
-my $sub_tree_3 = Tree::Simple->new("3.0");     
+# we create our new sub_tree
+my $sub_tree_3 = Tree::Simple->new("3.0");
 
 # check its node value
 is($sub_tree_3->getNodeValue(), "3.0", '... this tree is 3.0');
 
-# since we have not assigned a parent to 
+# since we have not assigned a parent to
 # the new sub_tree it will still be
 # considered a root
 ok($sub_tree_3->isRoot());
@@ -262,7 +262,7 @@ ok($sub_tree_3->isLeaf());
 $tree->insertChild(2, $sub_tree_3);
 
 # since we now have assigned a parent to
-# the new sub_tree, it will no longer be 
+# the new sub_tree, it will no longer be
 # considered a root
 ok(!$sub_tree_3->isRoot());
 
@@ -275,25 +275,25 @@ cmp_ok($sub_tree_3->getIndex(), '==', 2, '... index 
should be 2 now');
 # check the index of 4 now
 cmp_ok($sub_tree_4->getIndex(), '==', 3, '... index should be 3 now');
 
-# make sure that we now have 3 children in our root    
+# make sure that we now have 3 children in our root
 cmp_ok($tree->getChildCount(), '==', 4, '... we should have 4 children now');
 
 # and verify that the child at index 2
-# is actually our latest sub_tree      
-is($tree->getChild(2), $sub_tree_3, '... make sure our sub_tree is 
fetchable');        
+# is actually our latest sub_tree
+is($tree->getChild(2), $sub_tree_3, '... make sure our sub_tree is fetchable');
 
-# and verify that the child that was 
+# and verify that the child that was
 # at index 2 is actually now actually
-# at index 3   
-is($tree->getChild(3), $sub_tree_4, '... make sure our sub_tree is 
fetchable');        
+# at index 3
+is($tree->getChild(3), $sub_tree_4, '... make sure our sub_tree is fetchable');
 
 # and make sure that the new sub-trees
 # parent is the same as our root
-is($tree, $sub_tree_3->getParent(), '... make sure our sub_tree_3 parent is 
tree');    
+is($tree, $sub_tree_3->getParent(), '... make sure our sub_tree_3 parent is 
tree');
 
 ## ----------------------------------------------------------------------------
 ## test getting all children and siblings
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 
 # get it in scalar context and
 # check that our arrays are equal
@@ -309,7 +309,7 @@ ok eq_array(\@children, [ $sub_tree, $sub_tree_2, 
$sub_tree_3, $sub_tree_4 ]);
 # contexts are equal to one another
 ok eq_array($children, \@children);
 
-# now check that the siblings of all the 
+# now check that the siblings of all the
 # sub_trees are the same as the children
 foreach my $_sub_tree (@children) {
        # test siblings in scalar context
@@ -322,7 +322,7 @@ foreach my $_sub_tree (@children) {
 
 ## ----------------------------------------------------------------------------
 ## test addChildren
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 
 my @sub_children = (
                        Tree::Simple->new("1.1"),
@@ -340,9 +340,9 @@ foreach my $sub_child (@sub_children) {
 
        # and their node values
        like($sub_child->getNodeValue(), qr/1\.[0-9]/, '... they at least have 
"1." followed by a digit');
-       
+
        # and they should all have a depth of -1
-       cmp_ok($sub_child->getDepth(), '==', -1, '... depth should be -1');     
+       cmp_ok($sub_child->getDepth(), '==', -1, '... depth should be -1');
 }
 
 # check to see if we can add children
@@ -351,10 +351,10 @@ $sub_tree->addChildren(@sub_children);
 # we are no longer a leaf node now
 ok(!$sub_tree->isLeaf());
 
-# make sure that we now have 3 children now    
+# make sure that we now have 3 children now
 cmp_ok($sub_tree->getChildCount(), '==', 3, '... we should have 3 children 
now');
 
-# now check that sub_tree's children 
+# now check that sub_tree's children
 # are the same as our list
 ok eq_array([ $sub_tree->getAllChildren() ], \@sub_children);
 
@@ -364,25 +364,25 @@ foreach my $sub_child (@sub_children) {
        # they should no longer think
        # they are root
        ok(!$sub_child->isRoot());
-       
-       # but they should still think they 
+
+       # but they should still think they
        # are leaves
        ok($sub_child->isLeaf());
-       
+
        # now we test their parental relationship
        is($sub_tree, $sub_child->getParent(), '... their parent is the 
sub_tree');
-       
+
        # and they should all have a depth of 1
        cmp_ok($sub_child->getDepth(), '==', 1, '... depth should be 1');
-       
-       # now check that its siblings are the same 
-       # as the children of its parent                 
+
+       # now check that its siblings are the same
+       # as the children of its parent
        ok eq_array([ $sub_tree->getAllChildren() ], [ 
$sub_child->getAllSiblings() ]);
 }
 
 ## ----------------------------------------------------------------------------
 ## test insertingChildren
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 
 my @more_sub_children = (
                        Tree::Simple->new("1.2"),
@@ -400,18 +400,18 @@ foreach my $sub_child (@more_sub_children) {
 
        # and their node values
        like($sub_child->getNodeValue(), qr/1\.[0-9]/, '... they at least have 
"1." followed by a digit');
-       
+
        # and they should all have a depth of -1
-       cmp_ok($sub_child->getDepth(), '==', -1, '... depth should be -1');     
+       cmp_ok($sub_child->getDepth(), '==', -1, '... depth should be -1');
 }
 
 # check to see if we can insert children
 $sub_tree->insertChildren(1, @more_sub_children);
 
-# make sure that we now have 6 children now    
+# make sure that we now have 6 children now
 cmp_ok($sub_tree->getChildCount(), '==', 6, '... we should have 6 children 
now');
 
-# now check that sub_tree's children 
+# now check that sub_tree's children
 # are the same as our list
 ok eq_array([ $sub_tree->getAllChildren() ], [ $sub_children[0], 
@more_sub_children, @sub_children[1 .. $#sub_children] ]);
 
@@ -421,25 +421,25 @@ foreach my $sub_child (@more_sub_children) {
        # they should no longer think
        # they are roots
        ok(!$sub_child->isRoot());
-       
-       # but they should still think they 
+
+       # but they should still think they
        # are leaves
        ok($sub_child->isLeaf());
-       
+
        # now we test their parental relationship
        is($sub_tree, $sub_child->getParent(), '... their parent is the 
sub_tree');
-       
+
        # and they should all have a depth of 1
        cmp_ok($sub_child->getDepth(), '==', 1, '... depth should be 1');
-       
-       # now check that its siblings are the same 
+
+       # now check that its siblings are the same
        # as the children of its parent
        ok eq_array([ $sub_tree->getAllChildren() ], [ 
$sub_child->getAllSiblings() ]);
 }
 
 ## ----------------------------------------------------------------------------
 ## test addingSiblings
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 
 my @more_children = (
                        Tree::Simple->new("5.0"),
@@ -456,18 +456,18 @@ foreach my $sub_child (@more_children) {
 
        # and their node values
        like($sub_child->getNodeValue(), qr/[0-9]\.0/, '... they at least have 
digit followed by ".0"');
-       
+
        # and they should all have a depth of -1
-       cmp_ok($sub_child->getDepth(), '==', -1, '... depth should be -1');     
+       cmp_ok($sub_child->getDepth(), '==', -1, '... depth should be -1');
 }
 
 # check to see if we can insert children
 $sub_tree->addSiblings(@more_children);
 
-# make sure that we now have 6 children now    
+# make sure that we now have 6 children now
 cmp_ok($tree->getChildCount(), '==', 6, '... we should have 6 children now');
 
-# now check that tree's new children 
+# now check that tree's new children
 # are the same as our list
 is($tree->getChild(4), $more_children[0], '... they are the same');
 is($tree->getChild(5), $more_children[1], '... they are the same');
@@ -478,27 +478,27 @@ foreach my $sub_child (@more_children) {
        # they should no longer think
        # they are roots
        ok(!$sub_child->isRoot());
-       
-       # but they should still think they 
+
+       # but they should still think they
        # are leaves
        ok($sub_child->isLeaf());
-       
+
        # now we test their parental relationship
        is($tree, $sub_child->getParent(), '... their parent is the tree');
-       
+
        # and they should all have a depth of 1
        cmp_ok($sub_child->getDepth(), '==', 0, '... depth should be 0');
-       
-       # now check that its siblings are the same 
-       # as the children of its parent                 
+
+       # now check that its siblings are the same
+       # as the children of its parent
        ok eq_array([ $tree->getAllChildren() ], [ $sub_child->getAllSiblings() 
]);
 }
 
 ## ----------------------------------------------------------------------------
 ## test insertSibling
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 
-my $new_sibling = Tree::Simple->new("8.0"); 
+my $new_sibling = Tree::Simple->new("8.0");
 
 # they should think they are root
 ok($new_sibling->isRoot());
@@ -510,18 +510,18 @@ ok($new_sibling->isLeaf());
 is($new_sibling->getNodeValue(), "8.0", '... node value should be 6.0');
 
 # and they should all have a depth of -1
-cmp_ok($new_sibling->getDepth(), '==', -1, '... depth should be -1');  
+cmp_ok($new_sibling->getDepth(), '==', -1, '... depth should be -1');
 
 # check to see if we can insert children
 $sub_tree->insertSibling(5, $new_sibling);
 
-# make sure that we now have 6 children now    
+# make sure that we now have 6 children now
 cmp_ok($tree->getChildCount(), '==', 7, '... we should have 7 children now');
 
 # now check that sub_tree's new sibling
-# is in the right place and that it 
+# is in the right place and that it
 # should have displaced the old value at
-# that index to index + 1 
+# that index to index + 1
 is($tree->getChild(4), $more_children[0], '... they are the same');
 is($tree->getChild(5), $new_sibling, '... they are the same');
 is($tree->getChild(6), $more_children[1], '... they are the same');
@@ -530,7 +530,7 @@ is($tree->getChild(6), $more_children[1], '... they are the 
same');
 # they are roots
 ok(!$new_sibling->isRoot());
 
-# but they should still think they 
+# but they should still think they
 # are leaves
 ok($new_sibling->isLeaf());
 
@@ -539,14 +539,14 @@ is($tree, $new_sibling->getParent(), '... their parent is 
the tree');
 
 # and they should all have a depth of 1
 cmp_ok($new_sibling->getDepth(), '==', 0, '... depth should be 0');
-       
-# now check that its siblings are the same 
-# as the children of its parent                        
+
+# now check that its siblings are the same
+# as the children of its parent
 ok eq_array([ $tree->getAllChildren() ], [ $new_sibling->getAllSiblings() ]);
 
 ## ----------------------------------------------------------------------------
 ## test inserting Siblings
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 
 my @even_more_children = (
                        Tree::Simple->new("6.0"),
@@ -563,18 +563,18 @@ foreach my $sub_child (@even_more_children) {
 
        # and their node values
        like($sub_child->getNodeValue(), qr/[0-9]\.0/, '... they at least have 
digit followed by ".0"');
-       
+
        # and they should all have a depth of -1
-       cmp_ok($sub_child->getDepth(), '==', -1, '... depth should be -1');     
+       cmp_ok($sub_child->getDepth(), '==', -1, '... depth should be -1');
 }
 
 # check to see if we can insert children
 $sub_tree->insertSiblings(5, @even_more_children);
 
-# make sure that we now have 6 children now    
+# make sure that we now have 6 children now
 cmp_ok($tree->getChildCount(), '==', 9, '... we should have 6 children now');
 
-# now check that tree's new children 
+# now check that tree's new children
 # are the same as our list
 is($tree->getChild(4), $more_children[0], '... they are the same');
 is($tree->getChild(5), $even_more_children[0], '... they are the same');
@@ -588,34 +588,34 @@ foreach my $sub_child (@even_more_children) {
        # they should no longer think
        # they are roots
        ok(!$sub_child->isRoot());
-       
-       # but they should still think they 
+
+       # but they should still think they
        # are leaves
        ok($sub_child->isLeaf());
-       
+
        # now we test their parental relationship
        is($tree, $sub_child->getParent(), '... their parent is the tree');
-       
+
        # and they should all have a depth of 1
        cmp_ok($sub_child->getDepth(), '==', 0, '... depth should be 0');
-       
-       # now check that its siblings are the same 
-       # as the children of its parent                 
+
+       # now check that its siblings are the same
+       # as the children of its parent
        ok eq_array([ $tree->getAllChildren() ], [ $sub_child->getAllSiblings() 
]);
 }
 
 ## ----------------------------------------------------------------------------
 ## test getChild and getSibling
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 
 # make sure that getChild returns the
 # same as getSibling
-is($tree->getChild($_), $sub_tree->getSibling($_), '... siblings are the same 
as children') 
+is($tree->getChild($_), $sub_tree->getSibling($_), '... siblings are the same 
as children')
        foreach (0 .. $tree->getChildCount());
 
 ## ----------------------------------------------------------------------------
 ## test self referential returns
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 
 # addChildren's return value is actually $self
 # so that method calls can be chained
@@ -646,23 +646,23 @@ foreach my $sub_child 
($self_ref_tree_test->getAllChildren()) {
        # they should not think
        # they are roots
        ok(!$sub_child->isRoot());
-       
-       # but they should think they 
+
+       # but they should think they
        # are leaves
        ok($sub_child->isLeaf());
-       
+
        # now we test their parental relationship
        is($self_ref_tree_test, $sub_child->getParent(), '... their parent is 
the tree');
-       
+
        # and they should all have a depth of 1
        cmp_ok($sub_child->getDepth(), '==', 2, '... depth should be 0');
-       
-       # now check that its siblings are the same 
-       # as the children of its parent                 
+
+       # now check that its siblings are the same
+       # as the children of its parent
        ok eq_array([ $self_ref_tree_test->getAllChildren() ], [ 
$sub_child->getAllSiblings() ]);
 }
 
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 ## Test self-referential version of addChild
 ## ----------------------------------------------------------------------------
 
@@ -696,7 +696,7 @@ my $sub_child = $self_ref_tree_test_2->getChild(0);
 # they are roots
 ok(!$sub_child->isRoot());
 
-# but they should think they 
+# but they should think they
 # are leaves
 ok($sub_child->isLeaf());
 
@@ -706,13 +706,13 @@ is($self_ref_tree_test_2, $sub_child->getParent(), '... 
their parent is the tree
 # and they should all have a depth of 1
 cmp_ok($sub_child->getDepth(), '==', 2, '... depth should be 0');
 
-# now check that its siblings are the same 
-# as the children of its parent                
+# now check that its siblings are the same
+# as the children of its parent
 ok eq_array([ $self_ref_tree_test_2->getAllChildren() ], [ 
$sub_child->getAllSiblings() ]);
 
 ## ----------------------------------------------------------------------------
 ## test removeChildAt
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 
 my $sub_tree_of_tree_to_remove = Tree::Simple->new("1.1.a.1");
 # make a node to remove
@@ -722,9 +722,9 @@ my $tree_to_remove = 
Tree::Simple->new("1.1.a")->addChild($sub_tree_of_tree_to_r
 ok($tree_to_remove->isRoot());
 
 # and that its depth is -1
-cmp_ok($tree_to_remove->getDepth(), '==', -1, '... the depth should be -1'); 
+cmp_ok($tree_to_remove->getDepth(), '==', -1, '... the depth should be -1');
 # and the sub-trees depth is 0
-cmp_ok($sub_tree_of_tree_to_remove->getDepth(), '==', 0, '... the depth should 
be 0'); 
+cmp_ok($sub_tree_of_tree_to_remove->getDepth(), '==', 0, '... the depth should 
be 0');
 
 # insert it into the sub_tree
 $sub_tree->insertChild(1, $tree_to_remove);
@@ -733,30 +733,30 @@ $sub_tree->insertChild(1, $tree_to_remove);
 ok(!$tree_to_remove->isRoot());
 
 # check thats its depth is now 1
-cmp_ok($tree_to_remove->getDepth(), '==', 1, '... the depth should be 1'); 
+cmp_ok($tree_to_remove->getDepth(), '==', 1, '... the depth should be 1');
 # and the sub-trees depth is 2
-cmp_ok($sub_tree_of_tree_to_remove->getDepth(), '==', 2, '... the depth should 
be 2'); 
+cmp_ok($sub_tree_of_tree_to_remove->getDepth(), '==', 2, '... the depth should 
be 2');
 
 # make sure it is there
-is($sub_tree->getChild(1), $tree_to_remove, '... these tree should be equal'); 
        
+is($sub_tree->getChild(1), $tree_to_remove, '... these tree should be equal');
 
 # remove the subtree (it will be returned)
 my $removed_tree = $sub_tree->removeChildAt(1);
 
-# now check that the one removed it the one 
+# now check that the one removed it the one
 # we inserted origianlly
 is($removed_tree, $tree_to_remove, '... these tree should be equal');
 
 # it should think its a root again
 ok($tree_to_remove->isRoot());
 # and its depth should be back to -1
-cmp_ok($tree_to_remove->getDepth(), '==', -1, '... the depth should be -1'); 
+cmp_ok($tree_to_remove->getDepth(), '==', -1, '... the depth should be -1');
 # and the sub-trees depth is 0
-cmp_ok($sub_tree_of_tree_to_remove->getDepth(), '==', 0, '... the depth should 
be 0');         
+cmp_ok($sub_tree_of_tree_to_remove->getDepth(), '==', 0, '... the depth should 
be 0');
 
 ## ----------------------------------------------------------------------------
 ## test removeChild
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 
 my $sub_tree_of_tree_to_remove2 = Tree::Simple->new("1.1.a.1");
 # make a node to remove
@@ -766,9 +766,9 @@ my $tree_to_remove2 = 
Tree::Simple->new("1.1.a")->addChild($sub_tree_of_tree_to_
 ok($tree_to_remove2->isRoot());
 
 # and that its depth is -1
-cmp_ok($tree_to_remove2->getDepth(), '==', -1, '... the depth should be -1'); 
+cmp_ok($tree_to_remove2->getDepth(), '==', -1, '... the depth should be -1');
 # and the sub-trees depth is 0
-cmp_ok($sub_tree_of_tree_to_remove2->getDepth(), '==', 0, '... the depth 
should be 0'); 
+cmp_ok($sub_tree_of_tree_to_remove2->getDepth(), '==', 0, '... the depth 
should be 0');
 
 # insert it into the sub_tree
 $sub_tree->insertChild(1, $tree_to_remove2);
@@ -777,30 +777,30 @@ $sub_tree->insertChild(1, $tree_to_remove2);
 ok(!$tree_to_remove2->isRoot());
 
 # check thats its depth is now 1
-cmp_ok($tree_to_remove2->getDepth(), '==', 1, '... the depth should be 1'); 
+cmp_ok($tree_to_remove2->getDepth(), '==', 1, '... the depth should be 1');
 # and the sub-trees depth is 2
-cmp_ok($sub_tree_of_tree_to_remove2->getDepth(), '==', 2, '... the depth 
should be 2'); 
+cmp_ok($sub_tree_of_tree_to_remove2->getDepth(), '==', 2, '... the depth 
should be 2');
 
 # make sure it is there
-is($sub_tree->getChild(1), $tree_to_remove2, '... these tree should be 
equal');                
+is($sub_tree->getChild(1), $tree_to_remove2, '... these tree should be equal');
 
 # remove the subtree (it will be returned)
 my $removed_tree2 = $sub_tree->removeChild($tree_to_remove2);
 
-# now check that the one removed it the one 
+# now check that the one removed it the one
 # we inserted origianlly
 is($removed_tree2, $tree_to_remove2, '... these tree should be equal');
 
 # it should think its a root again
 ok($tree_to_remove2->isRoot());
 # and its depth should be back to -1
-cmp_ok($tree_to_remove2->getDepth(), '==', -1, '... the depth should be -1'); 
+cmp_ok($tree_to_remove2->getDepth(), '==', -1, '... the depth should be -1');
 # and the sub-trees depth is 0
-cmp_ok($sub_tree_of_tree_to_remove2->getDepth(), '==', 0, '... the depth 
should be 0');        
+cmp_ok($sub_tree_of_tree_to_remove2->getDepth(), '==', 0, '... the depth 
should be 0');
 
 ## ----------------------------------------------------------------------------
 ## test removeChild backwards compatibility
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 
 # make a node to remove
 my $tree_to_remove3 = Tree::Simple->new("1.1.a");
@@ -809,7 +809,7 @@ my $tree_to_remove3 = Tree::Simple->new("1.1.a");
 ok($tree_to_remove3->isRoot());
 
 # and that its depth is -1
-cmp_ok($tree_to_remove3->getDepth(), '==', -1, '... the depth should be -1'); 
+cmp_ok($tree_to_remove3->getDepth(), '==', -1, '... the depth should be -1');
 
 # insert it into the sub_tree
 $sub_tree->insertChild(1, $tree_to_remove3);
@@ -818,22 +818,22 @@ $sub_tree->insertChild(1, $tree_to_remove3);
 ok(!$tree_to_remove3->isRoot());
 
 # check thats its depth is now 1
-cmp_ok($tree_to_remove3->getDepth(), '==', 1, '... the depth should be 1'); 
+cmp_ok($tree_to_remove3->getDepth(), '==', 1, '... the depth should be 1');
 
 # make sure it is there
-is($sub_tree->getChild(1), $tree_to_remove3, '... these tree should be 
equal');                
+is($sub_tree->getChild(1), $tree_to_remove3, '... these tree should be equal');
 
 # remove the subtree (it will be returned)
 my $removed_tree3 = $sub_tree->removeChild(1);
 
-# now check that the one removed it the one 
+# now check that the one removed it the one
 # we inserted origianlly
 is($removed_tree3, $tree_to_remove3, '... these tree should be equal');
 
 # it should think its a root again
 ok($tree_to_remove3->isRoot());
 # and its depth should be back to -1
-cmp_ok($tree_to_remove3->getDepth(), '==', -1, '... the depth should be -1'); 
+cmp_ok($tree_to_remove3->getDepth(), '==', -1, '... the depth should be -1');
 
 ## ----------------------------------------------
 ## now test the edge cases
@@ -848,12 +848,12 @@ my $tree_to_remove_2 = Tree::Simple->new("1.7");
 $sub_tree->addChild($tree_to_remove_2);
 
 # make sure it is there
-is($sub_tree->getChild($sub_tree->getChildCount() - 1), $tree_to_remove_2, 
'... these tree should be equal');          
+is($sub_tree->getChild($sub_tree->getChildCount() - 1), $tree_to_remove_2, 
'... these tree should be equal');
 
 # remove the subtree (it will be returned)
 my $removed_tree_2 = $sub_tree->removeChildAt($sub_tree->getChildCount() - 1);
 
-# now check that the one removed it the one 
+# now check that the one removed it the one
 # we inserted origianlly
 is($removed_tree_2, $tree_to_remove_2, '... these tree should be equal');
 
@@ -866,24 +866,24 @@ my $tree_to_remove_3 = Tree::Simple->new("1.1.-1");
 $sub_tree->insertChild(0, $tree_to_remove_3);
 
 # make sure it is there
-is($sub_tree->getChild(0), $tree_to_remove_3, '... these tree should be 
equal');               
+is($sub_tree->getChild(0), $tree_to_remove_3, '... these tree should be 
equal');
 
 # remove the subtree (it will be returned)
 my $removed_tree_3 = $sub_tree->removeChildAt(0);
 
-# now check that the one removed it the one 
+# now check that the one removed it the one
 # we inserted origianlly
-is($removed_tree_3, $tree_to_remove_3, '... these tree should be equal');      
        
+is($removed_tree_3, $tree_to_remove_3, '... these tree should be equal');
 
 ## ----------------------------------------------------------------------------
 ## test traverse
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 
-# make a control set of 
+# make a control set of
 # all the nodes we have
 my @_all_node_values = qw(
-       1.0 
-               1.1 
+       1.0
+               1.1
                1.2
                1.3
                1.4
@@ -915,11 +915,11 @@ $tree->traverse(sub {
 is_deeply(\@_all_node_values, \@all_node_values, '... our nodes match our 
control nodes');
 
 # test traverse with both pre- and post- methods
-# make a control set of 
+# make a control set of
 # all the nodes we have with XML-style
 my @_all_node_values_post_traverse = qw(
-       1.0 
-               1.1 
+       1.0
+               1.1
         1.1
                1.2
         1.2
@@ -980,24 +980,24 @@ is_deeply(\@_all_node_values_post_traverse, 
\@all_node_values_post_traverse,
 
 ## ----------------------------------------------------------------------------
 ## test size
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 
 cmp_ok($tree->size(), '==', (scalar(@_all_node_values) + 1), '... our size is 
as we expect it to be');
 
 # NOTE:
-# it is (scalar(@_all_node_values) + 1) so that 
-# we account for the root node which is not in 
+# it is (scalar(@_all_node_values) + 1) so that
+# we account for the root node which is not in
 # the list.
 
 ## ----------------------------------------------------------------------------
 ## test height
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 
 cmp_ok($tree->height(), '==', 4, '... our height is as we expect it to be');
 
 ## ----------------------------------------------------------------------------
 ## test clone
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
 
 # clone the whole tree
 my $tree_clone = $tree->clone();
@@ -1021,14 +1021,14 @@ $tree_clone->traverse(sub {
        });
 
 my @all_cloned_node_values_changed;
-# collect them again   
+# collect them again
 $tree_clone->traverse(sub {
        my ($_tree) = @_;
        push @all_cloned_node_values_changed => $_tree->getNodeValue();
-       });     
+       });
 
-# make a copy of our control and cange it too  
-my @_all_node_values_changed = map { "-> $_" } @_all_node_values;      
+# make a copy of our control and cange it too
+my @_all_node_values_changed = map { "-> $_" } @_all_node_values;
 
 # now both our changed values should be correct
 ok eq_array(\@_all_node_values_changed, \@all_cloned_node_values_changed);
@@ -1041,10 +1041,10 @@ $tree->traverse(sub {
        push @all_node_values_check => $_tree->getNodeValue();
        });
 
-# this can be accomplished by checking them 
+# this can be accomplished by checking them
 # against our control again
-ok eq_array(\@_all_node_values, \@all_node_values_check);      
-       
+ok eq_array(\@_all_node_values, \@all_node_values_check);
+
 ## ----------------------------------------------------------------------------
 ## end test for Tree::Simple
-## 
----------------------------------------------------------------------------    
    
+## ----------------------------------------------------------------------------
diff --git a/xt/author/changes.t b/xt/author/changes.t
new file mode 100644
index 0000000..8a16c67
--- /dev/null
+++ b/xt/author/changes.t
@@ -0,0 +1,9 @@
+#!/usr/bin/perl
+
+use 5.006;
+use strict; use warnings;
+use Test::More;
+
+eval 'use Test::CPAN::Changes';
+plan skip_all => 'Test::CPAN::Changes required for this test' if $@;
+changes_ok();
\ No newline at end of file

-- 
Alioth's /usr/local/bin/git-commit-notice on 
/srv/git.debian.org/git/pkg-perl/packages/libtree-simple-perl.git

_______________________________________________
Pkg-perl-cvs-commits mailing list
Pkg-perl-cvs-commits@lists.alioth.debian.org
http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-perl-cvs-commits

Reply via email to