richtext 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 16ef90a0b51b4d329a49909ba65958daf6c47de2
-  data.tar.gz: 5deebc04e53b025b8da28ddfc706bf50631ab990
+  metadata.gz: af2b68e549093d993d27e2a6d32f7f1f5388636e
+  data.tar.gz: 6c92d9931c6252d9e56bf7594f09e969e903fde2
 SHA512:
-  metadata.gz: 5de128f8a275745aafd51273de5eb9e75d2fb32973e414afae0b0bddb9e7ccba96cc743611100de61ce98c0b502e6b38e2f48b83e2de9e5cde38745a361627e5
-  data.tar.gz: 52118715ab8bee14685d83db86bc1f4d552680b80f93e9776b3918ca678c418e5da424ebc62e74344a159da63c6c85cffae09ae79380620394bffa6ec31c66a2
+  metadata.gz: 9181421572a02691f179593a544414df3e25b6aae59c134915962e83afe9aa006ffa67dc05925650938101e8c7825feb4cf57fbc443096cdc5eab295af9d1dd3
+  data.tar.gz: 513bc38940ae2c975aa6656e6c0ae9edbd9a92dcfb58efee10383e5288d01fdacc2ecd4d41a92491a745e49d0535f281a5cdea6db53c77e268bffb512202a892

data/README.md

@@ -1,4 +1,9 @@
-# Richtext
+# RichText 
+
+[![Gem Version](https://badge.fury.io/rb/richtext.png)](http://badge.fury.io/rb/richtext)
+[![Build Status](https://travis-ci.org/seblindberg/ruby-richtext.svg?branch=master)](https://travis-ci.org/seblindberg/ruby-richtext) 
+[![Coverage Status](https://coveralls.io/repos/github/seblindberg/ruby-richtext/badge.svg?branch=master)](https://coveralls.io/github/seblindberg/ruby-richtext?branch=master)
+[![Inline docs](http://inch-ci.org/github/seblindberg/ruby-richtext.svg?branch=master)](http://inch-ci.org/github/seblindberg/ruby-richtext)
 
 This gem is intended to simplify the handling of formatted text. Out of the box there is no support for any actual format, but that is intentional. The RichText::Document class is primarily ment to be subclassed and extended, and only includes functionality that is (potentially) useful to any format.
 
@@ -69,7 +74,7 @@ class MyFormat < RichText::Document
     # each word is represented by its own entry. Entries are
     # given a random visibility attribute.
     string.split(' ').each do |word|
-      base.create_child word, visible: (word.length > 6)
+      base.append_child word, visible: (word.length > 6)
     end
   end
 

data/lib/richtext.rb

@@ -1,15 +1,16 @@
+require 'rooted_tree'
+
 require 'richtext/version'
-require 'richtext/node'
+require 'richtext/styleable'
 require 'richtext/document/entry'
 require 'richtext/document'
 
 module RichText
 end
 
-# RichText
-#
 # Convenience method for creating RichText objects. Calling RichText(obj) is
 # equivalent to RichText::Document.new(obj).
+
 def RichText(string)
   RichText::Document.new string
 end

data/lib/richtext/document.rb

@@ -7,68 +7,69 @@ module RichText
     attr_reader :raw
     protected :raw
 
-    # Initialize
-    #
     # Create a new RichText Document, either from a string or from an existing
-    # ducument. That feature is particularly useful when converting between
+    # document. That feature is particularly useful when converting between
     # formats.
     #
     # When given a string or a RichText Document of the same class no parsing is
     # performed. Only when given a document of a different subclass will the
     # parser need to be run parsed. Note that the document(s) may already be in
-    # parsed form, in which case no further parsing is performed. See #base for
+    # parsed form, in which case no further parsing is performed. See #root for
     # more details.
+
     def initialize(arg = '')
-      @base, @raw =
-        if arg.class == self.class
-          arg.parsed? ? [arg.base, nil] : [nil, arg.raw]
+      @root, @raw =
+        if arg.instance_of? self.class
+          arg.parsed? ? [arg.root, nil] : [nil, arg.raw]
         elsif arg.is_a? Document
-          # For any other RichText object we take the base node
-          [arg.base, nil]
+          # For any other RichText object we take the root node
+          [arg.root, nil]
         elsif arg.is_a? Entry
           # Also accept an Entry which will be used as the
-          # document base
-          [arg, nil]
+          # document root
+          [arg.root, nil]
         else
           [nil, arg.to_s]
         end
     end
 
-    # To String
-    #
-    # Use the static implementation of .render to convert the document back into
-    # a string. If the document was never parsed (and is unchanged) the
+    # Uses the static implementation of .render to convert the document back
+    # into a string. If the document was never parsed (and is unchanged) the
     # origninal string is just returned.
     #
     # If a block is given it will be used in place of .render to format the node
     # tree.
+    #
+    # Returns a string formatted according to the rules outlined by the Document
+    # format.
+
     def to_s(&block)
       if block_given?
-        base.to_s(&block)
+        root.to_s(&block)
       elsif parsed? || should_parse?
-        self.class.render base
+        self.class.render root
       else
         @raw
       end
     end
 
-    # To Plain
+    # Uses Entry#to_s to reduce the node structure down to a string.
     #
     # Returns the strings from all of the leaf nodes without any formatting
     # applied.
+
     def to_plain
-      base.to_s
+      root.to_s
     end
 
-    # Add (+)
-    #
     # Add another Document to this one. If the two are of (exactly) the same
     # class and neither one has been parsed, the two raw strings will be
-    # concatenated. If the other is a Document the two base nodes will be merged
+    # concatenated. If the other is a Document the two root nodes will be merged
     # and the new root added to a new Document.
     #
     # Lastly, if other is a string it will first be wraped in a new Document and
     # then added to this one.
+
     def +(other)
       # If the other object is of the same class, and neither
       # one of the texts have been parsed, we can concatenate
@@ -78,7 +79,7 @@ module RichText
       end
 
       # Same root class
-      return self.class.new(base + other.base) if other.is_a? Document
+      return self.class.new(root + other.root) if other.is_a? Document
 
       unless other.respond_to? :to_s
         raise TypeError,
@@ -91,33 +92,39 @@ module RichText
       self + self.class.new(other)
     end
 
-    # Append
+    # Append a string to the document. The string will not be parsed but
+    # inserted into a new entry, directly under the document root.
     #
+    # string - the string that will be wrapped in an Entry object.
+    # attributes - a hash of attributes that will be applied to the Entry.
     #
+    # Returns the newly created child.
+
     def append(string, **attributes)
-      base.create_child string, **attributes
+      root.append_child string, **attributes
+      root.child(-1)
     end
 
-    # Base
+    # Getter for the root node. If the raw input has not yet been
+    # parsed that will happen first, before the root node is returned.
     #
-    # Getter for the base node. If the raw input has not yet been
-    # parsed that will happen first, before the base node is returned.
-    def base
-      unless @base
-        @base = Entry.new
-        self.class.parse @base, @raw
+    # Returns the root Entry.
+
+    def root
+      unless @root
+        @root = Entry.new
+        self.class.parse @root, @raw
         @raw = nil
       end
 
-      @base
+      @root
     end
 
-    alias root base
+    alias base root
 
-    # Parsed?
-    #
     # Returns true if the raw input has been parsed and the internal
     # representation is now a tree of nodes.
+
     def parsed?
       @raw.nil?
     end
@@ -126,39 +133,35 @@ module RichText
       false
     end
 
-    # Each Node
-    #
     # Iterate over all Entry nodes in the document tree.
+
     def each_node(&block)
-      base.each(&block)
+      root.each(&block)
     end
 
     alias each_entry each_node
 
-    # Parse
-    #
     # Document type specific method for parsing a string and turning it into a
     # tree of entry nodes. This method is intended to be overridden when the
     # Document is subclassed. The default implementation just creates a top
     # level Entry containing the given string.
-    def self.parse(base, string)
-      base[:text] = string
+
+    def self.parse(root, string)
+      root.text = string
     end
 
-    # Render
-    #
     # Document type specific method for rendering a tree of entry nodes. This
     # method is intended to be overridden when the Document is subclassed. The
     # default implementation just concatenates the text entries into.
-    def self.render(base)
-      base.to_s
+
+    def self.render(root)
+      root.to_s
     end
 
-    # From
-    #
     # Convenience method for instansiating one RichText object from another. The
     # methods only purpose is to make that intent more clear, and to make the
     # creation from another RichText object explicit.
+
     def self.from(doc)
       unless doc.is_a? Document
         raise TypeError,

data/lib/richtext/document/entry.rb

@@ -2,8 +2,7 @@
 
 module RichText
   class Document
-    # Entry
-    #
+
     # The Entry class extends the basic Node class and adds methods that make
     # handling text a little nicer. Essentially the :text attribute is given
     # special status by allowing it to a) be set during initialization, b) only
@@ -13,129 +12,170 @@ module RichText
     # Some attributes are also supported explicitly by the inclusion of special
     # accesser methods. The attributes are are bold, italic, underline, color
     # and font.
-    #
-    class Entry < Node
-      # Initialize
-      #
+
+    class Entry < RootedTree::Node
+      include Styleable
+
+      attr_reader :attributes
+      protected :prepend_child, :prepend_sibling, :value, :value=
+
       # Extend the default Node initializer by also accepting a string. It will,
       # if given, be stored as a text attribute.
-      def initialize(text = nil, **attributes)
-        attributes[:text] = text if text
-        super attributes
-      end
 
-      # Text
-      #
-      # Read the text of the node. This will return nil unless the node is a
-      # leaf node. Note that nodes that are not leafs can have the text entry,
-      # but it is discouraged by dissalowing access using this method.
-      def text
-        self[:text] || '' if leaf?
+      def initialize(text = nil, **attributes)
+        @attributes = attributes
+        super text
       end
 
-      # Append
+      # Freeze the attributes hash, as well as the node structure.
       #
-      # Since the text attribute is treated differently, and only leaf nodes can
-      # expose it, it must be pushed to a new child if a) this node was a leaf
-      # prior to this method call and b) its text attribute is not empty.
-      def <<(child)
-        if leaf?
-          # Remove the text entry from the node and put it in a new leaf node
-          # among the children, unless it is empty
-          if (t = @attributes.delete :text)
-            create_child(t) unless t.empty?
-          end
-        end
+      # Returns self.
 
+      def freeze
+        @attributes.freeze
         super
       end
 
-      # Create Child
+      # Accessor for single attributes.
       #
-      # Create and append a new child, initialized with the given text and
-      # attributes.
-      def create_child(text = nil, **attributes)
-        attributes = attributes.merge(text: text) if text
-        super(attributes)
+      # key - the attribute key
+      #
+      # Returns the attribute value if it is set and nil otherwise.
+
+      def [](key)
+        attributes[key]
       end
 
-      # Optimize!
+      # Write a single attribute.
       #
-      # See RichText::Node#optimize! for a description of the fundemental
-      # behavior. Entries differ from regular Nodes in that leaf children with
-      # no text in them will be removed.
-      def optimize!
-        super { |child| !child.leaf? || !child.text.empty? }
+      # key - the attribute key
+      # v - the new value
+
+      def []=(key, v)
+        attributes[key] = v
       end
 
-      # To String
+      # Read the text of the node.
       #
-      # Combine the text from all the leaf nodes in the tree, from left to
-      # right. If a block is given the node, along with its text will be passed
-      # as arguments. The block will be called recursivly, starting at the leaf
-      # nodes and propagating up until the entire tree has been "rendered" in
-      # this way.
-      def to_s(&block)
-        string =
-          if leaf?
-            text
-          else
-            @children.reduce('') { |a, e| a + e.to_s(&block) }
-          end
+      # Returns the string stored in the node, if it is a leaf. Otherwise nil.
 
-        block_given? ? yield(self, string) : string
+      def text
+        value || '' if leaf?
       end
 
-      # Supported Text Attributes
+      # Write the text of the node. The method will raise a RuntimeException if
+      # the node is not a leaf.
 
-      # Bold
-      #
-      def bold?
-        self[:bold]
+      def text=(new_text)
+        raise 'Only leafs can have a text entry' unless leaf?
+        self.value = new_text
       end
 
-      def bold=(b)
-        self[:bold] = b ? true : false
+      # Create and append a new child, initialized with the given text and
+      # attributes.
+      #
+      # child_text - the text of the child or an Entry object.
+      # attributes - a hash of attributes to apply to the child if child_text is
+      #              not an Entry object.
+      #
+      # Returns self to allow chaining.
+
+      def append_child(child_text = nil, **attributes)
+        if leaf? && !text.empty?
+          super self.class.new(value)
+        end
+
+        if child_text.is_a? self.class
+          super child_text
+        else
+          super self.class.new(child_text, attributes)
+        end
       end
 
-      # Italic
+      alias << append_child
+
+      # Go through each child and merge any node that a) is not a lead node and
+      # b) only has one child, with its child. The attributes of the child will
+      # override those of the parent.
       #
-      def italic?
-        self[:italic]
-      end
+      # Returns self.
+
+      def optimize!(&block)
+        # If the node is a leaf it cannot be optimized further
+        return self if leaf?
 
-      def italic=(i)
-        self[:italic] = i ? true : false
+        block = proc { |e| e.leaf? && e.text.empty? } unless block_given?
+
+        children.each do |child|
+          child.delete if block.call child.optimize!(&block)
+        end
+
+        # If we only have one child it is superfluous and
+        # should be merged. That means this node will inherrit
+        # the children of the single child as well as its
+        # attributes
+        if degree == 1
+          # Move the attributes over
+          attributes.merge! child.attributes
+          self.value = child.text
+          # Get the children of the child and add them to self
+          first_child.delete.each { |child| append_child child }
+        end
+
+        self
       end
 
-      # Underline
+      # Optimize a copy of the node tree based on the rules outlined for
+      # #optimize!.
       #
-      def underline?
-        self[:underline]
-      end
+      # Returns the root of the new optimized node structure.
 
-      def underline=(u)
-        self[:underline] = u ? true : false
+      def optimize(&block)
+        dup.optimize!(&block)
       end
 
-      # Color
+      # Combine the text from all the leaf nodes in the tree, from left to
+      # right. If a block is given the node, along with its text will be passed
+      # as arguments. The block will be called recursivly, starting at the leaf
+      # nodes and propagating up until the entire tree has been "rendered" in
+      # this way.
       #
-      def color
-        self[:color]
-      end
+      # block - a block that will be used to generate strings for each node.
+      #
+      # Returns a string representation of the node structure.
 
-      def color=(c)
-        self[:color] = c
+      def to_s(&block)
+        string =
+          if leaf?
+            text
+          else
+            children.reduce('') { |a, e| a + e.to_s(&block) }
+          end
+
+        block_given? ? yield(self, string) : string
       end
 
-      # Font
+      # Represents the Entry structure as a hierarchy, showing the attributes of
+      # each node as well as the text entries in the leafs.
       #
-      def font
-        self[:font]
-      end
+      # If a block is given, it will be called once for each entry, and the
+      # returned string will be used to represent the object in the output
+      # graph.
+      #
+      # Returns a string. Note that it will contain newline characters if the
+      # node has children.
+
+      def inspect *args, &block
+        unless block_given?
+          block = proc do |entry|
+            base_name = entry.leaf? ? %Q{"#{entry.text}"} : '◯'
+            base_name + entry.attributes.reduce('') do |a, (k, v)|
+              a + " #{k}=#{v.inspect}"
+            end
+          end
+        end
 
-      def font=(f)
-        self[:font] = f
+        super(*args, &block)
       end
     end
   end

data/lib/richtext/styleable.rb

@@ -0,0 +1,68 @@
+module RichText
+  module Styleable
+    
+    # Returns true if bold formatting is applied.
+    
+    def bold?
+      self[:bold]
+    end
+    
+    # Sets bold to either true or false, depending on the given argument.
+  
+    def bold=(b)
+      self[:bold] = b ? true : false
+    end
+  
+    # Returns true if italic formatting is applied.
+    
+    def italic?
+      self[:italic]
+    end
+    
+    # Sets italic to either true or false, depending on the given argument.
+  
+    def italic=(i)
+      self[:italic] = i ? true : false
+    end
+  
+    # Returns true if underlined formatting is applied.
+    
+    def underlined?
+      self[:underlined]
+    end
+    
+    alias underline? underlined?
+    
+    # Sets underlined to either true or false, depending on the given argument.
+  
+    def underlined=(u)
+      self[:underlined] = u ? true : false
+    end
+    
+    alias underline= underlined=
+  
+    # Returns the color value if it is set, otherwise nil.
+    
+    def color
+      self[:color]
+    end
+    
+    # Sets the color value.
+  
+    def color=(c)
+      self[:color] = c
+    end
+  
+    # Returns the font value if it is set, otherwise nil.
+    
+    def font
+      self[:font]
+    end
+    
+    # Sets the font value.
+  
+    def font=(f)
+      self[:font] = f
+    end
+  end
+end

data/lib/richtext/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RichText
-  VERSION = '0.2.4'
+  VERSION = '0.3.0'
 end

data/richtext.gemspec

@@ -19,7 +19,10 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "rooted_tree", "~> 0.2.3"
+
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "coveralls", "~> 0.8"
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: richtext
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Sebastian Lindberg
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-19 00:00:00.000000000 Z
+date: 2016-07-28 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rooted_tree
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
 description: 
 email:
 - seb.lindberg@gmail.com
@@ -70,7 +98,7 @@ files:
 - lib/richtext.rb
 - lib/richtext/document.rb
 - lib/richtext/document/entry.rb
-- lib/richtext/node.rb
+- lib/richtext/styleable.rb
 - lib/richtext/version.rb
 - richtext.gemspec
 homepage: https://github.com/seblindberg/ruby-richtext

data/lib/richtext/node.rb

@@ -1,236 +0,0 @@
-# frozen_string_literal: true
-
-module RichText
-  # Node
-  #
-  # A Node can have  children, which themselvs can have children. A tree like
-  # structure can thus be formed by composing multiple Nodes. An example of such
-  # a tree structure can be seen below.
-  #
-  # The Node class implements some convenience methods for iterating, left to
-  # right, over either all
-  #  - nodes in the tree
-  #  - leafs in the tree
-  #  - direct decendant of a node
-  #
-  # In addition to having children a Node can also have attributes, represented
-  # by simple key => value pairs.
-  #
-  #                Example Tree
-  #                                        +--------------------------+
-  #                     A <- Root Node     | Left to right order: ABC |
-  #                    / \                 +--------------------------+
-  #      Leaf Node -> B   C <- Child to A
-  #    (no children)     /|\
-  #                      ...
-  #
-  class Node
-    include Enumerable
-
-    attr_reader :attributes, :children
-    protected :children
-
-    def initialize(**attributes)
-      @children   = []
-      @attributes = attributes
-    end
-
-    def initialize_copy(original)
-      @children   = original.children.map(&:dup)
-      @attributes = original.attributes.dup
-    end
-
-    # Leaf?
-    #
-    # Returns true if this node a leaf (childless) node.
-    def leaf?
-      @children.empty?
-    end
-    
-    # Child
-    #
-    # Access the individual children of the node. If the method is called
-    # without argument and the node has only one child it will be returned.
-    # Otherwise an exception will be raised.
-    def child n = nil
-      if n
-        @children[n]
-      else
-        raise 'Node does not have one child' unless count == 1
-        @children[0]
-      end
-    end
-
-    # Append
-    #
-    # Add a child to the end of the node child list. The child must be of this
-    # class to be accepted. Note that subclasses of Node will not accept regular
-    # Nodes. The method returns self so that multiple children can be added via
-    # chaining:
-    #   root << child_a << child_b
-    def <<(child)
-      unless child.is_a? self.class
-        raise TypeError,
-              "Only objects of class #{self.class.name} can be appended"
-      end
-
-      @children << child
-      self
-    end
-
-    # Create Child
-    #
-    # Create and append a new child, initialized with the given attributes.
-    def create_child(**attributes)
-      child = self.class.new(**attributes)
-      self << child
-      child
-    end
-
-    # Add (+)
-    #
-    # Combines two nodes by creating a new root and adding the two as children.
-    def +(other)
-      self.class.new.tap { |root| root << self << other }
-    end
-
-    # Each
-    #
-    # Iterate over each node in the tree, including self.
-    def each(&block)
-      return to_enum(__callee__) unless block_given?
-
-      yield self
-
-      @children.each do |child|
-        yield child
-        child.each(&block) unless child.leaf?
-      end
-    end
-
-    # Each Leaf
-    #
-    # Iterate over each leaf in the tree. This method will yield the leaf nodes
-    # of the tree from left to right.
-    def each_leaf(&block)
-      return to_enum(__callee__) unless block_given?
-      return yield self if leaf?
-
-      @children.each do |child|
-        if child.leaf?
-          yield child
-        else
-          child.each_leaf(&block)
-        end
-      end
-    end
-
-    # Each child
-    #
-    # Iterate over the children of this node.
-    def each_child(&block)
-      @children.each(&block)
-    end
-
-    # Attribute accessor
-    #
-    # Read and write an attribute of the node. Attributes are simply key-value
-    # pairs stored internally in a hash.
-    def [](attribute)
-      @attributes[attribute]
-    end
-
-    def []=(attribute, value)
-      @attributes[attribute] = value
-    end
-
-    # Count
-    #
-    # Returns the child count of this node.
-    def count
-      @children.size
-    end
-
-    # Size
-    #
-    # Returns the size of the tree where this node is the root.
-    def size
-      @children.reduce(1) { |a, e| a + e.size }
-    end
-
-    # Minimal?
-    #
-    # Test if the tree under this node is minimal or not. A non minimal tree
-    # contains children which themselvs only have one child.
-    def minimal?
-      all? { |node| node.count != 1 }
-    end
-
-    # Optimize!
-    #
-    # Go through each child and merge any node that a) is not a lead node and b)
-    # only has one child, with its child. The attributes of the child will
-    # override those of the parent.
-    def optimize!
-      # If the node is a leaf it cannot be optimized further
-      return self if leaf?
-
-      # First optimize each of the children. If a block was
-      # given each child will be yielded to it, and children
-      # for which the block returns false will be removed
-      if block_given?
-        @children.select! { |child| yield child.optimize! }
-      else
-        @children.map(&:optimize!)
-      end
-
-      # If we only have one child it is superfluous and
-      # should be merged. That means this node will inherrit
-      # the children of the single child as well as its
-      # attributes
-      if count == 1
-        child = @children[0]
-        # Move the children over
-        @children = child.children
-        @attributes.merge! child.attributes
-      end
-
-      self
-    end
-
-    def optimize
-      dup.optimize!
-    end
-
-    # Shallow equality (exclude children)
-    #
-    # Returns true if the other node has the exact same attributes.
-    def equal?(other)
-      count == other.count && @attributes == other.attributes
-    end
-
-    # Deep equality (include children)
-    #
-    # Returns true if the other node has the same attributes and its children
-    # are also identical.
-    def ==(other)
-      # First make sure the nodes child count matches
-      return false unless equal? other
-
-      # Lastly make sure all of the children are equal
-      each_child.zip(other.each_child).all? { |c| c[0] == c[1] }
-    end
-
-    def inspect
-      children = @children.reduce('') do |s, c|
-        s + "\n" + c.inspect.gsub(/(^)/) { |m| m + '  ' }
-      end
-
-      format '#<%{name} %<attrs>p:%<id>#x>%{children}',
-             name: self.class.name,
-             id: object_id,
-             attrs: @attributes,
-             children: children
-    end
-  end
-end