moxml 0.5.45 → 0.5.47

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f552fee96842dca761f5e88ba1f5074e6cfdaef32411b012e2bf30a6736a16c4
-  data.tar.gz: 68c734aa63688134b897a1e29e8abfa292a02534daefd278b727122ad952e4e3
+  metadata.gz: 83f4ac58d2c22de225ec143ff3e78eb95e3460863b8fb1d67e8230a872bfad2a
+  data.tar.gz: c7401f4154a32e534a1c6a53f067a25406b16056de651eec8e768ac04c602dcc
 SHA512:
-  metadata.gz: ff775d10b05c5e60fcbf59c66e49284b841e4148b7da7766393b351b47bb626697a34bb5f30cf0d697d8a578ed07c1a9b8b7987507364c436c7c274be380843f
-  data.tar.gz: 7bbaef0118ea13de356dc95041dca057d59373f96eec6a4621a38d1cce07b283ca682b3fd2db77eea34f8d9252aaca821cf2651cbbbebbf0e7e171dd0d51f0f5
+  metadata.gz: d0ad7a04cbac82f8195be3be4318ee7d381974a812c7c2fce45110778875abfcb0be7ebb0c8e19339ddf2c2d8d9f4bd575254062b492a9cf4ad35072d8fe67fd
+  data.tar.gz: 301188cc44df6af9339502db3694651cc2a69238e3c222f6c0cda92393e72b80d5353cca335671be6b6560d5d64da4c32ad3bc4484f91d12239ddebf677e6aec

data/Gemfile

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

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/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/element.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 module Moxml
-  class Element < Node
+  # Instance behavior for Moxml::Element, extracted so the leptris
+  # adapter can extend natives with it in place (issue #230); the
+  # class remains the consumer-facing contract.
+  module ElementBehavior
     def name
       # The adapter read is an FFI call plus (on several adapters) a
       # defensive string copy; names only change through name= and
@@ -359,4 +362,8 @@ module Moxml
       context.bump_namespace_scope_generation
     end
   end
+
+  class Element < Node
+    include ElementBehavior
+  end
 end

data/lib/moxml/node.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 module Moxml
-  class Node
+  # Instance behavior for Moxml::Node, extracted so the leptris
+  # adapter can extend natives with it in place (issue #230); the
+  # class remains the consumer-facing contract and the wrap factory.
+  module NodeBehavior
     include XmlUtils
     include Enumerable
 
@@ -441,37 +444,6 @@ module Moxml
       nil
     end
 
-    # Registry mapping node type symbols to wrapper classes.
-    # Built lazily to avoid load-order issues with subclasses.
-    def self.node_type_map
-      @node_type_map ||= {
-        element: Element,
-        text: Text,
-        cdata: Cdata,
-        comment: Comment,
-        processing_instruction: ProcessingInstruction,
-        document: Document,
-        declaration: Declaration,
-        doctype: Doctype,
-        attribute: Attribute,
-        entity_reference: EntityReference,
-      }.freeze
-    end
-
-    def self.wrap(node, context)
-      return nil if node.nil?
-
-      cached = context.wrapper_for(node)
-      return cached if cached
-
-      adapter = adapter(context)
-      type = adapter.node_type(node)
-      klass = node_type_map[type] || self
-
-      klass.new(node, context, adapter, type)
-        .tap { |wrapper| context.register_wrapper(node, wrapper) }
-    end
-
     # Internal: Set the parent node for cache invalidation tracking.
     # Called by NodeSet, Document, Element when establishing parent-child
     # relationships. Public to allow cross-class usage within Moxml internals.
@@ -485,12 +457,6 @@ module Moxml
 
     protected
 
-    def self.adapter(context)
-      context.config.adapter
-    end
-
-    # Invalidate cached children. Called by mutation methods
-    # and by Element attribute/namespace caches.
     def invalidate_children_cache!
       @children = nil
     end
@@ -545,4 +511,44 @@ module Moxml
       xml.gsub(/\r?\n/, line_ending)
     end
   end
+
+  class Node
+    include NodeBehavior
+
+    def self.node_type_map
+      @node_type_map ||= {
+        element: Element,
+        text: Text,
+        cdata: Cdata,
+        comment: Comment,
+        processing_instruction: ProcessingInstruction,
+        document: Document,
+        declaration: Declaration,
+        doctype: Doctype,
+        attribute: Attribute,
+        entity_reference: EntityReference,
+      }.freeze
+    end
+
+    def self.wrap(node, context)
+      return nil if node.nil?
+
+      cached = context.wrapper_for(node)
+      return cached if cached
+
+      adapter = adapter(context)
+      type = adapter.node_type(node)
+      klass = node_type_map[type] || self
+
+      klass.new(node, context, adapter, type)
+        .tap { |wrapper| context.register_wrapper(node, wrapper) }
+    end
+
+    def self.adapter(context)
+      context.config.adapter
+    end
+
+    # Invalidate cached children. Called by mutation methods
+    # and by Element attribute/namespace caches.
+  end
 end

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.5.45"
+  VERSION = "0.5.47"
 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.45
+  version: 0.5.47
 platform: ruby
 authors:
 - Ribose Inc.