glossarist 2.8.1 → 2.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9161012e7bc694c31f1450dfdc28538de9b559c4ca3cbf6fd7aad8427976d44
-  data.tar.gz: 465de2a3598f6a21fa007068b7fb4b282bd8e917fdb9e226636830bd24fc88ef
+  metadata.gz: f602beb2e985225705695343d1309f242117b6b59398f27b9b7d4966e2300c98
+  data.tar.gz: e5891cad0fd4efecac7140d007f36efe0a2f83609013a771ac02621199ba0306
 SHA512:
-  metadata.gz: db1a01d3b4c1da4ec1e1ea9c15c976c0c11aaa1c53e7ac38ec2d6d3a87d6c2b23c26ac0606f16aba395e01bb7ada4c32401436af23cae94081582bc19aa155f1
-  data.tar.gz: 4471a27273205c88f7f8f0eaa397a351ef23a9d5abc53c397665ac3d8a1f9321b29b289d5151da380bb742e217c0739595f34aff15b13fe4f0cb905c6f5dffb6
+  metadata.gz: 97a81b187d34665f43c2800b3ac7636de9ae71b83c832bb9fdba0f5d9895089f6c3229ba80d38b3e9b0479ab71f16bf282b924c4ee1f9292059c250ade950cfe
+  data.tar.gz: 5d5c43b11134a5f072d80d99c5110471dae8145a4c3212aa9cce49ac1c491fd478f748cd4f57adf97a5c3212a41c7ca679c31a07b6018cda6ecf77cdef3fff64

data/.rubocop.yml

@@ -8,4 +8,4 @@ inherit_from:
 # ...
 
 AllCops:
-  TargetRubyVersion: 2.5
+  TargetRubyVersion: 3.1

data/CLAUDE.md

@@ -24,7 +24,7 @@ All model classes use `Lutaml::Model::Serializable` for serialization.
 - **`Concept`** (`concept.rb`) — base concept with `ConceptData` (definition, terms/designations, notes, examples, sources, dates, language_code). Parent of `LocalizedConcept`.
 - **`LocalizedConcept`** (`localized_concept.rb`) — extends `Concept` with `classification`, `entry_status`, `review_type`.
 - **`ConceptData`** (`concept_data.rb`) — the data payload inside `Concept`: definition, terms, examples, notes, sources, non_verb_rep (collection of `NonVerbRep` resource references), language_code (ISO 639), script (ISO 15924), system (ISO 24229 conversion system code). Uses `DetailedDefinition` collections for definition/examples/notes.
-- **`ManagedConceptData`** (`managed_concept_data.rb`) — the data payload inside `ManagedConcept`: id, localized_concepts hash (lang_code => uuid), domains (ConceptReference collection — upper concept references replacing the old `groups` string array), sources.
+- **`ManagedConceptData`** (`managed_concept_data.rb`) — the data payload inside `ManagedConcept`: id, localized_concepts hash (lang_code => uuid), domains (ConceptReference collection — terminological domain references), tags (string collection — organizational tags for grouping/filtering, not rendered as domains), sources.
 
 ### NonVerbRep (Resource Reference)
 

data/Gemfile

@@ -5,7 +5,6 @@ source "https://rubygems.org"
 gemspec
 
 gem "canon"
-gem "lutaml-model", "~> 0.8.0"
 gem "nokogiri"
 gem "rake", "~> 13.0"
 gem "relaton", "~> 2.1.0"

data/README.adoc

@@ -101,7 +101,8 @@ related:: Array of <<related-concept,RelatedConcept>>
 status:: Enum for the normative status of the term.
 dates:: Array of <<concept-date,ConceptDate>>
 localized_concepts:: Hash of all localizations where keys are language codes and values are uuid of the localized concept.
-domains:: Array of <<concept-reference,ConceptReference>> — upper concepts (subject areas, concept schemes, organizing concepts) that this concept belongs to across all languages. Each domain is a typed reference (e.g. `{ concept_id: "103", ref_type: "domain" }`).
+domains:: Array of <<concept-reference,ConceptReference>> — terminological domain references (subject areas, concept schemes) that this concept belongs to. Each domain is a typed reference (e.g. `{ concept_id: "103", ref_type: "domain" }`). These are rendered as `<domain>` in output.
+tags:: Array of strings — organizational tags for grouping and filtering concepts (e.g. `["time-scale-units"]`). Tags are not rendered as terminological domains; they serve as metadata for document structure and retrieval.
 localizations:: Hash of all localizations for this concept where keys are language codes and values are instances of <<localized-concept,LocalizedConcept>>.
 
 There are two ways to initialize and populate a managed concept
@@ -121,6 +122,7 @@ concept = Glossarist::ManagedConcept.new({
     "domains" => [
       { "concept_id" => "103", "ref_type" => "domain" },
     ],
+    "tags" => ["time-scales"],
   },
 })
 ----
@@ -134,6 +136,7 @@ concept.id = "123"
 concept.data.domains = [
   Glossarist::ConceptReference.new(concept_id: "103", ref_type: "domain"),
 ]
+concept.data.tags = ["time-scales"]
 concept.localizations = <Array of localized concepts or localized concept hashes>
 ----
 

data/glossarist.gemspec

@@ -31,7 +31,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "lutaml-model", "~> 0.8.5"
+  spec.add_dependency "lutaml-model", "~> 0.8.15"
+  spec.add_dependency "lutaml-store", "~> 0.1.1"
   spec.add_dependency "paint", "~> 2.3"
   spec.add_dependency "relaton", ">= 2.0.0", "< 3"
   spec.add_dependency "rubyzip", ">= 2.3", "< 3"

data/lib/glossarist/concept_document.rb

@@ -23,10 +23,8 @@ module Glossarist
     def self.for_version(version)
       case version.to_s
       when "2"
-        require_relative "v2"
         V2::ConceptDocument
       else
-        require_relative "v3"
         V3::ConceptDocument
       end
     end

data/lib/glossarist/concept_manager.rb

@@ -16,7 +16,6 @@ module Glossarist
 
     def localized_concept_class
       if version.to_s == "2"
-        require_relative "v2"
         V2::LocalizedConcept
       else
         LocalizedConcept

data/lib/glossarist/concept_store.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "lutaml/store"
+
+module Glossarist
+  class ConceptStore
+    # Custom serializer that preserves both uuid and identifier through
+    # YAML string storage. ManagedConcept's key_value mapping writes both
+    # uuid and identifier to the same "id" key, so a naive to_hash/from_hash
+    # round-trip loses one of them. Storing the YAML string preserves the
+    # model exactly, and explicit metadata fields let the store index and
+    # query by uuid/identifier without deserializing.
+    class Serializer
+      def serialize(model)
+        {
+          "_yaml" => model.to_yaml,
+          "_uuid" => model.uuid,
+          "_identifier" => model.identifier,
+        }
+      end
+
+      def deserialize(data, model_class)
+        model = model_class.from_yaml(data["_yaml"])
+        model.assign_uuid(data["_uuid"]) if data["_uuid"]
+        model.identifier = data["_identifier"] if data["_identifier"]
+        model
+      end
+    end
+
+    attr_reader :db
+
+    def initialize(adapter: :memory)
+      @db = Lutaml::Store::DatabaseStore.new(
+        adapter: adapter,
+        models: [managed_concept_registration],
+      )
+    end
+
+    def save(concept)
+      db.save(concept)
+    end
+
+    def fetch(uuid)
+      db.fetch(model: ManagedConcept, uuid: uuid)
+    end
+
+    def fetch_by_id(identifier)
+      db.where(model: ManagedConcept, identifier: identifier).first
+    end
+
+    def update(uuid, **attributes)
+      db.update(model: ManagedConcept, uuid: uuid, attributes: attributes)
+    end
+
+    def delete(uuid)
+      db.destroy(model: ManagedConcept, uuid: uuid)
+    end
+
+    def all
+      db.all(model: ManagedConcept)
+    end
+
+    def count
+      db.count(model: ManagedConcept)
+    end
+
+    def exists?(uuid)
+      db.exists?(model: ManagedConcept, uuid: uuid)
+    end
+
+    def clear
+      all.each { |concept| delete(concept.uuid) }
+    end
+
+    def load_from_directory(path, format: :yaml, layout: :separate)
+      db.import_all(ManagedConcept, path: path, format: format, layout: layout)
+    end
+
+    def save_to_directory(path, format: :yaml, layout: :separate)
+      db.save_all(all, path: path, format: format, layout: layout)
+    end
+
+    private
+
+    def managed_concept_registration
+      {
+        model: ManagedConcept,
+        key: :uuid,
+        dir: "concept",
+        serializer: Serializer.new,
+      }
+    end
+  end
+end

data/lib/glossarist/managed_concept_data.rb

@@ -6,6 +6,7 @@ module Glossarist
     attribute :uri, :string
     attribute :localized_concepts, :hash
     attribute :domains, ConceptReference, collection: true
+    attribute :tags, :string, collection: true
     attribute :sources, ConceptSource, collection: true
     attribute :localizations, LocalizedConcept,
               collection: Collections::LocalizationCollection,
@@ -19,6 +20,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 }

data/lib/glossarist/rdf/gloss_concept.rb

@@ -5,8 +5,6 @@ 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
@@ -14,6 +12,10 @@ module Glossarist
       attribute :domains, GlossConceptReference, collection: true
       attribute :dates, GlossConceptDate, collection: true
 
+      RelationshipPredicates::CONCEPT_REL_PREDICATES.each_key do |type|
+        attribute :"#{type}_targets", :string, collection: true
+      end
+
       rdf do
         namespace Namespaces::GlossaristNamespace,
                   Namespaces::SkosNamespace,
@@ -27,7 +29,7 @@ module Glossarist
         types "gloss:Concept", "skos:Concept"
 
         predicate :identifier, namespace: Namespaces::GlossaristNamespace, to: :identifier
-        predicate :hasStatus, namespace: Namespaces::GlossaristNamespace, to: :status, as: :uri
+        predicate :hasStatus, namespace: Namespaces::GlossaristNamespace, to: :status, uri_reference: true
 
         members :localizations,
                 link: "gloss:hasLocalization"
@@ -37,6 +39,10 @@ module Glossarist
                 link: "gloss:hasDomain"
         members :dates,
                 link: "gloss:hasDate"
+
+        RelationshipPredicates::CONCEPT_REL_PREDICATES.each do |type, (ns, name)|
+          predicate name, namespace: ns, to: :"#{type}_targets", uri_reference: true
+        end
       end
     end
 

data/lib/glossarist/rdf/gloss_concept_date.rb

@@ -17,7 +17,7 @@ module Glossarist
         types "gloss:ConceptDate"
 
         predicate :dateValue, namespace: Namespaces::GlossaristNamespace, to: :date_value
-        predicate :dateType, namespace: Namespaces::GlossaristNamespace, to: :date_type, as: :uri
+        predicate :dateType, namespace: Namespaces::GlossaristNamespace, to: :date_type, uri_reference: true
       end
     end
   end

data/lib/glossarist/rdf/gloss_concept_source.rb

@@ -17,8 +17,8 @@ module Glossarist
 
         types "gloss:ConceptSource"
 
-        predicate :sourceStatus, namespace: Namespaces::GlossaristNamespace, to: :status, as: :uri
-        predicate :sourceType, namespace: Namespaces::GlossaristNamespace, to: :type, as: :uri
+        predicate :sourceStatus, namespace: Namespaces::GlossaristNamespace, to: :status, uri_reference: true
+        predicate :sourceType, namespace: Namespaces::GlossaristNamespace, to: :type, uri_reference: true
         predicate :modification, namespace: Namespaces::GlossaristNamespace, to: :modification
 
         members :origin, link: "gloss:sourceOrigin"

data/lib/glossarist/rdf/gloss_designation.rb

@@ -6,8 +6,8 @@ module Glossarist
   module Rdf
     COMMON_DESIGNATION_PREDICATES = lambda { |dsl|
       dsl.predicate :literalForm, namespace: Namespaces::SkosxlNamespace, to: :designation
-      dsl.predicate :normativeStatus, namespace: Namespaces::GlossaristNamespace, to: :normative_status, as: :uri
-      dsl.predicate :hasTermType, namespace: Namespaces::GlossaristNamespace, to: :term_type, as: :uri
+      dsl.predicate :normativeStatus, namespace: Namespaces::GlossaristNamespace, to: :normative_status, uri_reference: true
+      dsl.predicate :hasTermType, namespace: Namespaces::GlossaristNamespace, to: :term_type, uri_reference: true
       dsl.predicate :isInternational, namespace: Namespaces::GlossaristNamespace, to: :international
       dsl.predicate :isAbsent, namespace: Namespaces::GlossaristNamespace, to: :absent
       dsl.predicate :geographicalArea, namespace: Namespaces::GlossaristNamespace, to: :language
@@ -16,6 +16,10 @@ module Glossarist
       dsl.predicate :conversionSystem, namespace: Namespaces::GlossaristNamespace, to: :system
       dsl.members :pronunciations, link: "gloss:hasPronunciation"
       dsl.members :sources
+
+      RelationshipPredicates::DESIGNATION_REL_PREDICATES.each do |type, (ns, name)|
+        dsl.predicate name, namespace: ns, to: :"#{type}_targets", uri_reference: true
+      end
     }.freeze
 
     DESIGNATION_NAMESPACES = [
@@ -27,8 +31,6 @@ module Glossarist
     ].freeze
 
     class GlossDesignation < Lutaml::Model::Serializable
-      include Relationships
-
       attribute :designation, :string
       attribute :normative_status, :string
       attribute :type, :string
@@ -44,6 +46,10 @@ module Glossarist
       attribute :pronunciations, GlossPronunciation, collection: true
       attribute :sources, GlossConceptSource, collection: true
 
+      RelationshipPredicates::DESIGNATION_REL_PREDICATES.each_key do |type|
+        attribute :"#{type}_targets", :string, collection: true
+      end
+
       rdf do
         namespace(*DESIGNATION_NAMESPACES)
 

data/lib/glossarist/rdf/gloss_grammar_info.rb

@@ -19,8 +19,8 @@ module Glossarist
 
         types "gloss:GrammarInfo"
 
-        predicate :gender, namespace: Namespaces::GlossaristNamespace, to: :gender, as: :uri
-        predicate :number, namespace: Namespaces::GlossaristNamespace, to: :number, as: :uri
+        predicate :gender, namespace: Namespaces::GlossaristNamespace, to: :gender, uri_reference: true
+        predicate :number, namespace: Namespaces::GlossaristNamespace, to: :number, uri_reference: true
         predicate :isNoun, namespace: Namespaces::GlossaristNamespace, to: :noun?
         predicate :isVerb, namespace: Namespaces::GlossaristNamespace, to: :verb?
         predicate :isAdjective, namespace: Namespaces::GlossaristNamespace, to: :adjective?

data/lib/glossarist/rdf/gloss_localized_concept.rb

@@ -33,7 +33,7 @@ module Glossarist
         types "gloss:LocalizedConcept", "skos:Concept"
 
         predicate :language, namespace: Namespaces::DctermsNamespace, to: :language_code
-        predicate :hasEntryStatus, namespace: Namespaces::GlossaristNamespace, to: :entry_status, as: :uri
+        predicate :hasEntryStatus, namespace: Namespaces::GlossaristNamespace, to: :entry_status, uri_reference: true
         predicate :domain, namespace: Namespaces::GlossaristNamespace, to: :domain
         predicate :release, namespace: Namespaces::GlossaristNamespace, to: :release
         predicate :lineageSimilarity, namespace: Namespaces::GlossaristNamespace, to: :lineage_similarity

data/lib/glossarist/rdf/relationship_predicates.rb

@@ -0,0 +1,72 @@
+# 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,32 @@
 # 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 :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 :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/sts/importer.rb

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