glossarist 2.6.5 → 2.6.7

data/lib/glossarist/designation/suffix.rb

@@ -0,0 +1,17 @@
+module Glossarist
+  module Designation
+    class Suffix < Base
+      attribute :type, :string, default: -> { "suffix" }
+
+      key_value do
+        map :type, to: :type, render_default: true
+      end
+
+      def self.of_yaml(hash, options = {})
+        hash["type"] = "suffix" unless hash["type"]
+
+        super
+      end
+    end
+  end
+end

data/lib/glossarist/designation/symbol.rb

@@ -1,11 +1,9 @@
 module Glossarist
   module Designation
     class Symbol < Base
-      attribute :international, :boolean
       attribute :type, :string, default: -> { "symbol" }
 
       key_value do
-        map :international, to: :international
         map :type, to: :type, render_default: true
       end
 

data/lib/glossarist/gcr_metadata.rb

@@ -12,7 +12,7 @@ module Glossarist
     attribute :languages, :string, collection: true
     attribute :created_at, :string
     attribute :glossarist_version, :string
-    attribute :schema_version, :string, default: -> { "1.0.0" }
+    attribute :schema_version, :string, default: -> { Glossarist::SCHEMA_VERSION }
     attribute :statistics, GcrStatistics
     attribute :homepage, :string
     attribute :repository, :string
@@ -46,18 +46,19 @@ module Glossarist
 
     def self.from_concepts(concepts, register_data: nil, options: {})
       stats = GcrStatistics.from_concepts(concepts)
+      rd = register_data
       new(
-        shortname: options[:shortname] || register_data&.dig("shortname") || register_data&.dig("id"),
-        version: options[:version] || register_data&.dig("version"),
-        title: options[:title] || register_data&.dig("name"),
-        description: options[:description] || register_data&.dig("description"),
+        shortname: options[:shortname] || rd&.[]("shortname") || rd&.[]("id"),
+        version: options[:version] || rd&.[]("version"),
+        title: options[:title] || rd&.[]("name"),
+        description: options[:description] || rd&.[]("description"),
         owner: options[:owner],
         tags: options[:tags] || [],
         concept_count: concepts.length,
         languages: stats.languages,
         created_at: Time.now.utc.iso8601,
         glossarist_version: Glossarist::VERSION,
-        schema_version: register_data&.dig("schema_version") || SchemaMigration::CURRENT_SCHEMA_VERSION,
+        schema_version: rd&.[]("schema_version") || SchemaMigration::CURRENT_SCHEMA_VERSION,
         statistics: stats,
         uri_prefix: options[:uri_prefix],
         concept_uri_template: options[:concept_uri_template],
@@ -78,13 +79,5 @@ module Glossarist
       end
       sources.map { |uri| { "uri" => uri } }
     end
-
-    def [](key)
-      to_yaml_hash[key]
-    end
-
-    def dig(*keys)
-      to_yaml_hash.dig(*keys)
-    end
   end
 end

data/lib/glossarist/gcr_package.rb

@@ -156,31 +156,41 @@ module Glossarist
     end
 
     def read_file_assets(zip_file)
-      DATASET_ASSETS.each do |asset|
-        next unless asset[:type] == :file && asset[:attr]
-
-        entry = zip_file.find_entry(asset[:path])
-        next unless entry
-
-        instance_variable_set("@#{asset[:attr]}", entry.get_input_stream.read)
-      end
+      entry = zip_file.find_entry("bibliography.yaml")
+      @bibliography = entry.get_input_stream.read if entry
     end
 
     def read_concepts(zip_file)
+      doc_class = concept_document_class_for_read
       zip_file.entries.each do |entry|
         next unless entry.name.start_with?("concepts/") && entry.name.end_with?(".yaml")
 
         raw = entry.get_input_stream.read
-        doc = ConceptDocument.from_yamls(raw)
+        doc = doc_class.from_yamls(raw)
         @concepts << doc.to_managed_concept
       end
     end
 
     private
 
+    def concept_document_class_for_read
+      version = @metadata&.schema_version.to_s
+      ConceptDocument.for_version(version)
+    end
+
+    def concept_document_class_for_write(concept)
+      version = if concept.schema_version.to_s == "2"
+                  "2"
+                else
+                  "3"
+                end
+      ConceptDocument.for_version(version)
+    end
+
     def write_concept(zip_file, concept)
       termid = concept.data.id.to_s
-      doc = ConceptDocument.from_managed_concept(concept)
+      doc_class = concept_document_class_for_write(concept)
+      doc = doc_class.from_managed_concept(concept)
       zip_file.get_output_stream("concepts/#{termid}.yaml") do |f|
         f.write(doc.to_yamls)
       end
@@ -215,19 +225,21 @@ module Glossarist
     end
 
     def write_compiled_skos(zip_file, concepts, formats, opts, name) # rubocop:disable Metrics/MethodLength
-      require "glossarist/transforms/concept_to_skos_transform"
-      vocab = Transforms::ConceptToSkosTransform.transform_document(concepts,
-                                                                    opts)
+      require "glossarist/transforms/concept_to_gloss_transform"
+
+      if formats.include?("jsonld") || formats.include?("turtle")
+        transform = Transforms::ConceptToGlossTransform.new(nil, opts)
 
-      if formats.include?("jsonld")
-        zip_file.get_output_stream("compiled/#{name}.jsonld") do |f|
-          f.write(vocab.to_jsonld)
+        if formats.include?("jsonld")
+          zip_file.get_output_stream("compiled/#{name}.jsonld") do |f|
+            f.write(transform.to_jsonld(concepts))
+          end
         end
-      end
 
-      if formats.include?("turtle")
-        zip_file.get_output_stream("compiled/#{name}.ttl") do |f|
-          f.write(vocab.to_turtle)
+        if formats.include?("turtle")
+          zip_file.get_output_stream("compiled/#{name}.ttl") do |f|
+            f.write(transform.to_turtle(concepts))
+          end
         end
       end
 
@@ -235,8 +247,8 @@ module Glossarist
 
       zip_file.get_output_stream("compiled/#{name}.jsonl") do |f|
         concepts.each do |concept|
-          skos = Transforms::ConceptToSkosTransform.transform(concept, opts)
-          f.write(skos.to_jsonld)
+          transform = Transforms::ConceptToGlossTransform.new(concept, opts)
+          f.write(transform.to_jsonl_line)
           f.write("\n")
         end
       end
@@ -343,7 +355,7 @@ compiled_formats: [], **opts)
           languages: languages.sort,
           created_at: Time.now.utc.iso8601,
           glossarist_version: Glossarist::VERSION,
-          schema_version: register_data&.dig("schema_version") || SchemaMigration::CURRENT_SCHEMA_VERSION,
+          schema_version: register_data&.[]("schema_version") || SchemaMigration::CURRENT_SCHEMA_VERSION,
           uri_prefix: opts[:uri_prefix],
           concept_uri_template: opts[:concept_uri_template],
         )

data/lib/glossarist/gcr_validator.rb

@@ -4,6 +4,10 @@ require "zip"
 
 module Glossarist
   class GcrValidator
+    def initialize(on_progress: nil)
+      @on_progress = on_progress
+    end
+
     def validate(zip_path)
       result = ValidationResult.new
 
@@ -24,27 +28,36 @@ module Glossarist
         return result
       end
 
-      begin
-        context = Validation::Rules::GcrContext.new(zip_path)
-      rescue StandardError => e
-        result.add_error("Failed to load GCR: #{e.message}")
-        return result
-      end
+      context, all_concepts = load_gcr_context(zip_path, result)
+      return result if all_concepts.nil?
 
-      # Collection-level rules (metadata, structure, integrity)
-      collection_rules = Validation::Rules::Registry.for_scope(:collection)
-      collection_rules.each do |rule|
-        next unless rule.applicable?(context)
+      validate_concepts(context, all_concepts, result)
+      validate_collection(context, result)
 
-        rule.check(context).each { |i| result.add_issue(i) }
-      end
+      result
+    end
 
-      # Per-concept rules
+    private
+
+    def load_gcr_context(zip_path, result)
+      context = Validation::Rules::GcrContext.new(zip_path)
+      pkg = GcrPackage.load(zip_path)
+      [context, pkg.concepts]
+    rescue StandardError => e
+      result.add_error("Failed to load GCR: #{e.message}")
+      [nil, nil]
+    end
+
+    def validate_concepts(context, all_concepts, result)
       concept_rules = Validation::Rules::Registry.for_scope(:concept)
-      context.concepts.each_with_index do |concept, idx|
-        fname = concept.data&.id ? "concepts/#{concept.data.id}.yaml" : "concepts/concept-#{idx}.yaml"
+      total = all_concepts.length
+
+      all_concepts.each_with_index do |concept, idx|
+        context.add_concept(concept)
         concept_context = Validation::Rules::ConceptContext.new(
-          concept, file_name: fname, collection_context: context
+          concept,
+          file_name: concept.data&.id ? "concepts/#{concept.data.id}.yaml" : "concepts/concept-#{idx}.yaml",
+          collection_context: context,
         )
 
         concept_rules.each do |rule|
@@ -52,9 +65,17 @@ module Glossarist
 
           rule.check(concept_context).each { |i| result.add_issue(i) }
         end
+
+        @on_progress&.call(idx + 1, total)
       end
+    end
 
-      result
+    def validate_collection(context, result)
+      Validation::Rules::Registry.for_scope(:collection).each do |rule|
+        next unless rule.applicable?(context)
+
+        rule.check(context).each { |i| result.add_issue(i) }
+      end
     end
   end
 end

data/lib/glossarist/glossary_definition.rb

@@ -28,5 +28,10 @@ module Glossarist
     CONCEPT_DATE_TYPES = config.dig("concept_date", "type").freeze
 
     CONCEPT_STATUSES = config.dig("concept", "status").freeze
+
+    DESIGNATION_RELATIONSHIP_TYPES = config.dig("designation",
+                                                 "relationship_type")&.freeze
+
+    ISO12620_TERM_TYPES = config.dig("iso12620", "term_type").freeze
   end
 end

data/lib/glossarist/localized_concept.rb

@@ -37,5 +37,13 @@ module Glossarist
     def entry_status=(value)
       data.entry_status = value
     end
+
+    def all_sources
+      data.all_sources
+    end
+
+    def text_content
+      data.text_content
+    end
   end
 end

data/lib/glossarist/managed_concept.rb

@@ -8,7 +8,7 @@ module Glossarist
 
     attribute :related, RelatedConcept, collection: true
     attribute :dates, ConceptDate, collection: true
-    attribute :sources, ConceptSource
+    attribute :sources, ConceptSource, collection: true
     attribute :date_accepted, ConceptDate
     attribute :status, :string,
               values: Glossarist::GlossaryDefinition::CONCEPT_STATUSES
@@ -19,6 +19,8 @@ module Glossarist
 
     attribute :uuid, :string
 
+    attribute :schema_version, :string
+
     key_value do
       map :data, to: :data
       map :id, with: { to: :identifier_to_yaml, from: :identifier_from_yaml }
@@ -26,11 +28,13 @@ module Glossarist
           with: { to: :identifier_to_yaml, from: :identifier_from_yaml }
       map :related, to: :related
       map :dates, to: :dates
+      map :sources, to: :sources
       map %i[date_accepted dateAccepted],
           with: { from: :date_accepted_from_yaml, to: :date_accepted_to_yaml }
       map :status, to: :status
 
       map :uuid, to: :uuid, with: { from: :uuid_from_yaml, to: :uuid_to_yaml }
+      map :schema_version, to: :schema_version
     end
 
     def localizations
@@ -65,7 +69,7 @@ module Glossarist
     def uuid
       @uuid ||= Glossarist::Utilities::UUID.uuid_v5(
         Glossarist::Utilities::UUID::OID_NAMESPACE,
-        to_yaml(except: [:uuid]),
+        to_yaml(except: %i[uuid schema_version]),
       )
     end
 
@@ -109,18 +113,19 @@ module Glossarist
       data.localized_concepts ||= {}
       data.localized_concepts[lang] =
         data.localized_concepts[lang] || localized_concept.uuid
+      localized_concept.uuid = data.localized_concepts[lang]
       localizations.store(lang, localized_concept)
     end
     alias :add_l10n :add_localization
 
     def to_jsonld
-      require "glossarist/transforms/concept_to_skos_transform"
-      Transforms::ConceptToSkosTransform.transform(self).to_jsonld
+      require "glossarist/transforms/concept_to_gloss_transform"
+      Transforms::ConceptToGlossTransform.transform(self).to_jsonld
     end
 
     def to_turtle
-      require "glossarist/transforms/concept_to_skos_transform"
-      Transforms::ConceptToSkosTransform.transform(self).to_turtle
+      require "glossarist/transforms/concept_to_gloss_transform"
+      Transforms::ConceptToGlossTransform.transform(self).to_turtle
     end
 
     def default_designation
@@ -138,6 +143,34 @@ module Glossarist
       localization("eng") || localizations.values.first
     end
 
+    def schema_version
+      @schema_version
+    end
+
+    def assign_uuid(new_uuid)
+      @uuid = new_uuid
+    end
+
+    def self.detect_schema_version(concept) # rubocop:disable Metrics/PerceivedComplexity
+      raw = concept.schema_version
+      if raw && !%w[legacy nil].include?(raw.to_s)
+        return raw.to_s
+      end
+
+      return "3" if concept.related&.any?
+      return "3" if concept.sources&.any?
+      return "3" if concept.data&.domains&.any?
+      return "3" if localization_has_references?(concept)
+
+      "2"
+    end
+
+    def self.localization_has_references?(concept)
+      concept.localizations&.any? do |l10n|
+        l10n.is_a?(LocalizedConcept) && l10n.data&.references&.any?
+      end
+    end
+
     Glossarist::GlossaryDefinition::RELATED_CONCEPT_TYPES.each do |type|
       # List of related concepts of the specified type.
       # @return [Array<RelatedConcept>]

data/lib/glossarist/managed_concept_data.rb

@@ -5,18 +5,20 @@ module Glossarist
     attribute :id, :string
     attribute :uri, :string
     attribute :localized_concepts, :hash
-    attribute :groups, :string, collection: true
+    attribute :domains, ConceptReference, collection: true
     attribute :sources, ConceptSource, collection: true
     attribute :localizations, LocalizedConcept,
               collection: Collections::LocalizationCollection,
               initialize_empty: true
+    attribute :related, RelatedConcept, collection: true
 
     key_value do
       map %i[id identifier], to: :id,
                              with: { to: :id_to_yaml, from: :id_from_yaml }
       map :uri, to: :uri
       map %i[localized_concepts localizedConcepts], to: :localized_concepts
-      map :groups, to: :groups
+      map %i[domains groups], to: :domains,
+                              with: { from: :domains_from_yaml, to: :domains_to_yaml }
       map :sources, to: :sources
       map :localizations, to: :localizations,
                           with: { from: :localizations_from_yaml, to: :localizations_to_yaml }
@@ -41,6 +43,24 @@ module Glossarist
 
     def localizations_to_yaml(model, doc); end
 
+    def domains_from_yaml(model, value)
+      return unless value.is_a?(Array)
+
+      model.domains = value.map do |item|
+        if item.is_a?(Hash)
+          ConceptReference.of_yaml(item)
+        else
+          ConceptReference.new(concept_id: item.to_s, ref_type: "domain")
+        end
+      end
+    end
+
+    def domains_to_yaml(model, doc)
+      return if model.domains.nil? || model.domains.empty?
+
+      doc["domains"] = model.domains.map(&:to_hash)
+    end
+
     def authoritative_source
       return [] unless sources
 

data/lib/glossarist/non_verb_rep.rb

@@ -1,14 +1,29 @@
+# frozen_string_literal: true
+
 module Glossarist
+  # A non-verbal representation used to help define a concept, following
+  # ISO 10241-1 §6.5.
+  #
+  # Non-verbal representations are associated resources (images, tables,
+  # formulas) that live outside the concept model. They are referenced by URI
+  # and can be shared across concepts. The resource belongs either to the
+  # dataset package (relative path) or is externally referenced (URL/URN).
+  #
+  # Each non-verbal representation specifies:
+  # - +type+: one of "image", "table", "formula"
+  # - +ref+: URI reference to the resource (relative path, URN, or URL)
+  # - +text+: optional text description or alt text
+  # - +sources+: bibliographic sources for the representation
   class NonVerbRep < Lutaml::Model::Serializable
-    attribute :image, :string
-    attribute :table, :string
-    attribute :formula, :string
+    attribute :type, :string
+    attribute :ref, :string
+    attribute :text, :string
     attribute :sources, ConceptSource, collection: true
 
     key_value do
-      map :image, to: :image
-      map :table, to: :table
-      map :formula, to: :formula
+      map :type, to: :type
+      map :ref, to: :ref
+      map :text, to: :text
       map :sources, to: :sources
     end
   end

data/lib/glossarist/pronunciation.rb

@@ -0,0 +1,32 @@
+module Glossarist
+  # A pronunciation or transcription of a designation, following ISO 24229
+  # spelling system conventions.
+  #
+  # Each pronunciation entry specifies the text of the pronunciation and the
+  # context in which it is expressed:
+  # - +language+ (ISO 639) identifies the language or dialect being pronounced
+  # - +script+ (ISO 15924) identifies the script used for the pronunciation text
+  # - +country+ (ISO 3166-1) identifies the country variant
+  # - +system+ identifies the transcription/romanization system used (ISO 24229
+  #   conversion system code or a simple identifier like "IPA")
+  #
+  # A designation can have multiple pronunciations, e.g.:
+  #   - IPA:       { content: "toːkjoː", script: "Latn", language: "jpn", system: "IPA" }
+  #   - Hepburn:   { content: "Tōkyō",   script: "Latn", language: "jpn", system: "Var:jpn-Hrkt:Latn:Hepburn-1886" }
+  #   - Cyrillic:  { content: "Токио",   script: "Cyrl", language: "rus", system: "polivanov" }
+  class Pronunciation < Lutaml::Model::Serializable
+    attribute :content, :string
+    attribute :language, :string
+    attribute :script, :string
+    attribute :country, :string
+    attribute :system, :string
+
+    key_value do
+      map :content, to: :content
+      map :language, to: :language
+      map :script, to: :script
+      map :country, to: :country
+      map :system, to: :system
+    end
+  end
+end