glossarist 2.4.0 → 2.5.1

data/lib/glossarist/concept_manager.rb

@@ -3,7 +3,7 @@ module Glossarist
     attribute :path, :string
     attribute :localized_concepts_path, :string
 
-    yaml do
+    key_value do
       map :path, to: :path
       map %i[localized_concepts_path localizedConceptsPath],
           to: :localized_concepts_path
@@ -33,62 +33,43 @@ module Glossarist
       end
     end
 
-    def group_concept_hashes(mixed_hashes)
-      concept_hashes = mixed_hashes.select do |concept_hash|
-        !concept_hash["data"]["localized_concepts"].nil? ||
-          !concept_hash["data"]["localizedConcepts"].nil?
+    def load_concept_from_file(filename) # rubocop:disable Metrics/CyclomaticComplexity
+      raw = File.read(filename, encoding: "utf-8")
+      doc = ConceptDocument.from_yamls(raw)
+      concept = doc.concept
+      unless concept
+        raise Glossarist::ParseError.new(filename: filename)
       end
 
-      localized_concept_hashes = mixed_hashes.select do |concept_hash|
-        concept_hash["data"]["localized_concepts"].nil? &&
-          concept_hash["data"]["localizedConcepts"].nil?
-      end
-
-      [concept_hashes, localized_concept_hashes]
-    end
-
-    def load_concept_from_file(filename)
-      mixed_hashes = YAML.load_stream(File.read(filename, encoding: "utf-8"))
-      concepts = []
-
-      concept_hashes, localized_concept_hashes =
-        group_concept_hashes(mixed_hashes)
-
-      concept_hashes.each do |concept_hash|
-        concept_hash["uuid"] = concept_hash["id"] ||
-          File.basename(filename, ".*")
-        concept = Config.class_for(:managed_concept).of_yaml(concept_hash)
+      concept_uuid = concept.identifier || concept.data&.id || File.basename(
+        filename, ".*"
+      )
+      concept.instance_variable_set(:@uuid, concept_uuid)
 
-        concept.data.localized_concepts.each_value do |id|
-          localized_concept =
-            load_localized_concept(id, localized_concept_hashes)
-          concept.add_l10n(localized_concept)
-        end
-
-        concepts << concept
+      concept.data.localized_concepts.each_value do |id|
+        localized_concept = load_localized_concept(id, doc.localizations)
+        concept.add_l10n(localized_concept)
       end
 
-      concepts
+      [concept]
     rescue Psych::SyntaxError => e
       raise Glossarist::ParseError.new(filename: filename, line: e.line)
     end
 
-    def load_localized_concept(id, localized_concept_hashes = [])
-      {}
-
-      concept_hash = if localized_concept_hashes.empty?
-                       Psych.safe_load(
-                         File.read(localized_concept_path(id), encoding: "utf-8"),
-                         permitted_classes: [Date, Time],
-                       )
-                     else
-                       localized_concept_hashes.find do |hash|
-                         hash["id"] == id
-                       end
-                     end
-
-      concept_hash["uuid"] = id
-      Config.class_for(:localized_concept).of_yaml(concept_hash)
+    def load_localized_concept(id, inline_localizations = nil)
+      if inline_localizations
+        l10n = inline_localizations.find { |l| l.id == id }
+        if l10n
+          l10n.instance_variable_set(:@uuid, id)
+          return l10n
+        end
+      end
+
+      l10n = LocalizedConcept.from_yaml(
+        File.read(localized_concept_path(id), encoding: "utf-8"),
+      )
+      l10n.instance_variable_set(:@uuid, id)
+      l10n
     rescue Psych::SyntaxError => e
       raise Glossarist::ParseError.new(filename: filename, line: e.line)
     end
@@ -107,7 +88,8 @@ module Glossarist
 
       concept.localized_concepts.each do |lang, uuid|
         filename = File.join(localized_concept_dir, "#{uuid}.yaml")
-        File.write(filename, concept.localization(lang).to_yaml, encoding: "utf-8")
+        File.write(filename, concept.localization(lang).to_yaml,
+                   encoding: "utf-8")
       end
     end
 

data/lib/glossarist/concept_reference.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class ConceptReference < Lutaml::Model::Serializable
+    attribute :term, :string
+    attribute :concept_id, :string
+    attribute :source, :string
+    attribute :ref_type, :string
+
+    key_value do
+      map :term, to: :term
+      map :concept_id, to: :concept_id
+      map :source, to: :source
+      map :ref_type, to: :ref_type
+    end
+
+    def local?
+      %w[local designation].include?(ref_type) ||
+        (ref_type.nil? && (source.nil? || source.empty?))
+    end
+
+    def external?
+      !local?
+    end
+
+    def to_urn
+      return nil unless external?
+      return nil unless source && concept_id
+
+      case source
+      when /\Aurn:iec/ then "#{source}-#{concept_id}"
+      when /\Aurn:iso/ then "#{source}:term:#{concept_id}"
+      else "#{source}/#{concept_id}"
+      end
+    end
+
+    def to_gcr_hash
+      h = { "term" => term }
+      h["concept_id"] = concept_id if concept_id
+      h["source"] = source if source
+      h["ref_type"] = ref_type if ref_type
+      h.compact
+    end
+  end
+end

data/lib/glossarist/concept_source.rb

@@ -7,7 +7,7 @@ module Glossarist
     attribute :origin, Citation
     attribute :modification, :string
 
-    yaml do
+    key_value do
       # TODO: change to `map [:ref, :origin], to: :origin
       #       when multiple key mapping is supported in lutaml-model
       map :origin, to: :origin

data/lib/glossarist/concept_validator.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class ConceptValidator
+    LANG_CODES = Glossarist::LANG_CODES
+    VALID_ENTRY_STATUSES = %w[valid superseded withdrawn draft].freeze
+
+    attr_reader :path, :errors, :warnings
+
+    def initialize(path)
+      @path = path
+      @errors = []
+      @warnings = []
+    end
+
+    def validate_all
+      seen_ids = {}
+      file_idx = 0
+
+      ConceptCollector.each_concept(@path) do |concept|
+        fname = concept_file_name(concept, file_idx)
+        validate_concept(concept, fname, seen_ids)
+        file_idx += 1
+      end
+
+      if file_idx.zero?
+        yaml_files = find_yaml_files
+        if yaml_files.any?
+          @errors << "YAML files found but no parseable concepts"
+        end
+      end
+
+      ValidationResult.new(errors: @errors, warnings: @warnings)
+    end
+
+    private
+
+    def find_yaml_files
+      concepts_dir = if File.directory?(File.join(@path, "concepts"))
+                       File.join(@path, "concepts")
+                     else
+                       @path
+                     end
+      Dir.glob(File.join(concepts_dir, "*.yaml"))
+    end
+
+    def concept_file_name(concept, idx)
+      id = concept.data&.id
+      id ? "concept-#{id}.yaml" : "concept-#{idx}.yaml"
+    end
+
+    def validate_concept(concept, fname, seen_ids)
+      validate_id(concept, fname, seen_ids)
+      validate_localizations(concept, fname)
+      validate_definitions(concept, fname)
+      validate_entry_statuses(concept, fname)
+    end
+
+    def validate_id(concept, fname, seen_ids)
+      id = concept.data&.id
+      unless id
+        @errors << "#{fname}: missing concept id"
+        return
+      end
+
+      id_str = id.to_s
+      if seen_ids[id_str]
+        @errors << "#{fname}: duplicate id '#{id_str}' (first seen in #{seen_ids[id_str]})"
+      else
+        seen_ids[id_str] = fname
+      end
+    end
+
+    def validate_localizations(concept, fname)
+      l10ns = concept.localizations&.values || []
+      if l10ns.empty?
+        @errors << "#{fname}: no localizations found"
+        return
+      end
+
+      l10ns.each do |l10n|
+        lang = l10n.language_code || "unknown"
+        terms = l10n.data&.terms
+        unless terms.is_a?(Array) && terms.any?
+          @errors << "#{fname}/#{lang}: must have at least 1 term"
+        end
+      end
+    end
+
+    def validate_definitions(concept, fname)
+      (concept.localizations&.values || []).each do |l10n|
+        lang = l10n.language_code || "unknown"
+        next unless l10n.data&.definition
+
+        defs = l10n.data.definition
+        if defs.empty?
+          @errors << "#{fname}/#{lang}: definition is empty"
+        end
+      end
+    end
+
+    def validate_entry_statuses(concept, fname)
+      (concept.localizations&.values || []).each do |l10n|
+        lang = l10n.language_code || "unknown"
+        status = l10n.data&.entry_status
+        next unless status
+
+        unless VALID_ENTRY_STATUSES.include?(status)
+          @errors << "#{fname}/#{lang}: invalid entry_status '#{status}' (expected one of: #{VALID_ENTRY_STATUSES.join(', ')})"
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/custom_locality.rb

@@ -8,7 +8,7 @@ module Glossarist
     # @return [String]
     attribute :value, :string
 
-    yaml do
+    key_value do
       map :name, to: :name
       map :value, to: :value
     end

data/lib/glossarist/dataset_validator.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class DatasetValidator
+    def validate(path, strict: false, reference_path: nil)
+      result = validate_path(path)
+
+      if reference_path
+        ref_result = validate_cross_references(path, reference_path)
+        result.merge(ref_result)
+      end
+
+      result
+    end
+
+    private
+
+    def validate_path(path)
+      if File.extname(path).downcase == ".gcr"
+        validate_gcr(path)
+      else
+        validate_directory(path)
+      end
+    end
+
+    def validate_gcr(path)
+      GcrValidator.new.validate(path)
+    end
+
+    def validate_directory(path)
+      ConceptValidator.new(path).validate_all
+    end
+
+    def validate_cross_references(path, reference_path)
+      extractor = ReferenceExtractor.new
+      resolver = build_resolver(reference_path)
+
+      if File.extname(path).downcase == ".gcr"
+        validate_gcr_refs(resolver, path, extractor)
+      else
+        validate_directory_refs(resolver, path, extractor)
+      end
+    end
+
+    def build_resolver(reference_path)
+      resolver = ReferenceResolver.new
+      Dir.glob(File.join(reference_path, "*.gcr")).each do |gcr_path|
+        pkg = GcrPackage.load(gcr_path)
+        uri_prefix = pkg.metadata&.dig("uri_prefix") || pkg.metadata&.dig("shortname")
+        resolver.register_package(pkg, uri_prefix: uri_prefix)
+      end
+      resolver
+    end
+
+    def validate_gcr_refs(resolver, path, extractor)
+      pkg = GcrPackage.load(path)
+      uri_prefix = pkg.metadata&.dig("uri_prefix") || pkg.metadata&.dig("shortname")
+      resolver.register_self(pkg.concepts)
+      resolver.register_package(pkg, uri_prefix: uri_prefix)
+      resolver.validate_all(pkg, extractor: extractor)
+    end
+
+    def validate_directory_refs(resolver, path, extractor)
+      concepts = ConceptCollector.collect(path)
+      resolver.register_self(concepts)
+      resolver.validate_all(concepts, extractor: extractor)
+    end
+  end
+end

data/lib/glossarist/designation/abbreviation.rb

@@ -8,7 +8,7 @@ module Glossarist
         attribute name.to_sym, :boolean
       end
 
-      yaml do
+      key_value do
         map :international, to: :international
         map :type, to: :type, render_default: true
         Glossarist::GlossaryDefinition::ABBREVIATION_TYPES.each do |name|

data/lib/glossarist/designation/base.rb

@@ -7,7 +7,7 @@ module Glossarist
                 values: Glossarist::GlossaryDefinition::DESIGNATION_BASE_NORMATIVE_STATUSES
       attribute :type, :string
 
-      yaml do
+      key_value do
         map :type, to: :type
         map %i[normative_status normativeStatus], to: :normative_status
         map %i[geographical_area geographicalArea], to: :geographical_area
@@ -18,14 +18,13 @@ module Glossarist
         type = hash["type"]
 
         if type.nil? || /\w/ !~ type
-          raise ArgumentError, "designation type is missing"
+          type = infer_designation_type(hash)
+          hash["type"] = type
         end
 
         if self == Base
-          # called on Base class, delegate it to proper subclass
           SERIALIZED_TYPES[type].of_yaml(hash)
         else
-          # called on subclass, instantiate object
           unless SERIALIZED_TYPES[self] == type
             raise ArgumentError, "unexpected designation type: #{type}"
           end
@@ -33,6 +32,14 @@ module Glossarist
           super
         end
       end
+
+      def self.infer_designation_type(hash)
+        if hash["international"] || hash["abbreviation_type"]
+          "symbol"
+        else
+          "expression"
+        end
+      end
     end
   end
 end

data/lib/glossarist/designation/expression.rb

@@ -13,7 +13,7 @@ module Glossarist
       attribute :grammar_info, GrammarInfo, collection: true
       attribute :type, :string, default: -> { "expression" }
 
-      yaml do
+      key_value do
         map :type, to: :type, render_default: true
         map :prefix, to: :prefix
         map %i[usage_info usageInfo], to: :usage_info

data/lib/glossarist/designation/grammar_info.rb

@@ -8,7 +8,7 @@ module Glossarist
       attribute :part_of_speech, :string,
                 values: Glossarist::GlossaryDefinition::GRAMMAR_INFO_BOOLEAN_ATTRIBUTES
 
-      yaml do
+      key_value do
         map :gender, to: :gender
         map :number, to: :number
 

data/lib/glossarist/designation/graphical_symbol.rb

@@ -6,7 +6,7 @@ module Glossarist
       attribute :text, :string
       attribute :image, :string
 
-      yaml do
+      key_value do
         map :text, to: :text
         map :image, to: :image
       end

data/lib/glossarist/designation/letter_symbol.rb

@@ -5,7 +5,7 @@ module Glossarist
       attribute :language, :string
       attribute :script, :string
 
-      yaml do
+      key_value do
         map :text, to: :text
         map :language, to: :language
         map :script, to: :script

data/lib/glossarist/designation/symbol.rb

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

data/lib/glossarist/designation.rb

@@ -1,18 +1,15 @@
 # frozen_string_literal: true
 
-# (c) Copyright 2021 Ribose Inc.
-#
-
-require_relative "designation/base"
-require_relative "designation/expression"
-require_relative "designation/abbreviation"
-require_relative "designation/grammar_info"
-require_relative "designation/symbol"
-require_relative "designation/graphical_symbol"
-require_relative "designation/letter_symbol"
-
 module Glossarist
   module Designation
+    autoload :Base,              "glossarist/designation/base"
+    autoload :Expression,        "glossarist/designation/expression"
+    autoload :Abbreviation,      "glossarist/designation/abbreviation"
+    autoload :GrammarInfo,       "glossarist/designation/grammar_info"
+    autoload :Symbol,            "glossarist/designation/symbol"
+    autoload :GraphicalSymbol,   "glossarist/designation/graphical_symbol"
+    autoload :LetterSymbol,      "glossarist/designation/letter_symbol"
+
     # Bi-directional class-to-string mapping for STI-like serialization.
     SERIALIZED_TYPES = {
       Expression => "expression",

data/lib/glossarist/detailed_definition.rb

@@ -5,7 +5,7 @@ module Glossarist
     attribute :content, :string
     attribute :sources, ConceptSource, collection: true
 
-    yaml do
+    key_value do
       map :content, to: :content
       map :sources, to: :sources
     end

data/lib/glossarist/error.rb

@@ -1,9 +1,6 @@
+# frozen_string_literal: true
+
 module Glossarist
   class Error < StandardError
   end
 end
-
-require_relative "error/invalid_type_error"
-require_relative "error/invalid_language_code_error"
-require_relative "error/parse_error"
-require_relative "error/cache_version_mismatch_error"

data/lib/glossarist/gcr_metadata.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class GcrMetadata < Lutaml::Model::Serializable
+    attribute :shortname, :string
+    attribute :version, :string
+    attribute :title, :string
+    attribute :description, :string
+    attribute :owner, :string
+    attribute :tags, :string, collection: true
+    attribute :concept_count, :integer
+    attribute :languages, :string, collection: true
+    attribute :created_at, :string
+    attribute :glossarist_version, :string
+    attribute :schema_version, :string, default: -> { "1.0.0" }
+    attribute :statistics, GcrStatistics
+    attribute :homepage, :string
+    attribute :repository, :string
+    attribute :license, :string
+    attribute :uri_prefix, :string
+    attribute :concept_uri_template, :string
+    attribute :external_references, :hash, collection: true
+
+    key_value do
+      map :shortname, to: :shortname
+      map :version, to: :version
+      map :title, to: :title
+      map :description, to: :description
+      map :owner, to: :owner
+      map :tags, to: :tags
+      map :concept_count, to: :concept_count
+      map :languages, to: :languages
+      map :created_at, to: :created_at
+      map :glossarist_version, to: :glossarist_version
+      map :schema_version, to: :schema_version
+      map :statistics, to: :statistics
+      map :homepage, to: :homepage
+      map :repository, to: :repository
+      map :license, to: :license
+      map :uri_prefix, to: :uri_prefix
+      map :concept_uri_template, to: :concept_uri_template
+      map :external_references, to: :external_references
+    end
+
+    def self.from_concepts(concepts, register_data: nil, options: {})
+      stats = GcrStatistics.from_concepts(concepts)
+      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"),
+        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,
+        statistics: stats,
+        uri_prefix: options[:uri_prefix],
+        concept_uri_template: options[:concept_uri_template],
+        external_references: derive_external_references(concepts),
+      )
+    end
+
+    def self.derive_external_references(concepts)
+      sources = Set.new
+      concepts.each do |concept|
+        concept.localizations.each do |l10n|
+          l10n.data.references&.each do |ref|
+            src = ref.source
+            sources.add(src) if src && !src.empty?
+          end
+        end
+      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