gammo 0.1.0 → 0.2.0

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

@@ -0,0 +1,250 @@
+require 'gammo/xpath/ast/value'
+
+module Gammo
+  module XPath
+    module AST
+      # Class for representing a binary expression.
+      # @!visibility private
+      class BinaryExpr
+        # Constructs a binary expression by given "a" and "b".
+        # @param [Gammo::AST::Value, Gammo::AST:NodeSet] a
+        # @param [Gammo::AST::Value, Gammo::AST:NodeSet] b
+        # @!visibility private
+        def initialize(a, b)
+          @a = a
+          @b = b
+        end
+
+        # @!visibility private
+        def evaluate(context)
+          raise NotImplementedError, "BinaryExpr#evaluate must be implemented"
+        end
+
+        private
+
+        # @return [Array<Gammo::AST::Value...>]
+        # @!visibility private
+        def evaluate_values(context)
+          [@a.evaluate(context), @b.evaluate(context.dup)]
+        end
+      end
+
+      # Class for representing a binary expression that returns a boolean.
+      # @!visibility private
+      class BoolExpr < BinaryExpr
+        # @!visibility private
+        def evaluate(context)
+          compare(context, *evaluate_values(context))
+        end
+
+        private
+
+        # Compares both values and returns a boolean.
+        # @param [Context] context
+        # @param [Value] left
+        # @param [Value] right
+        # @return [TrueClass, FalseClass]
+        # @!visibility private
+        def compare(context, left, right)
+          return compare_with_node_set(
+            context, left.to_node_set(context), right) if left.node_set?
+          return compare_with_node_set(
+            context, right.to_node_set(context), left, reverse: true) if right.node_set?
+          do_compare(left, right)
+        end
+
+        # @!visibility private
+        def compare_with_node_set(context, node_set, value, reverse: false)
+          if value.node_set?
+            node_set.each do |lnode|
+              ls = string_from_node(lnode)
+              value.to_node_set(context).each do |rnode|
+                return true if compare(context, ls, string_from_node(rnode))
+              end
+            end
+          end
+          if value.number?
+            node_set.each do |node|
+              n = number_from_node(node)
+              return true if compare(context, *(reverse ? [value, n] : [n, value]))
+            end
+            return false
+          end
+          if value.string?
+            node_set.each do |node|
+              s = string_from_node(node)
+              return true if compare(context, *(reverse ? [value, s] : [s, value]))
+            end
+            return false
+          end
+          if value.bool?
+            b = node_set.to_bool
+            return compare(context, *(reverse ? [value, b] : [b, value]))
+          end
+          fail UnreachableError, 'unreachable pattern happens; please file an issue on github.'
+        end
+
+        # @!visibility private
+        def string_from_node(node)
+          case node
+          when Gammo::Node::Element, Gammo::Node::Document
+            AST::Value::String.new(node.inner_text)
+          when Gammo::Attribute
+            AST::Value::String.new(node.value)
+          when Gammo::Node::Comment, Gammo::Node::Text
+            AST::Value::String.new(node.data)
+          end
+        end
+
+        # @!visibility private
+        def number_from_node(node)
+          case node
+          when Gammo::Attribute
+            # TODO: Consider float case.
+            AST::Value::Number.new(node.value.to_i)
+          when Gammo::Node::Comment, Gammo::Node::Text
+            AST::Value::Number.new(node.data)
+          end
+        end
+
+        # @!visibility private
+        def equal?(left, right)
+          return left.to_bool == right.to_bool if left.bool? || right.bool?
+          return left.to_number == right.to_number if left.number? || right.number?
+          left.to_s == right.to_s
+        end
+      end
+
+      # @!visibility private
+      class EqExpr < BoolExpr
+        def do_compare(left, right)
+          equal?(left, right)
+        end
+      end
+
+      # @!visibility private
+      class NeqExpr < BoolExpr
+        def do_compare(left, right)
+          !equal?(left, right)
+        end
+      end
+
+      # @!visibility private
+      class LtExpr < BoolExpr
+        def do_compare(left, right)
+          left.to_number < right.to_number
+        end
+      end
+
+      # @!visibility private
+      class GtExpr < BoolExpr
+        def do_compare(left, right)
+          left.to_number > right.to_number
+        end
+      end
+
+      # @!visibility private
+      class LteExpr < BoolExpr
+        def do_compare(left, right)
+          left.to_number <= right.to_number
+        end
+      end
+
+      # @!visibility private
+      class GteExpr < BoolExpr
+        def do_compare(left, right)
+          left.to_number >= right.to_number
+        end
+      end
+
+      # Class for representing Arithmetic operators.
+      # @!visibility private
+      class ArithmeticExpr < BinaryExpr
+        def initialize(a, b)
+          super(a, b)
+        end
+
+        def evaluate(context)
+          # Expects left/right to be Integer.
+          Value::Number.new(do_arithmetic(*evaluate_values(context).map(&:to_number)))
+        end
+      end
+
+      # @!visibility private
+      class PlusExpr < ArithmeticExpr
+        def do_arithmetic(left, right)
+          left + right
+        end
+      end
+
+      # @!visibility private
+      class MinusExpr < ArithmeticExpr
+        def do_arithmetic(left, right)
+          left - right
+        end
+      end
+
+      # @!visibility private
+      class MultiplyExpr < ArithmeticExpr
+        def do_arithmetic(left, right)
+          left * right
+        end
+      end
+
+      # @!visibility private
+      class DividedExpr < ArithmeticExpr
+        def do_arithmetic(left, right)
+          left / right
+        end
+      end
+
+      # @!visibility private
+      class ModuloExpr < ArithmeticExpr
+        def do_arithmetic(left, right)
+          left % right
+        end
+      end
+
+      # @!visibility private
+      class UnionExpr < BinaryExpr
+        def evaluate(context)
+          cloned = context.clone
+          left, right = @a.evaluate(context), @b.evaluate(cloned)
+          left_node_set = left.to_node_set(context)
+          right_node_set = right.to_node_set(cloned)
+
+          duplicates = Set.new(left_node_set.nodes)
+          right_node_set.each { |node| left_node_set << node if duplicates.add?(node) }
+          left
+        end
+      end
+
+      # @!visibility private
+      class Negative
+        def initialize(expression)
+          @expression = expression
+        end
+
+        def evaluate(context)
+          AST::Value::Number.new(-@expression.evaluate(context).to_number)
+        end
+      end
+
+      # Class for representing predicate like "[foo='bar']" and "[0]".
+      # @!visibility private
+      class Predicate
+        def initialize(value)
+          @value = value
+        end
+
+        def evaluate(context)
+          ret = @value.evaluate(context)
+          if ret.instance_of?(AST::Value::Number)
+            return EqExpr.new(AST::Function::Position.new, ret).evaluate(context)
+          end
+          ret
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,179 @@
+require 'gammo/xpath/ast/subclassify'
+require 'gammo/xpath/ast/value'
+
+module Gammo
+  module XPath
+    module AST
+      # Class for representing XPath core function library.
+      # https://www.w3.org/TR/1999/REC-xpath-19991116/#corelib
+      class Function
+        extend Subclassify
+
+        # @!visibility private
+        def initialize(*arguments)
+          @arguments = arguments
+        end
+
+        # @!visibility private
+        def evaluate(context)
+          raise NotImplementedError, '#evaluate must be implemented'
+        end
+
+        private
+
+        # @!visibility private
+        def number(val)
+          return val if val.instance_of?(Value::Number)
+          Value::Number.new(val)
+        end
+
+        # @!visibility private
+        def bool(val)
+          return val if val.instance_of?(Value::Boolean)
+          Value::Boolean.new(val)
+        end
+
+        # @!visibility private
+        def string(val)
+          return val if val.instance_of?(Value::String)
+          Value::String.new(val)
+        end
+
+        attr_reader :arguments
+
+        # @!visibility private
+        class Boolean < Function
+          declare :boolean
+
+          def evaluate(context)
+            bool arguments[0].evaluate(context)
+          end
+        end
+
+        # @!visibility private
+        class Not < Function
+          declare :not
+
+          def evaluate(context)
+            bool !arguments[0].evaluate(context)
+          end
+        end
+
+        # @!visibility private
+        class True < Function
+          declare :true
+
+          def evaluate(context)
+            bool true
+          end
+        end
+
+        # @!visibility private
+        class False < Function
+          declare :false
+
+          def evaluate(context)
+            bool false
+          end
+        end
+
+        # @!visibility private
+        class Ceiling < Function
+          declare :ceiling
+
+          def evaluate(context)
+            number arguments[0].evaluate(context).value.ceil
+          end
+        end
+
+        # @!visibility private
+        class String < Function
+          declare :string
+
+          def evaluate(context)
+            return string context.node.to_s if arguments.length.zero?
+            string arguments[0].evaluate(context).to_s
+          end
+        end
+
+        # @!visibility private
+        class Concat < Function
+          declare :concat
+
+          def evaluate(context)
+            string arguments.each_with_object(::String.new) { |argument, s|
+              s << argument.evaluate(context.clone).to_s
+            }
+          end
+        end
+
+        # @!visibility private
+        class StartsWith < Function
+          declare :'starts-with'
+
+          def evaluate(context)
+            s1 = arguments[0].evaluate(context).to_s
+            s2 = arguments[1].evaluate(context.clone).to_s
+            return bool(true) if s2.empty?
+            bool s1.start_with?(s2)
+          end
+        end
+
+        # @!visibility private
+        class Contains < Function
+          declare :contains
+
+          def evaluate(context)
+            substr = arguments[1].evaluate(context).to_s
+            return bool(true) if substr.empty?
+            bool arguments[0].evaluate(context).to_s.include?(substr)
+          end
+        end
+
+        # @!visibility private
+        class SubstringBefore < Function
+          declare :'substring-before'
+
+          def evaluate(context)
+            s1 = arguments[0].evaluate(context).to_s
+            s2 = arguments[1].evaluate(context.clone).to_s
+            return string '' if s2.empty?
+            return string '' unless pos = s1.index(s2)
+            string s1[0...pos]
+          end
+        end
+
+        # @!visibility private
+        class SubstringAfter < Function
+          declare :'substring-after'
+
+          def evaluate(context)
+            s1 = arguments[0].evaluate(context).to_s
+            s2 = arguments[1].evaluate(context.clone).to_s
+            return string '' if s2.empty?
+            return string '' unless pos = s1.rindex(s2)
+            string s1[(pos + s2.length)..-1]
+          end
+        end
+
+        # @!visibility private
+        class Last < Function
+          declare :last
+
+          def evaluate(context)
+            number context.size
+          end
+        end
+
+        # @!visibility private
+        class Position < Function
+          declare :position
+
+          def evaluate(context)
+            number context.position
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+require 'gammo/xpath/ast/subclassify'
+require 'gammo/xpath/errors'
+
+module Gammo
+  module XPath
+    module AST
+      # @!visibility private
+      class NodeTest
+        extend Subclassify
+
+        def match?(node)
+          fail NotImplementedError, "#match must be implemented"
+        end
+
+        class Name < NodeTest
+          declare :name
+
+          attr_reader :local, :namespace
+
+          def initialize(local: nil, namespace: nil)
+            @local = local
+            @namespace = namespace
+          end
+
+          def xml_namespace?
+            namespace == 'http://www.w3.org/XML/1998/namespace'
+          end
+
+          def match?(node)
+            return false unless node
+            return false if xml_namespace?
+            return !namespace || namespace == node.namespace if local == ?*
+            # TODO: investigate
+            if node.instance_of?(Gammo::Attribute)
+              # TODO: need to work
+              node.key == local && node.namespace == namespace
+            else
+              if document = node.owner_document
+                # TODO: ignoring ascii case
+                return node.tag == local && (!namespace || node.namespace == namespace) if node.instance_of?(Gammo::Node::Element)
+                return node.tag == local && node.namespace == namespace && namespace
+              end
+              node.tag == local && node.namespace == namespace
+            end
+          end
+        end
+
+        # @!visibility private
+        class Any < NodeTest
+          declare :node
+
+          def match?(node)
+            true
+          end
+        end
+
+        # @!visibility private
+        class Text < NodeTest
+          declare :text
+
+          def match?(node)
+            node.instance_of?(Gammo::Node::Text)
+          end
+        end
+
+        # @!visibility private
+        class Comment < NodeTest
+          declare :comment
+
+          def match?(node)
+            node.instance_of?(Gammo::Node::Comment)
+          end
+        end
+
+        # @!visibility private
+        class ProcessingInstruction < NodeTest
+          declare :'processing-instruction'
+
+          def initialize
+            fail NotImplementedError, 'processing-instruction is not supported'
+          end
+        end
+      end
+    end
+  end
+end