lutaml-model 0.8.124 → 0.8.125

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4c03c6aacd7f243f8c919c1561cada699b4d6a06fa1fa7f48e7847787dcbef2
-  data.tar.gz: bdadc3e2abadd6df36b913d19ec281771e5ea4b68ec74f58b1566f93a6053242
+  metadata.gz: bd52cd1acd33af2b1f8abe39a9d57c4412618d63ee65b516204ef4fa9f7ff047
+  data.tar.gz: 903e6d8ed42b95b0c5f79616f362d856b79ef54c90b3bbc1ba854c3345e79bd2
 SHA512:
-  metadata.gz: '09ac4538324403ddc363c1b75ecedb9499a5361c399894287c83ec1ffb52cd4169cc6ea050f1dd4242c6d834b5df55845e17fa1b0c2e7b10b21c6639a52c7c26'
-  data.tar.gz: 8322eeba63f6c0b4ff546629bb81801a80d9b19b3ee13ab1fd72d5265c52b7f3248f28c498b59f3b6eb135fbe78cb73632f0cdd609cab821a5a792fd374251a6
+  metadata.gz: 125f630b5d0816ad0dbbf98e1650f9a221a19c83793fe05c38e384fa884ec251774e97b0ce9636be1a014f84f678fc2c4d42d9cbea108fc615051fbd1bf4112c
+  data.tar.gz: 9eec80327bca08b7cc3bb649c77c1b956356baa190d434ae86c5eebacaacfda95c5e2ed2392d6c1d2db7a98fa4a7e32d6d416eb74185d5f0ba8ba416cef66d2a

data/lib/lutaml/key_value/transform.rb

@@ -165,14 +165,15 @@ module Lutaml
                          Concurrent::Map.new
                        end
 
-      # [model class, register, format, rule, generation] -> KvRulePlan,
-      # or false for ineligible rules. Class-level: the interpretive
-      # walk re-derived the same eligibility chain for the same rule at
-      # every node (~12 predicate allocations x nodes per heroku.json
-      # parse). Same idempotent-write, generation-retirement pattern as
-      # KV_GROUP_PLANS; false (not nil) marks ineligible so a miss never
-      # rebuilds.
-      KV_RULE_PLANS = if Lutaml::Model.opal?
+      # [model class, register, format, generation] -> { rule => plan }.
+      # Class-level, generation-retired: the whole dispatch table for a
+      # model mapping compiles once — kind (scalar/custom/hash_map/
+      # interpretive/skip/invalid), target attribute and validity — so
+      # process_mapping_rule stops re-probing rule predicates at every
+      # node (~12 predicate calls plus a key array per rule per node;
+      # 154k+154k allocations per heroku.json parse). Same
+      # idempotent-write pattern as KV_GROUP_PLANS.
+      KV_WALK_PLANS = if Lutaml::Model.opal?
                         {}
                       else
                         Lutaml::Model::RuntimeCompatibility
@@ -717,18 +718,20 @@ format)
 
       def process_mapping_rule(doc, instance, format, rule, options = {},
 partition = nil)
-        attr = attribute_for_rule(rule)
-        return if attr&.derived?
+        plans = walk_plans_for(format)
+        plan = plans[rule] ||= build_walk_plan(format, rule)
+        kind = plan.kind
+        return if kind == :skip
 
-        raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(
-          rule, attr
-        )
+        raise "Attribute '#{rule.to}' not found in #{self}" unless plan.valid
+
+        attr = plan.attr
 
         # lutaml-model#88: discriminator rules (and plain rules on a
         # partitioned key) must filter the raw value, so they keep the
         # interpretive path.
         partitioned = partition && kv_partition_group(rule, partition)
-        if partitioned.nil? && (plan = kv_rule_plan(format, rule, attr)) &&
+        if partitioned.nil? && kind == :scalar &&
             (value = kv_fast_extract(doc, plan))
           rule.deserialize(instance, kv_fast_cast(value, plan, instance),
                            attributes, self, options[:context], pre_cast: true)
@@ -742,12 +745,14 @@ partition = nil)
         end
         value = apply_value_map(value, rule.value_map(:from, options), attr)
 
-        if rule.has_custom_method_for_deserialization?
-          # An empty value ("", [], {}) is a present value per the
-          # missing-values semantics and must reach the custom method;
-          # only nil (non-existent) skips it (lutaml-model#746).
-          return if value.nil?
+        # An empty value ("", [], {}) is a present value per the
+        # missing-values semantics and must reach the custom method;
+        # only nil (non-existent) skips it (lutaml-model#746).
+        if (kind == :custom) && value.nil?
+          return
+        end
 
+        if kind == :custom
           return rule.deserialize(instance, value, attributes, model_class,
                                   options[:context])
         end
@@ -757,11 +762,11 @@ partition = nil)
         # or explicit-null key has nothing to translate — the attribute
         # keeps its uninitialized/default state (a nil here previously
         # crashed translate_mappings).
-        return if value.nil? && (rule.hash_mappings || rule.child_mappings)
+        return if value.nil? && kind == :hash_map
 
         value = translate_mappings(value, rule.hash_mappings, attr, format,
                                    instance)
-        unless rule.hash_mappings
+        unless kind == :hash_map
           value = cast_value(value, attr, format, rule,
                              instance)
         end
@@ -792,7 +797,8 @@ partition = nil)
       # Guard + cached target — an inline cache per rule. Complex rules
       # (custom methods, transforms, value maps, delegates, hash mappings,
       # unions, polymorphism) return nil and keep the interpretive path.
-      KvRulePlan = ::Struct.new(:wire, :klass, :collection)
+      WalkPlan = ::Struct.new(:kind, :attr, :valid, :wire, :klass,
+                              :collection)
 
       # Memoized (per transform) wire name for plain rules — the from
       # spelling never changes after definition.
@@ -814,15 +820,48 @@ partition = nil)
         @kv_serialize_plans[rule] ||= KvSerializePlan.new(rule_from_name(rule))
       end
 
-      def kv_rule_plan(format, rule, attr)
-        key = [model_class, lutaml_register, format, rule,
-               Lutaml::Model::GlobalContext.context_generation]
-        cached = KV_RULE_PLANS[key]
-        return cached == false ? nil : cached unless cached.nil?
+      def walk_plans_for(format)
+        generation = Lutaml::Model::GlobalContext.context_generation
+        if @lutaml_walk_plans.nil? || @lutaml_walk_generation != generation ||
+            @lutaml_walk_format != format
+          key = [model_class, lutaml_register, format, generation]
+          @lutaml_walk_plans =
+            (KV_WALK_PLANS[key] ||= build_walk_plans(format))
+          @lutaml_walk_generation = generation
+          @lutaml_walk_format = format
+        end
+        @lutaml_walk_plans
+      end
+
+      def build_walk_plans(format)
+        plans = {}.compare_by_identity
+        mappings_for(format).mappings(lutaml_register).each do |rule|
+          plans[rule] = build_walk_plan(format, rule)
+        end
+        plans
+      end
+
+      # The per-rule dispatch compile. Kind precedence mirrors the
+      # interpretive method exactly: skip (derived) > invalid >
+      # custom (deserialization custom method) > hash_map
+      # (hash_mappings truthy — translate, never cast) > scalar (the
+      # fast-extract eligibility) > interpretive.
+      def build_walk_plan(format, rule, _attrs = nil)
+        attr = attribute_for_rule(rule)
+        return WalkPlan.new(:skip, nil, false, nil, nil, false) if attr&.derived?
+
+        valid = valid_rule?(rule, attr)
+        kind =
+          if rule.has_custom_method_for_deserialization?
+            :custom
+          elsif rule.hash_mappings
+            :hash_map
+          else
+            plan = build_kv_rule_plan(format, rule, attr)
+            plan ? :scalar : :interpretive
+          end
 
-        plan = build_kv_rule_plan(format, rule, attr)
-        KV_RULE_PLANS[key] = plan || false
-        plan
+        plan || WalkPlan.new(kind, attr, valid, nil, nil, false)
       end
 
       # `rule.polymorphic` defaults to an empty Hash, which is truthy —
@@ -849,7 +888,8 @@ partition = nil)
           !attr.value_policy.whole_value?(type) &&
           !Lutaml::Model::Attribute.custom_from_probe?(type)
 
-        KvRulePlan.new(rule.name.to_s, type, attr.collection?)
+        WalkPlan.new(:scalar, attr, true, rule.name.to_s, type,
+                     attr.collection?)
       end
 
       # Extraction fast path: plain hash fetch for a present, non-blank

data/lib/lutaml/model/union.rb

@@ -97,7 +97,23 @@ module Lutaml
                        end
               return [member, casted] unless casted == :no_match
             end
-            nil
+
+            lenient_model_member(value, members, format, register)
+          end
+
+          # With exactly one model member, a Hash that also carries unmapped
+          # keys still conforms: unknown keys are ignored by every non-union
+          # model attribute, and strict coverage would silently drop the
+          # whole value. With several model members the strict key-coverage
+          # check stays in charge — coverage is what discriminates between
+          # them. Plain-Ruby assignment keeps the strict constructor path.
+          def lenient_model_member(value, members, format, register)
+            return nil unless value.is_a?(::Hash)
+            return nil if format.nil?
+            return nil unless members.one? { |member| model_member?(member) }
+
+            member = members.find { |candidate| model_member?(candidate) }
+            [member, member.apply_mappings(value, format, register: register)]
           end
 
           # Whether a compiled mapping rule's attribute is a union — the single

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.124"
+    VERSION = "0.8.125"
   end
 end

data/spec/lutaml/model/union_attribute_spec.rb

@@ -686,14 +686,27 @@ RSpec.describe "Union-typed attributes (issue #190)" do
       expect(parsed.value).to be(true)
     end
 
-    it "returns nil only when no member conforms at all" do
+    it "builds the lone model member even when no key maps (#989: " \
+       "non-union parity)" do
       holder = Class.new(Lutaml::Model::Serializable) do
         attribute :value, [ExtendedShape, :boolean]
         key_value { map "value", to: :value }
       end
       stub_const("ExtendedHolderNinetyEight", holder)
 
-      expect(holder.from_json('{"value":{"unrelated":1}}').value).to be_nil
+      value = holder.from_json('{"value":{"unrelated":1}}').value
+
+      expect(value).to be_a(ExtendedShape)
+    end
+
+    it "returns nil when no member conforms at all" do
+      holder = Class.new(Lutaml::Model::Serializable) do
+        attribute :value, [ExtendedShape, :boolean]
+        key_value { map "value", to: :value }
+      end
+      stub_const("ExtendedHolderNinetyEightB", holder)
+
+      expect(holder.from_json('{"value":3}').value).to be_nil
     end
   end
 

data/spec/lutaml/model/union_lenient_model_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Regression spec for issue #987: with a single model member in a union,
+# a Hash carrying keys the model does not map must still conform. Unknown
+# keys are ignored by every non-union model attribute; strict key
+# coverage silently returned nil for the whole attribute instead.
+module UnionLenientModelSpec
+  class Extensible < Lutaml::Model::Serializable
+    attribute :type, :string
+    attribute :strict_properties, :boolean
+
+    key_value do
+      map "type", to: :type
+      map "strictProperties", to: :strict_properties
+    end
+  end
+
+  class Holder < Lutaml::Model::Serializable
+    attribute :value, [Extensible, :boolean]
+
+    key_value do
+      map "value", to: :value
+    end
+  end
+
+  class Other < Lutaml::Model::Serializable
+    attribute :celsius, :float
+
+    key_value do
+      map "celsius", to: :celsius
+    end
+  end
+
+  class TwoModelHolder < Lutaml::Model::Serializable
+    attribute :value, [Extensible, Other]
+
+    key_value do
+      map "value", to: :value
+    end
+  end
+
+  RSpec.describe "Union with a single model member accepts unmapped keys" do
+    it "builds the model when the hash carries unmapped keys" do
+      value = Holder.from_json('{"value":{"type":"string","x-ext":1}}').value
+
+      expect(value).to be_a(Extensible)
+      expect(value.type).to eq("string")
+    end
+
+    it "still accepts hashes with mapped keys only" do
+      value = Holder.from_json('{"value":{"type":"string"}}').value
+
+      expect(value).to be_a(Extensible)
+      expect(value.type).to eq("string")
+    end
+
+    it "keeps boolean members working" do
+      expect(Holder.from_json('{"value":true}').value).to be(true)
+      expect(Holder.from_json('{"value":false}').value).to be(false)
+    end
+
+    it "dispatches to the first model member with a mapped key across " \
+       "several members" do
+      json = '{"value":{"type":"string","celsius":1.0}}'
+
+      value = TwoModelHolder.from_json(json).value
+
+      expect(value).to be_a(Extensible)
+      expect(value.type).to eq("string")
+    end
+
+    it "still requires a match when nothing conforms" do
+      expect(Holder.from_json('{"value":3}').value).to be_nil
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.124
+  version: 0.8.125
 platform: ruby
 authors:
 - Ribose Inc.
@@ -1872,6 +1872,7 @@ files:
 - spec/lutaml/model/uninitialized_class_deep_dup_spec.rb
 - spec/lutaml/model/uninitialized_class_spec.rb
 - spec/lutaml/model/union_attribute_spec.rb
+- spec/lutaml/model/union_lenient_model_spec.rb
 - spec/lutaml/model/union_spec.rb
 - spec/lutaml/model/unregistered_context_resolution_spec.rb
 - spec/lutaml/model/utils_spec.rb