fontist 1.6.0 → 1.8.1

data/lib/fontist/formula_paths.rb

@@ -0,0 +1,43 @@
+module Fontist
+  class FormulaPaths
+    attr_reader :font_paths
+
+    def initialize(font_paths)
+      @font_paths = font_paths
+    end
+
+    def find(font, style = nil)
+      styles = find_styles_by_formulas(font, style)
+      return if styles.empty?
+
+      fonts = styles.uniq { |s| s["font"] }.flat_map do |s|
+        paths = search_font_paths(s["font"])
+        paths.map do |path|
+          { full_name: s["full_name"],
+            path: path }
+        end
+      end
+
+      fonts.empty? ? nil : fonts
+    end
+
+    private
+
+    def find_styles_by_formulas(font, style)
+      if style
+        Formula.find_styles(font, style)
+      else
+        fonts = Formula.find_fonts(font)
+        return [] unless fonts
+
+        fonts.flat_map(&:styles)
+      end
+    end
+
+    def search_font_paths(filename)
+      font_paths.select do |path|
+        File.basename(path) == filename
+      end
+    end
+  end
+end

data/lib/fontist/helpers.rb

@@ -0,0 +1,7 @@
+module Fontist
+  module Helpers
+    def self.parse_to_object(data)
+      JSON.parse(data.to_json, object_class: OpenStruct)
+    end
+  end
+end

data/lib/fontist/import/create_formula.rb

@@ -8,10 +8,6 @@ require_relative "formula_builder"
 module Fontist
   module Import
     class CreateFormula
-      FONT_PATTERN = /(\.ttf|\.otf)/i.freeze
-      FONT_COLLECTION_PATTERN = /\.ttc/i.freeze
-      LICENSE_PATTERN = /(OFL\.txt|UFL\.txt|LICENSE\.txt|COPYING)$/i.freeze
-
       def initialize(url, options = {})
         @url = url
         @options = options
@@ -26,41 +22,30 @@ module Fontist
       def formula
         builder = FormulaBuilder.new
         builder.url = @url
-        builder.archive = download(@url)
-        builder.extractor = extractor(builder.archive)
+        builder.archive = archive
+        builder.extractor = extractor
         builder.options = @options
-        builder.font_files = font_files(builder.extractor)
-        builder.font_collection_files = font_collection_files(builder.extractor)
-        builder.license_text = license_texts(builder.extractor).first
+        builder.font_files = extractor.font_files
+        builder.font_collection_files = extractor.font_collection_files
+        builder.license_text = extractor.license_text
         builder.formula
       end
 
-      def download(url)
-        return url if File.exist?(url)
-
-        Fontist::Utils::Downloader.download(url, progress_bar: true).path
+      def extractor
+        @extractor ||=
+          RecursiveExtraction.new(archive,
+                                  subarchive: @options[:subarchive],
+                                  subdir: @options[:subdir])
       end
 
-      def extractor(archive)
-        RecursiveExtraction.new(archive, subarchive: @options[:subarchive])
+      def archive
+        @archive ||= download(@url)
       end
 
-      def font_files(extractor)
-        extractor.extract(FONT_PATTERN) do |path|
-          Otf::FontFile.new(path)
-        end
-      end
-
-      def font_collection_files(extractor)
-        extractor.extract(FONT_COLLECTION_PATTERN) do |path|
-          Files::CollectionFile.new(path)
-        end
-      end
+      def download(url)
+        return url if File.exist?(url)
 
-      def license_texts(extractor)
-        extractor.extract(LICENSE_PATTERN) do |path|
-          File.read(path)
-        end
+        Fontist::Utils::Downloader.download(url, progress_bar: true).path
       end
 
       def save(hash)

data/lib/fontist/import/files/collection_file.rb

@@ -11,10 +11,15 @@ module Fontist
         def initialize(path)
           @path = path
           @fonts = read
+          @extension = "ttc"
         end
 
         def filename
-          File.basename(@path)
+          File.basename(@path, ".*") + "." + @extension
+        end
+
+        def source_filename
+          File.basename(@path) unless filename == File.basename(@path)
         end
 
         private

data/lib/fontist/import/files/file_requirement.rb

@@ -0,0 +1,17 @@
+module Fontist
+  module Import
+    module Files
+      class FileRequirement
+        def initialize
+          `file -v`
+        rescue Errno::ENOENT
+          abort "`file` is not available. (Or is PATH not setup properly?)"
+        end
+
+        def call(path)
+          Helpers::SystemHelper.run("file --brief '#{path}'")
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/files/font_detector.rb

@@ -0,0 +1,48 @@
+require_relative "file_requirement"
+
+module Fontist
+  module Import
+    module Files
+      class FontDetector
+        REQUIREMENTS = { file: FileRequirement.new }.freeze
+
+        FONT_LABELS = ["OpenType font data",
+                       "TrueType Font data"].freeze
+
+        COLLECTION_LABEL = "TrueType font collection data".freeze
+
+        FONT_EXTENSIONS = {
+          "OpenType font data" => "otf",
+          "TrueType Font data" => "ttf",
+          "TrueType font collection data" => "ttc",
+        }.freeze
+
+        def self.detect(path)
+          brief = file_brief(path)
+
+          if brief.start_with?(*FONT_LABELS)
+            :font
+          elsif brief.start_with?(COLLECTION_LABEL)
+            :collection
+          else
+            :other
+          end
+        end
+
+        def self.standard_extension(path)
+          brief = file_brief(path)
+
+          FONT_EXTENSIONS.each do |label, extension|
+            return extension if brief.start_with?(label)
+          end
+
+          raise Errors::UnknownFontTypeError.new(path)
+        end
+
+        def self.file_brief(path)
+          REQUIREMENTS[:file].call(path)
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/formula_builder.rb

@@ -107,7 +107,10 @@ module Fontist
 
         collections = @font_collection_files.map do |file|
           fonts = fonts_from_files(file.fonts, :to_collection_style)
-          { filename: file.filename, fonts: fonts }
+
+          { filename: file.filename,
+            source_filename: file.source_filename,
+            fonts: fonts }.compact
         end
 
         collections.sort_by do |x|
@@ -152,8 +155,9 @@ module Fontist
           return
         end
 
-        Fontist.ui.error("WARN: ensure it's an open license, otherwise change \
-                          to 'requires_license_agreement'")
+        Fontist.ui.error("WARN: ensure it's an open license, otherwise " \
+                         "change the 'open_license' attribute to " \
+                         "'requires_license_agreement'")
 
         TextHelper.cleanup(@license_text)
       end

data/lib/fontist/import/google_check.rb

@@ -12,7 +12,7 @@ module Fontist
       private
 
       def fetch_formulas
-        Formulas.fetch_formulas
+        Formula.update_formulas_repo
       end
 
       def new_fonts

data/lib/fontist/import/google_import.rb

@@ -156,10 +156,9 @@ module Fontist
           h.merge!(family_name: style.family_name,
                    type: style.style,
                    full_name: style.full_name)
-          h.merge!(style.to_h.slice(:post_script_name,
-                                    :version,
-                                    :description,
-                                    :copyright).compact)
+          h.merge!(style.to_h.select do |k, _|
+            %i(post_script_name version description copyright).include?(k)
+          end.compact)
           h.merge!(font: fix_variable_filename(style.filename))
         end
       end

data/lib/fontist/import/otf/font_file.rb

@@ -1,5 +1,6 @@
 require_relative "../otfinfo/otfinfo_requirement"
 require_relative "../text_helper"
+require_relative "../files/font_detector"
 
 module Fontist
   module Import
@@ -10,14 +11,19 @@ module Fontist
         }.freeze
 
         STYLE_ATTRIBUTES = %i[family_name type full_name post_script_name
-                              version description copyright font].freeze
-        COLLECTION_ATTRIBUTES = STYLE_ATTRIBUTES.reject { |a| a == :font }
+                              version description copyright font
+                              source_font].freeze
+
+        COLLECTION_ATTRIBUTES = STYLE_ATTRIBUTES.reject do |a|
+          %i[font source_font].include?(a)
+        end
 
         attr_reader :path
 
         def initialize(path)
           @path = path
           @info = read
+          @extension = detect_extension
         end
 
         def to_style
@@ -55,7 +61,11 @@ module Fontist
         end
 
         def font
-          File.basename(@path)
+          File.basename(@path, ".*") + "." + @extension
+        end
+
+        def source_font
+          File.basename(@path) unless font == File.basename(@path)
         end
 
         def copyright
@@ -85,6 +95,10 @@ module Fontist
             .map { |x| x.map { |y| Fontist::Import::TextHelper.cleanup(y) } }
             .to_h
         end
+
+        def detect_extension
+          Files::FontDetector.standard_extension(@path)
+        end
       end
     end
   end

data/lib/fontist/import/otfinfo_generate.rb

@@ -25,7 +25,7 @@ module Fontist
       def font_paths(font)
         formula = Fontist::Formula.find(font)
         font_formula = Object.const_get(formula.installer)
-        font_formula.fetch_font(nil, confirmation: "yes")
+        font_formula.install(confirmation: "yes")
       end
 
       def generate_styles(paths)

data/lib/fontist/import/recursive_extraction.rb

@@ -1,28 +1,40 @@
 require "find"
 require_relative "extractors"
+require_relative "files/font_detector"
 
 module Fontist
   module Import
     class RecursiveExtraction
-      BOTH_FONTS_PATTERN = "**/*.{ttf,otf,ttc}*".freeze
+      FONTS_PATTERN = "**/*.{ttf,otf,ttc}".freeze
       ARCHIVE_EXTENSIONS = %w[zip msi exe cab].freeze
+      LICENSE_PATTERN = /(OFL\.txt|UFL\.txt|LICENSE\.txt|COPYING)$/i.freeze
 
-      def initialize(archive, subarchive: nil)
+      def initialize(archive, subarchive: nil, subdir: nil)
         @archive = archive
         @subarchive = subarchive
+        @subdir = subdir
         @operations = []
+        @font_files = []
+        @collection_files = []
       end
 
       def extension
         File.extname(filename(@archive)).sub(/^\./, "")
       end
 
-      def extract(pattern)
-        Array.new.tap do |results|
-          Find.find(extracted_path) do |path| # rubocop:disable Style/CollectionMethods, Metrics/LineLength
-            results << yield(path) if path.match(pattern)
-          end
-        end
+      def font_files
+        ensure_extracted
+        @font_files
+      end
+
+      def font_collection_files
+        ensure_extracted
+        @collection_files
+      end
+
+      def license_text
+        ensure_extracted
+        @license_text
       end
 
       def operations
@@ -50,7 +62,11 @@ module Fontist
 
       def extract_recursively(archive)
         path = operate_on_archive(archive)
-        return path if fonts_exist?(path)
+        match_files(path)
+        if matched?
+          save_operation_subdir
+          return path
+        end
 
         next_archive = find_archive(path)
         extract_recursively(next_archive)
@@ -84,13 +100,58 @@ module Fontist
         @operations << { format: extractor.format }
       end
 
-      def fonts_exist?(path)
-        fonts = Dir.glob(File.join(path, BOTH_FONTS_PATTERN))
-        !fonts.empty?
+      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
+      end
+
+      def match_license(path)
+        @license_text ||= File.read(path) if license?(path)
+      end
+
+      def license?(file)
+        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
+          @font_files << Otf::FontFile.new(path)
+        when :collection
+          @collection_files << Files::CollectionFile.new(path)
+        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)
-        paths = Dir.children(path).map { |file| File.join(path, file) }
+        children = Dir.entries(path) - [".", ".."] # ruby 2.4 compat
+        paths = children.map { |file| File.join(path, file) }
         by_subarchive(paths) || by_size(paths)
       end
 

data/lib/fontist/index.rb

@@ -0,0 +1,72 @@
+require_relative "index_formula"
+
+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
+    end
+  end
+end