moxml 0.1.7 → 0.1.8

data/spec/moxml/xpath/compiler_spec.rb

@@ -0,0 +1,406 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::XPath::Compiler do
+  let(:context) { Moxml.new(:nokogiri) }
+  let(:xml) do
+    <<~XML
+      <root>
+        <child id="1">text1</child>
+        <child id="2">text2</child>
+        <other>other text</other>
+      </root>
+    XML
+  end
+  let(:doc) { context.parse(xml) }
+
+  describe ".compile_with_cache" do
+    it "compiles a simple path expression" do
+      ast = Moxml::XPath::Parser.parse("/root")
+      proc = described_class.compile_with_cache(ast)
+
+      expect(proc).to be_a(Proc)
+    end
+
+    it "caches compiled expressions" do
+      ast = Moxml::XPath::Parser.parse("/root")
+      proc1 = described_class.compile_with_cache(ast)
+      proc2 = described_class.compile_with_cache(ast)
+
+      expect(proc1).to equal(proc2)
+    end
+
+    it "uses different cache keys for different namespaces" do
+      ast = Moxml::XPath::Parser.parse("/root")
+      proc1 = described_class.compile_with_cache(ast,
+                                                 namespaces: { "x" => "http://example.com" })
+      proc2 = described_class.compile_with_cache(ast,
+                                                 namespaces: { "y" => "http://other.com" })
+
+      expect(proc1).not_to equal(proc2)
+    end
+  end
+
+  describe "Basic compilation" do
+    it "compiles and executes /root" do
+      ast = Moxml::XPath::Parser.parse("/root")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be_a(Moxml::NodeSet)
+      expect(result.size).to eq(1)
+      expect(result.first.name).to eq("root")
+    end
+
+    it "compiles and executes /root/child" do
+      ast = Moxml::XPath::Parser.parse("/root/child")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be_a(Moxml::NodeSet)
+      expect(result.size).to eq(2)
+      expect(result.map(&:name)).to eq(["child", "child"])
+    end
+
+    it "compiles and executes /root/other" do
+      ast = Moxml::XPath::Parser.parse("/root/other")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be_a(Moxml::NodeSet)
+      expect(result.size).to eq(1)
+      expect(result.first.name).to eq("other")
+    end
+  end
+
+  describe "Axis: child" do
+    it "selects direct children" do
+      ast = Moxml::XPath::Parser.parse("/root/child")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result.size).to eq(2)
+      expect(result.map(&:name)).to all(eq("child"))
+    end
+
+    it "returns empty set when no children match" do
+      ast = Moxml::XPath::Parser.parse("/root/nonexistent")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be_empty
+    end
+  end
+
+  describe "Axis: self" do
+    it "selects the node itself" do
+      ast = Moxml::XPath::Parser.parse("/root/self::root")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result.size).to eq(1)
+      expect(result.first.name).to eq("root")
+    end
+  end
+
+  describe "Axis: parent" do
+    it "selects parent node" do
+      ast = Moxml::XPath::Parser.parse("/root/child/parent::root")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result.size).to eq(2) # Two child elements have same parent
+      expect(result.first.name).to eq("root")
+    end
+  end
+
+  describe "Axis: descendant-or-self (//)" do
+    let(:nested_xml) do
+      <<~XML
+        <root>
+          <book price="10">
+            <title>Programming Ruby</title>
+            <author>Matz</author>
+          </book>
+          <book price="20">
+            <title>Programming Python</title>
+            <author>Guido</author>
+          </book>
+        </root>
+      XML
+    end
+    let(:nested_doc) { context.parse(nested_xml) }
+
+    it "finds all descendants with //" do
+      ast = Moxml::XPath::Parser.parse("//title")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(nested_doc)
+
+      expect(result).to be_a(Moxml::NodeSet)
+      expect(result.size).to eq(2)
+      expect(result.map(&:text)).to contain_exactly("Programming Ruby",
+                                                    "Programming Python")
+    end
+
+    it "finds nested elements" do
+      ast = Moxml::XPath::Parser.parse("//author")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(nested_doc)
+
+      expect(result.size).to eq(2)
+      expect(result.map(&:text)).to contain_exactly("Matz", "Guido")
+    end
+
+    it "works with wildcards" do
+      skip "HeadedOx limitation: Wildcard count differs due to Ox's DOM structure. See docs/HEADED_OX_LIMITATIONS.md"
+      ast = Moxml::XPath::Parser.parse("//*")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(nested_doc)
+
+      # Should find root, 2 books, 2 titles, 2 authors = 7 elements
+      expect(result.size).to be >= 7
+    end
+  end
+
+  describe "Axis: attribute (@)" do
+    let(:attr_xml) do
+      <<~XML
+        <root>
+          <book price="10" isbn="123">
+            <title lang="en">Book 1</title>
+          </book>
+          <book price="20" isbn="456">
+            <title lang="fr">Book 2</title>
+          </book>
+        </root>
+      XML
+    end
+    let(:attr_doc) { context.parse(attr_xml) }
+
+    it "selects attributes with @" do
+      ast = Moxml::XPath::Parser.parse("/root/book/@price")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(attr_doc)
+
+      expect(result).to be_a(Moxml::NodeSet)
+      expect(result.size).to eq(2)
+      expect(result.map(&:value)).to contain_exactly("10", "20")
+    end
+
+    it "works with wildcards" do
+      skip "HeadedOx limitation: Attribute wildcard (@*) not supported by XPath parser. See docs/HEADED_OX_LIMITATIONS.md"
+      ast = Moxml::XPath::Parser.parse("/root/book/@*")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(attr_doc)
+
+      # Each book has 2 attributes (price, isbn) = 4 total
+      expect(result.size).to eq(4)
+    end
+
+    it "selects nested element attributes" do
+      ast = Moxml::XPath::Parser.parse("/root/book/title/@lang")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(attr_doc)
+
+      expect(result.size).to eq(2)
+      expect(result.map(&:value)).to contain_exactly("en", "fr")
+    end
+
+    it "returns empty when no attributes match" do
+      ast = Moxml::XPath::Parser.parse("/root/book/@nonexistent")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(attr_doc)
+
+      expect(result).to be_empty
+    end
+  end
+
+  describe "Axis: descendant" do
+    let(:desc_xml) do
+      <<~XML
+        <root>
+          <parent id="p1">
+            <child id="c1">
+              <grandchild id="g1">text1</grandchild>
+            </child>
+            <child id="c2">
+              <grandchild id="g2">text2</grandchild>
+            </child>
+          </parent>
+        </root>
+      XML
+    end
+    let(:desc_doc) { context.parse(desc_xml) }
+
+    it "finds all descendants without self" do
+      ast = Moxml::XPath::Parser.parse("/root/descendant::grandchild")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(desc_doc)
+
+      expect(result).to be_a(Moxml::NodeSet)
+      expect(result.size).to eq(2)
+      expect(result.map do |n|
+        n.attribute("id")&.value
+      end).to contain_exactly("g1", "g2")
+    end
+
+    it "does not include the context node itself" do
+      ast = Moxml::XPath::Parser.parse("/root/parent/descendant::parent")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(desc_doc)
+
+      # Should not find parent itself, only descendants named parent (none)
+      expect(result).to be_empty
+    end
+  end
+
+  describe "Node tests" do
+    it "matches element names" do
+      ast = Moxml::XPath::Parser.parse("/root/child")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result.map(&:name)).to all(eq("child"))
+    end
+
+    it "handles wildcard" do
+      ast = Moxml::XPath::Parser.parse("/root/*")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result.size).to eq(3) # 2 child + 1 other
+    end
+
+    it "matches case-insensitively" do
+      xml_mixed = "<ROOT><Child>text</Child></ROOT>"
+      doc_mixed = context.parse(xml_mixed)
+
+      ast = Moxml::XPath::Parser.parse("/root/child")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc_mixed)
+
+      expect(result.size).to eq(1)
+    end
+  end
+
+  describe "Literals" do
+    it "compiles string literals" do
+      ast = Moxml::XPath::AST::Node.string("hello")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq("hello")
+    end
+
+    it "compiles number literals" do
+      ast = Moxml::XPath::AST::Node.number(42)
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(42.0)
+    end
+
+    it "compiles float literals" do
+      ast = Moxml::XPath::AST::Node.number(3.14)
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(3.14)
+    end
+  end
+
+  describe "Special nodes" do
+    it "handles current node (.)" do
+      ast = Moxml::XPath::Parser.parse(".")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(doc)
+    end
+
+    it "handles parent node (..)" do
+      # Get a child first
+      ast = Moxml::XPath::Parser.parse("/root/child")
+      proc = described_class.compile_with_cache(ast)
+      children = proc.call(doc)
+
+      # Now get parent from child
+      parent_ast = Moxml::XPath::Parser.parse("..")
+      parent_proc = described_class.compile_with_cache(parent_ast)
+      result = parent_proc.call(children.first)
+
+      expect(result.name).to eq("root")
+    end
+  end
+
+  describe "Complex paths" do
+    it "handles multi-step paths" do
+      xml_nested = <<~XML
+        <root>
+          <level1>
+            <level2>
+              <target>found</target>
+            </level2>
+          </level1>
+        </root>
+      XML
+      doc_nested = context.parse(xml_nested)
+
+      ast = Moxml::XPath::Parser.parse("/root/level1/level2/target")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc_nested)
+
+      expect(result.size).to eq(1)
+      expect(result.first.name).to eq("target")
+    end
+
+    it "handles paths that return no results" do
+      ast = Moxml::XPath::Parser.parse("/root/nonexistent/child")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be_empty
+    end
+  end
+
+  describe "Root node handling" do
+    it "selects document root with /" do
+      ast = Moxml::XPath::Parser.parse("/")
+      proc = described_class.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be_a(Moxml::NodeSet)
+      expect(result.size).to eq(1)
+      # Root should be the document or root element
+    end
+  end
+
+  describe "Error handling" do
+    it "handles malformed AST gracefully" do
+      # Create an AST with an unknown type
+      ast = Moxml::XPath::AST::Node.new(:unknown_type)
+
+      expect do
+        described_class.compile_with_cache(ast)
+      end.to raise_error(NoMethodError, /on_unknown_type/)
+    end
+  end
+
+  describe "Cache behavior" do
+    it "limits cache size" do
+      # Generate many different expressions
+      cache = Moxml::XPath::Cache.new(5)
+      compiler_class = Class.new(described_class) do
+        const_set(:CACHE, cache)
+      end
+
+      10.times do |i|
+        ast = Moxml::XPath::Parser.parse("/root/child#{i}")
+        compiler_class.compile_with_cache(ast)
+      end
+
+      expect(cache.size).to be <= 5
+    end
+  end
+end

data/spec/moxml/xpath/context_spec.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::XPath::Context do
+  let(:context) { described_class.new }
+
+  describe "#evaluate" do
+    it "evaluates simple Ruby code" do
+      result = context.evaluate("1 + 1")
+      expect(result).to eq(2)
+    end
+
+    it "evaluates string expressions" do
+      result = context.evaluate('"hello" + " world"')
+      expect(result).to eq("hello world")
+    end
+
+    it "evaluates boolean expressions" do
+      result = context.evaluate("true && false")
+      expect(result).to be(false)
+    end
+
+    it "evaluates arithmetic expressions" do
+      result = context.evaluate("10 * 5 + 3")
+      expect(result).to eq(53)
+    end
+
+    it "evaluates method calls" do
+      result = context.evaluate('"hello".upcase')
+      expect(result).to eq("HELLO")
+    end
+
+    it "evaluates array operations" do
+      result = context.evaluate("[1, 2, 3].map { |x| x * 2 }")
+      expect(result).to eq([2, 4, 6])
+    end
+
+    it "evaluates variable assignments and usage" do
+      code = <<~RUBY
+        x = 10
+        y = 20
+        x + y
+      RUBY
+      result = context.evaluate(code)
+      expect(result).to eq(30)
+    end
+
+    it "evaluates conditional statements" do
+      code = <<~RUBY
+        x = 15
+        if x > 10
+          "big"
+        else
+          "small"
+        end
+      RUBY
+      result = context.evaluate(code)
+      expect(result).to eq("big")
+    end
+
+    it "evaluates loops" do
+      code = <<~RUBY
+        sum = 0
+        [1, 2, 3, 4, 5].each do |n|
+          sum += n
+        end
+        sum
+      RUBY
+      result = context.evaluate(code)
+      expect(result).to eq(15)
+    end
+
+    it "returns the value of the last expression" do
+      code = <<~RUBY
+        x = 10
+        y = 20
+        x
+        y
+      RUBY
+      result = context.evaluate(code)
+      expect(result).to eq(20)
+    end
+
+    it "handles lambda expressions" do
+      code = "lambda { |x| x * 2 }.call(5)"
+      result = context.evaluate(code)
+      expect(result).to eq(10)
+    end
+
+    it "handles proc expressions" do
+      code = "proc { |x| x + 1 }.call(9)"
+      result = context.evaluate(code)
+      expect(result).to eq(10)
+    end
+
+    it "raises SyntaxError for invalid Ruby code" do
+      expect do
+        context.evaluate("def invalid syntax")
+      end.to raise_error(SyntaxError)
+    end
+
+    it "raises NameError for undefined variables" do
+      expect do
+        context.evaluate("undefined_variable")
+      end.to raise_error(NameError)
+    end
+
+    it "provides isolated binding between calls" do
+      context.evaluate("x = 100")
+      # Each evaluate call should have access to previously defined variables
+      # in the same context's binding
+      result = context.evaluate("x")
+      expect(result).to eq(100)
+    end
+
+    it "can define and call methods" do
+      code = <<~RUBY
+        def add(a, b)
+          a + b
+        end
+        add(3, 4)
+      RUBY
+      result = context.evaluate(code)
+      expect(result).to eq(7)
+    end
+
+    it "handles complex nested structures" do
+      code = <<~RUBY
+        data = { a: [1, 2, 3], b: [4, 5, 6] }
+        data[:a].map { |x| x * 2 } + data[:b].map { |x| x * 3 }
+      RUBY
+      result = context.evaluate(code)
+      expect(result).to eq([2, 4, 6, 12, 15, 18])
+    end
+
+    it "returns lambda/proc objects" do
+      result = context.evaluate("lambda { |x| x * 2 }")
+      expect(result).to be_a(Proc)
+      expect(result.call(5)).to eq(10)
+    end
+
+    it "handles begin/rescue/end blocks" do
+      code = <<~RUBY
+        begin
+          1 / 0
+        rescue ZeroDivisionError
+          "error caught"
+        end
+      RUBY
+      result = context.evaluate(code)
+      expect(result).to eq("error caught")
+    end
+  end
+
+  describe "binding isolation" do
+    it "maintains separate bindings for different context instances" do
+      context1 = described_class.new
+      context2 = described_class.new
+
+      context1.evaluate("x = 100")
+
+      # context2 should not have access to context1's variables
+      expect { context2.evaluate("x") }.to raise_error(NameError)
+    end
+
+    it "maintains state within a single context" do
+      context.evaluate("counter = 0")
+      context.evaluate("counter += 1")
+      context.evaluate("counter += 1")
+      result = context.evaluate("counter")
+
+      expect(result).to eq(2)
+    end
+  end
+
+  describe "edge cases" do
+    it "handles empty string" do
+      result = context.evaluate("")
+      expect(result).to be_nil
+    end
+
+    it "handles nil literal" do
+      result = context.evaluate("nil")
+      expect(result).to be_nil
+    end
+
+    it "handles true literal" do
+      result = context.evaluate("true")
+      expect(result).to be(true)
+    end
+
+    it "handles false literal" do
+      result = context.evaluate("false")
+      expect(result).to be(false)
+    end
+
+    it "handles multiline strings" do
+      code = <<~RUBY
+        str = <<~TEXT
+          Hello
+          World
+        TEXT
+        str.strip
+      RUBY
+      result = context.evaluate(code)
+      expect(result).to eq("Hello\nWorld")
+    end
+  end
+end