rubytree 0.7.0 → 0.8.1

data.tar.gz.sig

@@ -0,0 +1 @@
+ܥ**�]ڏ�)�5"����qƵtܣ�g��Fl]t�߉���8?��)����
����Bl"3mj(˳~�"U<_�M="�J�>�ݚ�K�1�h�Hgaw(�,���)T9�N��ⶎ�ڙ���P-q���U������)��u��T�e��>-��l�H�{�`,���Cn6�	ow�x��q�(k'g`��{p
Ɇ^u�4��&xGQ��E�DP*�.`���F?�m��m>+��W��C���U�f%u��2z\0
�

data/API-CHANGES

@@ -5,6 +5,15 @@ This file documents various API level changes that have been made to the RubyTre
 Note: API level changes are expected to reduce dramatically after the 1.x release.  In most cases, an alternative will
 be provided to ensure relatively smooth transition to the new APIs.
 
+== Release 0.8.0 Changes
+
+- Added the ability to specify an optional insertion position in the {Tree::TreeNode#add} method.  Idea and original
+  code contributed by Dirk.
+- Added a new method {Tree::TreeNode#detached_subtree_copy} to allow cloning the entire tree.  This method is also
+  aliased to {Tree::TreeNode#dup}.  Idea and original code contributed by Vincenzo Farruggia.
+- Converted all CamelCase method names to the canonical ruby_method_names (underscore separated).  The CamelCase methods
+  can still be invoked, but will throw a Deprecated warning.
+
 == Release 0.7.0 Changes
 
 - Converted all exceptions thrown on invalid method arguments to from 'RuntimeError' to 'ArgumentError'.  This impacts the

data/History.txt

@@ -1,3 +1,40 @@
+=== 0.8.1 / 2010-10-02
+
+* This is the public release of R0.8.0, with additional bug-fixes.
+  Note that R0.8.0 will not be released separately as a publicly
+  available Rubygem. All changes as listed for R0.8.0 are available in
+  this release.
+
+* The main change in R0.8.0/R0.8.1 is conversion of all CamelCase
+  method names to snake_case.  The old CamelCase method names will
+  still work (to ensure backwards compatibility), but will also
+  display a warning.
+
+* The TreeNode#add method now accepts an optional child insertion
+  point.
+
+* The subtree from the current node can now be cloned in its entirety
+  using the `TreeNode#detached_subtree_copy' method.
+
+* A major bug-fix for bug #28613 which impacted the Binarytree
+  implementation.  See
+  http://rubyforge.org/tracker/index.php?func=detail&aid=28613&group_id=1215&atid=4793
+  for details.
+
+* Minor code re-factoring driven by the code-smell checks using reek.
+
+* Inclusion of the `reek' code-smell detection tool in the Rakefile.
+
+=== 0.8.0 / 2010-05-04
+
+* Updated the 'add' method to allow the optional specification of an insertion position in the child array.
+
+* Added a new method 'detached_subtree_copy' to allow cloning the entire tree (this method is also aliased as 'dup').
+
+* Converted all CamelCase method names to the canonical ruby_method_names (underscore separated).  The CamelCase methods
+  can still be invoked, but will throw a Deprecated warning.  The support for old CamelCase methods will go away some
+  time in the future, so the user is advised to convert all current method invocations to the new names.
+
 === 0.7.0 / 2010-05-03
 
 * Added new methods to report the degree statistics of a node.

data/README

@@ -47,7 +47,7 @@ As an example, the following code-snippet implements this tree structure:
  root_node << Tree::TreeNode.new("CHILD2", "Child2 Content")
 
  # ..... Lets print the representation to stdout.  This is primarily used for debugging purposes.
- root_node.printTree
+ root_node.print_tree
 
  # ..... Lets directly access children and grandchildren of the root.  The can be "chained" for a given path to any depth.
  child1 = root_node["CHILD1"]
@@ -183,6 +183,7 @@ For generating the documentation, it is strongly suggested that the Yard[http://
 I would like to acknowledge the following contributors for helping improve RubyTree:
 
 1. Dirk Breuer (http://github.com/railsbros-dirk) for contributing the JSON conversion code.
+2. Vincenzo Farruggia for contributing the (sub)tree cloning code.
 
 == LICENSE:
 

data/Rakefile

@@ -71,10 +71,15 @@ begin
 
  Thank you for installing #{PKG_NAME}.
 
- Please note that a few APIs have been deprecated since Version 0.6.1.
+              WARNING: SIGNIFICANT API CHANGE in 0.8.0 !
+              ------------------------------------------
 
- Specifically, the 'Tree::TreeNode#depth' method is now deprecated, and
- a new nodeDepth() method has been introduced.
+ Please note that as of 0.8.0 the CamelCase method names are DEPRECATED.
+
+ The new method names follow the ruby_convention (separated by '_').
+
+ The old CamelCase methods still work (a warning will be displayed),
+ but may go away in the future.
 
  Details of the API changes are documented in the API-CHANGES file.
 
@@ -122,3 +127,21 @@ rescue LoadError
 
   END
 end
+
+begin
+  require 'reek/rake/task'
+  Reek::Rake::Task.new do |t|
+    t.verbose = false
+    t.source_files = 'lib/**/*.rb'
+  end
+rescue LoadError
+  $stderr.puts <<-END
+  ERROR!!! You need to have reek (http://github.com/kevinrutherford/reek) for detecing the code smell.
+
+  You can install the reek gem by running the following command as root (or sudo):
+
+    $ gem install reek
+
+  END
+
+end

data/TODO

@@ -1,8 +1,7 @@
 # -*- mode: org; coding: utf-8-unix; -*-
 
-
 * R0.7.0
-*** TODO Start using signed tags from R0.7.0
+*** DONE Start using signed tags from R0.7.0
 *** DONE Add a check in the Tree::TreeNode.add method to prevent addition of nil child nodes
     CLOSED: [2010-02-23 Tue 23:07]
 *** DONE Fix the edge condition for Tree::TreeNode.isOnlyChild? when the root node is the receiver.
@@ -16,9 +15,19 @@
 *** DONE Add new methods to return the degree counts of the receiver node (in-degree and out-degree)
     CLOSED: [2010-01-30 Sat 23:56]
 
+
+
 * R0.8.0
-*** TODO Convert all method names to the canonical /^[_a-z<>=\[|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/ pattern
+*** DONE Convert all method names to the canonical /^[_a-z<>=\[|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/ pattern
     See Roodi report at http://getcaliper.com/caliper/tool?tool=roodi&repo=git://github.com/evolve75/RubyTree.git
+*** DONE Integrate the subtree cloning patch submitted by Vincenzo Farrugia.
+
+
+* R0.8.1
+*** DONE Fix [[http://rubyforge.org/tracker/index.php?func%3Ddetail&aid%3D28613&group_id%3D1215&atid%3D4793][bug #28613]] which was affecting the `leftChild=' and `rightChild=' methods for binary trees.
+
+
+* R0.9.0
 *** TODO Fix the inconsistency of returning root as its first sibling, and returning a nil instead.  Ditto for last sibling.
 *** TODO fix the inconsistency of returning nil for the root, and an empty array for nodes which have no siblings.
 *** TODO We should perhaps return nil as root's root.
@@ -46,7 +55,3 @@
 *** TODO Fix the inconsistency of returning root as its last sibling, and returning a nil array for siblings of the node
 *** TODO marshal_load method probably should be a class method.  It currently clobbers self.
 *** TODO Fix the inconsistency of returning root as its first/last sibling, and returning a nil array for siblings of the node
-
-$Id$
-
-

data/lib/tree.rb

@@ -48,7 +48,7 @@
 module Tree
 
   # Rubytree Package Version
-  VERSION = '0.7.0'
+  VERSION = '0.8.1'
 
   # == TreeNode Class Description
   #
@@ -97,13 +97,14 @@ module Tree
   #
   #    # ..... Create the root node first.  Note that every node has a name and an optional content payload.
   #    root_node = Tree::TreeNode.new("ROOT", "Root Content")
+  #    root_node.print_tree
   #
   #    # ..... Now insert the child nodes.  Note that you can "chain" the child insertions for a given path to any depth.
   #    root_node << Tree::TreeNode.new("CHILD1", "Child1 Content") << Tree::TreeNode.new("GRANDCHILD1", "GrandChild1 Content")
   #    root_node << Tree::TreeNode.new("CHILD2", "Child2 Content")
   #
   #    # ..... Lets print the representation to stdout.  This is primarily used for debugging purposes.
-  #    root_node.printTree
+  #    root_node.print_tree
   #
   #    # ..... Lets directly access children and grandchildren of the root.  The can be "chained" for a given path to any depth.
   #    child1       = root_node["CHILD1"]
@@ -134,7 +135,6 @@ module Tree
     # Parent of this node.  Will be +nil+ for a root node.
     attr_reader   :parent
 
-
     # Creates a new node with a name and optional content.
     # The node name is expected to be unique within the tree.
     #
@@ -148,8 +148,8 @@ module Tree
       raise ArgumentError, "Node name HAS to be provided!" if name == nil
       @name, @content = name, content
 
-      self.setAsRoot!
-      @childrenHash = Hash.new
+      self.set_as_root!
+      @children_hash = Hash.new
       @children = []
     end
 
@@ -161,6 +161,23 @@ module Tree
       Tree::TreeNode.new(@name, @content ? @content.clone : nil)
     end
 
+    # Returns a copy of entire (sub-)tree from receiver node.
+    #
+    # @author Vincenzo Farruggia
+    # @since 0.8.0
+    #
+    # @return [Tree::TreeNode] A copy of (sub-)tree from receiver node.
+    def detached_subtree_copy
+      new_node = detached_copy
+      children { |child| new_node << child.detached_subtree_copy }
+      new_node
+    end
+
+    # Alias for {Tree::TreeNode#detached_subtree_copy}
+    #
+    # @see Tree::TreeNode#detached_subtree_copy
+    alias :dup :detached_subtree_copy
+
     # Returns string representation of the receiver node.
     # This method is primarily meant for debugging purposes.
     #
@@ -168,7 +185,7 @@ module Tree
     def to_s
       "Node Name: #{@name}" +
         " Content: " + (@content || "<Empty>") +
-        " Parent: " + (isRoot?()  ? "<None>" : @parent.name) +
+        " Parent: " + (is_root?()  ? "<None>" : @parent.name) +
         " Children: #{@children.length}" +
         " Total Nodes: #{size()}"
     end
@@ -180,16 +197,16 @@ module Tree
     #
     # @return [Array, nil] An array of ancestors of the receiver node, or +nil+ if this is a root node.
     def parentage
-      return nil if isRoot?
+      return nil if is_root?
 
-      parentageArray = []
-      prevParent = self.parent
-      while (prevParent)
-        parentageArray << prevParent
-        prevParent = prevParent.parent
+      parentage_array = []
+      prev_parent = self.parent
+      while (prev_parent)
+        parentage_array << prev_parent
+        prev_parent = prev_parent.parent
       end
 
-      parentageArray
+      parentage_array
     end
 
     # Protected method to set the parent node for the receiver node.
@@ -228,25 +245,44 @@ module Tree
     # the child is added as the last child ("right most") in the current set of
     # children of the receiver node.
     #
+    # Additionally you can specify a insert position. The new node will be inserted
+    # BEFORE that position. If you don't specify any position the node will be
+    # just appended. This feature is provided to make implementation of node
+    # movement within the tree very simple.
+    #
+    # If an insertion position is provided, it needs to be within the valid range of:
+    #
+    #    -children.size..children.size
+    #
+    # This is to prevent +nil+ nodes being created as children if a non-existant position is used.
+    #
     # @param [Tree::TreeNode] child The child node to add.
+    # @param [optional, Number] at_index The optional position where the node is to be inserted.
     #
     # @return [Tree::TreeNode] The added child node.
     #
     # @raise [RuntimeError] This exception is raised if another child node with the same
-    # name exists.
+    # name exists, or if an invalid insertion position is specified.
     # @raise [ArgumentError] This exception is raised if a +nil+ node is passed as the argument.
     #
     # @see #<<
-    def add(child)
+    def add(child, at_index = -1)
       raise ArgumentError, "Attempting to add a nil node" unless child
-      raise "Child #{child.name} already added!" if @childrenHash.has_key?(child.name)
+      raise "Child #{child.name} already added!" if @children_hash.has_key?(child.name)
 
-      @childrenHash[child.name]  = child
-      @children << child
+      if insertion_range.include?(at_index)
+        @children.insert(at_index, child)
+      else
+        raise "Attempting to insert a child at a non-existent location (#{at_index}) when only positions from #{insertion_range.min} to #{insertion_range.max} exist."
+      end
+
+      @children_hash[child.name]  = child
       child.parent = self
       return child
     end
 
+
+
     # Removes the specified child node from the receiver node.
     #
     # This method can also be used for *pruning* a sub-tree, in cases where the removed child node is
@@ -259,14 +295,14 @@ module Tree
     #
     # @return [Tree::TreeNode] The removed child node, or +nil+ if a +nil+ was passed in as argument.
     #
-    # @see #removeFromParent!
-    # @see #removeAll!
+    # @see #remove_from_parent!
+    # @see #remove_all!
     def remove!(child)
       return nil unless child
 
-      @childrenHash.delete(child.name)
+      @children_hash.delete(child.name)
       @children.delete(child)
-      child.setAsRoot!
+      child.set_as_root!
       child
     end
 
@@ -276,9 +312,9 @@ module Tree
     #
     # @return [Tree:TreeNode] +self+ (the removed receiver node) if the operation is successful, +nil+ otherwise.
     #
-    # @see #removeAll!
-    def removeFromParent!
-      @parent.remove!(self) unless isRoot?
+    # @see #remove_all!
+    def remove_from_parent!
+      @parent.remove!(self) unless is_root?
     end
 
     # Removes all children from the receiver node.  If an indepedent reference exists to the child
@@ -287,12 +323,11 @@ module Tree
     # @return [Tree::TreeNode] The receiver node (+self+)
     #
     # @see #remove!
-    # @see #removeFromParent!
-    def removeAll!
-      for child in @children
-        child.setAsRoot!
-      end
-      @childrenHash.clear
+    # @see #remove_from_parent!
+    def remove_all!
+      @children.each { |child| child.set_as_root! }
+
+      @children_hash.clear
       @children.clear
       self
     end
@@ -300,14 +335,14 @@ module Tree
     # Returns +true+ if the receiver node has content.
     #
     # @return [Boolean] +true+ if the node has content.
-    def hasContent?
+    def has_content?
       @content != nil
     end
 
     # Protected method which sets the receiver node as a root node.
     #
     # @return +nil+.
-    def setAsRoot!              # :nodoc:
+    def set_as_root!              # :nodoc:
       @parent = nil
     end
 
@@ -315,7 +350,7 @@ module Tree
     # orphaned children will also be reported as root nodes.
     #
     # @return [Boolean] +true+ if this is a root node.
-    def isRoot?
+    def is_root?
       @parent == nil
     end
 
@@ -323,8 +358,8 @@ module Tree
     #
     # @return [Boolean] +true+ if child nodes exist.
     #
-    # @see #isLeaf?
-    def hasChildren?
+    # @see #is_leaf?
+    def has_children?
       @children.length != 0
     end
 
@@ -333,9 +368,9 @@ module Tree
     #
     # @return [Boolean] +true+ if this is a leaf node.
     #
-    # @see #hasChildren?
-    def isLeaf?
-      !hasChildren?
+    # @see #has_children?
+    def is_leaf?
+      !has_children?
     end
 
     # Returns an array of all the immediate children of the receiver node.  The child nodes are ordered
@@ -360,7 +395,7 @@ module Tree
     # Will return +nil+ if no children are present.
     #
     # @return [Tree::TreeNode] The first child, or +nil+ if none is present.
-    def firstChild
+    def first_child
       children.first
     end
 
@@ -369,7 +404,7 @@ module Tree
     # Will return +nil+ if no children are present.
     #
     # @return [Tree::TreeNode] The last child, or +nil+ if none is present.
-    def lastChild
+    def last_child
       children.last
     end
 
@@ -432,7 +467,7 @@ module Tree
     # @see #each
     # @see #breadth_each
     def each_leaf &block
-      self.each { |node| yield(node) if node.isLeaf? }
+      self.each { |node| yield(node) if node.is_leaf? }
     end
 
     # Returns the requested node from the set of immediate children.
@@ -458,7 +493,7 @@ module Tree
       if name_or_index.kind_of?(Integer)
         @children[name_or_index]
       else
-        @childrenHash[name_or_index]
+        @children_hash[name_or_index]
       end
     end
 
@@ -489,21 +524,20 @@ module Tree
     # Pretty prints the (sub)tree rooted at the receiver node.
     #
     # @param [Number] level The indentation level (4 spaces) to start with.
-    def printTree(level = 0)
-
-      if isRoot?
+    def print_tree(level = 0)
+      if is_root?
         print "*"
       else
-        print "|" unless parent.isLastSibling?
+        print "|" unless parent.is_last_sibling?
         print(' ' * (level - 1) * 4)
-        print(isLastSibling? ? "+" : "|")
+        print(is_last_sibling? ? "+" : "|")
         print "---"
-        print(hasChildren? ? "+" : ">")
+        print(has_children? ? "+" : ">")
       end
 
       puts " #{name}"
 
-      children { |child| child.printTree(level + 1)}
+      children { |child| child.print_tree(level + 1)}
     end
 
     # Returns root node for the (sub)tree to which the receiver node belongs.
@@ -515,7 +549,7 @@ module Tree
     # @return [Tree::TreeNode] Root of the (sub)tree.
     def root
       root = self
-      root = root.parent while !root.isRoot?
+      root = root.parent while !root.is_root?
       root
     end
 
@@ -530,20 +564,20 @@ module Tree
     #
     # @return [Tree::TreeNode] The first sibling node.
     #
-    # @see #isFirstSibling?
-    # @see #lastSibling
-    def firstSibling
-      isRoot? ? self : parent.children.first
+    # @see #is_first_sibling?
+    # @see #last_sibling
+    def first_sibling
+      is_root? ? self : parent.children.first
     end
 
     # Returns +true+ if the receiver node is the first sibling at its level.
     #
     # @return [Boolean] +true+ if this is the first sibling.
     #
-    # @see #isLastSibling?
-    # @see #firstSibling
-    def isFirstSibling?
-      firstSibling == self
+    # @see #is_last_sibling?
+    # @see #first_sibling
+    def is_first_sibling?
+      first_sibling == self
     end
 
     # Returns the last sibling of the receiver node.  If this is the root node, then returns
@@ -557,20 +591,20 @@ module Tree
     #
     # @return [Tree::TreeNode] The last sibling node.
     #
-    # @see #isLastSibling?
-    # @see #firstSibling
-    def lastSibling
-      isRoot? ? self : parent.children.last
+    # @see #is_last_sibling?
+    # @see #first_sibling
+    def last_sibling
+      is_root? ? self : parent.children.last
     end
 
     # Returns +true+ if the receiver node is the last sibling at its level.
     #
     # @return [Boolean] +true+ if this is the last sibling.
     #
-    # @see #isFirstSibling?
-    # @see #lastSibling
-    def isLastSibling?
-      lastSibling == self
+    # @see #is_first_sibling?
+    # @see #last_sibling
+    def is_last_sibling?
+      last_sibling == self
     end
 
     # Returns an array of siblings for the receiver node.  The receiver node is excluded.
@@ -588,15 +622,13 @@ module Tree
     #
     # @return [Array<Tree::TreeNode>] Array of siblings of this node.
     #
-    # @see #firstSibling
-    # @see #lastSibling
+    # @see #first_sibling
+    # @see #last_sibling
     def siblings
-      return nil if isRoot?
+      return nil if is_root?
 
       if block_given?
-        for sibling in parent.children
-          yield sibling if sibling != self
-        end
+        parent.children.each { |sibling| yield sibling if sibling != self }
       else
         siblings = []
         parent.children {|my_sibling| siblings << my_sibling if my_sibling != self}
@@ -611,8 +643,8 @@ module Tree
     # @return [Boolean] +true+ if this is the only child of its parent.
     #
     # @see #siblings
-    def isOnlyChild?
-      isRoot? ? true : parent.children.size == 1
+    def is_only_child?
+      is_root? ? true : parent.children.size == 1
     end
 
     # Returns the next sibling for the receiver node.
@@ -622,13 +654,13 @@ module Tree
     #
     # @return [Tree::treeNode] the next sibling node, if present.
     #
-    # @see #previousSibling
+    # @see #previous_sibling
     # @see #siblings
-    def nextSibling
-      return nil if isRoot?
-      if myidx = parent.children.index(self)
-        parent.children.at(myidx + 1)
-      end
+    def next_sibling
+      return nil if is_root?
+
+      myidx = parent.children.index(self)
+      parent.children.at(myidx + 1) if myidx
     end
 
     # Returns the previous sibling of the receiver node.
@@ -638,13 +670,13 @@ module Tree
     #
     # @return [Tree::treeNode] the previous sibling node, if present.
     #
-    # @see #nextSibling
+    # @see #next_sibling
     # @see #siblings
-    def previousSibling
-      return nil if isRoot?
-      if myidx = parent.children.index(self)
-        parent.children.at(myidx - 1) if myidx > 0
-      end
+    def previous_sibling
+      return nil if is_root?
+
+      myidx = parent.children.index(self)
+      parent.children.at(myidx - 1) if myidx && myidx > 0
     end
 
     # Provides a comparision operation for the nodes.
@@ -663,18 +695,18 @@ module Tree
     #
     # The nodes become immutable after this operation.  In effect, the entire tree's
     # structure and contents become _read-only_ and cannot be changed.
-    def freezeTree!
+    def freeze_tree!
       each {|node| node.freeze}
     end
 
     # Returns a marshal-dump represention of the (sub)tree rooted at the receiver node.
     def marshal_dump
-      self.collect { |node| node.createDumpRep }
+      self.collect { |node| node.create_dump_rep }
     end
 
     # Creates a dump representation of the reciever node and returns the same as a hash.
-    def createDumpRep           # :nodoc:
-      { :name => @name, :parent => (isRoot? ? nil : @parent.name),  :content => Marshal.dump(@content)}
+    def create_dump_rep           # :nodoc:
+      { :name => @name, :parent => (is_root? ? nil : @parent.name),  :content => Marshal.dump(@content)}
     end
 
     # Loads a marshalled dump of a tree and returns the root node of the
@@ -686,7 +718,7 @@ module Tree
     #
     def marshal_load(dumped_tree_array)
       nodes = { }
-      for node_hash in dumped_tree_array do
+      dumped_tree_array.each do |node_hash|
         name        = node_hash[:name]
         parent_name = node_hash[:parent]
         content     = Marshal.load(node_hash[:content])
@@ -723,19 +755,23 @@ module Tree
           JSON.create_id => self.class.name
         }
 
-        if hasChildren?
+        if has_children?
           json_hash["children"] = children
         end
 
         return json_hash.to_json
 
-      rescue LoadError => e
+      rescue LoadError
         warn "The JSON gem couldn't be loaded. Due to this we cannot serialize the tree to a JSON representation"
       end
     end
 
-    # Creates a Tree::TreeNode object instance from a given JSON Hash representation.  This requires the JSON gem to be
-    # available, or else the operation fails with a warning message.
+    # Helper method to create a Tree::TreeNode instance from the JSON hash representation.  Note that this method should
+    # *NOT* be called directly.  Instead, to convert the JSON hash back to a tree, do:
+    #
+    # tree = JSON.parse (the_json_hash)
+    #
+    # This operation requires the JSON gem to be available, or else the operation fails with a warning message.
     #
     # @author Dirk Breuer (http://github.com/railsbros-dirk)
     # @since 0.7.0
@@ -770,24 +806,27 @@ module Tree
     # - The height of a leaf node is zero.
     #
     # @return [Number] Height of the node.
-    def nodeHeight
-      return 0 if isLeaf?
-      1 + @children.collect { |child| child.nodeHeight }.max
+    def node_height
+      return 0 if is_leaf?
+      1 + @children.collect { |child| child.node_height }.max
     end
 
     # Returns depth of the receiver node in its tree.  Depth of a node is defined as:
     #
     # Depth:: Length of the node's path to its root.  Depth of a root node is zero.
     #
+    # *Note* that the deprecated method Tree::TreeNode#depth was incorrectly computing this value.
+    # Please replace all calls to the old method with Tree::TreeNode#node_depth instead.
+    #
     # 'level' is an alias for this method.
     #
     # @return [Number] Depth of this node.
-    def nodeDepth
-      return 0 if isRoot?
-      1 + parent.nodeDepth
+    def node_depth
+      return 0 if is_root?
+      1 + parent.node_depth
     end
 
-    alias level nodeDepth       # Aliased level() method to the nodeDepth().
+    alias level node_depth       # Aliased level() method to the node_depth().
 
     # Returns depth of the tree from the receiver node. A single leaf node has a depth of 1.
     #
@@ -796,26 +835,46 @@ module Tree
     #
     # _height_ + 1 of the node, *NOT* the _depth_.
     #
-    # For correct and conventional behavior, please use {Tree::TreeNode#nodeDepth} and
-    # {Tree::TreeNode#nodeHeight} methods instead.
+    # For correct and conventional behavior, please use {Tree::TreeNode#node_depth} and
+    # {Tree::TreeNode#node_height} methods instead.
     #
     # @return [Number] depth of the node.
-    # @deprecated This method returns an incorrect value.  Use the 'nodeDepth' method instead.
+    # @deprecated This method returns an incorrect value.  Use the 'node_depth' method instead.
     #
-    # @see #nodeDepth
+    # @see #node_depth
     def depth
       begin
         require 'structured_warnings'   # To enable a nice way of deprecating of the depth method.
-        warn DeprecatedMethodWarning, 'This method is deprecated.  Please use nodeDepth() or nodeHeight() instead (bug # 22535)'
+        warn DeprecatedMethodWarning, 'This method is deprecated.  Please use node_depth() or node_height() instead (bug # 22535)'
       rescue LoadError
         # Oh well. Will use the standard Kernel#warn.  Behavior will be identical.
-        warn 'Tree::TreeNode#depth() method is deprecated.  Please use nodeDepth() or nodeHeight() instead (bug # 22535)'
+        warn 'Tree::TreeNode#depth() method is deprecated.  Please use node_depth() or node_height() instead (bug # 22535)'
       end
 
-      return 1 if isLeaf?
+      return 1 if is_leaf?
       1 + @children.collect { |child| child.depth }.max
     end
 
+    # Allow the deprecated CamelCase method names.  Display a warning.
+    def method_missing(meth, *args, &blk)
+      if self.respond_to?(new_method_name = underscore(meth))
+        begin
+          require 'structured_warnings'   # To enable a nice way of deprecating of the invoked CamelCase method.
+          warn DeprecatedMethodWarning, "The camelCased methods are deprecated. Please use #{new_method_name} instead of #{meth}"
+
+        rescue LoadError
+          # Oh well. Will use the standard Kernel#warn.  Behavior will be identical.
+          warn "Tree::TreeNode##{meth}() method is deprecated. Please use #{new_method_name} instead."
+
+        ensure                  # Invoke the method now.
+          return send(new_method_name, *args, &blk)
+        end
+
+      else
+        super
+      end
+    end
+
     # Returns breadth of the tree at the receiver node's level.
     # A single node without siblings has a breadth of 1.
     #
@@ -825,7 +884,7 @@ module Tree
     #
     # @return [Number] breadth of the node's level.
     def breadth
-      isRoot? ? 1 : parent.children.size
+      is_root? ? 1 : parent.children.size
     end
 
     # Returns the incoming edge-count of the receiver node.
@@ -838,7 +897,7 @@ module Tree
     #
     # @return [Number] The in-degree of this node.
     def in_degree
-      isRoot? ? 0 : 1
+      is_root? ? 0 : 1
     end
 
     # Returns the outgoing edge-count of the receiver node.
@@ -848,10 +907,33 @@ module Tree
     #
     # @return [Number] The out-degree of this node.
     def out_degree
-      isLeaf? ? 0 : children.size
+      is_leaf? ? 0 : children.size
     end
 
-    protected :parent=, :setAsRoot!, :createDumpRep
+    protected :parent=, :set_as_root!, :create_dump_rep
+
+    private
+
+    # Convert a CamelCasedWord to a underscore separated camel_cased_word.
+    #
+    # Just copied from ActiveSupport::Inflector because it is only needed
+    # aliasing deprecated methods
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+
+    # Return a range of valid insertion positions.  Used in the #add method.
+    def insertion_range
+      max = @children.size
+      min = -(max+1)
+      min..max
+    end
 
   end
 end