moxml 0.5.80 → 0.5.82

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 656e065f07ecc3aea2624682345254907cab3bee557d14a74e7a9a1e6d3e53f2
-  data.tar.gz: d3606b240493ed82eb131bb8dd37e7d011bcd4d7d12d8907407c5408fcecb970
+  metadata.gz: 2945a0f85059a2979b59e3623e208fcc7bbd0195b2e00b581502adb5fa9f76ac
+  data.tar.gz: a5ca2152292ba794be5bc6edd766e36bf769b86fa63ce235a396645245b38bf7
 SHA512:
-  metadata.gz: d956c3ff27cae1eedce7a4cc9cb53f57a7d12a58999b74ddebb7bc4a3c99661e2cea010a5a2cc9682315ed5d4bfe06b4122453127d6682ecb96fcfd4401202e2
-  data.tar.gz: 478679f5fc817ba910aa0adc927ca0e22009ec1cc787b1388cef9ed3ff570da51c83eaa5e5a99f9b4b9c21e2d6d0d8dbed280925035bc00b580ba242776e7766
+  metadata.gz: 9c57a2679fa6b1230ba4965f868c40de1eb98a8a4dac5dfe52a24a81f131d4ebb566707150b6d04e1f8b25d7e08bd284eae75d848b4488a0eed9c999b25662d5
+  data.tar.gz: 76107d50a3f3bfa76d2926931cbc54d49aa7e7e14d68f0aa932fb93513597d254f5063daf0341780bf9a2783472a884444b884fe50fa16e2248f08e0dcc68978

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/Rakefile

@@ -263,6 +263,14 @@ namespace :benchmark do
     sh "bundle exec ruby benchmark/plan_bench.rb"
   end
 
+  # SAX bench row (leptris#1298 / #279): the bulk record drain vs
+  # the callback Recorder. With LEPTRIS_BENCH_LOCK=1 (CI) it exits 1
+  # unless records-walk allocations stay under half the recorder's.
+  desc "SAX parse benchmark: record drain vs callback recorder"
+  task :sax do
+    sh "bundle exec ruby benchmark/sax_bench.rb"
+  end
+
   desc "Generate adapter benchmark report"
   task :report do
     ruby "benchmarks/generate_report.rb"

data/benchmark/sax_bench.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# SAX bench row (leptris#1298 follow-up / moxml#279 item 4): the
+# bulk record drain vs the callback Recorder on the canon parse-lane
+# shape. Run via `rake benchmark:sax`; with LEPTRIS_BENCH_LOCK=1
+# (CI) it exits 1 unless the drain stays materially cheaper than the
+# recorder — records-walk allocations must land under half the
+# recorder's, so the win stays visible and a regression re-opens
+# the lane.
+require "moxml"
+
+item = "<item n=\"1\" kind=\"k\" id=\"i1\">value text</item>"
+DOC = "<r>#{item * 225}<t>tail</t></r>".freeze # rubocop:disable Lint/ConstantDefinitionInBlock
+DOCS = [DOC, DOC].freeze # rubocop:disable Lint/ConstantDefinitionInBlock
+
+module SaxBenchHandlers
+  class NullHandler < Moxml::SAX::Handler
+    def on_start_element(_name, _attrs = {}, _namespaces = {}); end
+
+    def on_end_element(_name); end
+
+    def on_characters(_text); end
+  end
+
+  class RecordWalkHandler < Moxml::SAX::Handler
+    attr_reader :elements
+
+    def initialize
+      super
+      @elements = 0
+    end
+
+    # The hot-loop shape: walk the records, materialize one name per
+    # element (the #1298 target — consumer-chosen allocations).
+    def on_sax_records(table)
+      i = 0
+      while i < table.count
+        @elements += 1 if table.kind(i).zero? && table.view(i)
+        i += 1
+      end
+      :claimed
+    end
+  end
+end
+
+CTX = Moxml.new(:leptris).freeze # rubocop:disable Lint/ConstantDefinitionInBlock
+BRIDGE = Moxml::Adapter::Leptris::LeptrisSAXBridge # rubocop:disable Lint/ConstantDefinitionInBlock
+
+def allocations
+  GC.start
+  before = GC.stat(:total_allocated_objects)
+  GC.disable
+  yield
+  GC.enable
+  GC.stat(:total_allocated_objects) - before
+end
+
+def cpu_micros
+  GC.start
+  t0 = Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID, :microsecond)
+  yield
+  Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID, :microsecond) - t0
+end
+
+# warm both lanes
+handler = SaxBenchHandlers::NullHandler.new
+3.times { DOCS.each { |doc| Moxml::Adapter::Leptris.sax_parse(doc, handler) } }
+3.times { DOCS.each { |doc| Leptris::XML::SAX::Parser.new(BRIDGE.new(handler)).parse(doc) } }
+walker = SaxBenchHandlers::RecordWalkHandler.new
+3.times { DOCS.each { |doc| Moxml::Adapter::Leptris.sax_parse(doc, walker) } }
+
+recorder_allocs = allocations do
+  DOCS.each { |doc| Leptris::XML::SAX::Parser.new(BRIDGE.new(handler)).parse(doc) }
+end
+replay_allocs = allocations do
+  DOCS.each { |doc| Moxml::Adapter::Leptris.sax_parse(doc, handler) }
+end
+walk_allocs = allocations do
+  DOCS.each { |doc| Moxml::Adapter::Leptris.sax_parse(doc, walker) }
+end
+
+replay_time = cpu_micros { 5.times { DOCS.each { |doc| Moxml::Adapter::Leptris.sax_parse(doc, handler) } } }
+recorder_time = cpu_micros { 5.times { DOCS.each { |doc| Leptris::XML::SAX::Parser.new(BRIDGE.new(handler)).parse(doc) } } }
+walk_time = cpu_micros { 5.times { DOCS.each { |doc| Moxml::Adapter::Leptris.sax_parse(doc, walker) } } }
+
+puts format("recorder           %<allocs>6d allocs  %<time>6dµs", allocs: recorder_allocs, time: recorder_time / 5)
+puts format("drain replay       %<allocs>6d allocs  %<time>6dµs", allocs: replay_allocs, time: replay_time / 5)
+puts format("drain records-walk %<allocs>6d allocs  %<time>6dµs", allocs: walk_allocs, time: walk_time / 5)
+puts "(#{walker.elements} elements walked cumulatively; 452 per rep)"
+
+if ENV["LEPTRIS_BENCH_LOCK"]
+  if walk_allocs >= recorder_allocs / 2
+    warn "LEPTRIS_BENCH_LOCK: records-walk allocs (#{walk_allocs}) " \
+         "not under half the recorder's (#{recorder_allocs}) — the " \
+         "#1298 win regressed"
+    exit 1
+  end
+  puts "lock: records-walk under half the recorder's allocations ✓"
+end

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
@@ -1501,7 +1511,8 @@ module Moxml
 
           flat = attrs.flatten
           addr = ::Leptris::XML::Native.create_element_with_attrs(
-            doc.c_address, binding_parent.c_address, name.to_s, flat)
+            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
@@ -1510,7 +1521,7 @@ module Moxml
           # included — the SAME native, so the wrapper identity
           # holds across later traversals.
           canonical_native(doc,
-            ::Leptris::XML::Node.wrap(::FFI::Pointer.new(addr), doc))
+                           ::Leptris::XML::Node.wrap(::FFI::Pointer.new(addr), doc))
         end
 
         def attributes(element)
@@ -2114,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/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.80"
+  VERSION = "0.5.82"
 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/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.80
+  version: 0.5.82
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-24 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
@@ -41,6 +41,7 @@ files:
 - Rakefile
 - benchmark/pipeline_bench.rb
 - benchmark/plan_bench.rb
+- benchmark/sax_bench.rb
 - benchmarks/.gitignore
 - benchmarks/generate_report.rb
 - bin/console
@@ -160,6 +161,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 +302,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 +438,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