lutaml-model 0.7.7 → 0.8.0

data/spec/lutaml/model/group_spec.rb

@@ -1,5 +1,5 @@
 require "spec_helper"
-require "lutaml/model"
+require_relative "../../support/xml_mapping_namespaces"
 
 module GroupSpec
   class Ceramic < Lutaml::Model::Serializable
@@ -7,7 +7,7 @@ module GroupSpec
     attribute :name, :string, default: "Starc"
 
     xml do
-      no_root
+      # Type-only model - no element declaration needed
       map_element :type, to: :type
       map_element :name, to: :name
     end
@@ -22,7 +22,7 @@ module GroupSpec
     attribute :ceramic, Ceramic, collection: 1..2
 
     xml do
-      root "collection"
+      element "collection"
       map_element "ceramic", to: :ceramic
     end
   end
@@ -30,22 +30,38 @@ module GroupSpec
   class AttributeValueType < Lutaml::Model::Type::Decimal
   end
 
+  # Create child model for description element with GML namespace
+  class GmlDescription < Lutaml::Model::Serializable
+    attribute :value, :string
+
+    xml do
+      element "description"
+      namespace GmlNamespace
+      map_content to: :value
+    end
+  end
+
+  # Create custom type for code attribute with Example namespace
+  class ExampleCodeType < Lutaml::Model::Type::String
+    xml do
+      namespace ExampleNamespace
+    end
+  end
+
   class GroupOfItems < Lutaml::Model::Serializable
     attribute :name, :string
     attribute :type, :string
-    attribute :description, :string
-    attribute :code, :string
+    attribute :description, GmlDescription
+    attribute :code, ExampleCodeType
 
     xml do
-      no_root
+      # Type-only model - no element declaration needed
       sequence do
         map_element "name", to: :name
         map_element "type", to: :type
-        map_element "description", to: :description,
-                                   namespace: "http://www.sparxsystems.com/profiles/GML/1.0",
-                                   prefix: "GML"
+        map_element "description", to: :description
       end
-      map_attribute "code", to: :code, namespace: "http://www.example.com", prefix: "ex1"
+      map_attribute "code", to: :code
     end
   end
 
@@ -56,7 +72,7 @@ module GroupSpec
     import_model_attributes GroupOfItems
 
     xml do
-      root "GroupOfItems"
+      element "GroupOfItems"
       map_attribute "tag", to: :tag
       map_content to: :content
       map_element :group, to: :group
@@ -76,20 +92,20 @@ module GroupSpec
     attribute :name, :string
 
     xml do
-      root "group"
+      element "group"
       map_element :name, to: :name
     end
   end
 
   class CommonAttributes < Lutaml::Model::Serializable
-    choice do
+    choice(min: 1, max: 3) do
       attribute :mstyle, :string
       attribute :mcol, :string
       attribute :mr, :string
     end
 
     xml do
-      no_root
+      # Type-only model - no element declaration needed
       sequence do
         map_element :mstyle, to: :mstyle
         map_element :mr, to: :mr
@@ -103,7 +119,7 @@ module GroupSpec
     import_model CommonAttributes
 
     xml do
-      root "mrow"
+      element "mrow"
       map_element :mi, to: :mi
     end
 
@@ -121,7 +137,7 @@ module GroupSpec
     import_model CommonAttributes
 
     xml do
-      root "mfrac"
+      element "mfrac"
       map_element :num, to: :num
     end
   end
@@ -131,7 +147,7 @@ module GroupSpec
     attribute :organization, :string
 
     xml do
-      no_root
+      # Type-only model - no element declaration needed
       map_element "person", to: :person
       map_element "organization", to: :organization
     end
@@ -142,7 +158,7 @@ module GroupSpec
     import_model_attributes ContributionInfo
 
     xml do
-      root "contributor"
+      element "contributor"
       map_element "role", to: :role
       map_element "person", to: :person
       map_element "organization", to: :organization
@@ -164,19 +180,51 @@ module GroupSpec
   class ModelElement < Lutaml::Model::Serializable
     import_model Identifier
   end
+
+  class Address < Lutaml::Model::Serializable
+    attribute :street, :string
+    attribute :city, :string
+
+    key_value do
+      map :street, to: :street
+      map :city, to: :city
+    end
+  end
+
+  class Location < Lutaml::Model::Serializable
+    attribute :id, :string
+    import_model_attributes Address
+
+    key_value do
+      map :id, to: :id
+      import_model_mappings Address
+    end
+  end
+
+  class UserLocation < Lutaml::Model::Serializable
+    attribute :username, :string
+    import_model_attributes :location
+
+    key_value do
+      map :username, to: :username
+      import_model_mappings :location
+    end
+  end
 end
 
 RSpec.describe "Group" do
   context "when serializing and deserializing import model having no_root" do
     let(:xml) do
+      # W3C Rule: Namespaces can be declared at point of use (local) or at root (hoisted).
+      # Implementation prefers default format for cleaner output when creating new instances.
       <<~XML
-        <mrow xmlns:ex1="http://www.example.com" xmlns:GML="http://www.sparxsystems.com/profiles/GML/1.0">
+        <mrow>
           <mstyle>italic</mstyle>
           <mr>y</mr>
           <mi>x</mi>
           <name>Smith</name>
           <type>product</type>
-          <GML:description>Item</GML:description>
+          <description xmlns="http://www.sparxsystems.com/profiles/GML/1.0">Item</description>
         </mrow>
       XML
     end
@@ -197,7 +245,7 @@ RSpec.describe "Group" do
       expect(parsed.mstyle).to eq("italic")
       expect(parsed.name).to eq("Smith")
       expect(parsed.type).to eq("product")
-      expect(parsed.description).to eq("Item")
+      expect(parsed.description.value).to eq("Item")
     end
 
     it "parse the imported model attributes correctly" do
@@ -208,8 +256,9 @@ RSpec.describe "Group" do
     end
 
     it "serialize the imported model correctly" do
-      instance = GroupSpec::Mrow.new(mi: "x", mstyle: "italic", mr: "y", name: "Smith", type: "product", description: "Item")
-      expect(instance.to_xml).to be_equivalent_to(xml)
+      instance = GroupSpec::Mrow.new(mi: "x", mstyle: "italic", mr: "y",
+                                     name: "Smith", type: "product", description: GroupSpec::GmlDescription.new(value: "Item"))
+      expect(instance.to_xml).to be_xml_equivalent_to(xml)
     end
   end
 
@@ -276,7 +325,17 @@ RSpec.describe "Group" do
         source_attributes.each do |name, attr|
           expect(target_attributes[name].name).to eq(attr.name)
           expect(target_attributes[name].type).to eq(attr.type)
-          expect(target_attributes[name].options).to eq(attr.options)
+          # can't compare the 'choice' directly as their 'model' will be different
+          expect(target_attributes[name].options.except(:choice)).to eq(attr.options.except(:choice))
+          if target_attributes[name].options.key?(:choice)
+            target_choice = target_attributes[name].options[:choice]
+            source_choice = attr.options[:choice]
+            expect(target_choice.min).to eql(source_choice.min)
+            expect(target_choice.max).to eql(source_choice.max)
+            expect(target_choice.model).not_to be(source_choice.model)
+            # can't compare the attributes directly as 'model' of their 'choice' will be different
+            expect(target_choice.attributes).not_to be(source_choice.attributes)
+          end
         end
       end
     end
@@ -295,33 +354,45 @@ RSpec.describe "Group" do
     end
 
     describe GroupSpec::ComplexType do
-      it_behaves_like "imports attributes from", GroupSpec::GroupOfItems, described_class
-      it_behaves_like "imports mappings from", GroupSpec::GroupOfItems, described_class
+      it_behaves_like "imports attributes from", GroupSpec::GroupOfItems,
+                      described_class
+      it_behaves_like "imports mappings from", GroupSpec::GroupOfItems,
+                      described_class
     end
 
     describe GroupSpec::GenericType do
-      it_behaves_like "imports mappings from", GroupSpec::GroupOfItems, described_class
+      it_behaves_like "imports mappings from", GroupSpec::GroupOfItems,
+                      described_class
     end
 
     describe GroupSpec::SimpleType do
-      it_behaves_like "imports attributes from", GroupSpec::GroupOfItems, described_class
-      it_behaves_like "imports mappings from", GroupSpec::GroupOfItems, described_class
+      it_behaves_like "imports attributes from", GroupSpec::GroupOfItems,
+                      described_class
+      it_behaves_like "imports mappings from", GroupSpec::GroupOfItems,
+                      described_class
     end
 
     describe GroupSpec::ModelElement do
-      it_behaves_like "imports attributes from", GroupSpec::Identifier, described_class
-      it_behaves_like "imports mappings from", GroupSpec::Identifier, described_class
+      it_behaves_like "imports attributes from", GroupSpec::Identifier,
+                      described_class
+      it_behaves_like "imports mappings from", GroupSpec::Identifier,
+                      described_class
     end
 
     describe GroupSpec::Mrow do
-      it_behaves_like "imports attributes from", GroupSpec::CommonAttributes, described_class
-      it_behaves_like "imports attributes from", GroupSpec::Ceramic, described_class
-      it_behaves_like "imports mappings from", GroupSpec::CommonAttributes, described_class
-      it_behaves_like "imports mappings from", GroupSpec::Ceramic, described_class
+      it_behaves_like "imports attributes from", GroupSpec::CommonAttributes,
+                      described_class
+      it_behaves_like "imports attributes from", GroupSpec::Ceramic,
+                      described_class
+      it_behaves_like "imports mappings from", GroupSpec::CommonAttributes,
+                      described_class
+      it_behaves_like "imports mappings from", GroupSpec::Ceramic,
+                      described_class
     end
 
     describe GroupSpec::Contributor do
-      it_behaves_like "imports attributes from", GroupSpec::ContributionInfo, described_class
+      it_behaves_like "imports attributes from", GroupSpec::ContributionInfo,
+                      described_class
     end
 
     context "when importing multiple models with overlapping attributes" do
@@ -336,15 +407,20 @@ RSpec.describe "Group" do
 
       it "maintains the correct XML serialization order from last import" do
         xml = mrow_instance.to_xml
-        expected_xml = "<mrow xmlns:ex1='http://www.example.com' xmlns:GML='http://www.sparxsystems.com/profiles/GML/1.0'/>"
+        # W3C Rule: Empty elements don't need namespace declarations
+        expected_xml = "<mrow/>"
 
-        expect(xml).to be_equivalent_to(expected_xml)
+        expect(xml).to be_xml_equivalent_to(expected_xml)
       end
     end
 
     context "when update the imported attribute" do
       it "updates the attribute `mstyle` only in `Mrow`" do
-        GroupSpec::Mrow.attributes[:mstyle].instance_variable_set(:@type, :integer)
+        attr = GroupSpec::Mrow.attributes[:mstyle]
+        attr.instance_variable_set(:@type, :integer)
+        attr.instance_variable_set(:@unresolved_type, nil) # Clear unresolved_type cache
+        attr.instance_variable_set(:@cached_type_default, nil) # Clear performance cache
+        attr.instance_variable_set(:@default_type_context, nil) # Clear context cache
         expect(GroupSpec::Mrow.attributes[:mstyle].type).to eq(Lutaml::Model::Type::Integer)
       end
 
@@ -370,23 +446,25 @@ RSpec.describe "Group" do
       it "maintains original choice min/max in Mfrac" do
         choice = GroupSpec::Mfrac.choice_attributes.first
         expect(choice.min).to eq(1)
-        expect(choice.max).to eq(1)
+        expect(choice.max).to eq(3)
       end
 
       it "maintains original choice min/max in CommonAttributes" do
         choice = GroupSpec::CommonAttributes.choice_attributes.first
         expect(choice.min).to eq(1)
-        expect(choice.max).to eq(1)
+        expect(choice.max).to eq(3)
       end
     end
 
     context "when updating imported mappings" do
-      let(:new_namespace) { "http://www.example.com/new" }
+      let(:new_namespace) { ExampleNewNamespace }
       let(:new_prefix) { "test" }
 
       context "with element mappings" do
         it "updates the mapping namespace only in `Mrow`" do
-          mapping = GroupSpec::Mrow.mappings_for(:xml).elements.find { |e| e.name == :mstyle }
+          mapping = GroupSpec::Mrow.mappings_for(:xml).elements.find do |e|
+            e.name == :mstyle
+          end
           mapping.instance_variable_set(:@namespace, new_namespace)
           mapping.instance_variable_set(:@prefix, new_prefix)
 
@@ -395,13 +473,17 @@ RSpec.describe "Group" do
         end
 
         it "maintains original namespace for `mstyle` mapping in `Mfrac`" do
-          mapping = GroupSpec::Mfrac.mappings_for(:xml).elements.find { |e| e.name == :mstyle }
+          mapping = GroupSpec::Mfrac.mappings_for(:xml).elements.find do |e|
+            e.name == :mstyle
+          end
           expect(mapping.namespace).to be_nil
           expect(mapping.prefix).to be_nil
         end
 
         it "maintains original namespace for `mstyle` mapping in `CommonAttributes`" do
-          mapping = GroupSpec::CommonAttributes.mappings_for(:xml).elements.find { |e| e.name == :mstyle }
+          mapping = GroupSpec::CommonAttributes.mappings_for(:xml).elements.find do |e|
+            e.name == :mstyle
+          end
           expect(mapping.namespace).to be_nil
           expect(mapping.prefix).to be_nil
         end
@@ -409,19 +491,25 @@ RSpec.describe "Group" do
 
       context "with attribute mappings" do
         it "updates attribute mapping only in `Mrow`" do
-          mapping = GroupSpec::Mrow.mappings_for(:xml).attributes.find { |a| a.name == :mcol }
+          mapping = GroupSpec::Mrow.mappings_for(:xml).attributes.find do |a|
+            a.name == :mcol
+          end
           mapping.instance_variable_set(:@namespace, new_namespace)
 
           expect(mapping.namespace).to eq(new_namespace)
         end
 
         it "maintains original attribute mapping in `Mfrac`" do
-          mapping = GroupSpec::Mfrac.mappings_for(:xml).attributes.find { |a| a.name == :mcol }
+          mapping = GroupSpec::Mfrac.mappings_for(:xml).attributes.find do |a|
+            a.name == :mcol
+          end
           expect(mapping.namespace).to be_nil
         end
 
         it "maintains original attribute mapping in `CommonAttributes`" do
-          mapping = GroupSpec::CommonAttributes.mappings_for(:xml).attributes.find { |a| a.name == :mcol }
+          mapping = GroupSpec::CommonAttributes.mappings_for(:xml).attributes.find do |a|
+            a.name == :mcol
+          end
           expect(mapping.namespace).to be_nil
         end
       end
@@ -429,11 +517,10 @@ RSpec.describe "Group" do
       context "with sequence elements" do
         it "updates sequence elements only in `Mrow`" do
           sequence = GroupSpec::Mrow.mappings_for(:xml).element_sequence.first
-          sequence.attributes << Lutaml::Model::Xml::MappingRule.new(
+          sequence.attributes << Lutaml::Xml::MappingRule.new(
             "new_element",
             to: :new_element,
-            namespace: "http://example.com",
-            prefix: "test",
+            namespace: ExampleComNamespace,
           )
 
           expect(sequence.attributes.map(&:name)).to include("new_element")
@@ -462,7 +549,8 @@ RSpec.describe "Group" do
         Class.new(Lutaml::Model::Serializable) do
           import_model GroupSpec::GroupWithRoot
         end
-      end.to raise_error(Lutaml::Model::ImportModelWithRootError, "Cannot import a model `GroupSpec::GroupWithRoot` with a root element")
+      end.to raise_error(Lutaml::Model::ImportModelWithRootError,
+                         "Cannot import a model `GroupSpec::GroupWithRoot` with a root element")
     end
 
     it "raises error if namespace is defined with no_root" do
@@ -470,10 +558,61 @@ RSpec.describe "Group" do
         Class.new(Lutaml::Model::Serializable) do
           xml do
             no_root
-            namespace "http://www.omg.org/spec/XMI/20131001", "xmi"
+            namespace XmiNamespace
           end
         end
-      end.to raise_error(Lutaml::Model::NoRootNamespaceError, "Cannot assign namespace to `no_root`")
+      end.to raise_error(Lutaml::Model::NoRootNamespaceError,
+                         "Cannot assign namespace to `no_root`")
+    end
+  end
+
+  context "when importing model in key-value mappings" do
+    let(:custom_register) do
+      register = Lutaml::Model::Register.new(:custom_register)
+      Lutaml::Model::GlobalRegister.register(register)
+      register
+    end
+
+    after do
+      Lutaml::Model::GlobalRegister.unregister(:custom_register)
+    end
+
+    it "imports mappings from the model correctly with default register" do
+      instance = GroupSpec::Location.new(
+        id: "LOC123",
+        street: "123 Main St",
+        city: "Metropolis",
+      )
+
+      expect(instance.to_yaml).to eq(
+        <<~YAML,
+          ---
+          id: LOC123
+          street: 123 Main St
+          city: Metropolis
+        YAML
+      )
+    end
+
+    it "imports mappings from the model correctly with custom register" do
+      custom_register.register_model(GroupSpec::Location, id: :location)
+      instance = GroupSpec::UserLocation.new(
+        id: "LOC123",
+        username: "johndoe",
+        street: "123 Main St",
+        city: "Metropolis",
+        lutaml_register: custom_register,
+      )
+
+      expect(instance.to_yaml(register: custom_register)).to eq(
+        <<~YAML,
+          ---
+          username: johndoe
+          id: LOC123
+          street: 123 Main St
+          city: Metropolis
+        YAML
+      )
     end
   end
 end

data/spec/lutaml/model/hash/adapter_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-RSpec.describe "HashAdapter" do
+RSpec.describe "Hash" do
   before do
     stub_const("HashMappingSpec", Module.new)
 
@@ -205,8 +205,10 @@ RSpec.describe "HashAdapter" do
     context "with collections of objects" do
       let(:simples) do
         [
-          HashMappingSpec::SimpleClass.new(name: "First", age: 10, active: true),
-          HashMappingSpec::SimpleClass.new(name: "Second", age: 20, active: false),
+          HashMappingSpec::SimpleClass.new(name: "First", age: 10,
+                                           active: true),
+          HashMappingSpec::SimpleClass.new(name: "Second", age: 20,
+                                           active: false),
         ]
       end