rubytree 0.9.7 → 2.0.0

data/lib/tree.rb

@@ -9,9 +9,7 @@
 # Author:: Anupam Sengupta (anupamsg@gmail.com)
 #
 
-# Copyright (c) 2006-2015 Anupam Sengupta
-#
-# All rights reserved.
+# Copyright (c) 2006-2022 Anupam Sengupta. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are met:
@@ -38,6 +36,7 @@
 # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
+# frozen_string_literal: true
 
 require 'tree/tree_deps'
 
@@ -47,7 +46,6 @@ require 'tree/tree_deps'
 # This module also acts as the namespace for all classes in the *RubyTree*
 # package.
 module Tree
-
   # == TreeNode Class Description
   #
   # This class models the nodes for an *N-ary* tree data structure. The
@@ -83,12 +81,12 @@ module Tree
   # {include:file:examples/example_basic.rb}
   #
   # @author Anupam Sengupta
+  # noinspection RubyTooManyMethodsInspection
   class TreeNode
     include Enumerable
     include Comparable
     include Tree::Utils::TreeMetricsHandler
     include Tree::Utils::TreePathHandler
-    include Tree::Utils::CamelCaseMethodHandler
     include Tree::Utils::JSONConverter
     include Tree::Utils::TreeMergeHandler
     include Tree::Utils::HashConverter
@@ -108,11 +106,11 @@ module Tree
     # +content+ attribute for any non-unique node requirements.
     #
     # If you want to change the name, you probably want to call +rename+
-    # instead.
+    # instead. Note that +name=+ is a protected method.
     #
     # @see content
     # @see rename
-    attr_reader   :name
+    attr_accessor :name
 
     # @!attribute [rw] content
     # Content of this node.  Can be +nil+.  Note that there is no
@@ -132,38 +130,44 @@ module Tree
     # @return [Tree::TreeNode] Root of the (sub)tree.
     def root
       root = self
-      root = root.parent while !root.is_root?
+      root = root.parent until root.root?
       root
     end
 
-    # @!attribute [r] is_root?
+    # @!attribute [r] root?
     # Returns +true+ if this is a root node.  Note that
     # orphaned children will also be reported as root nodes.
     #
     # @return [Boolean] +true+ if this is a root node.
-    def is_root?
+    def root?
       @parent.nil?
     end
 
-    # @!attribute [r] has_content?
+    alias is_root? root? # @todo: Aliased for eventual replacement
+
+    # @!attribute [r] content?
     # +true+ if this node has content.
     #
     # @return [Boolean] +true+ if the node has content.
-    def has_content?
+    def content?
       @content != nil
     end
 
-    # @!attribute [r] is_leaf?
+    alias has_content? content? # @todo: Aliased for eventual replacement
+
+    # @!attribute [r] leaf?
     # +true+ if this node is a _leaf_ - i.e., one without
     # any children.
     #
     # @return [Boolean] +true+ if this is a leaf node.
     #
-    # @see #has_children?
-    def is_leaf?
-      !has_children?
+    # @see #children?
+    def leaf?
+      !children?
     end
 
+    alias is_leaf? leaf? # @todo: Aliased for eventual replacement
+
     # @!attribute [r] parentage
     # An array of ancestors of this node in reversed order
     # (the first element is the immediate parent of this node).
@@ -173,27 +177,29 @@ module Tree
     # @return [Array<Tree::TreeNode>] An array of ancestors of this node
     # @return [nil] if this is a root node.
     def parentage
-      return nil if is_root?
+      return nil if root?
 
       parentage_array = []
-      prev_parent = self.parent
-      while (prev_parent)
+      prev_parent = parent
+      while prev_parent
         parentage_array << prev_parent
         prev_parent = prev_parent.parent
       end
       parentage_array
     end
 
-    # @!attribute [r] has_children?
+    # @!attribute [r] children?
     # +true+ if the this node has any child node.
     #
     # @return [Boolean] +true+ if child nodes exist.
     #
-    # @see #is_leaf?
-    def has_children?
-      @children.length != 0
+    # @see #leaf?
+    def children?
+      !@children.empty?
     end
 
+    alias has_children? children? # @todo: Aliased for eventual replacement
+
     # @!group Node Creation
 
     # Creates a new node with a name and optional content.
@@ -215,18 +221,14 @@ module Tree
     #
     # @see #[]
     def initialize(name, content = nil)
-      raise ArgumentError, "Node name HAS to be provided!" if name == nil
-      @name, @content = name, content
-
-      if name.kind_of?(Integer)
-        warn StandardWarning,
-             "Using integer as node name."\
-             " Semantics of TreeNode[] may not be what you expect!"\
-             " #{name} #{content}"
-      end
+      raise ArgumentError, 'Node name HAS to be provided!' if name.nil?
+
+      name = name.to_s if name.is_a?(Integer)
+      @name = name
+      @content = content
 
-      self.set_as_root!
-      @children_hash = Hash.new
+      set_as_root!
+      @children_hash = {}
       @children = []
     end
 
@@ -235,7 +237,13 @@ module Tree
     #
     # @return [Tree::TreeNode] A copy of this node.
     def detached_copy
-      self.class.new(@name, @content ? @content.clone : nil)
+      cloned_content =
+        begin
+          @content&.clone
+        rescue TypeError
+          @content
+        end
+      self.class.new(@name, cloned_content)
     end
 
     # Returns a copy of entire (sub-)tree from this node.
@@ -253,50 +261,52 @@ module Tree
     # Alias for {Tree::TreeNode#detached_subtree_copy}
     #
     # @see Tree::TreeNode#detached_subtree_copy
-    alias :dup :detached_subtree_copy
+    alias dup detached_subtree_copy
 
     # Returns a {marshal-dump}[http://ruby-doc.org/core-1.8.7/Marshal.html]
-    # represention of the (sub)tree rooted at this node.
+    # representation of the (sub)tree rooted at this node.
     #
     def marshal_dump
-      self.collect { |node| node.create_dump_rep }
+      collect(&:create_dump_rep)
     end
 
     # Creates a dump representation of this node and returns the same as
     # a hash.
-    def create_dump_rep           # :nodoc:
-      { :name => @name,
-        :parent => (is_root? ? nil : @parent.name),
-        :content => Marshal.dump(@content)
-      }
+    def create_dump_rep # :nodoc:
+      { name: @name,
+        parent: (root? ? nil : @parent.name),
+        content: Marshal.dump(@content) }
     end
 
     protected :create_dump_rep
 
-    # Loads a marshalled dump of a tree and returns the root node of the
+    # Loads a marshaled dump of a tree and returns the root node of the
     # reconstructed tree. See the
     # {Marshal}[http://ruby-doc.org/core-1.8.7/Marshal.html] class for
     # additional details.
     #
+    # NOTE: This is a potentially *unsafe* method with similar concerns as with
+    # the Marshal#load method, and should *not* be used with untrusted user
+    # provided data.
     #
     # @todo This method probably should be a class method. It currently clobbers
     #       self and makes itself the root.
     #
     def marshal_load(dumped_tree_array)
-      nodes = { }
+      nodes = {}
       dumped_tree_array.each do |node_hash|
         name        = node_hash[:name]
         parent_name = node_hash[:parent]
         content     = Marshal.load(node_hash[:content])
 
-        if parent_name then
-          nodes[name] = current_node = Tree::TreeNode.new(name, content)
+        if parent_name
+          nodes[name] = current_node = self.class.new(name, content)
           nodes[parent_name].add current_node
         else
           # This is the root node, hence initialize self.
           initialize(name, content)
 
-          nodes[name] = self    # Add self to the list of nodes
+          nodes[name] = self # Add self to the list of nodes
         end
       end
     end
@@ -308,11 +318,9 @@ module Tree
     #
     # @return [String] A string representation of the node.
     def to_s
-      "Node Name: #{@name}" +
-        " Content: " + (@content.to_s || "<Empty>") +
-        " Parent: " + (is_root?()  ? "<None>" : @parent.name.to_s) +
-        " Children: #{@children.length}" +
-        " Total Nodes: #{size()}"
+      "Node Name: #{@name} Content: #{@content.to_s || '<Empty>'} " \
+        "Parent: #{root? ? '<None>' : @parent.name.to_s} "       \
+        "Children: #{@children.length} Total Nodes: #{size}"
     end
 
     # @!group Structure Modification
@@ -354,7 +362,7 @@ module Tree
     #
     #    -children.size..children.size
     #
-    # This is to prevent +nil+ nodes being created as children if a non-existant
+    # This is to prevent +nil+ nodes being created as children if a non-existent
     # position is used.
     #
     # If the new node being added has an existing parent node, then it will be
@@ -380,38 +388,37 @@ module Tree
     # @see #<<
     def add(child, at_index = -1)
       # Only handles the immediate child scenario
-      raise ArgumentError,
-            "Attempting to add a nil node" unless child
-      raise ArgumentError,
-            "Attempting add node to itself" if self.equal?(child)
-      raise ArgumentError,
-            "Attempting add root as a child" if child.equal?(root)
-
-      # Lazy mans unique test, won't test if children of child are unique in
+      raise ArgumentError, 'Attempting to add a nil node' unless child
+
+      raise ArgumentError, 'Attempting add node to itself' if equal?(child)
+
+      raise ArgumentError, 'Attempting add root as a child' if child.equal?(root)
+
+      # Lazy man's unique test, won't test if children of child are unique in
       # this tree too.
       raise "Child #{child.name} already added!"\
             if @children_hash.include?(child.name)
 
-      child.parent.remove! child if child.parent # Detach from the old parent
+      child.parent&.remove! child # Detach from the old parent
 
       if insertion_range.include?(at_index)
         @children.insert(at_index, child)
       else
-        raise "Attempting to insert a child at a non-existent location"\
+        raise 'Attempting to insert a child at a non-existent location'\
               " (#{at_index}) "\
-              "when only positions from "\
+              'when only positions from '\
               "#{insertion_range.min} to #{insertion_range.max} exist."
       end
 
-      @children_hash[child.name]  = child
+      @children_hash[child.name] = child
       child.parent = self
-      return child
+      child
     end
 
     # Return a range of valid insertion positions.  Used in the #add method.
     def insertion_range
       max = @children.size
-      min = -(max+1)
+      min = -(max + 1)
       min..max
     end
 
@@ -426,8 +433,8 @@ module Tree
     def rename(new_name)
       old_name = @name
 
-      if is_root?
-        self.name=(new_name)
+      if root?
+        self.name = new_name
       else
         @parent.rename_child old_name, new_name
       end
@@ -444,20 +451,10 @@ module Tree
     #   pass a String (Integer names may cause *surprises*)
     def rename_child(old_name, new_name)
       raise ArgumentError, "Invalid child name specified: #{old_name}"\
-            unless @children_hash.has_key?(old_name)
+            unless @children_hash.key?(old_name)
 
       @children_hash[new_name] = @children_hash.delete(old_name)
-      @children_hash[new_name].name=(new_name)
-    end
-
-    # Protected method to set the name of this node.
-    # This method should *NOT* be invoked by client code.
-    #
-    # @param [Object] new_name The node Name to set.
-    #
-    # @return [Object] The new name.
-    def name=(new_name)
-      @name = new_name
+      @children_hash[new_name].name = new_name
     end
 
     # Replaces the specified child node with another child node on this node.
@@ -472,7 +469,7 @@ module Tree
       old_child = remove! old_child
       add new_child, child_index
 
-      return old_child
+      old_child
     end
 
     # Replaces the node with another node
@@ -513,7 +510,7 @@ module Tree
     # @param [Tree::TreeNode] parent The parent node.
     #
     # @return [Tree::TreeNode] The parent node.
-    def parent=(parent)         # :nodoc:
+    def parent=(parent) # :nodoc:
       @parent = parent
       @node_depth = nil
     end
@@ -530,7 +527,7 @@ module Tree
     #
     # @see #remove_all!
     def remove_from_parent!
-      @parent.remove!(self) unless is_root?
+      @parent.remove!(self) unless root?
     end
 
     # Removes all children from this node. If an independent reference exists to
@@ -542,7 +539,7 @@ module Tree
     # @see #remove!
     # @see #remove_from_parent!
     def remove_all!
-      @children.each { |child| child.set_as_root! }
+      @children.each(&:remove_all!)
 
       @children_hash.clear
       @children.clear
@@ -552,7 +549,7 @@ module Tree
     # Protected method which sets this node as a root node.
     #
     # @return +nil+.
-    def set_as_root!              # :nodoc:
+    def set_as_root! # :nodoc:
       self.parent = nil
     end
 
@@ -563,7 +560,7 @@ 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 freeze_tree!
-      each {|node| node.freeze}
+      each(&:freeze)
     end
 
     # @!endgroup
@@ -574,46 +571,31 @@ module Tree
     #
     # - If the +name+ argument is an _Integer_, then the in-sequence
     #   array of children is accessed using the argument as the
-    #   *index* (zero-based).  However, if the second _optional_
-    #   +num_as_name+ argument is +true+, then the +name+ is used
-    #   literally as a name, and *NOT* as an *index*
+    #   *index* (zero-based).
     #
     # - If the +name+ argument is *NOT* an _Integer_, then it is taken to
     #   be the *name* of the child node to be returned.
     #
-    # If a non-+Integer+ +name+ is passed, and the +num_as_name+
-    # parameter is also +true+, then a warning is thrown (as this is a
-    # redundant use of the +num_as_name+ flag.)
+    # - To use an _Integer_ as the name, convert it to a _String_ first using
+    #   +<integer>.to_s+.
     #
     # @param [String|Number] name_or_index Name of the child, or its
     #   positional index in the array of child nodes.
     #
-    # @param [Boolean] num_as_name Whether to treat the +Integer+
-    #   +name+ argument as an actual name, and *NOT* as an _index_ to
-    #   the children array.
-    #
     # @return [Tree::TreeNode] the requested child node.  If the index
     #   in not in range, or the name is not present, then a +nil+
     #   is returned.
     #
-    # @note The use of +Integer+ names is allowed by using the optional
-    #       +num_as_name+ flag.
-    #
     # @raise [ArgumentError] Raised if the +name_or_index+ argument is +nil+.
     #
     # @see #add
     # @see #initialize
-    def [](name_or_index, num_as_name=false)
-      raise ArgumentError,
-            "Name_or_index needs to be provided!" if name_or_index == nil
+    def [](name_or_index)
+      raise ArgumentError, 'Name_or_index needs to be provided!' if name_or_index.nil?
 
-      if name_or_index.kind_of?(Integer) and not num_as_name
+      if name_or_index.is_a?(Integer)
         @children[name_or_index]
       else
-        if num_as_name and not name_or_index.kind_of?(Integer)
-          warn StandardWarning,
-             "Redundant use of the `num_as_name` flag for non-integer node name"
-        end
         @children_hash[name_or_index]
       end
     end
@@ -631,22 +613,22 @@ module Tree
     #
     # @return [Tree::TreeNode] this node, if a block if given
     # @return [Enumerator] an enumerator on this tree, if a block is *not* given
-    def each(&block)             # :yields: node
-
-     return self.to_enum unless block_given?
+    # noinspection RubyUnusedLocalVariable
+    def each # :yields: node
+      return to_enum unless block_given?
 
-      node_stack = [self]   # Start with this node
+      node_stack = [self] # Start with this node
 
       until node_stack.empty?
-        current = node_stack.shift    # Pop the top-most node
-        if current                    # Might be 'nil' (esp. for binary trees)
-          yield current               # and process it
-          # Stack children of the current node at top of the stack
-          node_stack = current.children.concat(node_stack)
-        end
+        current = node_stack.shift # Pop the top-most node
+        next unless current # Might be 'nil' (esp. for binary trees)
+
+        yield current # and process it
+        # Stack children of the current node at top of the stack
+        node_stack = current.children.concat(node_stack)
       end
 
-      return self if block_given?
+      self if block_given?
     end
 
     # Traverses the (sub)tree rooted at this node in pre-ordered sequence.
@@ -659,7 +641,7 @@ module Tree
     #
     # @return [Tree::TreeNode] this node, if a block if given
     # @return [Enumerator] an enumerator on this tree, if a block is *not* given
-    def preordered_each(&block)  # :yields: node
+    def preordered_each(&block) # :yields: node
       each(&block)
     end
 
@@ -671,30 +653,31 @@ module Tree
     # @see #breadth_each
     # @return [Tree::TreeNode] this node, if a block if given
     # @return [Enumerator] an enumerator on this tree, if a block is *not* given
-    def postordered_each(&block)
-      return self.to_enum(:postordered_each) unless block_given?
+    # noinspection RubyUnusedLocalVariable
+    def postordered_each
+      return to_enum(:postordered_each) unless block_given?
 
       # Using a marked node in order to skip adding the children of nodes that
       # have already been visited. This allows the stack depth to be controlled,
       # and also allows stateful backtracking.
-      markednode = Struct.new(:node, :visited)
-      node_stack = [markednode.new(self, false)] # Start with self
+      marked_node = Struct.new(:node, :visited)
+      node_stack = [marked_node.new(self, false)] # Start with self
 
       until node_stack.empty?
         peek_node = node_stack[0]
-        if peek_node.node.has_children? and not peek_node.visited
+        if peek_node.node.children? && !peek_node.visited
           peek_node.visited = true
           # Add the children to the stack. Use the marking structure.
           marked_children =
-            peek_node.node.children.map {|node| markednode.new(node, false)}
+            peek_node.node.children.map { |node| marked_node.new(node, false) }
           node_stack = marked_children.concat(node_stack)
           next
         else
-          yield node_stack.shift.node           # Pop and yield the current node
+          yield node_stack.shift.node # Pop and yield the current node
         end
       end
 
-      return self if block_given?
+      self if block_given?
     end
 
     # Performs breadth-first traversal of the (sub)tree rooted at this node. The
@@ -708,10 +691,11 @@ module Tree
     #
     # @return [Tree::TreeNode] this node, if a block if given
     # @return [Enumerator] an enumerator on this tree, if a block is *not* given
-    def breadth_each(&block)
-      return self.to_enum(:breadth_each) unless block_given?
+    # noinspection RubyUnusedLocalVariable
+    def breadth_each
+      return to_enum(:breadth_each) unless block_given?
 
-      node_queue = [self]       # Create a queue with self as the initial entry
+      node_queue = [self] # Create a queue with self as the initial entry
 
       # Use a queue to do breadth traversal
       until node_queue.empty?
@@ -721,7 +705,7 @@ module Tree
         node_to_traverse.children { |child| node_queue.push child }
       end
 
-      return self if block_given?
+      self if block_given?
     end
 
     # An array of all the immediate children of this node. The child
@@ -736,12 +720,12 @@ module Tree
     #
     # @return [Array<Tree::TreeNode>] An array of the child nodes, if no block
     #                                 is given.
-    def children
+    def children(&block)
       if block_given?
-        @children.each {|child| yield child}
-        return self
+        @children.each(&block)
+        self
       else
-        return @children.clone
+        @children.clone
       end
     end
 
@@ -758,12 +742,35 @@ module Tree
     #
     # @return [Tree::TreeNode] this node, if a block if given
     # @return [Array<Tree::TreeNode>] An array of the leaf nodes
-    def each_leaf &block
+    # noinspection RubyUnusedLocalVariable
+    def each_leaf
+      if block_given?
+        each { |node| yield(node) if node.leaf? }
+        self
+      else
+        self.select(&:leaf?)
+      end
+    end
+
+    # Yields every level of the (sub)tree rooted at this node to the
+    # specified block.
+    #
+    # Will yield this node as well since it is considered the first level.
+    #
+    # @yieldparam level [Array<Tree::TreeNode>] All nodes in the level
+    #
+    # @return [Tree::TreeNode] this node, if a block if given
+    # @return [Enumerator] an enumerator on this tree, if a block is *not* given
+    def each_level
       if block_given?
-        self.each { |node| yield(node) if node.is_leaf? }
-        return self
+        level = [self]
+        until level.empty?
+          yield level
+          level = level.map(&:children).flatten
+        end
+        self
       else
-        self.select { |node| node.is_leaf?}
+        each
       end
     end
 
@@ -776,7 +783,7 @@ module Tree
     #
     # @return [Tree::TreeNode] The first child, or +nil+ if none is present.
     def first_child
-      children.first
+      @children.first
     end
 
     # Last child of this node.
@@ -784,7 +791,7 @@ module Tree
     #
     # @return [Tree::TreeNode] The last child, or +nil+ if none is present.
     def last_child
-      children.last
+      @children.last
     end
 
     # @!group Navigating the Sibling Nodes
@@ -799,22 +806,24 @@ module Tree
     #
     # @return [Tree::TreeNode] The first sibling node.
     #
-    # @see #is_first_sibling?
+    # @see #first_sibling?
     # @see #last_sibling
     def first_sibling
-      is_root? ? self : parent.children.first
+      root? ? self : parent.children.first
     end
 
     # Returns +true+ if this node is the first sibling at its level.
     #
     # @return [Boolean] +true+ if this is the first sibling.
     #
-    # @see #is_last_sibling?
+    # @see #last_sibling?
     # @see #first_sibling
-    def is_first_sibling?
+    def first_sibling?
       first_sibling == self
     end
 
+    alias is_first_sibling? first_sibling? # @todo: Aliased for eventual replacement
+
     # Last sibling of this node.  If this is the root node, then returns
     # itself.
     #
@@ -825,22 +834,24 @@ module Tree
     #
     # @return [Tree::TreeNode] The last sibling node.
     #
-    # @see #is_last_sibling?
+    # @see #last_sibling?
     # @see #first_sibling
     def last_sibling
-      is_root? ? self : parent.children.last
+      root? ? self : parent.children.last
     end
 
     # Returns +true+ if this node is the last sibling at its level.
     #
     # @return [Boolean] +true+ if this is the last sibling.
     #
-    # @see #is_first_sibling?
+    # @see #first_sibling?
     # @see #last_sibling
-    def is_last_sibling?
+    def last_sibling?
       last_sibling == self
     end
 
+    alias is_last_sibling? last_sibling? # @todo: Aliased for eventual replacement
+
     # An array of siblings for this node. This node is excluded.
     #
     # If a block is provided, yields each of the sibling nodes to the block.
@@ -858,12 +869,14 @@ module Tree
     def siblings
       if block_given?
         parent.children.each { |sibling| yield sibling if sibling != self }
-        return self
+        self
       else
-        return [] if is_root?
+        return [] if root?
+
         siblings = []
-        parent.children {|my_sibling|
-                         siblings << my_sibling if my_sibling != self}
+        parent.children do |my_sibling|
+          siblings << my_sibling if my_sibling != self
+        end
         siblings
       end
     end
@@ -875,10 +888,12 @@ module Tree
     # @return [Boolean] +true+ if this is the only child of its parent.
     #
     # @see #siblings
-    def is_only_child?
-      is_root? ? true : parent.children.size == 1
+    def only_child?
+      root? ? true : parent.children.size == 1
     end
 
+    alias is_only_child? only_child? # @todo: Aliased for eventual replacement
+
     # Next sibling for this node.
     # The _next_ node is defined as the node to right of this node.
     #
@@ -890,10 +905,10 @@ module Tree
     # @see #previous_sibling
     # @see #siblings
     def next_sibling
-      return nil if is_root?
+      return nil if root?
 
-      myidx = parent.children.index(self)
-      parent.children.at(myidx + 1) if myidx
+      idx = parent.children.index(self)
+      parent.children.at(idx + 1) if idx
     end
 
     # Previous sibling of this node.
@@ -907,17 +922,17 @@ module Tree
     # @see #next_sibling
     # @see #siblings
     def previous_sibling
-      return nil if is_root?
+      return nil if root?
 
-      myidx = parent.children.index(self)
-      parent.children.at(myidx - 1) if myidx && myidx > 0
+      idx = parent.children.index(self)
+      parent.children.at(idx - 1) if idx&.positive?
     end
 
     # @!endgroup
 
-    # Provides a comparision operation for the nodes.
+    # Provides a comparison operation for the nodes.
     #
-    # Comparision is based on the natural ordering of the node name objects.
+    # Comparison is based on the natural ordering of the node name objects.
     #
     # @param [Tree::TreeNode] other The other node to compare against.
     #
@@ -925,8 +940,9 @@ module Tree
     #                   this node is a 'predecessor'. Returns 'nil' if the other
     #                   object is not a 'Tree::TreeNode'.
     def <=>(other)
-      return nil if other == nil || other.class != Tree::TreeNode
-      self.name <=> other.name
+      return nil if other.nil? || !other.is_a?(Tree::TreeNode)
+
+      name <=> other.name
     end
 
     # Pretty prints the (sub)tree rooted at this node.
@@ -937,17 +953,18 @@ module Tree
     # @param [Proc] block optional block to use for rendering
     def print_tree(level = node_depth, max_depth = nil,
                    block = lambda { |node, prefix|
-                     puts "#{prefix} #{node.name}" })
-      prefix = ''
+                             puts "#{prefix} #{node.name}"
+                           })
+      prefix = ''.dup # dup NEEDs to be invoked to make this mutable.
 
-      if is_root?
+      if root?
         prefix << '*'
       else
-        prefix << '|' unless parent.is_last_sibling?
+        prefix << '|' unless parent.last_sibling?
         prefix << (' ' * (level - 1) * 4)
-        prefix << (is_last_sibling? ? '+' : '|')
+        prefix << (last_sibling? ? '+' : '|')
         prefix << '---'
-        prefix << (has_children? ? '+' : '>')
+        prefix << (children? ? '+' : '>')
       end
 
       block.call(self, prefix)
@@ -955,10 +972,10 @@ module Tree
       # Exit if the max level is defined, and reached.
       return unless max_depth.nil? || level < max_depth
 
-      children { |child|
-        child.print_tree(level + 1,
-                         max_depth, block) if child } # Child might be 'nil'
+      # Child might be 'nil'
+      children do |child|
+        child&.print_tree(level + 1, max_depth, block)
+      end
     end
-
   end
 end