lutaml-model 0.8.84 → 0.8.85

data/lib/lutaml/xml/leptris/plan_serializer.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    module Leptris
+      # Serialize-side mirror of the plan fast path: builds the output
+      # tree directly through leptris's fused create_child chain — no
+      # XmlElement tree, no DeclarationPlanner pass, no builder context
+      # stack, no moxml wrapper minting. Serialized shapes must be the
+      # plain ones (attributes, scalars, collections, nested models,
+      # raw fragments, content runs); custom-method, polymorphic,
+      # union, and multi-spelling rows keep the interpretive serializer
+      # (their output flows through hash-shaped custom APIs).
+      #
+      # Ordered/mixed models serialize from element_order when the
+      # instance carries one (parsed models): text runs, comments, and
+      # element entries in document order, mirroring the interpretive
+      # order applier — including its content-attr-first text reads
+      # (mutations to the model show up) and CDATA flattening. Models
+      # without element_order fall back interpretively (return nil).
+      module PlanSerializer
+        SERIALIZABLE_KINDS = %i[scalar collection_native collection_cb
+                                nested ordered_deferred raw content
+                                content_deferred].freeze
+        CONTENT_KINDS = %i[content content_deferred].freeze
+
+        class << self
+          # plan: the compiler's entry for instance's class
+          def call(instance, plan, register = nil)
+            # The child model's declared lutaml_default_register takes
+            # precedence over the ambient register — the resolve_for_child
+            # contract (#876); without it, child plans and attribute
+            # serialization resolve in the parent context.
+            register = Lutaml::Model::Register.resolve_for_child(
+              instance.class,
+              register || Lutaml::Model::Config.default_register,
+            )
+            return nil if plan[:ordered] && instance.element_order.nil?
+
+            doc = ::Leptris::XML::Document.create
+            root = doc.create_element(plan[:tree][:name])
+            doc.root = root
+            if plan[:ordered]
+              build_ordered(root, instance, plan, doc, register)
+            else
+              build(root, instance, plan, doc, register)
+            end
+            doc.to_xml(indent: 2, no_decl: true)
+          end
+
+          # Whether the compiled plan is serialize-shaped. Ordered/mixed
+          # models serialize through build_ordered from element_order;
+          # plain models through plan rows.
+          def serializable?(plan)
+            plan[:rows].all? do |_rule, _attr, kind, _sp, _del|
+              SERIALIZABLE_KINDS.include?(kind)
+            end
+          end
+
+          private
+
+          def register
+            Lutaml::Model::Config.default_register
+          end
+
+          def build(element, instance, plan, doc, reg = nil)
+            reg ||= register
+            write_attributes(element, instance, plan, reg)
+            plan[:rows].each do |rule, attr, kind, spelling, delegate|
+              value = value_of(instance, attr, delegate)
+              next unless rule.render?(value, instance)
+
+              case kind
+              when :scalar
+                # Multi-capture parity: an attribute that collected
+                # several occurrences serializes one element per item,
+                # as the interpretive writer does. A plain scalar skips
+                # the Array() wrap — the common case.
+                if value.is_a?(::Array)
+                  value.each do |item|
+                    add_leaf(element, row_name(rule, spelling),
+                             attr.serialize(item, :xml, reg), doc,
+                             attrs: rule.when_attribute)
+                  end
+                else
+                  add_leaf(element, row_name(rule, spelling),
+                           attr.serialize(value, :xml, reg), doc,
+                           attrs: rule.when_attribute)
+                end
+              when :collection_native, :collection_cb
+                Array(value).each do |item|
+                  add_leaf(element, rule.name.to_s,
+                           attr.serialize(item, :xml, reg), doc,
+                           attrs: rule.when_attribute)
+                end
+              when :nested, :ordered_deferred
+                Array(value).each do |item|
+                  child_plan = PlanCompiler.compile(item.class, reg)
+                  child = element.create_child(child_plan[:tree][:name])
+                  if child_plan[:ordered]
+                    return nil unless build_ordered(child, item, child_plan,
+                                                    doc, reg)
+
+                  else
+                    build(child, item, child_plan, doc, reg)
+                  end
+                end
+              when :raw
+                Array(value).each { |raw| element.add_child(raw.to_s) }
+              when :content, :content_deferred
+                Array(value).each { |run| element.add_child(doc.create_text_node(run.to_s)) }
+              end
+            end
+          end
+
+          # Element_order-driven emission (the interpretive order
+          # applier's contract): text runs and comments verbatim, each
+          # element entry consuming the next item of its collection
+          # (document order). Text reads prefer the content attribute
+          # when it lines up with the text-node count, so mutations to
+          # the model are reflected; element_order text is the fallback.
+          # PIs drop (interpretive parity). Returns nil when a nested
+          # ordered child lacks element_order (caller falls back).
+          def build_ordered(element, instance, plan, doc, reg = nil)
+            reg ||= register
+            write_attributes(element, instance, plan, reg)
+            rows_by_name = {}
+            plan[:rows].each do |rule, attr, kind, spelling, delegate|
+              next unless rule.name
+
+              rows_by_name[rule.name.to_s] ||= [rule, attr, kind, spelling,
+                                                delegate]
+            end
+            content_entry = plan[:rows].find do |rule, _attr, kind, _sp, _del|
+              CONTENT_KINDS.include?(kind) && rule.name.nil?
+            end
+            order = instance.element_order
+            element_indices = ::Hash.new(0)
+            content_attr = content_entry && content_entry[1]
+            content_value = content_attr &&
+              value_of(instance, content_attr, content_entry[4])
+            text_node_count = order.count { |o| o.type == "Text" }
+            use_content_index = content_value.is_a?(Array) &&
+              content_value.length == text_node_count
+            content_cdata = content_entry && content_entry[0].cdata
+            text_node_index = 0
+
+            order.each do |object|
+              case object.type
+              when "Text"
+                text = if content_attr && !content_value.nil?
+                         if use_content_index
+                           content_value[text_node_index].to_s
+                         elsif !content_value.is_a?(Array) && text_node_count <= 1
+                           content_value.to_s
+                         else
+                           object.text_content || object.name
+                         end
+                       else
+                         object.text_content || object.name
+                       end
+                text_node_index += 1
+                next if text.nil?
+                # Mixed content keeps whitespace; ordered-only skips it
+                next if content_attr.nil? && text.strip.empty?
+
+                element.add_child(content_cdata ? doc.create_cdata(text) : doc.create_text_node(text))
+              when "Comment"
+                element.add_child(doc.create_comment(object.text_content))
+              when "Element"
+                entry = rows_by_name[object.name]
+                next unless entry
+
+                _, attr, kind, _spelling, delegate = entry
+                value = value_of(instance, attr, delegate)
+                case kind
+                when :collection_native, :collection_cb
+                  index = element_indices[object.name]
+                  items = Array(value)
+                  next unless index < items.length
+
+                  element_indices[object.name] += 1
+                  add_leaf(element, object.name,
+                           attr.serialize(items[index], :xml, reg), doc)
+                when :nested, :ordered_deferred
+                  item = if attr.collection?
+                           index = element_indices[object.name]
+                           element_indices[object.name] += 1
+                           Array(value)[index]
+                         else
+                           value
+                         end
+                  next unless item
+
+                  child_plan = PlanCompiler.compile(item.class, reg)
+                  child = element.create_child(child_plan[:tree][:name])
+                  if child_plan[:ordered]
+                    return nil unless build_ordered(child, item, child_plan,
+                                                    doc, reg)
+                  else
+                    build(child, item, child_plan, doc, reg)
+                  end
+                when :raw
+                  element.add_child(value.to_s) unless value.nil?
+                when :scalar
+                  add_leaf(element, object.name,
+                           attr.serialize(value, :xml, reg), doc)
+                end
+              end
+            end
+            true
+          end
+
+          # Attributes in document order when the instance recorded it
+          # (parsed models), else plan row order.
+          def write_attributes(element, instance, plan, _reg = nil)
+            recorded = instance.attribute_order
+            if recorded && !recorded.empty?
+              by_name = {}
+              plan[:attr_rows].each do |rule, attr, _sp, delegate|
+                by_name[rule.name.to_s] = [rule, attr, delegate]
+              end
+              names = recorded |
+                plan[:attr_rows].map { |rule, _a, _s, _d| rule.name.to_s }
+              names.each do |name|
+                write_attribute(element, instance, name, by_name[name])
+              end
+            else
+              plan[:attr_rows].each do |rule, attr, _sp, delegate|
+                write_attribute(element, instance, rule.name.to_s,
+                                [rule, attr, delegate])
+              end
+            end
+          end
+
+          def write_attribute(element, instance, name, entry, reg = nil)
+            return unless entry
+
+            _rule, attr, delegate = entry
+            value = value_of(instance, attr, delegate)
+            return if value.nil?
+
+            element.set_attribute(name,
+                                  attr.serialize(value, :xml, reg || register).to_s)
+          end
+
+          # Partition rows (#88) re-emit their discriminator: the wire
+          # element carries the when_attribute pairs so the round trip
+          # re-routes to the same attribute on reparse.
+          def add_leaf(element, name, value, doc, attrs: nil)
+            child = element.create_child(name)
+            attrs&.each { |k, v| child[k.to_s] = v.to_s }
+            child.add_child(doc.create_text_node(value.to_s)) unless value.nil?
+            child
+          end
+
+          def value_of(instance, attr, delegate)
+            if delegate
+              target = instance.public_send(delegate)
+              target&.public_send(attr.name)
+            else
+              instance.public_send(attr.name)
+            end
+          end
+
+          def row_name(rule, spelling)
+            (spelling || rule.name).to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/xml/leptris/plan_walk.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    module Leptris
+      # Public consumer surface for the plan fast path: one engine
+      # parse + descriptor walk and direct model hydration, bypassing
+      # the wrapper-tree construction that dominates large-document
+      # consumer paths. The returned object is the mapped model root;
+      # collection attributes remain collections on that model.
+      module PlanWalk
+        class << self
+          # Build the plan, walk the document, and hydrate the mapped
+          # root. Returns nil when the model is not plan-compilable.
+          def call(model_class, xml, _options = {})
+            register = Lutaml::Model::Config.default_register
+            plan = PlanCompiler.compile(model_class, register)
+            return nil unless plan
+
+            document = ::Leptris::XML.parse(xml)
+            root = document.root
+            return nil unless root && root.name == plan[:tree][:name]
+
+            PlanHydrator.call(model_class, plan,
+                              plan[:descriptor].walk(root),
+                              node: root)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/xml/leptris.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    # The leptris plan fast path: model mapping to libleptris descriptor
+    # plan, native walk, direct hydration. Everything under this
+    # namespace is bound to the leptris gem; nothing above it may
+    # reference leptris types directly (the moxml adapters and the
+    # interpretive path never enter here).
+    module Leptris
+      # The plan path requires the one-crossing child snapshot
+      # (leptris_plan_value_children_snapshot with child handles,
+      # PlanValue#children_snapshot), which shipped in leptris
+      # 1.9.273.0. Bundles resolving an older gem keep the
+      # interpretive path — PlanCompiler.compile answers nil — the
+      # existing opt-out protocol.
+      MIN_LEPTRIS_VERSION = "1.9.273.0"
+
+      def self.plan_path_compatible?
+        return false unless defined?(Gem)
+
+        spec = Gem.loaded_specs["leptris"]
+        spec && spec.version >= Gem::Version.new(MIN_LEPTRIS_VERSION)
+      end
+
+      autoload :PlanCompiler, "lutaml/xml/leptris/plan_compiler"
+      autoload :PlanHydrator, "lutaml/xml/leptris/plan_hydrator"
+      autoload :PlanOrder, "lutaml/xml/leptris/plan_order"
+      autoload :PlanSerializer, "lutaml/xml/leptris/plan_serializer"
+      autoload :PlanWalk, "lutaml/xml/leptris/plan_walk"
+    end
+  end
+end

data/lib/lutaml/xml/serialization/format_conversion.rb

@@ -63,7 +63,11 @@ module Lutaml
         #
         # @return [Array<String>]
         def xml_schema_paths
-          inherited = if superclass.respond_to?(:xml_schema_paths)
+          # Type check, not a probe: every Serializable carries the
+          # class method; a plain (non-Serializable) superclass ends
+          # the chain.
+          inherited = if superclass.is_a?(Class) &&
+                         superclass.include?(Lutaml::Model::Serialize)
                         superclass.xml_schema_paths
                       else
                         []

data/lib/lutaml/xml/transformation/ordered_applier.rb

@@ -428,7 +428,7 @@ text_node_count = 0, use_content_index = false)
         #   reconciliation could not place
         def apply_remaining_rules(model_instance, options, compiled_rules,
 mapping, processed_text_nodes, fallback_rules)
-          attr_order = model_instance.respond_to?(:attribute_order) &&
+          attr_order = model_instance.is_a?(Lutaml::Model::Serialize) &&
             model_instance.attribute_order
 
           rules_to_apply = if attr_order

data/lib/tasks/performance_probe_plan_walk.rb

@@ -47,7 +47,7 @@ end
 
 Lutaml::Model::Config.instance.xml_plan_fast_path = true
 measure.call("PlanWalk parse + 5000 model.new") do
-  result = Lutaml::Xml::PlanWalk.call(PlanWalkProbe::BulkRoot, xml)
+  result = Lutaml::Xml::Leptris::PlanWalk.call(PlanWalkProbe::BulkRoot, xml)
   raise "PlanWalk returned nil" unless result&.item&.size == 5000
 end
 

data/spec/lutaml/model/store_spec.rb

@@ -86,14 +86,18 @@ RSpec.describe Lutaml::Model::Store do
     end
 
     it "does not mix indices across different classes" do
-      model_class.new(id: "a")
-      other_class.new(id: "a")
+      # Hold strong references: Store keeps WeakRefs, so unreferenced
+      # instances can be collected between registration and resolve,
+      # making this example fail only under in-suite GC pressure.
+      a = model_class.new(id: "a")
+      b = other_class.new(id: "a")
 
       result = described_class.resolve(model_class, :id, "a")
       expect(result).to be_a(model_class)
 
       result2 = described_class.resolve(other_class, :id, "a")
       expect(result2).to be_a(other_class)
+      expect([a, b]).to all(be_a(Lutaml::Model::Serializable))
     end
 
     it "registering class B does not iterate class A's indices" do

data/spec/lutaml/xml/plan_fast_path_spec.rb

@@ -57,7 +57,7 @@ RSpec.describe "XML plan fast path" do
     end
     stub_const("PlanFastPath::SelfRef", node)
 
-    expect(Lutaml::Xml::PlanCompiler.compile(node, :default)).to be_nil
+    expect(Lutaml::Xml::Leptris::PlanCompiler.compile(node, :default)).to be_nil
 
     xml = "<n>#{'<n>t</n>' * 200}</n>"
     parsed = node.from_xml(xml)
@@ -94,7 +94,7 @@ RSpec.describe "XML plan fast path" do
 
     expect(parsed.xmi_type).to eq("uml:Parameter")
     expect(parsed.classifier_type).to eq("EAnone_void")
-    expect(Lutaml::Xml::PlanCompiler.compile(parameter, :default)).to be_nil
+    expect(Lutaml::Xml::Leptris::PlanCompiler.compile(parameter, :default)).to be_nil
   end
 
   it "is on by default and can be disabled" do
@@ -156,7 +156,7 @@ RSpec.describe "XML plan fast path" do
       end
     end
 
-    expect(Lutaml::Xml::PlanCompiler.compile(klass,
+    expect(Lutaml::Xml::Leptris::PlanCompiler.compile(klass,
                                              Lutaml::Model::Config.default_register)).not_to be_nil
     expect(klass.from_xml("<doc><note>hi</note></doc>").note).to eq("HI")
   end
@@ -223,14 +223,14 @@ RSpec.describe "XML plan fast path" do
       end
     end
 
-    expect(Lutaml::Xml::PlanCompiler.compile(klass,
+    expect(Lutaml::Xml::Leptris::PlanCompiler.compile(klass,
                                              Lutaml::Model::Config.default_register)).not_to be_nil
     parsed = klass.from_xml("<doc><note>hi</note></doc>")
     expect(parsed.tgt.note).to eq("hi")
   end
 
   it "routes a single collection row natively (hybrid routing)" do
-    plan = Lutaml::Xml::PlanCompiler.compile(
+    plan = Lutaml::Xml::Leptris::PlanCompiler.compile(
       Class.new(Lutaml::Model::Serializable) do
         attribute :xs, :string, collection: true
         attribute :name, :string
@@ -400,7 +400,7 @@ RSpec.describe "XML plan fast path" do
           map_element "para", to: :para
         end
       end
-      plan = Lutaml::Xml::PlanCompiler.compile(
+      plan = Lutaml::Xml::Leptris::PlanCompiler.compile(
         doc_class, Lutaml::Model::Config.default_register
       )
       expect(plan).not_to be_nil
@@ -623,7 +623,7 @@ RSpec.describe "XML plan fast path" do
       expect(req.guidance.map(&:text)).to eq(%w[g1 g2])
       expect(req.purpose.map(&:text)).to eq(["p1"])
 
-      expect(Lutaml::Xml::PlanCompiler.compile(partitioned,
+      expect(Lutaml::Xml::Leptris::PlanCompiler.compile(partitioned,
                                                :default)).to be_nil
     end
 
@@ -708,7 +708,7 @@ RSpec.describe "XML plan fast path" do
     stub_const("PlanFastPath::UpdateFields847", klass)
 
     expect(klass.new(value: false).to_xml).to include("http://example.com/ord847")
-    plan = Lutaml::Xml::PlanCompiler.compile(
+    plan = Lutaml::Xml::Leptris::PlanCompiler.compile(
       klass, Lutaml::Model::Config.default_register
     )
     expect(plan[:namespaced]).to be(true)

data/spec/lutaml/xml/plan_partition_spec.rb

@@ -37,7 +37,7 @@ RSpec.describe "Plan fast path with when_attribute partitions" do
   end
 
   it "compiles the partitioned model with row tags" do
-    plan = Lutaml::Xml::PlanCompiler.compile(
+    plan = Lutaml::Xml::Leptris::PlanCompiler.compile(
       model, Lutaml::Model::Config.default_register
     )
     expect(plan).not_to be_nil

data/spec/lutaml/xml/plan_walk_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
-require "lutaml/xml/plan_walk"
+require "lutaml/xml/leptris/plan_walk"
 
 RSpec.describe "XML PlanWalk consumer surface" do
   around do |example|
@@ -25,7 +25,7 @@ RSpec.describe "XML PlanWalk consumer surface" do
 
   it "hydrates equal to the interpretive path on a single-row document" do
     xml = %(<row id="7"><name>Alice</name><tags>x</tags><tags>y</tags></row>)
-    walked = Lutaml::Xml::PlanWalk.call(item_class, xml)
+    walked = Lutaml::Xml::Leptris::PlanWalk.call(item_class, xml)
     expected = item_class.from_xml(xml)
 
     expect(walked).to be_a(item_class)
@@ -46,7 +46,7 @@ RSpec.describe "XML PlanWalk consumer surface" do
       end
     end
 
-    walked = Lutaml::Xml::PlanWalk.call(root_class, xml)
+    walked = Lutaml::Xml::Leptris::PlanWalk.call(root_class, xml)
     expected = root_class.from_xml(xml)
 
     expect(walked.item).to be_an(Array)
@@ -71,7 +71,7 @@ RSpec.describe "XML PlanWalk consumer surface" do
       end
     end
 
-    walked = Lutaml::Xml::PlanWalk.call(root_class, xml)
+    walked = Lutaml::Xml::Leptris::PlanWalk.call(root_class, xml)
     interpretive = root_class.from_xml(xml)
     expect(walked.item.size).to eq(interpretive.item.size)
     expect(walked.item.map(&:id)).to eq(interpretive.item.map(&:id))
@@ -94,9 +94,9 @@ RSpec.describe "XML PlanWalk consumer surface" do
       end
     end
 
-    expect(Lutaml::Xml::PlanCompiler.compile(klass,
+    expect(Lutaml::Xml::Leptris::PlanCompiler.compile(klass,
                                              Lutaml::Model::Config.default_register)).not_to be_nil
-    expect(Lutaml::Xml::PlanWalk.call(klass, "<doc><note>x</note></doc>").tgt.note)
+    expect(Lutaml::Xml::Leptris::PlanWalk.call(klass, "<doc><note>x</note></doc>").tgt.note)
       .to eq("x")
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.84
+  version: 0.8.85
 platform: ruby
 authors:
 - Ribose Inc.
@@ -781,7 +781,13 @@ files:
 - lib/lutaml/xml/format_chooser.rb
 - lib/lutaml/xml/hoisting_algorithm.rb
 - lib/lutaml/xml/html_entities.rb
+- lib/lutaml/xml/leptris.rb
 - lib/lutaml/xml/leptris/element.rb
+- lib/lutaml/xml/leptris/plan_compiler.rb
+- lib/lutaml/xml/leptris/plan_hydrator.rb
+- lib/lutaml/xml/leptris/plan_order.rb
+- lib/lutaml/xml/leptris/plan_serializer.rb
+- lib/lutaml/xml/leptris/plan_walk.rb
 - lib/lutaml/xml/listener.rb
 - lib/lutaml/xml/mapping.rb
 - lib/lutaml/xml/mapping_rule.rb
@@ -810,11 +816,6 @@ files:
 - lib/lutaml/xml/parse_session.rb
 - lib/lutaml/xml/parsed_namespace_declaration.rb
 - lib/lutaml/xml/parsed_namespace_set.rb
-- lib/lutaml/xml/plan_compiler.rb
-- lib/lutaml/xml/plan_hydrator.rb
-- lib/lutaml/xml/plan_order.rb
-- lib/lutaml/xml/plan_serializer.rb
-- lib/lutaml/xml/plan_walk.rb
 - lib/lutaml/xml/polymorphic_value_handler.rb
 - lib/lutaml/xml/qualified_inheritance_strategy.rb
 - lib/lutaml/xml/rexml.rb