moxml 0.5.93 → 0.5.95

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92d24efac79874e02cbfa26e20fc8135e2a714020a727896cdf2a460fa7d0508
-  data.tar.gz: 91f18637388f6983c2c75c606e95e93f15919b3099fbdc0c8e59ebf9aca93d5e
+  metadata.gz: de8e16de76cef81c34b0a4e097d5aa16196fdbc03d9bfe2cbee1e765312f1599
+  data.tar.gz: ab5cc00b4c1a4a209065620c89b7541e107ed3d0a80e1e91e4455cb10c17fd98
 SHA512:
-  metadata.gz: 91cd7d93def6717a7eedf675e871ff7d05d3dfb5378f8ddbe8f839daa68d0d1dbe0e1bdf6bdb939704bb03f673950c9faa858265321e2a209fbcb2042224a3cd
-  data.tar.gz: c973d0559eb5fcc42f45dfb824758cdbec8758ec0dc378a4ce4034d918b3b50fcdada1120cd9f18b47c39a42055d4cd810225588dbcf598346c920a2a510e0c7
+  metadata.gz: bf21f0b903d142e6ebce40004d4e3bb657ec812396a2e8e6bd49c2eb06b6763fa6917f18c6918a134784d279360092c127fad56b2a75449f21d7e2dc94ae2e3c
+  data.tar.gz: 0bc9b8912c18c946101b76c88ce2c5c1d7f3ab2d8f643d06a8760d78332e1fd0d426844caff21efd8bb5241af9b35471478223fff9754b78405c3dda28d1990b

data/docs/_guides/advanced-features.adoc

@@ -80,6 +80,24 @@ adapter = element.context.config.adapter
 element = Moxml::Element.new(native_node, context)
 ----
 
+=== Parse bookkeeping opt-outs (leptris)
+
+Data-pipeline parses that never read diagnostics or source positions can
+skip that bookkeeping. Both are opt-in per call; the default parse is
+byte-identical either way.
+
+[source,ruby]
+----
+# Duplicate attributes admit silently: queries answer first-wins, but
+# the duplicate stays in the tree, so the serialized form can carry it.
+doc = Moxml.new.parse(xml, skip_dup_detection: true)
+
+# Source columns degrade; lines still resolve.
+doc = Moxml.new.parse(xml, skip_source_positions: true)
+----
+
+Without the flags, a duplicate attribute records a recover diagnostic in
+`doc.parse_diagnostics` and parses with the first value.
 
 See also:
 

data/lib/moxml/adapter/leptris.rb

@@ -856,6 +856,17 @@ module Moxml
         # Nokogiri semantics: blanks kept, no ATTLIST defaults).
         # noblanks forwards only once the engine flag is libxml2-safe
         # (see ENGINE_NOBLANKS_SAFE); otherwise it is moxml-side.
+        #
+        # The SKIP_ bookkeeping opt-outs (leptris-ruby#352, engine
+        # 1.9.272): duplicate attributes admit silently (first wins,
+        # no recover diagnostic) and source columns degrade (lines
+        # still resolve). Caller opt-in only — never defaults. The
+        # constant probe is the dependency-boundary check (the gem
+        # is zero-dep; user-resolved binding versions predate them).
+        NATIVE_PARSE_SKIPS =
+          ::Leptris::XML::ParseOptions.const_defined?(:SKIP_DUP_DETECTION) &&
+          ::Leptris::XML::ParseOptions.const_defined?(:SKIP_SOURCE_POSITIONS)
+
         def parse_flags(options, context: nil)
           flags = 0
           flags |= ::Leptris::XML::ParseOptions::DTDATTR if options[:dtdattr] == true
@@ -863,6 +874,11 @@ module Moxml
             (context&.config&.entity_mode == :keep ||
              options[:keep_entity_refs] == true)
           flags |= ::Leptris::XML::ParseOptions::NOBLANKS if options[:noblanks] == true && ENGINE_NOBLANKS_SAFE
+          if NATIVE_PARSE_SKIPS
+            po = ::Leptris::XML::ParseOptions
+            flags |= po::SKIP_DUP_DETECTION if options[:skip_dup_detection] == true
+            flags |= po::SKIP_SOURCE_POSITIONS if options[:skip_source_positions] == true
+          end
           flags.zero? ? nil : ::Leptris::XML::ParseOptions.new(flags)
         end
 
@@ -1942,7 +1958,14 @@ module Moxml
         end
 
         def processing_instruction_content(node)
-          return NN_CONTENT.bind_call(node) if NATIVE_READ_LAYER && node.is_a?(NN)
+          if NATIVE_READ_LAYER && node.is_a?(NN)
+            content = NN_CONTENT.bind_call(node)
+            # NativeNode#content answers nil for PI-kind nodes too
+            # (leptris-ruby#344 covers comments); bridge for the data.
+            return to_binding(node).content if content.nil?
+
+            return content
+          end
 
           node.content
         end

data/lib/moxml/adapter/nokogiri.rb

@@ -59,6 +59,7 @@ module Moxml
         # (Document/C14n), which is circular while THIS adapter file
         # is still loading.
         def native_inclusive10(native)
+          return nil if native.nil?
           return nil unless native_c14n_byte_safe?
 
           native.canonicalize(::Nokogiri::XML::XML_C14N_1_0)

data/lib/moxml/c14n/data_model.rb

@@ -237,7 +237,9 @@ module Moxml
       # included element renders with its namespaces, attributes and
       # DIRECT character data, but child ELEMENTS render only if
       # matched too — an unmatched Signature subtree stays out even
-      # though its ancestors are matched.
+      # though its ancestors are matched. Comments and PIs render
+      # only when the expression itself selects them (spec §3: the
+      # node-set is literal).
       def self.mark_subset_paths(root_node, paths)
         mark_all(root_node, false)
         paths.each do |path|
@@ -249,7 +251,7 @@ module Moxml
             node.namespace_nodes.each { |ns| ns.in_node_set = true }
             node.attribute_nodes.each { |attr| attr.in_node_set = true }
             node.children.each do |child|
-              child.in_node_set = true unless child.is_a?(Nodes::ElementNode)
+              child.in_node_set = true if child.is_a?(Nodes::TextNode)
             end
           else
             node.in_node_set = true

data/lib/moxml/version.rb

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

data/spec/moxml/adapter/leptris_parse_skips_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+DUP_XML = %(<r><e id="1">text</e><e id="2" id="3"/></r>)
+POS_XML = %(<r><e id="1">text</e></r>)
+
+RSpec.describe "Moxml leptris parse bookkeeping opt-outs" do
+  # leptris-ruby#352 (binding 1.9.273.1, engine 1.9.272 Door A):
+  # SKIP_DUP_DETECTION admits duplicate attributes silently (first
+  # wins, no recover diagnostic); SKIP_SOURCE_POSITIONS degrades
+  # source columns (lines still resolve). Caller opt-in only.
+  let(:ctx) { Moxml.new(:leptris) }
+  let(:adapter) { ctx.config.adapter }
+
+  before do
+    skip "binding without the SKIP_ parse flags" unless
+      Leptris::XML::ParseOptions.const_defined?(:SKIP_DUP_DETECTION)
+  end
+
+  it "drops the duplicate-attribute diagnostic when requested" do
+    doc = ctx.parse(DUP_XML, skip_dup_detection: true)
+    expect(adapter.parse_diagnostics(doc.native)).to eq([])
+  end
+
+  it "keeps the duplicate-attribute diagnostic by default" do
+    doc = ctx.parse(DUP_XML)
+    expect(adapter.parse_diagnostics(doc.native).map { |d| d[:kind] }).to include(:recover)
+  end
+
+  it "first attribute wins either way" do
+    expect(ctx.parse(DUP_XML, skip_dup_detection: true).root.children[1][:id])
+      .to eq(ctx.parse(DUP_XML).root.children[1][:id])
+  end
+
+  it "keeps lines but degrades columns for skipped positions" do
+    full = ctx.parse(POS_XML).root.children[0].source_position
+    skipped = ctx.parse(POS_XML, skip_source_positions: true)
+      .root.children[0].source_position
+    expect(skipped[:line]).to eq(full[:line])
+    expect(skipped[:col_start]).to be < full[:col_start]
+  end
+
+  it "keeps the duplicate in the tree — queries still answer first-wins" do
+    # The engine admits the duplicate silently: reads see the first
+    # value, but the second attribute stays in the tree, so the
+    # serialized form can carry it. Callers opting in trade the
+    # well-formed-output guarantee for the bookkeeping speed.
+    fast = ctx.parse(DUP_XML, skip_dup_detection: true)
+    expect(fast.root.children[1][:id]).to eq("2")
+    expect(fast.to_xml).to include('id="2" id="3"')
+  end
+
+  it "still raises on fatal errors with skips on" do
+    expect { ctx.parse("<r><e></r>", skip_dup_detection: true) }
+      .to raise_error(Moxml::ParseError)
+  end
+end

data/spec/moxml/c14n/subset_spec.rb

@@ -31,12 +31,21 @@ CORPUS = [
 ].freeze
 
 COMMENTS_CASE = [
-  "with_comments keeps matched comments only",
+  "with_comments renders explicitly selected comments only",
+  %(<a><!-- keep --><b><!-- in --><c/></b></a>), "//b | //comment()",
+  %(<!-- keep -->\n<b><!-- in --></b>)
+].freeze
+
+COMMENTS_EXCLUDED_CASE = [
+  "unselected comments stay out",
   %(<a><!-- keep --><b><!-- in --><c/></b></a>), "//b",
-  %(<b><!-- in --></b>)
+  %(<b></b>)
 ].freeze
 
 COMMENTS_PADDING_LOSS = %i[ox headed_ox].freeze
+# rexml's adapter xpath does not return comment()/text() node results
+# (pre-existing capability gap, same family for both axes).
+COMMENT_SELECTION_GAP = %i[rexml].freeze
 
 RSpec.describe "Moxml::C14n subset canonicalization" do
   # Node-set semantics follow the enveloped-signature interop
@@ -63,8 +72,11 @@ RSpec.describe "Moxml::C14n subset canonicalization" do
         end
 
         # ox/headed_ox strip comment content padding at the parse
-        # layer (pre-existing, same family as their PI content loss).
-        unless COMMENTS_PADDING_LOSS.include?(adapter_name)
+        # layer (pre-existing, same family as their PI content loss);
+        # only the rendered-comment case depends on it. rexml's
+        # comment() selection gap also only affects this case.
+        unless COMMENTS_PADDING_LOSS.include?(adapter_name) ||
+            COMMENT_SELECTION_GAP.include?(adapter_name)
           it COMMENTS_CASE[0] do
             doc = ctx.parse(COMMENTS_CASE[1])
             expect(Moxml::C14n.canonicalize_subset(doc, COMMENTS_CASE[2],
@@ -72,6 +84,13 @@ RSpec.describe "Moxml::C14n subset canonicalization" do
               .to eq(COMMENTS_CASE[3])
           end
         end
+
+        it COMMENTS_EXCLUDED_CASE[0] do
+          doc = ctx.parse(COMMENTS_EXCLUDED_CASE[1])
+          expect(Moxml::C14n.canonicalize_subset(doc, COMMENTS_EXCLUDED_CASE[2],
+                                                 with_comments: true))
+            .to eq(COMMENTS_EXCLUDED_CASE[3])
+        end
       end
     end
   end

data/spec/moxml/c14n/w3c_examples_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string: true
+
+require "spec_helper"
+require "moxml/c14n"
+
+# Shapes drawn from the W3C Canonical XML 1.0 REC examples (§2–§3):
+# attribute-value whitespace normalization, character-reference CR
+# preservation vs literal-CR folding, CDATA as character data, empty
+# element form, PI/comment placement, and the §3 document-subset
+# whitespace rules. Expected bytes are the forms all conformant
+# adapters answer identically.
+#
+# Documented parse-layer divergences (skipped rows):
+# - ox/headed_ox expand 
 to LF, strip inter-element whitespace
+#   and comment padding at parse (out of scope here)
+# - oga keeps the target/content separator space in PI data
+W3C_FULL_FORMS = [
+  ["attribute-value whitespace collapses to single spaces",
+   "<doc>\n   <e   attr1=\"v1\"\n        attr2   =   \"v2\"\n    >   content   </e>\n</doc>",
+   "<doc>\n   <e attr1=\"v1\" attr2=\"v2\">   content   </e>\n</doc>"],
+  ["character-reference CR stays &#xD;; literal CR folds to LF",
+   %(<doc>a&#xD;b\nc&#xA;d</doc>),
+   %(<doc>a&#xD;b\nc\nd</doc>)],
+  ["CDATA is character data and escapes",
+   %(<doc><![CDATA[a<b]]> &amp; &lt; x</doc>),
+   %(<doc>a&lt;b &amp; &lt; x</doc>)],
+  ["empty elements render as start and end tags",
+   %(<doc><e/><f></f></doc>),
+   "<doc><e></e><f></f></doc>"],
+  ["PIs render in place; comments drop without with_comments",
+   %(<doc><?pi c?><!-- c1 --><e/><!-- c2 --></doc>),
+   %(<doc><?pi c?><e></e></doc>)],
+].freeze
+
+W3C_SUBSET_FORM = [
+  %(<doc>\n   <e1 a="1" b="2"/>\n   <e2/>\n   <e3/>\n   <!-- A small comment -->\n   <?pi x?>\n</doc>),
+  "//e1 | //e2 | //e3",
+  %(<e1 a="1" b="2"></e1><e2></e2><e3></e3>),
+].freeze
+
+W3C_SUBSET_WITH_ROOT = [
+  %(<doc>\n   <e1 a="1" b="2"/>\n   <e2/>\n   <e3/>\n   <!-- A small comment -->\n   <?pi x?>\n</doc>),
+  "/doc | //e1 | //e2 | //e3",
+  %(<doc>\n   <e1 a="1" b="2"></e1>\n   <e2></e2>\n   <e3></e3>\n   \n   \n</doc>),
+].freeze
+
+CR_SHAPE = 1
+PI_SHAPE = 4
+WHITESPACE_SHAPES = %i[ox headed_ox].freeze
+
+RSpec.describe "Moxml::C14n W3C REC-xml-c14n examples" do
+  Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+    context "with the #{adapter_name} adapter" do
+      let(:ctx) { Moxml.new(adapter_name) }
+
+      W3C_FULL_FORMS.each_with_index do |(label, xml, expected), idx|
+        # ox/headed_ox strip inter-element whitespace, expand &#xD;
+        # and pad comments at parse; oga keeps the PI separator space.
+        skip_shapes = { ox: [0, CR_SHAPE, PI_SHAPE],
+                        headed_ox: [0, CR_SHAPE, PI_SHAPE],
+                        oga: [PI_SHAPE] }[adapter_name] || []
+        next if skip_shapes.include?(idx)
+
+        it "canonicalizes #{label}" do
+          doc = ctx.parse(xml)
+          expect(Moxml::C14n.canonicalize_inclusive10(doc)).to eq(expected)
+          expect(Moxml::C14n.canonicalize(doc.root)).to eq(expected)
+        end
+      end
+    end
+  end
+
+  describe "W3C §3 document-subset whitespace" do
+    Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+      next if WHITESPACE_SHAPES.include?(adapter_name)
+
+      it "renders selected nodes only, whitespace runs in place (#{adapter_name})" do
+        doc = Moxml.new(adapter_name).parse(W3C_SUBSET_FORM[0])
+        expect(Moxml::C14n.canonicalize_subset(doc, W3C_SUBSET_FORM[1]))
+          .to eq(W3C_SUBSET_FORM[2])
+      end
+
+      it "keeps the root's whitespace runs when the root is selected (#{adapter_name})" do
+        doc = Moxml.new(adapter_name).parse(W3C_SUBSET_WITH_ROOT[0])
+        expect(Moxml::C14n.canonicalize_subset(doc, W3C_SUBSET_WITH_ROOT[1]))
+          .to eq(W3C_SUBSET_WITH_ROOT[2])
+      end
+    end
+  end
+
+  describe "Ruby reference agrees with the native engines" do
+    %i[leptris nokogiri].each do |adapter_name|
+      next unless Moxml::Adapter::AVAILABLE_ADAPTERS.include?(adapter_name)
+
+      it "on every full-document shape (#{adapter_name})" do
+        W3C_FULL_FORMS.each do |_label, xml, _expected|
+          root = Moxml.new(adapter_name).parse(xml).root
+          expect(Moxml::C14n.canonicalize(root))
+            .to eq(Moxml::C14n.canonicalize_inclusive10(root))
+        end
+      end
+    end
+  end
+end

data/spec/moxml/struct_plan_typed_spec.rb

@@ -2,6 +2,10 @@
 
 require "spec_helper"
 
+# The per-item target class for the typed plan: Struct gives the
+# accessors StructPlan assigns the cast slots to.
+TypedItem = Struct.new(:price, :qty, :ok, :label)
+
 # Typed plan scalars (leptris plan ABI, #1269a consumer face):
 # [slot, type] declarations cast in C — Integer/Float/TrueClass/
 # FalseClass members with no Ruby String materialized; unparseable

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.93
+  version: 0.5.95
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-28 00:00:00.000000000 Z
+date: 2026-09-30 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -438,6 +438,7 @@ files:
 - spec/moxml/adapter/entity_restoration_spec.rb
 - spec/moxml/adapter/headed_ox_spec.rb
 - spec/moxml/adapter/leptris_doc_parts_spec.rb
+- spec/moxml/adapter/leptris_parse_skips_spec.rb
 - spec/moxml/adapter/leptris_record_driver_spec.rb
 - spec/moxml/adapter/leptris_sax_dup_attr_spec.rb
 - spec/moxml/adapter/leptris_sax_records_spec.rb
@@ -464,6 +465,7 @@ files:
 - spec/moxml/c14n/inclusive10_spec.rb
 - spec/moxml/c14n/namespace_edge_cases_spec.rb
 - spec/moxml/c14n/subset_spec.rb
+- spec/moxml/c14n/w3c_examples_spec.rb
 - spec/moxml/c14n/xml_attributes_spec.rb
 - spec/moxml/cdata_spec.rb
 - spec/moxml/comment_spec.rb