glossarist 2.8.7 → 2.8.11

data/lib/glossarist/schema_migration/v0_to_v1.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class SchemaMigration
+    class V0ToV1
+      ENTRY_STATUS_MAP = {
+        "Standard" => "valid",
+        "Confirmed" => "valid",
+        "Proposed" => "draft",
+      }.freeze
+
+      LANG_CODES = Glossarist::LANG_CODES
+
+      IEV_PATTERN = /\{\{([^,}]+),\s*IEV:([^}]+)\}\}/
+      URN_PATTERN = /\{urn:iso:std:iso:(\d+):([^,}]+),([^}]+)\}/
+
+      attr_reader :from_version, :to_version
+
+      def initialize(concept_hash, from_version: "0",
+                               to_version: SchemaMigration::CURRENT_SCHEMA_VERSION,
+                               ref_maps: {})
+        @concept = concept_hash
+        @from_version = from_version
+        @to_version = to_version
+        @ref_maps = ref_maps
+      end
+
+      def migrate
+        case [from_version, to_version]
+        when ["0", "1"] then migrate_v0_to_v1
+        else
+          raise Errors::Base,
+                "Unsupported migration: #{from_version} -> #{to_version}"
+        end
+        @concept
+      end
+
+      private
+
+      def migrate_v0_to_v1
+        migrate_termid
+        LANG_CODES.each do |lang|
+          migrate_language_block(lang) if @concept[lang]
+        end
+        strip_revisions
+      end
+
+      def migrate_termid
+        if @concept.key?("termid")
+          @concept["termid"] =
+            String(@concept["termid"])
+        end
+      end
+
+      def migrate_language_block(lang)
+        l10n_block = @concept[lang]
+        return unless l10n_block.is_a?(Hash)
+
+        migrate_definition(l10n_block)
+        migrate_authoritative_source(l10n_block)
+        migrate_dates(l10n_block)
+        migrate_entry_status(l10n_block)
+        migrate_terms_abbrev(l10n_block)
+        extract_inline_refs(l10n_block)
+        strip_revisions(l10n_block)
+      end
+
+      def migrate_definition(l10n_block)
+        return unless l10n_block.key?("definition")
+        return unless l10n_block["definition"].is_a?(String)
+
+        l10n_block["definition"] = [{ "content" => l10n_block["definition"] }]
+      end
+
+      def migrate_authoritative_source(l10n_block)
+        return unless l10n_block.key?("authoritative_source")
+
+        src = l10n_block.delete("authoritative_source")
+        return if l10n_block.key?("sources")
+
+        sources = (src.is_a?(Array) ? src : [src]).filter_map do |s|
+          next unless s.is_a?(Hash)
+
+          origin = {}
+          origin["ref"] = s["ref"] if s["ref"]
+          origin["clause"] = s["clause"] if s["clause"]
+          origin["link"] = s["link"] if s["link"]
+
+          entry = { "type" => "authoritative", "origin" => origin }
+          if s["relationship"]
+            entry["status"] = s["relationship"]["type"] || "identical"
+            if s["relationship"]["modification"]
+              entry["modification"] =
+                s["relationship"]["modification"]
+            end
+          end
+          entry
+        end
+
+        l10n_block["sources"] = sources if sources.any?
+      end
+
+      def migrate_dates(l10n_block)
+        return if l10n_block.key?("dates")
+
+        dates = []
+        if l10n_block["date_accepted"]
+          dates << { "type" => "accepted",
+                     "date" => l10n_block["date_accepted"] }
+        end
+        if l10n_block["date_amended"]
+          dates << { "type" => "amended", "date" => l10n_block["date_amended"] }
+        end
+        l10n_block["dates"] = dates if dates.any?
+      end
+
+      def migrate_entry_status(l10n_block)
+        return unless l10n_block.key?("entry_status")
+
+        mapped = ENTRY_STATUS_MAP[l10n_block["entry_status"]]
+        l10n_block["entry_status"] = mapped if mapped
+      end
+
+      def migrate_terms_abbrev(l10n_block)
+        return unless l10n_block["terms"].is_a?(Array)
+
+        l10n_block["terms"].each do |term|
+          next unless term.is_a?(Hash)
+          next unless term["abbrev"] == true
+
+          term["type"] = "abbreviation"
+          term.delete("abbrev")
+        end
+      end
+
+      def extract_inline_refs(l10n_block)
+        texts = []
+
+        if l10n_block["definition"].is_a?(Array)
+          l10n_block["definition"].each do |d|
+            texts << (d.is_a?(Hash) ? d["content"].to_s : d.to_s)
+          end
+        elsif l10n_block["definition"].is_a?(String)
+          texts << l10n_block["definition"]
+        end
+
+        Array(l10n_block["notes"]).each do |n|
+          texts << (n.is_a?(Hash) ? n["content"].to_s : n.to_s)
+        end
+        Array(l10n_block["examples"]).each do |e|
+          texts << (e.is_a?(Hash) ? e["content"].to_s : e.to_s)
+        end
+
+        full_text = texts.join(" ")
+
+        refs = []
+
+        full_text.scan(IEV_PATTERN) do |term, id|
+          refs << {
+            "term" => term.strip,
+            "concept_id" => id.strip,
+            "source" => "urn:iec:std:iec:60050",
+            "ref_type" => "urn",
+          }
+        end
+
+        full_text.scan(URN_PATTERN) do |std_num, id, term|
+          refs << {
+            "term" => term.strip,
+            "concept_id" => id.strip,
+            "source" => "urn:iso:std:iso:#{std_num}",
+            "ref_type" => "urn",
+          }
+        end
+
+        return if refs.empty?
+
+        existing = l10n_block["references"] || []
+        seen_ids = existing.to_set { |r| r["concept_id"] || r["id"] }
+        refs.each do |ref|
+          key = ref["concept_id"] || ref["id"]
+          next if seen_ids.include?(key)
+
+          seen_ids.add(key)
+          existing << ref
+        end
+        l10n_block["references"] = existing
+      end
+
+      def strip_revisions(hash = @concept)
+        hash.delete("_revisions")
+        LANG_CODES.each do |lang|
+          next unless hash[lang].is_a?(Hash)
+
+          hash[lang].delete("_revisions")
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/schema_migration/v2_to_v3.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class SchemaMigration
+    module V2ToV3
+      def self.migrate_concept(concept, target_version: Glossarist::SCHEMA_VERSION)
+        current = concept_version(concept)
+        target = target_version.to_s
+
+        return concept if current == target
+
+        max_steps = 5
+        max_steps.times do
+          break if current == target
+
+          case current
+          when "2" then current = step_v2_to_v3(concept)
+          else
+            raise Errors::Base,
+                  "No concept migration step from version #{current}"
+          end
+        end
+
+        unless current == target
+          raise Errors::Base,
+                "Migration chain too long or unresolvable"
+        end
+
+        concept.schema_version = target
+        concept
+      end
+
+      def self.concept_version(concept)
+        version = concept.schema_version
+        return version.to_s if version && !version.to_s.empty?
+
+        ManagedConcept.detect_schema_version(concept)
+      end
+
+      def self.step_v2_to_v3(concept)
+        if concept.data&.related&.any?
+          concept.related ||= []
+          concept.related = (concept.related + concept.data.related).uniq
+          concept.data.related = []
+        end
+        "3"
+      end
+    end
+  end
+end

data/lib/glossarist/schema_migration.rb

@@ -6,76 +6,19 @@ module Glossarist
   class SchemaMigration
     CURRENT_SCHEMA_VERSION = "1"
 
-    def self.migrate_concept(concept, target_version: Glossarist::SCHEMA_VERSION)
-      current = concept_version(concept)
-      target = target_version.to_s
-
-      return concept if current == target
-
-      max_steps = 5
-      max_steps.times do
-        break if current == target
-
-        case current
-        when "2" then current = step_v2_to_v3(concept)
-        else
-          raise Error, "No concept migration step from version #{current}"
-        end
-      end
-
-      unless current == target
-        raise Error,
-              "Migration chain too long or unresolvable"
-      end
-
-      concept.schema_version = target
-      concept
-    end
-
-    def self.concept_version(concept)
-      version = concept.schema_version
-      return version.to_s if version && !version.to_s.empty?
-
-      ManagedConcept.detect_schema_version(concept)
-    end
+    autoload :V0ToV1, "glossarist/schema_migration/v0_to_v1"
+    autoload :V2ToV3, "glossarist/schema_migration/v2_to_v3"
 
-    def self.step_v2_to_v3(concept)
-      if concept.data&.related&.any?
-        concept.related ||= []
-        concept.related = (concept.related + concept.data.related).uniq
-        concept.data.related = []
-      end
-      "3"
+    def self.new(...)
+      V0ToV1.new(...)
     end
 
-    ENTRY_STATUS_MAP = {
-      "Standard" => "valid",
-      "Confirmed" => "valid",
-      "Proposed" => "draft",
-    }.freeze
-
-    LANG_CODES = Glossarist::LANG_CODES
-
-    IEV_PATTERN = /\{\{([^,}]+),\s*IEV:([^}]+)\}\}/
-    URN_PATTERN = /\{urn:iso:std:iso:(\d+):([^,}]+),([^}]+)\}/
-
-    attr_reader :from_version, :to_version
-
-    def initialize(concept_hash, from_version: "0",
-                             to_version: CURRENT_SCHEMA_VERSION, ref_maps: {})
-      @concept = concept_hash
-      @from_version = from_version
-      @to_version = to_version
-      @ref_maps = ref_maps
+    def self.migrate_concept(concept, target_version: Glossarist::SCHEMA_VERSION)
+      V2ToV3.migrate_concept(concept, target_version: target_version)
     end
 
-    def migrate
-      case [from_version, to_version]
-      when ["0", "1"] then migrate_v0_to_v1
-      else
-        raise Error, "Unsupported migration: #{from_version} -> #{to_version}"
-      end
-      @concept
+    def self.concept_version(concept)
+      V2ToV3.concept_version(concept)
     end
 
     def self.upgrade_directory(source_dir, output:, # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
@@ -112,163 +55,6 @@ module Glossarist
       }
     end
 
-    private
-
-    def migrate_v0_to_v1
-      migrate_termid
-      LANG_CODES.each do |lang|
-        migrate_language_block(lang) if @concept[lang]
-      end
-      strip_revisions
-    end
-
-    def migrate_termid
-      @concept["termid"] = String(@concept["termid"]) if @concept.key?("termid")
-    end
-
-    def migrate_language_block(lang)
-      lc = @concept[lang]
-      return unless lc.is_a?(Hash)
-
-      migrate_definition(lc)
-      migrate_authoritative_source(lc)
-      migrate_dates(lc)
-      migrate_entry_status(lc)
-      migrate_terms_abbrev(lc)
-      extract_inline_refs(lc)
-      strip_revisions(lc)
-    end
-
-    def migrate_definition(lc)
-      return unless lc.key?("definition")
-      return unless lc["definition"].is_a?(String)
-
-      lc["definition"] = [{ "content" => lc["definition"] }]
-    end
-
-    def migrate_authoritative_source(lc)
-      return unless lc.key?("authoritative_source")
-
-      src = lc.delete("authoritative_source")
-      return if lc.key?("sources")
-
-      sources = (src.is_a?(Array) ? src : [src]).filter_map do |s|
-        next unless s.is_a?(Hash)
-
-        origin = {}
-        origin["ref"] = s["ref"] if s["ref"]
-        origin["clause"] = s["clause"] if s["clause"]
-        origin["link"] = s["link"] if s["link"]
-
-        entry = { "type" => "authoritative", "origin" => origin }
-        if s["relationship"]
-          entry["status"] = s["relationship"]["type"] || "identical"
-          if s["relationship"]["modification"]
-            entry["modification"] =
-              s["relationship"]["modification"]
-          end
-        end
-        entry
-      end
-
-      lc["sources"] = sources if sources.any?
-    end
-
-    def migrate_dates(lc)
-      return if lc.key?("dates")
-
-      dates = []
-      if lc["date_accepted"]
-        dates << { "type" => "accepted", "date" => lc["date_accepted"] }
-      end
-      if lc["date_amended"]
-        dates << { "type" => "amended", "date" => lc["date_amended"] }
-      end
-      lc["dates"] = dates if dates.any?
-    end
-
-    def migrate_entry_status(lc)
-      return unless lc.key?("entry_status")
-
-      mapped = ENTRY_STATUS_MAP[lc["entry_status"]]
-      lc["entry_status"] = mapped if mapped
-    end
-
-    def migrate_terms_abbrev(lc)
-      return unless lc["terms"].is_a?(Array)
-
-      lc["terms"].each do |term|
-        next unless term.is_a?(Hash)
-        next unless term["abbrev"] == true
-
-        term["type"] = "abbreviation"
-        term.delete("abbrev")
-      end
-    end
-
-    def extract_inline_refs(lc)
-      texts = []
-
-      if lc["definition"].is_a?(Array)
-        lc["definition"].each do |d|
-          texts << (d.is_a?(Hash) ? d["content"].to_s : d.to_s)
-        end
-      elsif lc["definition"].is_a?(String)
-        texts << lc["definition"]
-      end
-
-      Array(lc["notes"]).each do |n|
-        texts << (n.is_a?(Hash) ? n["content"].to_s : n.to_s)
-      end
-      Array(lc["examples"]).each do |e|
-        texts << (e.is_a?(Hash) ? e["content"].to_s : e.to_s)
-      end
-
-      full_text = texts.join(" ")
-
-      refs = []
-
-      full_text.scan(IEV_PATTERN) do |term, id|
-        refs << {
-          "term" => term.strip,
-          "concept_id" => id.strip,
-          "source" => "urn:iec:std:iec:60050",
-          "ref_type" => "urn",
-        }
-      end
-
-      full_text.scan(URN_PATTERN) do |std_num, id, term|
-        refs << {
-          "term" => term.strip,
-          "concept_id" => id.strip,
-          "source" => "urn:iso:std:iso:#{std_num}",
-          "ref_type" => "urn",
-        }
-      end
-
-      return if refs.empty?
-
-      existing = lc["references"] || []
-      seen_ids = existing.to_set { |r| r["concept_id"] || r["id"] }
-      refs.each do |ref|
-        key = ref["concept_id"] || ref["id"]
-        next if seen_ids.include?(key)
-
-        seen_ids.add(key)
-        existing << ref
-      end
-      lc["references"] = existing
-    end
-
-    def strip_revisions(hash = @concept)
-      hash.delete("_revisions")
-      LANG_CODES.each do |lang|
-        next unless hash[lang].is_a?(Hash)
-
-        hash[lang].delete("_revisions")
-      end
-    end
-
     class << self
       private
 
@@ -301,14 +87,14 @@ module Glossarist
           v1 = V1::Concept.from_file(file)
           next unless v1
 
-          migration = new(
+          migration = V0ToV1.new(
             v1.to_yaml_hash,
             from_version: source_version,
             to_version: target_version,
             ref_maps: ref_maps,
           )
           concepts << migration.migrate
-        rescue StandardError => e
+        rescue Errors::Base, Psych::SyntaxError => e
           errors += 1
           warn "  Error migrating #{File.basename(file)}: #{e.message}" if errors <= 5
         end

data/lib/glossarist/sts/importer.rb

@@ -184,8 +184,9 @@ module Glossarist
           package = GcrPackage.load(path)
           package.concepts.each { |mc| collection.store(mc) }
         else
-          concepts = ConceptCollector.collect(path)
-          concepts.each { |mc| collection.store(mc) }
+          GlossaryStore.new.tap do |s|
+            s.load(path)
+          end.each_concept { |mc| collection.store(mc) }
         end
         collection
       end
@@ -214,11 +215,10 @@ module Glossarist
       end
 
       def save_dataset(concepts, dir)
-        concepts_dir = File.join(dir, "concepts")
-        FileUtils.mkdir_p(concepts_dir)
-        collection = ManagedConceptCollection.new
-        concepts.each { |mc| collection.store(mc) }
-        collection.save_grouped_concepts_to_files(concepts_dir)
+        FileUtils.mkdir_p(dir)
+        store = GlossaryStore.new
+        concepts.each { |mc| store.add_concept(mc) }
+        store.save_directory(dir)
       end
 
       def create_gcr(concepts, output, shortname:, version:, **opts)
@@ -238,12 +238,11 @@ module Glossarist
 
       def build_temp_dataset(concepts)
         tmpdir = Dir.mktmpdir("glossarist-sts-import")
-        concepts_dir = File.join(tmpdir, "concepts")
-        FileUtils.mkdir_p(concepts_dir)
+        FileUtils.mkdir_p(tmpdir)
 
-        collection = ManagedConceptCollection.new
-        concepts.each { |mc| collection.store(mc) }
-        collection.save_grouped_concepts_to_files(concepts_dir)
+        store = GlossaryStore.new
+        concepts.each { |mc| store.add_concept(mc) }
+        store.save_directory(tmpdir)
 
         tmpdir
       end