lutaml-model 0.7.7 → 0.8.0

data/spec/lutaml/model/{register/key_value_spec.rb → register_key_value_spec.rb}

@@ -64,7 +64,9 @@ end
 
 RSpec.describe "RegisterKeyValueSpec" do
   let(:register) { Lutaml::Model::Register.new(:json_test_register) }
-  let(:person) { RegisterKeyValueSpec::Person.from_json(json, register: register) }
+  let(:person) do
+    RegisterKeyValueSpec::Person.from_json(json, register: register)
+  end
 
   before do
     # Register the registers in the global registry
@@ -75,6 +77,52 @@ RSpec.describe "RegisterKeyValueSpec" do
     register.register_model(RegisterKeyValueSpec::Address)
     register.register_model(RegisterKeyValueSpec::GeoCoordinate)
     register.register_model(RegisterKeyValueSpec::ContactInfo)
+
+    # Clear attribute type caches on all model classes BEFORE each test
+    [RegisterKeyValueSpec::Person, RegisterKeyValueSpec::Address,
+     RegisterKeyValueSpec::GeoCoordinate, RegisterKeyValueSpec::ContactInfo].each do |klass|
+      next unless klass.respond_to?(:attributes)
+
+      klass.attributes.each_value do |attr|
+        if attr.instance_variable_defined?(:@cached_type_default)
+          attr.instance_variable_set(:@cached_type_default,
+                                     nil)
+        end
+        if attr.instance_variable_defined?(:@default_type_context)
+          attr.instance_variable_set(:@default_type_context,
+                                     nil)
+        end
+        if attr.instance_variable_defined?(:@unresolved_type)
+          attr.instance_variable_set(:@unresolved_type,
+                                     nil)
+        end
+      end
+    end
+  end
+
+  after do
+    # Clear type class cache and global substitutions to prevent test pollution
+    register.clear_type_class_cache if register.respond_to?(:clear_type_class_cache)
+    register.clear_global_substitutions if register.respond_to?(:clear_global_substitutions)
+
+    # Clear transformation cache on all model classes to prevent test pollution
+    [RegisterKeyValueSpec::Person, RegisterKeyValueSpec::Address,
+     RegisterKeyValueSpec::GeoCoordinate, RegisterKeyValueSpec::ContactInfo,
+     RegisterKeyValueSpec::EnhancedContactInfo].each do |klass|
+      next unless klass.respond_to?(:instance_variable_defined?)
+
+      if klass.instance_variable_defined?(:@transformations)
+        klass.remove_instance_variable(:@transformations)
+      end
+      cache_key = :@resolved_mapping_json
+      if klass.instance_variable_defined?(cache_key)
+        klass.remove_instance_variable(cache_key)
+      end
+    end
+
+    # Clean up the register to prevent test pollution
+    Lutaml::Model::GlobalRegister.unregister(:json_test_register)
+    Lutaml::Model::Config.default_register = :default
   end
 
   describe "parsing JSON" do
@@ -177,7 +225,8 @@ RSpec.describe "RegisterKeyValueSpec" do
         register.register_model(RegisterKeyValueSpec::EnhancedContactInfo)
         register_substitution
 
-        enhanced_person = RegisterKeyValueSpec::Person.from_json(json, register: register.id)
+        enhanced_person = RegisterKeyValueSpec::Person.from_json(json,
+                                                                 register: register.id)
 
         expect(enhanced_person.contact).to be_a(RegisterKeyValueSpec::EnhancedContactInfo)
         expect(enhanced_person.contact).to respond_to(:preferred)
@@ -235,7 +284,8 @@ RSpec.describe "RegisterKeyValueSpec" do
     end
 
     it "correctly handles arrays of complex objects" do
-      team = RegisterKeyValueSpec::Team.from_json(complex_json, register: register)
+      team = RegisterKeyValueSpec::Team.from_json(complex_json,
+                                                  register: register)
 
       expect(team.name).to eq("Team Alpha")
       expect(team.members.size).to eq(2)
@@ -248,7 +298,8 @@ RSpec.describe "RegisterKeyValueSpec" do
 
       # Test round-trip serialization
       toml_output = team.to_toml
-      team2 = RegisterKeyValueSpec::Team.from_toml(toml_output, register: register)
+      team2 = RegisterKeyValueSpec::Team.from_toml(toml_output,
+                                                   register: register)
 
       expect(team2).to eq(team)
       expect(team2.members[0].name).to eq("Alice")
@@ -258,7 +309,8 @@ RSpec.describe "RegisterKeyValueSpec" do
 
   describe "#resolve" do
     before do
-      stub_const("RegisterKeyValueSpec::Team", Class.new(Lutaml::Model::Serializable))
+      stub_const("RegisterKeyValueSpec::Team",
+                 Class.new(Lutaml::Model::Serializable))
       register.register_model(RegisterKeyValueSpec::Team)
     end
 

data/spec/lutaml/model/register_spec.rb

@@ -7,9 +7,52 @@ module RegisterSpec
 
   Lutaml::Model::Type.register(:custom_string, CustomString)
 
-  class Address < Lutaml::Model::Serializable
+  class AddressFields < Lutaml::Model::Serializable
     attribute :location, :string
     attribute :postal_code, :custom_string
+    attribute :active, :custom_string
+
+    xml do
+      # Type-only model - no element declaration needed
+      sequence do
+        map_element :location, to: :location
+        map_element :postalCode, to: :postal_code
+      end
+      map_element :active, to: :active
+    end
+  end
+
+  class Address < Lutaml::Model::Serializable
+    import_model_attributes AddressFields
+  end
+
+  class Names < Lutaml::Model::Serializable
+    attribute :first_name, :custom_string
+    choice(min: 1, max: 1) do
+      attribute :middle_name, :custom_string
+      attribute :last_name, :custom_string
+    end
+
+    xml do
+      # Type-only model - no element declaration needed
+      map_element :firstName, to: :first_name
+      map_element :middleName, to: :middle_name
+      map_element :lastName, to: :last_name
+    end
+  end
+
+  class User < Lutaml::Model::Serializable
+    choice(min: 1, max: 1) do
+      import_model_attributes :address_fields
+    end
+    import_model :names
+    restrict :active, values: ["yes", "no"]
+
+    xml do
+      element "user"
+
+      import_model_mappings :address_fields
+    end
   end
 end
 
@@ -27,7 +70,8 @@ RSpec.describe Lutaml::Model::Register do
 
     before do
       v1_register.register_model(RegisterSpec::CustomString, id: :custom_string)
-      v1_register.register_model(RegisterSpec::CustomInteger, id: :custom_integer)
+      v1_register.register_model(RegisterSpec::CustomInteger,
+                                 id: :custom_integer)
     end
 
     it "registers model with explicit id" do
@@ -35,7 +79,8 @@ RSpec.describe Lutaml::Model::Register do
     end
 
     it "allows overriding an existing type" do
-      v1_register.register_model(Lutaml::Model::Type::String, id: :custom_string)
+      v1_register.register_model(Lutaml::Model::Type::String,
+                                 id: :custom_string)
       expect(v1_register.models[:custom_string]).to be_nil
     end
 
@@ -92,7 +137,9 @@ RSpec.describe Lutaml::Model::Register do
     end
 
     it "raises error for unsupported type" do
-      expect { v1_register.get_class(123) }.to raise_error(Lutaml::Model::UnknownTypeError)
+      expect do
+        v1_register.get_class(123)
+      end.to raise_error(Lutaml::Model::UnknownTypeError)
     end
   end
 
@@ -118,7 +165,8 @@ RSpec.describe Lutaml::Model::Register do
     let(:v1_register) { described_class.new(:v1) }
 
     it "registers a global type substitution" do
-      v1_register.register_global_type_substitution(from_type: :string, to_type: :text)
+      v1_register.register_global_type_substitution(from_type: :string,
+                                                    to_type: :text)
       expect(v1_register.instance_variable_get(:@global_substitutions)).to include(string: :text)
     end
   end
@@ -144,4 +192,186 @@ RSpec.describe Lutaml::Model::Register do
       expect(v1_register.models.keys).not_to include(:string)
     end
   end
+
+  describe "#import_model" do
+    let(:register) { described_class.new(:import_model_test) }
+
+    before do
+      Lutaml::Model::GlobalRegister.register(register)
+      register.register_model(RegisterSpec::AddressFields, id: :address_fields)
+      register.register_model(RegisterSpec::Names, id: :names)
+
+      # Also register in default register for tests that use attributes() without register arg
+      default_register = Lutaml::Model::GlobalRegister.lookup(:default)
+      default_register.register_model(RegisterSpec::AddressFields,
+                                      id: :address_fields)
+      default_register.register_model(RegisterSpec::Names, id: :names)
+    end
+
+    after do
+      Lutaml::Model::GlobalRegister.unregister(register.id)
+      # Clean up default register
+      default_register = Lutaml::Model::GlobalRegister.lookup(:default)
+      default_register.models.delete(:address_fields)
+      default_register.models.delete(:names)
+      default_register.models.delete("RegisterSpec::AddressFields")
+      default_register.models.delete("RegisterSpec::Names")
+    end
+
+    it "tracks imported model attributes by symbolic id in importable_choices" do
+      expect(RegisterSpec::User.importable_choices.count).to eq(1)
+    end
+
+    it "tracks imported models attributes for 'restrict' functionality" do
+      # Restore the restrict_attributes that were set by 'restrict' directive at class definition
+      # These get cleared after ensure_restrict_attributes! runs
+      RegisterSpec::User.instance_variable_set(:@restrict_attributes,
+                                               { active: { values: ["yes",
+                                                                    "no"] } })
+
+      expect(RegisterSpec::User.restrict_attributes).to eq({ active: { values: [
+                                                             "yes", "no"
+                                                           ] } })
+    end
+
+    it "preserves and accumulates attributes in main model when importing additional ones" do
+      # Reset state to ensure test isolation
+      # We need to restore importable_models and importable_choices because they get cleared after import
+      RegisterSpec::User.instance_variable_set(:@attributes, {})
+      RegisterSpec::User.instance_variable_set(:@register_records,
+                                               Hash.new do |h, k|
+                                                 h[k] =
+                                                   { attributes: {},
+                                                     choice_attributes: [] }
+                                               end)
+      RegisterSpec::User.instance_variable_set(:@models_imported, false)
+      RegisterSpec::User.instance_variable_set(:@choices_imported, false)
+      # Restore importable_models that were set by import_model_attributes and import_model at class def
+      importable_models = Lutaml::Model::MappingHash.new { |h, k| h[k] = [] }
+      importable_models[:import_model_attributes] = [:address_fields]
+      importable_models[:import_model] = [:names]
+      RegisterSpec::User.instance_variable_set(:@importable_models,
+                                               importable_models)
+
+      # Check raw storage before import resolution (avoid triggering ensure_imports!)
+      reg_record = RegisterSpec::User.instance_variable_get(:@register_records)
+      initial_count = reg_record[register.id][:attributes].count
+      RegisterSpec::User.ensure_imports!(register.id)
+      final_count = RegisterSpec::User.attributes(register.id).count
+
+      expect(initial_count).to eq(0)
+      expect(final_count).to eq(6)
+    end
+
+    it "tracks changes made to attribute updated using 'restrict'" do
+      # Ensure imports are resolved for the register
+      RegisterSpec::User.ensure_imports!(register.id)
+
+      # Ensure restrict_attributes is set for this test
+      # (it gets cleared after ensure_restrict_attributes! runs in other tests)
+      RegisterSpec::User.instance_variable_set(:@restrict_attributes,
+                                               { active: { values: ["yes",
+                                                                    "no"] } })
+      RegisterSpec::User.ensure_restrict_attributes!(register.id)
+
+      # AddressFields does not have :choice option on :active
+      expect(RegisterSpec::AddressFields.attributes[:active].options.keys).to be_empty
+      # User has :active via choice import which adds :choice option
+      # Attributes are stored in register-specific storage, so access via register
+      expect(RegisterSpec::User.attributes(register.id)[:active].options.keys).to eq(%i[
+                                                                                       choice values
+                                                                                     ])
+    end
+  end
+
+  describe "fallback behavior" do
+    let(:default_register) { Lutaml::Model::GlobalRegister.lookup(:default) }
+
+    context "when register is :default" do
+      it "has no fallback" do
+        expect(default_register.fallback).to eq([])
+      end
+    end
+
+    context "when register is custom without explicit fallback" do
+      let(:custom_register) { described_class.new(:custom) }
+
+      before do
+        Lutaml::Model::GlobalRegister.register(custom_register)
+      end
+
+      after do
+        Lutaml::Model::GlobalRegister.unregister(custom_register.id)
+      end
+
+      it "defaults to fallback: [:default]" do
+        expect(custom_register.fallback).to eq([:default])
+      end
+
+      it "can resolve types from default register" do
+        # Register a model only in default
+        default_register.register_model(RegisterSpec::Address,
+                                        id: :fallback_address)
+
+        # Custom register should find it via fallback (returns class, not raises)
+        result = custom_register.get_class_without_register(:fallback_address)
+        expect(result).to eq(RegisterSpec::Address)
+      end
+    end
+
+    context "when register has explicit fallback: []" do
+      let(:isolated_register) { described_class.new(:isolated, fallback: []) }
+
+      before do
+        Lutaml::Model::GlobalRegister.register(isolated_register)
+      end
+
+      after do
+        Lutaml::Model::GlobalRegister.unregister(isolated_register.id)
+      end
+
+      it "has empty fallback (isolated)" do
+        expect(isolated_register.fallback).to eq([])
+      end
+
+      it "cannot resolve types from default register" do
+        # Register a model only in default (not a Type::Value)
+        default_register.register_model(RegisterSpec::Address,
+                                        id: :isolated_type)
+
+        # Isolated register should NOT find it
+        expect { isolated_register.get_class(:isolated_type) }
+          .to raise_error(Lutaml::Model::UnknownTypeError)
+      end
+    end
+
+    context "when register has custom fallback chain" do
+      let(:core_register) { described_class.new(:core) }
+      let(:profile_register) do
+        described_class.new(:profile, fallback: %i[core default])
+      end
+
+      before do
+        Lutaml::Model::GlobalRegister.register(core_register)
+        Lutaml::Model::GlobalRegister.register(profile_register)
+      end
+
+      after do
+        Lutaml::Model::GlobalRegister.unregister(core_register.id)
+        Lutaml::Model::GlobalRegister.unregister(profile_register.id)
+      end
+
+      it "uses specified fallback chain" do
+        expect(profile_register.fallback).to eq(%i[core default])
+      end
+
+      it "tries fallback registers in order" do
+        # Register type only in core
+        core_register.register_model(RegisterSpec::CustomString, id: :core_type)
+
+        # Profile should find it via :core fallback
+        expect(profile_register.get_class(:core_type)).to eq(RegisterSpec::CustomString)
+      end
+    end
+  end
 end

data/spec/lutaml/model/render_empty_spec.rb

@@ -3,7 +3,7 @@ module RenderEmptySpec
     attribute :items, :string, collection: true
 
     xml do
-      root "default-model"
+      element "default-model"
       map_element "items", to: :items
     end
   end
@@ -12,7 +12,7 @@ module RenderEmptySpec
     attribute :items, :string, collection: true, initialize_empty: true
 
     xml do
-      root "empty-init-model"
+      element "empty-init-model"
       map_element "items", to: :items
     end
   end
@@ -21,7 +21,7 @@ module RenderEmptySpec
     attribute :items, :string, collection: true
 
     xml do
-      root "omit-empty-model"
+      element "omit-empty-model"
       map_element "items", to: :items, render_empty: :omit
     end
 
@@ -42,6 +42,7 @@ module RenderEmptySpec
     attribute :items, :string, collection: true
 
     xml do
+      element "explicit-blank-model"
       map_element "items", to: :items, render_empty: :as_blank
     end
   end
@@ -50,7 +51,7 @@ module RenderEmptySpec
     attribute :items, :string, collection: true
 
     xml do
-      root "explicit-nil-model"
+      element "explicit-nil-model"
       map_element "items", to: :items, render_empty: :as_nil
     end
 
@@ -58,6 +59,59 @@ module RenderEmptySpec
       map "items", to: :items, render_empty: :as_nil
     end
   end
+
+  # Model with ordered mapping to test element_order serialization path
+  class ExplicitBlankOrderedModel < Lutaml::Model::Serializable
+    attribute :authority, :string
+    attribute :topic, :string, collection: true
+
+    xml do
+      element "subject"
+      ordered
+      map_element "topic", to: :topic, render_empty: :as_blank
+    end
+  end
+
+  # Model using value_map to override render_empty default
+  # Regression: user-provided value_map entries must take precedence over
+  # computed defaults from render_nil/render_empty DSL options.
+  class ValueMapEmptyModel < Lutaml::Model::Serializable
+    attribute :code, :string
+    attribute :page, :string
+
+    xml do
+      root "doc"
+      map_attribute "code", to: :code
+      map_attribute "page", to: :page,
+                            value_map: { to: { empty: :empty } }
+    end
+  end
+
+  # Model for testing empty attribute round-trip preservation
+  class ImageModel < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :alt, :string
+    attribute :src, :string
+
+    xml do
+      element "image"
+      map_attribute "id", to: :id
+      map_attribute "alt", to: :alt, render_empty: true
+      map_attribute "src", to: :src
+    end
+  end
+
+  # Model with ordered mapping to test element_order with :as_nil
+  class ExplicitNilOrderedModel < Lutaml::Model::Serializable
+    attribute :authority, :string
+    attribute :topic, :string, collection: true
+
+    xml do
+      element "subject"
+      ordered
+      map_element "topic", to: :topic, render_empty: :as_nil
+    end
+  end
 end
 
 RSpec.describe "RenderEmptySpec" do
@@ -66,7 +120,7 @@ RSpec.describe "RenderEmptySpec" do
       it "defaults to nil" do
         model = RenderEmptySpec::DefaultModel.new
         expect(model.items).to be_nil
-        expect(model.to_xml).to eq("<default-model/>")
+        expect(model.to_xml).to be_xml_equivalent_to("<default-model/>")
       end
     end
 
@@ -74,7 +128,7 @@ RSpec.describe "RenderEmptySpec" do
       it "defaults to empty array" do
         model = RenderEmptySpec::EmptyInitModel.new
         expect(model.items).to eq([])
-        expect(model.to_xml).to eq("<empty-init-model/>")
+        expect(model.to_xml).to be_xml_equivalent_to("<empty-init-model/>")
       end
     end
   end
@@ -190,5 +244,88 @@ RSpec.describe "RenderEmptySpec" do
         end
       end
     end
+
+    context "when :as_blank with ordered mapping (element_order path)" do
+      it "renders empty collection as blank element on parsed model with element_order" do
+        xml = '<subject authority="lcsh"><topic/></subject>'
+        parsed = RenderEmptySpec::ExplicitBlankOrderedModel.from_xml(xml)
+        # Verify element_order is set (meaning ordered path will be used)
+        expect(parsed.respond_to?(:element_order)).to be true
+        expect(parsed.to_xml).to include("<topic/>")
+      end
+    end
+
+    context "when :as_nil with ordered mapping (element_order path)" do
+      it "renders empty collection as nil element on parsed model with element_order" do
+        xml = '<subject authority="lcsh"><topic xsi:nil="true"/></subject>'
+        parsed = RenderEmptySpec::ExplicitNilOrderedModel.from_xml(xml)
+        # Verify element_order is set (meaning ordered path will be used)
+        expect(parsed.respond_to?(:element_order)).to be true
+        expect(parsed.to_xml).to include('<topic xsi:nil="true"/>')
+      end
+    end
+  end
+
+  describe "Empty attribute round-trip preservation" do
+    context "when an XML attribute is explicitly set to empty string" do
+      let(:xml) do
+        '<image alt="" id="img1" src="photo.png"/>'
+      end
+
+      it "preserves empty attribute value after round-trip" do
+        parsed = RenderEmptySpec::ImageModel.from_xml(xml)
+        expect(parsed.alt).to eq("")
+        roundtripped = parsed.to_xml
+        expect(roundtripped).to include('alt=""')
+      end
+    end
+
+    context "when an XML attribute is not present" do
+      let(:xml) do
+        '<image id="img1" src="photo.png"/>'
+      end
+
+      it "does not render the missing attribute" do
+        parsed = RenderEmptySpec::ImageModel.from_xml(xml)
+        expect(parsed.alt).to be_nil
+        roundtripped = parsed.to_xml
+        expect(roundtripped).not_to include("alt")
+      end
+    end
+
+    context "when programmatically setting an attribute to empty string" do
+      let(:model) do
+        RenderEmptySpec::ImageModel.new(id: "img1", alt: "", src: "photo.png")
+      end
+
+      it "renders the empty attribute" do
+        expect(model.to_xml).to include('alt=""')
+      end
+    end
+  end
+
+  describe "value_map precedence over render_empty defaults" do
+    # Regression: value_map: { to: { empty: :empty } } must override the
+    # computed default from render_empty: false (which maps empty → :omitted).
+    # Bug was Hash#merge order: defaults merged ON TOP of user entries.
+    context "with value_map to: { empty: :empty } on XML attribute" do
+      it "round-trips empty string attribute via value_map" do
+        xml = '<doc code="A1" page=""/>'
+        parsed = RenderEmptySpec::ValueMapEmptyModel.from_xml(xml)
+        expect(parsed.page).to eq("")
+        roundtripped = parsed.to_xml
+        expect(roundtripped).to include('page=""')
+      end
+
+      it "round-trips empty string set programmatically" do
+        model = RenderEmptySpec::ValueMapEmptyModel.new(code: "B2", page: "")
+        expect(model.to_xml).to include('page=""')
+      end
+
+      it "omits attribute when value is nil (no value_map override for nil)" do
+        model = RenderEmptySpec::ValueMapEmptyModel.new(code: "C3", page: nil)
+        expect(model.to_xml).not_to include("page")
+      end
+    end
   end
 end

data/spec/lutaml/model/render_nil_spec.rb

@@ -1,11 +1,11 @@
 require "spec_helper"
-require "lutaml/model"
+require_relative "../../../lib/lutaml/model"
 
 class RenderNilNested < Lutaml::Model::Serializable
   attribute :name, Lutaml::Model::Type::String
 
   xml do
-    root "render_nil_nested"
+    element "render_nil_nested"
 
     map_element "name", to: :name
   end
@@ -28,9 +28,10 @@ class RenderNil < Lutaml::Model::Serializable
   end
 
   xml do
-    root "render_nil"
+    element "render_nil"
     map_element "name", to: :name, render_nil: true, render_empty: true
-    map_element "clay_type", to: :clay_type, render_nil: false, render_empty: true
+    map_element "clay_type", to: :clay_type, render_nil: false,
+                             render_empty: true
     map_element "glaze", to: :glaze, render_nil: true, render_empty: true
     map_element "render_nil_nested", to: :render_nil_nested, render_nil: true,
                                      render_default: true
@@ -58,7 +59,7 @@ module RenderNilSpec
     attribute :items, :string, collection: true
 
     xml do
-      root "omit-nil-model"
+      element "omit-nil-model"
       map_element "items", to: :items, render_nil: :omit
     end
 
@@ -71,7 +72,7 @@ module RenderNilSpec
     attribute :items, :string, collection: true
 
     xml do
-      root "explicit-nil-model"
+      element "explicit-nil-model"
       map_element "items", to: :items, render_nil: :as_nil
     end
 
@@ -84,7 +85,7 @@ module RenderNilSpec
     attribute :items, :string, collection: true
 
     xml do
-      root "omit-nil-model"
+      element "omit-nil-model"
       map_element "items", to: :items, render_nil: :as_blank
     end
   end
@@ -139,7 +140,7 @@ RSpec.describe RenderNil do
       </render_nil>
     XML
 
-    expect(model.to_xml).to be_equivalent_to(expected_xml)
+    expect(model.to_xml).to be_xml_equivalent_to(expected_xml)
   end
 
   it "deserializes from XML with render_nil option" do
@@ -250,7 +251,9 @@ RSpec.describe RenderNil do
         end
 
         it "omits nil collections while deserialize" do
-          expect(parsed.items).to be_nil
+          # Collection is the shared frozen sentinel (== []) since no items
+          # were present in the XML. Previously nil, now [] for lazy allocation.
+          expect(parsed.items).to eq([])
         end
       end
     end
@@ -297,7 +300,9 @@ RSpec.describe RenderNil do
         end
 
         it "sets nil values while deserialize" do
-          expect(parsed.items).to be_nil
+          # Collection is the shared frozen sentinel (== []) since no items
+          # were present in the XML. Previously nil, now [] for lazy allocation.
+          expect(parsed.items).to eq([])
         end
       end
     end