moxml 0.1.7 → 0.1.8

data/spec/moxml/xpath/conversion_spec.rb

@@ -0,0 +1,365 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::XPath::Conversion do
+  let(:context) { Moxml.new }
+
+  describe ".to_string" do
+    it "converts integers to strings" do
+      expect(described_class.to_string(42)).to eq("42")
+    end
+
+    it "converts floats with zero decimal to integers first" do
+      expect(described_class.to_string(10.0)).to eq("10")
+    end
+
+    it "preserves non-zero decimals in floats" do
+      expect(described_class.to_string(10.5)).to eq("10.5")
+    end
+
+    it "converts strings to themselves" do
+      expect(described_class.to_string("hello")).to eq("hello")
+    end
+
+    it "converts true to string" do
+      expect(described_class.to_string(true)).to eq("true")
+    end
+
+    it "converts false to string" do
+      expect(described_class.to_string(false)).to eq("false")
+    end
+
+    it "converts nil to empty string" do
+      expect(described_class.to_string(nil)).to eq("")
+    end
+
+    context "with NodeSet" do
+      it "returns text of first node" do
+        doc = context.parse("<root><item>first</item><item>second</item></root>")
+        nodes = doc.xpath("//item")
+
+        expect(described_class.to_string(nodes)).to eq("first")
+      end
+
+      it "returns empty string for empty NodeSet" do
+        doc = context.parse("<root></root>")
+        nodes = doc.xpath("//item")
+
+        expect(described_class.to_string(nodes)).to eq("")
+      end
+    end
+
+    context "with nodes that respond to text" do
+      it "returns the text content of the node" do
+        doc = context.parse("<root>Hello World</root>")
+        node = doc.xpath("//root").first
+
+        expect(described_class.to_string(node)).to eq("Hello World")
+      end
+    end
+  end
+
+  describe ".to_float" do
+    it "converts integers to floats" do
+      expect(described_class.to_float(42)).to eq(42.0)
+    end
+
+    it "converts floats to themselves" do
+      expect(described_class.to_float(10.5)).to eq(10.5)
+    end
+
+    it "converts numeric strings to floats" do
+      expect(described_class.to_float("42.5")).to eq(42.5)
+    end
+
+    it "converts true to 1.0" do
+      expect(described_class.to_float(true)).to eq(1.0)
+    end
+
+    it "converts false to 0.0" do
+      expect(described_class.to_float(false)).to eq(0.0)
+    end
+
+    it "returns NaN for non-numeric strings" do
+      result = described_class.to_float("not a number")
+      expect(result).to be_nan
+    end
+
+    it "returns NaN for nil" do
+      result = described_class.to_float(nil)
+      expect(result).to be_nan
+    end
+
+    it "returns NaN for empty string" do
+      result = described_class.to_float("")
+      expect(result).to be_nan
+    end
+
+    context "with NodeSet" do
+      it "converts text of first node to float" do
+        doc = context.parse("<root><item>42.5</item></root>")
+        nodes = doc.xpath("//item")
+
+        expect(described_class.to_float(nodes)).to eq(42.5)
+      end
+
+      it "returns NaN for empty NodeSet" do
+        doc = context.parse("<root></root>")
+        nodes = doc.xpath("//item")
+
+        result = described_class.to_float(nodes)
+        expect(result).to be_nan
+      end
+
+      it "returns NaN for non-numeric node text" do
+        doc = context.parse("<root><item>hello</item></root>")
+        nodes = doc.xpath("//item")
+
+        result = described_class.to_float(nodes)
+        expect(result).to be_nan
+      end
+    end
+
+    context "with nodes that respond to text" do
+      it "converts node text to float" do
+        doc = context.parse("<root>123.45</root>")
+        node = doc.xpath("//root").first
+
+        expect(described_class.to_float(node)).to eq(123.45)
+      end
+    end
+  end
+
+  describe ".to_boolean" do
+    context "with floats" do
+      it "returns true for positive floats" do
+        expect(described_class.to_boolean(1.5)).to be(true)
+      end
+
+      it "returns false for zero" do
+        expect(described_class.to_boolean(0.0)).to be(false)
+      end
+
+      it "returns true for negative floats" do
+        expect(described_class.to_boolean(-1.5)).to be(true)
+      end
+
+      it "returns false for NaN" do
+        expect(described_class.to_boolean(Float::NAN)).to be(false)
+      end
+    end
+
+    context "with integers" do
+      it "returns true for positive integers" do
+        expect(described_class.to_boolean(42)).to be(true)
+      end
+
+      it "returns false for zero" do
+        expect(described_class.to_boolean(0)).to be(false)
+      end
+
+      it "returns true for negative integers" do
+        expect(described_class.to_boolean(-42)).to be(true)
+      end
+    end
+
+    context "with strings" do
+      it "returns true for non-empty strings" do
+        expect(described_class.to_boolean("hello")).to be(true)
+      end
+
+      it "returns false for empty strings" do
+        expect(described_class.to_boolean("")).to be(false)
+      end
+    end
+
+    context "with arrays" do
+      it "returns true for non-empty arrays" do
+        expect(described_class.to_boolean([1, 2, 3])).to be(true)
+      end
+
+      it "returns false for empty arrays" do
+        expect(described_class.to_boolean([])).to be(false)
+      end
+    end
+
+    context "with NodeSets" do
+      it "returns true for non-empty NodeSets" do
+        doc = context.parse("<root><item/></root>")
+        nodes = doc.xpath("//item")
+
+        expect(described_class.to_boolean(nodes)).to be(true)
+      end
+
+      it "returns false for empty NodeSets" do
+        doc = context.parse("<root></root>")
+        nodes = doc.xpath("//item")
+
+        expect(described_class.to_boolean(nodes)).to be(false)
+      end
+    end
+
+    context "with true/false" do
+      it "returns true for true" do
+        expect(described_class.to_boolean(true)).to be(true)
+      end
+
+      it "returns false for false" do
+        expect(described_class.to_boolean(false)).to be(false)
+      end
+    end
+
+    context "with nil" do
+      it "returns false for nil" do
+        expect(described_class.to_boolean(nil)).to be(false)
+      end
+    end
+
+    context "with other objects" do
+      it "returns true for any truthy object" do
+        expect(described_class.to_boolean(Object.new)).to be(true)
+      end
+    end
+  end
+
+  describe ".to_compatible_types" do
+    it "converts NodeSet to string when compared with another value" do
+      doc = context.parse("<root><item>hello</item></root>")
+      nodes = doc.xpath("//item")
+
+      left, right = described_class.to_compatible_types(nodes, "world")
+      expect(left).to eq("hello")
+      expect(right).to eq("world")
+    end
+
+    it "converts node to string when compared with another value" do
+      doc = context.parse("<root>test</root>")
+      node = doc.xpath("//root").first
+
+      left, right = described_class.to_compatible_types(node, "other")
+      expect(left).to eq("test")
+      expect(right).to eq("other")
+    end
+
+    it "converts right operand to float when left is numeric" do
+      left, right = described_class.to_compatible_types(42, "10")
+      expect(left).to eq(42)
+      expect(right).to eq(10.0)
+    end
+
+    it "converts right operand to string when left is string" do
+      left, right = described_class.to_compatible_types("hello", 42)
+      expect(left).to eq("hello")
+      expect(right).to eq("42")
+    end
+
+    it "converts right operand to boolean when left is boolean" do
+      left, right = described_class.to_compatible_types(true, "non-empty")
+      expect(left).to be(true)
+      expect(right).to be(true)
+    end
+
+    it "handles both NodeSets" do
+      doc = context.parse("<root><a>text1</a><b>text2</b></root>")
+      nodes1 = doc.xpath("//a")
+      nodes2 = doc.xpath("//b")
+
+      left, right = described_class.to_compatible_types(nodes1, nodes2)
+      expect(left).to eq("text1")
+      expect(right).to eq("text2")
+    end
+
+    it "preserves compatible types" do
+      left, right = described_class.to_compatible_types(10, 20)
+      expect(left).to eq(10)
+      expect(right).to eq(20)
+    end
+
+    it "handles false boolean correctly" do
+      left, right = described_class.to_compatible_types(false, "text")
+      expect(left).to be(false)
+      expect(right).to be(true)
+    end
+  end
+
+  describe ".boolean?" do
+    it "returns true for true" do
+      expect(described_class.boolean?(true)).to be(true)
+    end
+
+    it "returns true for false" do
+      expect(described_class.boolean?(false)).to be(true)
+    end
+
+    it "returns false for integers" do
+      expect(described_class.boolean?(42)).to be(false)
+    end
+
+    it "returns false for strings" do
+      expect(described_class.boolean?("true")).to be(false)
+    end
+
+    it "returns false for nil" do
+      expect(described_class.boolean?(nil)).to be(false)
+    end
+
+    it "returns false for arrays" do
+      expect(described_class.boolean?([true])).to be(false)
+    end
+  end
+
+  describe ".first_node_text" do
+    it "returns text of first node in NodeSet" do
+      doc = context.parse("<root><item>first</item><item>second</item></root>")
+      nodes = doc.xpath("//item")
+
+      expect(described_class.first_node_text(nodes)).to eq("first")
+    end
+
+    it "returns empty string if first node does not respond to text" do
+      # Create a mock NodeSet with a node that doesn't respond to text
+      node_set = [double("node")]
+      allow(node_set).to receive(:[]).with(0).and_return(node_set[0])
+
+      expect(described_class.first_node_text(node_set)).to eq("")
+    end
+
+    it "handles nodes with empty text" do
+      doc = context.parse("<root><item></item></root>")
+      nodes = doc.xpath("//item")
+
+      expect(described_class.first_node_text(nodes)).to eq("")
+    end
+
+    it "handles nodes with whitespace text" do
+      doc = context.parse("<root><item>   </item></root>")
+      nodes = doc.xpath("//item")
+
+      expect(described_class.first_node_text(nodes)).to eq("   ")
+    end
+  end
+
+  describe "edge cases" do
+    it "handles Float::INFINITY in to_boolean" do
+      expect(described_class.to_boolean(Float::INFINITY)).to be(true)
+    end
+
+    it "handles -Float::INFINITY in to_boolean" do
+      expect(described_class.to_boolean(-Float::INFINITY)).to be(true)
+    end
+
+    it "handles scientific notation strings in to_float" do
+      expect(described_class.to_float("1.5e2")).to eq(150.0)
+    end
+
+    it "handles negative numbers in to_float" do
+      expect(described_class.to_float("-42.5")).to eq(-42.5)
+    end
+
+    it "handles very large numbers" do
+      large_num = 10**100
+      expect(described_class.to_string(large_num)).to eq(large_num.to_s)
+    end
+  end
+end

data/spec/moxml/xpath/fixtures/sample.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<library>
+  <book id="1" category="fiction">
+    <title lang="en">The Great Gatsby</title>
+    <author>F. Scott Fitzgerald</author>
+    <year>1925</year>
+    <price currency="USD">10.99</price>
+  </book>
+  <book id="2" category="fiction">
+    <title lang="en">To Kill a Mockingbird</title>
+    <author>Harper Lee</author>
+    <year>1960</year>
+    <price currency="USD">12.99</price>
+  </book>
+  <book id="3" category="non-fiction">
+    <title lang="en">Sapiens</title>
+    <author>Yuval Noah Harari</author>
+    <year>2011</year>
+    <price currency="USD">15.99</price>
+  </book>
+  <magazine id="4">
+    <title>Scientific American</title>
+    <issue number="12">December 2023</issue>
+  </magazine>
+</library>

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XPath Boolean Functions" do
+  let(:doc) do
+    xml = "<root><item/></root>"
+    Moxml.new(:nokogiri).parse(xml)
+  end
+
+  describe "boolean()" do
+    it "converts non-empty string to true" do
+      ast = Moxml::XPath::Parser.parse('boolean("text")')
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be true
+    end
+
+    it "converts empty string to false" do
+      ast = Moxml::XPath::Parser.parse('boolean("")')
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be false
+    end
+
+    it "converts non-zero number to true" do
+      ast = Moxml::XPath::Parser.parse("boolean(1)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be true
+    end
+
+    it "converts zero to false" do
+      ast = Moxml::XPath::Parser.parse("boolean(0)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be false
+    end
+
+    it "converts NaN to false" do
+      ast = Moxml::XPath::Parser.parse('boolean(number("not-a-number"))')
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be false
+    end
+  end
+
+  describe "not()" do
+    it "negates true" do
+      ast = Moxml::XPath::Parser.parse("not(true())")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be false
+    end
+
+    it "negates false" do
+      ast = Moxml::XPath::Parser.parse("not(false())")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be true
+    end
+
+    it "negates non-empty string" do
+      ast = Moxml::XPath::Parser.parse('not("text")')
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be false
+    end
+
+    it "negates empty string" do
+      ast = Moxml::XPath::Parser.parse('not("")')
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be true
+    end
+
+    it "negates number" do
+      ast = Moxml::XPath::Parser.parse("not(0)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be true
+    end
+  end
+
+  describe "true()" do
+    it "returns true" do
+      ast = Moxml::XPath::Parser.parse("true()")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be true
+    end
+  end
+
+  describe "false()" do
+    it "returns false" do
+      ast = Moxml::XPath::Parser.parse("false()")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to be false
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XPath Node Functions" do
+  let(:context) { Moxml.new(:nokogiri) }
+
+  let(:doc) do
+    xml = <<~XML
+      <root xmlns:ns="http://example.com">
+        <ns:item>namespaced</ns:item>
+        <child id="123">content</child>
+      </root>
+    XML
+    context.parse(xml)
+  end
+
+  describe "local-name()" do
+    it "returns local name without namespace prefix" do
+      ast = Moxml::XPath::Parser.parse("local-name(/root/child)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq("child")
+    end
+
+    it "returns local name for namespaced element" do
+      ast = Moxml::XPath::Parser.parse("local-name(/root/*[1])")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq("item")
+    end
+
+    it "returns empty string for no argument on non-element" do
+      ast = Moxml::XPath::Parser.parse("local-name()")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      root = doc.root
+      result = proc.call(root)
+
+      expect(result).to eq("root")
+    end
+  end
+
+  describe "name()" do
+    it "returns qualified name for element" do
+      ast = Moxml::XPath::Parser.parse("name(/root/child)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq("child")
+    end
+
+    it "returns qualified name with namespace prefix" do
+      ast = Moxml::XPath::Parser.parse("name(/root/*[1])")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      # Depending on adapter, may include ns: prefix
+      expect(result).to match(/item/)
+    end
+
+    it "returns empty string when no node matched" do
+      ast = Moxml::XPath::Parser.parse("name(/nonexistent)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq("")
+    end
+  end
+
+  describe "namespace-uri()" do
+    it "returns empty string for element without namespace" do
+      ast = Moxml::XPath::Parser.parse("namespace-uri(/root/child)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq("")
+    end
+
+    it "returns namespace URI for namespaced element" do
+      ast = Moxml::XPath::Parser.parse("namespace-uri(/root/*[1])")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq("http://example.com")
+    end
+
+    it "returns empty string when no node matched" do
+      ast = Moxml::XPath::Parser.parse("namespace-uri(/nonexistent)")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(doc)
+
+      expect(result).to eq("")
+    end
+  end
+
+  describe "lang()" do
+    let(:doc_with_lang) do
+      xml = <<~XML
+        <root xml:lang="en">
+          <child>text</child>
+          <other xml:lang="fr">french</other>
+        </root>
+      XML
+      context.parse(xml)
+    end
+
+    it "matches language on element with xml:lang" do
+      ast = Moxml::XPath::Parser.parse('lang("en")')
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      root = doc_with_lang.root
+      result = proc.call(root)
+
+      expect(result).to be true
+    end
+
+    it "does not match wrong language" do
+      ast = Moxml::XPath::Parser.parse('lang("fr")')
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      root = doc_with_lang.root
+      result = proc.call(root)
+
+      expect(result).to be false
+    end
+
+    it "inherits language from parent element" do
+      ast = Moxml::XPath::Parser.parse('lang("en")')
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      child = doc_with_lang.root.children.first
+      result = proc.call(child)
+
+      expect(result).to be true
+    end
+
+    it "uses closest xml:lang attribute" do
+      ast = Moxml::XPath::Parser.parse('lang("fr")')
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      other = doc_with_lang.root.children[1]
+      result = proc.call(other)
+
+      expect(result).to be true
+    end
+  end
+end