glossarist 2.6.5 → 2.6.7

data/lib/glossarist/rdf/ext/jsonld_transform_ext.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require "json"
+
+# Extends Lutaml::JsonLd::Transform to handle:
+# - Multiple rdf:type values
+# - URI-valued predicates (as: :uri)
+# - Linking predicates for members (link option)
+# - Recursive context/namespace collection
+# - Recursive graph document building
+module Lutaml
+  module JsonLd
+    class Transform < Lutaml::Rdf::Transform
+      def model_to_data(instance, _format, options = {})
+        mapping = extract_mapping(options)
+        return {} unless mapping
+
+        if mapping.rdf_members.any?
+          build_graph_document(mapping, instance)
+        else
+          build_resource_object(mapping, instance)
+        end
+      end
+
+      def data_to_model(data, _format, options = {})
+        mapping = extract_mapping(options)
+        return model_class.new unless mapping
+
+        hash = data.is_a?(String) ? JSON.parse(data) : data
+
+        if hash.key?("@graph") && hash["@graph"].is_a?(Array) && !hash["@graph"].empty?
+          graph_data = hash["@graph"]
+          first = graph_data.first
+          hash = first.is_a?(Hash) ? first : {}
+        end
+
+        hash = strip_jsonld_keywords(hash)
+
+        attrs = {}
+        mapping.rdf_predicates.each do |rule|
+          value = hash[rule.predicate_name]
+          next if value.nil?
+
+          attrs[rule.to] = if rule.lang_tagged && value.is_a?(Hash)
+                             flatten_language_map(value)
+                           else
+                             value
+                           end
+        end
+
+        build_instance(attrs, options)
+      end
+
+      private
+
+      def extract_mapping(options)
+        options[:mappings] || mappings_for(:jsonld, lutaml_register)
+      end
+
+      def build_graph_document(mapping, instance)
+        context = build_merged_context_recursive(mapping, instance)
+        graph = collect_resources(mapping, instance)
+
+        { "@context" => context, "@graph" => graph }
+      end
+
+      def collect_resources(mapping, instance)
+        graph = []
+
+        if mapping.rdf_subject
+          resource = build_resource_data(mapping, instance)
+          graph << resource unless resource.empty?
+        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[:jsonld]
+            next unless member_mapping
+
+            resource = build_resource_data(member_mapping, member)
+            graph << resource unless resource.empty?
+
+            # Recurse into child members
+            child_resources = collect_resources(member_mapping, member)
+            # Skip the first entry (already added above) and any empty resources
+            child_resources[1..-1].each { |r| graph << r }
+          end
+        end
+
+        graph
+      end
+
+      def build_merged_context_recursive(mapping, instance)
+        context_hash = build_context_from_mapping(mapping).to_hash
+
+        mapping.rdf_members.each do |member_rule|
+          collection = Array(instance.public_send(member_rule.attr_name))
+          next if collection.empty?
+
+          collection.map(&:class).uniq.each do |klass|
+            member_mapping = klass.mappings[:jsonld]
+            next unless member_mapping
+
+            context_hash.merge!(build_context_from_mapping(member_mapping).to_hash)
+
+            # Recurse into child members
+            child_ctx = build_merged_context_recursive(member_mapping, collection.first)
+            context_hash.merge!(child_ctx)
+          end
+        end
+
+        context_hash
+      end
+
+      def build_context_from_mapping(mapping)
+        context = Context.new
+        mapping.namespace_set.each { |ns| context.prefix(ns) }
+        mapping.rdf_predicates.each do |pred|
+          if pred.lang_tagged
+            context.term(pred.predicate_name,
+                         id: pred.uri,
+                         container: :language)
+          else
+            context.term(pred.predicate_name, id: pred.uri)
+          end
+        end
+        context
+      end
+
+      def build_resource_object(mapping, instance)
+        context = build_context_from_mapping(mapping).to_hash
+        data = build_resource_data(mapping, instance)
+        { "@context" => context }.merge(data)
+      end
+
+      def build_resource_data(mapping, instance)
+        result = {}
+
+        if mapping.rdf_types.any?
+          types = mapping.rdf_types.map do |t|
+            mapping.namespace_set.resolve_compact_iri(t)
+          end
+          result["@type"] = types.length == 1 ? types.first : types
+        end
+
+        if mapping.rdf_subject
+          result["@id"] = resolve_subject_uri(mapping, instance)
+        end
+
+        mapping.rdf_predicates.each do |rule|
+          value = instance.public_send(rule.to)
+          next if value.nil?
+          next if value.is_a?(String) && value.empty?
+
+          result[rule.predicate_name] = if rule.lang_tagged
+                                          build_language_map(value)
+                                        else
+                                          serialize_rdf_value(value, rule, mapping)
+                                        end
+        end
+
+        # Emit variable-predicate relationship triples
+        if instance.is_a?(Glossarist::Rdf::Relationships)
+          Array(instance.relationship_triples).each do |pred_uri, obj_uri|
+            key = pred_uri.split("#").last.split("/").last
+            result[key] = { "@id" => obj_uri }
+          end
+        end
+
+        result
+      end
+
+      def build_language_map(values)
+        case values
+        when Array
+          map = {}
+          values.each do |v|
+            lang = extract_language(v)
+            map[lang] = v.to_s if lang
+          end
+          map.empty? ? nil : map
+        else
+          lang = extract_language(values)
+          lang ? { lang => values.to_s } : values.to_s
+        end
+      end
+
+      def flatten_language_map(lang_map)
+        lang_map.values
+      end
+
+      def serialize_rdf_value(value, rule = nil, mapping = nil)
+        case value
+        when Array then value.map { |v| serialize_rdf_value(v, rule, mapping) }
+        when Integer, Float, TrueClass, FalseClass then value
+        else value.to_s
+        end
+      end
+
+      def strip_jsonld_keywords(data)
+        return data unless data.is_a?(Hash)
+
+        data.reject { |key, _| key.start_with?("@") }
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/ext/mapping_ext.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Extends Lutaml::Rdf::Mapping with support for multiple rdf:type values.
+#
+# Usage in rdf do blocks:
+#   type "gloss:Concept"                    # single type (original API)
+#   types "gloss:Concept", "skos:Concept"   # multiple types (new API)
+module Lutaml
+  module Rdf
+    class Mapping
+      attr_writer :namespace_set, :rdf_subject, :rdf_type, :rdf_predicates,
+                  :rdf_members
+
+      def types(*values)
+        @rdf_types = values.flatten.map(&:to_s)
+      end
+
+      def rdf_types
+        if defined?(@rdf_types) && @rdf_types
+          @rdf_types
+        elsif @rdf_type
+          [@rdf_type.to_s]
+        else
+          []
+        end
+      end
+
+      def rdf_types=(values)
+        @rdf_types = values
+      end
+
+      def has_types_or_predicates?
+        rdf_types.any? || rdf_predicates.any?
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/ext/mapping_rule_ext.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Extends Lutaml::Rdf::MappingRule with `as:` option for URI-valued predicates.
+#
+# Usage:
+#   predicate :hasStatus, namespace: Ns, to: :status, as: :uri
+#   predicate :name, namespace: Ns, to: :name                   # default: :literal
+module Lutaml
+  module Rdf
+    class MappingRule
+      attr_reader :as
+
+      def initialize(predicate_name, namespace:, to:, lang_tagged: false, as: :literal)
+        validate!(predicate_name, namespace, to)
+        @predicate_name = predicate_name.to_s.freeze
+        @namespace = namespace
+        @to = to
+        @lang_tagged = lang_tagged
+        @as = as
+      end
+
+      def uri_value?
+        @as == :uri
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/ext/member_rule_ext.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Extends Lutaml::Rdf::MemberRule with `inline:` and `link:` options.
+#
+# Usage:
+#   members :localizations, link: "gloss:hasLocalization"
+#   members :designations, link: ->(d) { skosxl_predicate_for(d) }
+#   members :definitions, link: "gloss:hasDefinition"
+#   members :sources                                # no linking predicate
+module Lutaml
+  module Rdf
+    class MemberRule
+      attr_reader :attr_name, :inline, :link
+
+      def initialize(attr_name, inline: true, link: nil)
+        @attr_name = attr_name.to_sym
+        @inline = inline
+        @link = link
+      end
+
+      def link_predicate_for(member, mapping)
+        return nil unless @link
+
+        case @link
+        when String
+          mapping.namespace_set.resolve_compact_iri(@link)
+        when Proc
+          uri = @link.call(member)
+          uri.include?(":") ? mapping.namespace_set.resolve_compact_iri(uri) : uri
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/ext/turtle_transform_ext.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require "rdf/turtle"
+
+# Extends Lutaml::Turtle::Transform to handle:
+# - Multiple rdf:type values (types method)
+# - URI-valued predicates (as: :uri)
+# - Reference-only members (inline: false)
+# - Linking predicates for members (link option)
+# - Recursive prefix collection
+# - Polymorphic member collections
+module Lutaml
+  module Turtle
+    class Transform < Lutaml::Rdf::Transform
+      def model_to_data(instance, _format, options = {})
+        mapping = extract_turtle_mapping(options)
+        return "" unless mapping
+
+        if !mapping.rdf_subject && mapping.has_types_or_predicates? && mapping.rdf_members.empty?
+          raise MissingSubjectError,
+                "Turtle mapping requires a subject block"
+        end
+
+        graph = build_graph(mapping, instance)
+        return "" if graph.empty?
+
+        prefixes = collect_all_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 = {})
+        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
+
+        if mapping.has_types_or_predicates?
+          subject_uri = if mapping.rdf_subject
+                          RDF::URI(resolve_subject_uri(mapping, instance))
+                        else
+                          RDF::Node.new
+                        end
+
+          emit_type_statements(graph, subject_uri, mapping)
+          emit_predicate_statements(graph, subject_uri, instance, mapping)
+          emit_member_link_statements(graph, subject_uri, instance, mapping)
+          emit_relationship_statements(graph, subject_uri, instance)
+        end
+
+        emit_child_resources(graph, instance, mapping)
+
+        graph
+      end
+
+      def emit_type_statements(graph, subject_uri, mapping)
+        mapping.rdf_types.each do |type_str|
+          type_uri = RDF::URI(mapping.namespace_set.resolve_compact_iri(type_str))
+          graph << RDF::Statement.new(subject_uri, RDF.type, type_uri)
+        end
+      end
+
+      def emit_predicate_statements(graph, subject_uri, instance, mapping)
+        mapping.rdf_predicates.each do |rule|
+          value = instance.public_send(rule.to)
+          next if value.nil?
+
+          Array(value).each do |v|
+            next if v.is_a?(String) && v.empty?
+
+            object = build_rdf_object(v, rule, mapping)
+            graph << RDF::Statement.new(subject_uri, RDF::URI(rule.uri), object)
+          end
+        end
+      end
+
+      def emit_member_link_statements(graph, subject_uri, instance, mapping)
+        mapping.rdf_members.each do |member_rule|
+          next unless member_rule.link
+
+          collection = Array(instance.public_send(member_rule.attr_name))
+          collection.each do |member|
+            child_mapping = member.class.mappings[:turtle]
+            next unless child_mapping&.rdf_subject
+
+            child_uri = RDF::URI(resolve_subject_uri(child_mapping, member))
+            link_uri = RDF::URI(member_rule.link_predicate_for(member, mapping))
+            next unless link_uri
+
+            graph << RDF::Statement.new(subject_uri, link_uri, child_uri)
+          end
+        end
+      end
+
+      def emit_relationship_statements(graph, subject_uri, instance)
+        return unless instance.is_a?(Glossarist::Rdf::Relationships)
+
+        Array(instance.relationship_triples).each do |pred_uri, obj_uri|
+          graph << RDF::Statement.new(subject_uri, RDF::URI(pred_uri), RDF::URI(obj_uri))
+        end
+      end
+
+      def emit_child_resources(graph, instance, mapping)
+        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
+      end
+
+      def build_rdf_object(value, rule, mapping = nil)
+        if rule.uri_value?
+          resolved = if mapping && value.include?(":")
+                       mapping.namespace_set.resolve_compact_iri(value)
+                     else
+                       value
+                     end
+          RDF::URI(resolved)
+        elsif 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 collect_all_prefixes(mapping, instance)
+        ns_set = collect_namespaces_recursive(mapping, instance)
+        ns_set.each.with_object({}) do |ns, h|
+          h[ns.prefix.to_sym] = ns.uri if ns.prefix && ns.uri
+        end
+      end
+
+      def collect_namespaces_recursive(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?
+
+          collection.map(&:class).uniq.each do |klass|
+            member_mapping = klass.mappings[:turtle]
+            next unless member_mapping
+
+            ns_set = ns_set.merge(member_mapping.namespace_set)
+            # Recurse into child members
+            child_ns = collect_namespaces_recursive(member_mapping, collection.first)
+            ns_set = ns_set.merge(child_ns)
+          end
+        end
+
+        ns_set
+      end
+
+      def extract_attributes(graph, mapping)
+        attrs = {}
+        first_type_uri = mapping.rdf_types.first
+        return attrs unless first_type_uri
+
+        type_uri = RDF::URI(mapping.namespace_set.resolve_compact_iri(first_type_uri))
+        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 do |s|
+              rule.uri_value? ? s.object.to_s : literal_to_ruby(s.object)
+            end
+            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/glossarist/rdf/ext.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "lutaml/turtle"
+require "lutaml/jsonld"
+
+require_relative "ext/mapping_ext"
+require_relative "ext/mapping_rule_ext"
+require_relative "ext/member_rule_ext"
+require_relative "ext/turtle_transform_ext"
+require_relative "ext/jsonld_transform_ext"
+
+# Update Lutaml::Rdf::Mapping#predicate to pass through `as` option.
+# Update Lutaml::Rdf::Mapping#members to pass through `inline` and `link` options.
+Lutaml::Rdf::Mapping.class_eval do
+  def predicate(name, namespace:, to:, lang_tagged: false, as: :literal)
+    @rdf_predicates << Lutaml::Rdf::MappingRule.new(
+      name,
+      namespace: namespace,
+      to: to,
+      lang_tagged: lang_tagged,
+      as: as,
+    )
+  end
+
+  def members(attr_name, inline: true, link: nil)
+    @rdf_members << Lutaml::Rdf::MemberRule.new(attr_name, inline: inline, link: link)
+  end
+
+  def deep_dup
+    self.class.new.tap do |new_mapping|
+      new_mapping.namespace_set = @namespace_set
+      new_mapping.rdf_subject = @rdf_subject
+      new_mapping.rdf_type = @rdf_type
+      new_mapping.rdf_types = @rdf_types&.dup
+      new_mapping.rdf_predicates = @rdf_predicates.dup
+      new_mapping.rdf_members = @rdf_members.dup
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_citation.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    class GlossCitation < Lutaml::Model::Serializable
+      attribute :source, :string
+      attribute :id, :string
+      attribute :version, :string
+      attribute :link, :string
+      attribute :locality, GlossLocality
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |c| "citation/#{GlossCitation.slug(c)}" }
+
+        types "gloss:Citation"
+
+        predicate :citationSource, namespace: Namespaces::GlossaristNamespace, to: :source
+        predicate :citationId, namespace: Namespaces::GlossaristNamespace, to: :id
+        predicate :citationVersion, namespace: Namespaces::GlossaristNamespace, to: :version
+        predicate :citationLink, namespace: Namespaces::GlossaristNamespace, to: :link
+
+        members :locality, link: "gloss:hasLocality"
+      end
+
+      def self.slug(citation)
+        slug = [citation.source, citation.id].compact.join("/")
+        slug = Digest::MD5.hexdigest(citation.source || "")[0..11] if slug.empty?
+        slug
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_concept.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    class GlossConcept < Lutaml::Model::Serializable
+      include Relationships
+
+      attribute :identifier, :string
+      attribute :status, :string
+      attribute :localizations, GlossLocalizedConcept, collection: true
+      attribute :sources, GlossConceptSource, collection: true
+      attribute :domains, GlossConceptReference, collection: true
+      attribute :dates, GlossConceptDate, collection: true
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace,
+                  Namespaces::SkosNamespace,
+                  Namespaces::DctermsNamespace,
+                  Namespaces::SkosxlNamespace,
+                  Namespaces::IsoThesNamespace,
+                  Namespaces::RdfNamespace
+
+        subject { |c| "concept/#{c.identifier}" }
+
+        types "gloss:Concept", "skos:Concept"
+
+        predicate :identifier, namespace: Namespaces::GlossaristNamespace, to: :identifier
+        predicate :hasStatus, namespace: Namespaces::GlossaristNamespace, to: :status, as: :uri
+
+        members :localizations,
+                link: "gloss:hasLocalization"
+        members :sources,
+                link: "gloss:hasSource"
+        members :domains,
+                link: "gloss:hasDomain"
+        members :dates,
+                link: "gloss:hasDate"
+      end
+    end
+
+    class GlossDocument < Lutaml::Model::Serializable
+      attribute :concepts, GlossConcept, collection: true
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace,
+                  Namespaces::SkosNamespace,
+                  Namespaces::DctermsNamespace,
+                  Namespaces::SkosxlNamespace,
+                  Namespaces::IsoThesNamespace,
+                  Namespaces::RdfNamespace
+
+        members :concepts
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_concept_date.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    class GlossConceptDate < Lutaml::Model::Serializable
+      attribute :date_value, :string
+      attribute :date_type, :string
+      attribute :concept_id, :string
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |d| "concept/#{d.concept_id}/date/#{d.date_type}" }
+
+        types "gloss:ConceptDate"
+
+        predicate :dateValue, namespace: Namespaces::GlossaristNamespace, to: :date_value
+        predicate :dateType, namespace: Namespaces::GlossaristNamespace, to: :date_type, as: :uri
+      end
+    end
+  end
+end