lutaml-model 0.8.121 → 0.8.123

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b4c137e1f669303a163bde341097dae39b9171b3f9c65b2a8dba97fff0ac6e5
-  data.tar.gz: a9c13e332f7228b0d45c1a2b24ce9cbe032c7d3b9a06b8585b54c30bd78fcfdc
+  metadata.gz: 6d77a19ece999a4de97c03776b3f56bc31eb217fb14904362eef4c98b4623be6
+  data.tar.gz: b76ef3e5de721b3e94a02dbac605c61fe3ca44fe97388b8fca1ec4645c3ab494
 SHA512:
-  metadata.gz: 51cad246d238f97af6becc7e9f90409d21152e60ff136658832e3440656a13f02b18693f8683605e0831738a2fb707490d137a2a47769121a2139aa845c927f6
-  data.tar.gz: a7be0c13e87ac6d37a61044bdea091f7d49a21ad2bb75cd206424456c9d1a77a13ba895b9f2d5d7b6ae6c45fe64b71ae493cd4dab444486641ebbc7cc6294a08
+  metadata.gz: 3a03373b96d83e69500cbd2371557f5ced955e85964b3a92340e8bf3cb4da0b45ea3f83ed59fc6f47e410661c5a2e0ca0b9a5d2db6d890ce9d192ed35ccda2c1
+  data.tar.gz: 6675bdd426008a94d3e1367b584d3ce92e242b6d6e6e3a85c1e7afc544ab57cce7da847a7af53c9a3f11bd1bfb4f3b49cefb1032eb8157a5e2ddee32b4761545

data/lib/lutaml/key_value/mapping.rb

@@ -187,6 +187,24 @@ module Lutaml
 
       alias map_element map
 
+      # Collects every document key no declared rule claims into the given
+      # attribute (#985): vendor extensions and forward-compatible keywords
+      # survive the round-trip instead of being dropped. Allowed alongside
+      # normal mappings; keys claimed by any rule are never collected, and
+      # on serialization the collected hash is merged after the mapped
+      # rules so mapped keys win.
+      def map_unmapped(to:)
+        @unmapped_attribute = to
+      end
+
+      def unmapped_attribute
+        @unmapped_attribute
+      end
+
+      # Writer used by deep_dup to carry the catch-all across mapping
+      # copies (registers, value-map specializations).
+      attr_writer :unmapped_attribute
+
       def map_all(
         to: nil,
         render_nil: false,
@@ -333,6 +351,7 @@ module Lutaml
         dup_instance.tap do |new_mapping|
           new_mapping.mappings = duplicate_mappings
           new_mapping.register_mappings = Lutaml::Model::Utils.deep_dup(@register_mappings)
+          new_mapping.unmapped_attribute = @unmapped_attribute
         end
       end
 

data/lib/lutaml/key_value/transform.rb

@@ -43,10 +43,56 @@ module Lutaml
         rules.each do |rule|
           process_mapping_rule(data, instance, format, rule, options, partition)
         end
+        collect_unmapped_keys(data, instance, mappings, rules)
 
         instance
       end
 
+      # #985: with `map_unmapped to:` declared, document keys no rule
+      # claims are collected verbatim into the target attribute, exactly
+      # as the model would have kept them outside a mapping.
+      def collect_unmapped_keys(data, instance, mappings, rules)
+        return unless data.is_a?(::Hash)
+
+        target = validated_unmapped_target(mappings)
+        return if target.nil?
+
+        claimed = {}
+        rules.each do |rule|
+          Array(rule.name).each { |name| claimed[name.to_s] = true } if rule.name
+        end
+
+        extras = nil
+        data.each do |key, value|
+          next if claimed[key.to_s]
+
+          (extras ||= {})[key] = value
+        end
+        return if extras.nil?
+
+        existing = instance.public_send(target)
+        merged = existing.is_a?(::Hash) ? existing.merge(extras) : extras
+        instance.public_send(:"#{target}=", merged)
+      end
+
+      # Memoized on the cached transform (one instance per model class
+      # and register): a typo'd map_unmapped target raises at first
+      # parse, naming the class and the target, instead of NoMethodError
+      # from inside the walk.
+      def validated_unmapped_target(mappings)
+        target = mappings.unmapped_attribute
+        return if target.nil?
+        return @lutaml_unmapped_target if @lutaml_unmapped_target == target
+
+        unless model_class.attributes(lutaml_register).key?(target)
+          raise ArgumentError,
+                "map_unmapped target :#{target} is not a declared " \
+                "attribute of #{model_class}"
+        end
+
+        @lutaml_unmapped_target = target
+      end
+
       def model_to_data(instance, format, options = {})
         # NEW ARCHITECTURE: Use KeyValue::Transformation if available
         # This provides symmetric OOP architecture with XmlDataModel
@@ -83,10 +129,23 @@ module Lutaml
             process_rule!(instance, rule, hash, format, mappings, options)
           end
         end
+        merge_unmapped_on_serialize(instance, mappings, hash)
 
         hash.keys == [""] ? hash[""] : hash
       end
 
+      # #985: re-emit the collected unknown keys after the mapped rules,
+      # so a mapped key colliding with a collected one wins. The
+      # attribute was declared in the mapping and validated at compile,
+      # so the accessor exists on every instance shape.
+      def merge_unmapped_on_serialize(instance, mappings, hash)
+        target = mappings.unmapped_attribute
+        return if target.nil?
+
+        extras = instance.public_send(target)
+        extras.each { |key, value| hash[key] ||= value } if extras.is_a?(::Hash)
+      end
+
       # ---- TODO.max-perf/37: group-then-instantiate fast path ----
 
       # [model class, format, register] -> rows or false (ineligible).
@@ -106,6 +165,21 @@ 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?
+                        {}
+                      else
+                        Lutaml::Model::RuntimeCompatibility
+                          .require_native("concurrent")
+                        Concurrent::Map.new
+                      end
+
       def self.kv_group_plan(model_class, format, register)
         # Context generation: specs (and apps) reset registers between
         # parses; a plan cached across a reset references dead attribute
@@ -138,6 +212,9 @@ module Lutaml
 
         mapping = model_class.mappings_for(format, register)
         return false if mapping.nil?
+        # The catch-all collect runs on the interpretive walk only —
+        # the compiled hydration must not skip unknown keys silently.
+        return false if mapping.unmapped_attribute
 
         attrs = model_class.attributes(register)
         rows = nil
@@ -732,9 +809,14 @@ partition = nil)
       end
 
       def kv_rule_plan(format, rule, attr)
-        @kv_rule_plans ||= {}
-        @kv_rule_plans[[format, rule]] ||= build_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?
+
+        plan = build_kv_rule_plan(format, rule, attr)
+        KV_RULE_PLANS[key] = plan || false
+        plan
       end
 
       # `rule.polymorphic` defaults to an empty Hash, which is truthy —

data/lib/lutaml/key_value/transformation.rb

@@ -45,6 +45,18 @@ module Lutaml
       def initialize(model_class, mapping_dsl, format, register)
         # Extract register_id before super
         register_id = extract_register_id(register)
+        # #985: the catch-all target (collected unknown keys) — merged
+        # after the compiled rules on serialize; mapped keys win. The
+        # DSL object is a KeyValue::Mapping by contract, and the target
+        # must be a declared attribute: a typo fails here, at compile
+        # time, not as a silent no-op on the wire.
+        @unmapped_attribute = mapping_dsl.unmapped_attribute
+        if @unmapped_attribute &&
+            !model_class.attributes(register_id).key?(@unmapped_attribute)
+          raise ArgumentError,
+                "map_unmapped target :#{@unmapped_attribute} is not a " \
+                "declared attribute of #{model_class}"
+        end
         transformation_factory = ->(type_class) {
           build_child_transformation(type_class)
         }
@@ -231,6 +243,11 @@ register = self.register)
           end
         end
 
+        if @unmapped_attribute
+          extras = model_instance.public_send(@unmapped_attribute)
+          extras.each { |key, value| root[key] ||= value } if extras.is_a?(::Hash)
+        end
+
         if ENV["DEBUG_KEYED_COLLECTION"]
           puts "=== TRANSFORM COMPLETE ==="
           puts "root: #{root.inspect}"

data/lib/lutaml/model/services/rule_value_extractor.rb

@@ -1,6 +1,18 @@
 module Lutaml
   module Model
     class RuleValueExtractor < Services::Base
+      # Memoized per rule object: the extractor is fresh per node, so
+      # the name array rebuilt per node is pure churn (~145k
+      # allocations per heroku.json parse). Rules are stable per
+      # (class, register); the bounded cache tracks their arrays.
+      RULE_NAMES_CACHE = if Lutaml::Model.opal?
+                           {}
+                         else
+                           Lutaml::Model::RuntimeCompatibility
+                             .require_native("concurrent")
+                           Concurrent::Map.new
+                         end
+
       def initialize(rule, doc, format, attr, register, options,
 instance_object)
         super()
@@ -29,7 +41,8 @@ instance_object)
                   :instance_object
 
       def rule_names
-        rule.multiple_mappings? ? rule.name : [rule.name]
+        RULE_NAMES_CACHE[rule] ||=
+          rule.multiple_mappings? ? rule.name : [rule.name]
       end
 
       def rule_value_for(name)

data/lib/lutaml/model/type/boolean.rb

@@ -4,11 +4,15 @@ module Lutaml
   module Model
     module Type
       class Boolean < Value
-        def self.cast(value, _options = {})
+        def self.cast(value, _options = EMPTY_OPTIONS)
           return nil if value.nil?
           return value if Utils.uninitialized?(value)
-          return true if value == true || value.to_s.match?(/^(true|t|yes|y|1)$/i)
-          return false if value == false || value.to_s.match?(/^(false|f|no|n|0)$/i)
+          # Actual booleans are the dominant input (default resolution,
+          # parsed JSON/YAML literals): answer without the two to_s +
+          # match? allocations the lexical path costs.
+          return value if value.equal?(true) || value.equal?(false)
+          return true if value.to_s.match?(/^(true|t|yes|y|1)$/i)
+          return false if value.to_s.match?(/^(false|f|no|n|0)$/i)
 
           value
         end

data/lib/lutaml/model/type/float.rb

@@ -4,7 +4,7 @@ module Lutaml
   module Model
     module Type
       class Float < Value
-        def self.cast(value, options = {})
+        def self.cast(value, options = EMPTY_OPTIONS)
           return nil if value.nil?
           return value if Utils.uninitialized?(value)
 

data/lib/lutaml/model/type/integer.rb

@@ -5,7 +5,7 @@ module Lutaml
     module Type
       class Integer < Value
         # Performance-optimized cast with short-circuit for already-correct types
-        def self.cast(value, options = {})
+        def self.cast(value, options = EMPTY_OPTIONS)
           return nil if value.nil?
           return value if Utils.uninitialized?(value)
           # Short-circuit: return immediately if already an Integer

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.121"
+    VERSION = "0.8.123"
   end
 end

data/lib/lutaml/xml/schema/xsd/complex_type.rb

@@ -30,6 +30,7 @@ module Lutaml
                                             initialize_empty: true
           attribute :attribute_group, :attribute_group, collection: true,
                                                         initialize_empty: true
+          attribute :any_attribute, :any_attribute
 
           xml do
             element "complexType"
@@ -50,6 +51,7 @@ module Lutaml
             map_element :attribute, to: :attribute
             map_element :annotation, to: :annotation
             map_element :attributeGroup, to: :attribute_group
+            map_element :anyAttribute, to: :any_attribute
             map_element :simpleContent, to: :simple_content
             map_element :complexContent, to: :complex_content
           end

data/lib/lutaml/xml/schema/xsd/extension_complex_content.rb

@@ -31,7 +31,7 @@ module Lutaml
             map_element :sequence, to: :sequence
             map_element :attribute, to: :attribute
             map_element :annotation, to: :annotation
-            map_element :any_attribute, to: :any_attribute
+            map_element :anyAttribute, to: :any_attribute
             map_element :attributeGroup, to: :attribute_group
           end
 

data/lib/lutaml/xml/schema/xsd/extension_simple_content.rb

@@ -23,7 +23,7 @@ module Lutaml
             map_attribute :base, to: :base
             map_element :attribute, to: :attribute
             map_element :annotation, to: :annotation
-            map_element :any_attribute, to: :any_attribute
+            map_element :anyAttribute, to: :any_attribute
             map_element :attributeGroup, to: :attribute_group
           end
 

data/spec/lutaml/model/map_unmapped_spec.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# #985: `map_unmapped to:` collects document keys no declared rule claims
+# into the given attribute, so vendor extensions and forward-compatible
+# keywords survive the round-trip. Opt-in: models without the directive
+# keep the drop behavior. Compiled fast paths are ineligible for such
+# models — the collect runs on the interpretive walk.
+RSpec.describe "key-value catch-all mapping (map_unmapped)" do
+  let(:schema_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :type, :string
+      attribute :description, :string
+      attribute :extensions, :hash, default: -> { {} }
+
+      key_value do
+        map "type", to: :type
+        map "description", to: :description
+        map_unmapped to: :extensions
+      end
+    end
+  end
+
+  let(:plain_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :type, :string
+
+      key_value do
+        map "type", to: :type
+      end
+    end
+  end
+
+  before do
+    stub_const("MapUnmappedSchema", schema_class)
+    stub_const("MapUnmappedPlain", plain_class)
+  end
+
+  it "collects unmapped keys on parse" do
+    model = MapUnmappedSchema.from_json(
+      '{"type":"object","x-enumDescriptions":{"a":"A"},"future":true}',
+    )
+
+    expect(model.type).to eq("object")
+    expect(model.extensions).to eq(
+      "x-enumDescriptions" => { "a" => "A" }, "future" => true,
+    )
+  end
+
+  it "never duplicates keys claimed by a rule" do
+    model = MapUnmappedSchema.from_json('{"type":"object"}')
+
+    expect(model.extensions).to eq({})
+  end
+
+  it "re-emits collected keys verbatim on serialization" do
+    model = MapUnmappedSchema.from_json(
+      '{"type":"object","x-enumDescriptions":{"a":"A"},"future":true}',
+    )
+    out = JSON.parse(model.to_json)
+
+    expect(out["x-enumDescriptions"]).to eq("a" => "A")
+    expect(out["future"]).to be(true)
+    expect(out["type"]).to eq("object")
+  end
+
+  it "lets mapped keys win on collision with collected keys" do
+    model = MapUnmappedSchema.new
+    model.type = "object"
+    model.extensions = { "type" => "extension-wins-only-if-unmapped" }
+
+    out = JSON.parse(model.to_json)
+
+    expect(out["type"]).to eq("object")
+  end
+
+  it "round-trips in yaml through the same contract" do
+    model = MapUnmappedSchema.from_yaml(
+      <<~YAML,
+        type: object
+        x-vendor: kept
+      YAML
+    )
+
+    expect(model.extensions).to eq("x-vendor" => "kept")
+    expect(YAML.safe_load(model.to_yaml)["x-vendor"]).to eq("kept")
+  end
+
+  it "fails fast when the target is not a declared attribute" do
+    typo_class = Class.new(Lutaml::Model::Serializable) do
+      attribute :type, :string
+
+      key_value do
+        map "type", to: :type
+        map_unmapped to: :extenshuns
+      end
+    end
+    stub_const("MapUnmappedTypo", typo_class)
+
+    # from_json wraps the raise in the format-error contract, message
+    # intact; to_json surfaces the bare ArgumentError at compile.
+    expect do
+      typo_class.from_json('{"type":"object","x-a":1}')
+    end.to raise_error(
+      Lutaml::Model::InvalidFormatError,
+      /map_unmapped target :extenshuns is not a declared attribute of/,
+    )
+    expect do
+      typo_class.new.to_json
+    end.to raise_error(
+      ArgumentError,
+      /map_unmapped target :extenshuns is not a declared attribute of/,
+    )
+  end
+
+  it "keeps the drop behavior when no catch-all is declared" do
+    model = MapUnmappedPlain.from_json('{"type":"object","x-lost":1}')
+
+    expect(model.to_json).not_to include("x-lost")
+  end
+
+  it "collects per instance in nested models" do
+    container = Class.new(Lutaml::Model::Serializable) do
+      attribute :child, "MapUnmappedSchema"
+
+      key_value do
+        map "child", to: :child
+      end
+    end
+    stub_const("MapUnmappedContainer", container)
+
+    model = MapUnmappedContainer.from_json(
+      '{"child":{"type":"object","x-inner":1}}',
+    )
+
+    expect(model.child.extensions).to eq("x-inner" => 1)
+  end
+end

data/spec/lutaml/xml/schema/xsd/any_attribute_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+
+RSpec.describe "xs:anyAttribute mappings" do
+  it "maps anyAttribute on a complexType from the parsed XSD" do
+    xsd = <<~XSD
+      <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+        <xs:complexType name="t">
+          <xs:attribute name="a"/>
+          <xs:anyAttribute namespace="##other" processContents="strict"/>
+        </xs:complexType>
+      </xs:schema>
+    XSD
+
+    schema = Lutaml::Xml::Schema::Xsd.parse(xsd)
+    wildcard = schema.complex_type.first.any_attribute
+
+    expect(wildcard).not_to be_nil
+    expect(wildcard.namespace).to eq("##other")
+    expect(wildcard.process_contents).to eq("strict")
+  end
+
+  it "maps anyAttribute inside a simpleContent extension" do
+    xsd = <<~XSD
+      <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+        <xs:complexType name="t">
+          <xs:simpleContent>
+            <xs:extension base="xs:string">
+              <xs:anyAttribute namespace="##local"/>
+            </xs:extension>
+          </xs:simpleContent>
+        </xs:complexType>
+      </xs:schema>
+    XSD
+
+    schema = Lutaml::Xml::Schema::Xsd.parse(xsd)
+    extension = schema.complex_type.first.simple_content.extension
+    wildcard = extension.any_attribute
+
+    expect(wildcard).not_to be_nil
+    expect(wildcard.namespace).to eq("##local")
+  end
+
+  it "maps anyAttribute inside a complexContent extension" do
+    xsd = <<~XSD
+      <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+        <xs:complexType name="t">
+          <xs:complexContent>
+            <xs:extension base="xs:anyType">
+              <xs:anyAttribute namespace="##targetNamespace"/>
+            </xs:extension>
+          </xs:complexContent>
+        </xs:complexType>
+      </xs:schema>
+    XSD
+
+    schema = Lutaml::Xml::Schema::Xsd.parse(xsd)
+    extension = schema.complex_type.first.complex_content.extension
+    wildcard = extension.any_attribute
+
+    expect(wildcard).not_to be_nil
+    expect(wildcard.namespace).to eq("##targetNamespace")
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.121
+  version: 0.8.123
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-21 00:00:00.000000000 Z
+date: 2026-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -1778,6 +1778,7 @@ files:
 - spec/lutaml/model/logger_spec.rb
 - spec/lutaml/model/map_all_spec.rb
 - spec/lutaml/model/map_content_spec.rb
+- spec/lutaml/model/map_unmapped_spec.rb
 - spec/lutaml/model/mapping_rule_perf_guard_spec.rb
 - spec/lutaml/model/mapping_type_validation_spec.rb
 - spec/lutaml/model/mixed_content_spec.rb
@@ -2018,6 +2019,7 @@ files:
 - spec/lutaml/xml/schema/facet_round_trip_spec.rb
 - spec/lutaml/xml/schema/rnc_compiler_spec.rb
 - spec/lutaml/xml/schema/rng_compiler_spec.rb
+- spec/lutaml/xml/schema/xsd/any_attribute_spec.rb
 - spec/lutaml/xml/schema/xsd/errors/error_context_spec.rb
 - spec/lutaml/xml/schema/xsd/errors/suggestion_spec.rb
 - spec/lutaml/xml/schema/xsd/file_validation_result_spec.rb