lutaml-model 0.8.4 → 0.8.5

data/spec/lutaml/jsonld/context_spec.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/jsonld"
+
+RSpec.describe Lutaml::JsonLd::Context do
+  subject(:ctx) { described_class.new }
+
+  describe "empty context" do
+    it "serializes to empty hash" do
+      expect(ctx.to_hash).to eq({})
+    end
+  end
+
+  describe "#prefix" do
+    it "adds namespace prefix from Rdf::Namespace class" do
+      ctx.prefix(Lutaml::Rdf::Namespaces::SkosNamespace)
+      expect(ctx.to_hash).to include("skos" => "http://www.w3.org/2004/02/skos/core#")
+    end
+
+    it "adds multiple prefixes" do
+      ctx.prefix(Lutaml::Rdf::Namespaces::SkosNamespace)
+      ctx.prefix(Lutaml::Rdf::Namespaces::DctermsNamespace)
+      hash = ctx.to_hash
+      expect(hash).to include("skos" => "http://www.w3.org/2004/02/skos/core#")
+      expect(hash).to include("dcterms" => "http://purl.org/dc/terms/")
+    end
+  end
+
+  describe "#vocab" do
+    it "sets @vocab" do
+      ctx.vocab("http://example.org/ns/")
+      expect(ctx.to_hash).to include("@vocab" => "http://example.org/ns/")
+    end
+  end
+
+  describe "#language" do
+    it "sets @language" do
+      ctx.language("en")
+      expect(ctx.to_hash).to include("@language" => "en")
+    end
+  end
+
+  describe "#base" do
+    it "sets @base" do
+      ctx.base("http://example.org/")
+      expect(ctx.to_hash).to include("@base" => "http://example.org/")
+    end
+  end
+
+  describe "#term" do
+    it "adds simple term as name => id" do
+      ctx.term("name", id: "http://example.org/name")
+      expect(ctx.to_hash).to include("name" => "http://example.org/name")
+    end
+
+    it "adds term with type" do
+      ctx.term("date", id: "http://example.org/date", type: "xsd:date")
+      expect(ctx.to_hash).to include("date" => {
+                                       "@id" => "http://example.org/date", "@type" => "xsd:date"
+                                     })
+    end
+
+    it "adds term with container" do
+      ctx.term("labels", id: "http://example.org/labels", container: :language)
+      expect(ctx.to_hash).to include("labels" => {
+                                       "@id" => "http://example.org/labels", "@container" => "@language"
+                                     })
+    end
+
+    it "adds term with reverse" do
+      ctx.term("parent", id: "http://example.org/parent", reverse: true)
+      expect(ctx.to_hash).to include("parent" => {
+                                       "@id" => "http://example.org/parent", "@reverse" => true
+                                     })
+    end
+  end
+
+  describe "#to_hash" do
+    it "serializes complete context" do
+      ctx.prefix(Lutaml::Rdf::Namespaces::SkosNamespace)
+      ctx.vocab("http://example.org/ns/")
+      ctx.term("name", id: "http://example.org/name")
+      hash = ctx.to_hash
+      expect(hash["@vocab"]).to eq("http://example.org/ns/")
+      expect(hash["skos"]).to eq("http://www.w3.org/2004/02/skos/core#")
+      expect(hash["name"]).to eq("http://example.org/name")
+    end
+  end
+
+  describe "#resolve" do
+    before do
+      ctx.prefix(Lutaml::Rdf::Namespaces::SkosNamespace)
+      ctx.vocab("http://example.org/ns/")
+      ctx.term("status", id: "http://example.org/status")
+    end
+
+    it "resolves compact IRI via prefixes" do
+      expect(ctx.resolve("skos:prefLabel")).to eq("http://www.w3.org/2004/02/skos/core#prefLabel")
+    end
+
+    it "resolves via term definitions" do
+      expect(ctx.resolve("status")).to eq("http://example.org/status")
+    end
+
+    it "resolves unprefixed name via @vocab" do
+      expect(ctx.resolve("unknown")).to eq("http://example.org/ns/unknown")
+    end
+
+    it "returns nil for unknown prefix" do
+      expect(ctx.resolve("unknown:something")).to be_nil
+    end
+  end
+end

data/spec/lutaml/jsonld/term_definition_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/jsonld"
+
+RSpec.describe Lutaml::JsonLd::TermDefinition do
+  it "simple term maps to name => id" do
+    td = described_class.new(name: "name", id: "http://example.org/name")
+    expect(td.to_context_hash).to eq("name" => "http://example.org/name")
+  end
+
+  it "term with type includes @type" do
+    td = described_class.new(name: "date", id: "http://example.org/date",
+                             type: "xsd:date")
+    expect(td.to_context_hash).to eq("date" => {
+                                       "@id" => "http://example.org/date", "@type" => "xsd:date"
+                                     })
+  end
+
+  it "term with container includes @container" do
+    td = described_class.new(name: "labels", id: "http://example.org/labels",
+                             container: :language)
+    expect(td.to_context_hash).to eq("labels" => {
+                                       "@id" => "http://example.org/labels", "@container" => "@language"
+                                     })
+  end
+
+  it "term with language includes @language" do
+    td = described_class.new(name: "title", id: "http://example.org/title",
+                             language: "en")
+    expect(td.to_context_hash).to eq("title" => {
+                                       "@id" => "http://example.org/title", "@language" => "en"
+                                     })
+  end
+
+  it "term with reverse includes @reverse" do
+    td = described_class.new(name: "parent", id: "http://example.org/parent",
+                             reverse: true)
+    expect(td.to_context_hash).to eq("parent" => {
+                                       "@id" => "http://example.org/parent", "@reverse" => true
+                                     })
+  end
+
+  it "complex term includes all fields" do
+    td = described_class.new(
+      name: "date",
+      id: "http://example.org/date",
+      type: "xsd:date",
+      container: :set,
+    )
+    hash = td.to_context_hash
+    expect(hash["date"]).to eq({ "@id" => "http://example.org/date",
+                                 "@type" => "xsd:date", "@container" => "@set" })
+  end
+end

data/spec/lutaml/jsonld/transform_spec.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/jsonld"
+
+RSpec.describe Lutaml::JsonLd::Transform do
+  before do
+    stub_const("TestSkosNs", Class.new(Lutaml::Rdf::Namespace) do
+      uri "http://www.w3.org/2004/02/skos/core#"
+      prefix "skos"
+    end)
+
+    stub_const("TestExNs", Class.new(Lutaml::Rdf::Namespace) do
+      uri "http://example.org/"
+      prefix "ex"
+    end)
+    stub_const("JsonLdTestModel", Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :description, :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 :description, namespace: TestExNs, to: :description
+      end
+    end)
+  end
+
+  let(:instance) do
+    JsonLdTestModel.new(name: "test", description: "A test concept")
+  end
+
+  describe "model_to_data" do
+    let(:result) { instance.to_jsonld }
+
+    it "generates @context with namespace prefixes" do
+      parsed = JSON.parse(result)
+      expect(parsed).to have_key("@context")
+      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 "generates @type as compact IRI" do
+      parsed = JSON.parse(result)
+      expect(parsed["@type"]).to eq("skos:Concept")
+    end
+
+    it "generates @id from subject block" do
+      parsed = JSON.parse(result)
+      expect(parsed["@id"]).to eq("http://example.org/test")
+    end
+
+    it "includes predicate data" do
+      parsed = JSON.parse(result)
+      expect(parsed["name"]).to eq("test")
+      expect(parsed["description"]).to eq("A test concept")
+    end
+  end
+
+  describe "model_to_data without type and subject" do
+    before do
+      stub_const("MinimalJsonLdModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :value, :string
+
+        rdf do
+          namespace TestSkosNs
+
+          predicate :notation, namespace: TestSkosNs, to: :value
+        end
+      end)
+    end
+
+    it "omits @type and @id when not defined" do
+      instance = MinimalJsonLdModel.new(value: "x")
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed).not_to have_key("@type")
+      expect(parsed).not_to have_key("@id")
+      expect(parsed["notation"]).to eq("x")
+    end
+  end
+
+  describe "data_to_model" do
+    let(:jsonld_input) do
+      {
+        "@context" => { "ex" => "http://example.org/" },
+        "@type" => "skos:Concept",
+        "@id" => "http://example.org/test",
+        "name" => "from_jsonld",
+        "description" => "Loaded from JSON-LD",
+      }
+    end
+
+    it "parses JSON-LD back to model" do
+      model = JsonLdTestModel.from_jsonld(JSON.generate(jsonld_input))
+      expect(model.name).to eq("from_jsonld")
+      expect(model.description).to eq("Loaded from JSON-LD")
+    end
+
+    it "strips JSON-LD keywords before attribute mapping" do
+      model = JsonLdTestModel.from_jsonld(JSON.generate(jsonld_input))
+      expect(model).to be_a(JsonLdTestModel)
+    end
+  end
+
+  describe "deserialization ignores JSON-LD keywords" do
+    let(:jsonld_input) do
+      {
+        "@context" => { "ex" => "http://example.org/" },
+        "@type" => "skos:Concept",
+        "@id" => "http://example.org/test",
+        "@graph" => [],
+        "name" => "value_only",
+      }
+    end
+
+    it "strips all @-prefixed keys" do
+      model = JsonLdTestModel.from_jsonld(JSON.generate(jsonld_input))
+      expect(model.name).to eq("value_only")
+    end
+  end
+
+  describe "round-trip" do
+    it "preserves data through model → JSON-LD → model" do
+      json = instance.to_jsonld
+      restored = JsonLdTestModel.from_jsonld(json)
+      expect(restored.name).to eq("test")
+      expect(restored.description).to eq("A test concept")
+    end
+
+    it "produces consistent @context through round-trip" do
+      json = instance.to_jsonld
+      parsed = JSON.parse(json)
+      expect(parsed["@context"]["skos"]).to eq("http://www.w3.org/2004/02/skos/core#")
+      expect(parsed["@context"]["ex"]).to eq("http://example.org/")
+    end
+  end
+
+  describe "nil attribute values" do
+    let(:instance) { JsonLdTestModel.new(name: "test", description: nil) }
+
+    it "omits nil values from output" do
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed["name"]).to eq("test")
+      expect(parsed).not_to have_key("description")
+    end
+  end
+
+  describe "model with integer and boolean attributes" do
+    before do
+      stub_const("TypedJsonLdModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :label, :string
+        attribute :count, :integer
+        attribute :active, :boolean
+
+        rdf do
+          namespace TestSkosNs
+
+          subject { |_| "http://example.org/1" } # rubocop:disable RSpec/NamedSubject
+
+          type "skos:Concept"
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :label
+          predicate :notation, namespace: TestSkosNs, to: :count
+          predicate :note, namespace: TestSkosNs, to: :active
+        end
+      end)
+    end
+
+    it "serializes and deserializes typed values" do
+      instance = TypedJsonLdModel.new(label: "test", count: 42, active: true)
+      json = instance.to_jsonld
+      parsed = JSON.parse(json)
+      expect(parsed["notation"]).to eq(42)
+      expect(parsed["note"]).to be(true)
+
+      restored = TypedJsonLdModel.from_jsonld(json)
+      expect(restored.count).to eq(42)
+      expect(restored.active).to be(true)
+    end
+  end
+
+  describe "collection attributes" do
+    before do
+      stub_const("CollectionJsonLdModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :tags, :string, collection: true
+
+        rdf do
+          namespace TestSkosNs
+
+          subject { |_| "http://example.org/1" } # rubocop:disable RSpec/NamedSubject
+
+          type "skos:Concept"
+
+          predicate :notation, namespace: TestSkosNs, to: :tags
+        end
+      end)
+    end
+
+    it "round-trips collection values" do
+      instance = CollectionJsonLdModel.new(tags: ["en", "fr"])
+      json = instance.to_jsonld
+      restored = CollectionJsonLdModel.from_jsonld(json)
+      expect(restored.tags).to eq(["en", "fr"])
+    end
+  end
+end

data/spec/lutaml/rdf/graph_serialization_spec.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/turtle"
+require "lutaml/jsonld"
+
+RSpec.describe "RDF graph-aware serialization" do
+  before do
+    stub_const("GraphTestNs", Class.new(Lutaml::Rdf::Namespace) do
+      uri "http://example.org/"
+      prefix "ex"
+    end)
+
+    stub_const("GraphMemberModel", Class.new(Lutaml::Model::Serializable) do
+      attribute :code, :string
+      attribute :name, :string
+
+      rdf do
+        namespace GraphTestNs
+
+        type "ex:Item"
+        predicate :notation, namespace: GraphTestNs, to: :code
+        predicate :prefLabel, namespace: GraphTestNs, to: :name
+      end
+    end)
+
+    stub_const("GraphContainerModel", Class.new(Lutaml::Model::Serializable) do
+      attribute :id, :string
+      attribute :items, GraphMemberModel, collection: true
+
+      rdf do
+        namespace GraphTestNs
+        subject { |m| "http://example.org/container/#{m.id}" } # rubocop:disable RSpec/NamedSubject
+
+        type "ex:Container"
+        predicate :prefLabel, namespace: GraphTestNs, to: :id
+        members :items
+      end
+    end)
+  end
+
+  let(:first_item) { GraphMemberModel.new(code: "1", name: "First") }
+  let(:second_item) { GraphMemberModel.new(code: "2", name: "Second") }
+  let(:container) do
+    GraphContainerModel.new(id: "test", items: [first_item, second_item])
+  end
+
+  describe "Turtle serialization with members" do
+    subject(:turtle) { container.to_turtle }
+
+    it "includes container triples" do
+      expect(turtle).to include("a ex:Container")
+      expect(turtle).to include("ex:container")
+    end
+
+    it "includes container predicates" do
+      expect(turtle).to include('ex:prefLabel "test"')
+    end
+
+    it "includes all member blank nodes" do
+      expect(turtle.scan("a ex:Item").length).to be >= 2
+    end
+
+    it "includes member types" do
+      expect(turtle.scan("a ex:Item").length).to eq(2)
+    end
+
+    it "includes member predicates" do
+      expect(turtle).to include('ex:notation "1"')
+      expect(turtle).to include('ex:notation "2"')
+      expect(turtle).to include('ex:prefLabel "First"')
+      expect(turtle).to include('ex:prefLabel "Second"')
+    end
+
+    it "shares prefix declarations" do
+      prefix_count = turtle.scan(/@prefix ex:/).length
+      expect(prefix_count).to eq(1)
+    end
+  end
+
+  describe "JSON-LD serialization with members" do
+    subject(:jsonld) { JSON.parse(container.to_jsonld) }
+
+    it "includes @context" do
+      expect(jsonld["@context"]).to include("ex")
+    end
+
+    it "includes @graph array" do
+      expect(jsonld["@graph"]).to be_an(Array)
+      expect(jsonld["@graph"].length).to eq(3) # container + 2 items
+    end
+
+    it "includes container in @graph" do
+      container_data = jsonld["@graph"].find do |r|
+        r["@type"] == "ex:Container"
+      end
+      expect(container_data).not_to be_nil
+      expect(container_data["@id"]).to eq("http://example.org/container/test")
+      expect(container_data["prefLabel"]).to eq("test")
+    end
+
+    it "includes all members in @graph" do
+      items = jsonld["@graph"].select { |r| r["@type"] == "ex:Item" }
+      expect(items.length).to eq(2)
+      codes = items.map { |i| i["notation"] }
+      expect(codes).to contain_exactly("1", "2")
+    end
+  end
+
+  describe "container without subject (member-only)" do
+    before do
+      stub_const("MemberOnlyModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :items, GraphMemberModel, collection: true
+
+        rdf do
+          namespace GraphTestNs
+          members :items
+        end
+      end)
+    end
+
+    let(:model) { MemberOnlyModel.new(items: [first_item, second_item]) }
+
+    it "serializes only member triples to turtle" do
+      turtle = model.to_turtle
+      expect(turtle).to include("a ex:Item")
+      expect(turtle).not_to include("ex:Container")
+    end
+
+    it "serializes only members to jsonld @graph" do
+      jsonld = JSON.parse(model.to_jsonld)
+      expect(jsonld["@graph"].length).to eq(2)
+      items = jsonld["@graph"].select { |r| r["@type"] == "ex:Item" }
+      expect(items.length).to eq(2)
+    end
+  end
+end

data/spec/lutaml/rdf/iri_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/rdf"
+
+RSpec.describe Lutaml::Rdf::Iri do
+  subject(:iri) { described_class.new("http://example.org/ns/Concept") }
+
+  it "stores frozen value" do
+    expect(iri.value).to eq("http://example.org/ns/Concept")
+    expect(iri.value).to be_frozen
+  end
+
+  it "coerces to string" do
+    expect(iri.to_s).to eq("http://example.org/ns/Concept")
+  end
+
+  describe "equality" do
+    it "equals Iri with same value" do
+      other = described_class.new("http://example.org/ns/Concept")
+      expect(iri).to eq(other)
+    end
+
+    it "does not equal Iri with different value" do
+      other = described_class.new("http://other.org/Thing")
+      expect(iri).not_to eq(other)
+    end
+
+    it "has consistent hash" do
+      other = described_class.new("http://example.org/ns/Concept")
+      expect(iri.hash).to eq(other.hash)
+    end
+  end
+
+  describe "comparable" do
+    it "compares by value" do
+      a = described_class.new("http://a.org/")
+      b = described_class.new("http://b.org/")
+      expect(a < b).to be true
+    end
+  end
+
+  describe "#expand" do
+    let(:ns_set) do
+      Lutaml::Rdf::NamespaceSet.new(
+        Lutaml::Rdf::Namespaces::SkosNamespace,
+      )
+    end
+
+    it "expands compact IRI via namespace set" do
+      iri = described_class.new("skos:Concept")
+      expect(iri.expand(ns_set)).to eq("http://www.w3.org/2004/02/skos/core#Concept")
+    end
+  end
+
+  describe "#compact" do
+    let(:ns_set) do
+      Lutaml::Rdf::NamespaceSet.new(
+        Lutaml::Rdf::Namespaces::SkosNamespace,
+      )
+    end
+
+    it "compacts full URI to prefixed form" do
+      iri = described_class.new("http://www.w3.org/2004/02/skos/core#Concept")
+      expect(iri.compact(ns_set)).to eq("skos:Concept")
+    end
+
+    it "returns nil for unknown URI" do
+      iri = described_class.new("http://unknown.org/Thing")
+      expect(iri.compact(ns_set)).to be_nil
+    end
+  end
+end

data/spec/lutaml/rdf/literal_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/rdf"
+
+RSpec.describe Lutaml::Rdf::Literal do
+  describe "plain literal" do
+    subject(:lit) { described_class.new("hello") }
+
+    it "stores value" do
+      expect(lit.value).to eq("hello")
+    end
+
+    it "has no datatype" do
+      expect(lit.datatype).to be_nil
+    end
+
+    it "has no language" do
+      expect(lit.language).to be_nil
+    end
+
+    it "serializes to Turtle" do
+      expect(lit.to_turtle).to eq('"hello"')
+    end
+
+    it "serializes to JSON-LD as plain value" do
+      expect(lit.to_jsonld_term).to eq("hello")
+    end
+  end
+
+  describe "language-tagged literal" do
+    subject(:lit) { described_class.new("hello", language: "en") }
+
+    it "serializes to Turtle with language tag" do
+      expect(lit.to_turtle).to eq('"hello"@en')
+    end
+
+    it "serializes to JSON-LD with @language" do
+      expect(lit.to_jsonld_term).to eq({ "@value" => "hello",
+                                         "@language" => "en" })
+    end
+  end
+
+  describe "typed literal" do
+    subject(:lit) { described_class.new("2024-01-01", datatype: "http://www.w3.org/2001/XMLSchema#date") }
+
+    it "serializes to Turtle with datatype" do
+      expect(lit.to_turtle).to eq('"2024-01-01"^^<http://www.w3.org/2001/XMLSchema#date>')
+    end
+
+    it "serializes to JSON-LD with @type" do
+      expect(lit.to_jsonld_term).to eq({ "@value" => "2024-01-01",
+                                         "@type" => "http://www.w3.org/2001/XMLSchema#date" })
+    end
+  end
+
+  describe "special character escaping" do
+    it "escapes quotes" do
+      lit = described_class.new('has "quotes"')
+      expect(lit.to_turtle).to eq('"has \\"quotes\\""')
+    end
+
+    it "escapes newlines" do
+      lit = described_class.new("line1\nline2")
+      expect(lit.to_turtle).to eq('"line1\\nline2"')
+    end
+
+    it "escapes backslashes" do
+      lit = described_class.new("back\\slash")
+      expect(lit.to_turtle).to eq('"back\\\\slash"')
+    end
+
+    it "escapes tabs" do
+      lit = described_class.new("tab\there")
+      expect(lit.to_turtle).to eq('"tab\\there"')
+    end
+  end
+
+  describe "equality" do
+    it "equals literal with same value, datatype, and language" do
+      a = described_class.new("hello", language: "en")
+      b = described_class.new("hello", language: "en")
+      expect(a).to eq(b)
+    end
+
+    it "does not equal with different language" do
+      a = described_class.new("hello", language: "en")
+      b = described_class.new("hello", language: "fr")
+      expect(a).not_to eq(b)
+    end
+
+    it "does not equal with different datatype" do
+      a = described_class.new("1", datatype: "xsd:integer")
+      b = described_class.new("1", datatype: "xsd:string")
+      expect(a).not_to eq(b)
+    end
+  end
+end