moxml 0.5.79 → 0.5.81

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9314d43b66d5890286b147d882d0200e33adee9e61209e8088674be8205e11ea
-  data.tar.gz: 3ec14b4892a6ae2f0dd2a8d2bded06b86a0c86ce742b20f6763478df4a851963
+  metadata.gz: 957697bcb855cea040ac0d8b2f202a7cd8fd230482137602fcf7d50fc2712ebb
+  data.tar.gz: 22815ac3e9920a8939b0076f3b4222a154e0420d4fe1a21d9b7e56bd9b0818b8
 SHA512:
-  metadata.gz: bb2f60f496656598a90121c56039f620e4a46518753c9062262d4aa21a7c56db6b3d8b1fa5d3d87f4f45773a1de03d63e731e10ee95fc9fbe1c6d8bab5c3122d
-  data.tar.gz: 59d27148762e9b3837feb218bd42820a3a17291b8ac266b8868b730b19dc0d4d84abaa238f60e32a279c31673593dfc70f809d4cefd8b60c6deae173e8f63745
+  metadata.gz: 422b076bb191e01b27693af02a66d4e985f574dbcc49451c9af395c1905f9cabfdb2faf0e1b15303a5444c17a8fba98e70e5bea7d5c61f1f152d9fa09a550329
+  data.tar.gz: 2d75b66d322414ea8c99b79fe1ed78c7aa758b90b7f5b7f56a685e9f861bca12d6f641803aa04ced575a812677a085619bd40ee435963b035cdbe005a36d1b55

data/Gemfile

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

data/lib/moxml/adapter/base.rb

@@ -358,6 +358,16 @@ namespace_validation_mode: :strict)
           nil
         end
 
+        # Single-crossing construction contract
+        # (Moxml::Element#add_element): create + attach under parent
+        # + all attributes in one call, returning the new native
+        # element. This default has no bulk face — nil sends the
+        # caller down the portable create_element + add_child path;
+        # adapters with the face override (leptris — #312/#1344).
+        def create_element_with_attrs(_parent, _name, _attrs)
+          nil
+        end
+
         # Read-only attribute listing as [name, value] pairs
         # (Moxml::Element#attribute_pairs) — document order,
         # duplicates included, no Attribute node wrappers. The

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Adapter
+    class Leptris
+      # Replays the engine's bulk SAX record table (leptris#1298) to
+      # the bridge protocol. One drain crossing replaces the
+      # per-event recorder replay; the only String materializations
+      # left are the name/value/text data the handler actually
+      # consumes. End events reconstruct from the records' parent
+      # indices with a name-carrying stack — pre-order records make
+      # a parent mismatch the exact close boundary, and
+      # self-closing elements pop at their next sibling, matching
+      # the callback engine's event stream.
+      #
+      # @private
+      class SaxRecordReplay
+        KIND_ELEMENT = ::Leptris::XML::SAX::Records::KIND_ELEMENT
+
+        def initialize(bridge)
+          @bridge = bridge
+        end
+
+        def run(table)
+          @bridge.start_document
+          idx_stack = []
+          name_stack = []
+          count = table.count
+          i = 0
+          while i < count
+            while !idx_stack.empty? && table.parent(i) != idx_stack.last
+              idx_stack.pop
+              @bridge.end_element(name_stack.pop)
+            end
+            if table.kind(i) == KIND_ELEMENT
+              name = table.view(i)
+              pairs = []
+              k = table.attr_first(i)
+              last = k + table.attr_count_of(i)
+              while k < last
+                v = table.attr_value(k)
+                pairs << [table.attr_name(k),
+                          table.attr_value_has_ws?(k) ? v.tr("\t\n\r", " ") : v]
+                k += 1
+              end
+              @bridge.start_element(name, pairs)
+              idx_stack << i
+              name_stack << name
+            else
+              @bridge.characters(table.view(i))
+            end
+            i += 1
+          end
+          @bridge.end_element(name_stack.pop) until name_stack.empty?
+          @bridge.end_document
+        end
+      end
+    end
+  end
+end

data/lib/moxml/adapter/leptris.rb

@@ -130,6 +130,15 @@ module Moxml
         defined?(::Leptris::XML::NativeNode) &&
         Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.163.2")
 
+      # Bulk SAX record drain (leptris#1298): leptris_sax_records_parse
+      # + Leptris::XML::SAX::Records — one crossing per document,
+      # handlers replay or walk the table. Ships in the binding ride
+      # 1.9.240.0 (1.9.239.0 predates the walker — the gate must name
+      # the carrying release, not the engine surface). Dev floor pins
+      # ~> 1.9.238; older bindings take the callback Parser below.
+      NATIVE_SAX_RECORDS =
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.240")
+
       # Defined unconditionally: the body self-guards, and call
       # sites must never depend on the layer having loaded
       # (issue #217 — binding-only installs crashed on the
@@ -522,6 +531,7 @@ module Moxml
       autoload :Materialize, "moxml/adapter/leptris/materialize"
       autoload :Serialize, "moxml/adapter/leptris/serialize"
       autoload :LeptrisSAXBridge, "moxml/adapter/leptris/sax_bridge"
+      autoload :SaxRecordReplay, "moxml/adapter/leptris/sax_record_replay"
       extend Serialize
       extend DocumentParts
       extend Markers
@@ -1488,6 +1498,32 @@ module Moxml
           line.zero? ? nil : line
         end
 
+        # Single-crossing construction (#312/#1344 consumer face):
+        # create + attach under parent + all attributes in ONE
+        # Ruby->C call (create_child is create+attach; the attr
+        # loop is C->C dlsym). Requires parent binding + the face;
+        # callers fall back to create_element + set_attribute +
+        # add_child when absent.
+        def create_element_with_attrs(parent, name, attrs)
+          binding_parent = to_binding(parent)
+          doc = binding_parent.document or return nil
+          return nil unless ::Leptris::XML::Native.respond_to?(:create_element_with_attrs)
+
+          flat = attrs.flatten
+          addr = ::Leptris::XML::Native.create_element_with_attrs(
+            doc.c_address, binding_parent.c_address, name.to_s, flat
+          )
+          return nil if addr.nil? || addr.zero?
+
+          # The binding's own wrap produces the proper binding
+          # Element (kind class, @c_address, @document); canonical
+          # convergence (#219) hands every accessor — children
+          # included — the SAME native, so the wrapper identity
+          # holds across later traversals.
+          canonical_native(doc,
+                           ::Leptris::XML::Node.wrap(::FFI::Pointer.new(addr), doc))
+        end
+
         def attributes(element)
           element = to_binding(element)
           element.attribute_nodes
@@ -2089,7 +2125,25 @@ module Moxml
         def sax_parse(xml, handler)
           bridge = LeptrisSAXBridge.new(handler)
           xml_string = xml.is_a?(IO) || xml.is_a?(::StringIO) ? xml.read : xml.to_s
-          ::Leptris::XML::SAX::Parser.new(bridge).parse(xml_string)
+          # Bulk record drain (leptris#1298, NATIVE_SAX_RECORDS):
+          # one crossing per document. The handler decides the shape
+          # polymorphically — Handler#on_sax_records answers
+          # :unhandled, so classic handlers get the exact callback
+          # stream replayed from the table; hot loops override and
+          # walk the records (nil table = outside the drain subset
+          # or pre-1.9.238 binding — callback path).
+          table = NATIVE_SAX_RECORDS ? ::Leptris::XML::SAX::Records.open(xml_string) : nil
+          if table
+            begin
+              return if handler.on_sax_records(table) != :unhandled
+
+              SaxRecordReplay.new(bridge).run(table)
+            ensure
+              table.free
+            end
+          else
+            ::Leptris::XML::SAX::Parser.new(bridge).parse(xml_string)
+          end
         rescue ::Leptris::XML::ParseError, ::Leptris::XML::Error => e
           handler.on_error(Moxml::ParseError.new(e.message))
         end

data/lib/moxml/cdata.rb

@@ -11,5 +11,10 @@ module Moxml
     def content=(text)
       adapter.set_cdata_content(@native, normalize_xml_value(text))
     end
+
+    # See Moxml::Text#text — Node#text's base is "" for non-elements.
+    def text
+      content
+    end
   end
 end

data/lib/moxml/comment.rb

@@ -13,5 +13,10 @@ module Moxml
       adapter.validate_comment_content(text)
       adapter.set_comment_content(@native, text)
     end
+
+    # See Moxml::Text#text — Node#text's base is "" for non-elements.
+    def text
+      content
+    end
   end
 end

data/lib/moxml/element.rb

@@ -126,6 +126,29 @@ module Moxml
       adapter.attribute_pairs(@native)
     end
 
+    # Create an element with attributes and attach it under this
+    # element — ONE construction on adapters with the bulk face
+    # (leptris, #312/#1344 consumer face): create + attach + all
+    # attributes in a single Ruby->C crossing. Returns the child
+    # wrapper. Equivalent to create_element + attribute writes +
+    # add_child, minus two crossings and the intermediate churn.
+    def add_element(name, attrs = {})
+      native_child = adapter.create_element_with_attrs(
+        @native, name, attrs
+      )
+      if native_child
+        adapter.node_type(native_child)
+        Moxml::Node.wrap_with(native_child, context, adapter)
+      else
+        fallback = Moxml::Node.wrap_with(
+          adapter.create_element(name), context, adapter
+        )
+        attrs.each { |k, v| fallback[k] = v.to_s }
+        add_child(fallback)
+        fallback
+      end
+    end
+
     def attributes
       # Primed like Node.wrap: the adapter and type are known at
       # mint, so the first name/value/attribute? access skips the

data/lib/moxml/sax/handler.rb

@@ -108,6 +108,21 @@ module Moxml
       def on_warning(message)
         # Override in subclass if needed
       end
+
+      # Bulk SAX record surface (leptris#1298, leptris adapter only).
+      # On bindings with the drain the adapter hands the WHOLE
+      # document as a Leptris::XML::SAX::Records table — one crossing,
+      # no per-event marshaling; hot loops walk the records and
+      # materialize only what they consume (this default answers
+      # :unhandled, and the adapter replays the classic callback
+      # stream from the table instead — the events are identical).
+      #
+      # @param table [Leptris::XML::SAX::Records] record table, valid
+      #   only during the call
+      # @return [Object] anything but :unhandled claims the table
+      def on_sax_records(_table)
+        :unhandled
+      end
     end
   end
 end

data/lib/moxml/text.rb

@@ -21,5 +21,13 @@ module Moxml
     def to_s
       content
     end
+
+    # Node#text's base returns "" for non-element nodes; a text
+    # node's text IS its content (leptris's Reads layer already
+    # answered content here — the wrapper contract now matches on
+    # every adapter).
+    def text
+      content
+    end
   end
 end

data/lib/moxml/version.rb

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

data/spec/consistency/eol_normalization_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# XML 1.0 §2.11 End-of-Line Handling: literal CRLF and lone CR
+# normalize to LF in parsed character data, before tokenization —
+# so CDATA content normalizes too, while character references
+# (
) sit OUTSIDE the rule and must survive as CR. Attribute
+# values normalize EOL first, then §3.3.3 maps the break to a
+# space (libxml2 parity: "x\r\ny" -> "x y").
+#
+# Adapter status (verified 2026-09-25):
+#   nokogiri/libxml - conform on all three surfaces
+#   rexml           - text/cdata conform; attrs EOL-only ("x\ny")
+#   ox              - text/cdata conform; attrs raw; 
+#                     over-normalized to \n (upstream)
+#   oga             - preserves raw CR everywhere (upstream)
+#   leptris         - fixed in engine 1.9.240 (leptris#1355,
+#                     leptris-ruby#326); skipped below until the
+#                     binding release vending that engine rides
+#                     (gate: binding 1.9.240).
+RSpec.describe "XML line-ending normalization" do
+  ADAPTERS = %i[leptris nokogiri ox oga rexml libxml].freeze # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+
+  def with_adapter(name)
+    ctx = Moxml.new(name)
+    yield ctx
+  rescue LoadError
+    skip "adapter #{name} unavailable"
+  end
+
+  def leptris_fixed?(name)
+    return true unless name == :leptris
+
+    defined?(Leptris::VERSION) &&
+      Gem::Version.new(Leptris::VERSION) >= Gem::Version.new("1.9.240")
+  end
+
+  it "normalizes CRLF and lone CR to LF in text content" do
+    ADAPTERS.each do |name|
+      next unless leptris_fixed?(name)
+
+      skip "oga preserves raw CR (upstream)" if name == :oga
+
+      with_adapter(name) do |ctx|
+        text = ctx.parse("<r>a\r\nb\rc</r>").root.children.first
+        expect(text.content).to eq("a\nb\nc"), "#{name}: #{text.content.inspect}"
+      end
+    end
+  end
+
+  it "normalizes EOL inside CDATA content" do
+    ADAPTERS.each do |name|
+      next unless leptris_fixed?(name)
+
+      skip "oga preserves raw CR (upstream)" if name == :oga
+
+      with_adapter(name) do |ctx|
+        cdata = ctx.parse("<r><![CDATA[a\r\nb]]></r>").root.children.first
+        expect(cdata.content).to eq("a\nb"), "#{name}: #{cdata.content.inspect}"
+      end
+    end
+  end
+
+  it "preserves CR from character references" do
+    ADAPTERS.each do |name|
+      next unless leptris_fixed?(name)
+
+      skip "ox collapses &#13; to LF (upstream)" if name == :ox
+      skip "oga preserves raw CR (upstream)" if name == :oga
+
+      with_adapter(name) do |ctx|
+        text = ctx.parse("<r>a&#13;b</r>").root.children.first
+        expect(text.content).to eq("a\rb"), "#{name}: #{text.content.inspect}"
+      end
+    end
+  end
+
+  it "collapses attribute CRLF to a single space (libxml2 parity)" do
+    conforming = %i[nokogiri libxml leptris]
+    conforming.each do |name|
+      next unless leptris_fixed?(name)
+
+      with_adapter(name) do |ctx|
+        root = ctx.parse("<r a=\"x\r\ny\" b=\"x\ty\"/>").root
+        expect(root["a"]).to eq("x y"), "#{name}: attr CRLF #{root['a'].inspect}"
+        expect(root["b"]).to eq("x y"), "#{name}: attr tab #{root['b'].inspect}"
+      end
+    end
+  end
+end

data/spec/consistency/round_trip_spec.rb

@@ -295,16 +295,24 @@ def normalize_type_attribute(name, value)
   end
 end
 
-def test_element_content(element)
-  return nil unless element
+def test_element_content(node)
+  return nil unless node
+
+  # :text_content holds a Text node (from //text()) — Text#text now
+  # returns real content on every adapter, so this branch actually
+  # fires. Text nodes have no name/attributes/children.
+  unless node.is_a?(Moxml::Element)
+    return { name: nil, attributes: {}, text: node.text.to_s.strip,
+             namespace: nil, children_count: 0, xpath: [] }
+  end
 
   {
-    name: element.name,
-    attributes: universal_attributes(element),
-    text: element.text.to_s.strip,
-    namespace: element.namespace&.uri,
-    children_count: element.children.size,
-    xpath: element.xpath("//*"),
+    name: node.name,
+    attributes: universal_attributes(node),
+    text: node.text.to_s.strip,
+    namespace: node.namespace&.uri,
+    children_count: node.children.size,
+    xpath: node.xpath("//*"),
   }
 end
 

data/spec/moxml/adapter/leptris_sax_records_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Bulk SAX record drain (leptris#1298): on bindings carrying
+# Leptris::XML::SAX::Records the leptris adapter drains the document
+# in one crossing. Classic handlers must receive the SAME event
+# stream the callback Recorder produces (the replay reconstructs end
+# events from the records' parent indices), handlers overriding
+# on_sax_records claim the raw table instead, and raw attribute
+# whitespace is normalized (3.3.3) exactly where the callback path
+# normalizes it.
+module SaxDrainHandlers
+  class EventCollector < Moxml::SAX::Handler
+    attr_reader :events
+
+    def initialize
+      super
+      @events = []
+    end
+
+    def on_start_document
+      @events << [:start_document]
+    end
+
+    def on_end_document
+      @events << [:end_document]
+    end
+
+    def on_start_element(name, attributes = {}, _namespaces = {})
+      @events << [:start, name, attributes]
+    end
+
+    def on_end_element(name)
+      @events << [:end, name]
+    end
+
+    def on_characters(text)
+      @events << [:chars, text]
+    end
+  end
+
+  class TableClaimant < Moxml::SAX::Handler
+    attr_reader :tables
+
+    def initialize
+      super
+      @tables = []
+    end
+
+    def on_sax_records(table)
+      @tables << table
+      :claimed
+    end
+  end
+end
+
+RSpec.describe "leptris SAX record drain", if: defined?(Leptris::XML::SAX::Records) do
+  let(:context) { Moxml.new(:leptris) }
+  let(:xml) do
+    '<r a="x  y" xmlns="urn:default"><item n="1">t1</item>' \
+      '<item n="2">t2<b>k</b></item><last/></r>'
+  end
+
+  it "replays the callback event stream through the drain" do
+    drain_events = SaxDrainHandlers::EventCollector.new
+    context.sax_parse(xml, drain_events)
+
+    callback_events = SaxDrainHandlers::EventCollector.new
+    bridge = Moxml::Adapter::Leptris::LeptrisSAXBridge.new(callback_events)
+    Leptris::XML::SAX::Parser.new(bridge).parse(xml)
+
+    expect(drain_events.events).to eq(callback_events.events)
+    expect(drain_events.events.first).to eq([:start_document])
+    expect(drain_events.events).to include([:start, "item", { "n" => "1" }])
+    expect(drain_events.events).to include([:chars, "t2"])
+    expect(drain_events.events.last).to eq([:end_document])
+  end
+
+  it "hands claimed tables to handlers that opt in" do
+    claimant = SaxDrainHandlers::TableClaimant.new
+    context.sax_parse("<r><a>n</a></r>", claimant)
+
+    expect(claimant.tables.size).to eq(1)
+    expect(claimant.tables.first.count).to eq(3)
+  end
+end

data/spec/moxml/element_add_element_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Element#add_element adapter-contract conformance (#312): the
+# child must land attached with ALL attributes in one call —
+# through the bulk face (leptris) or the portable create_element +
+# add_child fallback (every other adapter). Guards both halves of
+# the contract: a missing base default NoMethodErrors on non-face
+# adapters, a broken fallback loses attributes or the attach.
+RSpec.describe Moxml::Element do
+  ADAPTERS = %i[leptris nokogiri ox oga rexml libxml].freeze # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+
+  def with_adapter(name)
+    ctx = Moxml.new(name)
+    yield ctx
+  rescue StandardError, LoadError
+    skip "adapter #{name} unavailable"
+  end
+
+  it "attaches a child with all attributes on every available adapter" do
+    ADAPTERS.each do |name|
+      with_adapter(name) do |ctx|
+        doc = ctx.parse("<catalog/>")
+        root = doc.root
+        child = root.add_element("record", "id" => "r1", "kind" => "k1")
+
+        expect(child.name).to eq("record"), "#{name}: name"
+        expect(child["id"]).to eq("r1"), "#{name}: id attr"
+        expect(child["kind"]).to eq("k1"), "#{name}: kind attr"
+        expect(child.parent.name).to eq("catalog"), "#{name}: attach"
+        expect(root.children.map(&:name)).to include("record"), "#{name}: visible in children"
+      end
+    end
+  end
+
+  it "nests under a non-root element with empty attrs" do
+    ADAPTERS.each do |name|
+      with_adapter(name) do |ctx|
+        doc = ctx.parse("<catalog><record/></catalog>")
+        record = doc.root.children.first
+        field = record.add_element("field")
+
+        expect(field.name).to eq("field"), "#{name}: name"
+        expect(field.attributes).to be_empty, "#{name}: no attrs"
+        expect(field.parent.name).to eq("record"), "#{name}: attach"
+      end
+    end
+  end
+end

data/spec/moxml/text_spec.rb

@@ -14,6 +14,23 @@ RSpec.describe Moxml::Text do
     end
   end
 
+  describe "#text" do
+    it "matches content on a text node" do
+      text = doc.root.children.first
+      expect(text.text).to eq("plain text")
+    end
+
+    it "is consistent across adapters" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        ctx = Moxml.new(adapter_name)
+        d = ctx.parse("<root>hello world</root>")
+        text = d.root.children.first
+        expect(text.text).to eq("hello world"),
+                             "Text#text for #{adapter_name} adapter"
+      end
+    end
+  end
+
   describe "#to_xml" do
     it "returns XML representation" do
       text = doc.root.children.first

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.79
+  version: 0.5.81
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-23 00:00:00.000000000 Z
+date: 2026-09-25 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -160,6 +160,7 @@ files:
 - lib/moxml/adapter/leptris/markers.rb
 - lib/moxml/adapter/leptris/materialize.rb
 - lib/moxml/adapter/leptris/sax_bridge.rb
+- lib/moxml/adapter/leptris/sax_record_replay.rb
 - lib/moxml/adapter/leptris/serialize.rb
 - lib/moxml/adapter/libxml.rb
 - lib/moxml/adapter/libxml/entity_ref_registry.rb
@@ -300,6 +301,7 @@ files:
 - sig/moxml.rbs
 - spec/consistency/README.md
 - spec/consistency/adapter_parity_spec.rb
+- spec/consistency/eol_normalization_spec.rb
 - spec/consistency/round_trip_spec.rb
 - spec/examples/README.md
 - spec/examples/attribute_examples_spec.rb
@@ -435,6 +437,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_sax_records_spec.rb
 - spec/moxml/adapter/leptris_spec.rb
 - spec/moxml/adapter/libxml_internals_spec.rb
 - spec/moxml/adapter/libxml_spec.rb
@@ -468,6 +471,7 @@ files:
 - spec/moxml/document_free_spec.rb
 - spec/moxml/document_parse_diagnostics_spec.rb
 - spec/moxml/document_spec.rb
+- spec/moxml/element_add_element_spec.rb
 - spec/moxml/element_attribute_pairs_spec.rb
 - spec/moxml/element_spec.rb
 - spec/moxml/entity_preservation_spec.rb