lutaml-model 0.8.4 → 0.8.5

data/lib/lutaml/turtle/transform.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Turtle
+    class MissingSubjectError < Lutaml::Rdf::Error; end
+
+    class Transform < Lutaml::Rdf::Transform
+      def model_to_data(instance, _format, options = {})
+        require "rdf/turtle"
+        mapping = extract_turtle_mapping(options)
+        return "" unless mapping
+
+        if !mapping.rdf_subject && mapping.rdf_predicates.any? && mapping.rdf_members.empty?
+          raise MissingSubjectError,
+                "Turtle mapping requires a subject block"
+        end
+
+        graph = build_graph(mapping, instance)
+        return "" if graph.empty?
+
+        prefixes = build_prefixes(mapping, instance)
+        RDF::Turtle::Writer.buffer(prefixes: prefixes) do |writer|
+          graph.each_statement { |stmt| writer << stmt }
+        end.strip
+      end
+
+      def data_to_model(data, _format, options = {})
+        require "rdf/turtle"
+        mapping = extract_turtle_mapping(options)
+        unless mapping&.rdf_subject
+          raise MissingSubjectError,
+                "Turtle mapping requires a subject block"
+        end
+
+        graph = data.is_a?(RDF::Graph) ? data : Lutaml::Turtle::Adapter.parse(data)
+        attrs = extract_attributes(graph, mapping)
+        build_instance(attrs, options)
+      end
+
+      private
+
+      def extract_turtle_mapping(options)
+        options[:mappings] || mappings_for(:turtle, lutaml_register)
+      end
+
+      def build_graph(mapping, instance)
+        graph = RDF::Graph.new
+
+        has_predicates_or_type = mapping.rdf_type || mapping.rdf_predicates.any?
+
+        if has_predicates_or_type
+          subject_uri = if mapping.rdf_subject
+                          RDF::URI(resolve_subject_uri(mapping, instance))
+                        else
+                          RDF::Node.new
+                        end
+
+          if mapping.rdf_type
+            type_uri = RDF::URI(resolve_type_uri(mapping))
+            graph << RDF::Statement.new(subject_uri, RDF.type, type_uri)
+          end
+
+          mapping.rdf_predicates.each do |rule|
+            value = instance.public_send(rule.to)
+            next if value.nil?
+
+            Array(value).each do |v|
+              object = build_rdf_object(v, rule)
+              graph << RDF::Statement.new(subject_uri, RDF::URI(rule.uri),
+                                          object)
+            end
+          end
+        end
+
+        mapping.rdf_members.each do |member_rule|
+          collection = Array(instance.public_send(member_rule.attr_name))
+          collection.each do |member|
+            member_mapping = member.class.mappings[:turtle]
+            next unless member_mapping
+
+            graph << build_graph(member_mapping, member)
+          end
+        end
+
+        graph
+      end
+
+      def build_rdf_object(value, rule)
+        if rule.lang_tagged
+          lang = extract_language(value)
+          RDF::Literal.new(value.to_s, language: lang)
+        else
+          case value
+          when Integer then RDF::Literal.new(value, datatype: RDF::XSD.integer)
+          when Float then RDF::Literal.new(value, datatype: RDF::XSD.double)
+          when TrueClass, FalseClass then RDF::Literal.new(value, datatype: RDF::XSD.boolean)
+          else RDF::Literal.new(value.to_s)
+          end
+        end
+      end
+
+      def build_prefixes(mapping, instance)
+        ns_set = mapping.namespace_set
+
+        mapping.rdf_members.each do |member_rule|
+          collection = Array(instance.public_send(member_rule.attr_name))
+          next if collection.empty?
+
+          member_mapping = collection.first.class.mappings[:turtle]
+          next unless member_mapping
+
+          ns_set = ns_set.merge(member_mapping.namespace_set)
+        end
+
+        ns_set.each.with_object({}) do |ns, h|
+          h[ns.prefix.to_sym] = ns.uri if ns.prefix && ns.uri
+        end
+      end
+
+      def extract_attributes(graph, mapping)
+        attrs = {}
+        type_uri = resolve_type_uri(mapping)
+
+        matching_subjects = find_subjects_by_type(graph, type_uri)
+
+        matching_subjects.each do |subject|
+          mapping.rdf_predicates.each do |rule|
+            stmts = graph.query([subject, RDF::URI(rule.uri), nil])
+            next if stmts.empty?
+
+            values = stmts.map { |s| literal_to_ruby(s.object) }
+            attrs[rule.to] = values.length == 1 ? values.first : values
+          end
+        end
+
+        attrs
+      end
+
+      def find_subjects_by_type(graph, type_uri)
+        graph.query([nil, RDF.type, RDF::URI(type_uri)]).map(&:subject).uniq
+      end
+
+      def literal_to_ruby(rdf_object)
+        case rdf_object
+        when RDF::Literal
+          case rdf_object.datatype
+          when RDF::XSD.integer then rdf_object.value.to_i
+          when RDF::XSD.double, RDF::XSD.decimal, RDF::XSD.float then rdf_object.value.to_f
+          when RDF::XSD.boolean then rdf_object.value == "true"
+          else rdf_object.value
+          end
+        else
+          rdf_object.to_s
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/turtle.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "model"
+require_relative "rdf"
+
+module Lutaml
+  module Turtle
+    autoload :Mapping, "#{__dir__}/turtle/mapping"
+    autoload :Transform, "#{__dir__}/turtle/transform"
+    autoload :Adapter, "#{__dir__}/turtle/adapter"
+  end
+end
+
+Lutaml::Model::FormatRegistry.register(
+  :turtle,
+  mapping_class: Lutaml::Turtle::Mapping,
+  adapter_class: Lutaml::Turtle::Adapter,
+  transformer: Lutaml::Turtle::Transform,
+  key_value: false,
+  rdf: true,
+  error_types: ["RDF::ReaderError"],
+)

data/spec/lutaml/integration/edge_cases_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/rdf"
+
+RSpec.describe "RDF Namespace edge cases" do
+  describe "Namespace immutability" do
+    it "prevents URI change after initial set" do
+      ns_class = Class.new(Lutaml::Rdf::Namespace)
+      ns_class.uri "http://example.org/"
+      expect { ns_class.uri "http://other.org/" }.to raise_error(FrozenError)
+    end
+
+    it "prevents prefix change after initial set" do
+      ns_class = Class.new(Lutaml::Rdf::Namespace)
+      ns_class.prefix "ex"
+      expect { ns_class.prefix "other" }.to raise_error(FrozenError)
+    end
+  end
+
+  describe "NamespaceSet collision detection" do
+    it "raises when adding two different classes with same prefix" do
+      ns1 = Class.new(Lutaml::Rdf::Namespace)
+      ns1.uri "http://one.org/"
+      ns1.prefix "ex"
+
+      ns2 = Class.new(Lutaml::Rdf::Namespace)
+      ns2.uri "http://two.org/"
+      ns2.prefix "ex"
+
+      set = Lutaml::Rdf::NamespaceSet.new(ns1)
+      expect { set.add(ns2) }.to raise_error(ArgumentError, /conflicts/)
+    end
+
+    it "allows adding the same class twice" do
+      ns = Class.new(Lutaml::Rdf::Namespace)
+      ns.uri "http://example.org/"
+      ns.prefix "ex"
+
+      set = Lutaml::Rdf::NamespaceSet.new(ns)
+      expect { set.add(ns) }.not_to raise_error
+      expect(set.size).to eq(1)
+    end
+  end
+
+  describe "NamespaceSet edge cases" do
+    it "returns nil for unknown prefix lookup" do
+      set = Lutaml::Rdf::NamespaceSet.new
+      expect(set["unknown"]).to be_nil
+    end
+
+    it "returns nil for unknown URI compaction" do
+      set = Lutaml::Rdf::NamespaceSet.new
+      expect(set.compact("http://unknown.org/thing")).to be_nil
+    end
+
+    it "handles empty namespace set" do
+      set = Lutaml::Rdf::NamespaceSet.new
+      expect(set.size).to eq(0)
+      expect(set.empty?).to be(true)
+      expect(set.to_a).to eq([])
+      expect(set.to_hash).to eq({})
+    end
+
+    it "returns value as-is when no colon in compact IRI" do
+      set = Lutaml::Rdf::NamespaceSet.new
+      expect(set.resolve_compact_iri("plain_name")).to eq("plain_name")
+    end
+  end
+
+  describe "Iri value object edge cases" do
+    it "stores frozen string value" do
+      iri = Lutaml::Rdf::Iri.new("http://example.org/")
+      expect(iri.value).to be_frozen
+    end
+
+    it "compares with Comparable" do
+      a = Lutaml::Rdf::Iri.new("http://a.org/")
+      b = Lutaml::Rdf::Iri.new("http://b.org/")
+      expect(a < b).to be(true)
+      expect(b < a).to be(false)
+    end
+
+    it "returns nil compact when no namespace matches" do
+      iri = Lutaml::Rdf::Iri.new("http://unknown.org/thing")
+      set = Lutaml::Rdf::NamespaceSet.new
+      expect(iri.compact(set)).to be_nil
+    end
+  end
+
+  describe "Literal value object edge cases" do
+    it "plain literal has no datatype or language" do
+      lit = Lutaml::Rdf::Literal.new("hello")
+      expect(lit.datatype).to be_nil
+      expect(lit.language).to be_nil
+    end
+
+    it "handles empty string value" do
+      lit = Lutaml::Rdf::Literal.new("")
+      expect(lit.to_turtle).to eq('""')
+      expect(lit.to_jsonld_term).to eq("")
+    end
+
+    it "escapes tabs in Turtle output" do
+      lit = Lutaml::Rdf::Literal.new("tab\there")
+      expect(lit.to_turtle).to include("\\t")
+    end
+  end
+end

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