lutaml-model 0.8.84 → 0.8.86

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/mapping.rb

@@ -59,6 +59,7 @@ module Lutaml
 
         @elements = {}
         @attributes = {}
+        @any_element_rule = nil
         @element_sequence = []
         @content_mapping = nil
         @raw_mapping = nil
@@ -504,6 +505,26 @@ module Lutaml
       # @return [String, nil] the type name
       alias xsd_type type_name
 
+      # Catch-all element mapping: every child element with no
+      # explicit rule routes to one collection attribute. For
+      # parse-side consumption of dynamic vocabularies (semantic__
+      # trees); element_order preserves the original tag names.
+      # Serialization of a catch-all attribute emits the attribute's
+      # declared element name (not per-item originals).
+      def map_any_element(to:, render_nil: false, render_default: false)
+        validate!(nil, to, {}, render_nil, false, type: TYPES[:element])
+        @any_element_rule = MappingRule.new(
+          nil,
+          to: to,
+          render_nil: render_nil,
+          render_default: render_default,
+        )
+        @element_rules_index = nil if instance_variable_defined?(:@element_rules_index)
+        @any_element_rule
+      end
+
+      attr_reader :any_element_rule
+
       def map_instances(to:, polymorphic: {})
         map_element(to, to: to, polymorphic: polymorphic)
       end
@@ -1342,9 +1363,9 @@ module Lutaml
         elsif ["text", "#cdata-section"].include?(name.to_s) && type == "Text"
           content_mapping
         else
-          candidates = mappings.select do |rule|
-            rule.name == name.to_s || rule.name == name.to_sym
-          end
+          candidates = element_rules_index[name.to_s]
+          return @any_element_rule if candidates.nil? && @any_element_rule
+          return nil if candidates.nil?
           return candidates.first if namespace_uri.nil? || candidates.one?
 
           candidates.find do |r|
@@ -1353,6 +1374,29 @@ module Lutaml
         end
       end
 
+      # O(1) name -> rules lookup. Parsing consults this once per
+      # child element; the linear scan over every rule made large
+      # documents quadratic (155s on a 7MB vocabulary tree). Keyed on
+      # the stable source hashes (@elements/@attributes mutate only at
+      # DSL time), never on the per-call mappings array.
+      def element_rules_index
+        cache_key = [@elements.object_id, @attributes.object_id]
+        cached = (@element_rules_index ||= {})
+        idx = cached[cache_key]
+        return idx if idx
+
+        idx = {}
+        ([content_mapping, raw_mapping].compact + @elements.values +
+          @attributes.values).flatten.each do |rule|
+          next if rule.is_a?(::Hash)
+
+          (idx[rule.name.to_s] ||= []) << rule
+        end
+        cached[cache_key] = idx
+        idx
+      end
+      private :element_rules_index
+
       def find_by_to(to)
         mappings.detect { |rule| rule.to.to_s == to.to_s }
       end

data/lib/lutaml/xml/model_transform.rb

@@ -263,6 +263,9 @@ module Lutaml
         # Performance: Resolve xml_mapping once — used for both rules and metadata
         xml_mapping = mappings_for(:xml, effective_register)
         mappings = options[:mappings] || xml_mapping.mappings(effective_register)
+        # Catch-all rule (map_any_element): iterated like any other,
+        # claiming every child no explicit rule matches.
+        mappings += [xml_mapping.any_element_rule].compact if options[:mappings].nil?
         default_namespace = options[:default_namespace]
         ordered_option = options[:ordered]
         mixed_content_option = options[:mixed_content]
@@ -361,7 +364,25 @@ module Lutaml
               options
             end
 
-          value = if rule.raw_mapping?
+          value = if !rule.attribute? && rule.name.nil? &&
+              xml_mapping.any_element_rule.equal?(rule)
+                    # map_any_element: every child element no explicit
+                    # element rule claims, in document order. A name-less
+                    # MappingRule is otherwise indistinguishable from a
+                    # content rule (the dispatch consumed it as doc.text);
+                    # name-derived lookup also cannot express this — it
+                    # re-finds by name, losing order and double-picking.
+                    # The pass walks the document children once; the
+                    # normalize/cast pipeline below handles the rest.
+                    claimed = Set.new(
+                      xml_mapping.mappings(effective_register)
+                        .select { |r| !r.attribute? && r.name }
+                        .flat_map { |r| [r.name.to_s] },
+                    )
+                    doc.element_children.reject do |child|
+                      claimed.include?(child.unprefixed_name)
+                    end
+                  elsif rule.raw_mapping?
                     scoped_raw_inner_xml(doc, xml_mapping)
                   elsif rule.content_mapping?
                     rule.cdata ? doc.cdata : doc.text
@@ -369,6 +390,8 @@ module Lutaml
                       group.size > 1 && attr&.collection?
                     # First rule of a #765 group: match every spelling of
                     # the group so the children merge in document order.
+                    raise "GROUPED-BODY" if ENV["CATCHDBG"] && rule.name.nil?
+
                     if child_names_set &&
                         group.drop(1).none? do |s|
                           child_matches_rule?(s, child_names_set,
@@ -385,9 +408,11 @@ module Lutaml
                       value_for_rule(session, rule, new_opts, attr,
                                      extra_names)
                     end
-                  elsif child_names_set && !rule.attribute? &&
+                  elsif child_names_set && !rule.attribute? && rule.name &&
                       !child_matches_rule?(rule, child_names_set,
                                            default_namespace)
+                    raise "FASTSKIP-BODY" if ENV["CATCHDBG"] && rule.name.nil?
+
                     # Pre-match: no child element matches this rule.
                     # Skip expensive value_for_rule, handle defaults inline.
                     # NOTE: do not "read the instance" here (to_value_for) —
@@ -400,6 +425,8 @@ module Lutaml
                       ::Lutaml::Model::UninitializedClass.instance
                     end
                   else
+                    raise "ELSE-BODY" if ENV["CATCHDBG"] && rule.name.nil?
+
                     # Performance: Pass cached attr to avoid recomputing attribute_for_rule
                     val = value_for_rule(session, rule, new_opts, attr)
 

data/lib/lutaml/xml/parse_session.rb

@@ -24,6 +24,10 @@ module Lutaml
         @instance_is_serialize ||= instance.is_a?(::Lutaml::Model::Serialize)
       end
 
+      def mapping
+        @mapping ||= instance.class.mappings_for(:xml, register)
+      end
+
       # (element, rule name) -> resolved attribute name / matched
       # attribute VALUE for the lenient lookup paths. Both are pure
       # functions of the element and the name; ISO-13849-shaped

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/any_element_mapping_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+class AnyElementNode < Lutaml::Model::Serializable
+  attribute :id, :string
+  attribute :children, "AnyElementNode", collection: true
+
+  xml do
+    element "root"
+    map_element "id", to: :id
+    map_any_element to: :children
+  end
+end
+
+RSpec.describe AnyElementNode do
+  it "routes unmapped child elements to the catch-all collection" do
+    doc = described_class.from_xml(<<~XML)
+      <root>
+        <id>r-1</id>
+        <semantic__p>hello</semantic__p>
+        <semantic__title>Nested</semantic__title>
+        <semantic__p><semantic__em>deep</semantic__em></semantic__p>
+      </root>
+    XML
+
+    expect(doc.id).to eq("r-1")
+    expect(doc.children.size).to eq(3)
+  end
+
+  it "keeps explicit rules ahead of the catch-all" do
+    doc = described_class.from_xml("<root><id>x</id></root>")
+    expect(doc.id).to eq("x")
+    expect(doc.children).to be_empty
+  end
+
+  it "nests catch-all children recursively" do
+    doc = described_class.from_xml("<root><semantic__p><semantic__em>deep</semantic__em></semantic__p></root>")
+    expect(doc.children.first.children.size).to eq(1)
+  end
+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