fontist 1.4.0 → 1.7.1

data/lib/fontist/system_index.rb

@@ -0,0 +1,92 @@
+require "ttfunk"
+
+module Fontist
+  class SystemIndex
+    attr_reader :font_paths
+
+    def initialize(font_paths)
+      @font_paths = font_paths
+    end
+
+    def find(font, style)
+      fonts = system_index.select do |file|
+        file[:family_name].casecmp?(font) &&
+          (style.nil? || file[:type].casecmp?(style))
+      end
+
+      fonts.empty? ? nil : fonts
+    end
+
+    private
+
+    def system_index
+      @system_index ||= build_system_index
+    end
+
+    def build_system_index
+      previous_index = load_system_index
+      updated_index = detect_paths(font_paths, previous_index)
+      updated_index.tap do |index|
+        save_index(index)
+      end
+    end
+
+    def load_system_index
+      index = File.exist?(Fontist.system_index_path) ? YAML.load_file(Fontist.system_index_path) : []
+      index.group_by { |x| x[:path] }
+    end
+
+    def detect_paths(paths, indexed)
+      paths.flat_map do |path|
+        next indexed[path] if indexed[path]
+
+        detect_fonts(path)
+      end
+    end
+
+    def detect_fonts(path)
+      case File.extname(path).delete_prefix(".").downcase
+      when "ttf", "otf"
+        detect_file_font(path)
+      when "ttc"
+        detect_collection_fonts(path)
+      else
+        raise Errors::UnknownFontTypeError.new(path)
+      end
+    end
+
+    def detect_file_font(path)
+      file = TTFunk::File.open(path)
+      parse_font(file, path)
+    end
+
+    def detect_collection_fonts(path)
+      TTFunk::Collection.open(path) do |collection|
+        collection.map do |file|
+          parse_font(file, path)
+        end
+      end
+    end
+
+    def parse_font(file, path)
+      x = file.name
+
+      {
+        path: path,
+        full_name: parse_text(x.font_name.first),
+        family_name: parse_text(x.preferred_family.first || x.font_family.first),
+        type: parse_text(x.preferred_subfamily.first || x.font_subfamily.first),
+      }
+    end
+
+    def parse_text(text)
+      text.gsub(/[^[:print:]]/, "").to_s
+    end
+
+    def save_index(index)
+      dir = File.dirname(Fontist.system_index_path)
+      FileUtils.mkdir_p(dir) unless File.exist?(dir)
+      File.write(Fontist.system_index_path, YAML.dump(index))
+    end
+  end
+end

data/lib/fontist/utils.rb

@@ -2,6 +2,7 @@ require "fontist/utils/ui"
 require "fontist/utils/system"
 require "fontist/utils/dsl"
 require "fontist/utils/dsl/font"
+require "fontist/utils/dsl/collection_font"
 require "fontist/utils/downloader"
 require "fontist/utils/zip_extractor"
 require "fontist/utils/exe_extractor"

data/lib/fontist/utils/cache.rb

@@ -1,14 +1,18 @@
 module Fontist
   module Utils
     class Cache
-      def fetch(key)
+      def fetch(key, bar: nil)
         map = load_cache
-        return downloaded_path(map[key]) if cache_exist?(map[key])
+        if cache_exist?(map[key])
+          print_bar(bar, map[key]) if bar
+
+          return downloaded_file(map[key])
+        end
 
         generated_file = yield
-        path = save_cache(generated_file, key, map)
+        path = save_cache(generated_file, key)
 
-        downloaded_path(path)
+        downloaded_file(path)
       end
 
       private
@@ -21,18 +25,33 @@ module Fontist
         cache_map_path.exist? ? YAML.load_file(cache_map_path) : {}
       end
 
-      def downloaded_path(path)
-        File.new(Fontist.downloads_path.join(path))
+      def downloaded_file(path)
+        File.new(downloaded_path(path))
       end
 
       def cache_exist?(path)
-        path && File.exist?(Fontist.downloads_path.join(path))
+        path && File.exist?(downloaded_path(path))
+      end
+
+      def downloaded_path(path)
+        Fontist.downloads_path.join(path)
       end
 
-      def save_cache(generated_file, key, map)
+      def print_bar(bar, path)
+        File.size(downloaded_path(path)).tap do |size|
+          bar.total = size
+          bar.increment(size)
+          bar.finish("cache")
+        end
+      end
+
+      def save_cache(generated_file, key)
         path = move_to_downloads(generated_file)
+
+        map = load_cache
         map[key] = path
         File.write(cache_map_path, YAML.dump(map))
+
         path
       end
 

data/lib/fontist/utils/downloader.rb

@@ -7,13 +7,15 @@ module Fontist
         # TODO: If the first mirror fails, try the second one
         @file = file
         @sha = [sha].flatten.compact
-        @progress_bar = set_progress_bar(progress_bar)
         @file_size = (file_size || default_file_size).to_i
+        @progress_bar = set_progress_bar(progress_bar)
         @cache = Cache.new
       end
 
       def download
-        file = @cache.fetch(@file) { download_file }
+        file = @cache.fetch(@file, bar: @progress_bar) do
+          download_file
+        end
 
         if !sha.empty? && !sha.include?(Digest::SHA256.file(file).to_s)
           raise(Fontist::Errors::TamperedFileError.new(
@@ -46,25 +48,27 @@ module Fontist
       end
 
       def set_progress_bar(progress_bar)
-        ENV.fetch("TEST_ENV", "") === "CI" ? false : progress_bar
+        if ENV.fetch("TEST_ENV", "") === "CI" || progress_bar
+          ProgressBar.new(@file_size)
+        else
+          NullProgressBar.new
+        end
       end
 
       def download_file
-        bar = ProgressBar.new(file_size / byte_to_megabyte)
-
         file = Down.download(
           @file,
           open_timeout: 10,
           read_timeout: 10,
           content_length_proc: ->(content_length) {
-            bar.total = content_length / byte_to_megabyte if content_length
+            @progress_bar.total = content_length if content_length
           },
           progress_proc: -> (progress) {
-            bar.increment(progress / byte_to_megabyte) if @progress_bar === true
+            @progress_bar.increment(progress)
           }
         )
 
-        puts if @progress_bar === true
+        @progress_bar.finish
 
         file
       rescue Down::NotFound
@@ -72,6 +76,20 @@ module Fontist
       end
     end
 
+    class NullProgressBar
+      def total=(_)
+        # do nothing
+      end
+
+      def increment(_)
+        # do nothing
+      end
+
+      def finish(_ = nil)
+        # do nothing
+      end
+    end
+
     class ProgressBar
       def initialize(total)
         @counter = 1
@@ -83,9 +101,35 @@ module Fontist
       end
 
       def increment(progress)
-        complete = sprintf("%#.2f%%", ((@counter.to_f / @total.to_f) * 100))
-        print "\r\e[0KDownloads: #{@counter}MB/#{@total}MB (#{complete})"
         @counter = progress
+        Fontist.ui.print "\r\e[0KDownloads: #{counter_mb}MB/#{total_mb}MB " \
+                         "(#{completeness})"
+      end
+
+      def finish(message = nil)
+        if message
+          Fontist.ui.print " (#{message})\n"
+        else
+          Fontist.ui.print "\n"
+        end
+      end
+
+      private
+
+      def completeness
+        sprintf("%#.2f%%", (@counter.fdiv(@total) * 100)) # rubocop:disable Style/FormatStringToken, Metrics/LineLength
+      end
+
+      def counter_mb
+        @counter / byte_to_megabyte
+      end
+
+      def total_mb
+        @total / byte_to_megabyte
+      end
+
+      def byte_to_megabyte
+        @byte_to_megabyte ||= 1024 * 1024
       end
     end
   end

data/lib/fontist/utils/dsl.rb

@@ -47,6 +47,10 @@ module Fontist
         instance.temp_resource.merge!(filename: name)
       end
 
+      def source_filename(name)
+        instance.temp_resource.merge!(source_filename: name)
+      end
+
       def provides_font(font, options = {})
         font_styles = instance.extract_font_styles(options)
         instance.font_list.push(name: font, styles: font_styles)

data/lib/fontist/utils/dsl/collection_font.rb

@@ -0,0 +1,36 @@
+module Fontist
+  module Utils
+    module Dsl
+      class CollectionFont
+        REQUIRED_ATTRIBUTES = %i[style].freeze
+
+        attr_reader :attributes
+
+        def initialize(attributes)
+          REQUIRED_ATTRIBUTES.each do |required_attribute|
+            unless attributes[required_attribute]
+              raise(Fontist::Errors::MissingAttributeError.new(
+                      "Missing attribute: #{required_attribute}"
+                    ))
+            end
+          end
+
+          self.attributes = attributes
+        end
+
+        def attributes=(attrs)
+          @attributes = { family_name: attrs[:family_name],
+                          type: attrs[:style],
+                          collection: attrs[:full_name],
+                          full_name: attrs[:full_name],
+                          post_script_name: attrs[:post_script_name],
+                          version: attrs[:version],
+                          description: attrs[:description],
+                          copyright: attrs[:copyright],
+                          font: attrs[:filename],
+                          source_font: attrs[:source_filename] }
+        end
+      end
+    end
+  end
+end

data/lib/fontist/utils/dsl/font.rb

@@ -29,7 +29,8 @@ module Fontist
                           version: attrs[:version],
                           description: attrs[:description],
                           copyright: attrs[:copyright],
-                          font: attrs[:filename] }
+                          font: attrs[:filename],
+                          source_font: attrs[:source_filename] }
         end
       end
     end

data/lib/fontist/utils/exe_extractor.rb

@@ -5,17 +5,19 @@ module Fontist
         download = @downloaded === true ? false : download
 
         exe_file = download_file(exe_file).path if download
+
+        Fontist.ui.say(%(Installing font "#{key}".))
         cab_file = decompressor.search(exe_file)
-        cabbed_fonts = grep_fonts(cab_file.files, font_ext) || []
+        cabbed_fonts = grep_fonts(cab_file.files) || []
         fonts_paths = extract_cabbed_fonts_to_assets(cabbed_fonts)
 
         block_given? ? yield(fonts_paths) : fonts_paths
       end
 
-      def exe_extract(source)
+      def exe_extract(source, subarchive: nil)
         cab_file = decompressor.search(download_file(source).path)
-        fonts_paths = build_cab_file_hash(cab_file.files)
-        block_given? ? yield(fonts_paths) : fonts_paths
+        subarchive_path = extract_subarchive(cab_file.files, subarchive)
+        block_given? ? yield(subarchive_path) : subarchive_path
       end
 
       private
@@ -27,10 +29,10 @@ module Fontist
         )
       end
 
-      def grep_fonts(file, font_ext)
+      def grep_fonts(file)
         Array.new.tap do |fonts|
           while file
-            fonts.push(file) if file.filename.match(font_ext)
+            fonts.push(file) if font_file?(file.filename)
             file = file.next
           end
         end
@@ -39,7 +41,8 @@ module Fontist
       def extract_cabbed_fonts_to_assets(cabbed_fonts)
         Array.new.tap do |fonts|
           cabbed_fonts.each do |font|
-            font_path = fonts_path.join(font.filename).to_s
+            target_filename = target_filename(font.filename)
+            font_path = fonts_path.join(target_filename).to_s
             decompressor.extract(font, font_path)
 
             fonts.push(font_path)
@@ -47,10 +50,11 @@ module Fontist
         end
       end
 
-      def build_cab_file_hash(file)
+      def extract_subarchive(file, subarchive = nil)
         while file
           filename = file.filename
-          if filename.include?("cab") || filename.include?("msi")
+
+          if subarchive_found?(filename, subarchive)
             file_path = File.join(Dir.mktmpdir, filename)
             decompressor.extract(file, file_path)
 
@@ -60,6 +64,12 @@ module Fontist
           file = file.next
         end
       end
+
+      def subarchive_found?(filename, subarchive)
+        return subarchive == filename if subarchive
+
+        filename.include?("cab") || filename.include?("msi")
+      end
     end
   end
 end

data/lib/fontist/utils/ui.rb

@@ -18,6 +18,10 @@ module Fontist
       def self.ask(message, options = {})
         new.ask(message, options)
       end
+
+      def self.print(message)
+        super
+      end
     end
   end
 end

data/lib/fontist/utils/zip_extractor.rb

@@ -4,40 +4,49 @@ require "pathname"
 module Fontist
   module Utils
     module ZipExtractor
-      # fonts_sub_dir is unused now, but formulas have this option
-      # rubocop:disable Lint/UnusedMethodArgument
-      def zip_extract(resource, download: true, fonts_sub_dir: "")
+      def zip_extract(resource, download: true, fonts_sub_dir: nil)
         zip_file = download_file(resource) if download
         zip_file ||= resource.urls.first
 
-        fonts_paths = unzip_fonts(zip_file)
+        Fontist.ui.say(%(Installing font "#{key}".))
+        fonts_paths = unzip_fonts(zip_file, fonts_sub_dir)
         block_given? ? yield(fonts_paths) : fonts_paths
       end
-      # rubocop:enable Lint/UnusedMethodArgument
 
       alias_method :unzip, :zip_extract
 
       private
 
       # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      def unzip_fonts(file)
+      def unzip_fonts(file, subdir)
         Zip.on_exists_proc = true
 
         Array.new.tap do |fonts|
           Zip::File.open(file) do |zip_file|
-            zip_file.glob("**/*.{ttf,ttc,otf}").each do |entry|
+            zip_file.each do |entry|
               if entry.name
-                filename = Pathname.new(entry.name).basename
-                font_path = fonts_path.join(filename.to_s)
-                fonts.push(font_path.to_s)
+                filename = Pathname.new(entry.name).basename.to_s
+                if font_directory?(entry.name, subdir) && font_file?(filename)
+                  target_filename = target_filename(filename)
+                  font_path = fonts_path.join(target_filename)
+                  fonts.push(font_path.to_s)
 
-                entry.extract(font_path)
+                  entry.extract(font_path)
+                end
               end
             end
           end
         end
       end
       # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+      def font_directory?(path, subdir)
+        return true unless subdir
+
+        dirname = File.dirname(path)
+        normalized_pattern = subdir.chomp("/")
+        File.fnmatch?(normalized_pattern, dirname)
+      end
     end
   end
 end