lutaml-model 0.8.24 → 0.8.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8aca94b467fe681429ee9863355555d3aa003d9deda8543a74fd1424087bcc8
-  data.tar.gz: 02db8dceef19fc7ef7abd3a54f0936e00ef162a1ee6477191a8b1d3477ba7860
+  metadata.gz: b364f3d15a4c9fc529d85154e1e4789997432f557be698bfef559e3dc1139163
+  data.tar.gz: 3fe6af19792fc59b5800d0078e34171dd9b5d4c4009922e43a8eb0050ad8308c
 SHA512:
-  metadata.gz: 4da87513ed839ba070c32b28de27411ffe12ccc92f879a0dbe433aad85ea3a32a76759b36112958a131b09a747b1618c0ff8a95e92238aca40f45b736dd46950
-  data.tar.gz: ff488be2b79ef92c3017d63ee0a9bf4ac3b183549be5b17a59efcb42ea31ae00cacb2b63995f9b69fbe3628af9bd65f30dfedb2fb5d2722fe15189c7e964a93b
+  metadata.gz: 7b3ebf674d7f7d306caea42542b54250dcd7ebbffc23186e2e8aa2b932d040e7dcdf4f74f41b1a9b66f089661eacd3eb8cf0676c8728b471f14e5c403175f2d4
+  data.tar.gz: e38d81dc78936d9e24d0f389134bca507c7a77d338196663ef10d1986bc3165da3ae7c88043ef0fe5c04189aace3f846034ed5a03f3463d7dfbf48267ab42fa6

data/Gemfile

@@ -19,7 +19,6 @@ gem "benchmark-ips"
 gem "bigdecimal"
 gem "canon" # , path: "../canon"
 gem "json-ld"
-gem "leptris"
 gem "liquid", "~> 5"
 gem "multi_json"
 gem "nokogiri"
@@ -27,10 +26,13 @@ gem "oj"
 gem "openssl", "~> 3.0"
 gem "ox"
 gem "rake"
-# yeptris ships prebuilt platform gems for linux/darwin only; a source
-# build is not wired for windows runners.
 gem "rdf-turtle"
 gem "rexml"
+# Native engines stay development-only: every adapter detects and
+# degrades gracefully at runtime (safe requires + prefer-if-available).
+# yeptris ships no Windows prebuilt platform gem.
+gem "leptris"
+gem "teptris"
 gem "yeptris" unless Gem.win_platform?
 # TODO: revert rng branch to main when lutaml/rng#32 is merged
 gem "rng", git: "https://github.com/lutaml/rng", branch: "main"
@@ -39,8 +41,6 @@ gem "rubocop"
 gem "rubocop-performance", require: false
 gem "rubocop-rake", require: false
 gem "rubocop-rspec", require: false
-# teptris ships prebuilt gems for every platform (incl. mingw-ucrt)
-gem "teptris"
 gem "tomlib"
 gem "toml-rb"
 

data/lib/compat/opal/lutaml_model_boot.rb

@@ -169,6 +169,9 @@ require "lutaml/xml/parsed_namespace_declaration"
 require "lutaml/xml/parsed_namespace_set"
 require "lutaml/xml/plan_compiler"
 require "lutaml/xml/plan_hydrator"
+require "lutaml/xml/plan_order"
+require "lutaml/xml/plan_serializer"
+require "lutaml/xml/plan_walk"
 require "lutaml/xml/polymorphic_value_handler"
 require "lutaml/xml/qualified_inheritance_strategy"
 require "lutaml/xml/rexml"

data/lib/lutaml/json/adapter/yeptris_adapter.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "yeptris"
 require_relative "standard_adapter"
 
 module Lutaml
@@ -13,6 +12,7 @@ module Lutaml
       # load-only), so everything else inherits from the standard adapter.
       class YeptrisAdapter < StandardAdapter
         def self.parse(json, _options = {})
+          require "yeptris"
           ::Yeptris::JSON.load(json)
         end
       end

data/lib/lutaml/model/compiled_rule.rb

@@ -183,6 +183,22 @@ module Lutaml
         options.fetch(key, default)
       end
 
+      # Hot rule-shape reads on the serialization path (form/raw/cdata
+      # dominate method_missing traffic — one serialization of the
+      # 200-item probe made 4,800 misses). Real methods keep the hot
+      # path off method_missing; same source (options), same defaults.
+      def form
+        options[:form]
+      end
+
+      def raw
+        options[:raw]
+      end
+
+      def cdata
+        options[:cdata]
+      end
+
       # Handle method calls for accessing options dynamically
       #
       # This allows options to be accessed as methods (e.g., rule.cdata, rule.raw, rule.mixed_content)

data/lib/lutaml/model/serialize/format_conversion.rb

@@ -81,6 +81,29 @@ module Lutaml
           # No-op by default; XML overrides via prepend
         end
 
+        # Serialize-side plan fast path: same compiled plan, direct
+        # leptris construction. Serialize-shaped plans only — custom
+        # methods, polymorphism, unions, and spellings keep the
+        # interpretive serializer.
+        def xml_plan_fast_serialize(instance, options)
+          return nil unless defined?(::Leptris::XML::Document)
+          return nil if options.key?(:only) || options.key?(:except) ||
+            options.key?(:mappings) || options.key?(:adapter) ||
+            options.key?(:_adapter_override) ||
+            options.key?(:indent) || options.key?(:xml_declaration) ||
+            options.key?(:declaration) || options.key?(:doctype)
+
+          adapter_name = Lutaml::Model::Config.adapter_for(:xml)
+          adapter_name &&= adapter_name.name
+          return nil unless adapter_name.to_s.end_with?("LeptrisAdapter")
+
+          register = Lutaml::Model::Config.default_register
+          plan = Lutaml::Xml::PlanCompiler.compile(self, register)
+          return nil unless plan && Lutaml::Xml::PlanSerializer.serializable?(plan)
+
+          Lutaml::Xml::PlanSerializer.call(instance, plan)
+        end
+
         # Whole-document native materialization (Phase 5): compile the
         # mapping into a Leptris descriptor plan and hydrate from one
         # plan walk. Only when the resolved XML adapter is leptris-
@@ -106,7 +129,8 @@ module Lutaml
           return nil unless root.name == plan[:tree][:name]
 
           Lutaml::Xml::PlanHydrator.call(self, plan,
-                                         plan[:descriptor].walk(root))
+                                         plan[:descriptor].walk(root),
+                                         node: root)
         rescue ::Leptris::XML::ParseError => e
           raise Lutaml::Model::InvalidFormatError.new(:xml, e.message)
         end
@@ -240,6 +264,10 @@ module Lutaml
           Instrumentation.instrument(:to, model: name, format: format) do
             adapter_override = options.delete(:adapter)
             options[:_adapter_override] = true if adapter_override
+            if format == :xml && Lutaml::Model::Config.instance.xml_plan_fast_path
+              fast = xml_plan_fast_serialize(instance, options)
+              return fast if fast
+            end
             value = public_send(:"as_#{format}", instance, options)
             adapter = resolve_adapter(format, adapter_override)
 

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.24"
+    VERSION = "0.8.28"
   end
 end

data/lib/lutaml/xml/declaration_planner.rb

@@ -281,12 +281,18 @@ module Lutaml
 
       attr_reader :register
 
-      # Resolve the correct register for a child mapper class
+      # Resolve the correct register for a child mapper class.
+      # Hoisted per (mapper class) on the planner: resolve_for_child is
+      # globally cached but each call still allocates its key — the
+      # serialization hot path resolves the same handful of child
+      # classes per element.
       #
       # @param mapper_class [Class] The child's mapper class
       # @return [Symbol] The resolved register ID
       def register_for(mapper_class)
-        Lutaml::Model::Register.resolve_for_child(mapper_class, @register)
+        @register_for ||= {}
+        @register_for[mapper_class] ||=
+          Lutaml::Model::Register.resolve_for_child(mapper_class, @register)
       end
 
       # Build individual child plans for collection items

data/lib/lutaml/xml/format.rb

@@ -23,6 +23,9 @@ module Lutaml
   module Xml
     autoload :PlanCompiler, "#{__dir__}/plan_compiler"
     autoload :PlanHydrator, "#{__dir__}/plan_hydrator"
+    autoload :PlanOrder, "#{__dir__}/plan_order"
+    autoload :PlanSerializer, "#{__dir__}/plan_serializer"
+    autoload :PlanWalk, "#{__dir__}/plan_walk"
     # Error module for XML-specific errors
     module Error
       autoload :XmlError, "#{__dir__}/error/xml_error"

data/lib/lutaml/xml/namespace_collector.rb

@@ -566,9 +566,10 @@ module Lutaml
                 # Resolve type using child model's register context
                 mapper_class = options[:mapper_class]
                 child_register = if mapper_class
-                                   Lutaml::Model::Register.resolve_for_child(
-                                     mapper_class, @register
-                                   )
+                                   (@register_for ||= {})[mapper_class] ||=
+                                     Lutaml::Model::Register.resolve_for_child(
+                                       mapper_class, @register
+                                     )
                                  else
                                    @register
                                  end

data/lib/lutaml/xml/plan_compiler.rb

@@ -9,13 +9,15 @@ module Lutaml
     # walk+hydrate 8.7x faster, 82% fewer allocations than the
     # interpretive path, hydration-equal output.
     #
-    # A model compiles only when EVERY rule is plan-shaped; anything
-    # richer keeps the interpretive path (all-or-nothing per model):
-    #   - map_attribute / map_element rows only
-    #   - element rows: Value-scalar types or nested Serializables
-    #   - no content/raw mappings, custom methods, delegates,
-    #     polymorphism, transforms, multiple spellings, namespaces,
-    #     ordered mappings, hash_mappings, root_mappings
+    # A model compiles when EVERY rule is plan-shaped; richer rows
+    # defer their subtree verbatim and interpret post-walk rather
+    # than opting the whole model out:
+    #   - map_attribute / map_element / content / raw rows
+    #   - Value-scalar types or nested Serializables
+    #   - custom methods, polymorphism, unions, and ordered/mixed
+    #     children capture :raw and interpret post-walk
+    #   - ordered/mixed root mappings compile; the entry points
+    #     reconstruct element_order from the node surface
     #   - attributes not derived/union/polymorphic
     #
     # The fast path is opt-in (Config.xml_plan_fast_path) while the
@@ -52,48 +54,133 @@ module Lutaml
           rows = []
           attr_rows = [] # [[rule, attr]] hydration metadata
           plan_attrs = [] # [{name:, kind:}] rows for the engine plan
-          compiled = [] # [rule, attr, kind] in children order
+          compiled = [] # [rule, attr, kind, spelling, delegate_target]
+          cdata = false
+          mixed_content = false
+          needs_nodes = false
+          collection_defaults = [] # collection attrs with element rows
+          tag = 100 # type_tag echo space for callback-routed rows
+          model_ns = plan_namespace(model_class, mapping, register)
+
+          # Collection rows are NATIVE since leptris 1.9.178 —
+          # collection values echo name and type_tag (the #220 gap is
+          # closed), so any number routes without callbacks.
+          true
+
           mapping.mappings(register).each do |rule|
-            attr = model_class.attributes(register)[rule.to]
+            delegate_target = nil
+            attr = if rule.delegate
+                     delegate_target = model_class.attributes(register)[rule.delegate]
+                     t = delegate_target&.type(register)
+                     if t.is_a?(Class) && t.include?(::Lutaml::Model::Serialize)
+                       t.attributes(register)[rule.to]
+                     end
+                   else
+                     model_class.attributes(register)[rule.to]
+                   end
             return nil if attr.nil?
-            return nil if attr.derived? || attr.union? || attr.polymorphic?
+            return nil if attr.derived?
+
+            # Interpretive hydration materializes every mapped
+            # collection, present or not; the fast path mirrors with
+            # constructor-time empty arrays.
+            unless rule.attribute? || !attr.collection?
+              collection_defaults << attr.name.to_sym
+            end
+
+            # Fragment deferrals lose ancestor namespace context —
+            # ns-qualified models keep those rules interpretive.
+            fragment_needed = rule.has_custom_method_for_deserialization? ||
+              rule.polymorphic_mapping? || attr.polymorphic? || attr.union?
+            return nil if fragment_needed && model_ns
 
             if rule.attribute?
               return nil unless scalar_type?(attr, register)
 
               attr_rows << [rule, attr]
               plan_attrs << { name: rule.name.to_s }
-            else
-              return nil unless plan_element_row?(rule)
+            elsif rule.content_mapping?
+              return nil if content_rows(rows) >= 1
+
+              mixed_content = true
+              compiled << [rule, attr,
+                           attr.collection? ? :content : :content_deferred,
+                           nil, delegate_target]
+              rows << { name: "__content__#{compiled.size}", kind: :content }
+            elsif rule.raw_mapping? || rule.raw == :element
+              compiled << [rule, attr, :raw, nil, delegate_target]
+              rows << { name: rule.name.to_s, kind: :raw }
+            elsif rule.has_custom_method_for_deserialization?
+              needs_nodes = true
+              compiled << [rule, attr, :custom_method, nil, delegate_target]
+              rows << { name: rule.name.to_s, kind: :raw }
+            elsif rule.polymorphic_mapping? || attr.polymorphic? || attr.union?
+              type = attr.type(register)
+              return nil unless serializable_type?(type) || attr.union?
 
+              needs_nodes = true
+              compiled << [rule, attr, :polymorphic, nil, delegate_target]
+              rows << { name: rule.name.to_s, kind: :raw }
+            else
               type = attr.type(register)
               if serializable_type?(type)
                 child = compile(type, register)
                 return nil unless child
 
-                compiled << [rule, attr, :nested]
-                rows << { name: rule.name.to_s, kind: :nested,
-                          plan: child[:tree] }
+                if child[:ordered]
+                  # Ordered/mixed children need element_order on their
+                  # instances; the walk hands back plan values, not
+                  # source nodes, so the subtree defers interpretively
+                  # (the fragment parse runs the full machinery,
+                  # order included).
+                  return nil if model_ns
+
+                  needs_nodes = true
+                  compiled << [rule, attr, :ordered_deferred, nil,
+                               delegate_target]
+                  rows << { name: rule.name.to_s, kind: :raw }
+                else
+                  compiled << [rule, attr, :nested, nil, delegate_target]
+                  needs_nodes ||= child[:needs_nodes]
+                  nested_row = { name: rule.name.to_s, kind: :nested,
+                                 plan: child[:tree] }
+                  nested_row[:ns] = child_ns(rule, model_ns) if rule.namespace_set?
+                  rows << nested_row
+                end
+              elsif rule.multiple_mappings?
+                rule.name.each do |spelling|
+                  compiled << [rule, attr, :spelling, spelling.to_s,
+                               delegate_target]
+                  rows << { name: spelling.to_s, kind: :callback,
+                            type_tag: (tag += 1) }
+                end
               else
                 return nil unless scalar_type?(attr, register)
 
-                kind = attr.collection? ? :collection : :scalar
-                # Collection row values carry neither name nor type_tag
-                # echo (leptris 1.9.174): hydration can only attribute
-                # them unambiguously with a single collection row per
-                # element.
-                if kind == :collection && rows.count { |r| r[:kind] == :collection } >= 1
-                  return nil
+                row = { name: rule.name.to_s }
+                row[:ns] = child_ns(rule, model_ns) if rule.namespace_set?
+
+                if attr.collection?
+                  compiled << [rule, attr, :collection_native, nil,
+                               delegate_target]
+                  rows << row.merge(kind: :collection)
+                else
+                  cdata ||= rule.cdata
+                  compiled << [rule, attr, :scalar, nil, delegate_target]
+                  rows << row.merge(kind: :scalar)
                 end
-
-                compiled << [rule, attr, kind]
-                rows << { name: rule.name.to_s, kind: kind }
               end
             end
           end
 
-          tree = { name: mapping.root_element.to_s, attributes: plan_attrs,
-                   children: rows }
+          flags = []
+          flags << :cdata if cdata
+          flags << :mixed_content if mixed_content
+          flags << :ns_lenient if model_ns
+          tree = { name: mapping.root_element.to_s,
+                   attributes: plan_attrs, children: rows }
+          tree[:ns] = model_ns if model_ns
+          tree[:flags] = flags unless flags.empty?
           begin
             # Lazy: the Opal boot loads this file, and leptris is a
             # native gem there — the require only belongs on the
@@ -105,23 +192,50 @@ module Lutaml
           end
 
           { descriptor: descriptor, tree: tree, rows: compiled,
-            attr_rows: attr_rows, mapping: mapping }
+            attr_rows: attr_rows, mapping: mapping,
+            ordered: mapping.ordered? || mapping.mixed_content?,
+            needs_nodes: needs_nodes,
+            collection_defaults: collection_defaults }
         end
 
         def compilable_mapping?(mapping)
-          !mapping.ordered? && mapping.root_element &&
+          mapping.root_element &&
             !(mapping.respond_to?(:root_mappings) && mapping.root_mappings)
         end
 
-        def plan_element_row?(rule)
-          !rule.raw_mapping? && !rule.content_mapping? &&
-            !rule.delegate && !rule.multiple_mappings? &&
-            !rule.namespace_set? && !rule.cdata &&
-            !rule.mixed_content && !rule.as_list && !rule.delimiter &&
-            !rule.has_custom_method_for_deserialization? &&
-            !rule.polymorphic_mapping? &&
-            !(rule.transform.is_a?(Hash) && !rule.transform.empty?) &&
-            !rule.transform.is_a?(Class)
+        # Attribute for a rule — delegate rules resolve against their
+        # target model's attributes.
+        def attr_of(model_class, rule, register)
+          attr = model_class.attributes(register)[rule.to]
+          return attr if attr || !rule.delegate
+
+          target = model_class.attributes(register)[rule.delegate]
+          t = target&.type(register)
+          if t.is_a?(Class) && t.include?(::Lutaml::Model::Serialize)
+            t.attributes(register)[rule.to]
+          end
+        end
+
+        # Rule-level namespace → ChildPlan ns form (leptris 1.9.178):
+        # the child binds by local name under the rule's URI with any
+        # prefix. Blank-namespace rules (xmlns="") match :none.
+        def child_ns(rule, _model_ns)
+          uri = rule.namespace
+          return { exact: uri.to_s } if uri && !uri.to_s.empty?
+
+          :none
+        end
+
+        def content_rows(rows)
+          rows.count { |r| r[:kind] == :content }
+        end
+
+        # Model-level namespace: exact URI match with lenient prefixes
+        # — children bind by local name under any prefix the document
+        # bound to the URI (#754 adoption semantics on the engine).
+        def plan_namespace(_model_class, mapping, _register)
+          ns_class = mapping.namespace_class if mapping.respond_to?(:namespace_class)
+          ns_class&.uri ? { exact: ns_class.uri.to_s } : nil
         end
 
         def scalar_type?(attr, register)