moxml 0.5.61 → 0.5.63

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 432ffb6c040c2b5689552a050b01835b792cde27ddc816981fd186fd83b9df7d
-  data.tar.gz: 917f7712e1799209f6d1c3f832fb5a3de492da5e570959a9d8bf2a8b4902d537
+  metadata.gz: 60493a9fbb6b03a4db31f83e99f269c5d5cf1797f5e0e94f4b6139616905e45e
+  data.tar.gz: 4df319d1a67b69f2a08e99cf338131c55584b1e68cb4b46687a23c2f6329263c
 SHA512:
-  metadata.gz: b6f0a69c52df888bf9afbc2706e755d9844d8d65247720d887cc6fb34c8d855964f278d798b947bfb028ce58f32253ff6ed92101fcc2cf45fe28695170c23405
-  data.tar.gz: 90b841bd8eb58119a38dce5333a53f9b37abc70755e69a887c52ab4565d1101727a2dcc40903a4671b92a10d4ba1bd67ab712ac97d37bdd04861359dd4b09bba
+  metadata.gz: 6690afe362a4af5781c54271c29daf1af651a6bc34975fd078a9c1d56ec56ac6c5af13a63746a801c206162aa25c7d09314f5bca55db48d356d83586466eda7f
+  data.tar.gz: a53a4a73958a40338ed54fbeb6c9098264e5f480b8125888b7471c9d6d11ec9dde455fc35e7de8847c3246fa834e607ab16f8eed5f2f47089547a45ff5b17f8b

data/.github/workflows/rake.yml

@@ -59,3 +59,8 @@ jobs:
           RUN_PERFORMANCE: "1"
           RUBY_YJIT_ENABLE: "1"
         run: bundle exec rake spec:performance
+
+      - name: Plan parity lock (plan vs raw-nokogiri CPU)
+        env:
+          LEPTRIS_BENCH_LOCK: "1"
+        run: bundle exec rake benchmark:plan

data/Rakefile

@@ -253,6 +253,16 @@ namespace :benchmark do
     sh "ruby", "benchmark/pipeline_bench.rb"
   end
 
+  # Plan-bench regression lock (#249 follow-up): Moxml::Plan vs the
+  # wrapper walk vs raw nokogiri on the consumer shape. With
+  # LEPTRIS_BENCH_LOCK=1 (CI) it exits 1 when plan time exceeds
+  # 1.5x raw nokogiri — the "raw-nokogiri CPU parity" regression
+  # tripwire.
+  desc "Plan materialization benchmark with raw-nokogiri parity lock"
+  task :plan do
+    sh "bundle exec ruby benchmark/plan_bench.rb"
+  end
+
   desc "Generate adapter benchmark report"
   task :report do
     ruby "benchmarks/generate_report.rb"

data/benchmark/plan_bench.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+# Plan-bench regression lock (leptris follow-up to #249): the plan
+# path must stay at or near raw-nokogiri CPU parity on the consumer
+# shape. Run via `rake benchmark:plan` or with LEPTRIS_BENCH_LOCK=1
+# to enforce the ceiling (CI): plan <= nokogiri * 1.5 — failures
+# mean an adapter or plan change regressed the compiled walk.
+require "moxml"
+require "nokogiri"
+
+Field = Struct.new(:name, :unit, :value)
+Record = Struct.new(:id, :kind, :fields)
+Catalog = Struct.new(:records)
+
+parts = [%(<?xml version="1.0"?><catalog>)]
+150.times do |i|
+  parts << %(<record id="r#{i}" kind="k#{i % 3}">)
+  6.times { |j| parts << %(<field name="f#{j}" unit="u#{j}">value #{i}.#{j}</field>) }
+  parts << %(</record>)
+end
+parts << %(</catalog>)
+XML = parts.join
+
+CTX = Moxml.new(:leptris)
+
+STRUCT_PLAN = Moxml::StructPlan.new do
+  element "record", Record, attrs: { "id" => :id, "kind" => :kind }, children: :fields
+  element "field", Field, attrs: { "name" => :name, "unit" => :unit }, text: :value
+end
+
+PLAN = Moxml::Plan.new do
+  on("record") { |attrs, _t, fields| Record.new(attrs["id"], attrs["kind"], fields) }
+  on("field")  { |attrs, text, _k| Field.new(attrs["name"], attrs["unit"], text) }
+end
+
+def plan_run
+  records = PLAN.parse(XML, CTX)
+  raise "shape" unless records.size == 150 && records[7].fields[3].value == "value 7.3"
+
+  records
+end
+
+def struct_run
+  records = STRUCT_PLAN.parse(XML, CTX)
+  raise "shape" unless records.size == 150 && records[7].fields[3].value == "value 7.3"
+
+  records
+end
+
+def wrapper_run
+  doc = CTX.parse(XML)
+  catalog = Catalog.new([])
+  doc.root.children.each do |rec|
+    next unless rec.is_a?(Moxml::Element)
+
+    record = Record.new(rec["id"], rec["kind"], [])
+    rec.children.each do |f|
+      next unless f.is_a?(Moxml::Element)
+
+      record.fields << Field.new(f["name"], f["unit"], f.text)
+    end
+    catalog.records << record
+  end
+  raise "shape" unless catalog.records.size == 150
+
+  catalog
+end
+
+def nokogiri_run
+  doc = Nokogiri::XML(XML)
+  catalog = Catalog.new([])
+  doc.root.children.each do |rec|
+    next unless rec.is_a?(Nokogiri::XML::Element)
+
+    record = Record.new(rec["id"], rec["kind"], [])
+    rec.children.each do |f|
+      next unless f.is_a?(Nokogiri::XML::Element)
+
+      record.fields << Field.new(f["name"], f["unit"], f.text)
+    end
+    catalog.records << record
+  end
+  raise "shape" unless catalog.records.size == 150
+
+  catalog
+end
+
+REPS = 200
+
+def bench(&block)
+  times = []
+  allocs = []
+  REPS.times do
+    GC.start
+    a0 = GC.stat(:total_allocated_objects)
+    t0 = Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID)
+    yield
+    times << (Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID) - t0)
+    allocs << (GC.stat(:total_allocated_objects) - a0)
+  end
+  [times.sort[times.size / 2] * 1e6, allocs.min]
+end
+
+# The parity lock needs the lean plan rows (binding 1.9.194.2+);
+# on older bindings the plan runs the generic fallback and the
+# ceiling is meaningless — report and exit clean.
+if Gem::Version.new(Leptris::VERSION) < Gem::Version.new("1.9.194.2")
+  puts "SKIP parity lock: leptris #{Leptris::VERSION} lacks snapshot_rows (needs 1.9.194.2)"
+  exit 0
+end
+
+# warm
+plan_run
+struct_run
+wrapper_run
+nokogiri_run
+
+struct_us = nil
+struct_allocs = nil
+if Gem::Version.new(Leptris::VERSION) >= Gem::Version.new("1.9.197.1")
+  struct_us, struct_allocs = bench { struct_run }
+end
+plan_us,  plan_allocs  = bench { plan_run }
+wrap_us,  wrap_allocs  = bench { wrapper_run }
+nk_us,    nk_allocs    = bench { nokogiri_run }
+
+if struct_us
+  puts format("struct   (parse+materialize) %<t>8.0f us  %<a>7d allocs",
+              t: struct_us, a: struct_allocs)
+end
+puts format("plan     (parse+materialize) %<t>8.0f us  %<a>7d allocs",
+            t: plan_us, a: plan_allocs)
+puts format("wrapper  (parse+walk)       %<t>8.0f us  %<a>7d allocs",
+            t: wrap_us, a: wrap_allocs)
+puts format("nokogiri (parse+walk)       %<t>8.0f us  %<a>7d allocs",
+            t: nk_us, a: nk_allocs)
+puts format("plan/nokogiri %<r>.2fx (ceiling 1.50x for the CI lock)",
+            r: plan_us / nk_us)
+
+exit(1) if ENV["LEPTRIS_BENCH_LOCK"] && plan_us > nk_us * 1.5

data/lib/moxml/adapter/base.rb

@@ -358,15 +358,29 @@ namespace_validation_mode: :strict)
           nil
         end
 
-        # Plan row stream (Moxml::Plan): yields |name, attrs_pairs
-        # (flat [k, v, ...]), first-text, depth| per element in
-        # document order (pre-order). Returns true when the adapter
-        # provided the stream; nil/false lets the plan run its
-        # generic wrapper walk.
+        # Plan row stream (Moxml::Plan) — ADAPTER CONTRACT. Yields
+        # |name, attrs_pairs (flat [k, v, ...]), first-text, depth|
+        # per element in document order (pre-order); first-text is
+        # the element's first text child or nil. Adapters implement
+        # this natively off their engine nodes (nokogiri, ox, oga,
+        # rexml, libxml, leptris do) — Moxml::Plan executes entirely
+        # on these rows with no wrapper materialization. This default
+        # returns nil, which makes Moxml::Plan fall back to the
+        # generic wrapper walk — correct but slow; last resort only.
         def plan_rows(_native)
           nil
         end
 
+        # Struct-plan executor (Moxml::StructPlan): +spec+ compiles
+        # the consumer's shape as {name => [Struct class, attrs
+        # Hash (name => slot Symbol), text slot, children slot]}.
+        # Returns the array of top-level minted structs, or nil when
+        # the adapter has no C executor (the StructPlan then runs
+        # its Moxml::Plan fallback over plan_rows).
+        def plan_structs(_native, _spec)
+          nil
+        end
+
         # Deterministic native-memory release for adapters backed by
         # C trees (issue #134). GC-managed engines no-op; released
         # documents raise the engine's use-after-free error on

data/lib/moxml/adapter/leptris.rb

@@ -537,6 +537,32 @@ module Moxml
         NATIVE_READ_LAYER &&
         Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.193.4")
 
+      # leptris-ruby#266 (binding 1.9.197.1): Native.plan_structs —
+      # the C struct executor behind Moxml::StructPlan.
+      NATIVE_PLAN_STRUCTS =
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.197.1")
+
+      def self.plan_structs(native, spec)
+        return nil unless NATIVE_PLAN_STRUCTS
+
+        doc = if native.is_a?(::Leptris::XML::Document)
+                native
+              else
+                doc_for(native)
+              end
+        return nil if doc.nil? || attachments.get(doc, :entity_markers)
+
+        root_binding = if native.is_a?(::Leptris::XML::Document)
+                         doc.root
+                       else
+                         to_binding(native)
+                       end
+        return nil unless root_binding
+
+        ::Leptris::XML::Native.plan_structs(doc, root_binding.c_address,
+                                            spec)
+      end
+
       def self.plan_rows(native)
         return nil unless NATIVE_READ_LAYER
 

data/lib/moxml/adapter/libxml.rb

@@ -1312,6 +1312,38 @@ module Moxml
             dst[attr_name] = attr.value
           end
         end
+
+        # Plan row stream (Moxml::Plan contract): pre-order element
+        # rows straight off the LibXML nodes — no wrapper minting.
+        def plan_rows(native)
+          root = if native.is_a?(::LibXML::XML::Document)
+                   r = native.root
+                   return nil unless r
+
+                   r
+                 else
+                   native
+                 end
+
+          walk = lambda do |el, depth|
+            attrs = []
+            el.attributes.each do |attr|
+              attrs << attr.name << attr.value
+            end
+            first_text = nil
+            el.children.each do |c|
+              first_text ||= c.content if c.text?
+            end
+            yield(el.name, attrs, first_text, depth)
+            el.children.each do |c|
+              walk.call(c, depth + 1) if c.element?
+            end
+          end
+          walk.call(root, 0)
+          true
+        end
+
+        public :plan_rows
       end
 
       # Bridge between LibXML SAX and Moxml SAX

data/lib/moxml/adapter/nokogiri.rb

@@ -516,6 +516,25 @@ module Moxml
           attachments.set(native_doc, :xml_decl, nil)
         end
 
+        # Plan row stream (Moxml::Plan contract): pre-order element
+        # rows |name, attrs_pairs, first-text, depth| straight off
+        # the libxml2-backed nodes — no wrapper minting.
+        def plan_rows(native)
+          root = native.is_a?(::Nokogiri::XML::Document) ? native.root : native
+          return nil unless root
+
+          walk = lambda do |el, depth|
+            attrs = []
+            el.attribute_nodes.each { |a| attrs << a.name << a.value }
+            first_text = nil
+            el.children.each { |c| first_text ||= c.content if c.text? }
+            yield(el.name, attrs, first_text, depth)
+            el.element_children.each { |c| walk.call(c, depth + 1) }
+          end
+          walk.call(root, 0)
+          true
+        end
+
         private
 
         def build_declaration_attrs(version, encoding, standalone)
@@ -533,6 +552,10 @@ module Moxml
             hsh.merge(attr_name => value)
           end
         end
+
+        # Plan row stream (Moxml::Plan contract): pre-order element
+        # rows |name, attrs_pairs, first-text, depth| straight off
+        # the libxml2-backed nodes — no wrapper minting.
       end
 
       # Bridge between Nokogiri SAX and Moxml SAX

data/lib/moxml/adapter/oga.rb

@@ -643,6 +643,34 @@ module Moxml
 
           ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(node).to_xml
         end
+
+        # Plan row stream (Moxml::Plan contract): pre-order element
+        # rows over Oga's Ruby node objects.
+        def plan_rows(native)
+          root = if native.is_a?(::Oga::XML::Document)
+                   native.children.find { |c| c.is_a?(::Oga::XML::Element) }
+                 else
+                   native
+                 end
+          return nil unless root.is_a?(::Oga::XML::Element)
+
+          walk = lambda do |el, depth|
+            attrs = []
+            el.attributes.each { |a| attrs << a.name << a.value }
+            first_text = nil
+            el.children.each do |c|
+              first_text ||= c.text if c.is_a?(::Oga::XML::Text)
+            end
+            yield(el.name, attrs, first_text, depth)
+            el.children.each do |c|
+              walk.call(c, depth + 1) if c.is_a?(::Oga::XML::Element)
+            end
+          end
+          walk.call(root, 0)
+          true
+        end
+
+        public :plan_rows
       end
 
       # Bridge between a parsed Oga DOM and Moxml SAX events.

data/lib/moxml/adapter/ox.rb

@@ -955,6 +955,35 @@ module Moxml
           output << "</#{elem.name}>"
           output
         end
+
+        # Plan row stream (Moxml::Plan contract): pre-order element
+        # rows over Ox's Ruby node objects.
+        def plan_rows(native)
+          root = if native.is_a?(::Ox::Document)
+                   nodes = native.nodes.grep(::Ox::Element)
+                   nodes.first
+                 else
+                   native
+                 end
+          return nil unless root.is_a?(::Ox::Element)
+
+          walk = lambda do |el, depth|
+            attrs = []
+            (el.attributes || {}).each { |k, v| attrs << k.to_s << v.to_s }
+            first_text = nil
+            (el.nodes || []).each do |c|
+              first_text ||= c if c.is_a?(::String)
+            end
+            yield(el.name.to_s, attrs, first_text, depth)
+            (el.nodes || []).each do |c|
+              walk.call(c, depth + 1) if c.is_a?(::Ox::Element)
+            end
+          end
+          walk.call(root, 0)
+          true
+        end
+
+        public :plan_rows
       end
     end
 

data/lib/moxml/adapter/rexml.rb

@@ -694,6 +694,24 @@ module Moxml
           )
           formatter.write(node, output)
         end
+
+        # Plan row stream (Moxml::Plan contract): pre-order element
+        # rows over REXML's Ruby node objects.
+        def plan_rows(native)
+          root = native.is_a?(::REXML::Document) ? native.root : native
+          return nil unless root
+
+          walk = lambda do |el, depth|
+            attrs = []
+            el.attributes.each { |k, v| attrs << k << v }
+            yield(el.name, attrs, el.text, depth)
+            el.elements.each { |c| walk.call(c, depth + 1) }
+          end
+          walk.call(root, 0)
+          true
+        end
+
+        public :plan_rows
       end
     end
 

data/lib/moxml/struct_plan.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Moxml
+  # Struct-compiled materialization — the fully compiled grammar:
+  # declare the document shape once as STRUCTS; adapters with a C
+  # executor (leptris 1.9.197.1+) mint the typed objects directly
+  # with zero Ruby frames per element; everything else falls back to
+  # an equivalent Moxml::Plan over the row stream (spec-pinned
+  # equal).
+  #
+  #   plan = Moxml::StructPlan.new do
+  #     element "record", Record, attrs: { "id" => :id, "kind" => :kind },
+  #            children: :fields
+  #     element "field", Field, attrs: { "name" => :name, "unit" => :unit },
+  #            text: :value
+  #   end
+  #   records = plan.parse(xml, ctx)   # Array of Record
+  #
+  # Slot symbols must be the Struct's member names. Semantics equal
+  # Moxml::Plan: unmatched elements are barriers — their matched
+  # descendants surface at top level.
+  class StructPlan
+    Element = Struct.new(:klass, :attrs, :text, :children)
+
+    def initialize(&block)
+      @elements = {}
+      instance_eval(&block) if block
+    end
+
+    # Registers a struct element. +attrs+ maps attribute names to
+    # member slots; +text+ and +children+ name the member slots
+    # receiving the first text child and the matched children array.
+    # Returns self so registrations chain.
+    def element(name, klass, attrs: {}, text: nil, children: nil)
+      @elements[name] = Element.new(klass, attrs, text, children)
+      self
+    end
+
+    # The compiled spec the C executor consumes:
+    # {name => [klass, attrs, text slot, children slot]}.
+    def compile
+      @elements.each_with_object({}) do |(name, el), spec|
+        spec[name] = [el.klass, el.attrs, el.text, el.children]
+      end
+    end
+
+    def parse(xml, context)
+      materialize(context.parse(xml))
+    end
+
+    def materialize(node)
+      adapter = node.context.config.adapter
+      roots = adapter.plan_structs(node.native, compile)
+      return roots if roots
+
+      plan.materialize(node)
+    end
+
+    private
+
+    # The fallback: the same element table as block handlers over
+    # the plan row stream. instance_eval'd DSL — capture the table
+    # in a local (the Plan's self has no @elements).
+    def plan
+      @plan ||= begin
+        elements = @elements
+        Moxml::Plan.new do
+          elements.each do |name, el|
+            on(name) do |attrs, text, children|
+              obj = el.klass.new
+              el.attrs.each { |aname, slot| obj[slot] = attrs[aname] }
+              obj[el.text] = text if el.text
+              obj[el.children] = children if el.children
+              obj
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moxml/version.rb

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

data/lib/moxml.rb

@@ -94,6 +94,7 @@ module Moxml
   autoload :XmlEmitter, "moxml/xml_emitter"
   autoload :Materializer, "moxml/materializer"
   autoload :Plan, "moxml/plan"
+  autoload :StructPlan, "moxml/struct_plan"
   autoload :Adapter, "moxml/adapter"
   autoload :XPath, "moxml/xpath"
   autoload :SAX, "moxml/sax"

data/spec/moxml/plan_conformance_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Moxml::Plan adapter-contract conformance (leptris follow-up to
+# #249): every adapter must produce IDENTICAL plan results on the
+# same document, whether its plan_rows is a bulk C stream (leptris,
+# nokogiri, libxml) or a Ruby-native walk (ox, oga, rexml).
+PlanRow = Struct.new(:id, :kind, :fields)
+PlanCell = Struct.new(:name, :unit, :value)
+
+RSpec.describe "Moxml::Plan adapter conformance" do
+  # Single-line fixture: no inter-element whitespace text, so
+  # engines that differ on insignificant text still agree.
+  let(:xml) do
+    '<catalog><record id="r0" kind="k0"><field name="f0" unit="u0">v 0.0</field><field name="f1" unit="u1">v 0.1</field></record><record id="r1" kind="k1"><field name="f0" unit="u0">v 1.0</field></record></catalog>'
+  end
+
+  let(:plan) do
+    Moxml::Plan.new do
+      on("record") do |attrs, _text, fields|
+        PlanRow.new(attrs["id"], attrs["kind"], fields)
+      end
+      on("field") do |attrs, text, _kids|
+        PlanCell.new(attrs["name"], attrs["unit"], text)
+      end
+    end
+  end
+
+  ADAPTERS = %i[leptris nokogiri ox oga rexml libxml].freeze # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+
+  it "executes on every available adapter" do
+    available = ADAPTERS.select do |a|
+      ctx = Moxml.new(a)
+      ctx.parse(xml)
+      true
+    rescue StandardError
+      false
+    end
+    expect(available).not_to be_empty
+
+    results = available.to_h { |a| [a, plan.parse(xml, Moxml.new(a))] }
+
+    baseline = results[available.first]
+    results.each do |adapter, rows|
+      expect(rows).to eq(baseline), "adapter #{adapter} diverged"
+    end
+
+    expect(baseline.size).to eq(2)
+    expect(baseline[0].fields.map(&:value)).to eq(["v 0.0", "v 0.1"])
+  end
+
+  it "skips no element and preserves order" do
+    rows = plan.parse(xml, Moxml.new(:nokogiri))
+
+    expect(rows.map(&:id)).to eq(%w[r0 r1])
+  end
+
+  it "handles depth-3 nesting identically" do
+    deep = Moxml::Plan.new do
+      on("catalog") { |_a, _t, records| records }
+      on("record") { |attrs, _t, fields| [attrs["id"], fields] }
+      on("field") { |attrs, text, _| [attrs["name"], text] }
+    end
+
+    ADAPTERS.each do |a|
+      begin
+        ctx = Moxml.new(a)
+        ctx.parse(xml)
+      rescue StandardError
+        next
+      end
+      out = deep.parse(xml, ctx)
+      expect(out[0]).to eq(
+        [["r0", [["f0", "v 0.0"], ["f1", "v 0.1"]]],
+         ["r1", [["f0", "v 1.0"]]]],
+      )
+    end
+  end
+end

data/spec/moxml/struct_plan_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Moxml::StructPlan: the fully compiled grammar — struct slots
+# declared once, minted in C on leptris (1.9.197.1+) and via the
+# plan fallback everywhere else. Results must be identical to
+# Moxml::Plan.
+SRecord = Struct.new(:id, :kind, :fields)
+SField = Struct.new(:name, :unit, :value)
+
+RSpec.describe Moxml::StructPlan do
+  let(:xml) do
+    '<catalog><record id="r0" kind="k0"><field name="f0" unit="u0">v 0.0</field><field name="f1" unit="u1">v 0.1</field></record><record id="r1" kind="k1"><field name="f0" unit="u0">v 1.0</field></record></catalog>'
+  end
+  let(:plan) do
+    described_class.new do
+      element "record", SRecord,
+              attrs: { "id" => :id, "kind" => :kind }, children: :fields
+      element "field", SField,
+              attrs: { "name" => :name, "unit" => :unit }, text: :value
+    end
+  end
+  let(:block_plan) do
+    Moxml::Plan.new do
+      on("record") { |attrs, _t, fields| SRecord.new(attrs["id"], attrs["kind"], fields) }
+      on("field") { |attrs, text, _k| SField.new(attrs["name"], attrs["unit"], text) }
+    end
+  end
+
+  ADAPTERS = %i[leptris nokogiri ox oga rexml libxml].freeze # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+
+  def with_adapter(name)
+    yield Moxml.new(name)
+  rescue StandardError
+    skip "#{name} unavailable"
+  end
+
+  ADAPTERS.each do |adapter_name|
+    describe "on #{adapter_name}" do
+      it "materializes the same structs as Moxml::Plan" do
+        with_adapter(adapter_name) do |ctx|
+          expect(plan.parse(xml, ctx))
+            .to eq(block_plan.parse(xml, ctx))
+        end
+      end
+    end
+  end
+
+  it "treats unmatched elements as barriers like Moxml::Plan" do
+    barrier_xml = "<catalog><wrap><record id=\"r9\"/></wrap><record id=\"r8\"/></catalog>"
+    with_adapter(:leptris) do |ctx|
+      rows = plan.parse(barrier_xml, ctx)
+      expect(rows.map(&:id)).to eq(%w[r9 r8])
+    end
+  end
+
+  it "runs the C executor on leptris (not the fallback)" do
+    with_adapter(:leptris) do |ctx|
+      doc = ctx.parse(xml)
+      roots = Moxml::Adapter::Leptris.plan_structs(
+        doc.native,
+        "record" => [SRecord, { "id" => :id, "kind" => :kind }, nil, :fields],
+        "field" => [SField, { "name" => :name, "unit" => :unit }, :value, nil],
+      )
+      expect(roots).to eq(plan.parse(xml, ctx))
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.61
+  version: 0.5.63
 platform: ruby
 authors:
 - Ribose Inc.
@@ -39,6 +39,7 @@ files:
 - README.adoc
 - Rakefile
 - benchmark/pipeline_bench.rb
+- benchmark/plan_bench.rb
 - benchmarks/.gitignore
 - benchmarks/generate_report.rb
 - bin/console
@@ -270,6 +271,7 @@ files:
 - lib/moxml/signature/transform_pipeline.rb
 - lib/moxml/signature/verification_result.rb
 - lib/moxml/signature/verifier.rb
+- lib/moxml/struct_plan.rb
 - lib/moxml/text.rb
 - lib/moxml/version.rb
 - lib/moxml/wrappers.rb
@@ -488,6 +490,7 @@ files:
 - spec/moxml/opal_oga_smoke_spec.rb
 - spec/moxml/opal_rexml_adapter_spec.rb
 - spec/moxml/opal_smoke_spec.rb
+- spec/moxml/plan_conformance_spec.rb
 - spec/moxml/plan_spec.rb
 - spec/moxml/processing_instruction_spec.rb
 - spec/moxml/readonly_parse_spec.rb
@@ -508,6 +511,7 @@ files:
 - spec/moxml/signature/key_extractor_spec.rb
 - spec/moxml/signature/model_spec.rb
 - spec/moxml/signature/round_trip_spec.rb
+- spec/moxml/struct_plan_spec.rb
 - spec/moxml/text_spec.rb
 - spec/moxml/version_spec.rb
 - spec/moxml/xml_emitter_spec.rb