glossarist 2.8.2 → 2.8.4

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
 

data/lib/glossarist/concept_manager.rb

@@ -132,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

@@ -4,26 +4,23 @@ 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)
+    # Serializes ConceptDocument for storage in lutaml-store.
+    # Stores the YAML stream string to preserve the full concept + localizations.
+    class ConceptDocumentSerializer
+      def serialize(concept_document)
         {
-          "_yaml" => model.to_yaml,
-          "_uuid" => model.uuid,
-          "_identifier" => model.identifier,
+          "_yamls" => concept_document.to_yamls,
+          "_id" => concept_document.id,
         }
       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
+        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
 
@@ -32,62 +29,55 @@ module Glossarist
     def initialize(adapter: :memory)
       @db = Lutaml::Store::DatabaseStore.new(
         adapter: adapter,
-        models: [managed_concept_registration],
+        models: [concept_document_registration],
       )
     end
 
-    def save(concept)
-      db.save(concept)
-    end
-
-    def fetch(uuid)
-      db.fetch(model: ManagedConcept, uuid: uuid)
-    end
+    def load_glossary(path)
+      documents = db.load_all(
+        V3::ConceptDocument, path: path, format: :yamls, layout: :grouped
+      )
 
-    def fetch_by_id(identifier)
-      db.where(model: ManagedConcept, identifier: identifier).first
-    end
+      documents.each do |doc|
+        concept = doc.concept
+        concept.uuid = doc.id
+        db.save(doc)
+      end
 
-    def update(uuid, **attributes)
-      db.update(model: ManagedConcept, uuid: uuid, attributes: attributes)
+      documents
     end
 
-    def delete(uuid)
-      db.destroy(model: ManagedConcept, uuid: uuid)
+    def fetch(uuid)
+      doc = db.fetch(model: V3::ConceptDocument, id: uuid)
+      doc&.concept
     end
 
-    def all
-      db.all(model: ManagedConcept)
+    def concepts
+      db.all(model: V3::ConceptDocument).map(&:concept)
     end
 
     def count
-      db.count(model: ManagedConcept)
+      db.count(model: V3::ConceptDocument)
     end
 
     def exists?(uuid)
-      db.exists?(model: ManagedConcept, uuid: uuid)
+      db.exists?(model: V3::ConceptDocument, id: 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)
+      db.all(model: V3::ConceptDocument).each do |doc|
+        db.destroy(model: V3::ConceptDocument, id: doc.id)
+      end
     end
 
     private
 
-    def managed_concept_registration
+    def concept_document_registration
       {
-        model: ManagedConcept,
-        key: :uuid,
-        dir: "concept",
-        serializer: Serializer.new,
+        model: V3::ConceptDocument,
+        key: :id,
+        dir: "concepts",
+        serializer: ConceptDocumentSerializer.new,
       }
     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

data/lib/glossarist/glossary_store.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "lutaml/store"
+require "zip"
+
+module Glossarist
+  class GlossaryStore
+    attr_reader :package
+
+    def initialize
+      @package = nil
+      @concept_document_class = V3::ConceptDocument
+    end
+
+    # ── Load ──
+
+    def load_directory(path, format: nil)
+      metadata = load_metadata_from_directory(path)
+      @concept_document_class = resolve_concept_document_class(metadata)
+
+      definition = GcrPackageDefinition.definition(
+        concept_document_class: @concept_document_class,
+      )
+      @package = Lutaml::Store::PackageStore.load(
+        definition, path, transport: :directory, format: format
+      )
+
+      apply_metadata(metadata)
+      self
+    end
+
+    def load_zip(path, format: nil)
+      metadata = load_metadata_from_zip(path)
+      @concept_document_class = resolve_concept_document_class(metadata)
+
+      definition = GcrPackageDefinition.definition(
+        concept_document_class: @concept_document_class,
+      )
+      @package = Lutaml::Store::PackageStore.load(
+        definition, path, transport: :zip, format: format
+      )
+
+      apply_metadata(metadata)
+      self
+    end
+
+    def load(path, format: nil)
+      ext = File.extname(path).downcase
+      if [".gcr", ".zip"].include?(ext)
+        load_zip(path, format: format)
+      else
+        load_directory(path, format: format)
+      end
+    end
+
+    # ── Save ──
+
+    def save_directory(path, format: nil, formats: {})
+      @package.save(path, transport: :directory, format: format,
+                          formats: formats)
+    end
+
+    def save_zip(path, format: nil, formats: {})
+      @package.save(path, transport: :zip, format: format, formats: formats)
+    end
+
+    # ── Concepts ──
+
+    def concepts
+      @package.models_for(@concept_document_class).map(&:to_managed_concept)
+    end
+
+    def concept(uuid)
+      doc = @package.fetch_model(@concept_document_class, uuid)
+      doc&.to_managed_concept
+    end
+
+    def add_concept(managed_concept)
+      ensure_package
+      doc = @concept_document_class.from_managed_concept(managed_concept)
+      doc.id = managed_concept.uuid
+      @package.add_model(doc)
+    end
+
+    def remove_concept(uuid)
+      @package.remove_model(@concept_document_class, uuid)
+    end
+
+    def concept_count
+      @package.model_count(@concept_document_class)
+    end
+
+    def concept_exists?(uuid)
+      @package.model_exists?(@concept_document_class, uuid)
+    end
+
+    # ── Metadata ──
+
+    def metadata
+      @package&.metadata
+    end
+
+    def metadata=(value)
+      ensure_package
+      @package.metadata = value
+    end
+
+    # ── Register Data ──
+
+    def register_data
+      @package.models_for(RegisterData).first
+    end
+
+    def register_data=(value)
+      ensure_package
+      existing = register_data
+      @package.remove_model(RegisterData, existing.key) if existing
+      @package.add_model(value)
+    end
+
+    # ── Bibliography ──
+
+    def bibliography
+      @package.models_for(BibliographyData).first
+    end
+
+    def bibliography=(value)
+      ensure_package
+      existing = bibliography
+      @package.remove_model(BibliographyData, existing.shortname) if existing
+      @package.add_model(value)
+    end
+
+    # ── Images ──
+
+    def image(path)
+      @package.asset(path)
+    end
+
+    def add_image(path, content)
+      ensure_package
+      @package.add_asset(path, content)
+    end
+
+    def image_paths
+      @package.asset_paths.select { |p| p.start_with?("images/") }
+    end
+
+    # ── Stats ──
+
+    def stats
+      @package&.stats
+    end
+
+    # ── Convenience ──
+
+    def build_metadata(shortname:, version:, **opts)
+      GcrMetadata.from_concepts(concepts, register_data: register_data, options: {
+                                  shortname: shortname,
+                                  version: version,
+                                  **opts,
+                                })
+    end
+
+    private
+
+    def ensure_package
+      return if @package
+
+      definition = GcrPackageDefinition.definition(
+        concept_document_class: @concept_document_class,
+      )
+      @package = Lutaml::Store::PackageStore.new(definition)
+    end
+
+    def resolve_concept_document_class(metadata)
+      version = metadata&.schema_version.to_s
+      ConceptDocument.for_version(version)
+    end
+
+    def load_metadata_from_directory(path)
+      file_path = File.join(path, "metadata.yaml")
+      return nil unless File.exist?(file_path)
+
+      GcrMetadata.from_yaml(File.read(file_path, encoding: "utf-8"))
+    end
+
+    def load_metadata_from_zip(path)
+      Zip::File.open(path) do |zf|
+        entry = zf.find_entry("metadata.yaml")
+        return nil unless entry
+
+        GcrMetadata.from_yaml(entry.get_input_stream.read)
+      end
+    end
+
+    def apply_metadata(metadata)
+      @package.metadata = metadata if metadata && @package
+    end
+  end
+end

data/lib/glossarist/managed_concept_collection.rb

@@ -16,8 +16,8 @@ module Glossarist
       }.compact
     end
 
-    def each(&block)
-      @managed_concepts.each(&block)
+    def each(&)
+      @managed_concepts.each(&)
     end
 
     # Returns concept with given ID, if it is present in collection, or +nil+