moxml 0.5.70 → 0.5.71

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b329e431ed88f56890e49f855af38ed25c7ac216cbb35fe91dfc1377deeb44a
-  data.tar.gz: 113f2b97ceae1f8fcd3bb557ada4205c693ce8e603078ca2b749f5cbb91f0f86
+  metadata.gz: 20275fa1b50e6428f448b919513cea0b71c6737e002254bd34802f2491f4a6df
+  data.tar.gz: '09f7c98af52d5efab3a8ca2efbee63a50f3eae2c26cb1a8f1d4795711462c6b6'
 SHA512:
-  metadata.gz: b7de514485b6b9bb2393f61584b6f02d474bcd351ed2dc049aebc29ed31c4f8d2220b80facb9757df43fcac0bf8a0a46023c09af7c987ad06b22eaceea181bad
-  data.tar.gz: c3cd5913e50a4b700609cee9729e1eeb1b2eddcd98292a83764268319f2dcd0f8c79092459f58deba10f9a9eeec4de6a467422316b11496148fc0ab26edcee7c
+  metadata.gz: 4474310fe16f301dacbef2e6eac14f1b7cbb6c3be75fd547ed6ea85e054e0ad8c6fd60d3d11448e17ee2d556408670a1999ed8cb1d4dec83392480d6b6283e63
+  data.tar.gz: 7167a5ef4c392461ecb813ca330e1800f2433ed9c3254925943d921223210e84d480826ee8787728a14cb29c2f3b0f3f4f2c3141b3b87a4bc1d3df3e204798c5

data/Gemfile

@@ -9,7 +9,7 @@ gemspec
 gem "benchmark"
 gem "benchmark-ips"
 gem "get_process_mem"
-gem "leptris", "~> 1.9.174"
+gem "leptris", "~> 1.9.194"
 gem "libxml-ruby", ">= 5.0"
 gem "nokogiri", "~> 1.18"
 gem "openssl", "~> 3.0"

data/README.adoc

@@ -91,8 +91,10 @@ moxml's customized generator and decoder overrides.
 6.0 itself requires Ruby >= 3.2); Ruby 3.1 resolves 5.x.
 
 |Leptris (leptris-ruby)
-|>= 1.9.32
+|>= 1.9.194.1
 |Hard floor — `MINIMUM_BINDING_VERSION`; older bindings do not load.
+Raised from 1.9.32 (2026-09-20): every known consumer resolves a
+modern binding, and the sub-1.9.194 accommodation paths are deleted.
 Newer bindings unlock more native surface automatically:
 1.9.163.7+ single-result XPath seams, 1.9.174.4+ C-minted identity
 wrappers, 1.9.174.6+ one-dispatch subtree walks, 1.9.177+ first-class

data/lib/moxml/adapter/base.rb

@@ -358,6 +358,20 @@ namespace_validation_mode: :strict)
           nil
         end
 
+        # Read-only attribute listing as [name, value] pairs
+        # (Moxml::Element#attribute_pairs) — document order,
+        # duplicates included, no Attribute node wrappers. The
+        # walk-hot shape for consumers that only read name/value;
+        # mutation and per-attribute namespace resolution stay on
+        # #attributes. This default derives from #attributes;
+        # adapters with a bulk face override (leptris answers in
+        # one C crossing — leptris-ruby#278).
+        def attribute_pairs(element)
+          attributes(element).map do |attr|
+            [attribute_name(attr), attr.value.to_s]
+          end
+        end
+
         # Plan row stream (Moxml::Plan) — ADAPTER CONTRACT. Yields
         # |name, attrs_pairs (flat [k, v, ...]), first-text, depth|
         # per element in document order (pre-order); first-text is

data/lib/moxml/adapter/leptris.rb

@@ -26,18 +26,17 @@ module Moxml
       # (1.7.0) surfaces predate it. Older bindings are not eligible
       # for the default (see Config.leptris_preferred_available?) and
       # the adapter no longer carries accommodation paths for them.
-      MINIMUM_BINDING_VERSION = "1.9.32"
+      # Raised 1.9.32 -> 1.9.194.1 (2026-09-20): every known consumer
+      # resolves a modern binding (canon itself pins ~> 1.9.193), and
+      # the sub-1.9.194 accommodation paths are deleted.
+      MINIMUM_BINDING_VERSION = "1.9.194.1"
 
       # leptris_parse_html_string shipped in bindings 1.9.80
       # (libleptris 1.9.75, engine #659) as Leptris::XML.parse_html.
-      HTML_PARSE_SUPPORTED =
-        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.80")
-
       # Attribute-node xpath results carry proper wrappers since
       # 1.9.105 (leptris-ruby#153: ResultAttr with name/value);
       # before that the native gate routed them to the Ruby engine.
-      ATTR_RESULT_NATIVE =
-        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.105")
+      ATTR_RESULT_NATIVE = true
 
       # leptris_node_digest shipped in bindings 1.9.99 (libleptris
       # 1.9.99, engine #869): on-demand Merkle subtree hash, zero
@@ -223,77 +222,46 @@ module Moxml
             ELEMENT_CONTRACT_READ =
               ::Moxml::ElementBehavior.instance_method(:[])
 
-            NATIVE_HOT_ALIASES =
-              Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.194.1")
-
-            # Doc-level entity-marker memo shared by both hot-read
-            # faces (one WeakMap, generation-stamped Integer values).
+            # Bindings >= 1.9.194.1 (the floor) carry unshadowed
+            # aliases; the UnboundMethod#bind_call face for older
+            # shapes is deleted.
+            # Doc-level entity-marker memo (one WeakMap,
+            # generation-stamped Integer values).
             ENTITY_DOC_MEMO = ::ObjectSpace::WeakMap.new
 
-            if NATIVE_HOT_ALIASES
-              module Reads
-                # Marker presence is a DOCUMENT fact, but the wrapper
-                # memo re-derives it per node (the per-read machinery
-                # was ~a quarter of the consumer walk). Doc-level
-                # WeakMap, generation-stamped into one Integer
-                # (immediates make safe weak values): one C document
-                # read plus one map hit per bare read. Entries die
-                # with their documents; a stale generation re-derives.
-                def doc_entity_bearing?
-                  doc = NN_DOCUMENT.bind_call(self)
-                  memo = ENTITY_DOC_MEMO[doc]
-                  gen = ::Moxml::Adapter::Leptris.serialize_generation
-                  return memo.allbits?(1) if memo && (memo >> 1) == gen
-
-                  bearing = ::Moxml::Adapter::Leptris.entity_bearing?(self)
-                  ENTITY_DOC_MEMO[doc] = (gen << 1) | (bearing ? 1 : 0)
-                  bearing
-                end
-
-                def [](key)
-                  if key.is_a?(String) && !key.include?(":")
-                    value = attr_read(key)
-                    return value unless value.is_a?(String) && doc_entity_bearing?
+            module Reads
+              # Marker presence is a DOCUMENT fact, but the wrapper
+              # memo re-derives it per node (the per-read machinery
+              # was ~a quarter of the consumer walk). Doc-level
+              # WeakMap, generation-stamped into one Integer
+              # (immediates make safe weak values): one C document
+              # read plus one map hit per bare read. Entries die
+              # with their documents; a stale generation re-derives.
+              def doc_entity_bearing?
+                doc = NN_DOCUMENT.bind_call(self)
+                memo = ENTITY_DOC_MEMO[doc]
+                gen = ::Moxml::Adapter::Leptris.serialize_generation
+                return memo.allbits?(1) if memo && (memo >> 1) == gen
+
+                bearing = ::Moxml::Adapter::Leptris.entity_bearing?(self)
+                ENTITY_DOC_MEMO[doc] = (gen << 1) | (bearing ? 1 : 0)
+                bearing
+              end
 
-                    return ::Moxml::Adapter::Leptris.restore_entities(value)
-                  end
+              def [](key)
+                if key.is_a?(String) && !key.include?(":")
+                  value = attr_read(key)
+                  return value unless value.is_a?(String) && doc_entity_bearing?
 
-                  ELEMENT_CONTRACT_READ.bind_call(self, key)
+                  return ::Moxml::Adapter::Leptris.restore_entities(value)
                 end
 
-                def text
-                  value = text_read
-                  value.is_a?(String) && doc_entity_bearing? ? ::Moxml::Adapter::Leptris.restore_entities(value) : value
-                end
+                ELEMENT_CONTRACT_READ.bind_call(self, key)
               end
-            else
-              module Reads
-                def doc_entity_bearing?
-                  doc = NN_DOCUMENT.bind_call(self)
-                  memo = ENTITY_DOC_MEMO[doc]
-                  gen = ::Moxml::Adapter::Leptris.serialize_generation
-                  return memo.allbits?(1) if memo && (memo >> 1) == gen
-
-                  bearing = ::Moxml::Adapter::Leptris.entity_bearing?(self)
-                  ENTITY_DOC_MEMO[doc] = (gen << 1) | (bearing ? 1 : 0)
-                  bearing
-                end
-
-                def [](key)
-                  if key.is_a?(String) && !key.include?(":")
-                    value = NN_ATTRIBUTE.bind_call(self, key)
-                    return value unless value.is_a?(String) && doc_entity_bearing?
-
-                    return ::Moxml::Adapter::Leptris.restore_entities(value)
-                  end
 
-                  ELEMENT_CONTRACT_READ.bind_call(self, key)
-                end
-
-                def text
-                  value = NN_CONTENT.bind_call(self)
-                  value.is_a?(String) && doc_entity_bearing? ? ::Moxml::Adapter::Leptris.restore_entities(value) : value
-                end
+              def text
+                value = text_read
+                value.is_a?(String) && doc_entity_bearing? ? ::Moxml::Adapter::Leptris.restore_entities(value) : value
               end
             end
             ELEMENT.include(Reads)
@@ -536,9 +504,7 @@ module Moxml
       # exactly the plan's shape, with no wrapper minting at all.
       # Marker-bearing documents stay on the generic path (the bulk
       # stream has no marker split).
-      NATIVE_PLAN_ROWS =
-        NATIVE_READ_LAYER &&
-        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.193.4")
+      NATIVE_PLAN_ROWS = true
 
       # leptris-ruby#272 (binding 1.9.201.1): Native.plan_structs —
       # the C struct executor behind Moxml::StructPlan. The floor
@@ -602,20 +568,10 @@ module Moxml
                        end
         return nil unless root_binding
 
-        rows = if NATIVE_PLAN_ROWS
-                 ::Leptris::XML::Native.snapshot_rows(doc,
-                                                      root_binding.c_address)
-               else
-                 doc.snapshot(root_binding)
-               end
+        rows = ::Leptris::XML::Native.snapshot_rows(doc,
+                                                    root_binding.c_address)
         rows.each do |row|
-          if row.is_a?(::Array)
-            yield(row[0], row[1], row[2], row[3])
-          else
-            next unless row[:kind] == "element"
-
-            yield(row[:name], row[:attrs].flatten, row[:text], row[:depth])
-          end
+          yield(row[0], row[1], row[2], row[3])
         end
         true
       end
@@ -806,13 +762,6 @@ module Moxml
         end
 
         def parse_html(html, _options = {}, _context = nil)
-          unless HTML_PARSE_SUPPORTED
-            raise Moxml::AdapterError.new(
-              "HTML parsing requires leptris >= 1.9.80 (have #{::Leptris::VERSION})",
-              adapter: name, operation: "parse_html",
-            )
-          end
-
           html_string = html.is_a?(IO) || html.is_a?(StringIO) ? html.read : html.to_s
           native_doc = begin
             ::Leptris::XML.parse_html(html_string)
@@ -1460,6 +1409,18 @@ module Moxml
           element.attribute_nodes
         end
 
+        # One C crossing per element on bindings with the bulk face
+        # (leptris-ruby#278): interned names, fresh values, zero
+        # Attr objects. Face-probed, not version-gated — the floor
+        # (1.9.194.1) admits bindings without it, which take the
+        # base default over #attributes.
+        def attribute_pairs(element)
+          binding_element = to_binding(element)
+          return super unless binding_element.respond_to?(:attribute_pairs)
+
+          binding_element.attribute_pairs
+        end
+
         def attribute_element(attr)
           attr.element
         end

data/lib/moxml/element.rb

@@ -115,6 +115,17 @@ module Moxml
       self[attr_name]
     end
 
+    # Read-only [name, value] pairs in document order, duplicates
+    # included — no Attribute node wrappers. The walk-hot shape for
+    # consumers that only read name/value (leptris-ruby#278): on
+    # leptris >= 1.9.208.1 this answers in one C crossing with zero
+    # per-attribute objects. Names may be shared frozen strings —
+    # dup before mutating. Mutation and per-attribute namespace
+    # resolution stay on #attributes.
+    def attribute_pairs
+      adapter.attribute_pairs(@native)
+    end
+
     def attributes
       # Primed like Node.wrap: the adapter and type are known at
       # mint, so the first name/value/attribute? access skips the

data/lib/moxml/version.rb

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

data/spec/moxml/adapter/leptris_spec.rb

@@ -324,10 +324,8 @@ RSpec.describe Moxml::Adapter::Leptris do
   end
 
   describe "HTML parsing (leptris/leptris#659)" do
-    before do
-      skip "requires leptris 1.9.80+ (HTML engine mode)" unless described_class::HTML_PARSE_SUPPORTED
-    end
-
+    # leptris >= 1.9.80 is below the binding floor (1.9.194.1) —
+    # the HTML engine mode is always present.
     let(:ctx) { Moxml.new(:leptris) }
 
     it "synthesizes the html/body structure with lowercased names" do

data/spec/moxml/adapter/platform_spec.rb

@@ -93,11 +93,11 @@ RSpec.describe Moxml::Adapter do
       end
     end
 
-    it "pins the leptris binding floor at 1.9.32 (issue #149)" do
+    it "pins the leptris binding floor at 1.9.194.1 (issue #149; raised 2026-09-20)" do
       skip "leptris not installed" unless described_class.available?(:leptris)
 
       adapter = described_class.load(:leptris)
-      expect(adapter::MINIMUM_BINDING_VERSION).to eq("1.9.32")
+      expect(adapter::MINIMUM_BINDING_VERSION).to eq("1.9.194.1")
       expect(Gem::Version.new(Leptris::VERSION))
         .to be >= Gem::Version.new(adapter::MINIMUM_BINDING_VERSION)
     end

data/spec/moxml/element_attribute_pairs_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Element#attribute_pairs adapter-contract conformance
+# (leptris-ruby#278): pairs must equal what the node path yields —
+# attributes.map { |a| [a.name, a.value.to_s] } — on every adapter,
+# whether the adapter answers through a bulk C face (leptris >=
+# 1.9.208.1) or derives from #attributes.
+RSpec.describe Moxml::Element do
+  let(:xml) do
+    '<catalog><record id="r0" kind="k0"><field name="f0" unit="u0">v</field></record></catalog>'
+  end
+
+  ADAPTERS = %i[leptris nokogiri ox oga rexml libxml].freeze # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+
+  def with_adapter(name)
+    ctx = Moxml.new(name)
+    yield ctx
+  rescue StandardError, LoadError
+    skip "adapter #{name} unavailable"
+  end
+
+  it "matches the node path on every available adapter" do
+    results = ADAPTERS.filter_map do |name|
+      with_adapter(name) do |ctx|
+        root = ctx.parse(xml).root
+        [name, root.attribute_pairs]
+      end
+    end
+    expect(results).not_to be_empty
+
+    results.each do |name, pairs|
+      with_adapter(name) do |ctx|
+        root = ctx.parse(xml).root
+        node_derived = root.attributes.map { |a| [a.name, a.value.to_s] }
+        expect(pairs).to eq(node_derived),
+                         "#{name}: #{pairs.inspect} vs #{node_derived.inspect}"
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.70
+  version: 0.5.71
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-19 00:00:00.000000000 Z
+date: 2026-09-20 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -466,6 +466,7 @@ files:
 - spec/moxml/document_builder_spec.rb
 - spec/moxml/document_free_spec.rb
 - spec/moxml/document_spec.rb
+- spec/moxml/element_attribute_pairs_spec.rb
 - spec/moxml/element_spec.rb
 - spec/moxml/entity_preservation_spec.rb
 - spec/moxml/entity_reference_spec.rb