moxml 0.5.62 → 0.5.63

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 430e3a7e8c18cfa2c083ae9b263e9fedbaed03c109811980f0ca51de36507be7
-  data.tar.gz: 9644f7689ef2126884a6b11ecfcf9c532e0b2cae9cb44005b5b6b3434d96c7b4
+  metadata.gz: 60493a9fbb6b03a4db31f83e99f269c5d5cf1797f5e0e94f4b6139616905e45e
+  data.tar.gz: 4df319d1a67b69f2a08e99cf338131c55584b1e68cb4b46687a23c2f6329263c
 SHA512:
-  metadata.gz: 9f89223d0bc12427916bb46220f79d957df704b878ea02dc11387c9096c6829f5309ed857a3faa4c1b9aee0697b3dfe2f7fa9f73fc5e083b6c1c0963bea11501
-  data.tar.gz: 5120f5700dd76a688576501a90ee2e6ffc443558cb89478dd23f2ea5a424d29dac41dd4df4cb9acc764451b81f84c5a03eed3d4ab734adfa276c7a1043bf54ce
+  metadata.gz: 6690afe362a4af5781c54271c29daf1af651a6bc34975fd078a9c1d56ec56ac6c5af13a63746a801c206162aa25c7d09314f5bca55db48d356d83586466eda7f
+  data.tar.gz: a53a4a73958a40338ed54fbeb6c9098264e5f480b8125888b7471c9d6d11ec9dde455fc35e7de8847c3246fa834e607ab16f8eed5f2f47089547a45ff5b17f8b

data/benchmark/plan_bench.rb

@@ -23,6 +23,11 @@ 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) }
@@ -35,6 +40,13 @@ def plan_run
   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([])
@@ -99,13 +111,23 @@ 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",

data/lib/moxml/adapter/base.rb

@@ -371,6 +371,16 @@ namespace_validation_mode: :strict)
           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/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.62"
+  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/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.62
+  version: 0.5.63
 platform: ruby
 authors:
 - Ribose Inc.
@@ -271,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
@@ -510,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