glossarist 2.8.1 → 2.8.4

data/lib/glossarist/rdf/namespaces.rb

@@ -3,8 +3,9 @@
 module Glossarist
   module Rdf
     module Namespaces
-      autoload :DctermsNamespace,    "#{__dir__}/namespaces/dcterms_namespace"
-      autoload :GlossaristNamespace, "#{__dir__}/namespaces/glossarist_namespace"
+      autoload :DctermsNamespace, "#{__dir__}/namespaces/dcterms_namespace"
+      autoload :GlossaristNamespace,
+               "#{__dir__}/namespaces/glossarist_namespace"
       autoload :IsoThesNamespace,    "#{__dir__}/namespaces/iso_thes_namespace"
       autoload :OwlNamespace,        "#{__dir__}/namespaces/owl_namespace"
       autoload :RdfNamespace,        "#{__dir__}/namespaces/rdf_namespace"

data/lib/glossarist/rdf/relationship_predicates.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Rdf
+    # Canonical data-driven maps for relationship predicates.
+    #
+    # Each entry maps a relationship type symbol to [namespace_module, predicate_name].
+    # These maps drive:
+    #   1. Attribute declarations in RDF view classes (one typed collection per predicate)
+    #   2. RDF predicate mappings with uri_reference: true
+    #   3. Transform grouping logic in ConceptToGlossTransform
+    module RelationshipPredicates
+      CONCEPT_REL_PREDICATES = {
+        broader: [Namespaces::SkosNamespace, :broader],
+        narrower: [Namespaces::SkosNamespace, :narrower],
+        broader_generic: [Namespaces::IsoThesNamespace, :broaderGeneric],
+        narrower_generic: [Namespaces::IsoThesNamespace, :narrowerGeneric],
+        broader_partitive: [Namespaces::IsoThesNamespace, :broaderPartitive],
+        narrower_partitive: [Namespaces::IsoThesNamespace, :narrowerPartitive],
+        broader_instantial: [Namespaces::IsoThesNamespace, :broaderInstantial],
+        narrower_instantial: [Namespaces::IsoThesNamespace,
+                              :narrowerInstantial],
+        equivalent: [Namespaces::SkosNamespace, :exactMatch],
+        close_match: [Namespaces::SkosNamespace, :closeMatch],
+        broad_match: [Namespaces::SkosNamespace, :broadMatch],
+        narrow_match: [Namespaces::SkosNamespace, :narrowMatch],
+        related_match: [Namespaces::SkosNamespace, :relatedMatch],
+        see: [Namespaces::SkosNamespace, :related],
+        deprecates: [Namespaces::GlossaristNamespace, :deprecates],
+        supersedes: [Namespaces::GlossaristNamespace, :supersedes],
+        superseded_by: [Namespaces::GlossaristNamespace, :supersededBy],
+        compare: [Namespaces::GlossaristNamespace, :compares],
+        contrast: [Namespaces::GlossaristNamespace, :contrasts],
+        sequentially_related_concept: [Namespaces::GlossaristNamespace,
+                                       :sequentiallyRelated],
+        spatially_related_concept: [Namespaces::GlossaristNamespace,
+                                    :spatiallyRelated],
+        temporally_related_concept: [Namespaces::GlossaristNamespace,
+                                     :temporallyRelated],
+        related_concept_broader: [Namespaces::GlossaristNamespace,
+                                  :relatedConceptBroader],
+        related_concept_narrower: [Namespaces::GlossaristNamespace,
+                                   :relatedConceptNarrower],
+      }.freeze
+
+      DESIGNATION_REL_PREDICATES = {
+        homograph: [Namespaces::GlossaristNamespace, :hasHomograph],
+        false_friend: [Namespaces::GlossaristNamespace, :hasFalseFriend],
+        abbreviated_form_for: [Namespaces::GlossaristNamespace,
+                               :abbreviatedFormFor],
+        short_form_for: [Namespaces::GlossaristNamespace, :shortFormFor],
+      }.freeze
+
+      ALL_REL_PREDICATES = CONCEPT_REL_PREDICATES.merge(DESIGNATION_REL_PREDICATES).freeze
+
+      def self.related_targets_by_type(related_concepts, predicate_map)
+        targets = group_targets(related_concepts, predicate_map)
+        predicate_map.each_key.to_h do |type|
+          [:"#{type}_targets", targets[:"#{type}_targets"] || []]
+        end
+      end
+
+      def self.group_targets(related_concepts, predicate_map)
+        valid = valid_related(related_concepts, predicate_map)
+        valid
+          .group_by { |rc| rc.type.to_sym }
+          .transform_values { |rcs| rcs.map { |rc| "concept/#{rc.ref.id}" } }
+          .transform_keys { |type| :"#{type}_targets" }
+      end
+
+      def self.valid_related(related_concepts, predicate_map)
+        Array(related_concepts).select do |rc|
+          rc.ref&.id && predicate_map.key?(rc.type.to_sym)
+        end
+      end
+      private_class_method :group_targets, :valid_related
+    end
+  end
+end

data/lib/glossarist/rdf/v3/configuration.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../../context_configuration"
-
 module Glossarist
   module Rdf
     module V3

data/lib/glossarist/rdf/v3.rb

@@ -1,51 +1,10 @@
 # frozen_string_literal: true
 
-# Load shared infrastructure first
-require_relative "ext"
-require_relative "namespaces"
-require_relative "relationships"
-require_relative "localized_literal"
-
-# V3 Configuration must be loaded before view classes are registered
-require_relative "v3/configuration"
-
-# Load all view class files (must precede V3 constant assignments)
-require_relative "gloss_locality"
-require_relative "gloss_reference"
-require_relative "gloss_concept_source"
-require_relative "gloss_detailed_definition"
-require_relative "gloss_pronunciation"
-require_relative "gloss_grammar_info"
-require_relative "gloss_non_verbal_rep"
-require_relative "gloss_concept_date"
-require_relative "gloss_designation"
-require_relative "gloss_localized_concept"
-require_relative "gloss_concept"
-
 module Glossarist
   module Rdf
-    # V3 is the current (and only) RDF schema version.
-    #
-    # All RDF view classes produce v3 gloss ontology output:
-    # namespace URI: https://www.glossarist.org/ontologies/v3/
-    #
-    # Each version has its own Configuration module with a unique CONTEXT_ID
-    # so that V3 and (future) V4 classes are isolated in separate
-    # Lutaml::Model::GlobalContext registries.
-    #
-    # When v4 is added:
-    #   - Create Rdf::V4::Configuration with CONTEXT_ID = :glossarist_rdf_v4
-    #   - Create V4 view classes (standalone or inheriting from V3)
-    #   - Register V4 classes in Rdf::V4::Configuration
-    #   - Update ConceptToGlossTransform to support v4
-    #   - V3 and V4 coexist — consumers choose which to use
     module V3
-      # Namespace
-      GlossaristNamespace = Namespaces::GlossaristNamespace
+      autoload :Configuration, "glossarist/rdf/v3/configuration"
 
-      # Single source of truth: add new view classes here once.
-      # Each entry is registered in the V3 type registry and
-      # re-exported as a V3:: constant.
       VIEW_CLASS_NAMES = %i[
         GlossLocality
         GlossPronunciation
@@ -70,7 +29,9 @@ module Glossarist
 
       VIEW_CLASS_NAMES.each do |name|
         klass = ::Glossarist::Rdf.const_get(name)
-        registry_id = name.to_s.gsub(/([A-Z])/) { |c| "_#{c.downcase}" }.sub(/^_/, "").to_sym
+        registry_id = name.to_s
+          .gsub(/([A-Z])/) { |c| "_#{c.downcase}" }
+          .sub(/^_/, "").to_sym
         Configuration.register_model(klass, id: registry_id)
         const_set(name, klass)
       end

data/lib/glossarist/rdf.rb

@@ -1,30 +1,33 @@
 # frozen_string_literal: true
 
-# Load lutaml-model RDF extensions before any RDF view classes
-require_relative "rdf/ext"
+require "lutaml/rdf"
+require "lutaml/turtle"
+require "lutaml/jsonld"
 
 module Glossarist
   module Rdf
-    autoload :Namespaces, "#{__dir__}/rdf/namespaces"
-    autoload :LocalizedLiteral, "#{__dir__}/rdf/localized_literal"
-    autoload :Relationships, "#{__dir__}/rdf/relationships"
-    autoload :GlossLocality, "#{__dir__}/rdf/gloss_locality"
-    autoload :GlossCitation, "#{__dir__}/rdf/gloss_citation"
-    autoload :GlossConceptSource, "#{__dir__}/rdf/gloss_concept_source"
-    autoload :GlossDetailedDefinition, "#{__dir__}/rdf/gloss_detailed_definition"
-    autoload :GlossPronunciation, "#{__dir__}/rdf/gloss_pronunciation"
-    autoload :GlossGrammarInfo, "#{__dir__}/rdf/gloss_grammar_info"
-    autoload :GlossNonVerbalRep, "#{__dir__}/rdf/gloss_non_verbal_rep"
-    autoload :GlossConceptReference, "#{__dir__}/rdf/gloss_concept_reference"
-    autoload :GlossConceptDate, "#{__dir__}/rdf/gloss_concept_date"
-    autoload :GlossDesignation, "#{__dir__}/rdf/gloss_designation"
-    autoload :GlossExpression, "#{__dir__}/rdf/gloss_designation"
-    autoload :GlossAbbreviation, "#{__dir__}/rdf/gloss_designation"
-    autoload :GlossSymbol, "#{__dir__}/rdf/gloss_designation"
-    autoload :GlossLetterSymbol, "#{__dir__}/rdf/gloss_designation"
-    autoload :GlossGraphicalSymbol, "#{__dir__}/rdf/gloss_designation"
-    autoload :GlossLocalizedConcept, "#{__dir__}/rdf/gloss_localized_concept"
-    autoload :GlossConcept, "#{__dir__}/rdf/gloss_concept"
-    autoload :GlossDocument, "#{__dir__}/rdf/gloss_concept"
+    autoload :Namespaces,             "#{__dir__}/rdf/namespaces"
+    autoload :LocalizedLiteral,       "#{__dir__}/rdf/localized_literal"
+    autoload :RelationshipPredicates, "#{__dir__}/rdf/relationship_predicates"
+    autoload :GlossLocality,          "#{__dir__}/rdf/gloss_locality"
+    autoload :GlossCitation,          "#{__dir__}/rdf/gloss_citation"
+    autoload :GlossConceptSource,     "#{__dir__}/rdf/gloss_concept_source"
+    autoload :GlossDetailedDefinition,
+             "#{__dir__}/rdf/gloss_detailed_definition"
+    autoload :GlossPronunciation,     "#{__dir__}/rdf/gloss_pronunciation"
+    autoload :GlossGrammarInfo,       "#{__dir__}/rdf/gloss_grammar_info"
+    autoload :GlossNonVerbalRep,      "#{__dir__}/rdf/gloss_non_verbal_rep"
+    autoload :GlossConceptReference,  "#{__dir__}/rdf/gloss_concept_reference"
+    autoload :GlossConceptDate,       "#{__dir__}/rdf/gloss_concept_date"
+    autoload :GlossDesignation,       "#{__dir__}/rdf/gloss_designation"
+    autoload :GlossExpression,        "#{__dir__}/rdf/gloss_designation"
+    autoload :GlossAbbreviation,      "#{__dir__}/rdf/gloss_designation"
+    autoload :GlossSymbol,            "#{__dir__}/rdf/gloss_designation"
+    autoload :GlossLetterSymbol,      "#{__dir__}/rdf/gloss_designation"
+    autoload :GlossGraphicalSymbol,   "#{__dir__}/rdf/gloss_designation"
+    autoload :GlossLocalizedConcept,  "#{__dir__}/rdf/gloss_localized_concept"
+    autoload :GlossConcept,           "#{__dir__}/rdf/gloss_concept"
+    autoload :GlossDocument,          "#{__dir__}/rdf/gloss_concept"
+    autoload :V3,                     "#{__dir__}/rdf/v3"
   end
 end

data/lib/glossarist/register_data.rb

@@ -2,38 +2,88 @@
 
 module Glossarist
   class RegisterData < Lutaml::Model::Serializable
-    attribute :data, :hash, default: -> { {} }
+    attribute :key, :string, default: -> { "register" }
+    attribute :shortname, :string
+    attribute :name, :string
+    attribute :description, :string
+    attribute :schema_version, :string
+    attribute :version, :string
+    attribute :owner, :string
+    attribute :languages, :string, collection: true
+    attribute :subregisters, :hash, default: -> { {} }
+    attribute :uri_prefix, :string
+    attribute :concept_uri_template, :string
+    attribute :homepage, :string
+    attribute :repository, :string
+    attribute :license, :string
+    attribute :tags, :string, collection: true
 
     key_value do
-      map nil, to: :data, with: { from: :data_from, to: :data_to }
-    end
-
-    def self.from_file(path)
-      from_yaml(File.read(path))
-    rescue Errno::ENOENT
-      nil
+      map %i[id shortname], to: :shortname
+      map "name", to: :name
+      map "description", to: :description
+      map "schema_version", to: :schema_version
+      map "version", to: :version
+      map "owner", to: :owner
+      map "languages", to: :languages
+      map "subregisters", to: :subregisters
+      map "uri_prefix", to: :uri_prefix
+      map "concept_uri_template", to: :concept_uri_template
+      map "homepage", to: :homepage
+      map "repository", to: :repository
+      map "license", to: :license
+      map "tags", to: :tags
     end
 
     def [](key)
-      data[key]
+      case key
+      when "shortname", "id" then shortname
+      when "name" then name
+      when "description" then description
+      when "schema_version" then schema_version
+      when "version" then version
+      when "owner" then owner
+      when "languages" then languages
+      when "subregisters" then subregisters
+      when "uri_prefix" then uri_prefix
+      when "concept_uri_template" then concept_uri_template
+      when "homepage" then homepage
+      when "repository" then repository
+      when "license" then license
+      when "tags" then tags
+      end
     end
 
     def dig(*keys)
-      data.dig(*keys)
+      return nil if keys.empty?
+
+      first = self[keys.first]
+      keys.length == 1 ? first : nil
     end
 
     def to_h
-      data
+      h = {}
+      h["shortname"] = shortname if shortname
+      h["name"] = name if name
+      h["description"] = description if description
+      h["schema_version"] = schema_version if schema_version
+      h["version"] = version if version
+      h["owner"] = owner if owner
+      h["languages"] = languages if languages && !languages.empty?
+      h["subregisters"] = subregisters if subregisters && !subregisters.empty?
+      h["uri_prefix"] = uri_prefix if uri_prefix
+      h["concept_uri_template"] = concept_uri_template if concept_uri_template
+      h["homepage"] = homepage if homepage
+      h["repository"] = repository if repository
+      h["license"] = license if license
+      h["tags"] = tags if tags && !tags.empty?
+      h
     end
 
-    def data_from(model, value)
-      model.data = value
-    end
+    def self.from_file(path)
+      return nil unless File.exist?(path)
 
-    def data_to(model, doc)
-      model.data.each do |key, value|
-        doc[key] = value
-      end
+      from_yaml(File.read(path, encoding: "utf-8"))
     end
   end
 end

data/lib/glossarist/schema_migration.rb

@@ -23,7 +23,10 @@ module Glossarist
         end
       end
 
-      raise Error, "Migration chain too long or unresolvable" unless current == target
+      unless current == target
+        raise Error,
+              "Migration chain too long or unresolvable"
+      end
 
       concept.schema_version = target
       concept
@@ -53,8 +56,8 @@ module Glossarist
 
     LANG_CODES = Glossarist::LANG_CODES
 
-    IEV_PATTERN = /\{\{([^,}]+),\s*IEV:([^}]+)\}\}/.freeze
-    URN_PATTERN = /\{urn:iso:std:iso:(\d+):([^,}]+),([^}]+)\}/.freeze
+    IEV_PATTERN = /\{\{([^,}]+),\s*IEV:([^}]+)\}\}/
+    URN_PATTERN = /\{urn:iso:std:iso:(\d+):([^,}]+),([^}]+)\}/
 
     attr_reader :from_version, :to_version
 
@@ -149,7 +152,7 @@ module Glossarist
       src = lc.delete("authoritative_source")
       return if lc.key?("sources")
 
-      sources = (src.is_a?(Array) ? src : [src]).map do |s|
+      sources = (src.is_a?(Array) ? src : [src]).filter_map do |s|
         next unless s.is_a?(Hash)
 
         origin = {}
@@ -166,7 +169,7 @@ module Glossarist
           end
         end
         entry
-      end.compact
+      end
 
       lc["sources"] = sources if sources.any?
     end

data/lib/glossarist/sts/importer.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "tmpdir"
-require_relative "import_result"
 
 module Glossarist
   module Sts

data/lib/glossarist/transforms/concept_to_gloss_transform.rb

@@ -15,36 +15,10 @@ module Glossarist
       DCT    = Rdf::Namespaces::DctermsNamespace.uri
       RDF_NS = Rdf::Namespaces::RdfNamespace.uri
 
-      REL_PROPERTY_MAP = {
-        "broader" => "#{SKOS}broader",
-        "narrower" => "#{SKOS}narrower",
-        "broader_generic" => "#{ISO}broaderGeneric",
-        "narrower_generic" => "#{ISO}narrowerGeneric",
-        "broader_partitive" => "#{ISO}broaderPartitive",
-        "narrower_partitive" => "#{ISO}narrowerPartitive",
-        "broader_instantial" => "#{ISO}broaderInstantial",
-        "narrower_instantial" => "#{ISO}narrowerInstantial",
-        "equivalent" => "#{SKOS}exactMatch",
-        "close_match" => "#{SKOS}closeMatch",
-        "broad_match" => "#{SKOS}broadMatch",
-        "narrow_match" => "#{SKOS}narrowMatch",
-        "related_match" => "#{SKOS}relatedMatch",
-        "see" => "#{SKOS}related",
-        "deprecates" => "#{GLOSS}deprecates",
-        "supersedes" => "#{GLOSS}supersedes",
-        "superseded_by" => "#{GLOSS}supersededBy",
-        "compare" => "#{GLOSS}compares",
-        "contrast" => "#{GLOSS}contrasts",
-        "sequentially_related_concept" => "#{GLOSS}sequentiallyRelated",
-        "spatially_related_concept" => "#{GLOSS}spatiallyRelated",
-        "temporally_related_concept" => "#{GLOSS}temporallyRelated",
-        "homograph" => "#{GLOSS}hasHomograph",
-        "false_friend" => "#{GLOSS}hasFalseFriend",
-        "related_concept_broader" => "#{GLOSS}relatedConceptBroader",
-        "related_concept_narrower" => "#{GLOSS}relatedConceptNarrower",
-        "abbreviated_form_for" => "#{GLOSS}abbreviatedFormFor",
-        "short_form_for" => "#{GLOSS}shortFormFor",
-      }.freeze
+      REL_PROPERTY_MAP = Rdf::RelationshipPredicates::ALL_REL_PREDICATES
+        .transform_values { |ns, name| ns[name] }
+        .transform_keys(&:to_s)
+        .freeze
 
       DATE_TYPE_MAP = {
         "accepted" => "#{GLOSS}status/accepted",
@@ -89,7 +63,9 @@ module Glossarist
 
       def to_jsonld(concepts_or_concept = nil)
         if concepts_or_concept.is_a?(Array)
-          gloss_concepts = concepts_or_concept.map { |c| build_gloss_concept(c) }
+          gloss_concepts = concepts_or_concept.map do |c|
+            build_gloss_concept(c)
+          end
           doc = Rdf::GlossDocument.new(concepts: gloss_concepts)
           Rdf::GlossDocument.to_jsonld(doc)
         else
@@ -112,8 +88,6 @@ module Glossarist
 
       attr_reader :concept, :options
 
-      # ── Build RDF view instances from domain model ─────────────────────
-
       def build_gloss_concept(managed_concept)
         identifier = managed_concept.data&.id || managed_concept.identifier
 
@@ -121,17 +95,21 @@ module Glossarist
           build_gloss_localized_concept(l10n, identifier)
         end
 
-        gc = Rdf::GlossConcept.new(
+        rel_targets = Rdf::RelationshipPredicates.related_targets_by_type(
+          managed_concept.related,
+          Rdf::RelationshipPredicates::CONCEPT_REL_PREDICATES,
+        )
+
+        Rdf::GlossConcept.new(
           identifier: identifier.to_s,
           status: status_uri(managed_concept.status),
           localizations: localizations,
           sources: build_gloss_sources(managed_concept.data&.sources),
-          domains: build_gloss_domains(managed_concept.data&.domains, identifier),
+          domains: build_gloss_domains(managed_concept.data&.domains,
+                                       identifier),
           dates: build_gloss_dates(managed_concept.dates, identifier),
+          **rel_targets,
         )
-
-        gc.relationship_triples = build_relationship_triples(managed_concept.related)
-        gc
       end
 
       def build_gloss_localized_concept(l10n, concept_id)
@@ -146,7 +124,8 @@ module Glossarist
         notes = build_gloss_definitions(data&.notes)
         examples = build_gloss_definitions(data&.examples)
         sources = build_gloss_sources(data&.sources)
-        non_verb_reps = build_gloss_non_verbal_reps(l10n.non_verb_rep, concept_id, lang)
+        non_verb_reps = build_gloss_non_verbal_reps(l10n.non_verb_rep,
+                                                    concept_id, lang)
 
         Rdf::GlossLocalizedConcept.new(
           concept_id: concept_id.to_s,
@@ -168,26 +147,37 @@ module Glossarist
 
       def build_gloss_designation(desig, concept_id, lang, index)
         common_attrs = designation_common_attrs(desig, concept_id, lang, index)
+        instance = designation_instance_for(desig, common_attrs, concept_id,
+                                            lang, index)
 
-        instance = case desig
-                   when Designation::Abbreviation
-                     build_gloss_abbreviation(desig, common_attrs, concept_id, lang, index)
-                   when Designation::Expression
-                     build_gloss_expression(desig, common_attrs, concept_id, lang, index)
-                   when Designation::GraphicalSymbol
-                     Rdf::GlossGraphicalSymbol.new(common_attrs.merge(text: desig.text, image: desig.image))
-                   when Designation::LetterSymbol
-                     Rdf::GlossLetterSymbol.new(common_attrs.merge(text: desig.text))
-                   when Designation::Symbol
-                     Rdf::GlossSymbol.new(common_attrs)
-                   else
-                     Rdf::GlossExpression.new(common_attrs)
-                   end
-
-        instance.relationship_triples = build_relationship_triples(desig.related)
+        rel_targets = Rdf::RelationshipPredicates.related_targets_by_type(
+          desig.related,
+          Rdf::RelationshipPredicates::DESIGNATION_REL_PREDICATES,
+        )
+        rel_targets.each do |attr_name, targets|
+          instance.send(:"#{attr_name}=", targets) unless targets.empty?
+        end
         instance
       end
 
+      def designation_instance_for(desig, common_attrs, concept_id, lang, index)
+        case desig
+        when Designation::Abbreviation
+          build_gloss_abbreviation(desig, common_attrs, concept_id, lang, index)
+        when Designation::Expression
+          build_gloss_expression(desig, common_attrs, concept_id, lang, index)
+        when Designation::GraphicalSymbol
+          Rdf::GlossGraphicalSymbol.new(common_attrs.merge(text: desig.text,
+                                                           image: desig.image))
+        when Designation::LetterSymbol
+          Rdf::GlossLetterSymbol.new(common_attrs.merge(text: desig.text))
+        when Designation::Symbol
+          Rdf::GlossSymbol.new(common_attrs)
+        else
+          Rdf::GlossExpression.new(common_attrs)
+        end
+      end
+
       def designation_common_attrs(desig, concept_id, lang, index)
         norm_status = desig.normative_status
         {
@@ -203,7 +193,8 @@ module Glossarist
           concept_id: concept_id.to_s,
           lang_code: (desig.language || lang).to_s,
           index: index.to_s,
-          pronunciations: build_gloss_pronunciations(desig.pronunciation, concept_id, lang, index),
+          pronunciations: build_gloss_pronunciations(desig.pronunciation,
+                                                     concept_id, lang, index),
           sources: build_gloss_sources(desig.sources),
         }
       end
@@ -216,7 +207,9 @@ module Glossarist
                                      acronym: desig.acronym,
                                      initialism: desig.initialism,
                                      truncation: desig.truncation,
-                                     grammar_info: build_gloss_grammar_infos(desig.grammar_info, concept_id, lang, index),
+                                     grammar_info: build_gloss_grammar_infos(
+                                       desig.grammar_info, concept_id, lang, index
+                                     ),
                                    ))
       end
 
@@ -225,7 +218,9 @@ module Glossarist
                                    prefix: desig.prefix,
                                    usage_info: desig.usage_info,
                                    field_of_application: desig.field_of_application,
-                                   grammar_info: build_gloss_grammar_infos(desig.grammar_info, concept_id, lang, index),
+                                   grammar_info: build_gloss_grammar_infos(
+                                     desig.grammar_info, concept_id, lang, index
+                                   ),
                                  ))
       end
 
@@ -271,7 +266,8 @@ module Glossarist
         )
       end
 
-      def build_gloss_pronunciations(pronunciations, concept_id, lang, _desig_index)
+      def build_gloss_pronunciations(pronunciations, concept_id, lang,
+_desig_index)
         Array(pronunciations).each_with_index.map do |pron, idx|
           Rdf::GlossPronunciation.new(
             content: pron.content,
@@ -286,7 +282,8 @@ module Glossarist
         end
       end
 
-      def build_gloss_grammar_infos(grammar_infos, concept_id, lang, desig_index)
+      def build_gloss_grammar_infos(grammar_infos, concept_id, lang,
+desig_index)
         Array(grammar_infos).map do |gi|
           Rdf::GlossGrammarInfo.new(
             gender: Array(gi.gender).map { |g| "gloss:gender/#{g}" },
@@ -335,18 +332,6 @@ module Glossarist
         end
       end
 
-      def build_relationship_triples(related_concepts)
-        Array(related_concepts).filter_map do |rc|
-          predicate_uri = REL_PROPERTY_MAP[rc.type]
-          next unless predicate_uri
-
-          target_id = rc.ref&.id
-          next unless target_id
-
-          [predicate_uri, "concept/#{target_id}"]
-        end
-      end
-
       def status_uri(status)
         status ? "gloss:status/#{status}" : nil
       end

data/lib/glossarist/v2/concept_data.rb

@@ -37,7 +37,8 @@ module Glossarist
         map :system, to: :system
         map %i[entry_status entryStatus], to: :entry_status
         map %i[review_date reviewDate], to: :review_date
-        map %i[review_decision_date reviewDecisionDate], to: :review_decision_date
+        map %i[review_decision_date reviewDecisionDate],
+            to: :review_decision_date
         map %i[review_decision_event reviewDecisionEvent],
             to: :review_decision_event
       end

data/lib/glossarist/v2/concept_document.rb

@@ -10,7 +10,7 @@ module Glossarist
         sequence do
           map_document 0, to: :concept, type: V2::ManagedConcept
           map_document 1.., to: :localizations, type: V2::LocalizedConcept,
-                                             collection: true
+                            collection: true
         end
       end
     end

data/lib/glossarist/v2/configuration.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../context_configuration"
-
 module Glossarist
   module V2
     module Configuration

data/lib/glossarist/v2/managed_concept_data.rb

@@ -16,6 +16,7 @@ module Glossarist
         map %i[localized_concepts localizedConcepts], to: :localized_concepts
         map %i[domains groups], to: :domains,
                                 with: { from: :domains_from_yaml, to: :domains_to_yaml }
+        map :tags, to: :tags
         map :sources, to: :sources
         map :localizations, to: :localizations,
                             with: { from: :localizations_from_yaml, to: :localizations_to_yaml }