fontist 1.8.3 → 1.8.8

data/lib/fontist/font_path.rb

@@ -0,0 +1,29 @@
+require "fontist/indexes/filename_index"
+
+module Fontist
+  class FontPath
+    def initialize(path)
+      @path = path
+    end
+
+    def to_s
+      [].tap do |s|
+        s << "-"
+        s << @path
+        s << "(from #{formulas.join(' or ')} formula)" if formulas.any?
+      end.join(" ")
+    end
+
+    def formulas
+      @formulas ||= if fontist_font?
+                      Indexes::FilenameIndex.from_yaml.load_index_formulas(File.basename(@path)).map(&:name)
+                    else
+                      []
+                    end
+    end
+
+    def fontist_font?
+      @path.start_with?(Fontist.fonts_path.to_s)
+    end
+  end
+end

data/lib/fontist/formula.rb

@@ -21,11 +21,15 @@ module Fontist
     end
 
     def self.find(font_name)
-      Index.from_yaml.load_formulas(font_name).first
+      Indexes::FontIndex.from_yaml.load_formulas(font_name).first
+    end
+
+    def self.find_many(font_name)
+      Indexes::FontIndex.from_yaml.load_formulas(font_name)
     end
 
     def self.find_fonts(font_name)
-      formulas = Index.from_yaml.load_formulas(font_name)
+      formulas = Indexes::FontIndex.from_yaml.load_formulas(font_name)
 
       formulas.map do |formula|
         formula.fonts.select do |f|
@@ -35,7 +39,7 @@ module Fontist
     end
 
     def self.find_styles(font_name, style_name)
-      formulas = Index.from_yaml.load_formulas(font_name)
+      formulas = Indexes::FontIndex.from_yaml.load_formulas(font_name)
 
       formulas.map do |formula|
         formula.fonts.map do |f|
@@ -57,7 +61,7 @@ module Fontist
     end
 
     def to_index_formula
-      IndexFormula.new(path)
+      Indexes::IndexFormula.new(path)
     end
 
     def path

data/lib/fontist/import/recursive_extraction.rb

@@ -1,25 +1,22 @@
-require "find"
-require_relative "extractors"
 require_relative "files/font_detector"
 
 module Fontist
   module Import
     class RecursiveExtraction
-      FONTS_PATTERN = "**/*.{ttf,otf,ttc}".freeze
-      ARCHIVE_EXTENSIONS = %w[zip msi exe cab].freeze
       LICENSE_PATTERN = /(ofl\.txt|ufl\.txt|licenses?\.txt|copying)$/i.freeze
 
       def initialize(archive, subarchive: nil, subdir: nil)
         @archive = archive
-        @subarchive = subarchive
         @subdir = subdir
-        @operations = []
+        @operations = {}
         @font_files = []
         @collection_files = []
+
+        save_operation_subdir
       end
 
       def extension
-        File.extname(filename(@archive)).sub(/^\./, "")
+        fetch_extension(@archive)
       end
 
       def font_files
@@ -39,11 +36,22 @@ module Fontist
 
       def operations
         ensure_extracted
-        @operations.size == 1 ? @operations.first : @operations
+        @operations
       end
 
       private
 
+      def save_operation_subdir
+        return unless @subdir
+
+        @operations[:options] ||= {}
+        @operations[:options][:fonts_sub_dir] = @subdir
+      end
+
+      def fetch_extension(file)
+        File.extname(filename(file)).sub(/^\./, "")
+      end
+
       def filename(file)
         if file.respond_to?(:original_filename)
           file.original_filename
@@ -53,58 +61,21 @@ module Fontist
       end
 
       def ensure_extracted
-        extracted_path
-      end
-
-      def extracted_path
-        @extracted_path ||= extract_recursively(@archive)
-      end
+        return if @extracted
 
-      def extract_recursively(archive)
-        path = operate_on_archive(archive)
-        match_files(path)
-        if matched?
-          save_operation_subdir
-          return path
-        end
-
-        next_archive = find_archive(path)
-        extract_recursively(next_archive)
-      end
-
-      def operate_on_archive(archive)
-        extractor = choose_extractor(archive)
-        Fontist.ui.say("Extracting #{archive} with #{extractor.class.name}")
-
-        save_operation(extractor)
-        extractor.extract
+        extract_data(@archive)
+        @extracted = true
       end
 
-      # rubocop:disable Metrics/MethodLength
-      def choose_extractor(archive)
-        case filename(archive)
-        when /\.msi$/i
-          Extractors::OleExtractor.new(archive)
-        when /\.cab$/i
-          Extractors::CabExtractor.new(archive)
-        when /\.exe$/i
-          extractor = Extractors::SevenZipExtractor.new(archive)
-          extractor.try ? extractor : Extractors::CabExtractor.new(archive)
-        else
-          Extractors::ZipExtractor.new(archive)
+      def extract_data(archive)
+        Excavate::Archive.new(path(archive)).files(recursive_packages: true) do |path|
+          match_license(path)
+          match_font(path) if font_directory?(path)
         end
       end
-      # rubocop:enable Metrics/MethodLength
 
-      def save_operation(extractor)
-        @operations << { format: extractor.format }
-      end
-
-      def match_files(dir_path)
-        Find.find(dir_path) do |entry_path| # rubocop:disable Style/CollectionMethods
-          match_license(entry_path)
-          match_font(entry_path) if font_directory?(entry_path, dir_path)
-        end
+      def path(file)
+        file.respond_to?(:path) ? file.path : file
       end
 
       def match_license(path)
@@ -115,18 +86,6 @@ module Fontist
         file.match?(LICENSE_PATTERN)
       end
 
-      def font_directory?(path, base_path)
-        return true unless @subdir
-
-        # https://bugs.ruby-lang.org/issues/10011
-        base_path = Pathname.new(base_path)
-
-        relative_path = Pathname.new(path).relative_path_from(base_path).to_s
-        dirname = File.dirname(relative_path)
-        normalized_pattern = @subdir.chomp("/")
-        File.fnmatch?(normalized_pattern, dirname)
-      end
-
       def match_font(path)
         case Files::FontDetector.detect(path)
         when :font
@@ -136,53 +95,14 @@ module Fontist
         end
       end
 
-      def matched?
-        [@font_files, @collection_files].any? do |files|
-          files.size.positive?
-        end
-      end
-
-      def save_operation_subdir
-        return unless @subdir
-
-        @operations.last[:options] ||= {}
-        @operations.last[:options][:fonts_sub_dir] = @subdir
-      end
-
-      def find_archive(path)
-        children = Dir.entries(path) - [".", ".."] # ruby 2.4 compat
-        paths = children.map { |file| File.join(path, file) }
-        by_subarchive(paths) || by_size(paths)
-      end
+      def font_directory?(path)
+        return true unless subdirectory_pattern
 
-      def by_subarchive(paths)
-        return unless @subarchive
-
-        path_found = paths.detect do |path|
-          @subarchive == File.basename(path)
-        end
-
-        return unless path_found
-
-        save_operation_subarchive(path_found)
-
-        path_found
-      end
-
-      def save_operation_subarchive(path)
-        @operations.last[:options] ||= {}
-        @operations.last[:options][:subarchive] = File.basename(path)
-      end
-
-      def by_size(paths)
-        paths.max_by do |path|
-          [file_type(path), File.size(path)]
-        end
+        File.fnmatch?(subdirectory_pattern, File.dirname(path))
       end
 
-      def file_type(file_path)
-        extension = File.extname(file_path).delete(".")
-        ARCHIVE_EXTENSIONS.include?(extension) ? 1 : 0
+      def subdirectory_pattern
+        @subdirectory_pattern ||= "*" + @subdir.chomp("/") if @subdir
       end
     end
   end

data/lib/fontist/index.rb

@@ -1,72 +1,11 @@
-require_relative "index_formula"
+require_relative "indexes/font_index"
+require_relative "indexes/filename_index"
 
 module Fontist
   class Index
-    def self.from_yaml
-      unless File.exist?(Fontist.formula_index_path)
-        raise Errors::FormulaIndexNotFoundError.new("Please fetch index with `fontist update`.")
-      end
-
-      data = YAML.load_file(Fontist.formula_index_path)
-      new(data)
-    end
-
     def self.rebuild
-      index = new
-      index.build
-      index.to_yaml
-    end
-
-    def initialize(data = {})
-      @index = {}
-
-      data.each_pair do |font, paths|
-        paths.each do |path|
-          add_index_formula(font, IndexFormula.new(path))
-        end
-      end
-    end
-
-    def build
-      Formula.all.each do |formula|
-        add_formula(formula)
-      end
-    end
-
-    def add_formula(formula)
-      formula.fonts.each do |font|
-        add_index_formula(font.name, formula.to_index_formula)
-      end
-    end
-
-    def add_index_formula(font_raw, index_formula)
-      font = normalize_font(font_raw)
-      @index[font] ||= []
-      @index[font] << index_formula unless @index[font].include?(index_formula)
-    end
-
-    def load_formulas(font)
-      index_formulas(font).map(&:to_full)
-    end
-
-    def to_yaml
-      File.write(Fontist.formula_index_path, YAML.dump(to_h))
-    end
-
-    def to_h
-      @index.map do |font, index_formulas|
-        [font, index_formulas.map(&:to_s)]
-      end.to_h
-    end
-
-    private
-
-    def index_formulas(font)
-      @index[normalize_font(font)] || []
-    end
-
-    def normalize_font(font)
-      font.downcase
+      Fontist::Indexes::FontIndex.rebuild
+      Fontist::Indexes::FilenameIndex.rebuild
     end
   end
 end

data/lib/fontist/indexes/base_index.rb

@@ -0,0 +1,82 @@
+require_relative "index_formula"
+
+module Fontist
+  module Indexes
+    class BaseIndex
+      def self.from_yaml
+        @from_yaml ||= begin
+          unless File.exist?(path)
+            raise Errors::FormulaIndexNotFoundError.new("Please fetch `#{path}` index with `fontist update`.")
+          end
+
+          data = YAML.load_file(path)
+          new(data)
+        end
+      end
+
+      def self.path
+        raise NotImplementedError, "Please define path of an index"
+      end
+
+      def self.rebuild
+        index = new
+        index.build
+        index.to_yaml
+      end
+
+      def initialize(data = {})
+        @index = {}
+
+        data.each_pair do |key, paths|
+          paths.each do |path|
+            add_index_formula(key, IndexFormula.new(path))
+          end
+        end
+      end
+
+      def build
+        Formula.all.each do |formula|
+          add_formula(formula)
+        end
+      end
+
+      def add_formula(_formula)
+        raise NotImplementedError, "Please define how to add formula to an index, use #add_index_formula"
+      end
+
+      def add_index_formula(key_raw, index_formula)
+        key = normalize_key(key_raw)
+        @index[key] ||= []
+        @index[key] << index_formula unless @index[key].include?(index_formula)
+      end
+
+      def load_formulas(key)
+        index_formulas(key).map(&:to_full)
+      end
+
+      def load_index_formulas(key)
+        index_formulas(key)
+      end
+
+      def to_yaml
+        File.write(self.class.path, YAML.dump(to_h))
+      end
+
+      def to_h
+        @index.map do |key, index_formulas|
+          [key, index_formulas.map(&:to_s)]
+        end.to_h
+      end
+
+      private
+
+      def index_formulas(key)
+        @index[normalize_key(key)] || []
+      end
+
+      def normalize_key(key)
+        key
+      end
+    end
+  end
+end

data/lib/fontist/indexes/filename_index.rb

@@ -0,0 +1,19 @@
+require_relative "base_index"
+
+module Fontist
+  module Indexes
+    class FilenameIndex < BaseIndex
+      def self.path
+        Fontist.formula_filename_index_path
+      end
+
+      def add_formula(formula)
+        formula.fonts.each do |font|
+          font.styles.each do |style|
+            add_index_formula(style.font, formula.to_index_formula)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontist/indexes/font_index.rb

@@ -0,0 +1,21 @@
+require_relative "base_index"
+
+module Fontist
+  module Indexes
+    class FontIndex < BaseIndex
+      def self.path
+        Fontist.formula_index_path
+      end
+
+      def add_formula(formula)
+        formula.fonts.each do |font|
+          add_index_formula(font.name, formula.to_index_formula)
+        end
+      end
+
+      def normalize_key(key)
+        key.downcase
+      end
+    end
+  end
+end