moxml 0.1.26 → 0.3.0

data/spec/moxml/node_spec.rb

@@ -92,4 +92,108 @@ RSpec.describe Moxml::Node do
       expect(child.content).to eq("text")
     end
   end
+
+  describe "#ancestors" do
+    let(:doc) { context.parse("<library><section><book><title>Book 1</title></book></section></library>") }
+    let(:title) { doc.at_xpath("//title") }
+
+    it "returns ancestors from parent up to and including the document" do
+      ancestors = title.ancestors
+      expect(ancestors).to be_a(Moxml::NodeSet)
+      expect(ancestors.select(&:element?).map(&:name)).to eq(["book", "section", "library"])
+      expect(ancestors[3]).to be_a(Moxml::Document)
+    end
+
+    it "returns empty for the document" do
+      expect(doc.ancestors).to be_empty
+    end
+
+    it "returns the document for the root element" do
+      ancestors = doc.root.ancestors
+      expect(ancestors.size).to eq(1)
+      expect(ancestors.first).to be_a(Moxml::Document)
+    end
+  end
+
+  describe "#descendants" do
+    let(:doc) { context.parse("<section><book><title>Book 1</title></book></section>") }
+    let(:section) { doc.at_xpath("//section") }
+
+    it "returns all descendants excluding self" do
+      descendants = section.descendants
+      expect(descendants).to be_a(Moxml::NodeSet)
+      element_names = descendants.select(&:element?).map(&:name)
+      expect(element_names).to eq(["book", "title"])
+    end
+
+    it "includes text nodes" do
+      expect(section.descendants.any?(&:text?)).to be true
+    end
+
+    it "returns no elements for a leaf element" do
+      expect(doc.at_xpath("//title").descendants.select(&:element?)).to be_empty
+    end
+  end
+
+  describe "#path" do
+    %i[nokogiri oga rexml ox libxml].each do |adapter_name|
+      context "with #{adapter_name} adapter" do
+        let(:ctx) { Moxml.new(adapter_name) }
+        let(:doc) do
+          ctx.parse("<library><section><book id='1'/><book id='2'><title>Book 2</title></book></section></library>")
+        end
+        let(:first_book) { doc.root.children.find(&:element?).children.find { |c| c.element? && c.name == "book" && c["id"] == "1" } }
+        let(:second_book) { doc.root.children.find(&:element?).children.find { |c| c.element? && c.name == "book" && c["id"] == "2" } }
+        let(:title) { second_book.children.find(&:element?) }
+
+        it "builds the path without a predicate for uniquely named elements" do
+          expect(title.path).to eq("/library/section/book[2]/title")
+        end
+
+        it "adds a positional predicate for same-named siblings" do
+          expect(first_book.path).to eq("/library/section/book[1]")
+          expect(second_book.path).to eq("/library/section/book[2]")
+        end
+
+        it "locates the node via its path" do
+          # Ox translates only a limited XPath subset (no positional predicates)
+          skip "ox xpath translation does not support positional predicates" if adapter_name == :ox
+
+          expect(doc.at_xpath(title.path)).to eq(title)
+        end
+
+        it "returns / for the document" do
+          expect(doc.path).to eq("/")
+        end
+      end
+    end
+
+    it "raises for node types without a path representation" do
+      text = doc.root.children.first.children.first
+      expect { text.path }.to raise_error(Moxml::NotImplementedError, /element and document/)
+    end
+  end
+
+  describe "#line_number" do
+    %i[nokogiri oga rexml ox libxml].each do |adapter_name|
+      tracks_source_lines = adapter_name.eql?(:nokogiri) || adapter_name.eql?(:libxml)
+      context "with #{adapter_name} adapter" do
+        let(:ctx) { Moxml.new(adapter_name) }
+        let(:doc) do
+          ctx.parse("<?xml version='1.0'?>\n<library>\n  <book>\n    <title>Book 1</title>\n  </book>\n</library>\n")
+        end
+        let(:title) { doc.root.children.find(&:element?).children.find(&:element?) }
+
+        if tracks_source_lines
+          it "returns the 1-based source line" do
+            expect(title.line_number).to eq(4)
+          end
+        else
+          it "returns nil when the adapter does not track lines" do
+            expect(title.line_number).to be_nil
+          end
+        end
+      end
+    end
+  end
 end

data/spec/moxml/sax_entity_parity_spec.rb

@@ -0,0 +1,358 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Pins cross-adapter parity for entity-decoding in attribute values and
+# text content, across SAX, DOM, and build-then-serialize-then-reparse.
+# Previously the four adapters diverged: nokogiri/libxml SAX failed to
+# resolve "&#NN;"; rexml SAX delivered raw escaped strings; oga DOM
+# and SAX double-decoded.
+
+# Namespace-isolated container for the test data and the SAX capture
+# handler. Wrapping these in a module rather than declaring them as
+# top-level constants inside `RSpec.describe` keeps them out of the
+# global namespace and lets the spec reference them without tripping
+# the RSpec/* cops that forbid local-variable use inside examples.
+module SaxEntityParityFixtures
+  class CaptureHandler < Moxml::SAX::ElementHandler
+    attr_reader :first_attrs, :text
+
+    def initialize
+      super
+      @first_attrs = nil
+      @text = +""
+    end
+
+    def on_start_element(_name, attrs = {}, _namespaces = {})
+      @first_attrs = attrs.dup if @first_attrs.nil?
+    end
+
+    def on_characters(chunk)
+      @text << chunk
+    end
+  end
+
+  ADAPTERS = %i[nokogiri ox oga rexml libxml headed_ox].freeze
+
+  # Each row: [input XML, decoded attribute value, expected attribute
+  # value as it appears in the serialized XML]. The serialized form
+  # asserts what every adapter must emit byte-for-byte for the attribute.
+  ATTRIBUTE_CASES = {
+    "wrapped amp + decimal ref" => ['<doc x="&amp;#38;"/>', "&#38;", "&amp;#38;"],
+    "wrapped amp + hex ref" => ['<doc x="&amp;#x26;"/>', "&#x26;", "&amp;#x26;"],
+    "wrapped amp + non-std ref" => ['<doc x="&amp;copy;"/>', "&copy;", "&amp;copy;"],
+    "wrapped amp + lt" => ['<doc x="&amp;lt;"/>', "&lt;", "&amp;lt;"],
+    "wrapped amp + amp" => ['<doc x="&amp;amp;"/>', "&amp;", "&amp;amp;"],
+    "two amps" => ['<doc x="&amp;&amp;"/>', "&&", "&amp;&amp;"],
+    "plain amp" => ['<doc x="&amp;"/>', "&", "&amp;"],
+    "plain decimal ref" => ['<doc x="&#38;"/>', "&", "&amp;"],
+    "plain hex ref" => ['<doc x="&#x26;"/>', "&", "&amp;"],
+    "high codepoint" => ['<doc x="&#169;"/>', "©", "©"],
+    "no entities" => ['<doc x="plain"/>', "plain", "plain"],
+  }.freeze
+
+  # Each row: [input XML, decoded text, expected text as it appears in
+  # serialized XML].
+  TEXT_CASES = {
+    "text wrapped amp + decimal" => ["<doc>&amp;#38;</doc>", "&#38;", "&amp;#38;"],
+    "text wrapped amp + non-std" => ["<doc>&amp;copy;</doc>", "&copy;", "&amp;copy;"],
+    "text plain amp" => ["<doc>&amp;</doc>", "&", "&amp;"],
+  }.freeze
+
+  # XML 1.0 §2.6 — entity references inside PI content are NOT resolved.
+  # Every adapter must surface the literal source text. The libxml
+  # adapter previously decoded these five entities via a gsub chain in
+  # processing_instruction_content; pin each one explicitly.
+  PI_ENTITY_CASES = {
+    "&amp;" => "data &amp; more",
+    "&lt;" => "data &lt; more",
+    "&gt;" => "data &gt; more",
+    "&quot;" => "data &quot; more",
+    "&apos;" => "data &apos; more",
+  }.freeze
+
+  # Per-adapter overrides for the rebuild-path serialized form. Oga's
+  # set_attribute calls preprocess_entities which marks non-standard
+  # named entities so they survive serialization as "&name;" rather than
+  # being escaped to "&amp;name;". This is the entity-preservation
+  # feature documented in spec/moxml/adapter/entity_restoration_spec.rb
+  # and spec/moxml/adapter/oga_spec.rb — not a bug.
+  REBUILD_SERIALIZED_OVERRIDES = {
+    oga: {
+      "wrapped amp + non-std ref" => "&copy;",
+    },
+  }.freeze
+end
+
+RSpec.describe "SAX/DOM entity parity" do
+  SaxEntityParityFixtures::ADAPTERS.each do |adapter|
+    context "with #{adapter} adapter" do
+      let(:ctx) { Moxml.new(adapter) }
+
+      SaxEntityParityFixtures::ATTRIBUTE_CASES.each do |label, (xml, expected, expected_serialized)|
+        it "decodes attribute via SAX: #{label}" do
+          handler = SaxEntityParityFixtures::CaptureHandler.new
+          ctx.sax_parse(xml, handler)
+          expect(handler.first_attrs["x"]).to eq(expected)
+        end
+
+        it "decodes attribute via DOM: #{label}" do
+          expect(ctx.parse(xml).root["x"]).to eq(expected)
+        end
+
+        it "serializes attribute to expected XML form: #{label}" do
+          # End-to-end: parse → DOM access → set on fresh doc → serialize
+          # → assert exact serialized form. This pins what the consumer
+          # sees on the wire, not just what the parser delivers in memory.
+          parsed_value = ctx.parse(xml).root["x"]
+
+          doc2 = ctx.create_document
+          el = doc2.create_element("doc")
+          el["x"] = parsed_value
+          doc2.add_child(el)
+
+          serialized = doc2.to_xml.sub(/\A<\?[^>]*\?>\s*/, "")
+          expected_form = SaxEntityParityFixtures::REBUILD_SERIALIZED_OVERRIDES.dig(adapter, label) || expected_serialized
+          expect(serialized).to include(%(x="#{expected_form}"))
+        end
+
+        it "round-trips attribute through build+serialize+reparse: #{label}" do
+          parsed_value = ctx.parse(xml).root["x"]
+
+          doc2 = ctx.create_document
+          el = doc2.create_element("doc")
+          el["x"] = parsed_value
+          doc2.add_child(el)
+
+          serialized = doc2.to_xml.sub(/\A<\?[^>]*\?>/, "")
+          expect(ctx.parse(serialized).root["x"]).to eq(parsed_value)
+        end
+
+        it "re-serializes parsed document idempotently: #{label}" do
+          # Parse → serialize → re-parse → re-serialize → assert the two
+          # serializations match. This catches any non-idempotent
+          # mutations the adapter applies during the round-trip.
+          first = ctx.parse(xml).to_xml.sub(/\A<\?[^>]*\?>\s*/, "")
+          second = ctx.parse(first).to_xml.sub(/\A<\?[^>]*\?>\s*/, "")
+          expect(second).to eq(first)
+        end
+      end
+
+      SaxEntityParityFixtures::TEXT_CASES.each do |label, (xml, expected, expected_serialized)|
+        it "decodes text via SAX: #{label}" do
+          handler = SaxEntityParityFixtures::CaptureHandler.new
+          ctx.sax_parse(xml, handler)
+          expect(handler.text).to eq(expected)
+        end
+
+        it "decodes text via DOM: #{label}" do
+          expect(ctx.parse(xml).root.text).to eq(expected)
+        end
+
+        it "serializes text to expected XML form: #{label}" do
+          serialized = ctx.parse(xml).to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+          expect(serialized).to include(">#{expected_serialized}<")
+        end
+      end
+
+      it "does not double-escape '&' in a programmatically-built text node" do
+        # Pins the libxml customized Text#to_xml fix: an authored "&"
+        # must serialize to "&amp;" exactly once, never "&amp;amp;".
+        # Regression target for adapter/customized_libxml/text.rb where
+        # the previous implementation used #content (decoded text) and
+        # lost the "&" → "&amp;" escape, and earlier variants risked
+        # double-escaping on round-trip.
+        doc = ctx.create_document
+        el = doc.create_element("doc")
+        el.add_child("a & b")
+        doc.add_child(el)
+
+        serialized = doc.to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+        expect(serialized).to include(">a &amp; b<")
+        expect(serialized).not_to include("&amp;amp;")
+
+        # And the round-trip must preserve the original text exactly.
+        reparsed_text = ctx.parse(serialized).root.text
+        expect(reparsed_text).to eq("a & b")
+      end
+
+      it "mutates in-tree text node content without double-escaping '&'" do
+        # Pins the libxml fix for set_text_content on attached text
+        # nodes: libxml-ruby's #content= setter pre-escapes the input,
+        # and #to_s escapes again on serialization. The adapter must
+        # replace the in-tree node with a fresh raw-storage node to
+        # avoid silent double-escape data corruption.
+        doc = ctx.create_document
+        el = doc.create_element("doc")
+        text = doc.create_text("placeholder")
+        el.add_child(text)
+        doc.add_child(el)
+
+        text.content = "a & b"
+        expect(text.content).to eq("a & b")
+
+        serialized = doc.to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+        expect(serialized).to include(">a &amp; b<")
+        expect(serialized).not_to include("&amp;amp;")
+        expect(ctx.parse(serialized).root.text).to eq("a & b")
+      end
+
+      it "mutates in-tree PI content verbatim without escaping" do
+        # Pins the libxml fix for set_processing_instruction_content
+        # on attached PI nodes: libxml-ruby's #content= setter pre-
+        # escapes quotes and ampersands, but XML 1.0 §2.6 specifies
+        # PI content is verbatim — entity references are not resolved
+        # and no escaping is required on serialization.
+        doc = ctx.create_document
+        el = doc.create_element("doc")
+        pi = doc.create_processing_instruction("target", "placeholder")
+        el.add_child(pi)
+        doc.add_child(el)
+
+        pi.content = 'a " & b'
+        expect(pi.content.strip).to eq('a " & b')
+
+        serialized = doc.to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+        expect(serialized).to include('a " & b?>')
+        expect(serialized).not_to include("&quot;")
+        expect(serialized).not_to include("&amp;")
+        reparsed = ctx.parse(serialized).root.children.find do |c|
+          c.is_a?(Moxml::ProcessingInstruction)
+        end
+        expect(reparsed.content.strip).to eq('a " & b')
+      end
+
+      it "mutates unparented text/PI content before adoption into the tree" do
+        # Pins the swap_native_in_place early-return when parent is nil:
+        # set_text_content / set_processing_instruction_content called
+        # before the node is added to any element must still replace the
+        # wrapper's @native with a fresh raw-storage node, so the value
+        # survives correctly once the node is later attached and serialized.
+        doc = ctx.create_document
+        el = doc.create_element("doc")
+
+        text = doc.create_text("placeholder")
+        text.content = "a & b"
+        pi = doc.create_processing_instruction("target", "placeholder")
+        pi.content = 'a " & b'
+
+        el.add_child(text)
+        el.add_child(pi)
+        doc.add_child(el)
+
+        serialized = doc.to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+        expect(serialized).to include(">a &amp; b<")
+        expect(serialized).to include('<?target a " & b?>')
+        expect(serialized).not_to include("&amp;amp;")
+      end
+
+      # Regressions around &amp; appearing inside contexts that Oga's
+      # source-level preprocessor must not touch (CDATA, comments,
+      # DOCTYPE) — verified across adapters to ensure parity holds.
+      it "preserves literal &amp; inside CDATA" do
+        doc = ctx.parse("<doc><![CDATA[a &amp; b]]></doc>")
+        expect(doc.root.text).to eq("a &amp; b")
+      end
+
+      it "preserves literal &amp; inside comment" do
+        doc = ctx.parse("<doc><!-- a &amp; b --></doc>")
+        comment = doc.root.children.find { |c| c.is_a?(Moxml::Comment) }
+        expect(comment.content.strip).to eq("a &amp; b")
+      end
+
+      it "preserves literal U+FFFC U+FFFC user data in attribute" do
+        xml = "<doc x=\"\u{FFFC}\u{FFFC} test\"/>"
+        expect(ctx.parse(xml).root["x"]).to eq("\u{FFFC}\u{FFFC} test")
+      end
+
+      it "preserves literal U+FDD0 U+FDD0 user data in attribute" do
+        # Single noncharacters near the Oga marker codepoints — must not
+        # collide with the internal DEFAULT_AMP_MARKER sentinel.
+        xml = "<doc x=\"\u{FDD0}\u{FDD0} test\"/>"
+        expect(ctx.parse(xml).root["x"]).to eq("\u{FDD0}\u{FDD0} test")
+      end
+
+      it "preserves the exact Oga DEFAULT_AMP_MARKER sequence in attribute (no amp)" do
+        # User data matching the default Oga marker codepoints with NO
+        # &amp; in the input — restore must not run, so the sequence
+        # survives intact.
+        xml = "<doc x=\"\u{FDD0}\u{FDD1}\u{FDD2} plain\"/>"
+        expect(ctx.parse(xml).root["x"]).to eq("\u{FDD0}\u{FDD1}\u{FDD2} plain")
+      end
+
+      it "preserves the exact Oga DEFAULT_AMP_MARKER sequence in attribute (with amp)" do
+        # User data matching the default Oga marker codepoints alongside
+        # an &amp; that the preprocessor would otherwise substitute.
+        # The adapter must pick a marker not present in user data so
+        # restore doesn't corrupt the original sequence.
+        xml = "<doc x=\"\u{FDD0}\u{FDD1}\u{FDD2} &amp; foo\"/>"
+        expect(ctx.parse(xml).root["x"]).to eq("\u{FDD0}\u{FDD1}\u{FDD2} & foo")
+      end
+
+      it "preserves the exact Oga DEFAULT_AMP_MARKER sequence in text" do
+        xml = "<doc>\u{FDD0}\u{FDD1}\u{FDD2} &amp; foo</doc>"
+        expect(ctx.parse(xml).root.text).to eq("\u{FDD0}\u{FDD1}\u{FDD2} & foo")
+      end
+
+      it "handles DOCTYPE with '[' in quoted system ID" do
+        # System ID containing a literal "[" before the internal subset
+        # opener — quote-aware DOCTYPE terminator must not pick "]>"
+        # based on the bracket inside the quoted string.
+        xml = %(<!DOCTYPE root SYSTEM "has[bracket"><root x="&amp;#38;"/>)
+        expect(ctx.parse(xml).root["x"]).to eq("&#38;")
+      end
+
+      it "handles bare DOCTYPE with '>' in quoted system ID" do
+        # Bare DOCTYPE (no internal subset) — the terminator is ">".
+        # A literal ">" inside the quoted SYSTEM id must not be treated
+        # as the end of the declaration. For the Oga adapter this also
+        # exercises find_block_terminator's quote-aware ">" scan; if
+        # the bare-DOCTYPE end was misidentified, the preprocessor
+        # would rewrite "&amp;" inside the remaining quoted ID region
+        # to DEFAULT_AMP_MARKER and leak it into the serialized doctype.
+        xml = %(<!DOCTYPE root SYSTEM "a>b&amp;c"><root x="&amp;#38;"/>)
+        expect(ctx.parse(xml).root["x"]).to eq("&#38;")
+      end
+
+      it "handles DOCTYPE with ']>' inside a quoted entity value" do
+        # Quote-aware DOCTYPE terminator must skip past a literal "]>"
+        # appearing inside a quoted ExternalID / ENTITY value so the
+        # internal subset terminator is matched correctly. For the Oga
+        # adapter this also exercises the source-level DOCTYPE skipper;
+        # native-DOCTYPE parsers must reach the same result.
+        xml = '<!DOCTYPE root [ <!ENTITY foo "]>"> ]><root x="&amp;#38;"/>'
+        expect(ctx.parse(xml).root["x"]).to eq("&#38;")
+      end
+
+      SaxEntityParityFixtures::PI_ENTITY_CASES.each do |entity_label, payload|
+        it "preserves literal #{entity_label} inside processing instruction" do
+          doc = ctx.parse("<doc><?target #{payload}?></doc>")
+          pi = doc.root.children.find { |c| c.is_a?(Moxml::ProcessingInstruction) }
+          expect(pi.content.strip).to eq(payload)
+        end
+      end
+    end
+  end
+
+  # Cross-adapter equivalence: feed the same XML into every adapter and
+  # assert all of them emit the same serialized attribute form. Catches
+  # any regression where one adapter starts to deviate from the rest.
+  describe "cross-adapter serialization equivalence" do
+    def serialize_via(adapter, xml)
+      ctx = Moxml.new(adapter)
+      ctx.parse(xml).to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+    end
+
+    SaxEntityParityFixtures::ATTRIBUTE_CASES.each do |label, (xml, _expected, expected_serialized)|
+      it "every adapter emits the same attribute form: #{label}" do
+        results = SaxEntityParityFixtures::ADAPTERS.to_h { |a| [a, serialize_via(a, xml)] }
+        results.each do |a, out|
+          expect(out).to(
+            include(%(x="#{expected_serialized}")),
+            "#{a} produced #{out.inspect}",
+          )
+        end
+      end
+    end
+  end
+end

data/spec/moxml/xml_emitter_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::XmlEmitter do
+  describe ".escape_text" do
+    it "escapes only & < > in a single pass" do
+      expect(described_class.escape_text("a & < > ' \""))
+        .to eq("a &amp; &lt; &gt; ' \"")
+    end
+
+    it "returns clean strings unallocated" do
+      input = "clean"
+      expect(described_class.escape_text(input)).to equal(input)
+    end
+
+    it "coerces non-strings" do
+      expect(described_class.escape_text(1)).to eq("1")
+    end
+  end
+
+  describe ".escape_attribute" do
+    it "escapes & < > and double quotes, keeping apostrophes literal" do
+      expect(described_class.escape_attribute(%q{& < > ' "}))
+        .to eq("&amp; &lt; &gt; ' &quot;")
+    end
+  end
+
+  describe ".cdata" do
+    it "wraps content in a CDATA section" do
+      expect(described_class.cdata("data")).to eq("<![CDATA[data]]>")
+    end
+
+    it "splits an embedded end sequence into adjacent sections" do
+      expect(described_class.cdata("a]]>b"))
+        .to eq("<![CDATA[a]]]]><![CDATA[>b]]>")
+    end
+  end
+
+  describe ".declaration_xml" do
+    it "renders only the set attributes" do
+      expect(described_class.declaration_xml("1.0", nil, nil))
+        .to eq('<?xml version="1.0"?>')
+      expect(described_class.declaration_xml("1.0", "UTF-8", "yes"))
+        .to eq('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>')
+    end
+
+    it "omits empty encodings" do
+      expect(described_class.declaration_xml("1.0", "", nil))
+        .to eq('<?xml version="1.0"?>')
+    end
+  end
+
+  describe ".doctype_xml" do
+    it "renders PUBLIC and SYSTEM forms and bare names" do
+      expect(described_class.doctype_xml("r", "pub", "sys"))
+        .to eq('<!DOCTYPE r PUBLIC "pub" "sys">')
+      expect(described_class.doctype_xml("r", nil, "sys"))
+        .to eq('<!DOCTYPE r SYSTEM "sys">')
+      expect(described_class.doctype_xml("r", nil, nil))
+        .to eq("<!DOCTYPE r>")
+    end
+  end
+end

data/spec/moxml/xpath/axes_spec.rb

@@ -163,6 +163,118 @@ RSpec.describe "XPath Axes" do
       end
     end
 
+    describe "attribute axis with namespaces" do
+      let(:ns_doc) do
+        xml = <<~XML
+          <root xmlns:p="http://x.org" xmlns:q="http://x.org">
+            <item q:type="namespaced" type="bare" other="o"/>
+          </root>
+        XML
+        context.parse(xml)
+      end
+
+      def select(expression, namespaces = nil)
+        ast = Moxml::XPath::Parser.parse(expression)
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast,
+                                                         namespaces: namespaces)
+        proc.call(ns_doc).map(&:value)
+      end
+
+      it "matches bare names against no-namespace attributes only" do
+        expect(select("/root/item/@type")).to eq(["bare"])
+      end
+
+      it "matches prefixed names by namespace URI, not by prefix spelling" do
+        expect(select("/root/item/@p:type")).to eq(["namespaced"])
+        expect(select("/root/item/@q:type")).to eq(["namespaced"])
+      end
+
+      it "matches any local name within a prefix's namespace" do
+        expect(select("/root/item/@q:*")).to eq(["namespaced"])
+      end
+
+      it "matches nothing for an undeclared prefix" do
+        expect(select("/root/item/@z:type")).to be_empty
+      end
+
+      it "prefers context prefix mappings over document declarations" do
+        expect(select("/root/item/@p:type", "p" => "http://other.org"))
+          .to be_empty
+        expect(select("/root/item/@zzz:type", "zzz" => "http://x.org"))
+          .to eq(["namespaced"])
+      end
+    end
+
+    describe "ancestor and sibling axes" do
+      let(:family) do
+        context.parse("<root><parent id='p1'><b id='1'/><b id='2'/><c/><d/></parent></root>")
+      end
+
+      def select(expression, node = family)
+        ast = Moxml::XPath::Parser.parse(expression)
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        proc.call(node).map(&:name)
+      end
+
+      it "selects ancestors with ancestor::" do
+        expect(select("//c/ancestor::*")).to eq(%w[parent root])
+      end
+
+      it "includes the context node with ancestor-or-self::" do
+        expect(select("//c/ancestor-or-self::*")).to eq(%w[c parent root])
+      end
+
+      it "selects following siblings" do
+        expect(select("//c/following-sibling::*")).to eq(%w[d])
+        expect(select("//b[@id='1']/following-sibling::b")).to eq(%w[b])
+        expect(select("//b[@id='1']/following-sibling::*").size).to eq(3)
+      end
+
+      it "selects preceding siblings" do
+        expect(select("//c/preceding-sibling::*")).to eq(%w[b b])
+      end
+
+      it "resolves the bare parent step and steps after it" do
+        expect(select("//c/..")).to eq(%w[parent])
+        expect(select("//c/../*").size).to eq(4)
+      end
+
+      it "raises a clear error for unimplemented axes" do
+        expect { select("//c/following::*") }
+          .to raise_error(Moxml::XPath::Error, /not supported/)
+      end
+    end
+
+    describe "descendant-or-self shorthand from an element" do
+      it "selects descendants with .//step" do
+        ast = Moxml::XPath::Parser.parse(".//grandchild")
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        result = proc.call(doc.root.children.find(&:element?))
+
+        expect(result.map { |n| n.attribute("id").value })
+          .to contain_exactly("g1", "g2")
+      end
+    end
+
+    describe "node type tests as steps" do
+      it "selects text nodes with text()" do
+        ast = Moxml::XPath::Parser.parse("//grandchild/text()")
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        result = proc.call(doc)
+
+        expect(result.map(&:content)).to contain_exactly("text1", "text2")
+      end
+
+      it "selects comments with comment()" do
+        commented = context.parse("<root><!-- c1 --><a/><!-- c2 --></root>")
+        ast = Moxml::XPath::Parser.parse("//comment()")
+        proc = Moxml::XPath::Compiler.compile_with_cache(ast)
+        result = proc.call(commented)
+
+        expect(result.map(&:content)).to contain_exactly(" c1 ", " c2 ")
+      end
+    end
+
     describe "descendant axis" do
       it "finds descendants without self" do
         ast = Moxml::XPath::Parser.parse("/root/descendant::child")

data/spec/moxml/xpath/parser_spec.rb

@@ -60,6 +60,12 @@ RSpec.describe Moxml::XPath::Parser do
         expect(ast.type).to eq(:relative_path)
       end
 
+      it "parses prefixed attribute names" do
+        ast = described_class.parse("@xmi:type")
+        expect(ast.type).to eq(:relative_path)
+        expect { described_class.parse("@xmi:*") }.not_to raise_error
+      end
+
       it "parses path with parent reference" do
         ast = described_class.parse("../book")
         expect(ast.type).to eq(:relative_path)

data/spec/moxml/xpath_capabilities_spec.rb

@@ -131,11 +131,13 @@ RSpec.describe "XPath Capabilities" do
       end
 
       describe "XPath functions" do
-        it "supports count() function" do
+        it "supports count() function, returning the scalar unwrapped" do
           doc = Moxml.new.parse(simple_xml)
-          # NOTE: count() returns a number, not nodes
           result = doc.xpath("count(//book)")
-          expect(result).to be_a(Numeric) if result.is_a?(Numeric)
+          # REXML's XPath has no function support and yields an empty set
+          skip "count() function not supported on #{adapter_name}" if result.is_a?(Moxml::NodeSet)
+
+          expect(result).to eq(2)
         rescue Moxml::XPathError, NoMethodError
           skip "count() function not supported on #{adapter_name}"
         end