gammo 0.2.0 → 0.3.0

data/lib/gammo/css_selector/ast/selector/class_selector.rb

@@ -0,0 +1,19 @@
+module Gammo
+  module CSSSelector
+    module AST
+      module Selector
+        class Class
+          def initialize(class_name)
+            @class_name = class_name
+          end
+
+          def match?(context)
+            # TODO: prefer using class_name
+            return false unless val = context.node.attributes[:class]
+            val == @class_name || (val.split(/\s/).include?(@class_name))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gammo/css_selector/ast/selector/id_selector.rb

@@ -0,0 +1,18 @@
+module Gammo
+  module CSSSelector
+    module AST
+      module Selector
+        class ID
+          def initialize(id)
+            @id = id
+          end
+
+          def match?(context)
+            return false unless val = context.node.attributes[:id]
+            val == @id || (val.split(/\s/).include?(@id))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gammo/css_selector/ast/selector/negation.rb

@@ -0,0 +1,21 @@
+module Gammo
+  module CSSSelector
+    module AST
+      module Selector
+        class Negation
+          attr_accessor :value
+
+          extend Subclassify
+
+          def initialize(*args)
+            @arguments = args
+          end
+
+          def match?(context)
+            !@arguments[0].match?(context)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gammo/css_selector/ast/selector/pseudo_class.rb

@@ -0,0 +1,92 @@
+module Gammo
+  module CSSSelector
+    module AST
+      module Selector
+        class Pseudo
+          attr_accessor :value
+
+          extend Subclassify
+
+          def initialize(*args)
+            @arguments = args
+          end
+
+          def match?(context)
+            raise NotImplemented, "#match? must be implemented by sub class"
+          end
+
+          class Enabled < Pseudo
+            declare :enabled
+
+            def match?(context)
+              # Return true if attributes do not have the key, or value is not
+              # nil or the same with the key.
+              !context.node.attributes.key?(:disabled) || (!context.node.attributes[:disabled].nil? &&
+                                                           context.node.attributes[:disabled] != 'disabled')
+            end
+          end
+
+          class Disabled < Pseudo
+            declare :disabled
+
+            def match?(context)
+              # Return true if attributes have the key but nil, or value is the
+              # same with the key.
+              (context.node.attributes.key?(:disabled) && context.node.attributes[:disabled].nil?) ||
+                context.node.attributes[:disabled] == 'disabled'
+            end
+          end
+
+          class Checked < Pseudo
+            declare :checked
+
+            def match?(context)
+              # Return true if attributes have the key but nil, or value is the
+              # same with the key.
+              (context.node.attributes.key?(:checked) && context.node.attributes[:checked].nil?) ||
+                context.node.attributes[:checked] == 'checked'
+            end
+          end
+
+          class Root < Pseudo
+            declare :root
+
+            def match?(context)
+              # TODO:
+              context.node.tag == Tags::Html
+            end
+          end
+
+          class NthChild < Pseudo
+            declare :'nth-child'
+
+            InvalidExpression = Class.new(ArgumentError)
+
+            CONVERT_TABLE = {
+              'odd'  => ['2n+1'], #'2n+1',
+              'even' => ['2n']
+            }.freeze
+
+            # TODO: AST-style
+            def match?(context)
+              exprs = @arguments[0]
+              exprs = CONVERT_TABLE[exprs[0]] if CONVERT_TABLE[exprs[0]]
+
+              case value = exprs.join
+              when /\A\s*([\+\-])?([0-9]+)?\s*\z/ then
+                # Raises an error if given value is not integer, but basically unreachable.
+                context.position == Integer(value)
+              when match = /\A\s*([\-\+])?([0-9]+)?(#{Parser::N})(?:\s*([\-\+])\s*([0-9]+))?\s*\z/
+                d = (context.position - "#{$6}#{$7}".to_f) / "#{$1}#{$2 || 1}".to_f
+                # Converts the value into integer in order to ignore float numbers.
+                d >= 0 && d == d.to_i
+              else
+                raise InvalidExpression, 'invalid expression = %s' % value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gammo/css_selector/ast/selector.rb

@@ -0,0 +1,100 @@
+require 'set'
+require 'delegate'
+require 'gammo/modules/subclassify'
+require 'gammo/css_selector/node_set'
+require 'gammo/css_selector/ast/selector/id_selector'
+require 'gammo/css_selector/ast/selector/attrib_selector'
+require 'gammo/css_selector/ast/selector/class_selector'
+require 'gammo/css_selector/ast/selector/pseudo_class'
+require 'gammo/css_selector/ast/selector/negation'
+
+module Gammo
+  module CSSSelector
+    module AST
+      # Class for representing selectors group defined in the CSS selector specification.
+      # @!visibility private
+      class SelectorsGroup < DelegateClass(Array)
+        def initialize
+          super([])
+        end
+
+        def evaluate(context)
+          map { |selector| selector.evaluate(context.dup) }.inject(:+)
+        end
+      end
+
+      # @!visibility private
+      module Selector
+        class Base
+          attr_accessor :selectors
+
+          def initialize(namespace_prefix: nil, selectors: [])
+            @namespace_prefix = namespace_prefix
+            @selectors = selectors
+            @combinations = []
+          end
+
+          def evaluate(context)
+            node_set = NodeSet.new
+            search_descendant(context, node_set)
+
+            @combinations.inject(node_set) do |ns, combination|
+              duplicates = Set.new
+              ns.each_with_object(NodeSet.new) do |node, ret|
+                context.node = node
+                # TODO: #concat
+                combination.evaluate(context).each do |matched|
+                  ret << matched if duplicates.add?(matched)
+                end
+              end
+            end
+          end
+
+          def search_descendant(context, node_set)
+            queue = [context]
+            until queue.empty?
+              current_context = queue.shift
+              node_set << current_context.node if match?(current_context)
+              current_context.node.children.inject(0) do |i, child|
+                next i unless child.kind_of?(Node::Element)
+                i += 1
+                queue << Context.new(node: child, position: i)
+                i
+              end
+            end
+          end
+
+          def combine(selector)
+            @combinations << selector
+          end
+
+          def match?(context)
+            @selectors.all? { |matcher| matcher.match?(context) }
+          end
+        end
+
+        class Universal < Base
+          def initialize(**opts)
+            super
+          end
+
+          def match?(context)
+            super && context.node.kind_of?(Gammo::Node::Element)
+          end
+        end
+
+        class Type < Base
+          def initialize(element_name:, **opts)
+            @element_name = element_name
+            super(**opts)
+          end
+
+          def match?(context)
+            return false if @element_name != context.node.tag
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gammo/css_selector/context.rb

@@ -0,0 +1,17 @@
+module Gammo
+  module CSSSelector
+    # Class for representing a context at traversing DOM.
+    # @!visibility private
+    class Context
+      # Defines context node, context position and context size.
+      attr_accessor :node, :position, :size
+
+      # @param [Gammo::Node] node
+      # @param [Integer] position
+      def initialize(node:, position: 1)
+        @node     = node
+        @position = position
+      end
+    end
+  end
+end

data/lib/gammo/css_selector/errors.rb

@@ -0,0 +1,6 @@
+module Gammo
+  module CSSSelector
+    Error      = Class.new(StandardError)
+    ParseError = Class.new(Error)
+  end
+end

data/lib/gammo/css_selector/node_set.rb

@@ -0,0 +1,44 @@
+require 'forwardable'
+
+module Gammo
+  module CSSSelector
+    # Class for representing node set
+    # Especially this class will be used for expressing the result of evaluation
+    # of a given CSS selector.
+    class NodeSet
+      extend Forwardable
+      def_delegators :@nodes, :<<, :each, :each_with_object, :each_with_index, :length, :size,
+        :map, :[], :first, :last, :concat, :all?, :any?, :empty?
+
+      attr_reader :nodes
+
+      attr_accessor :disjoint
+
+      # Constructs a new instance of Gammo::CSSSelector::NodeSet.
+      # @return [Gammo::CSSSelector::NodeSet]
+      def initialize
+        @nodes    = []
+        @disjoint = false
+      end
+
+      # Replaces self nodes with an other node set destructively.
+      # @param [Gammo::CSSSelector::NodeSet] other
+      # @return [Gammo::CSSSelector::NodeSet]
+      # @!visibility private
+      def replace(other)
+        @nodes.replace(other.nodes)
+      end
+
+      def +(other)
+        ns = NodeSet.new
+        ns.nodes.concat(@nodes | other.nodes)
+        ns
+      end
+
+      # @!visibility private
+      def to_s
+        first.to_s
+      end
+    end
+  end
+end