lutaml-model 0.8.19 → 0.9.1

data/lib/lutaml/xml/mapping_rule.rb

@@ -183,6 +183,34 @@ module Lutaml
         result
       end
 
+      # Match names an attribute rule consumes during parsing, mirroring how
+      # serialization qualifies the same attribute (resolve_namespace):
+      # a rule serialized with a prefix matches only attributes in its
+      # namespace; a rule serialized unprefixed matches only namespace-less
+      # attributes.
+      #
+      # Performance: memoized on the rule with zero-allocation cache hits.
+      # The inputs are constant for a given rule, register and parent model,
+      # so every element of a collection reuses the first resolution.
+      def attribute_match_names(attr, register, parent_ns_class, form_default,
+                                default_namespace)
+        if defined?(@_amn_names) && @_amn_register == register &&
+            @_amn_parent_ns == parent_ns_class &&
+            @_amn_form_default == form_default &&
+            @_amn_default_ns == default_namespace
+          return @_amn_names
+        end
+
+        result = compute_attribute_match_names(attr, register, parent_ns_class,
+                                               form_default, default_namespace)
+        @_amn_register = register
+        @_amn_parent_ns = parent_ns_class
+        @_amn_form_default = form_default
+        @_amn_default_ns = default_namespace
+        @_amn_names = result
+        result
+      end
+
       def namespaced_name(parent_namespace = nil, name = self.name)
         if name.to_s == "lang"
           ::Lutaml::Model::Utils.blank?(prefix) ? name.to_s : "#{prefix}:#{name}"
@@ -274,6 +302,30 @@ module Lutaml
 
       private
 
+      # Extracted body of attribute_match_names for caching
+      def compute_attribute_match_names(attr, register, parent_ns_class,
+                                        form_default, default_namespace)
+        ns_info = resolve_namespace(
+          attr: attr,
+          register: register,
+          parent_ns_class: parent_ns_class,
+          form_default: form_default,
+        )
+        uri = ns_info[:uri]
+        # Schema-level attribute_form_default keeps the historical plain-name
+        # parse: dependents (e.g. ogc-gml) declare :qualified but their
+        # documents and expectations rely on unprefixed attributes parsing.
+        # Explicit namespaces, type namespaces and explicit form: rules
+        # mirror serialization strictly.
+        strict_match = uri && ns_info[:prefix] &&
+          !ns_info[:unqualified_same_ns] && !ns_info[:via_schema_default]
+        if strict_match
+          ["#{uri}:#{name}"].freeze
+        else
+          namespaced_names(default_namespace)
+        end
+      end
+
       # Extracted body of namespaced_names for caching
       def compute_namespaced_names(parent_namespace)
         if multiple_mappings?
@@ -427,7 +479,9 @@ form_default = :unqualified)
         # When schema specifies attributeFormDefault="qualified", attributes
         # must be qualified (prefixed) with the parent element's namespace
         if form_default == :qualified && parent_ns_class
-          return build_namespace_result_from_class(parent_ns_class)
+          result = build_namespace_result_from_class(parent_ns_class)
+          result[:via_schema_default] = true
+          return result
         end
 
         # 4. No namespace (W3C default for unprefixed attributes)

data/lib/lutaml/xml/model_transform.rb

@@ -509,8 +509,13 @@ _effective_register)
           local_name = rn[(last_colon_index + 1)..]
 
           matched_attr = doc.root.attributes.values.find do |attr|
-            # Match by the attribute's namespaced_name, unprefixed_name, or by extracting
-            # local name from the attribute's key (handles unresolved prefixes).
+            # A namespace-less, prefix-less attribute cannot belong to the
+            # rule's namespace, so it must not satisfy the fallback
+            # (lutaml-model#744). Attributes with undeclared prefixes keep
+            # their prefix in the raw name and stay eligible below.
+            next false if attr.namespace.nil? &&
+              attr.namespace_prefix.nil? && !attr.name.include?(":")
+
             attr.namespaced_name == local_name ||
               attr.unprefixed_name == local_name ||
               (attr.namespace.nil? && ((colon = attr.name.rindex(":")) ? attr.name[(colon + 1)..] : attr.name) == local_name)
@@ -544,9 +549,14 @@ _effective_register)
         rule_namespace = rule_namespace_set ? rule.namespace : nil
         options[:default_namespace]
 
-        # Enhanced namespace resolution with type support
-        rule_names = resolve_rule_names_with_type(rule, attr, options,
-                                                  effective_register, attr_type)
+        rule_names = if rule.attribute?
+                       resolve_attribute_rule_names(rule, attr, options,
+                                                    effective_register,
+                                                    instance, instance_is_serialize)
+                     else
+                       resolve_rule_names_with_type(rule, attr, options,
+                                                    effective_register, attr_type)
+                     end
 
         return value_for_xml_attribute(doc, rule, rule_names) if rule.attribute?
 
@@ -879,6 +889,44 @@ effective_register = lutaml_register)
         end
       end
 
+      # Match names for an attribute rule, mirroring how serialization
+      # qualifies the same attribute (MappingRule#attribute_match_names):
+      # a rule serialized with a prefix matches only attributes in its
+      # namespace; a rule serialized unprefixed matches only namespace-less
+      # attributes.
+      def resolve_attribute_rule_names(rule, attr, options, effective_register,
+                                       instance, instance_is_serialize)
+        return rule.namespaced_names(options[:default_namespace]) if attr.nil? ||
+          rule.multiple_mappings?
+
+        if instance_is_serialize
+          parent_ns_class, form_default = parent_attribute_context(instance)
+        else
+          parent_ns_class = nil
+          form_default = :unqualified
+        end
+        rule.attribute_match_names(attr, effective_register, parent_ns_class,
+                                   form_default,
+                                   options[:default_namespace])
+      end
+
+      # [namespace_class, attribute_form_default] for the instance's model,
+      # keyed on the model class. Attribute rules of one element share the
+      # model, so a 1-entry cache avoids a mappings_for lookup per rule.
+      def parent_attribute_context(instance)
+        klass = instance.class
+        if @parent_ns_klass == klass && @parent_ns_value
+          return @parent_ns_value
+        end
+
+        ns_class = klass.mappings_for(:xml)&.namespace_class
+        value = [ns_class,
+                 ns_class&.attribute_form_default || :unqualified]
+        @parent_ns_klass = klass
+        @parent_ns_value = value
+        value
+      end
+
       # Resolve rule names with type namespace support
       #
       # @param rule [MappingRule] the mapping rule

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

@@ -141,9 +141,7 @@ module Lutaml
           # Trigger autoloads for all XSD model classes to ensure they are
           # registered before parsing begins. This is necessary because
           # type resolution during parsing looks up classes in the register.
-          # rubocop:disable Style/RedundantFetchOverride
           XSD_AUTOLOAD_CLASSES.each { |c| const_get(c) unless c == :VERSION }
-          # rubocop:enable Style/RedundantFetchOverride
 
           # Validate XSD schema structure before parsing (unless disabled)
           if validate_schema && !nested_schema

data/lib/lutaml/xml/schema/xsd_schema.rb

@@ -410,7 +410,8 @@ attr_name)
         def self.get_attribute_xsd_type(attr, attr_type, register,
 _mapping_rule = nil)
           if attr.union?
-            raise Lutaml::Model::UnionSchemaUnsupportedError.new(attr.name, "XSD")
+            raise Lutaml::Model::UnionSchemaUnsupportedError.new(attr.name,
+                                                                 "XSD")
           end
 
           # 1. Check for deprecated attribute-level xsd_type override

data/lib/lutaml/xml/transformation/element_builder.rb

@@ -143,7 +143,8 @@ parent_element_form_default)
           # Get transformation for the actual class. Unions resolve the member
           # from the value's own class, like polymorphism.
           child_transformation = if union
-                                   value.class.transformation_for(:xml, register)
+                                   value.class.transformation_for(:xml,
+                                                                  register)
                                  elsif is_polymorphic || is_polymorphic_subtype
                                    actual_class.transformation_for(:xml,
                                                                    register)

data/lib/lutaml/xml/transformation/ordered_applier.rb

@@ -326,7 +326,8 @@ compiled_rules, mapping, processed_text_nodes)
                              compiled_rules
                            end
 
-          emitted_counts = element_order_coverage(model_instance, compiled_rules)
+          emitted_counts = element_order_coverage(model_instance,
+                                                  compiled_rules)
 
           rules_to_apply.each do |rule|
             mapping_type = rule.option(:mapping_type)

data/lutaml-model.gemspec

@@ -18,7 +18,10 @@ Gem::Specification.new do |spec|
 
   spec.bindir = "exe"
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
+  # lib/ uses anonymous argument forwarding in call position, which parses
+  # only on Ruby 3.2+ (verified: 6 files fail to parse on 3.1). Without this
+  # floor, bundler resolves 0.8.x on 3.1 and it dies at require time.
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.2.0")
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the

data/spec/lutaml/model/attribute_apply_value_map_spec.rb

@@ -18,7 +18,8 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
 
     it "maps nil through value_map[:nil] => :empty to [] (collection)" do
       expect(
-        attribute(:string, collection: true).apply_value_map(nil, { nil: :empty }),
+        attribute(:string, collection: true).apply_value_map(nil,
+                                                             { nil: :empty }),
       ).to eq([])
     end
 
@@ -34,13 +35,15 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
       custom_collection_class = Class.new(Lutaml::Model::Collection) do
         instances :items, member_class
       end
-      attr = described_class.new("items", member_class, collection: custom_collection_class)
+      attr = described_class.new("items", member_class,
+                                 collection: custom_collection_class)
       result = attr.apply_value_map(nil, { nil: :empty })
       expect(result).to be_a(custom_collection_class)
     end
 
     it "maps nil through value_map[:nil] => :omitted to UninitializedClass" do
-      expect(attribute(:string).apply_value_map(nil, { nil: :omitted })).to eq(uninit)
+      expect(attribute(:string).apply_value_map(nil,
+                                                { nil: :omitted })).to eq(uninit)
     end
   end
 
@@ -50,12 +53,14 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
     end
 
     it "maps '' through value_map[:empty] => :empty preserving '' for scalar" do
-      expect(attribute(:string).apply_value_map("", { empty: :empty })).to eq("")
+      expect(attribute(:string).apply_value_map("",
+                                                { empty: :empty })).to eq("")
     end
 
     it "maps [] through value_map[:empty] => :empty preserving [] for collection" do
       expect(
-        attribute(:string, collection: true).apply_value_map([], { empty: :empty }),
+        attribute(:string, collection: true).apply_value_map([],
+                                                             { empty: :empty }),
       ).to eq([])
     end
 
@@ -69,11 +74,13 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
 
   describe "omitted handling" do
     it "maps UninitializedClass through value_map[:omitted] => :nil" do
-      expect(attribute(:string).apply_value_map(uninit, { omitted: :nil })).to be_nil
+      expect(attribute(:string).apply_value_map(uninit,
+                                                { omitted: :nil })).to be_nil
     end
 
     it "maps UninitializedClass through value_map[:omitted] => :empty" do
-      expect(attribute(:string).apply_value_map(uninit, { omitted: :empty })).to eq("")
+      expect(attribute(:string).apply_value_map(uninit,
+                                                { omitted: :empty })).to eq("")
     end
 
     it "does NOT route UninitializedClass through the :empty branch" do
@@ -81,18 +88,21 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
       # utils.rb:132-137. Ensure dispatch order matches the originals: uninit
       # values go to :omitted, not :empty.
       expect(
-        attribute(:string).apply_value_map(uninit, { empty: :nil, omitted: :empty }),
+        attribute(:string).apply_value_map(uninit,
+                                           { empty: :nil, omitted: :empty }),
       ).to eq("")
     end
   end
 
   describe "Boolean bare-form (Boolean attribute type required)" do
     it "returns false directly for Boolean attribute, value_map[:empty] = false" do
-      expect(attribute(:boolean).apply_value_map("", { empty: false })).to be(false)
+      expect(attribute(:boolean).apply_value_map("",
+                                                 { empty: false })).to be(false)
     end
 
     it "returns true directly for Boolean attribute, value_map[:omitted] = true" do
-      expect(attribute(:boolean).apply_value_map(uninit, { omitted: true })).to be(true)
+      expect(attribute(:boolean).apply_value_map(uninit,
+                                                 { omitted: true })).to be(true)
     end
 
     it "does NOT apply bare-boolean form to a non-Boolean attribute (documented tightening)" do
@@ -106,15 +116,18 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
 
   describe "Boolean nested-form (value_map[:from][:empty] / [:omitted])" do
     it "returns false from value_map[:from][:empty] unconditionally for Boolean attribute" do
-      expect(attribute(:boolean).apply_value_map("", { from: { empty: false } })).to be(false)
+      expect(attribute(:boolean).apply_value_map("",
+                                                 { from: { empty: false } })).to be(false)
     end
 
     it "returns true from value_map[:from][:omitted] unconditionally for Boolean attribute" do
-      expect(attribute(:boolean).apply_value_map(uninit, { from: { omitted: true } })).to be(true)
+      expect(attribute(:boolean).apply_value_map(uninit,
+                                                 { from: { omitted: true } })).to be(true)
     end
 
     it "returns false from nested form even for non-Boolean attribute (no type gate)" do
-      expect(attribute(:string).apply_value_map("", { from: { empty: false } })).to be(false)
+      expect(attribute(:string).apply_value_map("",
+                                                { from: { empty: false } })).to be(false)
     end
   end
 

data/spec/lutaml/model/attribute_spec.rb

@@ -358,7 +358,8 @@ RSpec.describe Lutaml::Model::Attribute do
       it "executes the proc in the instance context (reads instance attribute)" do
         instance = model_class.new(name: "Alice")
         attribute = model_class.attributes[:greeting]
-        expect(attribute.default_value(register, instance)).to eq("Hello, Alice")
+        expect(attribute.default_value(register,
+                                       instance)).to eq("Hello, Alice")
       end
     end
   end
@@ -413,7 +414,9 @@ RSpec.describe Lutaml::Model::Attribute do
         end
         instance = model_class.new(prefix: "Dr")
         attr = model_class.attributes[:name]
-        expect { attr.validate_value!(nil, register, instance_object: instance) }
+        expect do
+          attr.validate_value!(nil, register, instance_object: instance)
+        end
           .to raise_error(Lutaml::Model::InvalidValueError) do |error|
             # The error carries the value that was used for validation.
             # If instance_exec ran, value is "Dr_default"; if not, error
@@ -427,7 +430,9 @@ RSpec.describe Lutaml::Model::Attribute do
       it "short-circuits without raising" do
         uninit = Lutaml::Model::UninitializedClass.instance
         attr = described_class.new("name", :string)
-        expect { attr.validate_value!(uninit, register, instance_object: model) }
+        expect do
+          attr.validate_value!(uninit, register, instance_object: model)
+        end
           .not_to raise_error
       end
     end

data/spec/lutaml/model/custom_from_empty_values_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string: true
+
+require "spec_helper"
+
+# lutaml-model#746: an empty value ("", [], {}) is a PRESENT value per
+# docs/_guides/missing-values-handling.adoc and must reach custom `from`
+# methods. Only nil (non-existent) and an omitted key (undefined) skip them.
+module CustomFromEmptyValuesSpec
+  class Tagged < Lutaml::Model::Serializable
+    attribute :received, :string
+
+    key_value do
+      map "tags", to: :received, with: { to: :tags_to, from: :tags_from }
+    end
+
+    def tags_to(model, doc)
+      doc["tags"] = model.received
+    end
+
+    def tags_from(model, value)
+      model.received = value.inspect
+    end
+  end
+
+  class Mapped < Lutaml::Model::Serializable
+    attribute :received, :string
+
+    key_value do
+      map "fields", to: :received, with: { to: :fields_to, from: :fields_from }
+    end
+
+    def fields_to(model, doc)
+      doc["fields"] = model.received
+    end
+
+    def fields_from(model, value)
+      model.received = value.inspect
+    end
+  end
+end
+
+RSpec.describe "custom from methods and empty values" do
+  it "receives an empty collection" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_yaml("tags: []").received)
+      .to eq("[]")
+  end
+
+  it "receives an empty string" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_yaml('tags: ""').received)
+      .to eq("\"\"")
+  end
+
+  it "receives an empty mapping" do
+    expect(CustomFromEmptyValuesSpec::Mapped.from_yaml("fields: {}").received)
+      .to eq("{}")
+  end
+
+  it "receives empty values from JSON too" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_json(%({"tags": []})).received)
+      .to eq("[]")
+    expect(CustomFromEmptyValuesSpec::Tagged.from_json(%({"tags": ""})).received)
+      .to eq("\"\"")
+  end
+
+  it "still skips the method for a nil value" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_yaml("tags:").received)
+      .to be_nil
+  end
+
+  it "still skips the method for an omitted key" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_yaml("{}").received)
+      .to be_nil
+  end
+end

data/spec/lutaml/model/defaults_spec.rb

@@ -146,6 +146,33 @@ module DefaultsSpec
 
   class InstanceAwareGrandChild < InstanceAwareChild
   end
+
+  # Class-method defaults must keep resolving as they did before 0.8.0
+  # (lutaml-model#745): default lambdas are evaluated against the instance,
+  # with the model class as fallback for methods the instance does not have.
+  class ClassMethodDefault < Lutaml::Model::Serializable
+    attribute :os, :string, default: -> { detect_os }
+
+    def self.detect_os
+      "from-class-method"
+    end
+  end
+
+  class ClassMethodDefaultWithArgs < Lutaml::Model::Serializable
+    attribute :label, :string, default: -> { build_label("x") }
+
+    def self.build_label(prefix)
+      "#{prefix}-label"
+    end
+  end
+
+  class InstanceMethodDefault < Lutaml::Model::Serializable
+    attribute :value, :string, default: -> { instance_helper }
+
+    def instance_helper
+      "from-instance-method"
+    end
+  end
 end
 
 RSpec.describe DefaultsSpec::Glaze do
@@ -346,3 +373,21 @@ RSpec.describe DefaultsSpec::Glaze do
     end
   end
 end
+
+RSpec.describe DefaultsSpec::ClassMethodDefault do
+  it "resolves class methods from default lambdas" do
+    expect(described_class.new.os).to eq("from-class-method")
+  end
+end
+
+RSpec.describe DefaultsSpec::ClassMethodDefaultWithArgs do
+  it "passes arguments through to class methods" do
+    expect(described_class.new.label).to eq("x-label")
+  end
+end
+
+RSpec.describe DefaultsSpec::InstanceMethodDefault do
+  it "still resolves instance methods in default lambdas" do
+    expect(described_class.new.value).to eq("from-instance-method")
+  end
+end

data/spec/lutaml/model/json_spec.rb

@@ -8,9 +8,8 @@ RSpec.describe Lutaml::Model::Json do
     let(:lib_path) { File.expand_path("../../../lib", __dir__) }
 
     it "loads require 'lutaml/json' without preloading lutaml/model" do
-      # rubocop:disable Style/CommandLiteral
+      # rubocop:disable-next Style/CommandLiteral
       result = `#{RbConfig.ruby} -I#{lib_path} -e 'require "lutaml/json"; puts :ok' 2>&1`
-      # rubocop:enable Style/CommandLiteral
 
       expect($?.success?).to be(true), result
       expect(result).to include("ok")

data/spec/lutaml/model/serialize/builder_spec.rb

@@ -112,7 +112,8 @@ RSpec.describe "Lutaml::Model::Serialize::Builder" do
           <items>c</items>
         </container>
       XML
-      expect(obj.element_order.map(&:name)).to eq(%w[singular items items items])
+      expect(obj.element_order.map(&:name)).to eq(%w[singular items items
+                                                     items])
     end
 
     it "all direct setters: emits in call order" do
@@ -298,7 +299,8 @@ RSpec.describe "Lutaml::Model::Serialize::Builder" do
       # so both assignments are recorded. The serializer emits the current
       # value of the attribute via element_order in recorded order; the
       # safety net guarantees no data loss.
-      expect(obj.element_order.map(&:name)).to eq(%w[items items items items items])
+      expect(obj.element_order.map(&:name)).to eq(%w[items items items items
+                                                     items])
       xml = obj.to_xml
       # The serialized output must contain all current items
       expect(xml).to include("<items>c</items>")
@@ -317,7 +319,8 @@ RSpec.describe "Lutaml::Model::Serialize::Builder" do
         xml = obj.to_xml
 
         if !obj.singular.nil? && !obj.singular.to_s.empty?
-          expect(xml).to include("<singular>"), "singular was dropped from output"
+          expect(xml).to include("<singular>"),
+                         "singular was dropped from output"
         end
         return if obj.items.nil? || obj.items.empty?
 

data/spec/lutaml/model/transform_apply_value_map_spec.rb

@@ -33,7 +33,8 @@ RSpec.describe Lutaml::Model::Transform, "#apply_value_map (nil attr)" do
     end
 
     it "passes initialized values through unchanged" do
-      expect(transform.apply_value_map("hello", default_vmap, nil)).to eq("hello")
+      expect(transform.apply_value_map("hello", default_vmap,
+                                       nil)).to eq("hello")
     end
   end
 
@@ -50,11 +51,13 @@ RSpec.describe Lutaml::Model::Transform, "#apply_value_map (nil attr)" do
   # custom method runs), and resolved :nil/:empty consistently for empty inputs.
   describe "non-:nil options with nil attr" do
     it "maps a nil value to uninitialized via nil: :omitted" do
-      expect(transform.apply_value_map(nil, { nil: :omitted }, nil)).to eq(uninit)
+      expect(transform.apply_value_map(nil, { nil: :omitted },
+                                       nil)).to eq(uninit)
     end
 
     it "maps an empty value to uninitialized via empty: :omitted" do
-      expect(transform.apply_value_map("", { empty: :omitted }, nil)).to eq(uninit)
+      expect(transform.apply_value_map("", { empty: :omitted },
+                                       nil)).to eq(uninit)
     end
 
     it "maps an empty value to nil via empty: :nil" do

data/spec/lutaml/model/union_attribute_spec.rb

@@ -311,7 +311,8 @@ RSpec.describe "Union-typed attributes (issue #190)" do
     it "serializes a model member built in plain Ruby identically to a deserialized one" do
       built = UnionAttributeSpec::Ceramic.new(
         firing_temperature:
-          UnionAttributeSpec::TemperatureWithUnit.new(number: 1300.0, unit: "C"),
+          UnionAttributeSpec::TemperatureWithUnit.new(number: 1300.0,
+                                                      unit: "C"),
       )
       round = UnionAttributeSpec::Ceramic.from_yaml(built.to_yaml)
       expect(round.firing_temperature)
@@ -424,7 +425,8 @@ RSpec.describe "Union-typed attributes (issue #190)" do
     end
 
     it "rejects unsupported scalar member types at definition time" do
-      %i[hash symbol time time_without_date date date_time].each do |unsupported|
+      %i[hash symbol time time_without_date date
+         date_time].each do |unsupported|
         expect do
           Class.new(Lutaml::Model::Serializable) do
             attribute :bad, [unsupported, :string]