arboretum 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 42a7d24be72182eafaad9b254b40ff5738423389
-  data.tar.gz: 5e0fc2574eb3bbc059c94dd9213dd7f7283c35d4
+  metadata.gz: 53ab23c0b718279ac0f58181b1b57cc75a610aa1
+  data.tar.gz: 964672ec600783cb39cad917b61deba000bd544f
 SHA512:
-  metadata.gz: 44b8504954777d1d5090fd11cbeba70dcd462d47a117d9b27a1b08de0b491fa74c41062cfa76cfb1e28f709a74779d0c9023ab48922392b61e1fac92ff92a95d
-  data.tar.gz: ee812ae2721613864054cd0d605f217bff0495e34021c0e77e2d597ca65b35763024b9f5a5d38c9b2a84fe404a523ec4e25540e3e685a25703949528fc3ef740
+  metadata.gz: 0f141ef672014ac90376357b7edad9335e6653d27eebd23620bdce06e4f5bc58ce8da6890c1cf6f0255de622f52b08129b88dff9932e6ff5e36b6dfe48a9c837
+  data.tar.gz: d1f8c0b8e694062e19ca877c1fcb3a4c1aae57eb8856615660f7f6a33d26cde5d0e37d8356f948e2ced718668ded81c52c8fead8bdb3c3ed49a3fd317cc932ec

data/lib/arboretum.rb

@@ -1,3 +1,3 @@
-require_relative 'arboretum/xml'
+require_relative 'arboretum/scandent'
 require_relative 'arboretum/doctree'
-require_relative 'arboretum/scandent'
+require_relative 'arboretum/xml'

data/lib/arboretum/debtor.rb

@@ -0,0 +1,49 @@
+require 'fiber'
+
+class ArboretumFiber
+  def self.ROOT_FIBER
+    @@ROOT_FIBER
+  end
+  def self.set_root_fiber(fiber)
+    @@ROOT_FIBER = fiber
+  end
+end
+
+ArboretumFiber.set_root_fiber(Fiber.current)
+
+class Debtor
+  def initialize
+    @resource = nil
+    @locked = true
+    @creditors = Array.new
+  end
+  def set_resource(rsc)
+    @resource = rsc
+  end
+  alias_method :set, :set_resource
+  def resource
+    begin
+      if locked?
+        @creditors << Fiber.current
+        Fiber.yield
+      end
+    rescue FiberError
+      puts "Warning: Tried to yield the root Fiber on a locked resource call. Returning resource anyways..."
+    end
+    @resource
+  end
+  def resource!
+    @resource
+  end
+  def locked?
+    @locked
+  end
+  def free?
+    !@locked
+  end
+  def free
+    @locked = false
+    @creditors.each {|c| c.resume }
+    @creditors = Array.new
+  end
+end

data/lib/arboretum/doctree.rb

@@ -1,3 +1,7 @@
+require 'promise'
+require 'forwardable'
+require 'securerandom'
+
 module Arboretum
   module DocTree
     module Counters
@@ -60,21 +64,21 @@ module Arboretum
     end # Counters
 
     module Elements
-      require 'forwardable'
-      require 'securerandom'
-      require_relative 'scandent'
-
       # Tree is a representation of a tree data structure consisting of elements
       # A Tree holds only reference to the root Element of the tree
       # A tree is useful for contextual operations on elements with the root as an ancestor
       class Tree
         include Enumerable
 
-        attr_accessor :root
+        attr_accessor :root, :id_cache
 
         def initialize(root=nil)
-          @root = root    # Element
-          @listeners = [] # Array of GroupListeners
+          @root = root            # Element
+          @listeners = Array.new  # Array of GroupListeners
+
+          @id_cache = Hash.new    # Hash: String => Element
+
+          root.update_tree_residence(self)
         end
 
         # Redefine the `each` method to iterate through all elements in the tree in depth-first order
@@ -94,6 +98,24 @@ module Arboretum
           Array.new.tap {|list| self.each {|element| list << element}}
         end
 
+        def id_cache_add(id, element)
+          @id_cache[id] = element
+        end
+
+        def id_cache_remove(id)
+          @id_cache.delete(id)
+        end
+
+        def id_cache_get(id)
+          @id_cache[id].tap {|element| yield element if block_given?}
+        end
+        alias_method :element_from_id, :id_cache_get
+
+        def element_from_id_hash(hash_id)
+          raise IndexError.new("Tried to get element from hash id with no hash: #{hash_id}") if !hash_id[0].eql?("#")
+          self.id_cache_get(hash_id[1..-1]).tap {|element| yield element if block_given?}
+        end
+
         # Find any and all elements in the tree that match a given ScandentRule string
         def scan(rule_string)
           selected = []
@@ -387,6 +409,7 @@ module Arboretum
           element = Element.create(element) if element.is_a?(Hash)
           element.graft_onto(self.parent, self.index_in_parent)
           self.graft_onto(element, index)
+          yield element if block_given?
           element
         end
       end
@@ -424,7 +447,7 @@ module Arboretum
         attr_writer :parent, :children, :sibling_prev, :sibling_next, :incrementers, :resetters, :library
           
         public
-        attr_reader :parent, :children, :sibling_prev, :sibling_next, :incrementers, :resetters, :library
+        attr_reader :parent, :children, :sibling_prev, :sibling_next, :incrementers, :resetters, :library, :tree_residence
         attr_accessor :break_within, :history
 
         # Class method to stitch together two elements as siblings, ordered
@@ -461,7 +484,7 @@ module Arboretum
             end
             created_element = TaggedElement.new(namespace, tag, sanitary_attrs)
             if !text.nil?
-              raise TypeError.new("Text must be a string or TextElement") if !(text.is_a?(String) or text.is_a?(TextElement))
+              raise TypeError.new("Text must be a String or TextElement") if !(text.is_a?(String) or text.is_a?(TextElement))
               if text.is_a?(String)
                 text_child = TextElement.new(text)
                 created_element.append_child(text_child)
@@ -484,6 +507,9 @@ module Arboretum
           @sibling_next = nil     # Element
           @children = []          # Array of Elements
 
+          # Tree residence
+          @tree_residence = nil   # Tree
+
           # Properties, references, and counters
           @break_within = false     # Boolean
           @incrementers = Hash.new  # Hash with key: Symbol (name), value: Incrementer
@@ -535,7 +561,7 @@ module Arboretum
         alias_method :unshift, :prepend_child
 
         # Insert an element as a child at a specified index it this element's children
-        def insert_child(*elements)
+        def insert_child(*elements, index)
           placed = Array.new
           elements.each do |element|
             if !element.nil?
@@ -659,19 +685,15 @@ module Arboretum
         # Add an element to a category in this element's library
         def lib_add(other, category)
           raise TypeError.new("Cannot create a record for a non-element") if !other.is_a?(Element) and !other.is_a?(ElementGroup)
+          category = category.to_sym if !category.is_a?(Symbol)
           if @library.has_key?(category)
-            record = @library[category]
-            if record.is_a?(Element) and other.is_a?(Element)
-              @library[category] = ElementGroup.new([record, other])
-            elsif record.is_a?(ElementGroup) and other.is_a?(Element)
+            if other.is_a?(Element)
               @library[category] << other
-            elsif record.is_a?(Element) and other.is_a?(ElementGroup)
-              @library[category] = ElementGroup.new([record]) + other
-            elsif record.is_a?(ElementGroup) and other.is_a?(ElementGroup)
-              @library[category] = record + other
+            else
+              @library[category] = @library[category] + other
             end
           else
-            @library[category] = other
+            @library[category] = ElementGroup.new([other])
           end
 
         end
@@ -680,6 +702,7 @@ module Arboretum
 
         # Get record from the given category in this element's library
         def lib_get(category)
+          category = category.to_sym if !category.is_a?(Symbol)
           @library[category]
         end
         alias_method :[], :lib_get
@@ -697,6 +720,11 @@ module Arboretum
           element_copy
         end
 
+        def update_tree_residence(update_tree)
+          @tree_residence = update_tree
+          @children.each {|child| child.update_tree_residence(update_tree)}
+        end
+
         # Detach from current parent/siblings
         def detach
           Element.stitch!(@sibling_prev, @sibling_next)
@@ -705,6 +733,8 @@ module Arboretum
         end
         alias_method :prune, :detach
         alias_method :delete, :detach
+        alias_method :clear, :detach
+        alias_method :remove, :detach
 
         # Graft onto another element of the tree at any index of its children
         # By default, it will graft as the last element of the other element's children
@@ -730,6 +760,8 @@ module Arboretum
             next_child = graft_parent.children[index]
             Element.stitch!(self, next_child)
 
+            self.update_tree_residence(graft_parent.tree_residence) if !self.tree_residence.eql?(graft_parent.tree_residence)
+
             # Graft group at index
             graft_parent.children.insert(index, self)
           end
@@ -747,6 +779,8 @@ module Arboretum
           Element.stitch!(nil, self)
           Element.stitch!(self, next_child)
 
+          self.update_tree_residence(graft_parent.tree_residence) if !self.tree_residence.eql?(graft_parent.tree_residence)
+
           # Insert graft group at the beginning of parent children
           graft_parent.children.insert(0, self)
         end
@@ -763,6 +797,8 @@ module Arboretum
           Element.stitch!(previous_child, self)
           Element.stitch!(self, nil)
 
+          self.update_tree_residence(graft_parent.tree_residence) if !self.tree_residence.eql?(graft_parent.tree_residence)
+
           # Push graft group onto parent children
           graft_parent.children.push(self)
         end
@@ -850,18 +886,18 @@ module Arboretum
         end
 
         # Finds elements in relation to this one that fit a ScandentRule string
-        def find(rule_string)
+        def find(rule_string, silent: false)
           rule = Arboretum::Scandent::Parser.parse_rule_string(rule_string, :PATH_LOCATOR)
           selected = rule.locate(self) {|found_element| yield found_element if block_given?}
-          puts "--Warning: Rule #{rule} did not match any elements!--" if selected.empty?
+          puts "--Warning: Rule #{rule} did not match any elements!--" if selected.empty? and !silent
           ElementGroup.new(selected)
         end
         alias_method :locate, :find
 
         # Finds up to `n` elements in relation to this one that fit a ScandentRule string
-        def find_first_n(rule_string, limit)
+        def find_first_n(rule_string, limit, silent: false)
           if limit.zero?
-            puts "--Warning: Rule #{rule} was given limit '0'. Returning nil...--" if selected.empty?
+            puts "--Warning: Rule #{rule} was given limit '0'. Returning nil...--" if selected.empty? and !silent
             return nil
           end
           selected = []
@@ -871,14 +907,14 @@ module Arboretum
             yield found_element if block_given?
             selected << found_element
           end
-          puts "--Warning: Rule #{rule} did not match any elements!--" if selected.empty?
+          puts "--Warning: Rule #{rule} on #{self.to_s} did not match any elements!--" if selected.empty? and !silent
           ElementGroup.new(selected)
         end
         alias_method :locate_first_n, :find_first_n
 
         # Find the first element in relation to this one that fits a ScandentRule string
-        def find_first(rule_string)
-          self.find_first_n(rule_string, 1) {|found_element| yield found_element if block_given?}.first
+        def find_first(rule_string, silent: false)
+          self.find_first_n(rule_string, 1, :silent => silent) {|found_element| yield found_element if block_given?}.first
         end
         alias_method :locate_first, :find_first
 
@@ -970,7 +1006,6 @@ module Arboretum
       class TaggedElement < Element
         @@unpaired_tags = [:'DOCTYPE', :'!DOCTYPE', :'area', :'base', :'br', :'col', :'command', :'embed', :'hr', :'img',
                           :'input', :'keygen', :'link', :'meta', :'param', :'source', :'track', :'wbr']
-        @@need_valid_xml = true
 
         attr_accessor :namespace, :tag, :attrs
 
@@ -980,7 +1015,7 @@ module Arboretum
           # Element tag and attributes
           @namespace = namespace  # Symbol
           @tag = tag              # Symbol
-          @attrs = attrs          # Hash with key: Symbol, String: Array of Strings
+          @attrs = attrs          # Hash: Symbol => Array of Strings
         end
 
         def self.paired?(tag)
@@ -994,6 +1029,15 @@ module Arboretum
           element_copy
         end
 
+        def update_tree_residence(update_tree)
+          # Update old and new tree id cache
+          if self.has_attr?(:id)
+            self.tree_residence&.id_cache_remove(self.attr_value_str(:id))
+            update_tree&.id_cache_add(self.attr_value_str(:id), self)
+          end
+          super(update_tree)
+        end
+
         # Returns the id of this element, or an auto-assigned one if none exists
         def ref
           if !self.has_attr?(:id) or self.attr_value_str(:id).nil?
@@ -1005,6 +1049,7 @@ module Arboretum
           end
         end
 
+        # Returns the '#'-prefixed id of this element, or an auto-assigned one if none exists
         def href
           "#" << self.ref
         end
@@ -1018,6 +1063,10 @@ module Arboretum
 
         def del_attr(attr_name)
           attr_name = attr_name.to_sym if !attr_name.is_a?(Symbol)
+
+          # Update tree id cache
+          self.tree_residence&.id_cache_remove(self.attr_value_str(:id)) if attr_name.eql?(:id)
+
           self.attrs.delete(attr_name)
         end
 
@@ -1029,7 +1078,13 @@ module Arboretum
           raise TypeError.new("Attribute value must be a String or Array of Strings") if !attr_value.is_a?(Array)
           attr_value.each{|sub_val| raise TypeError.new("Each attribute value in an array must be a String") if !sub_val.is_a?(String)}
 
+          # Update tree id cache
+          self.tree_residence&.id_cache_remove(self.attr_value_str(:id)) if attr_name.eql?(:id)
+
           self.attrs[attr_name] = attr_value
+
+          # Update tree id cache
+          self.tree_residence&.id_cache_add(self.attr_value_str(:id), self) if attr_name.eql?(:id)
         end
 
         def del_attr_value(attr_name, attr_value)
@@ -1040,7 +1095,13 @@ module Arboretum
           raise TypeError.new("Attribute value must be a String or Array of Strings") if !attr_value.is_a?(Array)
           attr_value.each{|sub_val| raise TypeError.new("Each attribute value in an array must be a String") if !sub_val.is_a?(String)}
 
+          # Update tree id cache
+          self.tree_residence&.id_cache_remove(self.attr_value_str(:id)) if attr_name.eql?(:id)
+          
           self.attrs[attr_name].delete_if {|sub_val| attr_value.include?(sub_val)}
+
+          # Update tree id cache
+          self.tree_residence&.id_cache_add(self.attr_value_str(:id), self) if (attr_name.eql?(:id) and !self.attr_value_str.nil?)
         end
 
         def add_attr_value(attr_name, attr_value)
@@ -1055,6 +1116,8 @@ module Arboretum
           else
             self.attrs[attr_name] = attr_value
           end
+          # Update tree id cache
+          self.tree_residence&.id_cache_add(self.attr_value_str(:id), self) if attr_name.eql?(:id)
         end
 
         def set_tag(new_tag)
@@ -1112,9 +1175,7 @@ module Arboretum
             values.each do |v|
               element_string << "#{v.gsub('&','&amp;').gsub('<', '&lt;').gsub('>','&gt;')} "
             end
-            if not values.empty?
-              element_string = element_string[0..-2]
-            end
+            element_string = element_string.chop unless values.empty?
             element_string << "\""
           end
           # Close the tag if document must have valid xml
@@ -1135,21 +1196,11 @@ module Arboretum
           self.attrs.each do |key, values|
             element_string << " #{key}"
             element_string << "=\""
-            values.each do |v|
-              element_string << "#{v} "
-            end
-            if not values.empty?
-              element_string = element_string[0..-2]
-            end
+            values.each {|v| element_string << "#{v} "}
+            element_string = element_string.chop unless values.empty?
             element_string << "\""
           end
-          # Close the tag if document must have xml/xhtml
-          if self.paired? or not @@need_valid_xml
-            element_string << ">"
-          else
-            element_string << " />"
-          end
-          element_string
+          element_string << (self.paired? ? ">" : "/>")
         end
 
         def to_s_close
@@ -1283,10 +1334,17 @@ module Arboretum
           @group
         end
 
+        def only
+          raise IndexError.new("Element is not the only in its group") if not @group.length == 1
+          @group.first
+        end
+
         def text_string
-          full_string = ''
-          @group.each {|element| full_string << element.text_string}
-          full_string
+          String.new.tap{|full_string| @group.each {|element| full_string << element.text_string} }
+        end
+
+        def text_elements
+          Array.new.tap{|full_list| @group.each {|element| full_list << element.text_elements} }
         end
 
         def +(other)

data/lib/arboretum/scandent.rb

@@ -36,7 +36,7 @@ module Arboretum
       def to_s
         rule_str = ''
         @paths.each do |path|
-          rule_str << ', ' if !rule_str.empty?
+          rule_str << ', ' unless rule_str.empty?
           rule_str << path.to_s
         end
         rule_str
@@ -226,8 +226,8 @@ module Arboretum
                           !@attrs[:matches].empty? or
                           (element_ref == :ELEMENT_ROOT and !element.parent.nil?)
         end
-        @pseudo_exps.each do |psuedo_name, pseudo_arg|
-          return false if !PseudoElements.match(element, pseudo_name, pseudo_arg)
+        @pseudo_exps.each do |pseudo_name, pseudo_arg|
+          return false if !PseudoClasses.match(element, pseudo_name, pseudo_arg)
         end
         @valid_rules.each do |rule|
           return false if !rule.valid_on?(element)
@@ -361,9 +361,18 @@ module Arboretum
       end
     end
 
-    class PseudoElements
+    class PseudoClasses
+      # Call a pseudo class function
       def self.match(element, pseudo_name, pseudo_arg)
-        PseudoElements.public_send(:pseudo_name, element, pseudo_arg)
+        PseudoClasses.public_send(pseudo_name.to_sym, element, pseudo_arg)
+      end
+
+      # Pseudo class functions start here
+      def self.header(element, pseudo_arg)
+        (element.is_a?(Arboretum::DocTree::Elements::TaggedElement) and !(/h\d+/.match(element.tag.to_s).nil?))
+      end
+      def self.not(element, pseudo_arg)
+        !element.matches_rule?(pseudo_arg)
       end
     end
 
@@ -372,14 +381,14 @@ module Arboretum
     # ScandentRules can then be matched to Elements in a DocTree
     class Parser
       @@actions = {
-        :T_SLASH => :ACTION_CHILD,
-        :T_SLASH2 => :ACTION_DESCENDANT,
-        :T_SLASHDOT2 => :ACTION_PARENT,
-        :T_SLASHDOT3 => :ACTION_ANCESTOR,
-        :T_SLASHGT => :ACTION_FOLLOWING_SIBLING,
-        :T_SLASHGT2 => :ACTION_FOLLOWING,
-        :T_SLASHLT => :ACTION_PRECEDING_SIBLING,
-        :T_SLASHLT2 => :ACTION_PRECEDING
+        :T_SLASH      => :ACTION_CHILD,
+        :T_SLASH2     => :ACTION_DESCENDANT,
+        :T_SLASHDOT2  => :ACTION_PARENT,
+        :T_SLASHDOT3  => :ACTION_ANCESTOR,
+        :T_SLASHGT    => :ACTION_FOLLOWING_SIBLING,
+        :T_SLASHGT2   => :ACTION_FOLLOWING,
+        :T_SLASHLT    => :ACTION_PRECEDING_SIBLING,
+        :T_SLASHLT2   => :ACTION_PRECEDING
       }
 
       # Parse a Scandent string by giving it to the Tokenizer and then parsing the results
@@ -444,6 +453,7 @@ module Arboretum
           raise ParseException.new("Unknown step type")
         end
 
+        # Initialize all of the components that a step uses to match an element
         element_ref = []
         tag = []
         namespace = []
@@ -457,124 +467,103 @@ module Arboretum
         pseudo_exps = []
         valid_rules = []
 
-        index = 0
+        # Walk through the tokens of this step one at a time to parse grammar
+        index = -1
         state = :STATE_ROOT_PATH
-        while index < step_tokens.length
-          # Consume current token and increment
-          index_token = step_tokens[index]
-          index += 1
+        while (index + 1) < step_tokens.length
+          # Consume next token
+          index_token = step_tokens[index+=1]
 
           case index_token[0]
           when :T_PCT
-            following_token = step_tokens[index]
-            index += 1
-            raise InvalidExpressionException.new if following_token[0] != :LITERAL_IDENT
-            tag << following_token[1]
+            next_token = step_tokens[index+=1]
+            raise InvalidExpressionException.new if next_token[0] != :LITERAL_IDENT
+            tag << next_token[1]
           when :T_AT
-            following_token = step_tokens[index]
-            index += 1
-            raise InvalidExpressionException.new if following_token[0] != :LITERAL_IDENT
-            namespace << following_token[1]
+            next_token = step_tokens[index+=1]
+            raise InvalidExpressionException.new if next_token[0] != :LITERAL_IDENT
+            namespace << next_token[1]
           when :T_PND
-            following_token = step_tokens[index]
-            index += 1
-            raise InvalidExpressionException.new if following_token[0] != :LITERAL_IDENT
-            id << following_token[1]
+            next_token = step_tokens[index+=1]
+            raise InvalidExpressionException.new if next_token[0] != :LITERAL_IDENT
+            id << next_token[1]
           when :T_COLON
-            following_token = step_tokens[index]
-            index += 1
-            raise InvalidExpressionException.new if following_token[0] != :LITERAL_IDENT
-            pseudo_name = following_token[1].to_sym
+            next_token = step_tokens[index+=1]
+            raise InvalidExpressionException.new if next_token[0] != :LITERAL_IDENT
+            pseudo_name = next_token[1].to_sym
             arg_tokens = []
 
-            following_token = step_tokens[index]
-            if following_token[0] == :T_LPAREN
-              index += 1 # To consume the LPAREN
-              following_token = step_tokens[index]
-              index += 1
-              until following_token[0] == :T_RPAREN or index > step_tokens.length
-                arg_tokens << following_token
-                following_token = step_tokens[index]
-                index += 1
+            next_token = step_tokens[index+=1]
+            if next_token[0] == :T_LPAREN
+              next_token = step_tokens[index+=1]
+              until next_token[0] == :T_RPAREN or index > step_tokens.length
+                arg_tokens << next_token
+                next_token = step_tokens[index+=1]
               end
               raise InvalidExpressionException.new if index > step_tokens.length # Undesirable exit condition to above loop
-              index += 1 # To consume the RPAREN
             end
             pseudo_exps << [pseudo_name, Parser.parse_arg(arg_tokens)]
-          when :T_ASTERISK # Adds no restrictions, so do nothing
+          when :T_ASTERISK
+            # Adds no restrictions, so do nothing
           when :T_TILDE
             element_ref << :ELEMENT_ROOT
           when :T_DOT
             element_ref << :ELEMENT_SELF
           when :T_LBRAK
-            following_token = step_tokens[index]
-            index += 1
-            raise InvalidExpressionException.new if following_token[0] != :LITERAL_IDENT
-            attr_name = following_token[1].to_sym
+            next_token = step_tokens[index+=1]
+            raise InvalidExpressionException.new if next_token[0] != :LITERAL_IDENT
+            attr_name = next_token[1].to_sym
             attr_value = nil
             operation = nil
 
-            following_token = step_tokens[index]
-            index += 1
-            case following_token[0]
+            next_token = step_tokens[index+=1]
+            case next_token[0]
             when :T_EQL
               operation = :contains
 
-              following_token = step_tokens[index]
-              index += 1
-              raise InvalidExpressionException.new("Expected a string after '='") if ![:T_DQUOTE, :T_SQUOTE].include?(following_token[0])
-              string_limiter = following_token[0]
+              next_token = step_tokens[index+=1]
+              raise InvalidExpressionException.new("Expected a string after '='") if ![:T_DQUOTE, :T_SQUOTE].include?(next_token[0])
+              string_limiter = next_token[0]
 
-              following_token = step_tokens[index]
-              index += 1
-              raise InvalidExpressionException.new if not [:LITERAL_IDENT, :LITERAL_STRING, :LITERAL_INT, :LITERAL_FLOAT].include?(following_token[0])
-              attr_value = following_token[1]
+              next_token = step_tokens[index+=1]
+              raise InvalidExpressionException.new if not [:LITERAL_IDENT, :LITERAL_STRING, :LITERAL_INT, :LITERAL_FLOAT].include?(next_token[0])
+              attr_value = next_token[1]
 
-              following_token = step_tokens[index]
-              index += 1
-              raise InvalidExpressionException.new if following_token[0] != string_limiter
+              next_token = step_tokens[index+=1]
+              raise InvalidExpressionException.new if next_token[0] != string_limiter
 
-              following_token = step_tokens[index]
-              index += 1
-              raise InvalidExpressionException.new if following_token[0] != :T_RBRAK
+              next_token = step_tokens[index+=1]
+              raise InvalidExpressionException.new if next_token[0] != :T_RBRAK
             when :T_EQL2
               operation = :equals
-              following_token = step_tokens[index]
-              index += 1
-              raise InvalidExpressionException.new if ![:T_DQUOTE, :T_SQUOTE].include?(following_token[0])
-              string_limiter = following_token[0]
-
-              following_token = step_tokens[index]
-              index += 1
-              raise InvalidExpressionException.new if not [:LITERAL_IDENT, :LITERAL_STRING, :LITERAL_INT, :LITERAL_FLOAT].include?(following_token[0])
-              attr_value = following_token[1].split
-
-              following_token = step_tokens[index]
-              index += 1
-              raise InvalidExpressionException.new if following_token[0] != string_limiter
-
-              following_token = step_tokens[index]
-              index += 1
-              raise InvalidExpressionException.new if following_token[0] != :T_RBRAK
+              next_token = step_tokens[index+=1]
+              raise InvalidExpressionException.new if ![:T_DQUOTE, :T_SQUOTE].include?(next_token[0])
+              string_limiter = next_token[0]
+
+              next_token = step_tokens[index+=1]
+              raise InvalidExpressionException.new if not [:LITERAL_IDENT, :LITERAL_STRING, :LITERAL_INT, :LITERAL_FLOAT].include?(next_token[0])
+              attr_value = next_token[1].split
+
+              next_token = step_tokens[index+=1]
+              raise InvalidExpressionException.new if next_token[0] != string_limiter
+
+              next_token = step_tokens[index+=1]
+              raise InvalidExpressionException.new if next_token[0] != :T_RBRAK
             when :T_TILDE_EQL
               operation = :matches
 
-              following_token = step_tokens[index]
-              index += 1
-              raise InvalidExpressionException.new if following_token[0] != :T_VBARSLASH
+              next_token = step_tokens[index+=1]
+              raise InvalidExpressionException.new if next_token[0] != :T_VBARSLASH
 
-              following_token = step_tokens[index]
-              index += 1
-              raise InvalidExpressionException.new if not [:LITERAL_IDENT, :LITERAL_STRING, :LITERAL_INT, :LITERAL_FLOAT].include?(following_token[0])
-              attr_value = Regexp.new(following_token[1])
+              next_token = step_tokens[index+=1]
+              raise InvalidExpressionException.new if not [:LITERAL_IDENT, :LITERAL_STRING, :LITERAL_INT, :LITERAL_FLOAT].include?(next_token[0])
+              attr_value = Regexp.new(next_token[1])
 
-              following_token = step_tokens[index]
-              index += 1
-              raise InvalidExpressionException.new if following_token[0] != :T_SLASHVBAR
+              next_token = step_tokens[index+=1]
+              raise InvalidExpressionException.new if next_token[0] != :T_SLASHVBAR
 
-              following_token = step_tokens[index]
-              index += 1
-              raise InvalidExpressionException.new if following_token[0] != :T_RBRAK
+              next_token = step_tokens[index+=1]
+              raise InvalidExpressionException.new if next_token[0] != :T_RBRAK
             when :T_RBRAK
               operation = nil
             else
@@ -588,18 +577,17 @@ module Arboretum
           when :T_LBRACE
             equilibrium = 1
             reformed_path_string = ''
-            following_token = step_tokens[index]
-            index += 1
-            until (following_token[0] == :T_RBRACE and equilibrium.zero?) or index > step_tokens.length
-              reformed_path_string << following_token[1]
-              following_token = step_tokens[index]
-              index += 1
-              equilibrium += 1 if following_token[0] == :T_LBRACE
-              equilibrium -= 1 if following_token[0] == :T_RBRACE
+            next_token = step_tokens[index+=1]
+            until (next_token[0] == :T_RBRACE and equilibrium.zero?) or index > step_tokens.length
+              reformed_path_string << next_token[1]
+              next_token = step_tokens[index+=1]
+              equilibrium += 1 if next_token[0] == :T_LBRACE
+              equilibrium -= 1 if next_token[0] == :T_RBRACE
             end
             raise InvalidExpressionException.new("Could not find matching R_BRACE in #{reformed_path_string}") if index > step_tokens.length # Undesirable exit condition to above loop
             valid_rules << Parser.parse_rule_string(reformed_path_string, :PATH_LOCATOR)
           when :T_SLASH, :T_SLASH2, :T_SLASHDOT2, :T_SLASHDOT3, :T_SLASHGT, :T_SLASHGT2, :T_SLASHLT, :T_SLASHLT2
+            # Do nothing since the action has already been determined
           else
             raise ParseException.new("Consumed unexpected token: #{index_token}")
           end

data/lib/arboretum/xml.rb

@@ -1,9 +1,8 @@
+require 'ox'
+
 module Arboretum
   module XML
     module IO
-      require 'ox'
-      require_relative 'doctree'
-      
       class XMLParseException < StandardError
         def initialize(msg="An error occurred while parsing XML")
           super(msg)
@@ -87,7 +86,7 @@ module Arboretum
 
           # Add TaggedElement to tree
           opened_element = TaggedElement.new(element_ns, element_tag)
-          @open_elements.last.append_child(opened_element)
+          opened_element.graft_last_onto(@open_elements.last)
 
           # Open the element if paired
           @open_elements.push(opened_element)
@@ -101,7 +100,7 @@ module Arboretum
         def comment(str)
           # Add CommentElement to tree
           comment_element = CommentElement.new(str)
-          @open_elements.last.append_child(comment_element)
+          comment_element.graft_last_onto(@open_elements.last)
           # Do not open the element (no children)
         end
         def text(str)
@@ -111,13 +110,13 @@ module Arboretum
 
             # Add TextElement to tree
             text_element = TextElement.new(str)
-            @open_elements.last.append_child(text_element)
+            text_element.graft_last_onto(@open_elements.last)
             # Do not open the element (no children)
 
           elsif @style == :preserve
             # Add TextElement to tree
             text_element = TextElement.new(str)
-            @open_elements.last.append_child(text_element)
+            text_element.graft_last_onto(@open_elements.last)
             # Do not open the element (no children)
           end
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arboretum
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - tomjw64
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-26 00:00:00.000000000 Z
+date: 2017-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ox
@@ -37,6 +37,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/arboretum.rb
+- lib/arboretum/debtor.rb
 - lib/arboretum/doctree.rb
 - lib/arboretum/scandent.rb
 - lib/arboretum/xml.rb