moxml 0.1.7 → 0.1.8

data/spec/moxml/text_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Text do
+  let(:context) { Moxml.new }
+  let(:doc) { context.parse("<root>plain text</root>") }
+
+  describe "#content" do
+    it "returns text content" do
+      text = doc.root.children.first
+      expect(text).to be_a(described_class)
+      expect(text.content).to eq("plain text")
+    end
+  end
+
+  describe "#to_xml" do
+    it "returns XML representation" do
+      text = doc.root.children.first
+      expect(text.to_xml).to eq("plain text")
+    end
+  end
+
+  describe "creation" do
+    it "creates a text node" do
+      text = doc.create_text("new text")
+      expect(text).to be_a(described_class)
+      expect(text.content).to eq("new text")
+    end
+  end
+end

data/spec/moxml/version_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Moxml::VERSION" do
+  it "has a version number" do
+    expect(Moxml::VERSION).not_to be_nil
+    expect(Moxml::VERSION).to be_a(String)
+  end
+
+  it "follows semantic versioning" do
+    expect(Moxml::VERSION).to match(/\d+\.\d+\.\d+/)
+  end
+end

data/spec/moxml/xml_utils/encoder_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::XmlUtils::Encoder do
+  describe "#call (encoding)" do
+    it "encodes XML special characters in basic mode" do
+      encoder = described_class.new("<tag>content & more</tag>", :basic)
+      result = encoder.call
+      expect(result).to include("&lt;")
+      expect(result).to include("&gt;")
+      expect(result).to include("&amp;")
+    end
+
+    it "encodes quotes in full mode" do
+      encoder = described_class.new('"value"', :full)
+      result = encoder.call
+      expect(result).to include("&quot;")
+    end
+
+    it "doesn't encode in none mode" do
+      encoder = described_class.new("<tag>", :none)
+      result = encoder.call
+      expect(result).to eq("<tag>")
+    end
+  end
+end

data/spec/moxml/xml_utils_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::XmlUtils do
+  # XmlUtils is a mixin module, create a test class that includes it
+  let(:test_class) do
+    Class.new do
+      include Moxml::XmlUtils
+    end
+  end
+  let(:utils) { test_class.new }
+
+  describe "#validate_declaration_version" do
+    it "validates XML versions" do
+      expect { utils.validate_declaration_version("1.0") }.not_to raise_error
+      expect { utils.validate_declaration_version("1.1") }.not_to raise_error
+    end
+
+    it "raises error for invalid version" do
+      expect do
+        utils.validate_declaration_version("2.0")
+      end.to raise_error(Moxml::ValidationError, "Invalid XML version: 2.0")
+    end
+  end
+
+  describe "#validate_declaration_encoding" do
+    it "validates encodings" do
+      expect { utils.validate_declaration_encoding("UTF-8") }.not_to raise_error
+      expect do
+        utils.validate_declaration_encoding("ISO-8859-1")
+      end.not_to raise_error
+    end
+  end
+
+  describe "#validate_element_name" do
+    it "validates element names" do
+      expect { utils.validate_element_name("root") }.not_to raise_error
+      expect { utils.validate_element_name("my-element") }.not_to raise_error
+    end
+
+    it "raises error for invalid names" do
+      expect do
+        utils.validate_element_name("123invalid")
+      end.to raise_error(Moxml::ValidationError,
+                         "Invalid XML element name: 123invalid")
+    end
+  end
+end

data/spec/moxml/xpath/ast/node_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::XPath::AST::Node do
+  describe "abstract interface" do
+    let(:node) { described_class.new }
+
+    describe "#evaluate" do
+      it "raises NotImplementedError" do
+        context = Moxml::XPath::Context.new
+        expect { node.evaluate(context) }.to raise_error(
+          NotImplementedError,
+          /#{described_class}#evaluate must be implemented by subclass/,
+        )
+      end
+    end
+
+    describe "#constant?" do
+      it "returns false by default" do
+        expect(node.constant?).to be(false)
+      end
+    end
+
+    describe "#result_type" do
+      it "returns :unknown by default" do
+        expect(node.result_type).to eq(:unknown)
+      end
+    end
+
+    describe "#inspect" do
+      it "returns class name representation" do
+        expect(node.inspect).to match(/^#<#{Regexp.escape(described_class.name)} @type=/)
+      end
+    end
+
+    describe "#to_s" do
+      it "aliases #inspect" do
+        expect(node.to_s).to eq(node.inspect)
+      end
+    end
+  end
+
+  describe "concrete implementation" do
+    # Create a test subclass to verify the interface works
+    let(:test_class) do
+      Class.new(described_class) do
+        def initialize(value)
+          @value = value
+        end
+
+        def evaluate(_context)
+          @value
+        end
+
+        def constant?
+          true
+        end
+
+        def result_type
+          :string
+        end
+      end
+    end
+
+    it "can be subclassed with custom evaluate" do
+      node = test_class.new("test_value")
+      context = Moxml::XPath::Context.new
+
+      expect(node.evaluate(context)).to eq("test_value")
+    end
+
+    it "can override constant?" do
+      node = test_class.new("test")
+      expect(node.constant?).to be(true)
+    end
+
+    it "can override result_type" do
+      node = test_class.new("test")
+      expect(node.result_type).to eq(:string)
+    end
+  end
+end

data/spec/moxml/xpath/axes_spec.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XPath Axes" do
+  let(:context) { Moxml.new(:nokogiri) }
+  let(:doc) do
+    xml = <<~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
+    context.parse(xml)
+  end
+
+  describe "Implemented Axes" do
+    it "lists all implemented axes" do
+      compiler = Moxml::XPath::Compiler.new
+
+      axes = [
+        "child", "self", "parent",
+        "descendant", "descendant_or_self", "attribute",
+        "ancestor", "ancestor_or_self",
+        "following_sibling", "preceding_sibling",
+        "following", "preceding", "namespace"
+      ]
+
+      implemented = axes.select do |axis|
+        compiler.respond_to?(:"on_axis_#{axis}", true)
+      end
+
+      puts "\nImplemented Axes: #{implemented.size}/13"
+      implemented.each { |a| puts "  ✓ #{a}" }
+
+      missing = axes - implemented
+      if missing.any?
+        puts "\nMissing Axes: #{missing.size}/13"
+        missing.each { |a| puts "  ✗ #{a}" }
+      end
+
+      # Expect at least 6 axes (3 original + 3 new critical axes)
+      expect(implemented.size).to be >= 6
+      expect(implemented).to include("child", "self", "parent")
+      expect(implemented).to include("descendant_or_self", "attribute",
+                                     "descendant")
+    end
+  end
+
+  describe "Critical Axes" do
+    describe "child axis" do
+      it "selects direct children only" do
+        ast = Moxml::XPath::Parser.parse("/root/child::parent")
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        result = proc.call(doc)
+
+        expect(result.size).to eq(1)
+        expect(result.first.attribute("id").value).to eq("p1")
+      end
+
+      it "does not select grandchildren" do
+        ast = Moxml::XPath::Parser.parse("/root/child::child")
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        result = proc.call(doc)
+
+        expect(result).to be_empty
+      end
+    end
+
+    describe "self axis" do
+      it "selects the context node" do
+        ast = Moxml::XPath::Parser.parse("/root/self::root")
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        result = proc.call(doc)
+
+        expect(result.size).to eq(1)
+        expect(result.first.name).to eq("root")
+      end
+    end
+
+    describe "parent axis" do
+      it "selects parent of children" do
+        ast = Moxml::XPath::Parser.parse("/root/parent/child/parent::parent")
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        result = proc.call(doc)
+
+        expect(result.size).to eq(2) # Two children, both have same parent
+        expect(result.first.attribute("id").value).to eq("p1")
+      end
+    end
+
+    describe "descendant-or-self axis (enables //)" do
+      it "finds all descendant nodes including self" do
+        ast = Moxml::XPath::Parser.parse("/root/descendant-or-self::root")
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        result = proc.call(doc)
+
+        expect(result.size).to eq(1)
+        expect(result.first.name).to eq("root")
+      end
+
+      it "finds deep descendants" do
+        ast = Moxml::XPath::Parser.parse("/root/descendant-or-self::grandchild")
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        result = proc.call(doc)
+
+        expect(result.size).to eq(2)
+        expect(result.map do |n|
+          n.attribute("id").value
+        end).to contain_exactly("g1", "g2")
+      end
+
+      it "powers the // operator" do
+        ast = Moxml::XPath::Parser.parse("//grandchild")
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        result = proc.call(doc)
+
+        expect(result.size).to eq(2)
+      end
+    end
+
+    describe "attribute axis (enables @)" do
+      let(:attr_doc) do
+        xml = <<~XML
+          <root>
+            <item id="1" name="first" type="A"/>
+            <item id="2" name="second" type="B"/>
+          </root>
+        XML
+        context.parse(xml)
+      end
+
+      it "selects specific attribute" do
+        ast = Moxml::XPath::Parser.parse("/root/item/attribute::id")
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        result = proc.call(attr_doc)
+
+        expect(result.size).to eq(2)
+        expect(result.map(&:value)).to contain_exactly("1", "2")
+      end
+
+      it "selects all attributes with wildcard" do
+        ast = Moxml::XPath::Parser.parse("/root/item/attribute::*")
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        result = proc.call(attr_doc)
+
+        # 2 items × 3 attributes each = 6
+        expect(result.size).to eq(6)
+      end
+
+      it "powers the @ operator" do
+        ast = Moxml::XPath::Parser.parse("/root/item/@name")
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        result = proc.call(attr_doc)
+
+        expect(result.size).to eq(2)
+        expect(result.map(&:value)).to contain_exactly("first", "second")
+      end
+    end
+
+    describe "descendant axis" do
+      it "finds descendants without self" do
+        ast = Moxml::XPath::Parser.parse("/root/descendant::child")
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        result = proc.call(doc)
+
+        expect(result.size).to eq(2)
+        expect(result.map do |n|
+          n.attribute("id").value
+        end).to contain_exactly("c1", "c2")
+      end
+
+      it "does not include context node" do
+        ast = Moxml::XPath::Parser.parse("/root/parent/descendant::parent")
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        result = proc.call(doc)
+
+        # Should not find parent itself, only descendants named parent
+        expect(result).to be_empty
+      end
+
+      it "finds all descendants at any depth" do
+        ast = Moxml::XPath::Parser.parse("/root/descendant::*")
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        result = proc.call(doc)
+
+        # parent + 2 children + 2 grandchildren = 5
+        expect(result.size).to eq(5)
+      end
+    end
+  end
+
+  describe "Axis + Predicate Combinations" do
+    let(:book_doc) do
+      xml = <<~XML
+        <library>
+          <book price="10" category="fiction">
+            <title>Book A</title>
+          </book>
+          <book price="20" category="tech">
+            <title>Book B</title>
+          </book>
+          <book price="15" category="fiction">
+            <title>Book C</title>
+          </book>
+        </library>
+      XML
+      context.parse(xml)
+    end
+
+    it "combines descendant-or-self with element test" do
+      ast = Moxml::XPath::Parser.parse("//book")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(book_doc)
+
+      expect(result.size).to eq(3)
+    end
+
+    it "combines attribute axis with wildcards" do
+      skip "HeadedOx limitation: Attribute wildcard (@*) not supported by XPath parser. See docs/HEADED_OX_LIMITATIONS.md"
+      ast = Moxml::XPath::Parser.parse("//book/@*")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(book_doc)
+
+      # 3 books × 2 attributes each = 6
+      expect(result.size).to eq(6)
+    end
+  end
+
+  describe "Real-world XPath Patterns" do
+    let(:complex_doc) do
+      xml = <<~XML
+        <catalog>
+          <section name="Programming">
+            <book id="b1" price="29.99">
+              <title lang="en">Ruby Programming</title>
+              <author>Matz</author>
+            </book>
+            <book id="b2" price="39.99">
+              <title lang="en">Python Programming</title>
+              <author>Guido</author>
+            </book>
+          </section>
+          <section name="Databases">
+            <book id="b3" price="49.99">
+              <title lang="en">PostgreSQL Essentials</title>
+              <author>Expert</author>
+            </book>
+          </section>
+        </catalog>
+      XML
+      context.parse(xml)
+    end
+
+    it "finds all books anywhere //book" do
+      ast = Moxml::XPath::Parser.parse("//book")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(complex_doc)
+
+      expect(result.size).to eq(3)
+    end
+
+    it "finds all titles anywhere //title" do
+      ast = Moxml::XPath::Parser.parse("//title")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(complex_doc)
+
+      expect(result.size).to eq(3)
+      expect(result.map(&:text)).to include("Ruby Programming",
+                                            "Python Programming", "PostgreSQL Essentials")
+    end
+
+    it "finds all price attributes //book/@price" do
+      ast = Moxml::XPath::Parser.parse("//book/@price")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(complex_doc)
+
+      expect(result.size).to eq(3)
+      expect(result.map(&:value)).to contain_exactly("29.99", "39.99", "49.99")
+    end
+
+    it "combines // with specific paths //section/book" do
+      ast = Moxml::XPath::Parser.parse("//section/book")
+      proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+      result = proc.call(complex_doc)
+
+      expect(result.size).to eq(3)
+    end
+  end
+end