lutaml-model 0.8.4 → 0.8.6

data/spec/lutaml/integration/round_trip_spec.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/turtle"
+require "lutaml/jsonld"
+
+RSpec.describe "Round-trip fidelity" 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)
+  end
+
+  describe "Turtle round-trip" do
+    before do
+      stub_const("RtTurtleModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :label, :string
+        attribute :note, :string
+        attribute :code, :integer
+
+        turtle do
+          namespace TestSkosNs
+
+          subject { |m| "http://example.org/item/#{m.code}" } # rubocop:disable RSpec/NamedSubject
+
+          type "skos:Concept"
+          predicate :prefLabel,
+                    namespace: TestSkosNs,
+                    to: :label
+          predicate :note,
+                    namespace: TestSkosNs,
+                    to: :note
+          predicate :notation,
+                    namespace: TestSkosNs,
+                    to: :code
+        end
+      end)
+    end
+
+    it "preserves string and integer attributes" do
+      original = RtTurtleModel.new(label: "hello", note: "world", code: 99)
+      turtle = original.to_turtle
+      restored = RtTurtleModel.from_turtle(turtle)
+      expect(restored.label).to eq("hello")
+      expect(restored.note).to eq("world")
+      expect(restored.code).to eq(99)
+    end
+
+    it "handles special characters in string values" do
+      original = RtTurtleModel.new(label: 'say "hi"', note: "line1\nline2",
+                                   code: 1)
+      turtle = original.to_turtle
+      restored = RtTurtleModel.from_turtle(turtle)
+      expect(restored.label).to eq('say "hi"')
+      expect(restored.note).to eq("line1\nline2")
+    end
+
+    it "handles nil optional attributes" do
+      original = RtTurtleModel.new(label: "test", note: nil, code: 1)
+      turtle = original.to_turtle
+      restored = RtTurtleModel.from_turtle(turtle)
+      expect(restored.label).to eq("test")
+      expect(restored.note).to be_nil
+      expect(restored.code).to eq(1)
+    end
+  end
+
+  describe "JSON-LD round-trip" do
+    before do
+      stub_const("RtJsonLdModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :title, :string
+        attribute :body, :string
+        attribute :priority, :integer
+
+        rdf do
+          namespace TestExNs
+
+          subject { |m| "http://example.org/articles/#{m.priority}" } # rubocop:disable RSpec/NamedSubject
+
+          type "http://example.org/Article"
+
+          predicate :title, namespace: TestExNs, to: :title
+          predicate :body, namespace: TestExNs, to: :body
+          predicate :priority, namespace: TestExNs, to: :priority
+        end
+      end)
+    end
+
+    it "preserves all attributes through serialize → deserialize" do
+      original = RtJsonLdModel.new(title: "Test", body: "Content", priority: 5)
+      json = original.to_jsonld
+      restored = RtJsonLdModel.from_jsonld(json)
+      expect(restored.title).to eq("Test")
+      expect(restored.body).to eq("Content")
+      expect(restored.priority).to eq(5)
+    end
+
+    it "preserves @context structure across round-trip" do
+      original = RtJsonLdModel.new(title: "Test", body: "Content", priority: 1)
+      json1 = original.to_jsonld
+      restored = RtJsonLdModel.from_jsonld(json1)
+      json2 = restored.to_jsonld
+
+      ctx1 = JSON.parse(json1)["@context"]
+      ctx2 = JSON.parse(json2)["@context"]
+      expect(ctx1).to eq(ctx2)
+    end
+
+    it "handles nil optional attributes" do
+      original = RtJsonLdModel.new(title: "Test", body: nil, priority: 1)
+      json = original.to_jsonld
+      restored = RtJsonLdModel.from_jsonld(json)
+      expect(restored.title).to eq("Test")
+      expect(restored.body).to be_nil
+    end
+  end
+
+  describe "Error handling" do
+    it "Turtle raises MissingSubjectError without subject" do
+      stub_const("NoSubjModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        turtle do
+          namespace TestSkosNs
+          type "skos:Concept"
+          predicate :prefLabel,
+                    namespace: TestSkosNs,
+                    to: :name
+        end
+      end)
+
+      expect { NoSubjModel.new(name: "test").to_turtle }
+        .to raise_error(Lutaml::Turtle::MissingSubjectError, /subject/)
+    end
+
+    it "JSON-LD handles invalid JSON gracefully" do
+      stub_const("SimpleJsonLdModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        rdf do
+          namespace TestExNs
+          predicate :name, namespace: TestExNs, to: :name
+        end
+      end)
+
+      expect { SimpleJsonLdModel.from_jsonld("not valid json!!!") }
+        .to raise_error(Lutaml::Model::InvalidFormatError)
+    end
+
+    it "Rdf::MappingRule validates namespace type" do
+      mapping = Lutaml::Rdf::Mapping.new
+      expect do
+        mapping.predicate(:foo, namespace: String, to: :bar)
+      end.to raise_error(ArgumentError, /Rdf::Namespace/)
+    end
+
+    it "Rdf::MappingRule requires :to parameter" do
+      mapping = Lutaml::Rdf::Mapping.new
+      expect do
+        mapping.predicate(:foo, namespace: TestSkosNs, to: nil)
+      end.to raise_error(ArgumentError, /required/)
+    end
+  end
+end

data/spec/lutaml/jsonld/adapter_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/jsonld"
+
+RSpec.describe Lutaml::JsonLd::Adapter do
+  let(:jsonld_hash) do
+    {
+      "@context" => { "name" => "http://example.org/name" },
+      "@type" => "Thing",
+      "name" => "test",
+    }
+  end
+
+  describe ".parse" do
+    it "parses valid JSON-LD string to hash" do
+      json = JSON.generate(jsonld_hash)
+      result = described_class.parse(json)
+      expect(result).to eq(jsonld_hash.transform_keys(&:to_s))
+    end
+  end
+
+  describe "#to_jsonld" do
+    it "generates JSON-LD string from hash" do
+      adapter = described_class.new(jsonld_hash)
+      result = adapter.to_jsonld
+      parsed = JSON.parse(result)
+      expect(parsed["@context"]).to eq({ "name" => "http://example.org/name" })
+    end
+
+    it "supports pretty generation" do
+      adapter = described_class.new(jsonld_hash)
+      result = adapter.to_jsonld(pretty: true)
+      expect(result).to include("\n")
+    end
+  end
+
+  it "round-trips parse → generate" do
+    json = JSON.generate(jsonld_hash)
+    parsed = described_class.parse(json)
+    adapter = described_class.new(parsed)
+    result = adapter.to_jsonld
+    round_tripped = JSON.parse(result)
+    expect(round_tripped).to eq(jsonld_hash.transform_keys(&:to_s))
+  end
+end

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