lutaml-model 0.8.9 → 0.8.11

data/spec/lutaml/model/optimization_spec.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Optimization behaviors" do
+  before do
+    Lutaml::Model::GlobalContext.clear_caches
+    Lutaml::Model::TransformationRegistry.instance.clear
+    Lutaml::Model::GlobalRegister.instance.reset
+    Lutaml::Model::Store.clear
+  end
+
+  after do
+    Lutaml::Model::GlobalContext.clear_caches
+    Lutaml::Model::TransformationRegistry.instance.clear
+    Lutaml::Model::GlobalRegister.instance.reset
+    Lutaml::Model::Store.clear
+  end
+
+  describe "DeserializationContext propagation" do
+    let(:propagation_keys) do
+      Lutaml::Model::Serialize::DeserializationContext::PROPAGATION_KEYS
+    end
+
+    it "propagates only whitelisted keys" do
+      options = {
+        lutaml_parent: "parent",
+        lutaml_root: "root",
+        default_namespace: "http://example.com",
+        namespace_uri: "http://internal.com",
+        resolved_type: String,
+        converted: true,
+        polymorphic: :by_type,
+        collection: true,
+      }
+
+      propagated = Lutaml::Model::Serialize::DeserializationContext.propagate(options)
+
+      expect(propagated).to eq({
+                                 lutaml_parent: "parent",
+                                 lutaml_root: "root",
+                                 default_namespace: "http://example.com",
+                                 polymorphic: :by_type,
+                                 collection: true,
+                               })
+    end
+
+    it "excludes parent-internal keys" do
+      options = {
+        namespace_uri: "http://internal.com",
+        resolved_type: String,
+        converted: true,
+        mappings: double("mappings"),
+      }
+
+      propagated = Lutaml::Model::Serialize::DeserializationContext.propagate(options)
+
+      expect(propagated).to be_empty
+    end
+
+    it "CHILD_PROPAGATION_KEYS matches PROPAGATION_KEYS" do
+      expect(Lutaml::Model::Attribute::CHILD_PROPAGATION_KEYS).to eq(propagation_keys)
+    end
+  end
+
+  describe "conditional reference store registration" do
+    it "registers instances by default" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :string
+      end
+
+      obj = klass.new(id: "test")
+      result = Lutaml::Model::Store.resolve(klass, :id, "test")
+      expect(result).to eq(obj)
+    end
+
+    it "skips registration when skip_reference_registration is declared" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :string
+        skip_reference_registration
+      end
+
+      klass.new(id: "test")
+      result = Lutaml::Model::Store.resolve(klass, :id, "test")
+      expect(result).to be_nil
+    end
+
+    it "reference_resolvable? returns true by default" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :string
+      end
+
+      expect(klass.reference_resolvable?).to be true
+    end
+
+    it "reference_resolvable? returns false after skip_reference_registration" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :string
+        skip_reference_registration
+      end
+
+      expect(klass.reference_resolvable?).to be false
+    end
+
+    it "skips registration during allocate_for_deserialization" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :string
+        skip_reference_registration
+      end
+
+      instance = klass.allocate_for_deserialization
+      instance.public_send(:id=, "deserialized")
+      result = Lutaml::Model::Store.resolve(klass, :id, "deserialized")
+      expect(result).to be_nil
+    end
+  end
+
+  describe "class_attributes accessor" do
+    it "returns raw attributes without register merging" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+      end
+
+      expect(klass.class_attributes).to be_a(Hash)
+      expect(klass.class_attributes.keys).to include(:name)
+    end
+  end
+
+  describe "MappingRule#static_namespace_option" do
+    it "returns frozen hash for rules with explicit namespace" do
+      rule = Lutaml::Xml::MappingRule.new(
+        "test",
+        to: :test,
+        namespace: ExampleComNamespace,
+        namespace_set: true,
+      )
+
+      result = rule.static_namespace_option
+      expect(result).to eq({ default_namespace: "http://example.com" })
+      expect(result).to be_frozen
+    end
+
+    it "returns the same object on repeated calls (cached)" do
+      rule = Lutaml::Xml::MappingRule.new(
+        "test",
+        to: :test,
+        namespace: ExampleComNamespace,
+        namespace_set: true,
+      )
+
+      first = rule.static_namespace_option
+      second = rule.static_namespace_option
+      expect(first).to equal(second) # same object identity
+    end
+
+    it "returns nil when no namespace is set" do
+      rule = Lutaml::Xml::MappingRule.new("test", to: :test)
+
+      expect(rule.static_namespace_option).to be_nil
+    end
+
+    it "returns nil when namespace is :inherit" do
+      rule = Lutaml::Xml::MappingRule.new(
+        "test",
+        to: :test,
+        namespace: :inherit,
+      )
+
+      expect(rule.static_namespace_option).to be_nil
+    end
+  end
+
+  describe "String deduplication in namespace URIs" do
+    it "XmlElement#namespace_uri deduplicates via unary minus" do
+      ns_instance = ExampleComNamespace.new
+      parent = Lutaml::Xml::XmlElement.new(nil, {}, [], nil,
+                                           name: "root",
+                                           parent_document: double(namespaces: { nil => ns_instance }))
+      uri = parent.namespace_uri
+
+      # The returned string should be the deduplicated version (-uri)
+      expect(uri).to eq("http://example.com")
+      expect(uri).to be_frozen
+    end
+
+    it "XmlElement#namespaced_name deduplicates the result string" do
+      ExampleComNamespace.new
+      parent = Lutaml::Xml::XmlElement.new(nil, {}, [], nil,
+                                           name: "root",
+                                           default_namespace: "http://example.com",
+                                           parent_document: double(namespaces: {}))
+      result = parent.namespaced_name
+
+      expect(result).to eq("http://example.com:root")
+      expect(result).to be_frozen
+    end
+  end
+
+  describe "value_set_for" do
+    it "transitions from nil (all defaults) to per-attribute tracking" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :age, :integer
+      end
+
+      obj = klass.allocate_for_deserialization
+      expect(obj.using_default?(:name)).to be true
+      expect(obj.using_default?(:age)).to be true
+
+      obj.value_set_for(:name)
+      expect(obj.using_default?(:name)).to be false
+      expect(obj.using_default?(:age)).to be true
+    end
+
+    it "values_set_for sets multiple attributes at once" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :age, :integer
+      end
+
+      obj = klass.allocate_for_deserialization
+      obj.values_set_for(%i[name age])
+
+      expect(obj.using_default?(:name)).to be false
+      expect(obj.using_default?(:age)).to be false
+    end
+  end
+end

data/spec/lutaml/model/store_spec.rb

@@ -69,6 +69,47 @@ RSpec.describe Lutaml::Model::Store do
     end
   end
 
+  describe "multi-class index isolation" do
+    let(:other_class) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :string
+        attribute :code, :string
+      end
+    end
+
+    it "does not mix indices across different classes" do
+      model_class.new(id: "a")
+      other_class.new(id: "a")
+
+      result = described_class.resolve(model_class, :id, "a")
+      expect(result).to be_a(model_class)
+
+      result2 = described_class.resolve(other_class, :id, "a")
+      expect(result2).to be_a(other_class)
+    end
+
+    it "registering class B does not iterate class A's indices" do
+      # Build index for model_class (hold strong ref so GC cannot collect it)
+      _obj = model_class.new(id: "x")
+      described_class.resolve(model_class, :id, "x")
+
+      # Registering other_class should not trigger work on model_class indices
+      100.times { |i| other_class.new(id: "other-#{i}", code: "c#{i}") }
+      result = described_class.resolve(model_class, :id, "x")
+      expect(result.id).to eq("x")
+    end
+
+    it "resolves by different reference keys independently per class" do
+      other_class.new(id: "alpha", code: "Z1")
+
+      result = described_class.resolve(other_class, :id, "alpha")
+      expect(result.id).to eq("alpha")
+
+      result2 = described_class.resolve(other_class, :code, "Z1")
+      expect(result2.code).to eq("Z1")
+    end
+  end
+
   describe "WeakRef behavior" do
     it "uses WeakRef for storage (objects can be collected when unreferenced)" do
       obj = model_class.new(id: "alive")
@@ -97,6 +138,160 @@ RSpec.describe Lutaml::Model::Store do
     end
   end
 
+  describe "compaction amortisation" do
+    it "bounds the number of full-array compactions across many live registers" do
+      threshold = Lutaml::Model::Store::COMPACTION_THRESHOLD
+      interval  = Lutaml::Model::Store::COMPACTION_INTERVAL
+      n = threshold + (3 * interval)
+
+      instance = described_class.instance
+
+      # Holding strong refs so WeakRefs stay alive across the registers.
+      objects = Array.new(n) { |i| model_class.new(id: "amortise-#{i}") }
+      expect(objects.size).to eq(n)
+
+      # Without amortisation this would be ~3000 compactions (one per register
+      # past threshold). With amortisation it fires once per INTERVAL inserts,
+      # so ~3 compactions plus a small slack.
+      expect(instance.compaction_count).to be <= 5
+
+      # Correctness: the most recently registered object still resolves.
+      expect(described_class.resolve(model_class, :id, "amortise-#{n - 1}").id)
+        .to eq("amortise-#{n - 1}")
+    end
+
+    it "resets the per-class insertion counter on clear" do
+      threshold = Lutaml::Model::Store::COMPACTION_THRESHOLD
+      objects = Array.new(threshold + 10) do |i|
+        model_class.new(id: "pre-#{i}")
+      end
+      expect(objects.size).to eq(threshold + 10)
+      described_class.clear
+
+      expect(described_class.instance.inserts_since_compaction).to be_empty
+    end
+
+    it "resets the compaction counter on clear" do
+      threshold = Lutaml::Model::Store::COMPACTION_THRESHOLD
+      interval  = Lutaml::Model::Store::COMPACTION_INTERVAL
+      _objects = Array.new(threshold + interval + 10) do |i|
+        model_class.new(id: "pre-#{i}")
+      end
+
+      described_class.clear
+
+      expect(described_class.instance.compaction_count).to eq(0)
+    end
+
+    it "removes dead refs during compaction" do
+      threshold = Lutaml::Model::Store::COMPACTION_THRESHOLD
+      interval  = Lutaml::Model::Store::COMPACTION_INTERVAL
+      instance = described_class.instance
+
+      # Register enough objects to trigger compaction, then release them.
+      # Use .times so each object is immediately unreferenced after the
+      # iteration — no Array holds strong refs, so GC can collect them.
+      (threshold + 1).times { |i| model_class.new(id: "die-#{i}") }
+      GC.start
+
+      # Register enough more to cross the interval gate and trigger compaction.
+      Array.new(interval) { |i| model_class.new(id: "live-#{i}") }
+
+      # After compaction, the refs array should be smaller than before
+      # (some dead refs removed). Exact count depends on GC timing,
+      # but the live refs must still be present.
+      live = instance.refs_for(model_class.to_s)
+      alive_count = live.count do |ref|
+        ref.weakref_alive?
+      rescue WeakRef::RefError
+        false
+      end
+      expect(alive_count).to be < (threshold + 1 + interval)
+    end
+
+    it "maintains per-class counter independence" do
+      other_class = Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :string
+      end
+
+      # Register 5 model_class objects and 3 other_class objects.
+      _objects_a = Array.new(5) { |i| model_class.new(id: "a-#{i}") }
+      _objects_b = Array.new(3) { |i| other_class.new(id: "b-#{i}") }
+
+      counters = described_class.instance.inserts_since_compaction
+      expect(counters[model_class.to_s]).to eq(5)
+      expect(counters[other_class.to_s]).to eq(3)
+    end
+
+    it "does not compact when exactly at threshold" do
+      threshold = Lutaml::Model::Store::COMPACTION_THRESHOLD
+      instance = described_class.instance
+
+      _objects = Array.new(threshold) { |i| model_class.new(id: "edge-#{i}") }
+
+      # refs.size == threshold, which does not satisfy size > threshold
+      expect(instance.compaction_count).to eq(0)
+    end
+  end
+
+  describe "index pruning" do
+    it "removes stale entry on resolve" do
+      instance = described_class.instance
+
+      _obj = model_class.new(id: "stale")
+      described_class.resolve(model_class, :id, "stale")
+      expect(instance.index_entry_count(model_class.to_s)).to eq(1)
+
+      _obj = nil
+      GC.start
+
+      expect(described_class.resolve(model_class, :id, "stale")).to be_nil
+      expect(instance.index_entry_count(model_class.to_s)).to eq(0)
+    end
+
+    it "prunes dead index entries during compaction" do
+      threshold = described_class::COMPACTION_THRESHOLD
+      interval  = described_class::COMPACTION_INTERVAL
+      instance = described_class.instance
+
+      # Register and index a batch of objects
+      _batch = Array.new(threshold + 1) { |i| model_class.new(id: "die-#{i}") }
+      described_class.resolve(model_class, :id, "die-0")
+      expect(instance.index_entry_count(model_class.to_s)).to eq(threshold + 1)
+
+      # Release and trigger compaction
+      _batch = nil
+      GC.start
+      Array.new(interval) { |i| model_class.new(id: "live-#{i}") }
+
+      # Dead entries should be pruned; only live entries remain
+      expect(instance.index_entry_count(model_class.to_s)).to be <= interval + 50
+    end
+
+    it "rebuilds index after pruning removes all entries for a reference key" do
+      threshold = described_class::COMPACTION_THRESHOLD
+      interval  = described_class::COMPACTION_INTERVAL
+
+      # Register and index by :name only
+      _batch = Array.new(threshold + 1) do |i|
+        model_class.new(id: "die-#{i}", name: "n-#{i}")
+      end
+      described_class.resolve(model_class, :name, "n-0")
+
+      # Release all and trigger compaction
+      _batch = nil
+      GC.start
+      Array.new(interval) do |i|
+        model_class.new(id: "live-#{i}", name: "live-n-#{i}")
+      end
+
+      # Index for :name should be rebuilt on next resolve
+      new_obj = model_class.new(id: "fresh", name: "fresh-name")
+      expect(described_class.resolve(model_class, :name,
+                                     "fresh-name")).to eq(new_obj)
+    end
+  end
+
   describe "#clear" do
     it "removes all registered objects" do
       model_class.new(id: "a")

data/spec/lutaml/rdf/mapping_rule_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/rdf"
+
+RSpec.describe Lutaml::Rdf::MappingRule do
+  subject(:rule) do
+    described_class.new(
+      :prefLabel,
+      namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+      to: :name,
+    )
+  end
+
+  describe ".new" do
+    it "stores predicate_name as frozen string" do
+      expect(rule.predicate_name).to eq("prefLabel")
+      expect(rule.predicate_name).to be_frozen
+    end
+
+    it "stores to as symbol" do
+      expect(rule.to).to eq(:name)
+    end
+
+    it "defaults lang_tagged to false" do
+      expect(rule.lang_tagged).to be(false)
+    end
+
+    it "defaults uri_reference to false" do
+      expect(rule.uri_reference).to be(false)
+    end
+
+    it "raises when predicate_name is nil" do
+      expect do
+        described_class.new(nil,
+                            namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                            to: :name)
+      end.to raise_error(ArgumentError, /predicate_name is required/)
+    end
+
+    it "raises when namespace is not a Rdf::Namespace subclass" do
+      expect do
+        described_class.new(:foo, namespace: String, to: :bar)
+      end.to raise_error(ArgumentError, /Rdf::Namespace/)
+    end
+
+    it "raises when to is nil" do
+      expect do
+        described_class.new(:foo,
+                            namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                            to: nil)
+      end.to raise_error(ArgumentError, /required/)
+    end
+
+    it "raises when both lang_tagged and uri_reference are true" do
+      expect do
+        described_class.new(:foo,
+                            namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                            to: :bar,
+                            lang_tagged: true,
+                            uri_reference: true)
+      end.to raise_error(ArgumentError, /mutually exclusive/)
+    end
+  end
+
+  describe "#kind" do
+    it "returns :plain by default" do
+      expect(rule.kind).to eq(:plain)
+    end
+
+    it "returns :lang_tagged when lang_tagged" do
+      r = described_class.new(:prefLabel,
+                              namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                              to: :name, lang_tagged: true)
+      expect(r.kind).to eq(:lang_tagged)
+    end
+
+    it "returns :uri_reference when uri_reference" do
+      r = described_class.new(:related,
+                              namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                              to: :related, uri_reference: true)
+      expect(r.kind).to eq(:uri_reference)
+    end
+  end
+
+  describe "#uri" do
+    it "resolves predicate name to full URI via namespace" do
+      expect(rule.uri).to eq("http://www.w3.org/2004/02/skos/core#prefLabel")
+    end
+  end
+
+  describe "#prefixed_name" do
+    it "returns prefix:local form" do
+      expect(rule.prefixed_name).to eq("skos:prefLabel")
+    end
+  end
+end

data/spec/lutaml/rdf/mapping_spec.rb

@@ -29,9 +29,20 @@ RSpec.describe Lutaml::Rdf::Mapping do
   end
 
   describe "#type" do
-    it "stores RDF type" do
+    it "stores single RDF type as array" do
       mapping.type("skos:Concept")
-      expect(mapping.rdf_type).to eq("skos:Concept")
+      expect(mapping.rdf_type).to eq(["skos:Concept"])
+    end
+
+    it "stores multiple RDF types" do
+      mapping.type(["skos:Concept", "dcterms:Agent"])
+      expect(mapping.rdf_type).to eq(["skos:Concept", "dcterms:Agent"])
+    end
+
+    it "overwrites previous type on subsequent call" do
+      mapping.type("skos:Concept")
+      mapping.type("dcterms:Agent")
+      expect(mapping.rdf_type).to eq(["dcterms:Agent"])
     end
   end
 
@@ -60,6 +71,28 @@ RSpec.describe Lutaml::Rdf::Mapping do
       expect(mapping.rdf_predicates.first.lang_tagged).to be(true)
     end
 
+    it "creates MappingRule with uri_reference option" do
+      mapping.predicate(
+        :related,
+        namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+        to: :related,
+        uri_reference: true,
+      )
+      expect(mapping.rdf_predicates.first.uri_reference).to be(true)
+    end
+
+    it "rejects lang_tagged combined with uri_reference" do
+      expect do
+        mapping.predicate(
+          :related,
+          namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+          to: :related,
+          lang_tagged: true,
+          uri_reference: true,
+        )
+      end.to raise_error(ArgumentError, /mutually exclusive/)
+    end
+
     it "registers multiple predicates" do
       mapping.predicate(:prefLabel,
                         namespace: Lutaml::Rdf::Namespaces::SkosNamespace, to: :name)
@@ -100,6 +133,28 @@ RSpec.describe Lutaml::Rdf::Mapping do
       expect(mapping.rdf_members.length).to eq(1)
       expect(mapping.rdf_members.first.attr_name).to eq(:items)
     end
+
+    it "creates MemberRule with linking predicate" do
+      mapping.members(:items,
+                      predicate_name: :member,
+                      namespace: Lutaml::Rdf::Namespaces::SkosNamespace)
+      rule = mapping.rdf_members.first
+      expect(rule.linked?).to be(true)
+      expect(rule.linked_predicate_uri).to eq("http://www.w3.org/2004/02/skos/core#member")
+    end
+
+    it "creates MemberRule without linking predicate" do
+      mapping.members(:items)
+      rule = mapping.rdf_members.first
+      expect(rule.linked?).to be(false)
+      expect(rule.linked_predicate_uri).to be_nil
+    end
+
+    it "raises when predicate_name given without namespace" do
+      expect do
+        mapping.members(:items, predicate_name: :member)
+      end.to raise_error(ArgumentError, /namespace is required/)
+    end
   end
 
   describe "#mappings" do
@@ -140,7 +195,7 @@ RSpec.describe Lutaml::Rdf::Mapping do
         Lutaml::Rdf::Namespaces::DctermsNamespace,
       )
       mapping.subject { |m| "http://example.org/#{m.name}" }
-      mapping.type("skos:Concept")
+      mapping.type(["skos:Concept", "dcterms:Agent"])
       mapping.predicate(:prefLabel,
                         namespace: Lutaml::Rdf::Namespaces::SkosNamespace, to: :name)
     end
@@ -149,7 +204,7 @@ RSpec.describe Lutaml::Rdf::Mapping do
       duped = mapping.deep_dup
       expect(duped.namespace_set.size).to eq(2)
       expect(duped.rdf_subject).to be_a(Proc)
-      expect(duped.rdf_type).to eq("skos:Concept")
+      expect(duped.rdf_type).to eq(["skos:Concept", "dcterms:Agent"])
       expect(duped.rdf_predicates.length).to eq(1)
     end
 
@@ -160,5 +215,20 @@ RSpec.describe Lutaml::Rdf::Mapping do
       expect(mapping.rdf_predicates.length).to eq(1)
       expect(duped.rdf_predicates.length).to eq(2)
     end
+
+    it "does not share type array with original" do
+      duped = mapping.deep_dup
+      duped.type("skos:Collection")
+      expect(mapping.rdf_type).to eq(["skos:Concept", "dcterms:Agent"])
+      expect(duped.rdf_type).to eq(["skos:Collection"])
+    end
+
+    it "does not share member state with original" do
+      mapping.members(:items)
+      duped = mapping.deep_dup
+      duped.members(:more_items)
+      expect(mapping.rdf_members.length).to eq(1)
+      expect(duped.rdf_members.length).to eq(2)
+    end
   end
 end

data/spec/lutaml/rdf/member_rule_spec.rb

@@ -13,5 +13,46 @@ RSpec.describe Lutaml::Rdf::MemberRule do
       rule = described_class.new("concepts")
       expect(rule.attr_name).to eq(:concepts)
     end
+
+    it "raises ArgumentError when predicate_name given without namespace" do
+      expect do
+        described_class.new(:items, predicate_name: :member)
+      end.to raise_error(ArgumentError, /namespace is required/)
+    end
+
+    it "allows both predicate_name and namespace together" do
+      rule = described_class.new(:items,
+                                 predicate_name: :member,
+                                 namespace: Lutaml::Rdf::Namespaces::SkosNamespace)
+      expect(rule.predicate_name).to eq(:member)
+    end
+  end
+
+  describe "#linked?" do
+    it "returns false when no predicate_name" do
+      rule = described_class.new(:items)
+      expect(rule.linked?).to be(false)
+    end
+
+    it "returns true when predicate_name is set" do
+      rule = described_class.new(:items,
+                                 predicate_name: :member,
+                                 namespace: Lutaml::Rdf::Namespaces::SkosNamespace)
+      expect(rule.linked?).to be(true)
+    end
+  end
+
+  describe "#linked_predicate_uri" do
+    it "returns nil when no linking predicate" do
+      rule = described_class.new(:items)
+      expect(rule.linked_predicate_uri).to be_nil
+    end
+
+    it "resolves the linking predicate URI" do
+      rule = described_class.new(:items,
+                                 predicate_name: :member,
+                                 namespace: Lutaml::Rdf::Namespaces::SkosNamespace)
+      expect(rule.linked_predicate_uri).to eq("http://www.w3.org/2004/02/skos/core#member")
+    end
   end
 end