lutaml-model 0.8.6 → 0.8.8

data/lib/lutaml/model/transform.rb

@@ -6,7 +6,8 @@ module Lutaml
       @transform_cache = {}
 
       # Maximum number of cached Transform instances before eviction.
-      MAX_CACHE_SIZE = 256
+      # Covers most OOXML/ISO schemas with ~1000+ classes and multiple registers.
+      MAX_CACHE_SIZE = 2048
 
       def self.data_to_model(context, data, format, options = {})
         register = options[:register] || Lutaml::Model::Config.default_register
@@ -15,7 +16,7 @@ module Lutaml
       end
 
       def self.model_to_data(context, model, format, options = {})
-        register = model.lutaml_register if model.respond_to?(:lutaml_register)
+        register = model.lutaml_register if model.is_a?(Lutaml::Model::Serialize)
         register ||= Lutaml::Model::Config.default_register
         transform = cached_transform(context, register)
         transform.model_to_data(model, format, options)
@@ -23,7 +24,7 @@ module Lutaml
 
       def self.cached_transform(context, register)
         @transform_cache ||= {}
-        cache_key = [context.object_id, register]
+        cache_key = [context, register]
         entry = @transform_cache[cache_key]
         return entry if entry
 
@@ -39,6 +40,16 @@ module Lutaml
         @transform_cache&.size || 0
       end
 
+      def self.invalidate_for(context, register = nil)
+        return unless @transform_cache
+
+        if register
+          @transform_cache.delete([context, register])
+        else
+          @transform_cache.reject! { |(ctx, _reg)| ctx == context }
+        end
+      end
+
       def self.evict_if_needed
         # Evict oldest half of entries when cache is full
         keys_to_remove = @transform_cache.keys.first(@transform_cache.size / 2)

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

@@ -8,10 +8,10 @@ module Lutaml
           return super if Utils.uninitialized?(value)
           return nil if value.nil?
 
-          hash = if value.respond_to?(:to_h)
-                   value.to_h
-                 else
-                   Hash(value)
+          hash = case value
+                 when ::Hash then value
+                 when ::Array then value.to_h
+                 else value.to_h
                  end
 
           normalize_hash(hash)
@@ -40,7 +40,11 @@ module Lutaml
           return nil if value.nil?
           return value if value.is_a?(::Hash)
 
-          value.respond_to?(:to_h) ? value.to_h : Hash(value)
+          case value
+          when ::Hash then value
+          when ::Array then value.to_h
+          else value.to_h
+          end
         end
 
         # XSD type for Hash

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

@@ -7,7 +7,7 @@ module Lutaml
         def self.cast(value, options = {})
           return nil if value.nil?
           return value if Utils.uninitialized?(value)
-          return nil if value.respond_to?(:empty?) && value.empty?
+          return nil if value.is_a?(::String) && value.empty?
 
           # Convert to string for validation and unwrapping
           str_value = if value.is_a?(::Symbol)

data/lib/lutaml/model/utils.rb

@@ -115,18 +115,25 @@ module Lutaml
         end
 
         def blank?(value)
-          value.respond_to?(:empty?) ? value.empty? : value.nil?
+          case value
+          when ::String, ::Array, ::Hash then value.empty?
+          when ::NilClass then true
+          else false
+          end
         end
 
         def empty_collection?(collection)
           return false if collection.nil?
-          return false unless [Array, Hash].include?(collection.class)
+          return false unless [::Array, ::Hash].include?(collection.class)
 
           collection.empty?
         end
 
         def empty?(value)
-          value.respond_to?(:empty?) ? value.empty? : false
+          case value
+          when ::String, ::Array, ::Hash then value.empty?
+          else false
+          end
         end
 
         def add_if_present(hash, key, value)
@@ -273,7 +280,11 @@ module Lutaml
         end
 
         def deep_dup_object(object)
-          object.respond_to?(:deep_dup) ? object.deep_dup : object.dup
+          if object.is_a?(DeepDupable)
+            object.deep_dup
+          else
+            object.dup
+          end
         end
 
         def camelize_part(part)

data/lib/lutaml/model/validation.rb

@@ -10,7 +10,7 @@ module Lutaml
           value = public_send(:"#{name}")
 
           begin
-            if value.respond_to?(:validate)
+            if value.is_a?(Lutaml::Model::Serialize)
               sub_errors = value.validate
               errors.concat(sub_errors) if sub_errors.is_a?(Array)
             else
@@ -74,8 +74,14 @@ module Lutaml
         nil
       end
 
+      # Default: no element order. XML overrides via InstanceMethods prepend
+      # with attr_accessor :element_order.
+      def element_order
+        nil
+      end
+
       def order_names
-        return [] unless respond_to?(:element_order) && element_order
+        return [] unless element_order
 
         element_order.each_with_object([]) do |element, arr|
           next if element.text?

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.6"
+    VERSION = "0.8.8"
   end
 end

data/lib/lutaml/model.rb

@@ -33,6 +33,7 @@ module Lutaml
     autoload :AdapterResolver, "#{__dir__}/model/adapter_resolver"
     autoload :AdapterScope, "#{__dir__}/model/adapter_scope"
     autoload :Utils, "#{__dir__}/model/utils"
+    autoload :DeepDupable, "#{__dir__}/model/deep_dupable"
     autoload :Serializable, "#{__dir__}/model/serializable"
     autoload :Error, "#{__dir__}/model/error"
     autoload :Constants, "#{__dir__}/model/constants"

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

@@ -145,13 +145,10 @@ module Lutaml
             attribute_group.sort_by { |item| item.name.to_s }
           end
 
-          # Capture both the target namespace URI and the matching prefix
-          # discovered during XML deserialization.
-          def target_namespace_from(model, value, custom_args = {})
+          def target_namespace_from(model, value)
             model.target_namespace = value
-            namespaces = custom_args[:namespaces] || {}
             model.target_namespace_prefix =
-              namespaces.find { |_, namespace| namespace.uri == value }&.first
+              namespace_prefix_for(model.pending_plan_root_element, value)
           end
 
           # Find a type definition by local name
@@ -246,6 +243,12 @@ module Lutaml
 
           private
 
+          def namespace_prefix_for(element, namespace_uri)
+            element&.own_namespaces&.find do |_, namespace|
+              namespace.uri == namespace_uri
+            end&.first
+          end
+
           def all_namespaces
             # Aggregate the schema target namespace with imported namespaces.
             namespaces = [target_namespace].compact

data/lib/lutaml/xml/serialization/instance_methods.rb

@@ -34,6 +34,8 @@ module Lutaml
         def clear_xml_parse_state!
           @import_declaration_plan = nil
           @pending_plan_root_element = nil
+          @element_order = nil
+          @attribute_order = nil
           self
         end
 

data/lib/lutaml/xml/xml_element.rb

@@ -282,7 +282,7 @@ module Lutaml
                                      namespace_uri: child.namespace_uri,
                                      namespace_prefix: child.namespace_prefix)
           end
-        end
+        end.each(&:freeze).freeze
       end
 
       def root

data/spec/lutaml/model/attribute_spec.rb

@@ -288,30 +288,19 @@ RSpec.describe Lutaml::Model::Attribute do
   describe "#deep_dup" do
     let(:duplicate_attribute) { Lutaml::Model::Utils.deep_dup(attribute) }
 
-    context "when deep_dup method is not defined and instance is deep_duplicated" do
-      let(:attribute) { described_class.new("name", :string) }
-
-      before do
-        described_class.alias_method :orig_deep_dup, :deep_dup
-        described_class.undef_method :deep_dup
-      end
-
-      after do
-        described_class.alias_method :deep_dup, :orig_deep_dup
-        attribute.options.delete(:foo)
-      end
-
-      it "confirms that options values are linked of original and duplicate instances" do
-        duplicate_attribute
-        attribute.options[:foo] = "bar"
-        expect(duplicate_attribute.options).to include(:foo)
+    context "when object does not include DeepDupable" do
+      it "falls back to dup for plain objects" do
+        plain = Struct.new(:value).new("hello")
+        result = Lutaml::Model::Utils.deep_dup(plain)
+        expect(result.value).to eq("hello")
+        expect(result).not_to equal(plain)
       end
     end
 
-    context "when deep_dup method is defined and instance is deep_duplicated" do
+    context "when Attribute is deep_duplicated" do
       let(:attribute) { described_class.new("name", :string) }
 
-      it "confirms that options values are not linked of original and duplicate instances" do
+      it "creates independent copies of options" do
         duplicate_attribute
         attribute.options[:foo] = "bar"
         expect(duplicate_attribute.options).not_to include(:foo)

data/spec/lutaml/model/register_methods_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Register-specific attribute methods" do
+  let(:register) do
+    Lutaml::Model::Register.new(:register_methods_test,
+                                fallback: [:default])
+  end
+
+  let(:base_model) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+
+      xml do
+        root "Base"
+        map_element "Name", to: :name
+      end
+    end
+  end
+
+  let(:extension_model) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :version, :string
+      attribute :priority, :integer
+
+      xml do
+        root "Extension"
+        map_element "Version", to: :version
+        map_element "Priority", to: :priority
+      end
+    end
+  end
+
+  before do
+    Lutaml::Model::GlobalContext.reset!
+    Lutaml::Model::GlobalRegister.register(register)
+    register.register_model(extension_model, id: :extension_model)
+    base_model.import_model_attributes(extension_model, register.id)
+  end
+
+  describe "class-level method definition" do
+    it "does not create singleton class methods for register-specific attributes" do
+      instance = base_model.new({ name: "test",
+                                  version: "1.0" },
+                                register: register.id)
+
+      expect(instance.version).to eq("1.0")
+
+      # Method should be on the class, NOT directly on the singleton class
+      expect(instance.singleton_class.instance_methods(false)).not_to include(:version)
+      expect(instance.singleton_class.instance_methods(false)).not_to include(:version=)
+    end
+
+    it "defines methods on the class accessible to all instances" do
+      instance1 = base_model.new({ name: "a" }, register: register.id)
+      instance2 = base_model.new({ name: "b" }, register: register.id)
+
+      instance1.version = "1.0"
+      instance2.version = "2.0"
+
+      expect(instance1.version).to eq("1.0")
+      expect(instance2.version).to eq("2.0")
+    end
+
+    it "guards against re-definition with @_register_methods_defined" do
+      base_model.new({ name: "a" }, register: register.id)
+
+      guard = base_model.instance_variable_get(:@_register_methods_defined)
+      expect(guard).to include(register.id => true)
+
+      # Second instance creation should not re-trigger method definition
+      base_model.new({ name: "b" }, register: register.id)
+      expect(guard[register.id]).to be(true)
+    end
+  end
+
+  describe "type casting in setter" do
+    it "casts integer values correctly" do
+      instance = base_model.new({ name: "test" }, register: register.id)
+
+      instance.priority = "5"
+      expect(instance.priority).to eq(5)
+    end
+
+    it "casts string values correctly" do
+      instance = base_model.new({ name: "test" }, register: register.id)
+
+      instance.version = 42
+      expect(instance.version).to eq("42")
+    end
+  end
+
+  describe "value_set_for tracking" do
+    it "marks register-specific attributes as explicitly set" do
+      instance = base_model.new({ name: "test" }, register: register.id)
+
+      # After initialization, version was set via public_send in initialize_attributes
+      expect(instance.using_default?(:version)).to be(false)
+    end
+
+    it "uses default when register-specific attribute is not provided" do
+      instance = base_model.allocate_for_deserialization(register.id)
+
+      # Not yet set — using default
+      expect(instance.using_default?(:version)).to be(true)
+
+      instance.version = "1.0"
+      expect(instance.using_default?(:version)).to be(false)
+    end
+  end
+
+  describe "default register instances" do
+    it "returns early without defining methods for :default register" do
+      base_model.ensure_register_methods_defined(:default)
+
+      guard = base_model.instance_variable_get(:@_register_methods_defined)
+      expect(guard).to be_nil
+    end
+
+    it "default-register instances still work for class-level attributes" do
+      instance = base_model.new(name: "test")
+
+      expect(instance.name).to eq("test")
+      instance.name = "changed"
+      expect(instance.name).to eq("changed")
+    end
+  end
+
+  describe "deserialization path" do
+    it "defines methods via finalize_deserialization" do
+      instance = base_model.allocate_for_deserialization(register.id)
+      instance.version = "3.0"
+
+      expect(instance.version).to eq("3.0")
+      expect(instance.singleton_class.instance_methods(false)).not_to include(:version)
+    end
+  end
+
+  describe "clear_cache resets the guard" do
+    it "clears @_register_methods_defined on clear_cache" do
+      base_model.new({ name: "a" }, register: register.id)
+      expect(base_model.instance_variable_get(:@_register_methods_defined)).not_to be_nil
+
+      base_model.clear_cache
+      expect(base_model.instance_variable_get(:@_register_methods_defined)).to be_nil
+    end
+  end
+end

data/spec/lutaml/model/store_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Store do
+  let(:model_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :id, :string
+      attribute :name, :string
+    end
+  end
+
+  before { described_class.clear }
+  after { described_class.clear }
+
+  describe "#register and #resolve" do
+    it "resolves a registered object by reference key" do
+      obj = model_class.new(id: "abc", name: "test")
+      result = described_class.resolve(model_class, :id, "abc")
+      expect(result).to eq(obj)
+    end
+
+    it "returns nil for non-existent reference" do
+      model_class.new(id: "abc")
+      result = described_class.resolve(model_class, :id, "nonexistent")
+      expect(result).to be_nil
+    end
+
+    it "returns nil for non-existent class" do
+      other_class = Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :string
+      end
+      result = described_class.resolve(other_class, :id, "anything")
+      expect(result).to be_nil
+    end
+
+    it "resolves by name attribute" do
+      obj = model_class.new(id: "abc", name: "myobj")
+      result = described_class.resolve(model_class, :name, "myobj")
+      expect(result).to eq(obj)
+    end
+  end
+
+  describe "indexed lookup" do
+    it "builds index lazily on first resolve" do
+      5.times { |i| model_class.new(id: "obj-#{i}") }
+
+      result = described_class.resolve(model_class, :id, "obj-3")
+      expect(result.id).to eq("obj-3")
+    end
+
+    it "updates index when new objects are registered after first resolve" do
+      model_class.new(id: "first")
+      described_class.resolve(model_class, :id, "first") # triggers index build
+
+      model_class.new(id: "second")
+      result = described_class.resolve(model_class, :id, "second")
+      expect(result.id).to eq("second")
+    end
+
+    it "reuses index across multiple resolves for same key" do
+      10.times { |i| model_class.new(id: "obj-#{i}") }
+
+      # First resolve builds the index
+      described_class.resolve(model_class, :id, "obj-5")
+      # Second resolve should use the same index
+      result = described_class.resolve(model_class, :id, "obj-7")
+      expect(result.id).to eq("obj-7")
+    end
+  end
+
+  describe "WeakRef behavior" do
+    it "uses WeakRef for storage (objects can be collected when unreferenced)" do
+      obj = model_class.new(id: "alive")
+      result = described_class.resolve(model_class, :id, "alive")
+      expect(result).to eq(obj)
+    end
+
+    it "resolves objects with strong references held externally" do
+      obj = model_class.new(id: "alive")
+      GC.start
+      result = described_class.resolve(model_class, :id, "alive")
+      expect(result).to eq(obj)
+    end
+  end
+
+  describe "#store" do
+    it "returns only live objects" do
+      obj1 = model_class.new(id: "keep")
+      _obj2 = model_class.new(id: "drop")
+      _obj2 = nil
+      GC.start
+
+      entries = described_class.store[model_class.to_s]
+      # obj1 should be alive; obj2 may or may not be GC'd depending on timing
+      expect(entries).to include(obj1)
+    end
+  end
+
+  describe "#clear" do
+    it "removes all registered objects" do
+      model_class.new(id: "a")
+      model_class.new(id: "b")
+      described_class.clear
+
+      expect(described_class.resolve(model_class, :id, "a")).to be_nil
+      expect(described_class.resolve(model_class, :id, "b")).to be_nil
+    end
+
+    it "clears the index" do
+      model_class.new(id: "indexed")
+      described_class.resolve(model_class, :id, "indexed") # build index
+      described_class.clear
+
+      model_class.new(id: "new-one")
+      result = described_class.resolve(model_class, :id, "new-one")
+      expect(result.id).to eq("new-one")
+    end
+  end
+end

data/spec/lutaml/model/transform_cache_spec.rb

@@ -59,4 +59,46 @@ RSpec.describe "Transform caching" do
       expect(Lutaml::Model::Transform.cache_size).to be <= 4
     end
   end
+
+  describe ".invalidate_for" do
+    it "invalidates cache for a specific context" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+      end
+
+      t1 = Lutaml::Model::Transform.cached_transform(klass, :default)
+      Lutaml::Model::Transform.invalidate_for(klass)
+      t2 = Lutaml::Model::Transform.cached_transform(klass, :default)
+      expect(t1).not_to equal(t2)
+    end
+
+    it "invalidates cache for a specific context and register" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+      end
+
+      t1_default = Lutaml::Model::Transform.cached_transform(klass, :default)
+      t1_other = Lutaml::Model::Transform.cached_transform(klass, :other)
+
+      Lutaml::Model::Transform.invalidate_for(klass, :default)
+
+      t2_default = Lutaml::Model::Transform.cached_transform(klass, :default)
+      t2_other = Lutaml::Model::Transform.cached_transform(klass, :other)
+
+      expect(t1_default).not_to equal(t2_default)
+      expect(t1_other).to equal(t2_other)
+    end
+
+    it "uses class identity as key, not object_id" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+      end
+
+      t1 = Lutaml::Model::Transform.cached_transform(klass, :default)
+      # Force GC — object_id reuse should not cause stale hits
+      GC.start
+      t2 = Lutaml::Model::Transform.cached_transform(klass, :default)
+      expect(t1).to equal(t2)
+    end
+  end
 end

data/spec/lutaml/xml/clear_parse_state_spec.rb

@@ -75,11 +75,18 @@ RSpec.describe "#clear_xml_parse_state!" do
   end
 
   describe "user-facing attributes" do
-    it "does not clear element_order" do
+    it "clears element_order to release parse buffers" do
       model = model_class.from_xml(xml_with_ns)
-      original_order = model.element_order
+      expect(model.element_order).not_to be_nil
       model.clear_xml_parse_state!
-      expect(model.element_order).to eq(original_order)
+      expect(model.element_order).to be_nil
+    end
+
+    it "clears attribute_order to release parse buffers" do
+      model = model_class.from_xml(xml_with_ns)
+      expect(model.attribute_order).not_to be_nil
+      model.clear_xml_parse_state!
+      expect(model.attribute_order).to be_nil
     end
 
     it "does not clear encoding" do

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

@@ -14,6 +14,41 @@ RSpec.describe "Schema mapping integration" do
     Lutaml::Xml::Schema::Xsd::Glob.schema_mappings = nil
   end
 
+  describe "target namespace prefix parsing" do
+    let(:xsd_content) do
+      <<~XSD
+        <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                   xmlns:t="http://example.com/test"
+                   targetNamespace="http://example.com/test">
+          <xs:element name="Root" type="xs:string"/>
+        </xs:schema>
+      XSD
+    end
+
+    it "captures the root prefix declared for the target namespace" do
+      parsed = Lutaml::Xml::Schema::Xsd.parse(xsd_content)
+
+      expect(parsed.target_namespace).to eq("http://example.com/test")
+      expect(parsed.target_namespace_prefix).to eq("t")
+      expect(parsed.element.first.target_prefix).to eq("t")
+    end
+
+    it "captures nil prefix when target namespace is the default (unprefixed)" do
+      xsd_default_ns = <<~XSD
+        <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                   xmlns="http://example.com/default"
+                   targetNamespace="http://example.com/default">
+          <xs:element name="Root" type="xs:string"/>
+        </xs:schema>
+      XSD
+
+      parsed = Lutaml::Xml::Schema::Xsd.parse(xsd_default_ns)
+
+      expect(parsed.target_namespace).to eq("http://example.com/default")
+      expect(parsed.target_namespace_prefix).to be_nil
+    end
+  end
+
   describe "parsing with exact string mappings" do
     let(:xsd_content) do
       <<~XSD

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "lutaml/model"
 require "lutaml/xml/schema/xsd"
 
 module XsdSpecHelper