lutaml-model 0.8.10 → 0.8.12

data/spec/lutaml/jsonld/transform_spec.rb

@@ -208,4 +208,243 @@ RSpec.describe Lutaml::JsonLd::Transform do
       expect(restored.tags).to eq(["en", "fr"])
     end
   end
+
+  describe "multiple types" do
+    before do
+      stub_const("DctermsTestNs", Class.new(Lutaml::Rdf::Namespace) do
+        uri "http://purl.org/dc/terms/"
+        prefix "dcterms"
+      end)
+
+      stub_const("MultiTypeJsonLdModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        rdf do
+          namespace TestSkosNs, DctermsTestNs
+
+          subject { |m| "http://example.org/#{m.name}" } # rubocop:disable RSpec/NamedSubject
+
+          type ["skos:Concept", "dcterms:Agent"]
+
+          predicate :name, namespace: TestExNs, to: :name
+        end
+      end)
+    end
+
+    it "generates @type as array for multiple types" do
+      instance = MultiTypeJsonLdModel.new(name: "multi")
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed["@type"]).to eq(["skos:Concept", "dcterms:Agent"])
+    end
+
+    it "generates @type as string for single type" do
+      instance = JsonLdTestModel.new(name: "single")
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed["@type"]).to eq("skos:Concept")
+    end
+  end
+
+  describe "URI reference predicates" do
+    before do
+      stub_const("UriRefJsonLdModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :related, :string, collection: true
+
+        rdf do
+          namespace TestSkosNs, TestExNs
+
+          subject { |m| "http://example.org/#{m.name}" } # rubocop:disable RSpec/NamedSubject
+
+          type "skos:Concept"
+
+          predicate :name, namespace: TestExNs, to: :name
+          predicate :related, namespace: TestSkosNs, to: :related,
+                              uri_reference: true
+        end
+      end)
+    end
+
+    it "generates @type @id in context for uri_reference predicates" do
+      instance = UriRefJsonLdModel.new(name: "test", related: ["skos:other"])
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed["@context"]["related"]).to eq({
+                                                    "@id" => "http://www.w3.org/2004/02/skos/core#related",
+                                                    "@type" => "@id",
+                                                  })
+    end
+
+    it "serializes URI reference as @id object" do
+      instance = UriRefJsonLdModel.new(name: "test", related: ["skos:other"])
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed["related"]).to eq([{ "@id" => "skos:other" }])
+    end
+
+    it "serializes single URI reference value as @id object" do
+      stub_const("SingleUriRefModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :link, :string
+
+        rdf do
+          namespace TestSkosNs, TestExNs
+
+          subject { |m| "http://example.org/#{m.name}" } # rubocop:disable RSpec/NamedSubject
+
+          type "skos:Concept"
+
+          predicate :name, namespace: TestExNs, to: :name
+          predicate :related, namespace: TestSkosNs, to: :link,
+                              uri_reference: true
+        end
+      end)
+
+      instance = SingleUriRefModel.new(name: "test", link: "skos:something")
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed["related"]).to eq({ "@id" => "skos:something" })
+    end
+  end
+
+  describe "member linking predicates" do
+    before do
+      stub_const("JsonLdChildModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :cid, :string
+        attribute :label, :string
+
+        rdf do
+          namespace TestSkosNs, TestExNs
+
+          subject { |m| "http://example.org/item/#{m.cid}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          type "skos:Concept"
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :label
+        end
+      end)
+
+      stub_const("JsonLdParentModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :children, JsonLdChildModel, collection: true
+
+        rdf do
+          namespace TestSkosNs, TestExNs
+
+          subject { |m| "http://example.org/group/#{m.name}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          type "skos:Collection"
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :name
+
+          members :children,
+                  predicate_name: :member,
+                  namespace: TestSkosNs
+        end
+      end)
+    end
+
+    it "includes linking term in @context with @type @id" do
+      parent = JsonLdParentModel.new(
+        name: "grp1",
+        children: [JsonLdChildModel.new(cid: "a", label: "Alpha")],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      expect(parsed["@context"]["member"]).to eq({
+                                                   "@id" => "http://www.w3.org/2004/02/skos/core#member",
+                                                   "@type" => "@id",
+                                                 })
+    end
+
+    it "generates @id references for linked members in @graph" do
+      parent = JsonLdParentModel.new(
+        name: "grp1",
+        children: [
+          JsonLdChildModel.new(cid: "a", label: "Alpha"),
+          JsonLdChildModel.new(cid: "b", label: "Beta"),
+        ],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      parent_resource = parsed["@graph"].find { |r| r["@type"] }
+      expect(parent_resource["member"]).to eq([
+                                                { "@id" => "http://example.org/item/a" },
+                                                { "@id" => "http://example.org/item/b" },
+                                              ])
+    end
+
+    it "includes member resources in @graph" do
+      parent = JsonLdParentModel.new(
+        name: "grp1",
+        children: [JsonLdChildModel.new(cid: "a", label: "Alpha")],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      member = parsed["@graph"].find { |r| r["prefLabel"] == "Alpha" }
+      expect(member).not_to be_nil
+      expect(member["@id"]).to eq("http://example.org/item/a")
+    end
+
+    it "merges child namespaces into @context" do
+      parent = JsonLdParentModel.new(
+        name: "grp1",
+        children: [JsonLdChildModel.new(cid: "a", label: "Alpha")],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      expect(parsed["@context"]["skos"]).to eq("http://www.w3.org/2004/02/skos/core#")
+      expect(parsed["@context"]["ex"]).to eq("http://example.org/")
+    end
+
+    it "omits linking key when members have no linking predicate" do
+      stub_const("UnlinkedChild", Class.new(Lutaml::Model::Serializable) do
+        attribute :label, :string
+
+        rdf do
+          namespace TestSkosNs
+
+          subject { |m| "http://example.org/#{m.label}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :label
+        end
+      end)
+
+      stub_const("UnlinkedParent", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :items, UnlinkedChild, collection: true
+
+        rdf do
+          namespace TestSkosNs
+
+          subject { |m| "http://example.org/#{m.name}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :name
+
+          members :items
+        end
+      end)
+
+      parent = UnlinkedParent.new(
+        name: "grp",
+        items: [UnlinkedChild.new(label: "a")],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      expect(parsed["@context"]).not_to have_key("member")
+    end
+  end
+
+  describe "empty type array" do
+    before do
+      stub_const("NoTypeJsonLdModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        rdf do
+          namespace TestExNs
+
+          subject { |m| "http://example.org/#{m.name}" } # rubocop:disable RSpec/NamedSubject
+
+          predicate :name, namespace: TestExNs, to: :name
+        end
+      end)
+    end
+
+    it "omits @type when no types declared" do
+      instance = NoTypeJsonLdModel.new(name: "test")
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed).not_to have_key("@type")
+    end
+  end
 end

data/spec/lutaml/model/opal_smoke_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Opal compatibility", if: RUBY_ENGINE == "opal" do
+  it "includes Serialize in a class" do
+    klass = Class.new { include Lutaml::Model::Serialize }
+    expect(klass.include?(Lutaml::Model::Serialize)).to be true
+  end
+
+  it "defines attributes and serializes to hash" do
+    person = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :name, :string
+      attribute :age, :integer
+    end
+
+    instance = person.new(name: "Alice", age: 30)
+    expect(instance.to_hash).to eq({ "name" => "Alice", "age" => 30 })
+  end
+
+  it "round-trips JSON serialization" do
+    person = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :name, :string
+      attribute :age, :integer
+    end
+
+    instance = person.from_json('{"name":"Bob","age":25}')
+    expect(instance.name).to eq("Bob")
+    expect(instance.age).to eq(25)
+  end
+
+  it "handles collections" do
+    team = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :members, :string, collection: true
+    end
+
+    instance = team.new(members: %w[Alice Bob Carol])
+    expect(instance.members).to eq(%w[Alice Bob Carol])
+  end
+
+  it "handles defaults" do
+    widget = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :name, :string
+      attribute :active, :boolean, default: -> { true }
+    end
+
+    instance = widget.new(name: "test")
+    expect(instance.active).to be true
+  end
+
+  it "handles type coercion" do
+    record = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :count, :integer
+      attribute :ratio, :float
+      attribute :flag, :boolean
+    end
+
+    instance = record.new(count: "42", ratio: "3.14", flag: "true")
+    expect(instance.count).to eq(42)
+    expect(instance.ratio).to eq(3.14)
+    expect(instance.flag).to be true
+  end
+
+  it "handles nested models" do
+    address = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :city, :string
+      attribute :zip, :string
+    end
+
+    person = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :name, :string
+      attribute :address, address
+    end
+
+    instance = person.new(name: "Alice",
+                          address: address.new(
+                            city: "NYC", zip: "10001",
+                          ))
+    expect(instance.address.city).to eq("NYC")
+  end
+
+  it "handles YAML serialization" do
+    config = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :host, :string
+      attribute :port, :integer
+    end
+
+    instance = config.from_yaml("host: localhost\nport: 8080\n")
+    expect(instance.host).to eq("localhost")
+    expect(instance.port).to eq(8080)
+  end
+
+  it "RuntimeCompatibility detects Opal" do
+    expect(Lutaml::Model::RuntimeCompatibility.opal?).to be true
+  end
+
+  it "AdapterResolver auto-detects REXML" do
+    adapter = Lutaml::Model::AdapterResolver.detect_xml_adapter
+    expect(adapter).to eq(:rexml)
+  end
+end

data/spec/lutaml/model/store_spec.rb

@@ -89,8 +89,8 @@ RSpec.describe Lutaml::Model::Store do
     end
 
     it "registering class B does not iterate class A's indices" do
-      # Build index for model_class
-      model_class.new(id: "x")
+      # 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
@@ -138,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