fontist 1.7.3 → 1.8.5

data/lib/fontist/errors.rb

@@ -1,16 +1,67 @@
 module Fontist
   module Errors
-    class LicensingError < StandardError; end
-    class MissingFontError < StandardError; end
-    class NonSupportedFontError < StandardError; end
-    class TamperedFileError < StandardError; end
-    class InvalidResourceError < StandardError; end
-    class TimeoutError < StandardError; end
-    class MissingAttributeError < StandardError; end
-    class UnknownFontTypeError < StandardError; end
-    class FontNotFoundError < StandardError; end
-    class BinaryCallError < StandardError; end
-    class ManifestCouldNotBeReadError < StandardError; end
-    class ManifestCouldNotBeFoundError < StandardError; end
+    class GeneralError < StandardError; end
+
+    class BinaryCallError < GeneralError; end
+    class FontIndexCorrupted < GeneralError; end
+    class FontNotFoundError < GeneralError; end
+    class FormulaIndexNotFoundError < GeneralError; end
+    class InvalidResourceError < GeneralError; end
+    class LicensingError < GeneralError; end
+    class ManifestCouldNotBeFoundError < GeneralError; end
+    class ManifestCouldNotBeReadError < GeneralError; end
+    class MissingAttributeError < GeneralError; end
+    class TamperedFileError < GeneralError; end
+    class TimeoutError < GeneralError; end
+    class UnknownFontTypeError < GeneralError; end
+    class UnknownArchiveError < GeneralError; end
+
+    class FontError < GeneralError
+      attr_reader :font, :style
+
+      def initialize(msg, font = nil, style = nil)
+        @font = font
+        @style = style
+
+        super(msg)
+      end
+
+      def name
+        messages = []
+        messages << "Font name: '#{@font}'"
+        messages << "Style: '#{@style}'" if @style
+        messages.join("; ")
+      end
+    end
+
+    class MissingFontError < FontError
+      def initialize(font, style = nil)
+        name = prepare_name(font, style)
+        msg = "#{name} font is missing, please run `fontist install '#{font}'` to download the font."
+
+        super(msg, font, style)
+      end
+
+      private
+
+      def prepare_name(font, style)
+        names = []
+        names << "'#{font}'"
+        names << "'#{style}'" if style
+        names.join(" ")
+      end
+    end
+
+    class UnsupportedFontError < FontError
+      def initialize(font)
+        msg = <<~MSG.chomp
+          Font '#{font}' not found locally nor available in the Fontist formula repository.
+          Perhaps it is available at the latest Fontist formula repository.
+          You can update the formula repository using the command `fontist update` and try again.
+        MSG
+
+        super(msg, font)
+      end
+    end
   end
 end

data/lib/fontist/font.rb

@@ -1,9 +1,12 @@
+require "fontist/font_installer"
+require "fontist/font_path"
+
 module Fontist
   class Font
     def initialize(options = {})
-      @name = options.fetch(:name, nil)
-      @confirmation = options.fetch(:confirmation, "no")
-      @force = options.fetch(:force, false)
+      @name = options[:name]
+      @confirmation = options[:confirmation] || "no"
+      @force = options[:force] || false
 
       check_or_create_fontist_path!
     end
@@ -20,10 +23,6 @@ module Fontist
       new(name: name, confirmation: confirmation, force: force).install
     end
 
-    def self.try_install(name, confirmation: "no")
-      new(name: name, confirmation: confirmation).try_install
-    end
-
     def self.uninstall(name)
       new(name: name).uninstall
     end
@@ -37,43 +36,31 @@ module Fontist
     end
 
     def find
-      find_system_font || downloadable_font || raise(
-        Fontist::Errors::NonSupportedFontError
-      )
+      find_system_font || downloadable_font || raise_non_supported_font
     end
 
     def install
-      (find_system_font unless @force) || download_font || raise(
-        Fontist::Errors::NonSupportedFontError
-      )
-    end
-
-    def try_install
-      download_font
+      (find_system_font unless @force) || download_font || raise_non_supported_font
     end
 
     def uninstall
-      uninstall_font || downloadable_font || raise(
-        Fontist::Errors::NonSupportedFontError
-      )
+      uninstall_font || downloadable_font || raise_non_supported_font
     end
 
     def status
-      return installed_statuses unless @name
+      return installed_paths unless @name
 
-      font_status || downloadable_font || raise(
-        Fontist::Errors::NonSupportedFontError
-      )
+      find_system_font || downloadable_font || raise_non_supported_font
     end
 
     def list
       return all_list unless @name
 
-      font_list || raise(Fontist::Errors::NonSupportedFontError)
+      font_list || raise_non_supported_font
     end
 
     def all
-      Fontist::Formula.all.to_h.map { |_name, formula| formula.fonts }.flatten
+      Fontist::Formula.all.map(&:fonts).flatten
     end
 
     private
@@ -87,9 +74,14 @@ module Fontist
         return
       end
 
+      print_paths(paths)
+    end
+
+    def print_paths(paths)
       Fontist.ui.say("Fonts found at:")
       paths.each do |path|
-        Fontist.ui.say("- #{path}")
+        font_path = FontPath.new(path)
+        Fontist.ui.say(font_path.to_s)
       end
     end
 
@@ -101,7 +93,7 @@ module Fontist
     end
 
     def font_installer(formula)
-      Object.const_get(formula.installer)
+      FontInstaller.new(formula)
     end
 
     def formula
@@ -110,20 +102,14 @@ module Fontist
 
     def downloadable_font
       if formula
-        raise(
-          Fontist::Errors::MissingFontError,
-          "#{name} fonts are missing, please run " \
-          "`fontist install '#{name}'` to " \
-          "download the font."
-        )
+        raise Fontist::Errors::MissingFontError.new(name)
       end
     end
 
     def download_font
       if formula
         check_and_confirm_required_license(formula)
-        paths = font_installer(formula).fetch_font(name,
-                                                   confirmation: confirmation)
+        paths = font_installer(formula).install(confirmation: confirmation)
 
         Fontist.ui.say("Fonts installed at:")
         paths.each do |path|
@@ -136,7 +122,7 @@ module Fontist
       if formula.license_required && !confirmation.casecmp("yes").zero?
         @confirmation = show_license_and_ask_for_input(formula.license)
 
-        if !confirmation.casecmp("yes").zero?
+        unless confirmation&.casecmp?("yes")
           raise Fontist::Errors::LicensingError.new(
             "Fontist will not download these fonts unless you accept the terms."
           )
@@ -181,39 +167,18 @@ module Fontist
       Fontist::FontistFont.find(name)
     end
 
-    def installed_statuses
-      installed_styles(all_formulas)
+    def installed_paths
+      print_paths(SystemFont.font_paths)
     end
 
     def all_formulas
-      Fontist::Formula.all.to_h.values
-    end
-
-    def font_status
-      return unless formula
-
-      statuses = installed_styles([formula])
-      statuses.empty? ? nil : statuses
-    end
-
-    def installed_styles(formulas)
-      filter_blank(formulas) do |formula|
-        filter_blank(formula.fonts) do |font|
-          filter_blank(font.styles) do |style|
-            path(style)
-          end
-        end
-      end
-    end
-
-    def filter_blank(elements)
-      elements.map { |e| [e, yield(e)] }
-        .to_h
-        .reject { |_k, v| v.nil? || v.empty? }
+      Fontist::Formula.all
     end
 
     def path(style)
-      font_paths.grep(/#{style.font}/i).first
+      font_paths.detect do |path|
+        File.basename(path) == style.font
+      end
     end
 
     def font_paths
@@ -247,5 +212,9 @@ module Fontist
     def installed(style)
       path(style) ? true : false
     end
+
+    def raise_non_supported_font
+      raise Fontist::Errors::UnsupportedFontError.new(@name)
+    end
   end
 end

data/lib/fontist/font_installer.rb

@@ -0,0 +1,118 @@
+require "fontist/utils"
+
+module Fontist
+  class FontInstaller
+    include Utils::ZipExtractor
+    include Utils::ExeExtractor
+    include Utils::MsiExtractor
+    include Utils::SevenZipExtractor
+    include Utils::RpmExtractor
+    include Utils::GzipExtractor
+    include Utils::CpioExtractor
+    include Utils::TarExtractor
+
+    def initialize(formula)
+      @formula = formula
+    end
+
+    def install(confirmation:)
+      if @formula.license_required && !"yes".casecmp?(confirmation)
+        raise(Fontist::Errors::LicensingError)
+      end
+
+      reinitialize
+      install_font
+    end
+
+    private
+
+    attr_reader :formula
+
+    def reinitialize
+      @downloaded = false
+    end
+
+    def install_font
+      fonts_paths = run_in_temp_dir { extract }
+      fonts_paths.empty? ? nil : fonts_paths
+    end
+
+    def run_in_temp_dir
+      Dir.mktmpdir(nil, Dir.tmpdir) do |dir|
+        @temp_dir = Pathname.new(dir)
+
+        result = yield
+
+        @temp_dir = nil
+
+        result
+      end
+    end
+
+    def extract
+      resource = @formula.resources.first
+
+      [@formula.extract].flatten.each do |operation|
+        resource = extract_by_operation(operation, resource)
+      end
+
+      fonts_paths = resource
+
+      fonts_paths
+    end
+
+    def extract_by_operation(operation, resource)
+      method = "#{operation.format}_extract"
+      if operation.options
+        send(method, resource, **operation.options.to_h)
+      else
+        send(method, resource)
+      end
+    end
+
+    def fonts_path
+      Fontist.fonts_path
+    end
+
+    def download_file(source)
+      url = source.urls.first
+      Fontist.ui.say(%(Downloading font "#{@formula.key}" from #{url}))
+
+      downloaded_file = Fontist::Utils::Downloader.download(
+        url,
+        sha: source.sha256,
+        file_size: source.file_size,
+        progress_bar: true
+      )
+
+      @downloaded = true
+      downloaded_file
+    end
+
+    def font_file?(filename)
+      source_files.include?(filename)
+    end
+
+    def source_files
+      @source_files ||= @formula.fonts.flat_map do |font|
+        font.styles.map do |style|
+          style.source_font || style.font
+        end
+      end
+    end
+
+    def target_filename(source_filename)
+      target_filenames[source_filename]
+    end
+
+    def target_filenames
+      @target_filenames ||= @formula.fonts.flat_map do |font|
+        font.styles.map do |style|
+          source = style.source_font || style.font
+          target = style.font
+          [source, target]
+        end
+      end.to_h
+    end
+  end
+end

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/fontist_font.rb

@@ -2,8 +2,6 @@ module Fontist
   class FontistFont
     def initialize(font_name:)
       @font_name = font_name
-
-      check_and_register_font_formulas
     end
 
     def self.find(name)
@@ -11,60 +9,16 @@ module Fontist
     end
 
     def find
-      return unless @font_name
-
-      filenames = fonts_filenames
-      return if filenames.empty?
-
-      paths = font_paths.select do |path|
-        filenames.any? { |f| File.basename(path).casecmp?(f) }
-      end
+      styles = FormulaPaths.new(font_paths).find(@font_name)
+      return unless styles
 
-      paths.empty? ? nil : paths
+      styles.map { |x| x[:path] }
     end
 
     private
 
-    def fonts_filenames
-      fonts.map { |font| font.styles.map(&:font) }.flatten
-    end
-
-    def fonts
-      by_key || by_name || []
-    end
-
-    def by_key
-      _key, formula = formulas.detect do |key, _value|
-        key.to_s.casecmp?(@font_name)
-      end
-
-      return unless formula
-
-      formula.fonts
-    end
-
-    def by_name
-      _key, formula = formulas.detect do |_key, value|
-        value.fonts.map(&:name).map(&:downcase).include?(@font_name.downcase)
-      end
-
-      return unless formula
-
-      formula.fonts.select do |font|
-        font.name.casecmp?(@font_name)
-      end
-    end
-
-    def formulas
-      @formulas ||= Fontist::Registry.instance.formulas.to_h
-    end
-
     def font_paths
       Dir.glob(Fontist.fonts_path.join("**"))
     end
-
-    def check_and_register_font_formulas
-      $check_and_register_font_formulas ||= Fontist::Formulas.register_formulas
-    end
   end
 end