lutaml-model 0.8.3 → 0.8.5

data/spec/lutaml/integration/multi_format_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/turtle"
+require "lutaml/jsonld"
+
+RSpec.describe "Multi-format model" 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("MultiFormatModel", Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :description, :string
+      attribute :code, :string
+
+      json do
+        map "name", to: :name
+        map "description", to: :description
+        map "code", to: :code
+      end
+
+      rdf do
+        namespace TestSkosNs
+
+        subject { |m| "http://example.org/concept/#{m.code}" } # rubocop:disable RSpec/NamedSubject
+
+        type "skos:Concept"
+
+        predicate :prefLabel, namespace: TestSkosNs, to: :name
+        predicate :definition, namespace: TestSkosNs, to: :description
+        predicate :notation, namespace: TestSkosNs, to: :code
+      end
+    end)
+  end
+
+  let(:instance) do
+    MultiFormatModel.new(name: "test", description: "desc", code: "42")
+  end
+
+  describe "JSON format" do
+    it "serializes without @context" do
+      json = instance.to_json
+      parsed = JSON.parse(json)
+      expect(parsed).not_to have_key("@context")
+      expect(parsed["name"]).to eq("test")
+      expect(parsed["code"]).to eq("42")
+    end
+
+    it "round-trips" do
+      restored = MultiFormatModel.from_json(instance.to_json)
+      expect(restored.name).to eq("test")
+      expect(restored.code).to eq("42")
+    end
+  end
+
+  describe "JSON-LD format" do
+    it "serializes with @type and @id" do
+      jsonld = instance.to_jsonld
+      parsed = JSON.parse(jsonld)
+      expect(parsed["@type"]).to eq("skos:Concept")
+      expect(parsed["@id"]).to eq("http://example.org/concept/42")
+      expect(parsed["prefLabel"]).to eq("test")
+    end
+
+    it "round-trips" do
+      restored = MultiFormatModel.from_jsonld(instance.to_jsonld)
+      expect(restored.name).to eq("test")
+      expect(restored.code).to eq("42")
+    end
+  end
+
+  describe "Turtle format" do
+    it "serializes with prefixes and type" do
+      turtle = instance.to_turtle
+      expect(turtle).to include("@prefix skos:")
+      expect(turtle).to include("a skos:Concept")
+      expect(turtle).to include("<http://example.org/concept/42>")
+      expect(turtle).to include("skos:prefLabel \"test\"")
+    end
+
+    it "round-trips" do
+      restored = MultiFormatModel.from_turtle(instance.to_turtle)
+      expect(restored.name).to eq("test")
+      expect(restored.code).to eq("42")
+    end
+  end
+
+  describe "cross-format independence" do
+    it "JSON serialization does not affect JSON-LD" do
+      json_parsed = JSON.parse(instance.to_json)
+      jsonld_parsed = JSON.parse(instance.to_jsonld)
+      expect(json_parsed).not_to have_key("@type")
+      expect(jsonld_parsed).to have_key("@type")
+    end
+
+    it "JSON-LD serialization does not affect Turtle" do
+      instance.to_jsonld
+      turtle = instance.to_turtle
+      expect(turtle).not_to include("@context")
+      expect(turtle).to include("@prefix")
+    end
+  end
+end

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