moxml 0.5.94 → 0.5.96

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e54a93041f955c95affa2211704839bfaf47dafc0908cd73b58012946ffe99f1
-  data.tar.gz: 4d28d6376f61ae7441e13075ac5e9433bd18b6c393cf95afe363a639a4b8d251
+  metadata.gz: 011415dfeb5b083b1cb88c8a7b4619ed3cc896c51b78500fe849c02bbab055a4
+  data.tar.gz: a8b99c779efcca214047df53e1891b07961f0d3ab154e3f3538e83bfdbfb64f5
 SHA512:
-  metadata.gz: 3e13a34f69a9e91b18d7fc9cef1e30c40ced24c8c73b322459ecba15af568439b002db8eec51097af2188571d026bfae7861646cc33077127c1fbd570b179863
-  data.tar.gz: a873c43e7ee3ccffc1997bf103263b7848d8ed17c61e25322a8d550bdf62a46d2f1e9e4a93f6e2832484a6df9d93350fd53d833a0b48ce04e1247583fc447d50
+  metadata.gz: d1eb8163f7e725c42bba78d058abcece733204a414df60278d4fbfc477808160e8800eaa9fd5de5c011c1ce849d3f9e630eb667ebe15808cc6a614120a92fcd5
+  data.tar.gz: 5d4108fc8881b6c8073dd8de95c0023b3aaeca379e258fa5b8345a6c6016f0ee814b9d2c6b047ea1d91c724391e4fc8b6127090781c33665dcba59c536f8bb52

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
 

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/adapter/rexml.rb

@@ -25,12 +25,12 @@ module Moxml
         def parse(xml, options = {}, _context = nil)
           xml = "" if xml.nil?
 
-          # Handle frozen strings by creating a mutable copy
-          processed_xml = if xml.frozen?
-                            xml.dup.force_encoding("UTF-8").encode("UTF-8")
-                          else
-                            xml.force_encoding("UTF-8").encode("UTF-8")
-                          end
+          # Transcode from the input's own encoding tag; encode returns
+          # a fresh string (or self, already UTF-8) — the caller's
+          # buffer is never retagged in place. The old non-frozen
+          # branch force_encoding!-mutated the CALLER's string,
+          # corrupting it (invalid UTF-8 tag) for every later parse.
+          processed_xml = xml.encode("UTF-8")
 
           # Preprocess entities to avoid double-escaping on output
           processed_xml = preprocess_entities(processed_xml)

data/lib/moxml/entity.rb

@@ -112,6 +112,7 @@ module Moxml
             else
               xml.encode("UTF-8")
             end
+      str = rewrite_declared_encoding(str)
       # Fast path: no `&` means no entity references to mark — skip
       # the regex scan and string allocation entirely. The vast
       # majority of XML payloads contain no entity references.
@@ -139,6 +140,24 @@ module Moxml
       preprocess_with_marker_flag(xml)[0]
     end
 
+    # Engines honor the DECLARED encoding and re-decode the bytes they
+    # are handed — moxml always feeds UTF-8 (see the normalization
+    # above), so a declaration naming another encoding must be
+    # rewritten to match, or the already-transcoded bytes decode a
+    # second time into mojibake ("café" -> "café"). The anchored match
+    # fails on the first two bytes for documents without a declaration.
+    DECLARED_ENCODING_RE = /\A(<\?xml[^>]*?encoding=)['"][^'"]*['"]/
+    private_constant :DECLARED_ENCODING_RE
+
+    def rewrite_declared_encoding(str)
+      # The passthrough contract (Entity spec: plain text returns the
+      # SAME object) requires no allocation when no declaration names
+      # another encoding — both gates are allocation-free.
+      return str unless str.start_with?("<?xml") && str.include?("encoding=")
+
+      str.sub(DECLARED_ENCODING_RE) { "#{Regexp.last_match(1)}\"UTF-8\"" }
+    end
+
     # Resolve numeric (&#NN; / &#xNN;) and the five standard named
     # (&amp; &lt; &gt; &quot; &apos;) XML entity references in one
     # single pass. The resulting characters are data; no further

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.5.94"
+  VERSION = "0.5.96"
 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/character_encoding_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/c14n"
+
+# TODO.c14n/13: encoding edge cases. moxml normalizes every parse to
+# UTF-8 bytes and rewrites the declaration to match — engines honor
+# the DECLARED encoding and would otherwise re-decode the already
+# transcoded bytes into mojibake.
+CAF_E_UTF8 = [60, 114, 62, 99, 97, 102, 195, 169, 60, 47, 114, 62].freeze
+LATIN1_XML = (+"<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><r>caf\xE9</r>").force_encoding("ISO-8859-1")
+BOM_XML = (+"\xEF\xBB\xBF<r/>").force_encoding("UTF-8")
+NFC_XML = (+"<r>caf\xC3\xA9</r>").force_encoding("UTF-8")
+
+# oga's parse layer leaks the declaration as a PI node and the BOM as
+# text (pre-existing, documented in the W3C examples spec).
+OGA_LEAK = %i[oga].freeze
+
+RSpec.describe "Moxml character encoding at the parse boundary" do
+  Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+    context "with the #{adapter_name} adapter" do
+      let(:ctx) { Moxml.new(adapter_name) }
+
+      unless OGA_LEAK.include?(adapter_name)
+        it "transcodes declared Latin-1 to UTF-8 bytes" do
+          doc = ctx.parse(LATIN1_XML.dup)
+          expect(Moxml::C14n.canonicalize(doc).bytes).to eq(CAF_E_UTF8)
+        end
+
+        it "strips a leading UTF-8 BOM" do
+          doc = ctx.parse(BOM_XML.dup)
+          expect(Moxml::C14n.canonicalize(doc)).to eq("<r></r>")
+        end
+      end
+
+      it "passes NFC content through without normalization" do
+        doc = ctx.parse(NFC_XML.dup)
+        expect(Moxml::C14n.canonicalize(doc).bytes).to eq(CAF_E_UTF8)
+      end
+
+      it "does not mutate the caller's input string" do
+        input = LATIN1_XML.dup
+        expect(input).not_to be_frozen
+        ctx.parse(input)
+        expect(input.encoding).to eq(Encoding::ISO_8859_1)
+        expect(input.valid_encoding?).to be(true)
+        expect(input.bytes).to eq(LATIN1_XML.bytes)
+      end
+
+      it "serializes transcoded documents as UTF-8 declarations" do
+        doc = ctx.parse(LATIN1_XML.dup)
+        expect(doc.to_xml).to include("UTF-8")
+        expect(doc.to_xml).not_to include("ISO-8859-1")
+      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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.94
+  version: 0.5.96
 platform: ruby
 authors:
 - Ribose Inc.
@@ -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
@@ -460,6 +461,7 @@ files:
 - spec/moxml/c14n/adapter_delegation_spec.rb
 - spec/moxml/c14n/api_spec.rb
 - spec/moxml/c14n/c14n_spec.rb
+- spec/moxml/c14n/character_encoding_spec.rb
 - spec/moxml/c14n/comments_pis_spec.rb
 - spec/moxml/c14n/inclusive10_spec.rb
 - spec/moxml/c14n/namespace_edge_cases_spec.rb