glossarist 2.8.7 → 2.8.11

data/lib/glossarist/concept_collector.rb

@@ -1,231 +0,0 @@
-# frozen_string_literal: true
-
-module Glossarist
-  class ConceptCollector
-    def self.collect(dir)
-      dir = File.expand_path(dir)
-      unless File.directory?(dir)
-        raise ArgumentError, "#{dir} is not a directory"
-      end
-
-      if v2_concepts?(dir)
-        collect_v2_concepts(dir)
-      elsif managed_concepts?(dir)
-        collect_managed_concepts(dir)
-      elsif v1_concepts?(dir)
-        collect_v1_concepts(dir)
-      else
-        []
-      end
-    end
-
-    def self.each_concept(dir, &block)
-      dir = File.expand_path(dir)
-      unless File.directory?(dir)
-        raise ArgumentError, "#{dir} is not a directory"
-      end
-      return enum_for(:each_concept, dir) unless block
-
-      if v2_concepts?(dir)
-        each_v2_concept(dir, &block)
-      elsif managed_concepts?(dir)
-        each_managed_concept(dir, &block)
-      elsif v1_concepts?(dir)
-        each_v1_concept(dir, &block)
-      end
-    end
-
-    def self.count(dir)
-      dir = File.expand_path(dir)
-      return 0 unless File.directory?(dir)
-
-      if managed_concepts?(dir)
-        Dir.glob(File.join(dir, "concepts", "concept", "*.yaml")).length
-      elsif v2_concepts?(dir)
-        count_v2(dir)
-      elsif v1_concepts?(dir)
-        Dir.glob(File.join(dir, "concepts", "*.yaml")).length
-      else
-        0
-      end
-    end
-
-    class << self
-      private
-
-      def count_v2(dir)
-        if v2_flat_concepts?(dir)
-          Dir.glob(File.join(dir, "concepts", "*.yaml")).length
-        else
-          v2_dir = File.join(dir, "geolexica-v2")
-          if File.directory?(File.join(v2_dir, "concepts"))
-            Dir.glob(File.join(v2_dir, "concepts", "concept", "*.yaml")).length
-          else
-            Dir.glob(File.join(v2_dir, "*.yaml")).length
-          end
-        end
-      end
-
-      def v1_concepts?(dir)
-        concepts_dir = File.join(dir, "concepts")
-        File.directory?(concepts_dir) &&
-          !v2_flat_concepts?(dir) &&
-          !managed_concepts?(dir) &&
-          Dir.glob(File.join(concepts_dir, "*.yaml")).any? do |f|
-            V1::Concept.from_file(f)&.termid?
-          end
-      end
-
-      def v2_concepts?(dir)
-        File.directory?(File.join(dir, "geolexica-v2")) ||
-          v2_flat_concepts?(dir)
-      end
-
-      def v2_flat_concepts?(dir)
-        return false if managed_concepts?(dir)
-
-        concepts_dir = File.join(dir, "concepts")
-        return false unless File.directory?(concepts_dir)
-
-        Dir.glob(File.join(concepts_dir, "*.yaml")).first(5).any? do |f|
-          v2_flat_concept_file?(f)
-        end
-      end
-
-      def v2_flat_concept_file?(path)
-        raw = File.read(path, encoding: "utf-8")
-        doc = ConceptDocument.from_yamls(raw)
-        !!doc.concept&.data&.id
-      rescue StandardError
-        false
-      end
-
-      def managed_concepts?(dir)
-        concept_dir = File.join(dir, "concepts", "concept")
-        File.directory?(concept_dir) &&
-          Dir.glob(File.join(concept_dir, "*.yaml")).any?
-      end
-
-      def collect_v1_concepts(dir)
-        concepts = []
-        each_v1_concept(dir) { |mc| concepts << mc }
-        concepts
-      end
-
-      def each_v1_concept(dir)
-        concepts_dir = File.join(dir, "concepts")
-        files = Dir.glob(File.join(concepts_dir, "*.yaml"))
-        files.each do |file|
-          v1 = V1::Concept.from_file(file)
-          next unless v1
-
-          yield v1.to_managed_concept
-        end
-      end
-
-      def collect_v2_concepts(dir)
-        if v2_flat_concepts?(dir)
-          collect_grouped_v2_concepts(File.join(dir, "concepts"))
-        else
-          v2_dir = File.join(dir, "geolexica-v2")
-          if File.directory?(File.join(v2_dir, "concepts"))
-            collect_managed_concepts(v2_dir)
-          else
-            collect_grouped_v2_concepts(v2_dir)
-          end
-        end
-      end
-
-      def each_v2_concept(dir, &)
-        if v2_flat_concepts?(dir)
-          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, &)
-          else
-            each_grouped_v2_concepts(v2_dir, &)
-          end
-        end
-      end
-
-      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(&)
-      end
-
-      def collect_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.to_a
-      end
-
-      def collect_managed_concepts(dir) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        concepts = []
-        each_managed_concept(dir) { |mc| concepts << mc }
-        concepts
-      end
-
-      def each_managed_concept(dir) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        concepts_dir = File.join(dir, "concepts")
-        concept_files = Dir.glob(File.join(concepts_dir, "concept", "*.yaml"))
-        return if concept_files.empty?
-
-        lc_dir = find_localized_concepts_dir(concepts_dir)
-        lc_index = build_lc_index(lc_dir) if lc_dir
-
-        concept_files.each do |f|
-          mc = ManagedConcept.from_yaml(File.read(f))
-          next unless mc.data&.id
-
-          lc_map = mc.data.localized_concepts || {}
-          lc_map.each_value do |uuid|
-            lc_file = lc_index ? lc_index[uuid] : nil
-            next unless lc_file
-
-            l10n = LocalizedConcept.from_yaml(File.read(lc_file))
-            mc.add_localization(l10n)
-          rescue StandardError
-            next
-          end
-
-          yield mc
-        rescue StandardError
-          next
-        end
-      end
-
-      def build_lc_index(lc_dir)
-        Dir.glob(File.join(lc_dir, "*.{yaml,yml}"))
-          .to_h { |f| [File.basename(f, ".*"), f] }
-      end
-
-      def find_localized_concepts_dir(concepts_dir)
-        %w[localized_concept localized-concept].each do |name|
-          d = File.join(concepts_dir, name)
-          return d if File.directory?(d)
-        end
-        nil
-      end
-
-      def detect_schema_version(dir)
-        concepts_dir = File.join(dir, "concepts")
-        search_dir = File.directory?(concepts_dir) ? concepts_dir : dir
-        sample = Dir.glob(File.join(search_dir, "*.yaml")).first
-        return "2" unless sample
-
-        raw = File.read(sample, encoding: "utf-8")
-        doc = ConceptDocument.from_yamls(raw)
-        ver = doc.concept&.schema_version.to_s
-        ver == "3" ? "3" : "2"
-      rescue StandardError
-        "2"
-      end
-    end
-  end
-end

data/lib/glossarist/concept_manager.rb

@@ -1,183 +0,0 @@
-module Glossarist
-  class ConceptManager < Lutaml::Model::Serializable
-    attribute :path, :string
-    attribute :localized_concepts_path, :string
-    attribute :version, :string, default: -> { "2" }
-
-    key_value do
-      map :path, to: :path
-      map %i[localized_concepts_path localizedConceptsPath],
-          to: :localized_concepts_path
-    end
-
-    def concept_document_class
-      ConceptDocument.for_version(version)
-    end
-
-    def localized_concept_class
-      if version.to_s == "2"
-        V2::LocalizedConcept
-      else
-        LocalizedConcept
-      end
-    end
-
-    def load_from_files(collection: nil)
-      collection ||= ManagedConceptCollection.new
-
-      Dir.glob(concepts_glob) do |filename|
-        concepts = load_concept_from_file(filename)
-
-        concepts.each do |concept|
-          collection.store(concept)
-        end
-      rescue StandardError
-        next
-      end
-    end
-
-    def save_to_files(managed_concepts)
-      managed_concepts.each do |concept|
-        save_concept_to_file(concept)
-      end
-    end
-
-    def save_grouped_concepts_to_files(managed_concepts)
-      managed_concepts.each do |concept|
-        save_grouped_concepts_to_file(concept)
-      end
-    end
-
-    def load_concept_from_file(filename) # rubocop:disable Metrics/CyclomaticComplexity
-      raw = File.read(filename, encoding: "utf-8")
-      self.version = detect_version(raw)
-      doc = concept_document_class.from_yamls(raw)
-      concept = doc.concept
-      unless concept
-        raise Glossarist::ParseError.new(filename: filename)
-      end
-
-      concept_uuid = concept.identifier || concept.data&.id || File.basename(
-        filename, ".*"
-      )
-      concept.uuid = concept_uuid
-
-      concept.data.localized_concepts.each_value do |id|
-        localized_concept = load_localized_concept(id, doc.localizations)
-        concept.add_l10n(localized_concept)
-      end
-
-      [concept]
-    rescue Psych::SyntaxError => e
-      raise Glossarist::ParseError.new(filename: filename, line: e.line)
-    end
-
-    def load_localized_concept(id, inline_localizations = nil)
-      if inline_localizations
-        l10n = inline_localizations.find { |l| l.id == id }
-        if l10n
-          l10n.uuid = id
-          return l10n
-        end
-      end
-
-      l10n = localized_concept_class.from_yaml(
-        File.read(localized_concept_path(id), encoding: "utf-8"),
-      )
-      l10n.uuid = id
-      l10n
-    rescue Psych::SyntaxError => e
-      raise Glossarist::ParseError.new(filename: filename, line: e.line)
-    end
-
-    def save_concept_to_file(concept)
-      @localized_concepts_path ||= "localized_concept"
-      concept_dir = File.join(path, "concept")
-
-      localized_concept_dir = File.join(path, @localized_concepts_path)
-
-      FileUtils.mkdir_p(concept_dir)
-      FileUtils.mkdir_p(localized_concept_dir)
-
-      filename = File.join(concept_dir, "#{concept.uuid}.yaml")
-      File.write(filename, concept.to_yaml, encoding: "utf-8")
-
-      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")
-      end
-    end
-
-    def save_grouped_concepts_to_file(concept)
-      @localized_concepts_path ||= "localized_concept"
-      concept_dir = File.join(path)
-
-      FileUtils.mkdir_p(concept_dir)
-
-      content = []
-
-      filename = File.join(concept_dir, "#{concept.uuid}.yaml")
-      content << concept.to_yaml
-
-      concept.localized_concepts.each_key do |lang|
-        content << concept.localization(lang).to_yaml
-      end
-
-      File.write(filename, content.join("\n"), encoding: "utf-8")
-    end
-
-    def concepts_glob
-      return path if File.file?(path)
-
-      if v1_collection?
-        File.join(path, "concept-*.{yaml,yml}")
-      else
-        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
-
-    def localized_concept_path(id)
-      localized_concept_possible_dir = {
-        "localized_concept" => File.join(
-          path,
-          "localized_concept",
-          "#{id}.{yaml,yml}",
-        ),
-
-        "localized-concept" => File.join(
-          path,
-          "localized-concept",
-          "#{id}.{yaml,yml}",
-        ),
-      }
-
-      localized_concept_possible_dir.each do |dir_name, file_path|
-        actual_path = Dir.glob(file_path)&.first
-
-        if actual_path
-          @localized_concepts_path = dir_name
-          return actual_path
-        end
-      end
-    end
-
-    def detect_version(raw)
-      if (m = raw.match(/^schema_version:\s*v?(\d)/))
-        m[1]
-      else
-        version
-      end
-    end
-
-    def v1_collection?
-      @v1_collection ||= !Dir.glob(File.join(path,
-                                             "concept-*.{yaml,yml}")).empty?
-    end
-  end
-end

data/lib/glossarist/error/cache_version_mismatch_error.rb

@@ -1,8 +0,0 @@
-module Glossarist
-  class CacheVersionMismatchError < Error
-    def initialize(cache_dir, expected, actual)
-      super("Relaton cache version mismatch in '#{cache_dir}': " \
-            "expected '#{expected}', got '#{actual}'")
-    end
-  end
-end

data/lib/glossarist/error/invalid_language_code_error.rb

@@ -1,15 +0,0 @@
-module Glossarist
-  class InvalidLanguageCodeError < Error
-    attr_reader :code
-
-    def initialize(code:)
-      @code = code
-
-      super()
-    end
-
-    def to_s
-      "Invalid value for language_code: `#{code}`. It must be 3 characters long string."
-    end
-  end
-end

data/lib/glossarist/error/invalid_type_error.rb

@@ -1,4 +0,0 @@
-module Glossarist
-  class InvalidTypeError < Error
-  end
-end

data/lib/glossarist/error/parse_error.rb

@@ -1,16 +0,0 @@
-module Glossarist
-  class ParseError < Error
-    attr_accessor :line, :filename
-
-    def initialize(filename:, line: nil)
-      @filename = filename
-      @line = line
-
-      super()
-    end
-
-    def to_s
-      "Unable to parse file: #{filename}, error on line: #{line}"
-    end
-  end
-end