lutaml-model 0.8.101 → 0.8.103

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70de43228d2b233faab386c9016139160f2b75e9f76c27386de22104df2820f5
-  data.tar.gz: 78b4591ba8eec19bbc7fde9a1fd2d298c58094b1198352f2323067406d39b5aa
+  metadata.gz: 02366b5cf16f9598e6eae1c391d7b21002fe9744cc4d617bf4bb9ffc785141a8
+  data.tar.gz: b3e2928f228d2aa613e506c6b07ce70a765bb33d1574e61e871fd7f6d226ee43
 SHA512:
-  metadata.gz: f1d54790ba8f6d44834134ef283b3d146002e3ca4f2e25f0fb99e84bd442878d6470d50f6da81f36a8e4165e93c07e2e3a6de2cffeb981f45b40d849a6be1037
-  data.tar.gz: 4d358cd375296cdb737fa12300076a4154f38aa22ce940cbcb7483453691152d4cbfd25fef88131fe1150105868eb9a1d56fa193028f3bd51eff7eb853d43c09
+  metadata.gz: '096e5a0302f14999f0f0c33c5c08455cdea460bee145d0a2cbb222d5bf19157f931a8aecd9e99a2232e176db0a7c546b62908a91f851c083aedf75a4cbfb5993'
+  data.tar.gz: 79a62c6ce918c5ea416eec0a9343a9b52b65f5f9d7e234bcc94beaba817e2658d25ba680215ffaee282a8bfc4ba3f4d4fd2900ecfe5907c36f0ff317ec293028

data/Gemfile

@@ -44,11 +44,12 @@ 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.
-# leptris floor: the plan hydrator's one-crossing snapshot
-# (leptris_plan_value_children_snapshot) landed in 1.9.273.0; older
-# gems fall back to accessor enumeration at runtime, but CI and dev
-# resolve the snapshot-capable line.
-gem "leptris", ">= 1.9.273.0"
+# leptris floor: the single capability line for the plan fast path
+# (see Lutaml::Xml::Leptris::MIN_LEPTRIS_VERSION) — child snapshots,
+# exact-URI attribute rows, nested-attribute capture, wildcard rows,
+# walk-side ns retention and leniency, :unqualified rows, and the
+# address-based text attach all ride it.
+gem "leptris", ">= 1.9.336.0"
 gem "teptris"
 gem "yeptris" unless Gem.win_platform?
 # TODO: revert rng branch to main when lutaml/rng#32 is merged

data/lib/compat/opal/lutaml_model_boot.rb

@@ -382,6 +382,7 @@ require "lutaml/xml/error/namespace_mismatch_error"
 require "lutaml/xml/error/schema_validation_error"
 require "lutaml/xml/error/xml_configuration_error"
 require "lutaml/xml/error/xml_error"
+require "lutaml/xml/leptris/native_emission"
 require "lutaml/xml/leptris/plan_compiler"
 require "lutaml/xml/leptris/plan_hydrator"
 require "lutaml/xml/leptris/plan_order"

data/lib/lutaml/model/configuration.rb

@@ -19,6 +19,12 @@ module Lutaml
       # compilable XML models (Leptris::XML::Descriptor walk). Opt-in
       # while the full semantics audit completes.
       attr_accessor :xml_plan_fast_path
+      # Ordered/mixed-content models on the plan path: opt-in. The
+      # per-node ordered hydration is FASTER than the interpretive
+      # lane on time but allocates above the downstream budget gates
+      # (niso pnas ratio 1.25); it ships dark until the allocation
+      # diet lands.
+      attr_accessor :xml_plan_ordered_path
       # #909: when false, XML deserialization skips the per-instance
       # element_order/attribute_order summaries — read-only consumers of
       # large documents never serialize back and should not pay for
@@ -31,6 +37,7 @@ module Lutaml
         @conversion_cache = nil
         @configured = false
         @xml_plan_fast_path = true
+        @xml_plan_ordered_path = false
         @element_order_tracking = true
       end
 

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

@@ -84,6 +84,26 @@ module Lutaml
           @__order_tracking__ ? true : false
         end
 
+        # Whether any writer setter ran on this instance. Parsed
+        # instances start pristine — every set element value is covered
+        # by the parse-built element_order, so ordered serialization
+        # can skip order reconciliation; the first writer-set marks the
+        # instance and reconciliation engages (writer-added values sit
+        # outside the parse order).
+        # @return [Boolean]
+        def mutated_after_parse?
+          @__mutated_after_parse__ ? true : false
+        end
+
+        # Construction-time reset: hydration routes every attribute
+        # through the generated writers (which mark mutations); a
+        # freshly built instance is definitionally not
+        # mutated-after-parse.
+        # @return [void]
+        def clear_mutated_after_parse!
+          @__mutated_after_parse__ = false
+        end
+
         # Record a singular attribute mutation in element_order.
         #
         # No-op unless order tracking is enabled (i.e. the instance was
@@ -102,6 +122,7 @@ module Lutaml
         #   content for content-mapped attributes, ignored otherwise
         # @return [Object] the passed value
         def record_mutation(attribute_name, value = nil)
+          @__mutated_after_parse__ = true
           return value unless @__order_tracking__
 
           track_order(attribute_name, value, nil)
@@ -122,6 +143,7 @@ module Lutaml
         # @param value [Object, nil] The value assigned to the collection
         # @return [Object] the passed value
         def record_mutation_collection(attribute_name, value)
+          @__mutated_after_parse__ = true
           return value unless @__order_tracking__
           return value if value.nil? || Lutaml::Model::Utils.uninitialized?(value)
 

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

@@ -138,7 +138,6 @@ module Lutaml
           register = Lutaml::Model::Config.default_register
           plan = Lutaml::Xml::Leptris::PlanCompiler.compile(self, register)
           return nil unless plan
-          return nil unless Lutaml::Xml::Leptris::PlanCompiler.engine_walk_safe?(plan)
 
           root = ::Leptris::XML.parse(data.to_s).root
           return nil if root.nil?
@@ -146,7 +145,11 @@ module Lutaml
 
           Lutaml::Xml::Leptris::PlanHydrator.call(self, plan,
                                          plan[:descriptor].walk(root),
-                                         node: root)
+                                         node: root,
+                                         declaration_plan_mode:
+                                           options.fetch(
+                                             :import_declaration_plan, :eager
+                                           ))
         rescue ::Leptris::XML::ParseError => e
           raise Lutaml::Model::InvalidFormatError.new(:xml, e.message)
         end

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

@@ -455,6 +455,7 @@ module Lutaml
             unknown = attrs.keys.find { |k| !known.include?(k.to_sym) }
             raise Error, "unknown attribute '#{unknown}' for #{self}"
           end
+          instance.clear_mutated_after_parse!
           instance
         end
 

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.101"
+    VERSION = "0.8.103"
   end
 end

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

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    module Leptris
+      # The native emission lane of the plan fast path: instead of
+      # minting the output DOM node-by-node through the Ruby
+      # create_child chain, build a plan RESULT from ops
+      # (leptris_plan_result_build), render it through the engine's
+      # plan serializer, reparse the compact output, and write it with
+      # the engine's indented document writer. Both renderings are
+      # pure C; measured 2.4x faster than the DOM-mint loop on the
+      # 500-row audit at a modest allocation increase.
+      #
+      # Byte-parity with the DOM lane holds because both lanes end at
+      # the same document writer over structurally identical
+      # documents: the compact emission escapes exactly as the DOM
+      # text nodes do, and reparsing yields one text node per leaf,
+      # matching the minted tree. The reparse is an engine-internal
+      # cost, not a Ruby one.
+      #
+      # Emission is enabled for the provably static subset: trees with
+      # no namespace form anywhere (every spelling is the unwritten
+      # local name, nothing to declare, no instance-dependent
+      # prefix/default flips) and the non-ordered build() shapes
+      # (attributes, scalars, collections, nested models). Wildcard,
+      # raw, callback, and content rows and ordered models keep the
+      # DOM lane — their emission shapes are not expressible as ops
+      # (or not verified to be) and the DOM lane is byte-exact.
+      module NativeEmission
+        ROOT_ROW = 0xFFFF_FFFF
+        EMITTABLE_KINDS = %i[scalar collection nested].freeze
+
+        class << self
+          def compatible?(plan)
+            !plan[:ordered] && tree_emittable?(plan[:tree])
+          end
+
+          # Pre-order depth-first, children in row order — the same
+          # walk Descriptor.flatten_plan performs, so the plan_index
+          # counters here match the engine's flattened plans array.
+          def tree_emittable?(tree)
+            return false if tree[:ns]
+            return false if (tree[:attributes] || []).any? { |a| a[:ns].is_a?(Hash) }
+
+            (tree[:children] || []).all? do |row|
+              EMITTABLE_KINDS.include?(row[:kind]) &&
+                (row[:kind] != :nested || !row[:plan] || tree_emittable?(row[:plan]))
+            end
+          end
+
+          def emit(instance, plan, register)
+            ops = [{ kind: :element, row_index: ROOT_ROW }]
+            emit_element(ops, instance, plan, register, 0)
+            ops << { kind: :end }
+            compact = plan[:descriptor].serialize(
+              plan[:descriptor].build_result(ops),
+            )
+            ::Leptris::XML.parse(compact).to_xml(indent: 2, no_decl: true)
+          end
+
+          private
+
+          # plan_index: this plan's flattened index. The engine's
+          # flatten_plan pushes each nested row's child plan exactly
+          # once — collection members share that slot — so child flat
+          # indices come from a static per-plan layout (relative to
+          # this plan's index), never from a runtime counter.
+          def emit_element(ops, instance, plan, register, plan_index)
+            my_index = plan_index
+            layout = flat_layout_for(plan)
+
+            emit_attributes(ops, instance, plan, my_index, register)
+
+            plan[:rows].each_with_index do |(rule, attr, kind, _spelling, delegate), row_index|
+              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 DOM lane does.
+                if value.is_a?(::Array)
+                  value.each do |item|
+                    ops << scalar_op(my_index, row_index, attr, item, register)
+                  end
+                else
+                  ops << scalar_op(my_index, row_index, attr, value, register)
+                end
+              when :collection_native, :collection_cb
+                Array(value).each do |item|
+                  ops << scalar_op(my_index, row_index, attr, item, register)
+                end
+              when :nested
+                _tree, child_rel = layout[row_index]
+                next unless child_rel
+
+                Array(value).each do |item|
+                  child_plan = nested_plans_for(plan)[[item.class, rule.name.to_s]] ||
+                    (nested_plans_for(plan)[[item.class, rule.name.to_s]] =
+                       PlanCompiler.compile(item.class, register))
+                  ops << { kind: :element, plan_index: my_index,
+                           row_index: row_index }
+                  emit_element(ops, item, child_plan,
+                               register, my_index + child_rel)
+                  ops << { kind: :end }
+                end
+              end
+            end
+          end
+
+          # {nested row_index => [child tree, relative flat index]} —
+          # children of this plan occupy slots my_index+1 .. in row
+          # order, each nested row's subtree sized once.
+          def flat_layout_for(plan)
+            plan[:flat_layout] ||= begin
+              layout = {}
+              rel = 1
+              (plan[:tree][:children] || []).each_with_index do |row, i|
+                next unless row[:kind] == :nested && row[:plan]
+
+                layout[i] = [row[:plan], rel]
+                rel += subtree_size(row[:plan])
+              end
+              layout
+            end
+          end
+
+          def subtree_size(tree)
+            1 + (tree[:children] || []).sum do |row|
+              row[:kind] == :nested && row[:plan] ? subtree_size(row[:plan]) : 0
+            end
+          end
+
+          def emit_attributes(ops, instance, plan, plan_index, register)
+            recorded = instance.attribute_order
+            attr_rows = plan[:attr_rows]
+            if recorded && !recorded.empty?
+              by_name = {}
+              attr_rows.each { |rule, attr, _sp, delegate| by_name[rule.name.to_s] = [rule, attr, delegate] }
+              names = recorded | attr_rows.map { |rule, _a, _s, _d| rule.name.to_s }
+            else
+              names = attr_rows.map { |rule, _a, _s, _d| rule.name.to_s }
+              by_name = {}
+              attr_rows.each { |rule, attr, _sp, delegate| by_name[rule.name.to_s] = [rule, attr, delegate] }
+            end
+            tree_attrs = plan[:tree][:attributes] || []
+            names.each do |name|
+              entry = by_name[name]
+              next unless entry
+
+              _rule, attr, delegate = entry
+              value = value_of(instance, attr, delegate)
+              next if value.nil?
+
+              row_index = tree_attrs.index { |a| a[:name] == name }
+              next unless row_index
+
+              ops << { kind: :attr, plan_index: plan_index,
+                       row_index: row_index, name: name,
+                       value: attr.serialize(value, :xml, register).to_s }
+            end
+          end
+
+          def scalar_op(plan_index, row_index, attr, value, register)
+            { kind: :scalar, plan_index: plan_index, row_index: row_index,
+              value: attr.serialize(value, :xml, register).to_s }
+          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 nested_plans_for(plan)
+            plan[:nested_plans] ||= {}
+          end
+        end
+      end
+    end
+  end
+end