moxml 0.5.95 → 0.5.97

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de8e16de76cef81c34b0a4e097d5aa16196fdbc03d9bfe2cbee1e765312f1599
-  data.tar.gz: ab5cc00b4c1a4a209065620c89b7541e107ed3d0a80e1e91e4455cb10c17fd98
+  metadata.gz: ec3d9011525010958b918f5c9665d47f54c202c96d0e3917c65d90ced667233b
+  data.tar.gz: 4d7d535d9960f935a6419006c586db0b49981de555cfa362eee641c548c51c1b
 SHA512:
-  metadata.gz: bf21f0b903d142e6ebce40004d4e3bb657ec812396a2e8e6bd49c2eb06b6763fa6917f18c6918a134784d279360092c127fad56b2a75449f21d7e2dc94ae2e3c
-  data.tar.gz: 0bc9b8912c18c946101b76c88ce2c5c1d7f3ab2d8f643d06a8760d78332e1fd0d426844caff21efd8bb5241af9b35471478223fff9754b78405c3dda28d1990b
+  metadata.gz: 8e39fcd9157a62fc686befcae1e4ca077e757c6b9bfc399b590f02377199be55e45f281f9cd50dcac5eaff9d32abd8aa2d40de7fc3250b3d02dd69aadd1dfefe
+  data.tar.gz: d947c13ae056a34a65d91d27648b54b89d4bca1c0d7a56712a77c560e7ef89cf798538af3871298ddcf5146379cc57442a7f02d359013228057a707765003f11

data/Gemfile

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

data/lib/moxml/adapter/ox.rb

@@ -779,41 +779,52 @@ module Moxml
           if node.is_a?(::Ox::Element) && (doc = document(node))
             return true if attachments.get(doc, :has_entity_refs)
             return true if attachments.get(doc, :has_cdata_end_markers)
+            return true if attachments.get(doc, :has_patched_text)
             return false if attachments.key?(doc, :has_entity_refs) &&
-              attachments.key?(doc, :has_cdata_end_markers)
+              attachments.key?(doc, :has_cdata_end_markers) &&
+              attachments.key?(doc, :has_patched_text)
 
             scan_root = doc
           end
 
           # One merged tree scan instead of two; flags cache on the
           # document either way.
-          has_er, has_cdata = tree_scan_custom_needs(scan_root)
+          has_er, has_cdata, has_patched = tree_scan_custom_needs(scan_root)
           if scan_root.is_a?(::Ox::Document)
             attachments.set(scan_root, :has_entity_refs, has_er)
             attachments.set(scan_root, :has_cdata_end_markers, has_cdata)
+            attachments.set(scan_root, :has_patched_text, has_patched)
           end
 
-          has_er || has_cdata
+          has_er || has_cdata || has_patched
         end
 
-        # Single walk collecting both custom-serialize triggers.
+        # Single walk collecting the custom-serialize triggers.
         def tree_scan_custom_needs(node)
           has_er = false
           has_cdata = false
+          # Text enumeration hands out CustomizedOx::Text wrappers
+          # (node.rb patches String children so they can carry a
+          # parent); dup/append of an enumerated wrapper plants the
+          # subclass instance in the raw tree, and ::Ox.dump rejects
+          # classes it does not know (moxml#301).
+          has_patched = false
           stack = [node]
           until stack.empty?
             current = stack.pop
             case current
             when ::Moxml::Adapter::CustomizedOx::EntityReference
               has_er = true
+            when ::Moxml::Adapter::CustomizedOx::Text
+              has_patched = true
             when ::Ox::CData
               has_cdata = true if current.value&.include?("]]>")
             when ::Ox::Element, ::Ox::Document
               current.nodes&.each { |child| stack << child }
             end
-            return [true, has_cdata] if has_er
+            return [true, has_cdata, has_patched] if has_er
           end
-          [has_er, has_cdata]
+          [has_er, has_cdata, has_patched]
         end
 
         def has_declaration?(native_doc, _wrapper)

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.95"
+  VERSION = "0.5.97"
 end

data/spec/moxml/adapter/ox_spec.rb

@@ -110,4 +110,34 @@ RSpec.describe Moxml::Adapter::Ox do
       end
     end
   end
+
+  # moxml#301: text enumeration hands out CustomizedOx::Text
+  # (String children are patched so they can carry a parent); dup or
+  # append of an enumerated wrapper plants the subclass instance in
+  # the raw tree, and ::Ox.dump rejects classes it does not know.
+  # The custom-serialize gate must trip on it (has_patched_text).
+  describe "duped and appended text nodes serialize" do
+    let(:ctx) { Moxml.new(:ox) }
+
+    it "round-trips a duped text appended to a parsed tree" do
+      doc = ctx.parse(%(<r><a>t</a></r>))
+      doc.root.add_child(doc.root.children[0].children[0].dup)
+      expect(doc.to_xml).to eq(%(<r><a>t</a>t</r>))
+    end
+
+    it "round-trips an enumerated text moved into a built document" do
+      src = ctx.parse(%(<r>x</r>))
+      built = ctx.create_document
+      root = built.create_element("r")
+      built.root = root
+      root.add_child(src.root.children[0].dup)
+      expect(built.to_xml).to eq("<r>x</r>")
+    end
+
+    it "round-trips a cloned text appended deep" do
+      doc = ctx.parse(%(<r><a>keep</a></r>))
+      doc.root.children[0].add_child(doc.root.children[0].children[0].clone)
+      expect(doc.to_xml).to eq(%(<r><a>keepkeep</a></r>))
+    end
+  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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.95
+  version: 0.5.97
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-30 00:00:00.000000000 Z
+date: 2026-10-01 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -461,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