glossarist 2.8.1 → 2.8.4

data/lib/glossarist/bibliography_data.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class BibliographyData < Lutaml::Model::Serializable
+    attribute :shortname, :string, default: -> { "bibliography" }
+    attribute :entries, BibliographyEntry, collection: true,
+                                           initialize_empty: true
+
+    key_value do
+      map nil, to: :entries,
+               with: { from: :entries_from_hash, to: :entries_to_hash }
+    end
+
+    def find(citation_key)
+      entries.find { |e| e.citation_key == citation_key }
+    end
+
+    def keys
+      entries.map(&:citation_key)
+    end
+
+    def [](citation_key)
+      entry = find(citation_key)
+      entry&.data
+    end
+
+    def entries_from_hash(model, value)
+      return unless value.is_a?(Hash)
+
+      model.entries = value.map do |key, data|
+        BibliographyEntry.new(citation_key: key, data: data || {})
+      end
+    end
+
+    def entries_to_hash(model, doc)
+      model.entries.each do |entry|
+        doc[entry.citation_key] = entry.data
+      end
+    end
+  end
+end

data/lib/glossarist/bibliography_entry.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class BibliographyEntry < Lutaml::Model::Serializable
+    attribute :citation_key, :string
+    attribute :data, :hash, default: -> { {} }
+
+    key_value do
+      map "citation_key", to: :citation_key
+      map "data", to: :data
+    end
+  end
+end

data/lib/glossarist/citation.rb

@@ -56,8 +56,14 @@ module Glossarist
 
       doc["locality"] = {}
       doc["locality"]["type"] = model.locality.type
-      doc["locality"]["reference_from"] = model.locality.reference_from if model.locality.reference_from
-      doc["locality"]["reference_to"] = model.locality.reference_to if model.locality.reference_to
+      if model.locality.reference_from
+        doc["locality"]["reference_from"] =
+          model.locality.reference_from
+      end
+      if model.locality.reference_to
+        doc["locality"]["reference_to"] =
+          model.locality.reference_to
+      end
     end
   end
 end

data/lib/glossarist/cli/export_command.rb

@@ -74,14 +74,18 @@ module Glossarist
 
       def export_jsonld(concepts, name, output_dir)
         require "glossarist/transforms/concept_to_gloss_transform"
-        transform = Transforms::ConceptToGlossTransform.new(nil, transform_options)
-        File.write(File.join(output_dir, "#{name}.jsonld"), transform.to_jsonld(concepts))
+        transform = Transforms::ConceptToGlossTransform.new(nil,
+                                                            transform_options)
+        File.write(File.join(output_dir, "#{name}.jsonld"),
+                   transform.to_jsonld(concepts))
       end
 
       def export_turtle(concepts, name, output_dir)
         require "glossarist/transforms/concept_to_gloss_transform"
-        transform = Transforms::ConceptToGlossTransform.new(nil, transform_options)
-        File.write(File.join(output_dir, "#{name}.ttl"), transform.to_turtle(concepts))
+        transform = Transforms::ConceptToGlossTransform.new(nil,
+                                                            transform_options)
+        File.write(File.join(output_dir, "#{name}.ttl"),
+                   transform.to_turtle(concepts))
       end
 
       def export_tbx(concepts, name, output_dir)
@@ -95,7 +99,8 @@ module Glossarist
         require "glossarist/transforms/concept_to_gloss_transform"
         File.open(File.join(output_dir, "#{name}.jsonl"), "w") do |f|
           concepts.each do |concept|
-            transform = Transforms::ConceptToGlossTransform.new(concept, transform_options)
+            transform = Transforms::ConceptToGlossTransform.new(concept,
+                                                                transform_options)
             f.write(transform.to_jsonl_line)
             f.write("\n")
           end

data/lib/glossarist/cli/validate_command.rb

@@ -37,7 +37,8 @@ module Glossarist
         filled = (current.to_f / total * bar_width).round
         bar = "#{'█' * filled}#{'░' * (bar_width - filled)}"
 
-        $stderr.print "\r  #{Paint['Validating', :bold]} #{bar} #{current}/#{total} (#{pct}%)"
+        $stderr.print "\r  #{Paint['Validating',
+                                   :bold]} #{bar} #{current}/#{total} (#{pct}%)"
         $stderr.flush
       end
 
@@ -96,18 +97,33 @@ module Glossarist
         msg_col = 21
 
         puts "    #{label}  #{code}  #{issue.message}"
-        puts "#{' ' * msg_col}#{Paint[issue.suggestion, :green]}" if issue.suggestion
+        if issue.suggestion
+          puts "#{' ' * msg_col}#{Paint[issue.suggestion,
+                                        :green]}"
+        end
       end
 
       def print_summary_line(result)
         error_count = result.issues.count(&:error?)
         warning_count = result.issues.count(&:warning?)
 
-        status = error_count.positive? ? Paint["INVALID", :red, :bold] : Paint["VALID", :green, :bold]
+        status = if error_count.positive?
+                   Paint["INVALID", :red,
+                         :bold]
+                 else
+                   Paint["VALID", :green,
+                         :bold]
+                 end
 
         details = []
-        details << Paint["#{error_count} error(s)", :red] if error_count.positive?
-        details << Paint["#{warning_count} warning(s)", :yellow] if warning_count.positive?
+        if error_count.positive?
+          details << Paint["#{error_count} error(s)",
+                           :red]
+        end
+        if warning_count.positive?
+          details << Paint["#{warning_count} warning(s)",
+                           :yellow]
+        end
 
         puts "  #{status}  #{details.join(', ')}"
       end

data/lib/glossarist/collection.rb

@@ -15,8 +15,8 @@ module Glossarist
       @index = {}
     end
 
-    def each(&block)
-      @index.each_value(&block)
+    def each(&)
+      @index.each_value(&)
     end
 
     # Returns concept with given ID, if it is present in collection, or +nil+

data/lib/glossarist/collections/bibliography_collection.rb

@@ -7,7 +7,7 @@ module Glossarist
     class BibliographyCollection < Relaton::Db
       def initialize(_concepts, global_cache, local_cache)
         @version_mismatch = check_cache_version(local_cache) ||
-                            check_cache_version(global_cache)
+          check_cache_version(global_cache)
         super(global_cache, local_cache)
       end
 
@@ -40,6 +40,7 @@ module Glossarist
         concepts.each do |concept|
           concept.default_lang.sources.each do |source|
             next if source.origin.ref.nil?
+
             ref_text = source.origin.ref.source
             next if ref_text.nil?
 

data/lib/glossarist/collections/collection.rb

@@ -18,8 +18,8 @@ module Glossarist
         @collection << @klass.new(object)
       end
 
-      def each(&block)
-        @collection.each(&block)
+      def each(&)
+        @collection.each(&)
       end
 
       def empty?

data/lib/glossarist/collections/localization_collection.rb

@@ -27,12 +27,12 @@ module Glossarist
         to_a
       end
 
-      def each_key(&block)
-        keys.each(&block)
+      def each_key(&)
+        keys.each(&)
       end
 
-      def each_value(&block)
-        values.each(&block)
+      def each_value(&)
+        values.each(&)
       end
     end
   end

data/lib/glossarist/concept_collector.rb

@@ -136,25 +136,25 @@ module Glossarist
         end
       end
 
-      def each_v2_concept(dir, &block)
+      def each_v2_concept(dir, &)
         if v2_flat_concepts?(dir)
-          each_grouped_v2_concepts(File.join(dir, "concepts"), &block)
+          each_grouped_v2_concepts(File.join(dir, "concepts"), &)
         else
           v2_dir = File.join(dir, "geolexica-v2")
           if File.directory?(File.join(v2_dir, "concepts"))
-            each_managed_concept(v2_dir, &block)
+            each_managed_concept(v2_dir, &)
           else
-            each_grouped_v2_concepts(v2_dir, &block)
+            each_grouped_v2_concepts(v2_dir, &)
           end
         end
       end
 
-      def each_grouped_v2_concepts(v2_dir, &block)
+      def each_grouped_v2_concepts(v2_dir, &)
         collection = ManagedConceptCollection.new
         manager = ConceptManager.new(path: v2_dir)
         manager.version = detect_schema_version(v2_dir)
         manager.load_from_files(collection: collection)
-        collection.each(&block)
+        collection.each(&)
       end
 
       def collect_grouped_v2_concepts(v2_dir)

data/lib/glossarist/concept_document.rb

@@ -2,6 +2,7 @@
 
 module Glossarist
   class ConceptDocument < Lutaml::Model::Serializable
+    attribute :id, :string
     attribute :concept, ManagedConcept
     attribute :localizations, LocalizedConcept, collection: true
 
@@ -9,7 +10,7 @@ module Glossarist
       sequence do
         map_document 0, to: :concept, type: ManagedConcept
         map_document 1.., to: :localizations, type: LocalizedConcept,
-                                           collection: true
+                          collection: true
       end
     end
 
@@ -23,10 +24,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
@@ -133,13 +132,12 @@ module Glossarist
       if v1_collection?
         File.join(path, "concept-*.{yaml,yml}")
       else
-        # normal v2 collection
-        concepts_glob = File.join(path, "concept", "*.{yaml,yml}")
-        if Dir.glob(concepts_glob).empty?
-          # multiple content YAML files
-          concepts_glob = File.join(path, "*.{yaml,yml}")
-        end
-        concepts_glob
+        candidates = [
+          File.join(path, "concept", "*.{yaml,yml}"),
+          File.join(path, "concepts", "*.{yaml,yml}"),
+          File.join(path, "*.{yaml,yml}"),
+        ]
+        candidates.find { |g| !Dir.glob(g).empty? }
       end
     end
 

data/lib/glossarist/concept_set.rb

@@ -36,7 +36,7 @@ module Glossarist
     end
 
     def to_latex_from_file(entries_file)
-      File.readlines(entries_file).map do |concept_name|
+      File.readlines(entries_file).filter_map do |concept_name|
         concept = concept_map[concept_name.strip.downcase]
 
         if concept.nil?
@@ -44,7 +44,7 @@ module Glossarist
         else
           latex_template(concept)
         end
-      end.compact.join("\n")
+      end.join("\n")
     end
 
     def read_concepts(concepts)
@@ -72,9 +72,9 @@ module Glossarist
     end
 
     def concept_map
-      @concept_map ||= concepts.managed_concepts.map do |concept|
+      @concept_map ||= concepts.managed_concepts.to_h do |concept|
         [concept.default_designation.downcase, concept]
-      end.to_h
+      end
     end
   end
 end

data/lib/glossarist/concept_store.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "lutaml/store"
+
+module Glossarist
+  class ConceptStore
+    # Serializes ConceptDocument for storage in lutaml-store.
+    # Stores the YAML stream string to preserve the full concept + localizations.
+    class ConceptDocumentSerializer
+      def serialize(concept_document)
+        {
+          "_yamls" => concept_document.to_yamls,
+          "_id" => concept_document.id,
+        }
+      end
+
+      def deserialize(data, model_class)
+        doc = model_class.from_yamls(data["_yamls"])
+        doc.id = data["_id"]
+        concept = doc.concept
+        concept.uuid = doc.id if doc.id && concept
+        doc.localizations.each { |l10n| concept&.add_localization(l10n) }
+        doc
+      end
+    end
+
+    attr_reader :db
+
+    def initialize(adapter: :memory)
+      @db = Lutaml::Store::DatabaseStore.new(
+        adapter: adapter,
+        models: [concept_document_registration],
+      )
+    end
+
+    def load_glossary(path)
+      documents = db.load_all(
+        V3::ConceptDocument, path: path, format: :yamls, layout: :grouped
+      )
+
+      documents.each do |doc|
+        concept = doc.concept
+        concept.uuid = doc.id
+        db.save(doc)
+      end
+
+      documents
+    end
+
+    def fetch(uuid)
+      doc = db.fetch(model: V3::ConceptDocument, id: uuid)
+      doc&.concept
+    end
+
+    def concepts
+      db.all(model: V3::ConceptDocument).map(&:concept)
+    end
+
+    def count
+      db.count(model: V3::ConceptDocument)
+    end
+
+    def exists?(uuid)
+      db.exists?(model: V3::ConceptDocument, id: uuid)
+    end
+
+    def clear
+      db.all(model: V3::ConceptDocument).each do |doc|
+        db.destroy(model: V3::ConceptDocument, id: doc.id)
+      end
+    end
+
+    private
+
+    def concept_document_registration
+      {
+        model: V3::ConceptDocument,
+        key: :id,
+        dir: "concepts",
+        serializer: ConceptDocumentSerializer.new,
+      }
+    end
+  end
+end

data/lib/glossarist/dataset_validator.rb

@@ -28,7 +28,8 @@ module Glossarist
     end
 
     def validate_directory(path, reference_path: nil)
-      result = ConceptValidator.new(path, on_progress: @on_progress).validate_all
+      result = ConceptValidator.new(path,
+                                    on_progress: @on_progress).validate_all
 
       if reference_path
         ref_result = validate_directory_cross_references(path, reference_path)

data/lib/glossarist/gcr_package_definition.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "lutaml/store"
+
+module Glossarist
+  module GcrPackageDefinition
+    def self.definition(concept_document_class: V3::ConceptDocument)
+      Lutaml::Store::PackageDefinition.new(
+        name: :gcr,
+        metadata_model: GcrMetadata,
+        metadata_file: "metadata.yaml",
+      ) do |pkg|
+        pkg.model(
+          model: concept_document_class,
+          dir: "concepts",
+          layout: :grouped,
+          key: :id,
+          default_format: :yamls,
+          serializer: ConceptStore::ConceptDocumentSerializer.new,
+        )
+        pkg.model(
+          model: RegisterData,
+          file: "register.yaml",
+          key: :key,
+          default_format: :yaml,
+        )
+        pkg.model(
+          model: BibliographyData,
+          file: "bibliography.yaml",
+          key: :shortname,
+          default_format: :yaml,
+        )
+        pkg.asset("images", type: :directory)
+      end
+    end
+  end
+end

data/lib/glossarist/gcr_statistics.rb

@@ -21,8 +21,8 @@ module Glossarist
 
       new(
         total_concepts: concepts.length,
-        languages: l10ns.map(&:language_code).compact.sort.uniq,
-        concepts_by_status: l10ns.map(&:entry_status).compact.tally,
+        languages: l10ns.filter_map(&:language_code).sort.uniq,
+        concepts_by_status: l10ns.filter_map(&:entry_status).tally,
         concepts_with_definitions: count_with(l10ns, :definition),
         concepts_with_sources: count_with(l10ns, :sources),
       )

data/lib/glossarist/glossary_definition.rb

@@ -30,7 +30,7 @@ module Glossarist
     CONCEPT_STATUSES = config.dig("concept", "status").freeze
 
     DESIGNATION_RELATIONSHIP_TYPES = config.dig("designation",
-                                                 "relationship_type")&.freeze
+                                                "relationship_type")&.freeze
 
     ISO12620_TERM_TYPES = config.dig("iso12620", "term_type").freeze
   end