moxml 0.5.51 → 0.5.52

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb379e02cd764ce5e8cae044e9adc1724f8efe0ba4e5d218f7a8a5621363fa6d
-  data.tar.gz: ebd5156591fe35f41b6f67d4f54577485615a5d777abb072ad2413d1f02a7a59
+  metadata.gz: 5b9e4f8b355a983117cbc435343e414c731791232b8ecee131f5de68fe8e7ce8
+  data.tar.gz: 9409d7e0b355d76423acb9abbc812a09665110c53ba29e04cf838d486d257c4e
 SHA512:
-  metadata.gz: d8090ca95f64b7d6a42449e2159cac6c68ecef2520c87c231311c2598a8de0a6b35a41f0656068a2816a6f72bbb6cb636033a80f0b94a0c0f903e17fc112b0bc
-  data.tar.gz: c9c1b1766519455679f8b1fdda3003c5ade352e31846bf2443875944656e5457b08f9607eb603d2a26e5096638fb15eb515537a040b39c7b219829804f3a94e8
+  metadata.gz: '028a06c0b8f3e041f4ac257df4104052137f4d64d590d1be2c58f093dbf6909685767924c08914e1624daeb7bb8d419e2ad034ae61003a5099e7c673c7ced58b'
+  data.tar.gz: 0f737e2a0055194c05492bfebee65253e5a45fffecdd610e0c1f46b53728e23483acc44cdd48165313c213b8fca597685e1bf8e0f28db6afa8a67c28ae1c4167

data/lib/moxml/adapter/base.rb

@@ -213,9 +213,9 @@ namespace_validation_mode: :strict)
           create_native_namespace(element, prefix, uri)
         end
 
-        def create_entity_reference(name)
+        def create_entity_reference(name, owner_doc = nil)
           validate_entity_reference_name(name)
-          create_native_entity_reference(name)
+          create_native_entity_reference(name, owner_doc)
         end
 
         # Mutation return contract: protocol methods that may change

data/lib/moxml/adapter/leptris.rb

@@ -103,6 +103,14 @@ module Moxml
         NN_ADD_CHILD = NN.instance_method(:add_child)
       end
 
+      # Entity-reference preservation (leptris-ruby#212 / upstream
+      # #1094): 1.9.177 ships ParseOptions.keep_entity_refs plus
+      # first-class EntityReference nodes — the marker machinery
+      # becomes bypassable when the Context's entity_mode is :keep.
+      NATIVE_ENTITY_REFS =
+        defined?(::Leptris::XML::EntityReference) &&
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.177")
+
       # 1.9.163.2 moved the native bulk children into C
       # (Native.bulk_children) and fixed the 512 truncation
       # (leptris-ruby#202). The 162.6-163.1 window carries the
@@ -493,7 +501,15 @@ module Moxml
           xml_string = xml.is_a?(IO) || xml.is_a?(StringIO) ? xml.read : xml.to_s
           # The marker flag rides preprocess's own `&` scan — no
           # second full-buffer probe (issue #132 parse-side note).
-          processed, entity_markers = Entity.preprocess_with_marker_flag(xml_string)
+          entity_mode_keep =
+            NATIVE_ENTITY_REFS &&
+            (_context&.config&.entity_mode == :keep || options[:keep_entity_refs] == true)
+          processed, entity_markers =
+            if entity_mode_keep
+              [xml_string, false]
+            else
+              Entity.preprocess_with_marker_flag(xml_string)
+            end
 
           # readonly: true (issue #133): the binding memoizes reads and
           # refuses mutations — the parse-and-read lifecycle for
@@ -504,7 +520,7 @@ module Moxml
             ::Leptris::XML::Document.parse(
               processed,
               readonly: options[:readonly] == true,
-              options: parse_flags(options),
+              options: parse_flags(options, context: _context),
             )
           rescue ::Leptris::XML::ParseError => e
             # libleptris has no recovery mode that survives unclosed
@@ -534,6 +550,7 @@ module Moxml
 
           record_source_declaration(native_doc, processed)
           attachments.set(native_doc, :entity_markers, entity_markers)
+          attachments.set(native_doc, :keep_entity_refs, entity_mode_keep)
           bump_serialize_generation
           attachments.set(native_doc, :parse_errors, recover_errors) if recover_errors
 
@@ -601,9 +618,12 @@ 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.
-        def parse_flags(options)
+        def parse_flags(options, context: nil)
           flags = 0
           flags |= ::Leptris::XML::ParseOptions::DTDATTR if options[:dtdattr] == true
+          flags |= ::Leptris::XML::ParseOptions::KEEP_ENTITY_REFS if NATIVE_ENTITY_REFS &&
+            (context&.config&.entity_mode == :keep ||
+             options[:keep_entity_refs] == true)
           flags |= ::Leptris::XML::ParseOptions::NOBLANKS if options[:noblanks] == true && ENGINE_NOBLANKS_SAFE
           flags.zero? ? nil : ::Leptris::XML::ParseOptions.new(flags)
         end
@@ -698,11 +718,18 @@ module Moxml
           CustomizedLeptris::Declaration.new(version, encoding, standalone)
         end
 
-        def create_native_entity_reference(name)
+        def create_native_entity_reference(name, owner_doc = nil)
+          if NATIVE_ENTITY_REFS && owner_doc
+            return owner_doc.create_entity_reference(name.to_s)
+          end
+
           CustomizedLeptris::EntityReference.new(name)
         end
 
         def entity_reference_name(node)
+          return node.name if NATIVE_ENTITY_REFS &&
+            node.is_a?(::Leptris::XML::EntityReference)
+
           node.name if node.is_a?(CustomizedLeptris::EntityReference)
         end
 
@@ -884,6 +911,7 @@ module Moxml
           when ::Leptris::XML::DocType, CustomizedLeptris::Doctype then :doctype
           when CustomizedLeptris::Declaration then :declaration
           when CustomizedLeptris::EntityReference then :entity_reference
+          when ::Leptris::XML::EntityReference then :entity_reference if NATIVE_ENTITY_REFS
           else :unknown
           end
         end
@@ -945,6 +973,11 @@ module Moxml
         end
 
         def children(node, entity_bearing: false)
+          if NATIVE_ENTITY_REFS &&
+              native_keep_entity_refs?(node)
+            return to_binding(node).children.to_a
+          end
+
           if NATIVE_READ_LAYER && node.is_a?(::Leptris::XML::NativeNode)
             # Bulk C children through moxml's own scratch (see
             # NATIVE_READ_LAYER note above). Entity-marker documents
@@ -1007,6 +1040,13 @@ module Moxml
           end
         end
 
+        def native_keep_entity_refs?(node)
+          return false unless node.is_a?(::Leptris::XML::NativeNode)
+
+          doc = NN_DOCUMENT.bind_call(node)
+          attachments.get(doc, :keep_entity_refs) == true
+        end
+
         def parent(node)
           if NATIVE_READ_LAYER && node.is_a?(::Leptris::XML::NativeNode)
             parent = NN_PARENT.bind_call(node)

data/lib/moxml/adapter/libxml.rb

@@ -198,7 +198,7 @@ module Moxml
           CustomizedLibxml::Text.new(native)
         end
 
-        def create_native_entity_reference(name)
+        def create_native_entity_reference(name, _owner_doc = nil)
           CustomizedLibxml::EntityReference.new(name)
         end
 

data/lib/moxml/adapter/nokogiri.rb

@@ -172,7 +172,7 @@ module Moxml
           )
         end
 
-        def create_native_entity_reference(name)
+        def create_native_entity_reference(name, _owner_doc = nil)
           ::Nokogiri::XML::EntityReference.new(create_document, name)
         end
 

data/lib/moxml/adapter/oga.rb

@@ -103,7 +103,7 @@ module Moxml
           text
         end
 
-        def create_native_entity_reference(name)
+        def create_native_entity_reference(name, _owner_doc = nil)
           text = ::Oga::XML::Text.new
           text.text = "#{Entity::MARKER}#{name};"
           attachments.set(text, :entity_name, name)
@@ -561,6 +561,20 @@ module Moxml
           )
         end
 
+        # Whether this oga build honors the indent option (newer
+        # releases do; the capability probe keeps the indentation
+        # spec pending-or-live across both).
+        def indents_output?
+          return @indents_output unless @indents_output.nil?
+
+          probe = ::Oga::XML::Document.new
+          el = ::Oga::XML::Element.new(name: "r")
+          el.children << ::Oga::XML::Text.new(text: "t")
+          probe.children << el
+          @indents_output = serialize(probe, indent: 2).include?("
+  ")
+        end
+
         def serialize(node, options = {})
           serialize_without_entity_processing(node, options)
         end

data/lib/moxml/adapter/ox.rb

@@ -109,7 +109,7 @@ module Moxml
           content.dup
         end
 
-        def create_native_entity_reference(name)
+        def create_native_entity_reference(name, _owner_doc = nil)
           ::Moxml::Adapter::CustomizedOx::EntityReference.new(name)
         end
 

data/lib/moxml/adapter/rexml.rb

@@ -103,7 +103,7 @@ module Moxml
           ::REXML::Text.new(content.to_s, true, nil)
         end
 
-        def create_native_entity_reference(name)
+        def create_native_entity_reference(name, _owner_doc = nil)
           ::Moxml::Adapter::CustomizedRexml::EntityReference.new(name)
         end
 

data/lib/moxml/config.rb

@@ -24,6 +24,13 @@ module Moxml
     # - :optional - Try to load, continue silently if unavailable
     # - :disabled - Don't load entities, use empty registry
     # - :custom - Use custom entity provider via entity_provider callback
+    # Entity-reference preservation mode (leptris-ruby#212 / upstream
+    # #1094): :expand (default) keeps the shipped behavior (entities
+    # expanded at parse, marker-driven round-trip); :keep enables
+    # first-class EntityReference nodes and skips the marker machinery
+    # when the binding supports it (leptris >= 1.9.177).
+    ENTITY_MODES = %i[expand keep].freeze
+
     ENTITY_LOAD_MODES = %i[required optional disabled custom].freeze
 
     class << self
@@ -115,6 +122,7 @@ module Moxml
                   :entity_provider,
                   :namespace_validation_mode,
                   :entity_restoration_mode,
+                  :entity_mode,
                   :ox_skip,
                   :ox_mode
 
@@ -165,6 +173,7 @@ module Moxml
       @entity_provider = nil
       @namespace_validation_mode = :strict
       @entity_restoration_mode = :lenient
+      @entity_mode = :expand
     end
 
     def adapter=(name)
@@ -212,6 +221,16 @@ module Moxml
       @namespace_validation_mode = mode
     end
 
+    def entity_mode=(mode)
+      mode = mode.to_sym
+      unless ENTITY_MODES.include?(mode)
+        raise ArgumentError,
+              "Invalid entity_mode: #{mode.inspect}. Must be one of: #{ENTITY_MODES.join(', ')}"
+      end
+
+      @entity_mode = mode
+    end
+
     def entity_restoration_mode=(mode)
       mode = mode.to_sym
       unless ENTITY_RESTORATION_MODES.include?(mode)

data/lib/moxml/document.rb

@@ -99,7 +99,8 @@ module Moxml
     end
 
     def create_entity_reference(name)
-      Wrappers::EntityReference.new(adapter.create_entity_reference(name), context)
+      native = adapter.create_entity_reference(name, @native)
+      Wrappers::EntityReference.new(native, context)
     end
 
     def add_child(node)

data/lib/moxml/version.rb

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

data/spec/moxml/adapter/leptris_spec.rb

@@ -629,14 +629,46 @@ RSpec.describe Moxml::Adapter::Leptris do
       expect(doc.at_xpath("//a").to_xml).to eq("<a>text</a>")
     end
 
-    it "flips the flag when the builder mints an entity reference" do
-      doc = ctx.parse("<root><a/></root>")
-      expect(described_class.entity_bearing?(doc.root.native)).to be(false)
+    it "validates entity_mode" do
+      config = Moxml::Config.new(:leptris)
+      config.entity_mode = :keep
 
-      er = doc.create_entity_reference("nbsp")
-      doc.at_xpath("//a").add_child(er)
-      expect(described_class.entity_bearing?(doc.root.native)).to be(true)
-      expect(doc.at_xpath("//a").children.to_a.map { |k| k.is_a?(Moxml::EntityReference) }).to include(true)
+      expect(config.entity_mode).to eq(:keep)
+      expect { config.entity_mode = :invalid }.to raise_error(ArgumentError)
+    end
+
+    it "uses first-class entity references when requested on supported bindings" do
+      skip "requires leptris 1.9.177" unless described_class::NATIVE_ENTITY_REFS
+
+      keep_ctx = Moxml.new(:leptris) { |config| config.entity_mode = :keep }
+      doc = keep_ctx.parse("<root><a>pre &amp; middle &lt; post</a></root>")
+      children = doc.at_xpath("//a").children.to_a
+
+      expect(children.map(&:content)).to eq(["pre ", "", " middle ", "", " post"])
+      expect(children[1]).to be_a(Moxml::EntityReference)
+      expect(children[1].name).to eq("amp")
+      expect(children[3].name).to eq("lt")
+      expect(doc.to_xml).to include("pre &amp; middle &lt; post")
+    end
+
+    it "creates a first-class entity reference on supported bindings" do
+      skip "requires leptris 1.9.177" unless described_class::NATIVE_ENTITY_REFS
+
+      keep_ctx = Moxml.new(:leptris) { |config| config.entity_mode = :keep }
+      doc = keep_ctx.parse("<root><a/></root>")
+      reference = doc.create_entity_reference("copy")
+      doc.at_xpath("//a").add_child(reference)
+
+      expect(reference).to be_a(Moxml::EntityReference)
+      expect(reference.name).to eq("copy")
+      expect(doc.to_xml).to include("&copy;")
+    end
+
+    it "keeps expansion as the default entity mode" do
+      doc = Moxml.new(:leptris).parse("<root>a &amp; b</root>")
+
+      expect(doc.root.children.first).to be_a(Moxml::Text)
+      expect(doc.root.children.first.content).to eq("a & b")
     end
   end
 

data/spec/moxml/adapter/shared_examples/adapter_contract.rb

@@ -334,7 +334,8 @@ RSpec.shared_examples "xml adapter" do
     end
 
     it "respects indentation settings" do
-      if described_class.name.include?("Oga")
+      if described_class.name.include?("Oga") &&
+          !described_class.indents_output?
         pending("Oga does not support indentation settings")
       end
       if described_class.name.include?("Libxml")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.51
+  version: 0.5.52
 platform: ruby
 authors:
 - Ribose Inc.