gammo 0.1.0 → 0.2.0

data/Rakefile

@@ -23,3 +23,9 @@ task :generate do
   table = eval(Erubi::Engine.new(File.read('misc/table.erubi')).src, binding)
   File.write('lib/gammo/tags/table.rb', table)
 end
+
+namespace :racc do
+  task :parser do
+    `bundle exec racc lib/gammo/xpath/parser.y -o lib/gammo/xpath/parser.rb`
+  end
+end

data/lib/gammo/attribute.rb

@@ -3,15 +3,24 @@ module Gammo
   class Attribute
     attr_accessor :key, :value, :namespace
 
+    # @!visibility private
+    attr_accessor :owner_element
+
     # Constructs an attribute with the key-value pair.
     # @param [String] key
     # @param [String] value
     # @param [String] namespace
+    # @param [Gammo::Element] owner_element
     # @return [Attribute]
-    def initialize(key:, value:, namespace: nil)
-      @key       = key
-      @value     = value
-      @namespace = namespace
+    def initialize(key:, value:, namespace: nil, owner_element: nil)
+      @key           = key
+      @value         = value
+      @namespace     = namespace
+      @owner_element = owner_element
+    end
+
+    def to_s
+      "<Gammo::Attribute #{key}='#{value}'>"
     end
   end
 end

data/lib/gammo/attributes.rb

@@ -0,0 +1,95 @@
+require 'delegate'
+
+module Gammo
+  # Class for representing attributes.
+  class Attributes < DelegateClass(Array)
+    attr_accessor :owner_element
+
+    def initialize(array, owner_element: nil)
+      super(array)
+      array.each { |attr| attr.owner_element = owner_element }
+      @owner_element = owner_element
+      @attributes_hash = attributes_to_hash(array)
+    end
+
+    def <<(attr)
+      super
+      @attributes_hash[attr.key] = attr.value
+    end
+
+    def [](key)
+      @attributes_hash[key.to_s]
+    end
+
+    def []=(key, value)
+      self << Attribute.new(key: key.to_s, value: value, owner_element: owner_element)
+    end
+
+    def prepend(*attrs)
+      prepended = super
+      attrs.each { |attr| @attributes_hash[attr.key.to_s] = attr.value }
+      prepended
+    end
+    alias_method :unshift, :prepend
+
+    def shift(n = nil)
+      original = self.dup
+      ret = n ? super : super()
+      (original - self).each { |attr| @attributes_hash.delete(attr.key.to_s) }
+      ret
+    end
+
+    def pop(n = nil)
+      original = self.dup
+      ret = n ? super : super()
+      (original - self).each { |attr| @attributes_hash.delete(attr.key.to_s) }
+      ret
+    end
+
+    def append(*attrs)
+      super
+      attrs.each { |attr| @attributes_hash[attr.key.to_s] = attr.value }
+    end
+    alias_method :push, :append
+
+    def delete(attr)
+      deleted = super
+      @attributes_hash.delete(deleted.key) if deleted
+      deleted
+    end
+
+    def reject!
+      original = self.dup
+      rejected = super
+      (original - self).each { |attr| @attributes_hash.delete(attr.key.to_s) }
+      rejected
+    end
+
+    def delete_if
+      original = self.dup
+      super
+      (original - self).each { |attr| @attributes_hash.delete(attr.key.to_s) }
+      self
+    end
+
+    def delete_at(pos)
+      deleted = super
+      deleted.each { |attr| @attributes_hash.delete(attr.key.to_s) }
+      deleted
+    end
+
+    def to_h
+      @attributes_hash.dup
+    end
+
+    def to_s
+      @attributes_hash.to_s
+    end
+
+    private
+
+    def attributes_to_hash(attrs)
+      attrs.each_with_object({}) { |attr, h| h[attr.key.to_s] = attr.value }
+    end
+  end
+end

data/lib/gammo/node.rb

@@ -1,18 +1,91 @@
+require 'gammo/xpath'
+require 'gammo/attributes'
+
 module Gammo
   # Class for representing Node.
   # https://html.spec.whatwg.org/multipage/parsing.html#tokenization
   class Node
+    # Raised if uncaught node is given for particular operations.
+    # @!visibility private
+    UncaughtTypeError = Class.new(ArgumentError)
+
+    # Raised if anything goes wrong on hierarchy while node operations.
+    # @!visibility private
+    HierarchyRequestError = Class.new(ArgumentError)
+
+    # `parent` is the pointer for the parent node.
+    attr_accessor :parent
+
+    # `first_child` and `last_child` are pointers for the first and the last nodes.
+    attr_accessor :first_child, :last_child
+
+    # `previous_sibling` and `next_sibling` are pointers for the previous and next sibling nodes.
+    attr_accessor :previous_sibling, :next_sibling
+
+    # Properties required to represent node.
+    attr_accessor :tag, :data, :namespace
+
+    # Reader for attributes associated with this node.
+    attr_reader :attributes
+
     # Represents the error token.
     Error = Class.new(Node)
 
+    def text_content
+      nil
+    end
+
+    def get_attribute_node(key, namespace: nil)
+      attributes.find { |attr| attr.key == key && attr.namespace == namespace }
+    end
+
+    def each_descendant
+      stack = [self]
+      until stack.empty?
+        node = stack.pop
+        yield node unless node == self
+        stack << node.next_sibling if node != self && node.next_sibling
+        stack << node.first_child if node.first_child
+      end
+    end
+
     # Represents the text token.
-    Text = Class.new(Node)
+    class Text < Node
+      alias_method :text_content, :data
+      alias_method :to_s, :text_content
+    end
 
     # Represents the root document token.
-    Document = Class.new(Node)
+    class Document < Node
+      include XPath
+    end
 
     # Represents the element token including start, end and self-closing token.
-    Element = Class.new(Node)
+    class Element < Node
+
+      # TODO: The current innerText() implementation does not conform to WHATWG spec.
+      # https://html.spec.whatwg.org/multipage/dom.html#the-innertext-idl-attribute
+      def inner_text
+        text = ''
+        each_descendant { |node| text << node.data if node.instance_of?(Text) }
+        text
+      end
+
+      def to_s
+        s = "<#{tag}"
+        attrs = attributes_to_string
+        s << ' ' unless attrs.empty?
+        s << "#{attrs}>"
+      end
+
+      private
+
+      def attributes_to_string
+        attributes.each_with_object([]) { |attr, attrs|
+          attrs << "#{attr.key}=#{attr.value}"
+        }.join(?\s)
+      end
+    end
 
     # Represents the comment token like "<!-- foo -->".
     Comment = Class.new(Node) 
@@ -30,37 +103,25 @@ module Gammo
     # template, td, th, and caption elements"
     DEFAULT_SCOPE_MARKER = Node::ScopeMarker.new
 
-    # Raised if uncaught node is given for particular operations.
-    # @!visibility private
-    UncaughtTypeError = Class.new(ArgumentError)
-
-    # Raised if anything goes wrong on hierarchy while node operations.
-    # @!visibility private
-    HierarchyRequestError = Class.new(ArgumentError)
-
-    # `parent` is the pointer for the parent node.
-    attr_accessor :parent
-
-    # `first_child` and `last_child` are pointers for the first and the last nodes.
-    attr_accessor :first_child, :last_child
-
-    # `previous_sibling` and `next_sibling` are pointers for the previous and next sibling nodes.
-    attr_accessor :previous_sibling, :next_sibling
-
-    # Properties required to represent node.
-    attr_accessor :tag, :data, :namespace, :attributes
-
     # Constructs a node which represents HTML element node.
     # @param [String] tag
     # @param [String] data
     # @param [String, NilClass] namespace
-    # @param [Hash(String => String)] attributes
+    # @param [Gammo::Attributes] attributes
     # @return [Gammo::Node]
-    def initialize(tag: nil, data: nil, namespace: nil, attributes: [])
+    def initialize(tag: nil, data: nil, namespace: nil, attributes: Attributes.new([]))
       @tag        = tag
       @data       = data
       @namespace  = namespace
-      @attributes = attributes
+      @attributes = Attributes.new(attributes, owner_element: self)
+    end
+
+    # Sets attributes in self.
+    # @param [Gammo::Attributes] attrs
+    def attributes=(attrs)
+      cloned = attrs.dup
+      cloned.each { |attr| attr.owner_element = self }
+      @attributes = cloned
     end
 
     # Inserts a node before a reference node as a child of a specified parent node.
@@ -142,6 +203,39 @@ module Gammo
       }
     end
 
+    # Select all nodes whose the evaluation of a given block is true.
+    def select(&block)
+      nodes = []
+      stack = [self]
+      until stack.empty?
+        node = stack.pop
+        nodes << node if block.call(node)
+        stack << node.next_sibling if node.next_sibling
+        stack << node.first_child if node.first_child
+      end
+      nodes
+    end
+
+    def children
+      ret = []
+      child = first_child
+      while child
+        ret << child
+        child = child.next_sibling
+      end
+      ret
+    end
+
+    def owner_document
+      node = self
+      node = node.parent until node.document?
+      node
+    end
+
+    def document?
+      self.instance_of?(Document)
+    end
+
     private
 
     # @!visibility private

data/lib/gammo/parser.rb

@@ -319,7 +319,9 @@ module Gammo
 
     # @!visibility private
     def add_element
-      add_child(Node::Element.new(tag: token.tag, data: token.data, attributes: token.attributes))
+      elm = Node::Element.new(tag: token.tag, data: token.data)
+      elm.attributes = Attributes.new(token.attributes, owner_element: elm)
+      add_child(elm)
     end
 
     # @!visibility private

data/lib/gammo/version.rb

@@ -1,3 +1,3 @@
 module Gammo
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/gammo/xpath.rb

@@ -0,0 +1,74 @@
+require 'gammo/xpath/parser'
+require 'gammo/xpath/context'
+
+module Gammo
+  module XPath
+    # Result types
+    # But features related to snapshot and ordered node are not supported.
+    # TODO: Support official result types.
+    #   - ORDERED_NODE_ITERATOR_TYPE
+    #   - UNORDERED_NODE_SNAPSHOT_TYPE
+    #   - ORDERED_NODE_SNAPSHOT_TYPE
+    ANY_TYPE                     = 0
+    NUMBER_TYPE                  = 1
+    STRING_TYPE                  = 2
+    BOOLEAN_TYPE                 = 3
+    UNORDERED_NODE_ITERATOR_TYPE = 4
+    ANY_UNORDERED_NODE_TYPE      = 8
+    FIRST_ORDERED_NODE_TYPE      = 9
+
+    # Class for traversing DOM tree built by Gammo::Parser by a given expression.
+    # @!visibility private
+    class Traverser
+      # Constructs an instance of Gammo::XPath::Traverser.
+      # @param [String] expr
+      # @param [Integer] result_type
+      # @!visibility private
+      def initialize(expr:, result_type:)
+        @expr = expr
+        @result_type = result_type
+      end
+
+      # Evaluates a given expression and returns value according to the
+      # result type.
+      # @param [Gammo::XPath::Context] context
+      # @return [String, Integer, TrueClass, FalseClass, Gammo::XPath::NodeSet]
+      # @!visibility private
+      def evaluate(context)
+        convert_value context, Parser.new(@expr).parse.evaluate(context)
+      end
+
+      private
+
+      # @!visibility private
+      def convert_value(context, value)
+        case @result_type
+        when ANY_TYPE then return value.value
+        when NUMBER_TYPE then return value.to_number
+        when STRING_TYPE then return value.to_s
+        when BOOLEAN_TYPE then return value.to_bool
+        when UNORDERED_NODE_ITERATOR_TYPE
+          fail TypeError, 'the result is not a node set' unless value.node_set?
+          value.to_node_set(context)
+        when ANY_UNORDERED_NODE_TYPE, FIRST_UNORDERED_NODE_TYPE
+          fail TypeError, 'the result is not a node set' unless value.node_set?
+          value.to_node_set(context).first
+        end
+      end
+    end
+
+    # Traverses DOM tree by a given expression, and returns a result according
+    # to the result type.
+    # @param [String] expr
+    # @param [Hash{Symbol => String, Symbol, Integer, TrueClass, FalseClass, #call}] variables
+    # @param [Integer] result_type
+    # @param [Gammo::Node] context_node
+    # @return [String, Integer, TrueClass, FalseClass, Gammo::XPath::NodeSet]
+    def xpath(expr, variables: {}, result_type: UNORDERED_NODE_ITERATOR_TYPE, context_node: self)
+      Traverser.new(
+        expr: expr,
+        result_type: result_type,
+      ).evaluate(Context.new(node: context_node, variables: variables))
+    end
+  end
+end

data/lib/gammo/xpath/ast/axis.rb

@@ -0,0 +1,231 @@
+require 'gammo/xpath/node_set'
+require 'gammo/xpath/ast/subclassify'
+require 'gammo/tags'
+
+module Gammo
+  module XPath
+    module AST
+      # Class for representing Axes.
+      # https://www.w3.org/TR/1999/REC-xpath-19991116/#axes
+      # @!visibility private
+      class Axis
+        attr_reader :node_test, :predicates
+
+        extend Subclassify
+
+        def initialize(node_test:, predicates: [])
+          @node_test = node_test
+          @predicates = Array(predicates)
+        end
+
+        def evaluate_context_node_with_node_set(context, context_node, node_set)
+          context.position = 0
+          # Strain nodes from context node for each axis.
+          strain(context, context_node, node_set)
+          # After straining try to filter by given predicates.
+          predicates.each do |predicate|
+            new_nodes = Gammo::XPath::NodeSet.new
+            node_set.each_with_index do |node, i|
+              context.node = node
+              context.size = node_set.size
+              context.position = i + 1
+              new_nodes << node if predicate.evaluate(context)
+            end
+            node_set.replace(new_nodes)
+          end
+        end
+
+        private
+
+        class Ancestor < Axis
+          declare :ancestor
+
+          def strain(context, context_node, node_set)
+            if context_node.instance_of?(Gammo::Attribute)
+              context_node = context_node.owner_element
+              node_set << context_node if node_test.match?(context_node)
+            end
+            node = context_node
+            while node = node.parent
+              node_set << node if node_test.match?(node)
+            end
+          end
+        end
+
+        class AncestorOrSelf < Axis
+          declare :ancestor_or_self
+
+          def strain(context, context_node, node_set)
+            node_set << context_node if node_test.match?(context_node)
+            if context_node.instance_of?(Gammo::Attribute)
+              context_node = context_node.owner_element
+              node_set << context_node if node_test.match?(context_node)
+            end
+            node = context_node
+            while node = node.parent
+              node_set << node if node_test.match?(node)
+            end
+          end
+        end
+
+        class Attribute < Axis
+          declare :attribute
+
+          def strain(context, context_node, node_set)
+            if node_test.instance_of?(NodeTest::Name) && node_test.local != ?*
+              attribute =
+                if !node_test.namespace
+                  context_node.get_attribute_node(node_test.local)
+                else
+                  # TODO: Test this properly.
+                  context_node.get_attribute_node(node_test.local, namespace: node_test.namespace)
+                end
+              if attribute && attribute.namespace != 'http://www.w3.org/XML/1998/namespace'
+                node_set << attribute if node_test.match?(attribute)
+              end
+              return
+            end
+
+            node_set.concat(context_node.attributes.select { |attribute|
+              node_test.match?(attribute)
+            })
+          end
+        end
+
+        class Child < Axis
+          declare :child
+
+          def strain(context, context_node, node_set)
+            return if context_node.instance_of?(Gammo::Attribute)
+            node = context_node.first_child
+            while node
+              node_set << node if node_test.match?(node)
+              node = node.next_sibling
+            end
+          end
+        end
+
+        class Descendant < Axis
+          declare :descendant
+
+          def strain(context, context_node, node_set)
+            return if context_node.instance_of?(Gammo::Attribute)
+            context_node.each_descendant do |node|
+              node_set << node if node_test.match?(node)
+            end
+          end
+        end
+
+        class DescendantOrSelf < Axis
+          declare :descendant_or_self
+
+          def strain(context, context_node, node_set)
+            node_set << context_node if node_test.match?(context_node)
+            return if context_node.instance_of?(Gammo::Attribute)
+            context_node.each_descendant do |node|
+              node_set << node if node_test.match?(node)
+            end
+          end
+        end
+
+        class Following < Axis
+          declare :following
+
+          def strain(context, context_node, node_set)
+            context_node = context_node.owner_element if context_node.instance_of?(Gammo::Attribute)
+            while node = context_node.next_sibling
+              each_following(node) do |node|
+                node_set << node if node_test.match?(node)
+              end
+              break if context_node.parent.tag != Gammo::Tags::Html
+            end
+          end
+
+          def each_following(context_node)
+            stack = [context_node]
+            until stack.empty?
+              node = stack.pop
+              yield node unless node == context_node
+              stack << node.next_sibling if node.next_sibling
+              stack << node.first_child if node.first_child
+            end
+          end
+        end
+
+        class FollowingSibling < Axis
+          declare :following_sibling
+
+          def strain(context, context_node, node_set)
+            return if context_node.instance_of?(Gammo::Attribute)
+            node = context_node
+            while node = node.next_sibling
+              node_set << node if node_test.match?(node)
+            end
+          end
+        end
+
+        class Namespace < Axis
+          declare :namespace
+
+          def strain(context, context_node, node_set)
+            # Not implemented
+          end
+        end
+
+        class Parent < Axis
+          declare :parent
+
+          def strain(context, context_node, node_set)
+            context_node = context_node.instance_of?(Gammo::Attribute) ?
+              context_node.owner_element : context_node.parent
+            node_set << context_node if node_test.match?(context_node)
+          end
+        end
+
+        class Preceding < Axis
+          declare :preceding
+
+          def strain(context, context_node, node_set)
+            context_node = context_node.owner_element if context_node.instance_of?(Gammo::Attribute)
+            each_preceding(context_node) do |node|
+              node_set << node if node_test.match?(node)
+            end
+          end
+
+          private
+
+          def each_preceding(context_node)
+            node = context_node
+            while parent = node.parent
+              while node = node.previous_sibling
+                yield node
+                break if node == parent
+              end
+              node = parent
+            end
+          end
+        end
+
+        class PrecedingSibling < Axis
+          declare :preceding_sibling
+
+          def strain(context, context_node, node_set)
+            return if context_node.instance_of?(Gammo::Attribute)
+            node = context_node
+            while node = node.previous_sibling
+              node_set << node if node_test.match?(node)
+            end
+          end
+        end
+
+        class Self < Axis
+          declare :self
+
+          def strain(context, context_node, node_set)
+            node_set << context_node if node_test.match?(context_node)
+          end
+        end
+      end
+    end
+  end
+end