moxml 0.1.6 → 0.1.8

data/lib/moxml/xpath/context.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Moxml
+  module XPath
+    # Class used as the context for compiled XPath Procs.
+    #
+    # The binding of this class is used for the binding of Procs compiled by
+    # {Compiler}. Not using a specific binding would result in the procs using
+    # the binding of {Compiler#compile}, which could lead to race conditions.
+    #
+    # @private
+    class Context
+      def initialize
+        @binding = binding
+      end
+
+      # Evaluates a Ruby code string in this context's binding.
+      #
+      # @param [String] string Ruby code to evaluate
+      # @return [Proc]
+      def evaluate(string)
+        @binding.eval(string)
+      end
+    end
+  end
+end

data/lib/moxml/xpath/conversion.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Moxml
+  module XPath
+    # Module for converting XPath objects such as NodeSets to different types.
+    #
+    # @private
+    module Conversion
+      # Converts both arguments to a type that can be compared using ==.
+      #
+      # @param [Object] left
+      # @param [Object] right
+      # @return [Array<Object, Object>]
+      def self.to_compatible_types(left, right)
+        if left.is_a?(Moxml::NodeSet) || left.respond_to?(:text)
+          left = to_string(left)
+        end
+
+        if right.is_a?(Moxml::NodeSet) || right.respond_to?(:text)
+          right = to_string(right)
+        end
+
+        if left.is_a?(Numeric) && !right.is_a?(Numeric)
+          right = to_float(right)
+        end
+
+        if left.is_a?(String) && !right.is_a?(String)
+          right = to_string(right)
+        end
+
+        if boolean?(left) && !boolean?(right)
+          right = to_boolean(right)
+        end
+
+        [left, right]
+      end
+
+      # Converts a value to an XPath string.
+      #
+      # @param [Object] value
+      # @return [String]
+      def self.to_string(value)
+        # If we have a number that has a zero decimal (e.g. 10.0) we want to
+        # get rid of that decimal. For this we'll first convert the number to
+        # an integer.
+        if value.is_a?(Float) && value.modulo(1).zero?
+          value = value.to_i
+        end
+
+        if value.is_a?(Moxml::NodeSet)
+          value = first_node_text(value)
+        end
+
+        if value.respond_to?(:text)
+          value = value.text
+        end
+
+        value.to_s
+      end
+
+      # Converts a value to an XPath number (float).
+      #
+      # @param [Object] value
+      # @return [Float]
+      def self.to_float(value)
+        if value.is_a?(Moxml::NodeSet)
+          value = first_node_text(value)
+        end
+
+        if value.respond_to?(:text)
+          value = value.text
+        end
+
+        if value == true
+          1.0
+        elsif value == false
+          0.0
+        else
+          begin
+            Float(value)
+          rescue ArgumentError, TypeError
+            Float::NAN
+          end
+        end
+      end
+
+      # Converts a value to an XPath boolean.
+      #
+      # @param [Object] value
+      # @return [Boolean]
+      def self.to_boolean(value)
+        bool = false
+
+        if value.is_a?(Float)
+          bool = !value.nan? && !value.zero?
+        elsif value.is_a?(Integer)
+          bool = !value.zero?
+        elsif value.respond_to?(:empty?)
+          bool = !value.empty?
+        elsif value
+          bool = true
+        end
+
+        bool
+      end
+
+      # Checks if a value is a boolean.
+      #
+      # @param [Object] value
+      # @return [Boolean]
+      def self.boolean?(value)
+        [true, false].include?(value)
+      end
+
+      # Gets the text of the first node in a NodeSet.
+      #
+      # @param [Moxml::NodeSet] set
+      # @return [String]
+      def self.first_node_text(set)
+        set[0].respond_to?(:text) ? set[0].text : ""
+      end
+    end
+  end
+end

data/lib/moxml/xpath/engine.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Moxml
+  module XPath
+    # XPath 1.0 evaluation engine
+    #
+    # This engine provides complete XPath 1.0 support for Moxml documents,
+    # particularly useful for the Ox adapter which has limited native XPath.
+    #
+    # @example Evaluate XPath expression
+    #   engine = Moxml::XPath::Engine.new(document)
+    #   results = engine.evaluate("//book[@id='123']/title")
+    #
+    # @example With context node
+    #   engine = Moxml::XPath::Engine.new(document)
+    #   results = engine.evaluate("./author", context: book_element)
+    #
+    class Engine
+      attr_reader :document
+
+      # Initialize engine with a document
+      #
+      # @param document [Moxml::Document] The document to query
+      def initialize(document)
+        @document = document
+      end
+
+      # Evaluate an XPath expression
+      #
+      # @param expression [String] XPath expression to evaluate
+      # @param context [Moxml::Node, nil] Context node (defaults to document root)
+      # @return [Moxml::NodeSet, String, Numeric, Boolean] Result depends on expression
+      # @raise [Moxml::XPath::SyntaxError] If expression syntax is invalid
+      # @raise [Moxml::XPath::EvaluationError] If evaluation fails
+      def evaluate(expression, context: nil)
+        raise ::NotImplementedError,
+              "XPath engine implementation in progress (Phase 1.1+)"
+      end
+
+      # Check if expression is valid XPath syntax
+      #
+      # @param expression [String] XPath expression to validate
+      # @return [Boolean] true if valid, false otherwise
+      def valid?(expression)
+        evaluate(expression, context: document.root)
+        true
+      rescue Moxml::XPath::SyntaxError
+        false
+      end
+    end
+  end
+end

data/lib/moxml/xpath/errors.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Moxml
+  module XPath
+    # Base error for XPath-specific errors
+    # Inherits from Moxml::XPathError to maintain compatibility
+    class Error < Moxml::XPathError; end
+
+    # Error raised when XPath syntax is invalid
+    class SyntaxError < Error
+      attr_reader :position, :token
+
+      def initialize(message, expression: nil, position: nil, token: nil)
+        @position = position
+        @token = token
+        super(message, expression: expression)
+      end
+
+      def to_s
+        msg = super
+        msg += "\n  Position: #{@position}" if @position
+        msg += "\n  Unexpected token: #{@token.inspect}" if @token
+        msg
+      end
+    end
+
+    # Error raised when XPath evaluation fails
+    class EvaluationError < Error
+      attr_reader :context_node, :step
+
+      def initialize(message, expression: nil, context_node: nil, step: nil)
+        @context_node = context_node
+        @step = step
+        super(message, expression: expression)
+      end
+
+      def to_s
+        msg = super
+        msg += "\n  Context node: <#{@context_node.name}>" if @context_node.respond_to?(:name)
+        msg += "\n  Step: #{@step}" if @step
+        msg
+      end
+    end
+
+    # Error raised when an XPath function is not found or invalid
+    class FunctionError < Error
+      attr_reader :function_name, :argument_count
+
+      def initialize(message, expression: nil, function_name: nil,
+argument_count: nil)
+        @function_name = function_name
+        @argument_count = argument_count
+        super(message, expression: expression)
+      end
+
+      def to_s
+        msg = super
+        msg += "\n  Function: #{@function_name}" if @function_name
+        msg += "\n  Arguments: #{@argument_count}" if @argument_count
+        msg
+      end
+    end
+
+    # Error raised when an XPath operation on unsupported node type
+    class NodeTypeError < Error
+      attr_reader :node_type, :operation
+
+      def initialize(message, expression: nil, node_type: nil, operation: nil)
+        @node_type = node_type
+        @operation = operation
+        super(message, expression: expression)
+      end
+
+      def to_s
+        msg = super
+        msg += "\n  Node type: #{@node_type}" if @node_type
+        msg += "\n  Operation: #{@operation}" if @operation
+        msg
+      end
+    end
+
+    # Error raised when an XPath function is called without required context
+    class InvalidContextError < Error
+      attr_reader :function_name, :required_context
+
+      def initialize(message, expression: nil, function_name: nil,
+required_context: nil)
+        @function_name = function_name
+        @required_context = required_context
+        super(message, expression: expression)
+      end
+
+      def to_s
+        msg = super
+        msg += "\n  Function: #{@function_name}" if @function_name
+        msg += "\n  Required context: #{@required_context}" if @required_context
+        msg
+      end
+    end
+  end
+end

data/lib/moxml/xpath/lexer.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+module Moxml
+  module XPath
+    # XPath expression lexer/tokenizer
+    #
+    # Converts XPath expressions into a stream of tokens for parsing.
+    # Each token is represented as [type, value, position].
+    #
+    # @example
+    #   lexer = Lexer.new("//book[@id='123']")
+    #   tokens = lexer.tokenize
+    #   # => [[:dslash, "//", 0], [:name, "book", 2], ...]
+    class Lexer
+      # XPath axis names for recognition
+      AXIS_NAMES = %w[
+        ancestor ancestor-or-self attribute child descendant
+        descendant-or-self following following-sibling namespace
+        parent preceding preceding-sibling self
+      ].freeze
+
+      # XPath node type names
+      NODE_TYPES = %w[
+        comment text processing-instruction node
+      ].freeze
+
+      # Reserved keywords
+      KEYWORDS = %w[and or mod div].freeze
+
+      # Initialize lexer with XPath expression
+      #
+      # @param expression [String] XPath expression to tokenize
+      def initialize(expression)
+        @expression = expression.to_s
+        @position = 0
+        @length = @expression.length
+        @tokens = []
+      end
+
+      # Tokenize the XPath expression
+      #
+      # @return [Array<Array>] Array of [type, value, position] tuples
+      # @raise [XPath::SyntaxError] if expression contains invalid syntax
+      def tokenize
+        @tokens = []
+        @position = 0
+
+        while @position < @length
+          skip_whitespace
+          break if @position >= @length
+
+          token_start = @position
+
+          case current_char
+          when "/"
+            if peek_char == "/"
+              add_token(:dslash, "//", token_start)
+              advance(2)
+            else
+              add_token(:slash, "/", token_start)
+              advance
+            end
+          when "|"
+            add_token(:pipe, "|", token_start)
+            advance
+          when "+"
+            add_token(:plus, "+", token_start)
+            advance
+          when "-"
+            add_token(:minus, "-", token_start)
+            advance
+          when "*"
+            add_token(:star, "*", token_start)
+            advance
+          when "="
+            add_token(:eq, "=", token_start)
+            advance
+          when "!"
+            if peek_char == "="
+              add_token(:neq, "!=", token_start)
+              advance(2)
+            else
+              raise_syntax_error("Unexpected '!' at position #{@position}")
+            end
+          when "<"
+            if peek_char == "="
+              add_token(:lte, "<=", token_start)
+              advance(2)
+            else
+              add_token(:lt, "<", token_start)
+              advance
+            end
+          when ">"
+            if peek_char == "="
+              add_token(:gte, ">=", token_start)
+              advance(2)
+            else
+              add_token(:gt, ">", token_start)
+              advance
+            end
+          when "("
+            add_token(:lparen, "(", token_start)
+            advance
+          when ")"
+            add_token(:rparen, ")", token_start)
+            advance
+          when "["
+            add_token(:lbracket, "[", token_start)
+            advance
+          when "]"
+            add_token(:rbracket, "]", token_start)
+            advance
+          when ","
+            add_token(:comma, ",", token_start)
+            advance
+          when "@"
+            add_token(:at, "@", token_start)
+            advance
+          when ":"
+            if peek_char == ":"
+              add_token(:dcolon, "::", token_start)
+              advance(2)
+            else
+              add_token(:colon, ":", token_start)
+              advance
+            end
+          when "."
+            if peek_char == "."
+              add_token(:ddot, "..", token_start)
+              advance(2)
+            elsif /\d/.match?(peek_char)
+              scan_number(token_start)
+            else
+              add_token(:dot, ".", token_start)
+              advance
+            end
+          when "$"
+            add_token(:dollar, "$", token_start)
+            advance
+          when '"', "'"
+            scan_string(token_start)
+          when /\d/
+            scan_number(token_start)
+          when /[a-zA-Z_]/
+            scan_name_or_keyword(token_start)
+          else
+            raise_syntax_error(
+              "Unexpected character '#{current_char}' at position #{@position}",
+            )
+          end
+        end
+
+        @tokens
+      end
+
+      private
+
+      # Get current character
+      #
+      # @return [String, nil] Current character or nil if at end
+      def current_char
+        @expression[@position]
+      end
+
+      # Peek at next character
+      #
+      # @return [String, nil] Next character or nil if at end
+      def peek_char
+        @expression[@position + 1]
+      end
+
+      # Advance position by n characters
+      #
+      # @param n [Integer] Number of characters to advance
+      def advance(n = 1)
+        @position += n
+      end
+
+      # Skip whitespace characters
+      def skip_whitespace
+        @position += 1 while @position < @length &&
+            @expression[@position] =~ /\s/
+      end
+
+      # Add token to token list
+      #
+      # @param type [Symbol] Token type
+      # @param value [String] Token value
+      # @param position [Integer] Token position
+      def add_token(type, value, position)
+        @tokens << [type, value, position]
+      end
+
+      # Scan string literal
+      #
+      # @param start_pos [Integer] Starting position
+      def scan_string(start_pos)
+        quote = current_char
+        advance
+
+        value = ""
+        while @position < @length && current_char != quote
+          if current_char == "\\"
+            advance
+            if @position < @length
+              # Handle escape sequences
+              value += case current_char
+                       when "t"
+                         "\t"
+                       when "n"
+                         "\n"
+                       when "r"
+                         "\r"
+                       when "\\"
+                         "\\"
+                       when '"'
+                         '"'
+                       when "'"
+                         "'"
+                       else
+                         # Unknown escape - add literally
+                         current_char
+                       end
+            end
+          else
+            value += current_char
+          end
+          advance
+        end
+
+        if @position >= @length
+          raise_syntax_error("Unterminated string starting at position #{start_pos}")
+        end
+
+        advance # Skip closing quote
+        add_token(:string, value, start_pos)
+      end
+
+      # Scan number (integer or decimal)
+      #
+      # @param start_pos [Integer] Starting position
+      def scan_number(start_pos)
+        value = ""
+
+        # Integer part
+        while @position < @length && current_char =~ /\d/
+          value += current_char
+          advance
+        end
+
+        # Decimal part
+        if @position < @length && current_char == "."
+          value += current_char
+          advance
+
+          while @position < @length && current_char =~ /\d/
+            value += current_char
+            advance
+          end
+        end
+
+        add_token(:number, value, start_pos)
+      end
+
+      # Scan name or keyword
+      #
+      # @param start_pos [Integer] Starting position
+      def scan_name_or_keyword(start_pos)
+        value = ""
+
+        # Name can contain letters, digits, underscores, hyphens, and dots
+        while @position < @length && current_char =~ /[a-zA-Z0-9_\-.]/
+          value += current_char
+          advance
+        end
+
+        # Check if it's an axis name followed by ::
+        if AXIS_NAMES.include?(value) &&
+            @position < @length - 1 &&
+            @expression[@position, 2] == "::"
+          add_token(:axis, value, start_pos)
+        elsif KEYWORDS.include?(value)
+          add_token(value.to_sym, value, start_pos)
+        elsif NODE_TYPES.include?(value)
+          add_token(:node_type, value, start_pos)
+        else
+          add_token(:name, value, start_pos)
+        end
+      end
+
+      # Raise syntax error
+      #
+      # @param message [String] Error message
+      # @raise [XPath::SyntaxError]
+      def raise_syntax_error(message)
+        raise Moxml::XPath::SyntaxError.new(
+          message,
+          expression: @expression,
+          position: @position,
+        )
+      end
+    end
+  end
+end