moxml 0.5.143 → 0.5.146

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7ef456b1833d080915877e15238d23fd1e3d38bd638a434711bc98d423b78fc
-  data.tar.gz: 680fe1bbe7097895d5fdb46c29e5e2c624b13ed29792be2ffa941ef3c8bbe3bb
+  metadata.gz: b529948a14e67202c6ad6fc9acbe6c06c033ba022f93ada6bc9e4001554ea583
+  data.tar.gz: 68a76e1a69397aef0d0356e3ddd7bc200737a41333a70d6688cfca34d44e4c27
 SHA512:
-  metadata.gz: 01e458bb31733bbb8a9bf379d37ba30b4d5b30d1670eceffbfad5ae953afa85f1dc272ce3cc99cf719808417a13035dadf00e14fdb6a01d5cce3f4bcc855e8ac
-  data.tar.gz: e0eae403141507dcc8dd23e3b6962935cac3481382ef268a41105ae919e014fc53e657e4b44d261cdb8e59799678dc0a2f1f103937580ee6bb7b8f4e93372667
+  metadata.gz: 3775a27419325f8c764d6d686c547e88f75bdc073cbe354bdd97d2e0516e68a4f83896d4cd840c25be26f7d6aafdca24a596d3c6aa2893e8596ed95d646c16fa
+  data.tar.gz: 84c2f0abec2a55d990cdc921f9abac0c9206def8190d609fd298256dd035d586334dedc04bb97af496a98fe9053b2fa3b65f716a11e22e94516f2f8b91837e1b

data/lib/moxml/adapter/leptris.rb

@@ -463,25 +463,72 @@ module Moxml
           # instances). The hot bare reads super into the C methods
           # (exact-name = the bare-name contract).
           module Identity
+            # The C faces are captured before the contract modules
+            # shadow them — alias copies bind at this point, so the
+            # overrides below plain-dispatch the native reads
+            # (leptris-ruby#463 completed the surface: every contract
+            # face is a C method at 50-84ns).
             ELEMENT = Class.new(::Leptris::XML::NativeNode) do
+              alias_method :native_name, :name
               include ::Moxml::Node
               include ::Moxml::Element
+
+              # Memo form kept: a warm read is an ivar hit (~30ns
+              # vs the C call's 84ns); the cold read drops the
+              # adapter round-trip and its PI-check bind_call.
+              def name
+                @name ||= native_name
+              end
             end
             TEXT = Class.new(::Leptris::XML::NativeNode) do
+              alias_method :native_content, :content
               include ::Moxml::Node
               include ::Moxml::Text
+
+              # Text#content's memo + entity restore are the
+              # contract; the backing read drops the adapter
+              # round-trip (dispatch + is_a? + bind_call) for the
+              # C face.
+              def raw_content
+                native_content
+              end
             end
             CDATA = Class.new(::Leptris::XML::NativeNode) do
+              alias_method :native_content, :content
               include ::Moxml::Node
               include ::Moxml::Cdata
+
+              def content
+                native_content
+              end
             end
             COMMENT = Class.new(::Leptris::XML::NativeNode) do
+              alias_method :native_content, :content
               include ::Moxml::Node
               include ::Moxml::Comment
+
+              # The nil bridge stays for floor-admitted bindings
+              # where the native face answers nil for comment-kind
+              # (leptris-ruby#313).
+              def content
+                content = native_content
+                return ::Moxml::Adapter::Leptris.to_binding(self).content if content.nil?
+
+                content
+              end
             end
             PROCESSING_INSTRUCTION = Class.new(::Leptris::XML::NativeNode) do
+              alias_method :native_content, :content
               include ::Moxml::Node
               include ::Moxml::ProcessingInstruction
+
+              # Same nil bridge as Comment (leptris-ruby#344).
+              def content
+                content = native_content
+                return ::Moxml::Adapter::Leptris.to_binding(self).content if content.nil?
+
+                content
+              end
             end
 
             TYPES = {
@@ -537,6 +584,46 @@ module Moxml
             end
             ELEMENT.include(Reads)
             TEXT.include(Reads)
+
+            # leptris-ruby#503: name_read joins attr_read/text_read as
+            # the unshadowed contract faces. With them, the hot reads
+            # plain-dispatch the C faces (one Ruby frame over the
+            # ~45ns native call) instead of the adapter bind_call
+            # crossing. Face-probed — older bindings keep the
+            # adapter paths. The memos ride the existing
+            # invalidation: name= and clear_native_memo! clear
+            # @name, content= clears @content.
+            if NN.method_defined?(:name_read)
+              module ContractReads
+                def name
+                  @name ||= name_read
+                end
+              end
+              ELEMENT.include(ContractReads)
+            end
+
+            if NN.method_defined?(:text_read)
+              module TextContractReads
+                # The stamp fast path is inlined (same ivar protocol
+                # as Reads#doc_entity_bearing?, which stays the
+                # single writer on recompute) — the two frames it
+                # saves are ~20% of the cold read.
+                def content
+                  value = @content
+                  return value if value
+
+                  value = text_read
+                  stamp = @doc_entity_stamp
+                  if stamp && (stamp >> 1) == ::Moxml::Adapter::Leptris.serialize_generation
+                    value = ::Moxml::Adapter::Leptris.restore_entities(value) if stamp.allbits?(1)
+                  elsif doc_entity_bearing?
+                    value = ::Moxml::Adapter::Leptris.restore_entities(value)
+                  end
+                  @content = value
+                end
+              end
+              TEXT.include(TextContractReads)
+            end
           end
 
           # leptris-ruby#246 klass-propagating reads: the read
@@ -2842,6 +2929,7 @@ module Moxml
         PARENT_AXIS_CACHE = XPath::Cache.new(100)
 
         def xpath(node, expression, namespaces = {})
+          namespaces = normalize_xpath_namespaces(namespaces)
           node = to_binding(node) if NATIVE_READ_LAYER
           native = native_xpath(node, expression, namespaces)
           return native unless native.nil?
@@ -2873,6 +2961,7 @@ module Moxml
         end
 
         def at_xpath(node, expression, namespaces = {})
+          namespaces = normalize_xpath_namespaces(namespaces)
           native = native_xpath(node, expression, namespaces, first_only: true)
           return native unless native.nil?
 
@@ -2880,6 +2969,16 @@ module Moxml
           result.is_a?(Array) ? result.first : result
         end
 
+        # Bindings arrive in both spellings (symbol keys are the
+        # common Nokogiri idiom); every seam below — the "xmlns"
+        # reserved-key check and the native pairs set — is
+        # string-keyed (issue #395).
+        def normalize_xpath_namespaces(namespaces)
+          return namespaces unless namespaces.is_a?(Hash)
+
+          namespaces.transform_keys(&:to_s)
+        end
+
         # @return [Array, Object, nil] native results, or nil when the
         #   query must run on the Ruby engine
         def native_xpath(node, expression, namespaces, first_only: false)

data/lib/moxml/adapter/rexml.rb

@@ -607,6 +607,11 @@ module Moxml
           # XPath.match for every expression: get_elements only
           # handles simple child-name paths — attribute terminals,
           # absolute paths and predicates silently degrade there.
+          # REXML resolves prefixes by string spelling — symbol-keyed
+          # bindings (the common Nokogiri idiom) must normalize or
+          # namespaced elements never match (issue #395).
+          namespaces = namespaces.transform_keys(&:to_s) if
+            namespaces.is_a?(Hash)
           if namespaces && !namespaces.empty?
             ::REXML::XPath.match(node, expression, namespaces).to_a
           else

data/lib/moxml/document.rb

@@ -227,7 +227,21 @@ module Moxml
       self
     end
 
+    # Relative name-test paths on the document resolve laxly, as
+    # descendant-or-self anchored at the root — Nokogiri's own
+    # Document#at/#search semantics (moxml#393; its #xpath/#at_xpath are
+    # strict document-context, where the only element child is the root,
+    # and the adapters disagree there anyway: leptris's engine returns []
+    # for every relative path — leptris-ruby#502 — while Nokogiri's
+    # #at/#xpath disagree with each other). Every strict match survives
+    # the lax rewrite (the only strict-matchable first step is the root
+    # itself), so this is purely additive. Non-name-test expressions
+    # (axes, node types, ".", "..") keep document context.
+    RELATIVE_NAME_TEST = /\A\s*(\*|[A-Za-z_][\w.-]*)(\s*\[|\s*\||\z|\/)/
+
     def xpath(expression, namespaces = nil)
+      expression = lax_document_path(expression) if relative_name_test?(expression)
+
       result = adapter.xpath(@native, expression, namespaces)
 
       # Handle different result types:
@@ -246,6 +260,8 @@ module Moxml
     end
 
     def at_xpath(expression, namespaces = nil)
+      expression = lax_document_path(expression) if relative_name_test?(expression)
+
       if (native_node = adapter.at_xpath(@native, expression, namespaces))
         Moxml::Node.wrap(native_node, context)
       end
@@ -268,5 +284,44 @@ module Moxml
     def find_all(xpath)
       xpath(xpath).to_a
     end
+
+    private
+
+    def relative_name_test?(expression)
+      expression.match?(RELATIVE_NAME_TEST)
+    end
+
+    # Anchor every top-level union branch at the document root
+    # ("//"= descendant-or-self): "a/b | c" -> "//a/b | //c" — one
+    # adapter call, engine document order preserved, and the
+    # attribute-terminal idiom (pinned below) stays intact, which the
+    # ".//" form does not (libxml2 rejects .//r/a/@id).
+    def lax_document_path(expression)
+      split_top_level_unions(expression)
+        .map { |branch| "//#{branch.strip}" }
+        .join(" | ")
+    end
+
+    def split_top_level_unions(expression)
+      branches = [+""]
+      depth = 0
+      quote = nil
+      expression.each_char do |ch|
+        if quote
+          quote = nil if ch == quote
+        elsif ["'", '"'].include?(ch)
+          quote = ch
+        elsif ["(", "["].include?(ch)
+          depth += 1
+        elsif [")", "]"].include?(ch)
+          depth -= 1
+        elsif ch == "|" && depth.zero?
+          branches << +""
+          next
+        end
+        branches.last << ch
+      end
+      branches
+    end
   end
 end

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.5.143"
+  VERSION = "0.5.146"
 end

data/lib/moxml/xpath/compiler.rb

@@ -40,6 +40,7 @@ module Moxml
       # @param namespaces [Hash, nil] Optional namespace prefix mappings
       # @return [Proc] Compiled Proc that accepts a document
       def self.compile_with_cache(ast, namespaces: nil)
+        namespaces = normalize_namespaces(namespaces)
         cache_key = namespaces ? [ast, namespaces] : ast
         CACHE.get_or_set(cache_key) { new(namespaces: namespaces).compile(ast) }
       end
@@ -48,12 +49,24 @@ module Moxml
       #
       # @param namespaces [Hash, nil] Optional namespace prefix mappings
       def initialize(namespaces: nil)
-        @namespaces = namespaces
+        @namespaces = self.class.normalize_namespaces(namespaces)
         @literal_id = 0
         @predicate_nodesets = []
         @predicate_indexes = []
       end
 
+      # Prefix lookups are string-keyed (the parser yields prefix
+      # strings); symbol-keyed bindings — the common Nokogiri spelling
+      # (`xpath("//cml:molecule", cml: URI)`) — must resolve too, or
+      # the miss falls through to prefix-spelling matching and
+      # namespaced elements never match (issue #395).
+      def self.normalize_namespaces(namespaces)
+        return nil if namespaces.nil?
+        return namespaces unless namespaces.is_a?(Hash)
+
+        namespaces.transform_keys(&:to_s)
+      end
+
       # Compiles an XPath AST into a Ruby Proc
       #
       # @param ast [AST::Node] XPath AST to compile

data/spec/consistency/xpath_idioms_spec.rb

@@ -11,11 +11,22 @@ require "spec_helper"
 # - Attribute-terminal steps work in every path position
 #   (leptris-ruby#458's table: //a/@id, //@id, r/a/@id,
 #   //*[f()]/@id — fixed by the engine's VM path work).
+CML_NS = "http://www.xml-cml.org/schema"
+ACI_NS = "http://www.xml-cml.org/schema/asciichem"
+
 RSpec.describe "XPath idioms across adapters" do
   let(:default_ns_xml) do
     '<svgmap xmlns="http://www.example.org/doc"><target href="a"/></svgmap>'
   end
   let(:plain_xml) { '<r><a id="x"><b/></a></r>' }
+  let(:cml_xml) do
+    <<~XML
+      <molecule xmlns="#{CML_NS}" xmlns:aci="#{ACI_NS}" id="m1">
+        <atomArray><atom id="a1"/></atomArray>
+        <aci:group multiplicity="2" bracket="paren" atomRefs="a1"/>
+      </molecule>
+    XML
+  end
 
   Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
     next if adapter_name == :headed_ox # same engine as :ox
@@ -53,9 +64,48 @@ RSpec.describe "XPath idioms across adapters" do
         expect(doc.xpath("//a/@id").first&.value).to eq("x")
         expect(doc.xpath("//@id").first&.value).to eq("x")
         expect(doc.xpath("r/a/@id").first&.value).to eq("x")
-        expect(
-          doc.xpath("//*[local-name()='a']/@id").first&.value,
-        ).to eq("x")
+        expect(doc.xpath("//*[local-name()='a']/@id").first&.value).to eq("x")
+      end
+
+      # Issue #395: bindings hashes arrive in both key spellings
+      # (symbols are the common Nokogiri idiom); the engines must
+      # resolve both — a symbol-key miss falls through to
+      # prefix-spelling matching and namespaced elements never match.
+      # asciichem's CML group extraction rides exactly this shape.
+      it "resolves symbol-keyed namespace bindings" do
+        doc = ctx.parse(cml_xml)
+        mols = doc.xpath("//cml:molecule", cml: CML_NS)
+        expect(mols.to_a.size).to eq(1)
+
+        groups = mols.first.xpath("./aci:group", aci: ACI_NS)
+        expect(groups.to_a.size).to eq(1)
+        expect(groups.first["multiplicity"]).to eq("2")
+      end
+
+      it "resolves string-keyed namespace bindings identically" do
+        doc = ctx.parse(cml_xml)
+        expect(doc.xpath("//cml:molecule", "cml" => CML_NS).to_a.size).to eq(1)
+      end
+
+      # moxml#393: a relative name-test path on the DOCUMENT resolves
+      # laxly, descendant-anchored at the root — Nokogiri's own
+      # Document#at/#search semantics, now pinned for every adapter.
+      # Axes, node types and "." keep strict document context.
+      it "resolves document-context relative name-test paths from the root" do
+        doc = ctx.parse(plain_xml)
+        expect(doc.at("a/b")&.name).to eq("b")
+        expect(doc.at_xpath("a/b")&.name).to eq("b")
+        expect(doc.xpath("a/b").map(&:name)).to eq(["b"])
+        expect(doc.xpath("a | r").map(&:name).sort).to eq(%w(a r))
+        expect(doc.xpath("missing").map(&:name)).to eq([])
+        expect(doc.at_xpath("missing")).to be_nil
+      end
+
+      it "keeps non-name-test expressions in document context" do
+        doc = ctx.parse(plain_xml)
+        expect(doc.at_xpath(".")).to be_truthy
+        expect(doc.at_xpath("/*")&.name).to eq("r")
+        expect(doc.at_xpath("/r")&.name).to eq("r")
       end
     end
   end

data/spec/moxml/adapter/leptris_contract_reads_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# leptris-ruby#460 — the Identity contract reads ride the C faces
+# by plain dispatch (NativeNode subclasses inherit the C-defined
+# name/content since binding 1.9.359). The wrapper memo stays; the
+# ADAPTER CROSSING (bind_call through node_name/text_content) goes.
+RSpec.describe "leptris Identity contract reads" do
+  let(:ctx) { Moxml.new(:leptris) }
+
+  before do
+    unless Moxml::Adapter::Leptris::NATIVE_READ_LAYER &&
+        Leptris::XML::NativeNode.method_defined?(:name) &&
+        Leptris::XML::NativeNode.method_defined?(:content)
+      skip "binding #{defined?(Leptris) && Leptris::VERSION} lacks the C contract faces"
+    end
+  end
+
+  def bust(node, *ivars)
+    ivars.each do |iv|
+      node.remove_instance_variable(iv) if node.instance_variable_defined?(iv)
+    end
+  end
+
+  def forbid_crossing!(method)
+    singleton = Moxml::Adapter::Leptris.singleton_class
+    singleton.send(:alias_method, :"#{method}_without_460", method)
+    singleton.send(:define_method, method) { |*| raise "adapter #{method} crossing" }
+    method
+  end
+
+  def restore_crossing!(method)
+    singleton = Moxml::Adapter::Leptris.singleton_class
+    singleton.send(:alias_method, method, :"#{method}_without_460")
+    singleton.send(:remove_method, :"#{method}_without_460")
+  end
+
+  describe "element#name" do
+    it "answers without the adapter node_name crossing" do
+      unless Leptris::XML::NativeNode.method_defined?(:name_read)
+        skip "binding #{Leptris::VERSION} has no name_read face (adapter path is correct there)"
+      end
+      doc = ctx.parse('<root><item id="1">v</item></root>')
+      el = doc.root.children.first
+      expect(el.native).to be_a(Leptris::XML::NativeNode)
+
+      bust(el, :@name)
+      forbid_crossing!(:node_name)
+      begin
+        expect(el.name).to eq("item")
+      ensure
+        restore_crossing!(:node_name)
+      end
+    end
+
+    it "answers the local name for prefixed elements (cross-adapter contract)" do
+      doc = ctx.parse('<root xmlns:ns="urn:u"><ns:p/></root>')
+      el = doc.root.children.first
+      bust(el, :@name)
+      expect(el.name).to eq("p")
+    end
+
+    it "memoizes: warm reads return the same String" do
+      doc = ctx.parse("<root><item/></root>")
+      el = doc.root.children.first
+      first = el.name
+      expect(el.name).to equal(first)
+    end
+
+    it "re-reads after name=" do
+      doc = ctx.parse("<root><item/></root>")
+      el = doc.root.children.first
+      el.name = "renamed"
+      expect(el.name).to eq("renamed")
+    end
+  end
+
+  describe "text#content" do
+    it "answers without the adapter text_content crossing" do
+      unless Leptris::XML::NativeNode.method_defined?(:text_read)
+        skip "binding #{Leptris::VERSION} has no text_read face (adapter path is correct there)"
+      end
+      doc = ctx.parse("<root><item>v</item></root>")
+      tx = doc.root.children.first.children.first
+      expect(tx.native).to be_a(Leptris::XML::NativeNode)
+
+      bust(tx, :@content)
+      forbid_crossing!(:text_content)
+      begin
+        expect(tx.content).to eq("v")
+      ensure
+        restore_crossing!(:text_content)
+      end
+    end
+
+    it "memoizes: warm reads return the same String" do
+      doc = ctx.parse("<root><item>v</item></root>")
+      tx = doc.root.children.first.children.first
+      first = tx.content
+      expect(tx.content).to equal(first)
+    end
+
+    it "re-reads after content=" do
+      doc = ctx.parse("<root><item>v</item></root>")
+      tx = doc.root.children.first.children.first
+      tx.content = "changed"
+      expect(tx.content).to eq("changed")
+    end
+
+    it "restores entities on entity-bearing documents" do
+      ctx2 = Moxml.new(:leptris) { |c| c.restore_entities = true }
+      doc = ctx2.parse("<root><item>a &amp; b</item></root>")
+      tx = doc.root.children.first.children.first
+      bust(tx, :@content)
+      expect(tx.content).to eq("a & b")
+    end
+  end
+
+  describe "the untouched faces" do
+    it "keeps text wrappers named text" do
+      doc = ctx.parse("<root><item>v</item></root>")
+      tx = doc.root.children.first.children.first
+      expect(tx.name).to eq("text")
+    end
+
+    it "keeps element#text on the existing path" do
+      doc = ctx.parse("<root><item>v</item></root>")
+      el = doc.root.children.first
+      expect(el.text).to eq("v")
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.143
+  version: 0.5.146
 platform: ruby
 authors:
 - Ribose Inc.
@@ -452,6 +452,7 @@ files:
 - spec/moxml/adapter/leptris_append_gc_spec.rb
 - spec/moxml/adapter/leptris_attribute_snapshot_spec.rb
 - spec/moxml/adapter/leptris_binding_cap_spec.rb
+- spec/moxml/adapter/leptris_contract_reads_spec.rb
 - spec/moxml/adapter/leptris_doc_parts_spec.rb
 - spec/moxml/adapter/leptris_document_declaration_spec.rb
 - spec/moxml/adapter/leptris_inbody_comment_spec.rb