glossarist 2.8.2 → 2.8.5

data/lib/glossarist/concept_store.rb

@@ -1,29 +1,24 @@
 # 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)
+    # 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 +27,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_register.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class DatasetRegister < Lutaml::Model::Serializable
+    attribute :schema_type, :string, default: -> { "glossarist" }
+    attribute :schema_version, :string, default: -> { "3" }
+    attribute :id, :string
+    attribute :ref, :string
+    attribute :year, :integer
+    attribute :urn, :string
+    attribute :urn_aliases, :string, collection: true
+    attribute :ref_aliases, :string, collection: true
+    attribute :status, :string
+    attribute :supersedes, :string
+    attribute :owner, :string
+    attribute :source_repo, :string
+    attribute :tags, :string, collection: true
+    attribute :languages, :string, collection: true
+    attribute :language_order, :string, collection: true
+    attribute :ordering, :string
+    attribute :sections, Section, collection: true
+    attribute :description, :hash
+    attribute :about, :hash
+    attribute :logo, :string
+
+    key_value do
+      map "schema_type", to: :schema_type
+      map "schema_version", to: :schema_version
+      map "id", to: :id
+      map "ref", to: :ref
+      map "year", to: :year
+      map "urn", to: :urn
+      map "urnAliases", to: :urn_aliases
+      map "refAliases", to: :ref_aliases
+      map "status", to: :status
+      map "supersedes", to: :supersedes
+      map "owner", to: :owner
+      map "sourceRepo", to: :source_repo
+      map "tags", to: :tags
+      map "languages", to: :languages
+      map "languageOrder", to: :language_order
+      map "ordering", to: :ordering
+      map "sections", to: :sections
+      map "description", to: :description
+      map "about", to: :about
+      map "logo", to: :logo
+    end
+
+    def section_by_id(target_id)
+      sections&.each do |section|
+        return section if section.id == target_id
+
+        found = section.descendant_by_id(target_id)
+        return found if found
+      end
+      nil
+    end
+
+    def self.from_file(path)
+      return nil unless File.exist?(path)
+
+      from_yaml(File.read(path, encoding: "utf-8"))
+    end
+
+    def self.from_directory(dir)
+      register_path = File.join(dir, "register.yaml")
+      return nil unless File.exist?(register_path)
+
+      from_file(register_path)
+    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_metadata.rb

@@ -21,6 +21,7 @@ module Glossarist
     attribute :concept_uri_template, :string
     attribute :compiled_formats, :string, collection: true
     attribute :external_references, :hash, collection: true
+    attribute :translations, :hash, default: -> { {} }
 
     key_value do
       map :shortname, to: :shortname
@@ -42,28 +43,30 @@ module Glossarist
       map :concept_uri_template, to: :concept_uri_template
       map :compiled_formats, to: :compiled_formats
       map :external_references, to: :external_references
+      map :translations, to: :translations
     end
 
     def self.from_concepts(concepts, register_data: nil, options: {})
       stats = GcrStatistics.from_concepts(concepts)
       rd = register_data
       new(
-        shortname: options[:shortname] || rd&.[]("shortname") || rd&.[]("id"),
-        version: options[:version] || rd&.[]("version"),
-        title: options[:title] || rd&.[]("name"),
-        description: options[:description] || rd&.[]("description"),
+        shortname: options[:shortname] || rd&.shortname,
+        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: rd&.[]("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],
         compiled_formats: options[:compiled_formats] || [],
         external_references: derive_external_references(concepts),
+        translations: rd&.translations || {},
       )
     end
 

data/lib/glossarist/gcr_package_definition.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+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,198 @@
+# frozen_string_literal: true
+
+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+

data/lib/glossarist/rdf/gloss_citation.rb

@@ -18,10 +18,14 @@ module Glossarist
 
         types "gloss:Citation"
 
-        predicate :citationSource, namespace: Namespaces::GlossaristNamespace, to: :source
-        predicate :citationId, namespace: Namespaces::GlossaristNamespace, to: :id
-        predicate :citationVersion, namespace: Namespaces::GlossaristNamespace, to: :version
-        predicate :citationLink, namespace: Namespaces::GlossaristNamespace, to: :link
+        predicate :citationSource, namespace: Namespaces::GlossaristNamespace,
+                                   to: :source
+        predicate :citationId, namespace: Namespaces::GlossaristNamespace,
+                               to: :id
+        predicate :citationVersion, namespace: Namespaces::GlossaristNamespace,
+                                    to: :version
+        predicate :citationLink, namespace: Namespaces::GlossaristNamespace,
+                                 to: :link
 
         members :locality, link: "gloss:hasLocality"
       end

data/lib/glossarist/rdf/gloss_concept.rb

@@ -28,8 +28,10 @@ module Glossarist
 
         types "gloss:Concept", "skos:Concept"
 
-        predicate :identifier, namespace: Namespaces::GlossaristNamespace, to: :identifier
-        predicate :hasStatus, namespace: Namespaces::GlossaristNamespace, to: :status, uri_reference: true
+        predicate :identifier, namespace: Namespaces::GlossaristNamespace,
+                               to: :identifier
+        predicate :hasStatus, namespace: Namespaces::GlossaristNamespace,
+                              to: :status, uri_reference: true
 
         members :localizations,
                 link: "gloss:hasLocalization"
@@ -41,7 +43,8 @@ module Glossarist
                 link: "gloss:hasDate"
 
         RelationshipPredicates::CONCEPT_REL_PREDICATES.each do |type, (ns, name)|
-          predicate name, namespace: ns, to: :"#{type}_targets", uri_reference: true
+          predicate name, namespace: ns, to: :"#{type}_targets",
+                          uri_reference: true
         end
       end
     end

data/lib/glossarist/rdf/gloss_concept_date.rb

@@ -16,8 +16,10 @@ module Glossarist
 
         types "gloss:ConceptDate"
 
-        predicate :dateValue, namespace: Namespaces::GlossaristNamespace, to: :date_value
-        predicate :dateType, namespace: Namespaces::GlossaristNamespace, to: :date_type, uri_reference: true
+        predicate :dateValue, namespace: Namespaces::GlossaristNamespace,
+                              to: :date_value
+        predicate :dateType, namespace: Namespaces::GlossaristNamespace,
+                             to: :date_type, uri_reference: true
       end
     end
   end

data/lib/glossarist/rdf/gloss_concept_reference.rb

@@ -19,9 +19,12 @@ module Glossarist
 
         types "gloss:ConceptReference"
 
-        predicate :refType, namespace: Namespaces::GlossaristNamespace, to: :ref_type
-        predicate :conceptId, namespace: Namespaces::GlossaristNamespace, to: :concept_id
-        predicate :sourceUri, namespace: Namespaces::GlossaristNamespace, to: :source
+        predicate :refType, namespace: Namespaces::GlossaristNamespace,
+                            to: :ref_type
+        predicate :conceptId, namespace: Namespaces::GlossaristNamespace,
+                              to: :concept_id
+        predicate :sourceUri, namespace: Namespaces::GlossaristNamespace,
+                              to: :source
         predicate :urn, namespace: Namespaces::GlossaristNamespace, to: :urn
       end
     end

data/lib/glossarist/rdf/gloss_concept_source.rb

@@ -17,9 +17,12 @@ module Glossarist
 
         types "gloss:ConceptSource"
 
-        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
+        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"
       end