glossarist 2.8.1 → 2.8.4

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

@@ -1,37 +0,0 @@
-# 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

@@ -1,27 +0,0 @@
-# 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

@@ -1,34 +0,0 @@
-# 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

@@ -1,222 +0,0 @@
-# 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

@@ -1,39 +0,0 @@
-# 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/relationships.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Glossarist
-  module Rdf
-    # Included by RDF view classes that carry variable-predicate relationships.
-    #
-    # Standard SKOS/iso-thes relationships (broader, exactMatch, etc.) and
-    # glossarist-specific relationships (deprecates, compares, etc.) are
-    # emitted as direct triples with the predicate determined at runtime
-    # from REL_PROPERTY_MAP.
-    module Relationships
-      attr_reader :relationship_triples
-
-      def relationship_triples=(pairs)
-        @relationship_triples = Array(pairs)
-      end
-    end
-  end
-end