moxml 0.5.44 → 0.5.46

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd5c99b547004d2f6521f882b006da2b612ee74cabf92775a3b061d9f096bc20
-  data.tar.gz: 652bce88c043068ecd97ef7008044557f764661a2e792f1128d435d4e83d715a
+  metadata.gz: 3b15f3ffeac134fbaa674a8e2970ae5606dd1e08985f288d01c48323ffeca4f1
+  data.tar.gz: 43f616e34f485d21bbc431cd42da7347e404647a71e0e84af697e205e24067a1
 SHA512:
-  metadata.gz: ba8297809db361e15cac3cbfbc132aa5545ceee6fe4e3d8b7df9a6250e7585ce930eaf7ba7d15de155975848f0d2deb205dcf8b0ebbdd3e00d96cbfc8d758633
-  data.tar.gz: 982406a0ff5f858aeed1569fd4ca1d4536bbb2b9841d791b4f560475b19b77641db0831fac7efd6760c3493216a9db8635de55d5e146f158cc0f16297fc97895
+  metadata.gz: 7007190eea32272f8be0de72b5a11f9b4d66cc0108cff530986443012a46814a886b34f925649593139c3d0cd7d4bf13d91d4088ae19be71ad150cc8464436de
+  data.tar.gz: f967159613aa7c650d3d58c05b1dc7cb5376d975c01496e69aabc6f3c8d5631fcd9bb8dcb3c05320b3e345cf44fdd5cce922da0ca38079c4d7c322e39fb9dd72

data/docs/_pages/adapters/ox.adoc

@@ -17,6 +17,21 @@ Ox is the fastest XML parser available for Ruby, providing excellent performance
 * Memory-constrained environments
 * When XPath usage is minimal
 
+=== Parse options (issue #189)
+
+The adapter parses with `Ox.load` (not `Ox.parse`, which hardcodes `skip: :skip_white` and collapses whitespace runs inside text content). Two knobs flow through the parse options:
+
+* `ox_skip` (default `Moxml::Config::OX_DEFAULT_SKIP`, `:skip_none`) — Ox's whitespace policy. `:skip_none` keeps every character of text content, so `xml:space="preserve"` documents round-trip intact; `:skip_white` restores the collapsing behavior. Inter-element indentation is dropped by Ox's generic mode under every skip setting, so child lists are identical either way.
+* `ox_mode` (default `:generic`) — Ox's load mode. Only `:generic` yields the tree the adapter walks; `:hash` and `:object` fail loudly rather than corrupt.
+
+Set the policy once per context or per parse:
+
+[source,ruby]
+----
+ctx = Moxml.new(:ox) { |c| c.ox_skip = :skip_white }  # context default
+doc = ctx.parse(xml, ox_skip: :skip_none)              # per-parse wins
+----
+
 == Specific adapter limitations
 
 === Ox adapter

data/lib/moxml/adapter/leptris/document_parts.rb

@@ -139,27 +139,43 @@ module Moxml
         # facade's canonical form (checked post-hoc: a source
         # declaration carrying standalone or another version would
         # diverge).
+        # 1.9.174 attached leptris_document_first_child (libleptris
+        # 1.9.174): pointer probe for the single-child document
+        # shape without wrapping the child chain.
+        DOCUMENT_CHILD_PTRS =
+          ::Leptris::XML::FFI.respond_to?(:leptris_document_first_child)
+
         def fast_document_output(doc, options)
           return nil unless LIBXML2_LAYOUT_PARITY
-          return nil if attachments.get(doc, :declaration) ||
-            attachments.get(doc, :doctype) ||
-            attachments.get(doc, :document_text) ||
-            attachments.get(doc, :entity_markers)
+          return nil unless attachments.none_set?(
+            doc, %i[declaration doctype document_text entity_markers]
+          )
 
           include_decl = !options[:no_declaration] && options.fetch(:declaration) do
             document_has_declaration?(doc)
           end
 
-          root_seen = false
-          doc.children.each do |child|
-            if child.is_a?(::Leptris::XML::Element)
-              return nil if root_seen
-
-              root_seen = true
-            elsif root_seen
-              # Epilog parts glue directly to the root in the engine's
-              # document output — compose those.
-              return nil
+          # Exactly one document child — the root — is the common
+          # parsed shape; pointer probes decide it without wrapping
+          # the child chain. Anything else (prolog/epilog parts,
+          # multi-root) falls back to the scan.
+          root = doc.root
+          single_child = DOCUMENT_CHILD_PTRS && root &&
+            ::Leptris::XML::FFI.leptris_document_first_child(doc.c_ptr)
+              .address == root.c_ptr.address &&
+            root.next_sibling.nil?
+          unless single_child
+            root_seen = false
+            doc.children.each do |child|
+              if child.is_a?(::Leptris::XML::Element)
+                return nil if root_seen
+
+                root_seen = true
+              elsif root_seen
+                # Epilog parts glue directly to the root in the engine's
+                # document output — compose those.
+                return nil
+              end
             end
           end
 

data/lib/moxml/adapter/ox.rb

@@ -39,7 +39,15 @@ module Moxml
         def parse(xml, options = {}, _context = nil)
           processed_xml = preprocess_entities(xml)
           native_doc = begin
-            result = ::Ox.parse(processed_xml)
+            # ::Ox.parse has arity 1 and hardcodes skip: :skip_white;
+            # ::Ox.load takes the policy (issue #189). Both knobs flow
+            # from Config through Context#default_options; the fetch
+            # defaults keep direct adapter calls context-free.
+            result = ::Ox.load(
+              processed_xml,
+              skip: options.fetch(:ox_skip, Moxml::Config::OX_DEFAULT_SKIP),
+              mode: options.fetch(:ox_mode, Moxml::Config::OX_DEFAULT_MODE),
+            )
 
             # result can be either Document or Element
             if result.is_a?(::Ox::Document)

data/lib/moxml/config.rb

@@ -93,6 +93,18 @@ module Moxml
     # - :strict — only restore DTD-declared entities (falls back to lenient until DTD parsing is implemented)
     ENTITY_RESTORATION_MODES = %i[strict lenient].freeze
 
+    # Ox whitespace policy (issue #189): ::Ox.parse hardcodes
+    # skip: :skip_white, which collapses whitespace runs inside text
+    # content — xml:space="preserve" documents round-trip mangled.
+    # The adapter parses with ::Ox.load instead; these defaults keep
+    # every character of text content (inter-element indentation is
+    # dropped by Ox's generic mode under every skip setting, so the
+    # child lists stay identical to the old parse).
+    OX_DEFAULT_SKIP = :skip_none
+    OX_DEFAULT_MODE = :generic
+    OX_VALID_SKIPS = %i[skip_none skip_white skip_off].freeze
+    OX_VALID_MODES = %i[generic hash object].freeze
+
     attr_reader :adapter_name, :default_line_ending
     attr_accessor :strict_parsing,
                   :default_encoding,
@@ -102,7 +114,27 @@ module Moxml
                   :entity_load_mode,
                   :entity_provider,
                   :namespace_validation_mode,
-                  :entity_restoration_mode
+                  :entity_restoration_mode,
+                  :ox_skip,
+                  :ox_mode
+
+    def ox_skip=(value)
+      unless OX_VALID_SKIPS.include?(value)
+        raise ArgumentError,
+              "Invalid ox_skip: #{value.inspect}. Must be one of #{OX_VALID_SKIPS.inspect}"
+      end
+
+      @ox_skip = value
+    end
+
+    def ox_mode=(value)
+      unless OX_VALID_MODES.include?(value)
+        raise ArgumentError,
+              "Invalid ox_mode: #{value.inspect}. Must be one of #{OX_VALID_MODES.inspect}"
+      end
+
+      @ox_mode = value
+    end
 
     def default_line_ending=(value)
       unless VALID_LINE_ENDINGS.include?(value)
@@ -118,6 +150,12 @@ module Moxml
                    default_encoding = nil)
       self.adapter = adapter_name || Config.default.adapter_name
       @strict_parsing = strict_parsing || Config.default.strict_parsing
+      # Constant-initialized (not Config.default fallback): the
+      # default Config constructs via Config.default — a fallback
+      # read there recurses. Global-default propagation for these
+      # knobs is not part of the contract; per-context is (#189).
+      @ox_skip = OX_DEFAULT_SKIP
+      @ox_mode = OX_DEFAULT_MODE
       @default_encoding = default_encoding || Config.default.default_encoding
       @default_indent = 2
       @default_line_ending = LINE_ENDING_LF

data/lib/moxml/context.rb

@@ -233,6 +233,8 @@ module Moxml
         encoding: config.default_encoding,
         strict: config.strict_parsing,
         indent: config.default_indent,
+        ox_skip: config.ox_skip,
+        ox_mode: config.ox_mode,
       }
     end
   end

data/lib/moxml/native_attachment/native.rb

@@ -43,6 +43,13 @@ module Moxml
         end
       end
 
+      def none_set?(native, keys)
+        h = @data[native.object_id]
+        return true if h.nil?
+
+        keys.none? { |key| h.key?(key) }
+      end
+
       def key?(native, key)
         h = @data[native.object_id]
         !h.nil? && h.key?(key)

data/lib/moxml/native_attachment/opal.rb

@@ -13,6 +13,10 @@ module Moxml
         native.instance_variable_set(attachment_ivar_name(key), value)
       end
 
+      def none_set?(native, keys)
+        keys.none? { |key| native.instance_variable_defined?(attachment_ivar_name(key)) }
+      end
+
       def key?(native, key)
         native.instance_variable_defined?(attachment_ivar_name(key))
       end

data/lib/moxml/native_attachment.rb

@@ -20,6 +20,12 @@ module Moxml
       @backend.get(native, key)
     end
 
+    # One probe for "none of these keys are set" — the document
+    # serialize gate asks about four keys per call.
+    def none_set?(native, keys)
+      @backend.none_set?(native, keys)
+    end
+
     def set(native, key, value)
       @backend.set(native, key, value)
     end

data/lib/moxml/version.rb

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

data/spec/integration/shared_examples/edge_cases.rb

@@ -157,6 +157,13 @@ RSpec.shared_examples "Moxml Edge Cases" do
     end
   end
 
+  describe "text content whitespace preservation" do
+    it "preserves whitespace runs inside text content (xml:space, issue #189)" do
+      doc = context.parse(%(<r xml:space="preserve"><t>  spaced  </t></r>))
+      expect(doc.root.children.first.text).to eq("  spaced  ")
+    end
+  end
+
   describe "whitespace text node preservation" do
     # Ox/HeadedOx do not generate whitespace-only text nodes in their parser,
     # so these tests only apply to adapters that do (Nokogiri, OGA, REXML, LibXML)

data/spec/moxml/adapter/ox_spec.rb

@@ -68,5 +68,46 @@ RSpec.describe Moxml::Adapter::Ox do
       count = described_class.xpath(doc, "count(//child)")
       expect(count).to eq(2)
     end
+
+    describe "parse whitespace policy" do
+      it "preserves whitespace runs inside text content by default (issue #189)" do
+        doc = described_class.parse(%(<r xml:space="preserve"><t>  spaced  </t></r>))
+        expect(doc.root.children.first.text).to eq("  spaced  ")
+      end
+
+      it "collapses runs with a per-parse ox_skip: :skip_white" do
+        doc = described_class.parse(%(<r><t>  spaced  </t></r>), ox_skip: :skip_white)
+        expect(doc.root.children.first.text).to eq(" spaced ")
+      end
+
+      it "honors a context default set once on the config" do
+        context = Moxml.new(:ox) { |c| c.ox_skip = :skip_white }
+        doc = context.parse(%(<r><t>  s  </t></r>))
+        expect(doc.root.children.first.text).to eq(" s ")
+      end
+
+      it "lets a per-parse option beat the context default" do
+        context = Moxml.new(:ox) { |c| c.ox_skip = :skip_white }
+        doc = context.parse(%(<r><t>  s  </t></r>), ox_skip: :skip_none)
+        expect(doc.root.children.first.text).to eq("  s  ")
+      end
+
+      it "fails loudly on ox_mode: :hash (the adapter walks a tree, not a Hash)" do
+        expect { described_class.parse("<r><t> x </t></r>", ox_mode: :hash) }
+          .to raise_error(RuntimeError, /must be a String or Ox::Node/)
+      end
+
+      it "surfaces an invalid ox_skip as Moxml::ParseError" do
+        expect { described_class.parse("<r/>", ox_skip: :bogus) }
+          .to raise_error(Moxml::ParseError)
+      end
+
+      it "validates Config ox_skip/ox_mode assignments" do
+        expect { Moxml::Config.new.ox_skip = :bogus }
+          .to raise_error(ArgumentError, /Invalid ox_skip/)
+        expect { Moxml::Config.new.ox_mode = :bogus }
+          .to raise_error(ArgumentError, /Invalid ox_mode/)
+      end
+    end
   end
 end

metadata

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