lutaml-model 0.8.10 → 0.8.11

data/lib/lutaml/rdf/mapping.rb

@@ -10,7 +10,7 @@ module Lutaml
         super
         @namespace_set = Lutaml::Rdf::NamespaceSet.new
         @rdf_subject = nil
-        @rdf_type = nil
+        @rdf_type = []
         @rdf_predicates = []
         @rdf_members = []
       end
@@ -24,20 +24,26 @@ module Lutaml
       end
 
       def type(value)
-        @rdf_type = value
+        @rdf_type = Array(value)
       end
 
-      def predicate(name, namespace:, to:, lang_tagged: false)
+      def predicate(name, namespace:, to:, lang_tagged: false,
+                    uri_reference: false)
         @rdf_predicates << Lutaml::Rdf::MappingRule.new(
           name,
           namespace: namespace,
           to: to,
           lang_tagged: lang_tagged,
+          uri_reference: uri_reference,
         )
       end
 
-      def members(attr_name)
-        @rdf_members << Lutaml::Rdf::MemberRule.new(attr_name)
+      def members(attr_name, predicate_name: nil, namespace: nil)
+        @rdf_members << Lutaml::Rdf::MemberRule.new(
+          attr_name,
+          predicate_name: predicate_name,
+          namespace: namespace,
+        )
       end
 
       def mappings(_register_id = nil)
@@ -57,14 +63,14 @@ module Lutaml
       end
 
       def deep_dup
-        self.class.new.tap do |new_mapping|
-          new_mapping.instance_variable_set(:@namespace_set, @namespace_set)
-          new_mapping.instance_variable_set(:@rdf_subject, @rdf_subject)
-          new_mapping.instance_variable_set(:@rdf_type, @rdf_type)
-          new_mapping.instance_variable_set(:@rdf_predicates,
-                                            @rdf_predicates.dup)
-          new_mapping.instance_variable_set(:@rdf_members, @rdf_members.dup)
-        end
+        dup
+      end
+
+      def initialize_copy(source)
+        super
+        @rdf_type = source.rdf_type.dup
+        @rdf_predicates = source.rdf_predicates.dup
+        @rdf_members = source.rdf_members.dup
       end
     end
   end

data/lib/lutaml/rdf/mapping_rule.rb

@@ -3,14 +3,31 @@
 module Lutaml
   module Rdf
     class MappingRule
-      attr_reader :predicate_name, :namespace, :to, :lang_tagged
+      attr_reader :predicate_name, :namespace, :to, :lang_tagged, :uri_reference
 
-      def initialize(predicate_name, namespace:, to:, lang_tagged: false)
+      def initialize(predicate_name, namespace:, to:, lang_tagged: false,
+                     uri_reference: false)
         validate!(predicate_name, namespace, to)
+        if lang_tagged && uri_reference
+          raise ArgumentError,
+                "lang_tagged and uri_reference are mutually exclusive"
+        end
+
         @predicate_name = predicate_name.to_s.freeze
         @namespace = namespace
         @to = to
         @lang_tagged = lang_tagged
+        @uri_reference = uri_reference
+      end
+
+      def kind
+        if uri_reference
+          :uri_reference
+        elsif lang_tagged
+          :lang_tagged
+        else
+          :plain
+        end
       end
 
       def uri

data/lib/lutaml/rdf/member_rule.rb

@@ -3,10 +3,27 @@
 module Lutaml
   module Rdf
     class MemberRule
-      attr_reader :attr_name
+      attr_reader :attr_name, :predicate_name, :namespace
+
+      def initialize(attr_name, predicate_name: nil, namespace: nil)
+        if predicate_name && !namespace
+          raise ArgumentError,
+                "namespace is required when predicate_name is provided"
+        end
 
-      def initialize(attr_name)
         @attr_name = attr_name.to_sym
+        @predicate_name = predicate_name
+        @namespace = namespace
+      end
+
+      def linked?
+        !!@predicate_name
+      end
+
+      def linked_predicate_uri
+        return nil unless linked?
+
+        @namespace[@predicate_name]
       end
     end
   end

data/lib/lutaml/rdf/transform.rb

@@ -3,22 +3,35 @@
 module Lutaml
   module Rdf
     class Transform < Lutaml::Model::Transform
-      protected
-
       def resolve_subject_uri(mapping, instance)
         mapping.rdf_subject&.call(instance)
       end
 
-      def resolve_type_uri(mapping)
-        return unless mapping.rdf_type
+      def resolve_single_type_uri(mapping, type_value)
+        mapping.namespace_set.resolve_compact_iri(type_value)
+      end
+
+      def resolve_type_uris(mapping)
+        return [] unless mapping.rdf_type.any?
+
+        mapping.rdf_type.map { |t| resolve_single_type_uri(mapping, t) }
+      end
+
+      def each_member(instance, member_rule, &)
+        collection = Array(instance.public_send(member_rule.attr_name))
+        collection.each(&)
+      end
 
-        mapping.namespace_set.resolve_compact_iri(mapping.rdf_type)
+      def member_mapping_for(member, format)
+        member.class.mappings[format]
       end
 
-      def resolve_type_compact(mapping)
-        mapping.rdf_type
+      def extract_language(value)
+        value.language_tag if value.is_a?(Lutaml::Rdf::LanguageTagged)
       end
 
+      protected
+
       def build_instance(attrs, options)
         child_register = Lutaml::Model::Register.resolve_for_child(
           model_class, lutaml_register
@@ -27,10 +40,6 @@ module Lutaml
         root_and_parent_assignment(instance, options)
         instance
       end
-
-      def extract_language(value)
-        value.language_tag if value.is_a?(Lutaml::Rdf::LanguageTagged)
-      end
     end
   end
 end

data/lib/lutaml/turtle/transform.rb

@@ -46,56 +46,101 @@ module Lutaml
       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)
+        has_resource_data =
+          mapping.rdf_type.any? ||
+          mapping.rdf_predicates.any? ||
+          mapping.rdf_members.any?(&:linked?)
+
+        if has_resource_data
+          subject_uri = resolve_subject(mapping, instance)
+          build_resource_triples(graph, mapping, instance, subject_uri)
+        end
+
+        build_member_subgraphs(graph, mapping, instance)
+
+        graph
+      end
+
+      def resolve_subject(mapping, instance)
+        if mapping.rdf_subject
+          RDF::URI(resolve_subject_uri(mapping, instance))
+        else
+          RDF::Node.new
+        end
+      end
+
+      def build_resource_triples(graph, mapping, instance, subject_uri)
+        mapping.rdf_type.each do |type_value|
+          type_uri = RDF::URI(resolve_single_type_uri(mapping, type_value))
+          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, mapping.namespace_set)
+            graph << RDF::Statement.new(subject_uri, RDF::URI(rule.uri), object)
           end
+        end
+
+        mapping.rdf_members.each do |member_rule|
+          next unless member_rule.linked?
 
-          mapping.rdf_predicates.each do |rule|
-            value = instance.public_send(rule.to)
-            next if value.nil?
+          each_member(instance, member_rule) do |member|
+            member_mapping = member_mapping_for(member, :turtle)
+            next unless member_mapping
 
-            Array(value).each do |v|
-              object = build_rdf_object(v, rule)
-              graph << RDF::Statement.new(subject_uri, RDF::URI(rule.uri),
-                                          object)
-            end
+            member_subject = RDF::URI(resolve_subject_uri(member_mapping,
+                                                          member))
+            graph << RDF::Statement.new(
+              subject_uri,
+              RDF::URI(member_rule.linked_predicate_uri),
+              member_subject,
+            )
           end
         end
+      end
 
+      def build_member_subgraphs(graph, mapping, instance)
         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]
+          each_member(instance, member_rule) do |member|
+            member_mapping = member_mapping_for(member, :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
+      def build_rdf_object(value, rule, namespace_set)
+        case rule.kind
+        when :uri_reference
+          build_uri_reference_object(value, namespace_set)
+        when :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
+          build_plain_literal(value)
+        end
+      end
+
+      def build_uri_reference_object(value, namespace_set)
+        resolved = if value.to_s.include?(":")
+                     namespace_set.resolve_compact_iri(value.to_s)
+                   else
+                     value.to_s
+                   end
+        RDF::URI.new(resolved)
+      end
+
+      def build_plain_literal(value)
+        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
 
@@ -103,13 +148,12 @@ module Lutaml
         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
+          each_member(instance, member_rule) do |member|
+            member_mapping = member_mapping_for(member, :turtle)
+            next unless member_mapping
 
-          ns_set = ns_set.merge(member_mapping.namespace_set)
+            ns_set = ns_set.merge(member_mapping.namespace_set)
+          end
         end
 
         ns_set.each.with_object({}) do |ns, h|
@@ -119,38 +163,66 @@ module Lutaml
 
       def extract_attributes(graph, mapping)
         attrs = {}
-        type_uri = resolve_type_uri(mapping)
+        type_uris = resolve_type_uris(mapping)
 
-        matching_subjects = find_subjects_by_type(graph, type_uri)
+        matching_subjects = find_subjects_by_types(graph, type_uris)
 
         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
+          attrs["id"] = subject.to_s unless subject.node?
+          extract_predicate_attributes(graph, subject, mapping, attrs)
         end
 
         attrs
       end
 
-      def find_subjects_by_type(graph, type_uri)
-        graph.query([nil, RDF.type, RDF::URI(type_uri)]).map(&:subject).uniq
+      def extract_predicate_attributes(graph, subject, mapping, attrs)
+        mapping.rdf_predicates.each do |rule|
+          stmts = graph.query([subject, RDF::URI(rule.uri), nil])
+          next if stmts.empty?
+
+          values = stmts.map do |s|
+            literal_to_ruby(s.object, rule, mapping.namespace_set)
+          end
+          attrs[rule.to] = values.length == 1 ? values.first : values
+        end
+      end
+
+      def find_subjects_by_types(graph, type_uris)
+        type_uris.flat_map do |type_uri|
+          graph.query([nil, RDF.type, RDF::URI(type_uri)]).map(&:subject).uniq
+        end.uniq
       end
 
-      def literal_to_ruby(rdf_object)
+      def literal_to_ruby(rdf_object, rule, namespace_set)
         case rdf_object
+        when RDF::URI
+          uri_to_ruby(rdf_object, rule, namespace_set)
         when RDF::Literal
+          literal_value_to_ruby(rdf_object, rule)
+        else
+          rdf_object.to_s
+        end
+      end
+
+      def uri_to_ruby(rdf_object, rule, namespace_set)
+        uri_str = rdf_object.to_s
+        if rule.kind == :uri_reference
+          namespace_set.compact(uri_str) || uri_str
+        else
+          uri_str
+        end
+      end
+
+      def literal_value_to_ruby(rdf_object, rule)
+        if rule.kind == :lang_tagged && rdf_object.language
+          rdf_object.value
+        else
           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

data/spec/lutaml/jsonld/transform_spec.rb

@@ -208,4 +208,243 @@ RSpec.describe Lutaml::JsonLd::Transform do
       expect(restored.tags).to eq(["en", "fr"])
     end
   end
+
+  describe "multiple types" do
+    before do
+      stub_const("DctermsTestNs", Class.new(Lutaml::Rdf::Namespace) do
+        uri "http://purl.org/dc/terms/"
+        prefix "dcterms"
+      end)
+
+      stub_const("MultiTypeJsonLdModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        rdf do
+          namespace TestSkosNs, DctermsTestNs
+
+          subject { |m| "http://example.org/#{m.name}" } # rubocop:disable RSpec/NamedSubject
+
+          type ["skos:Concept", "dcterms:Agent"]
+
+          predicate :name, namespace: TestExNs, to: :name
+        end
+      end)
+    end
+
+    it "generates @type as array for multiple types" do
+      instance = MultiTypeJsonLdModel.new(name: "multi")
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed["@type"]).to eq(["skos:Concept", "dcterms:Agent"])
+    end
+
+    it "generates @type as string for single type" do
+      instance = JsonLdTestModel.new(name: "single")
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed["@type"]).to eq("skos:Concept")
+    end
+  end
+
+  describe "URI reference predicates" do
+    before do
+      stub_const("UriRefJsonLdModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :related, :string, collection: true
+
+        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 :related, namespace: TestSkosNs, to: :related,
+                              uri_reference: true
+        end
+      end)
+    end
+
+    it "generates @type @id in context for uri_reference predicates" do
+      instance = UriRefJsonLdModel.new(name: "test", related: ["skos:other"])
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed["@context"]["related"]).to eq({
+                                                    "@id" => "http://www.w3.org/2004/02/skos/core#related",
+                                                    "@type" => "@id",
+                                                  })
+    end
+
+    it "serializes URI reference as @id object" do
+      instance = UriRefJsonLdModel.new(name: "test", related: ["skos:other"])
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed["related"]).to eq([{ "@id" => "skos:other" }])
+    end
+
+    it "serializes single URI reference value as @id object" do
+      stub_const("SingleUriRefModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :link, :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 :related, namespace: TestSkosNs, to: :link,
+                              uri_reference: true
+        end
+      end)
+
+      instance = SingleUriRefModel.new(name: "test", link: "skos:something")
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed["related"]).to eq({ "@id" => "skos:something" })
+    end
+  end
+
+  describe "member linking predicates" do
+    before do
+      stub_const("JsonLdChildModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :cid, :string
+        attribute :label, :string
+
+        rdf do
+          namespace TestSkosNs, TestExNs
+
+          subject { |m| "http://example.org/item/#{m.cid}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          type "skos:Concept"
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :label
+        end
+      end)
+
+      stub_const("JsonLdParentModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :children, JsonLdChildModel, collection: true
+
+        rdf do
+          namespace TestSkosNs, TestExNs
+
+          subject { |m| "http://example.org/group/#{m.name}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          type "skos:Collection"
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :name
+
+          members :children,
+                  predicate_name: :member,
+                  namespace: TestSkosNs
+        end
+      end)
+    end
+
+    it "includes linking term in @context with @type @id" do
+      parent = JsonLdParentModel.new(
+        name: "grp1",
+        children: [JsonLdChildModel.new(cid: "a", label: "Alpha")],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      expect(parsed["@context"]["member"]).to eq({
+                                                   "@id" => "http://www.w3.org/2004/02/skos/core#member",
+                                                   "@type" => "@id",
+                                                 })
+    end
+
+    it "generates @id references for linked members in @graph" do
+      parent = JsonLdParentModel.new(
+        name: "grp1",
+        children: [
+          JsonLdChildModel.new(cid: "a", label: "Alpha"),
+          JsonLdChildModel.new(cid: "b", label: "Beta"),
+        ],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      parent_resource = parsed["@graph"].find { |r| r["@type"] }
+      expect(parent_resource["member"]).to eq([
+                                                { "@id" => "http://example.org/item/a" },
+                                                { "@id" => "http://example.org/item/b" },
+                                              ])
+    end
+
+    it "includes member resources in @graph" do
+      parent = JsonLdParentModel.new(
+        name: "grp1",
+        children: [JsonLdChildModel.new(cid: "a", label: "Alpha")],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      member = parsed["@graph"].find { |r| r["prefLabel"] == "Alpha" }
+      expect(member).not_to be_nil
+      expect(member["@id"]).to eq("http://example.org/item/a")
+    end
+
+    it "merges child namespaces into @context" do
+      parent = JsonLdParentModel.new(
+        name: "grp1",
+        children: [JsonLdChildModel.new(cid: "a", label: "Alpha")],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      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 "omits linking key when members have no linking predicate" do
+      stub_const("UnlinkedChild", Class.new(Lutaml::Model::Serializable) do
+        attribute :label, :string
+
+        rdf do
+          namespace TestSkosNs
+
+          subject { |m| "http://example.org/#{m.label}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :label
+        end
+      end)
+
+      stub_const("UnlinkedParent", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :items, UnlinkedChild, collection: true
+
+        rdf do
+          namespace TestSkosNs
+
+          subject { |m| "http://example.org/#{m.name}" } # rubocop:disable RSpec/NamedSubject, RSpec/MultipleSubjects
+
+          predicate :prefLabel, namespace: TestSkosNs, to: :name
+
+          members :items
+        end
+      end)
+
+      parent = UnlinkedParent.new(
+        name: "grp",
+        items: [UnlinkedChild.new(label: "a")],
+      )
+      parsed = JSON.parse(parent.to_jsonld)
+      expect(parsed["@context"]).not_to have_key("member")
+    end
+  end
+
+  describe "empty type array" do
+    before do
+      stub_const("NoTypeJsonLdModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        rdf do
+          namespace TestExNs
+
+          subject { |m| "http://example.org/#{m.name}" } # rubocop:disable RSpec/NamedSubject
+
+          predicate :name, namespace: TestExNs, to: :name
+        end
+      end)
+    end
+
+    it "omits @type when no types declared" do
+      instance = NoTypeJsonLdModel.new(name: "test")
+      parsed = JSON.parse(instance.to_jsonld)
+      expect(parsed).not_to have_key("@type")
+    end
+  end
 end