lutaml-model 0.8.4 → 0.8.5

data/spec/lutaml/rdf/mapping_spec.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/rdf"
+
+RSpec.describe Lutaml::Rdf::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 "stores subject generator proc" do
+      mapping.subject { |obj| "http://example.org/#{obj.name}" }
+      expect(mapping.rdf_subject).to be_a(Proc)
+    end
+
+    it "returns nil when no subject block given" do
+      expect(mapping.rdf_subject).to be_nil
+    end
+  end
+
+  describe "#type" do
+    it "stores RDF type" do
+      mapping.type("skos:Concept")
+      expect(mapping.rdf_type).to eq("skos:Concept")
+    end
+  end
+
+  describe "#predicate" do
+    it "creates 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 "creates 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)
+      expect(mapping.rdf_predicates.first.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)
+      expect(mapping.rdf_predicates.first.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 "#members" do
+    it "creates MemberRule" do
+      mapping.members(:items)
+      expect(mapping.rdf_members.length).to eq(1)
+      expect(mapping.rdf_members.first.attr_name).to eq(:items)
+    end
+  end
+
+  describe "#mappings" do
+    it "returns the predicate list" do
+      mapping.predicate(:prefLabel,
+                        namespace: Lutaml::Rdf::Namespaces::SkosNamespace, to: :name)
+      mapping.predicate(:definition,
+                        namespace: Lutaml::Rdf::Namespaces::SkosNamespace, to: :desc)
+      expect(mapping.mappings).to eq(mapping.rdf_predicates)
+    end
+  end
+
+  describe "#finalize" do
+    it "is a no-op that accepts a mapper class" do
+      expect { mapping.finalize(String) }.not_to raise_error
+    end
+  end
+
+  describe "#finalized?" do
+    it "returns true" do
+      expect(mapping.finalized?).to be(true)
+    end
+  end
+
+  describe "#map_element" do
+    it "raises IncorrectMappingArgumentsError" do
+      expect do
+        mapping.map_element("name", to: :name)
+      end.to raise_error(Lutaml::Model::IncorrectMappingArgumentsError,
+                         /predicate/)
+    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/rdf/member_rule_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Rdf::MemberRule do
+  describe ".new" do
+    it "stores attr_name as symbol" do
+      rule = described_class.new(:concepts)
+      expect(rule.attr_name).to eq(:concepts)
+    end
+
+    it "converts string attr_name to symbol" do
+      rule = described_class.new("concepts")
+      expect(rule.attr_name).to eq(:concepts)
+    end
+  end
+end

data/spec/lutaml/rdf/namespace_set_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/rdf"
+
+RSpec.describe Lutaml::Rdf::NamespaceSet do
+  subject(:set) do
+    described_class.new(
+      Lutaml::Rdf::Namespaces::SkosNamespace,
+      Lutaml::Rdf::Namespaces::DctermsNamespace,
+    )
+  end
+
+  describe "construction" do
+    it "accepts namespace classes" do
+      expect(set.size).to eq(2)
+    end
+
+    it "is enumerable" do
+      expect(set.map(&:prefix)).to contain_exactly("skos", "dcterms")
+    end
+  end
+
+  describe "#add" do
+    it "adds a namespace" do
+      set.add(Lutaml::Rdf::Namespaces::XsdNamespace)
+      expect(set.size).to eq(3)
+    end
+
+    it "allows adding same class twice" do
+      set.add(Lutaml::Rdf::Namespaces::SkosNamespace)
+      expect(set.size).to eq(2)
+    end
+
+    it "raises on prefix collision with different class" do
+      duplicate = Class.new(Lutaml::Rdf::Namespace)
+      duplicate.uri "http://other.org/"
+      duplicate.prefix "skos"
+      expect { set.add(duplicate) }.to raise_error(ArgumentError, /conflicts/)
+    end
+
+    it "returns self for chaining" do
+      result = set.add(Lutaml::Rdf::Namespaces::XsdNamespace)
+      expect(result).to eq(set)
+    end
+  end
+
+  describe "#[]" do
+    it "looks up by prefix" do
+      expect(set["skos"]).to eq(Lutaml::Rdf::Namespaces::SkosNamespace)
+    end
+
+    it "returns nil for unknown prefix" do
+      expect(set["unknown"]).to be_nil
+    end
+  end
+
+  describe "#resolve_compact_iri" do
+    it "resolves known compact IRI" do
+      expect(set.resolve_compact_iri("skos:Concept"))
+        .to eq("http://www.w3.org/2004/02/skos/core#Concept")
+    end
+
+    it "returns value for unknown prefix" do
+      expect(set.resolve_compact_iri("foo:Bar")).to eq("foo:Bar")
+    end
+
+    it "returns value for no-colon string" do
+      expect(set.resolve_compact_iri("Concept")).to eq("Concept")
+    end
+  end
+
+  describe "#compact" do
+    it "compacts full URI to prefixed form" do
+      expect(set.compact("http://www.w3.org/2004/02/skos/core#Concept"))
+        .to eq("skos:Concept")
+    end
+
+    it "returns nil for unknown URI" do
+      expect(set.compact("http://unknown.org/Thing")).to be_nil
+    end
+  end
+
+  describe "#to_hash" do
+    it "returns prefix => uri mapping" do
+      h = set.to_hash
+      expect(h["skos"]).to eq("http://www.w3.org/2004/02/skos/core#")
+      expect(h["dcterms"]).to eq("http://purl.org/dc/terms/")
+    end
+  end
+
+  describe "#merge" do
+    it "adds namespaces from another set" do
+      other = described_class.new(Lutaml::Rdf::Namespaces::XsdNamespace)
+      result = set.merge(other)
+      expect(result.size).to eq(3)
+      expect(result["xsd"]).to eq(Lutaml::Rdf::Namespaces::XsdNamespace)
+    end
+
+    it "returns self" do
+      other = described_class.new(Lutaml::Rdf::Namespaces::XsdNamespace)
+      expect(set.merge(other)).to equal(set)
+    end
+
+    it "skips duplicate prefixes" do
+      other = described_class.new(Lutaml::Rdf::Namespaces::SkosNamespace)
+      set.merge(other)
+      expect(set.size).to eq(2)
+    end
+
+    it "returns self when merging with itself" do
+      expect(set.merge(set)).to equal(set)
+    end
+  end
+end

data/spec/lutaml/rdf/namespace_spec.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/rdf"
+
+RSpec.describe Lutaml::Rdf::Namespace do
+  describe "base class" do
+    it "stores uri at class level" do
+      ns = Class.new(described_class)
+      ns.uri "http://example.org/ns/"
+      expect(ns.uri).to eq("http://example.org/ns/")
+    end
+
+    it "stores prefix at class level" do
+      ns = Class.new(described_class)
+      ns.prefix "ex"
+      expect(ns.prefix).to eq("ex")
+    end
+
+    it "casts prefix to string" do
+      ns = Class.new(described_class)
+      ns.prefix :ex
+      expect(ns.prefix).to eq("ex")
+    end
+
+    it "freezes uri" do
+      ns = Class.new(described_class)
+      ns.uri "http://example.org/ns/"
+      expect(ns.uri).to be_frozen
+    end
+
+    it "freezes prefix" do
+      ns = Class.new(described_class)
+      ns.prefix "ex"
+      expect(ns.prefix).to be_frozen
+    end
+
+    it "raises FrozenError when uri set twice" do
+      ns = Class.new(described_class)
+      ns.uri "http://first.org/"
+      expect { ns.uri "http://second.org/" }.to raise_error(FrozenError)
+    end
+
+    it "raises FrozenError when prefix set twice" do
+      ns = Class.new(described_class)
+      ns.prefix "a"
+      expect { ns.prefix "b" }.to raise_error(FrozenError)
+    end
+
+    describe "#[]" do
+      it "resolves local name to full URI" do
+        ns = Class.new(described_class)
+        ns.uri "http://example.org/ns/"
+        expect(ns["someName"]).to eq("http://example.org/ns/someName")
+      end
+    end
+
+    describe ".prefixed" do
+      it "resolves local name to compact form" do
+        ns = Class.new(described_class)
+        ns.prefix "ex"
+        expect(ns.prefixed("someName")).to eq("ex:someName")
+      end
+    end
+
+    it "each subclass has independent state" do
+      ns1 = Class.new(described_class)
+      ns1.uri "http://ns1.org/"
+      ns1.prefix "ns1"
+
+      ns2 = Class.new(described_class)
+      ns2.uri "http://ns2.org/"
+      ns2.prefix "ns2"
+
+      expect(ns1.uri).to eq("http://ns1.org/")
+      expect(ns2.uri).to eq("http://ns2.org/")
+      expect(ns1.prefix).to eq("ns1")
+      expect(ns2.prefix).to eq("ns2")
+    end
+
+    describe "equality" do
+      it "equals another namespace class with same uri and prefix" do
+        a = Class.new(described_class)
+        a.uri "http://example.org/"
+        a.prefix "ex"
+
+        b = Class.new(described_class)
+        b.uri "http://example.org/"
+        b.prefix "ex"
+
+        expect(a).to eq(b)
+      end
+
+      it "does not equal with different uri" do
+        a = Class.new(described_class)
+        a.uri "http://a.org/"
+        a.prefix "ex"
+
+        b = Class.new(described_class)
+        b.uri "http://b.org/"
+        b.prefix "ex"
+
+        expect(a).not_to eq(b)
+      end
+    end
+
+    describe "#to_s" do
+      it "includes class name, prefix, and uri" do
+        ns = Class.new(described_class)
+        ns.uri "http://example.org/"
+        ns.prefix "ex"
+        expect(ns.to_s).to include("prefix: \"ex\"")
+        expect(ns.to_s).to include("uri: \"http://example.org/\"")
+      end
+    end
+  end
+
+  describe ".resolve_compact_iri" do
+    let(:namespaces) do
+      [
+        Lutaml::Rdf::Namespaces::SkosNamespace,
+        Lutaml::Rdf::Namespaces::DctermsNamespace,
+      ]
+    end
+
+    it "resolves known prefix to full URI" do
+      expect(described_class.resolve_compact_iri("skos:Concept", namespaces))
+        .to eq("http://www.w3.org/2004/02/skos/core#Concept")
+    end
+
+    it "returns value as-is when prefix is unknown" do
+      expect(described_class.resolve_compact_iri("unknown:Thing", namespaces))
+        .to eq("unknown:Thing")
+    end
+
+    it "returns value as-is when no colon present" do
+      expect(described_class.resolve_compact_iri("Concept", namespaces))
+        .to eq("Concept")
+    end
+  end
+
+  describe "W3C namespace classes" do
+    describe Lutaml::Rdf::Namespaces::SkosNamespace do
+      subject(:ns) { described_class }
+
+      it "has SKOS URI" do
+        expect(ns.uri).to eq("http://www.w3.org/2004/02/skos/core#")
+      end
+
+      it "has skos prefix" do
+        expect(ns.prefix).to eq("skos")
+      end
+
+      it "resolves prefLabel to full URI" do
+        expect(ns["prefLabel"]).to eq("http://www.w3.org/2004/02/skos/core#prefLabel")
+      end
+
+      it "resolves Concept to compact form" do
+        expect(ns.prefixed("Concept")).to eq("skos:Concept")
+      end
+    end
+
+    describe Lutaml::Rdf::Namespaces::DctermsNamespace do
+      subject(:ns) { described_class }
+
+      it "has DCTERMS URI" do
+        expect(ns.uri).to eq("http://purl.org/dc/terms/")
+      end
+
+      it "has dcterms prefix" do
+        expect(ns.prefix).to eq("dcterms")
+      end
+
+      it "resolves source to compact form" do
+        expect(ns.prefixed("source")).to eq("dcterms:source")
+      end
+    end
+
+    describe Lutaml::Rdf::Namespaces::RdfNamespace do
+      subject(:ns) { described_class }
+
+      it "has RDF URI" do
+        expect(ns.uri).to eq("http://www.w3.org/1999/02/22-rdf-syntax-ns#")
+      end
+
+      it "has rdf prefix" do
+        expect(ns.prefix).to eq("rdf")
+      end
+
+      it "resolves type to compact form" do
+        expect(ns.prefixed("type")).to eq("rdf:type")
+      end
+    end
+
+    describe Lutaml::Rdf::Namespaces::RdfSyntaxNamespace do
+      it "is the same class as RdfNamespace alias" do
+        expect(described_class).to eq(Lutaml::Rdf::Namespaces::RdfNamespace)
+      end
+    end
+
+    describe Lutaml::Rdf::Namespaces::RdfsNamespace do
+      subject(:ns) { described_class }
+
+      it "has RDFS URI" do
+        expect(ns.uri).to eq("http://www.w3.org/2000/01/rdf-schema#")
+      end
+
+      it "has rdfs prefix" do
+        expect(ns.prefix).to eq("rdfs")
+      end
+    end
+
+    describe Lutaml::Rdf::Namespaces::OwlNamespace do
+      subject(:ns) { described_class }
+
+      it "has OWL URI" do
+        expect(ns.uri).to eq("http://www.w3.org/2002/07/owl#")
+      end
+
+      it "has owl prefix" do
+        expect(ns.prefix).to eq("owl")
+      end
+    end
+
+    describe Lutaml::Rdf::Namespaces::XsdNamespace do
+      subject(:ns) { described_class }
+
+      it "has XSD URI" do
+        expect(ns.uri).to eq("http://www.w3.org/2001/XMLSchema#")
+      end
+
+      it "has xsd prefix" do
+        expect(ns.prefix).to eq("xsd")
+      end
+
+      it "resolves date to compact form" do
+        expect(ns.prefixed("date")).to eq("xsd:date")
+      end
+    end
+  end
+end

data/spec/lutaml/rdf/rdf_transform_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/rdf"
+
+RSpec.describe Lutaml::Rdf::Transform do
+  let(:transform) { described_class.new(nil) }
+
+  describe "#resolve_subject_uri" do
+    it "returns nil when mapping has no subject" do
+      mapping = Lutaml::Rdf::Mapping.new
+      expect(transform.send(:resolve_subject_uri, mapping, double)).to be_nil
+    end
+
+    it "calls subject proc with instance" do
+      mapping = Lutaml::Rdf::Mapping.new
+      mapping.subject { |i| "http://example.org/#{i}" }
+
+      result = transform.send(:resolve_subject_uri, mapping, "test")
+      expect(result).to eq("http://example.org/test")
+    end
+  end
+
+  describe "#resolve_type_uri" do
+    it "returns nil when mapping has no type" do
+      mapping = Lutaml::Rdf::Mapping.new
+      expect(transform.send(:resolve_type_uri, mapping)).to be_nil
+    end
+
+    it "resolves compact IRI to full URI" do
+      mapping = Lutaml::Rdf::Mapping.new
+      stub_const("TestNs", Class.new(Lutaml::Rdf::Namespace) do
+        uri "http://example.org/"
+        prefix "ex"
+      end)
+      mapping.namespace(TestNs)
+      mapping.type "ex:Thing"
+
+      result = transform.send(:resolve_type_uri, mapping)
+      expect(result).to eq("http://example.org/Thing")
+    end
+  end
+
+  describe "#resolve_type_compact" do
+    it "returns the compact form" do
+      mapping = Lutaml::Rdf::Mapping.new
+      mapping.type "skos:Concept"
+
+      expect(transform.send(:resolve_type_compact,
+                            mapping)).to eq("skos:Concept")
+    end
+  end
+
+  describe "#extract_language" do
+    it "extracts language from LanguageTagged objects" do
+      literal = Lutaml::Rdf::Literal.new("hello", language: "eng")
+      expect(transform.send(:extract_language, literal)).to eq("eng")
+    end
+
+    it "returns nil for plain strings" do
+      expect(transform.send(:extract_language, "hello")).to be_nil
+    end
+
+    it "returns nil for non-LanguageTagged objects" do
+      expect(transform.send(:extract_language, 42)).to be_nil
+    end
+  end
+
+  describe "#build_instance" do
+    it "constructs a model instance with resolved register" do
+      stub_const("BuildTestModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+      end)
+
+      context = BuildTestModel
+      t = described_class.new(context)
+      instance = t.send(:build_instance, { name: "test" }, {})
+      expect(instance).to be_a(BuildTestModel)
+      expect(instance.name).to eq("test")
+    end
+  end
+end

data/spec/lutaml/turtle/adapter_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/turtle"
+
+RSpec.describe Lutaml::Turtle::Adapter do
+  describe ".parse" do
+    it "parses valid Turtle into RDF::Graph" do
+      turtle = <<~TURTLE
+        @prefix skos: <http://www.w3.org/2004/02/skos/core#> .
+        <http://example.org/1> a skos:Concept ;
+          skos:prefLabel "test"@en .
+      TURTLE
+
+      graph = described_class.parse(turtle)
+      expect(graph).to be_a(RDF::Graph)
+      expect(graph.count).to eq(2)
+    end
+
+    it "produces empty graph for invalid Turtle" do
+      # RDF::Turtle::Reader logs errors instead of raising
+      graph = described_class.parse("not valid turtle !!!")
+      expect(graph).to be_a(RDF::Graph)
+      expect(graph.count).to eq(0)
+    end
+  end
+
+  describe "#to_turtle" do
+    it "returns string data as-is" do
+      adapter = described_class.new("some turtle content")
+      expect(adapter.to_turtle).to eq("some turtle content")
+    end
+
+    it "serializes RDF::Enumerable to string" do
+      graph = RDF::Graph.new
+      graph << RDF::Statement.new(
+        RDF::URI("http://example.org/1"),
+        RDF::URI("http://www.w3.org/2004/02/skos/core#prefLabel"),
+        RDF::Literal.new("test"),
+      )
+      adapter = described_class.new(graph)
+      result = adapter.to_turtle
+      expect(result).to include("http://example.org/1")
+      expect(result).to include("test")
+    end
+  end
+end