moxml 0.1.6 → 0.1.8

data/spec/moxml/xpath/functions/numeric_functions_spec.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XPath Numeric Functions" do
+  let(:doc) do
+    xml = <<~XML
+      <root>
+        <item price="10">A</item>
+        <item price="20">B</item>
+        <item price="30">C</item>
+      </root>
+    XML
+    Moxml.new(:nokogiri).parse(xml)
+  end
+
+  describe "number()" do
+    it "converts string to number" do
+      ast = Moxml::XPath::Parser.parse('number("123.45")')
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(123.45)
+    end
+
+    it "converts boolean true to number" do
+      ast = Moxml::XPath::Parser.parse("number(true())")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(1.0)
+    end
+
+    it "converts boolean false to number" do
+      ast = Moxml::XPath::Parser.parse("number(false())")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(0.0)
+    end
+  end
+
+  describe "sum()" do
+    it "sums node values" do
+      ast = Moxml::XPath::Parser.parse("sum(/root/item/@price)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(60.0)
+    end
+
+    it "returns 0 for empty nodeset" do
+      ast = Moxml::XPath::Parser.parse("sum(/root/missing)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(0.0)
+    end
+  end
+
+  describe "count()" do
+    it "counts nodes" do
+      ast = Moxml::XPath::Parser.parse("count(/root/item)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(3.0)
+    end
+
+    it "returns 0 for empty nodeset" do
+      ast = Moxml::XPath::Parser.parse("count(/root/missing)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(0.0)
+    end
+  end
+
+  describe "floor()" do
+    it "rounds down positive number" do
+      ast = Moxml::XPath::Parser.parse("floor(3.7)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(3.0)
+    end
+
+    it "rounds down negative number" do
+      ast = Moxml::XPath::Parser.parse("floor(-3.2)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(-4.0)
+    end
+
+    it "leaves integer unchanged" do
+      ast = Moxml::XPath::Parser.parse("floor(5)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(5.0)
+    end
+  end
+
+  describe "ceiling()" do
+    it "rounds up positive number" do
+      ast = Moxml::XPath::Parser.parse("ceiling(3.2)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(4.0)
+    end
+
+    it "rounds up negative number" do
+      ast = Moxml::XPath::Parser.parse("ceiling(-3.7)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(-3.0)
+    end
+
+    it "leaves integer unchanged" do
+      ast = Moxml::XPath::Parser.parse("ceiling(5)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(5.0)
+    end
+  end
+
+  describe "round()" do
+    it "rounds to nearest (up)" do
+      ast = Moxml::XPath::Parser.parse("round(3.5)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(4.0)
+    end
+
+    it "rounds to nearest (down)" do
+      ast = Moxml::XPath::Parser.parse("round(3.4)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(3.0)
+    end
+
+    it "rounds negative numbers" do
+      ast = Moxml::XPath::Parser.parse("round(-3.5)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(-4.0)
+    end
+
+    it "leaves integer unchanged" do
+      ast = Moxml::XPath::Parser.parse("round(5)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq(5.0)
+    end
+  end
+end

data/spec/moxml/xpath/functions/position_functions_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XPath Position Functions" do
+  let(:context) { Moxml.new(:nokogiri) }
+
+  let(:doc) do
+    xml = <<~XML
+      <root>
+        <item>first</item>
+        <item>second</item>
+        <item>third</item>
+      </root>
+    XML
+    context.parse(xml)
+  end
+
+  describe "position()" do
+    it "raises error when used outside predicate" do
+      ast = Moxml::XPath::Parser.parse("position()")
+
+      expect do
+        Moxml::XPath::Compiler.compile_with_cache(ast)
+      end.to raise_error(
+        Moxml::XPath::InvalidContextError,
+        /position\(\) requires a predicate context/,
+      )
+    end
+
+    # These tests require predicate support to be implemented
+    # They are marked as pending until predicates are working
+    xit "returns current position in predicate" do
+      ast = Moxml::XPath::Parser.parse("/root/item[position() = 2]")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result.size).to eq(1)
+      expect(result.first.text).to eq("second")
+    end
+
+    xit "works with position comparison" do
+      ast = Moxml::XPath::Parser.parse("/root/item[position() > 1]")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result.size).to eq(2)
+      expect(result.map(&:text)).to eq(["second", "third"])
+    end
+  end
+
+  describe "last()" do
+    it "raises error when used outside predicate" do
+      ast = Moxml::XPath::Parser.parse("last()")
+
+      expect do
+        Moxml::XPath::Compiler.compile_with_cache(ast)
+      end.to raise_error(
+        Moxml::XPath::InvalidContextError,
+        /last\(\) requires a predicate context/,
+      )
+    end
+
+    # These tests require predicate support to be implemented
+    # They are marked as pending until predicates are working
+    xit "returns size of context in predicate" do
+      ast = Moxml::XPath::Parser.parse("/root/item[position() = last()]")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result.size).to eq(1)
+      expect(result.first.text).to eq("third")
+    end
+
+    xit "works with last() - 1" do
+      ast = Moxml::XPath::Parser.parse("/root/item[position() = last() - 1]")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result.size).to eq(1)
+      expect(result.first.text).to eq("second")
+    end
+
+    xit "works with comparison to last()" do
+      ast = Moxml::XPath::Parser.parse("/root/item[position() < last()]")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result.size).to eq(2)
+      expect(result.map(&:text)).to eq(["first", "second"])
+    end
+  end
+end

data/spec/moxml/xpath/functions/special_functions_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XPath Special Functions" do
+  let(:context) { Moxml.new(:nokogiri) }
+
+  describe "id()" do
+    let(:doc) do
+      xml = <<~XML
+        <root>
+          <item id="a">first</item>
+          <item id="b">second</item>
+          <item id="c">third</item>
+        </root>
+      XML
+      context.parse(xml)
+    end
+
+    it "finds node by single ID" do
+      ast = Moxml::XPath::Parser.parse('id("b")')
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be_a(Moxml::NodeSet)
+      expect(result.size).to eq(1)
+      expect(result.first.text).to eq("second")
+    end
+
+    it "finds multiple nodes by space-separated IDs" do
+      ast = Moxml::XPath::Parser.parse('id("a c")')
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be_a(Moxml::NodeSet)
+      expect(result.size).to eq(2)
+      expect(result.map(&:text)).to contain_exactly("first", "third")
+    end
+
+    it "returns empty nodeset for non-existent ID" do
+      ast = Moxml::XPath::Parser.parse('id("nonexistent")')
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be_a(Moxml::NodeSet)
+      expect(result.size).to eq(0)
+    end
+
+    it "handles multiple space-separated IDs" do
+      ast = Moxml::XPath::Parser.parse('id("b a")')
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be_a(Moxml::NodeSet)
+      expect(result.size).to eq(2)
+      expect(result.map(&:text)).to contain_exactly("first", "second")
+    end
+
+    it "ignores duplicate IDs" do
+      ast = Moxml::XPath::Parser.parse('id("a a b")')
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be_a(Moxml::NodeSet)
+      expect(result.map(&:text)).to include("first", "second")
+    end
+
+    # Test with nodeset argument - requires path evaluation
+    xit "accepts nodeset argument containing IDs" do
+      xml = <<~XML
+        <root>
+          <item id="a">first</item>
+          <item id="b">second</item>
+          <ref>a</ref>
+          <ref>b</ref>
+        </root>
+      XML
+      doc_with_refs = context.parse(xml)
+
+      ast = Moxml::XPath::Parser.parse("id(/root/ref)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc_with_refs)
+
+      expect(result).to be_a(Moxml::NodeSet)
+      expect(result.size).to eq(2)
+      expect(result.map(&:text)).to contain_exactly("first", "second")
+    end
+  end
+end