lutaml-model 0.8.4 → 0.8.5

data/spec/lutaml/turtle/mapping_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/turtle"
+
+RSpec.describe Lutaml::Turtle::Mapping do
+  subject(:mapping) { described_class.new }
+
+  describe "#namespace" do
+    it "builds a NamespaceSet from namespace classes" do
+      mapping.namespace(
+        Lutaml::Rdf::Namespaces::SkosNamespace,
+        Lutaml::Rdf::Namespaces::DctermsNamespace,
+      )
+      expect(mapping.namespace_set.size).to eq(2)
+      expect(mapping.namespace_set["skos"]).to eq(Lutaml::Rdf::Namespaces::SkosNamespace)
+    end
+  end
+
+  describe "#subject" do
+    it "sets subject generator block" do
+      mapping.subject { |obj| "http://example.org/#{obj.name}" }
+      expect(mapping.rdf_subject).to be_a(Proc)
+    end
+  end
+
+  describe "#type" do
+    it "sets RDF type" do
+      mapping.type("skos:Concept")
+      expect(mapping.rdf_type).to eq("skos:Concept")
+    end
+  end
+
+  describe "#predicate" do
+    it "registers MappingRule with namespace reference" do
+      mapping.predicate(
+        :prefLabel,
+        namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+        to: :name,
+      )
+      expect(mapping.rdf_predicates.length).to eq(1)
+      rule = mapping.rdf_predicates.first
+      expect(rule).to be_a(Lutaml::Rdf::MappingRule)
+      expect(rule.predicate_name).to eq("prefLabel")
+      expect(rule.to).to eq(:name)
+      expect(rule.lang_tagged).to be(false)
+    end
+
+    it "registers MappingRule with lang_tagged option" do
+      mapping.predicate(
+        :prefLabel,
+        namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+        to: :name,
+        lang_tagged: true,
+      )
+      expect(mapping.rdf_predicates.first.lang_tagged).to be(true)
+    end
+
+    it "registers multiple predicates" do
+      mapping.predicate(:prefLabel,
+                        namespace: Lutaml::Rdf::Namespaces::SkosNamespace, to: :name)
+      mapping.predicate(:source,
+                        namespace: Lutaml::Rdf::Namespaces::DctermsNamespace, to: :source)
+      expect(mapping.rdf_predicates.length).to eq(2)
+    end
+
+    it "resolves predicate URI" do
+      mapping.predicate(:prefLabel,
+                        namespace: Lutaml::Rdf::Namespaces::SkosNamespace, to: :name)
+      rule = mapping.rdf_predicates.first
+      expect(rule.uri).to eq("http://www.w3.org/2004/02/skos/core#prefLabel")
+    end
+
+    it "produces prefixed name" do
+      mapping.predicate(:prefLabel,
+                        namespace: Lutaml::Rdf::Namespaces::SkosNamespace, to: :name)
+      rule = mapping.rdf_predicates.first
+      expect(rule.prefixed_name).to eq("skos:prefLabel")
+    end
+
+    it "validates namespace is a Rdf::Namespace subclass" do
+      expect do
+        mapping.predicate(:foo, namespace: String, to: :bar)
+      end.to raise_error(ArgumentError, /Rdf::Namespace/)
+    end
+
+    it "validates :to is required" do
+      expect do
+        mapping.predicate(:foo,
+                          namespace: Lutaml::Rdf::Namespaces::SkosNamespace, to: nil)
+      end.to raise_error(ArgumentError, /required/)
+    end
+  end
+
+  describe "#deep_dup" do
+    before do
+      mapping.namespace(
+        Lutaml::Rdf::Namespaces::SkosNamespace,
+        Lutaml::Rdf::Namespaces::DctermsNamespace,
+      )
+      mapping.subject { |m| "http://example.org/#{m.name}" }
+      mapping.type("skos:Concept")
+      mapping.predicate(:prefLabel,
+                        namespace: Lutaml::Rdf::Namespaces::SkosNamespace, to: :name)
+    end
+
+    it "copies all fields" do
+      duped = mapping.deep_dup
+      expect(duped.namespace_set.size).to eq(2)
+      expect(duped.rdf_subject).to be_a(Proc)
+      expect(duped.rdf_type).to eq("skos:Concept")
+      expect(duped.rdf_predicates.length).to eq(1)
+    end
+
+    it "does not share predicate state with original" do
+      duped = mapping.deep_dup
+      duped.predicate(:source,
+                      namespace: Lutaml::Rdf::Namespaces::DctermsNamespace, to: :source)
+      expect(mapping.rdf_predicates.length).to eq(1)
+      expect(duped.rdf_predicates.length).to eq(2)
+    end
+  end
+end

data/spec/lutaml/turtle/transform_spec.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/turtle"
+
+RSpec.describe Lutaml::Turtle::Transform do
+  before do
+    stub_const("TurtleTestModel", Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :description, :string
+      attribute :code, :string
+
+      turtle do
+        namespace Lutaml::Rdf::Namespaces::SkosNamespace,
+                  Lutaml::Rdf::Namespaces::DctermsNamespace
+
+        subject { |m| "http://example.org/concept/#{m.code}" }
+
+        type "skos:Concept"
+
+        predicate :prefLabel,
+                  namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                  to: :name,
+                  lang_tagged: true
+
+        predicate :definition,
+                  namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                  to: :description
+
+        predicate :notation,
+                  namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                  to: :code
+      end
+    end)
+  end
+
+  let(:instance) do
+    TurtleTestModel.new(name: "test concept",
+                        description: "A test description",
+                        code: "2119")
+  end
+
+  describe "model_to_data" do
+    let(:result) { instance.to_turtle }
+
+    it "generates prefix declarations for used namespaces" do
+      expect(result).to include("@prefix skos: <http://www.w3.org/2004/02/skos/core#>")
+    end
+
+    it "generates subject URI" do
+      expect(result).to include("<http://example.org/concept/2119>")
+    end
+
+    it "generates rdf:type triple using compact prefix" do
+      expect(result).to include("a skos:Concept")
+    end
+
+    it "generates predicate triples" do
+      expect(result).to include("skos:notation \"2119\"")
+      expect(result).to include("skos:definition \"A test description\"")
+    end
+
+    it "terminates with a period" do
+      expect(result.strip).to end_with(".")
+    end
+  end
+
+  describe "special character escaping" do
+    let(:instance) do
+      TurtleTestModel.new(name: "has \"quotes\" and\nnewlines",
+                          description: "back\\slash",
+                          code: "1")
+    end
+
+    it "escapes double quotes in literals" do
+      result = instance.to_turtle
+      expect(result).to include('\\"quotes\\"')
+    end
+
+    it "handles multiline literals via triple-quoted strings" do
+      result = instance.to_turtle
+      expect(result).to include("has")
+      expect(result).to include("newlines")
+    end
+
+    it "escapes backslashes in literals" do
+      result = instance.to_turtle
+      expect(result).to include("back\\\\slash")
+    end
+  end
+
+  describe "numeric and boolean values" do
+    before do
+      stub_const("TypedModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :label, :string
+        attribute :count, :integer
+        attribute :active, :boolean
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+
+          subject { |_| "http://example.org/1" }
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :label
+
+          predicate :notation,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :count
+
+          predicate :note,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :active
+        end
+      end)
+    end
+
+    it "serializes integers as native Turtle literals" do
+      instance = TypedModel.new(label: "test", count: 42, active: true)
+      result = instance.to_turtle
+      expect(result).to match(/skos:notation 42/)
+    end
+
+    it "serializes booleans as native Turtle literals" do
+      instance = TypedModel.new(label: "test", count: 1, active: true)
+      result = instance.to_turtle
+      expect(result).to match(/skos:note true/)
+    end
+  end
+
+  describe "model without subject" do
+    before do
+      stub_const("NoSubjectModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+          type "skos:Concept"
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :name
+        end
+      end)
+    end
+
+    it "raises MissingSubjectError" do
+      instance = NoSubjectModel.new(name: "test")
+      expect { instance.to_turtle }
+        .to raise_error(Lutaml::Turtle::MissingSubjectError)
+    end
+  end
+
+  describe "model with nil values" do
+    let(:instance) { TurtleTestModel.new(name: "test", code: "2119") }
+
+    it "omits predicates for nil attributes" do
+      result = instance.to_turtle
+      expect(result).not_to include("definition")
+      expect(result).to include("prefLabel")
+    end
+  end
+
+  describe "model with no predicates producing data" do
+    before do
+      stub_const("EmptyPredModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+
+          subject { |m| "http://example.org/#{m.name}" }
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :name
+        end
+      end)
+    end
+
+    let(:instance) { EmptyPredModel.new(name: nil) }
+
+    it "returns empty string when no data" do
+      expect(instance.to_turtle).to eq("")
+    end
+  end
+
+  describe "collection predicates" do
+    before do
+      stub_const("CollectionModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :labels, :string, collection: true
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+
+          subject { |_| "http://example.org/1" }
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :labels
+        end
+      end)
+    end
+
+    it "generates triples for all collection values" do
+      instance = CollectionModel.new(labels: ["en", "fr"])
+      result = instance.to_turtle
+      expect(result).to include('"en"')
+      expect(result).to include('"fr"')
+      expect(result).to include("skos:prefLabel")
+    end
+  end
+
+  describe "full URI type (no prefix)" do
+    before do
+      stub_const("FullUriTypeModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        turtle do
+          namespace Lutaml::Rdf::Namespaces::SkosNamespace
+
+          subject { |m| "http://example.org/#{m.name}" }
+
+          type "http://example.org/MyType"
+
+          predicate :prefLabel,
+                    namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                    to: :name
+        end
+      end)
+    end
+
+    it "uses full URI as-is when no colon prefix" do
+      instance = FullUriTypeModel.new(name: "test")
+      result = instance.to_turtle
+      expect(result).to include("<http://example.org/MyType>")
+    end
+  end
+
+  describe "data_to_model (deserialization)" do
+    let(:turtle_input) do
+      <<~TURTLE
+        @prefix skos: <http://www.w3.org/2004/02/skos/core#> .
+        @prefix dcterms: <http://purl.org/dc/terms/> .
+
+        <http://example.org/concept/2119> a skos:Concept ;
+          skos:prefLabel "test concept"@en ;
+          skos:definition "A test description" ;
+          skos:notation "2119" .
+      TURTLE
+    end
+
+    it "deserializes string attributes" do
+      model = TurtleTestModel.from_turtle(turtle_input)
+      expect(model.code).to eq("2119")
+      expect(model.description).to eq("A test description")
+    end
+
+    it "deserializes language-tagged values" do
+      model = TurtleTestModel.from_turtle(turtle_input)
+      expect(model.name).to eq("test concept")
+    end
+  end
+
+  describe "round-trip" do
+    it "preserves data through model → Turtle → model" do
+      turtle = instance.to_turtle
+      restored = TurtleTestModel.from_turtle(turtle)
+      expect(restored.code).to eq("2119")
+      expect(restored.description).to eq("A test description")
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.4
+  version: 0.8.5
 platform: ruby
 authors:
 - Ribose Inc.
@@ -198,12 +198,15 @@ files:
 - docs/_guides/creating-xsd.adoc
 - docs/_guides/document-validation.adoc
 - docs/_guides/index.adoc
+- docs/_guides/jsonld-serialization.adoc
 - docs/_guides/keyvalue-serialization.adoc
 - docs/_guides/liquid-templates.adoc
 - docs/_guides/missing-values-handling.adoc
 - docs/_guides/ooxml-examples.adoc
+- docs/_guides/rdf-serialization.adoc
 - docs/_guides/schema-generation.adoc
 - docs/_guides/schema-import.adoc
+- docs/_guides/turtle-serialization.adoc
 - docs/_guides/value-transformations.adoc
 - docs/_guides/xml-mapping.adoc
 - docs/_guides/xml-mappings-guide.adoc
@@ -253,6 +256,7 @@ files:
 - docs/_references/instance-serialization.adoc
 - docs/_references/lutaml-namespace-planning.md
 - docs/_references/parent-root-context.adoc
+- docs/_references/rdf-namespaces.adoc
 - docs/_references/reference_type.adoc
 - docs/_references/serialization-model-mappings.adoc
 - docs/_references/three-phase-namespace-architecture.adoc
@@ -313,6 +317,11 @@ files:
 - lib/lutaml/jsonl/adapter/mapping_rule.rb
 - lib/lutaml/jsonl/adapter/standard_adapter.rb
 - lib/lutaml/jsonl/adapter/transform.rb
+- lib/lutaml/jsonld.rb
+- lib/lutaml/jsonld/adapter.rb
+- lib/lutaml/jsonld/context.rb
+- lib/lutaml/jsonld/term_definition.rb
+- lib/lutaml/jsonld/transform.rb
 - lib/lutaml/key_value.rb
 - lib/lutaml/key_value/adapter.rb
 - lib/lutaml/key_value/adapter/hash.rb
@@ -589,6 +598,24 @@ files:
 - lib/lutaml/model/version.rb
 - lib/lutaml/model/yaml.rb
 - lib/lutaml/model/yamls.rb
+- lib/lutaml/rdf.rb
+- lib/lutaml/rdf/error.rb
+- lib/lutaml/rdf/iri.rb
+- lib/lutaml/rdf/language_tagged.rb
+- lib/lutaml/rdf/literal.rb
+- lib/lutaml/rdf/mapping.rb
+- lib/lutaml/rdf/mapping_rule.rb
+- lib/lutaml/rdf/member_rule.rb
+- lib/lutaml/rdf/namespace.rb
+- lib/lutaml/rdf/namespace_set.rb
+- lib/lutaml/rdf/namespaces.rb
+- lib/lutaml/rdf/namespaces/dcterms_namespace.rb
+- lib/lutaml/rdf/namespaces/owl_namespace.rb
+- lib/lutaml/rdf/namespaces/rdf_namespace.rb
+- lib/lutaml/rdf/namespaces/rdfs_namespace.rb
+- lib/lutaml/rdf/namespaces/skos_namespace.rb
+- lib/lutaml/rdf/namespaces/xsd_namespace.rb
+- lib/lutaml/rdf/transform.rb
 - lib/lutaml/toml.rb
 - lib/lutaml/toml/adapter.rb
 - lib/lutaml/toml/adapter/document.rb
@@ -598,6 +625,10 @@ files:
 - lib/lutaml/toml/adapter/tomlib_adapter.rb
 - lib/lutaml/toml/adapter/transform.rb
 - lib/lutaml/toml/type/serializers.rb
+- lib/lutaml/turtle.rb
+- lib/lutaml/turtle/adapter.rb
+- lib/lutaml/turtle/mapping.rb
+- lib/lutaml/turtle/transform.rb
 - lib/lutaml/xml.rb
 - lib/lutaml/xml/adapter.rb
 - lib/lutaml/xml/adapter/adapter_helpers.rb
@@ -1513,6 +1544,13 @@ files:
 - spec/fixtures/xml/user.xsd
 - spec/fixtures/xml/valid_math_document.xml
 - spec/fixtures/yamls_range_concept.rb
+- spec/lutaml/integration/edge_cases_spec.rb
+- spec/lutaml/integration/multi_format_spec.rb
+- spec/lutaml/integration/round_trip_spec.rb
+- spec/lutaml/jsonld/adapter_spec.rb
+- spec/lutaml/jsonld/context_spec.rb
+- spec/lutaml/jsonld/term_definition_spec.rb
+- spec/lutaml/jsonld/transform_spec.rb
 - spec/lutaml/key_value/transformation/collection_serializer_spec.rb
 - spec/lutaml/key_value/transformation/rule_compiler_spec.rb
 - spec/lutaml/key_value/transformation/value_serializer_spec.rb
@@ -1658,6 +1696,17 @@ files:
 - spec/lutaml/model/yamls_sequence_spec.rb
 - spec/lutaml/model/yamls_spec.rb
 - spec/lutaml/model_spec.rb
+- spec/lutaml/rdf/graph_serialization_spec.rb
+- spec/lutaml/rdf/iri_spec.rb
+- spec/lutaml/rdf/literal_spec.rb
+- spec/lutaml/rdf/mapping_spec.rb
+- spec/lutaml/rdf/member_rule_spec.rb
+- spec/lutaml/rdf/namespace_set_spec.rb
+- spec/lutaml/rdf/namespace_spec.rb
+- spec/lutaml/rdf/rdf_transform_spec.rb
+- spec/lutaml/turtle/adapter_spec.rb
+- spec/lutaml/turtle/mapping_spec.rb
+- spec/lutaml/turtle/transform_spec.rb
 - spec/lutaml/xml/adapter/nokogiri_adapter_spec.rb
 - spec/lutaml/xml/adapter/oga_adapter_spec.rb
 - spec/lutaml/xml/adapter/ox_adapter_spec.rb