fontist 1.7.2 → 1.8.4

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,11 @@
+require "fontist/font_installer"
+
 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 +22,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 +35,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
 
-      font_status || downloadable_font || raise(
-        Fontist::Errors::NonSupportedFontError
-      )
+      font_status || 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
@@ -101,7 +87,7 @@ module Fontist
     end
 
     def font_installer(formula)
-      Object.const_get(formula.installer)
+      FontInstaller.new(formula)
     end
 
     def formula
@@ -110,20 +96,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 +116,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."
           )
@@ -186,7 +166,7 @@ module Fontist
     end
 
     def all_formulas
-      Fontist::Formula.all.to_h.values
+      Fontist::Formula.all
     end
 
     def font_status
@@ -213,7 +193,9 @@ module Fontist
     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 +229,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/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

data/lib/fontist/formula.rb

@@ -1,50 +1,43 @@
+require "fontist/index"
+require "fontist/helpers"
+require "git"
+
 module Fontist
   class Formula
-    def initialize(options = {})
-      @font_name = options.fetch(:font_name, nil)
-      @style_name = options.fetch(:style_name, nil)
-
-      check_and_register_font_formulas
+    def self.update_formulas_repo
+      if Dir.exist?(Fontist.formulas_repo_path)
+        Git.open(Fontist.formulas_repo_path).pull
+      else
+        Git.clone(Fontist.formulas_repo_url,
+                  Fontist.formulas_repo_path,
+                  depth: 1)
+      end
     end
 
     def self.all
-      new.all
+      Dir[Fontist.formulas_path.join("**/*.yml").to_s].map do |path|
+        Formula.new_from_file(path)
+      end
     end
 
     def self.find(font_name)
-      new(font_name: font_name).find
+      Index.from_yaml.load_formulas(font_name).first
     end
 
-    def self.find_fonts(name)
-      new(font_name: name).find_fonts
-    end
-
-    def self.find_styles(font, style)
-      new(font_name: font, style_name: style).find_styles
-    end
+    def self.find_fonts(font_name)
+      formulas = Index.from_yaml.load_formulas(font_name)
 
-    def all
-      @all ||= Fontist::Registry.instance.formulas
-    end
-
-    def find
-      formulas.values.detect do |formula|
-        formula.fonts.any? do |f|
-          f.name.casecmp?(font_name)
-        end
-      end
-    end
-
-    def find_fonts
-      formulas.values.map do |formula|
+      formulas.map do |formula|
         formula.fonts.select do |f|
           f.name.casecmp?(font_name)
         end
       end.flatten
     end
 
-    def find_styles
-      formulas.values.map do |formula|
+    def self.find_styles(font_name, style_name)
+      formulas = Index.from_yaml.load_formulas(font_name)
+
+      formulas.map do |formula|
         formula.fonts.map do |f|
           f.styles.select do |s|
             f.name.casecmp?(font_name) && s.type.casecmp?(style_name)
@@ -53,16 +46,89 @@ module Fontist
       end.flatten
     end
 
+    def self.new_from_file(path)
+      data = YAML.load_file(path)
+      new(data, path)
+    end
+
+    def initialize(data, path)
+      @data = data
+      @path = path
+    end
+
+    def to_index_formula
+      IndexFormula.new(path)
+    end
+
+    def path
+      @path
+    end
+
+    def key
+      @data["key"] || default_key
+    end
+
+    def description
+      @data["description"]
+    end
+
+    def homepage
+      @data["homepage"]
+    end
+
+    def copyright
+      @data["copyright"]
+    end
+
+    def license_url
+      @data["license_url"]
+    end
+
+    def license
+      @data["open_license"] || @data["requires_license_agreement"]
+    end
+
+    def license_required
+      @data["requires_license_agreement"] ? true : false
+    end
+
+    def extract
+      Helpers.parse_to_object(@data["extract"])
+    end
+
+    def resources
+      Helpers.parse_to_object(@data["resources"].values)
+    end
+
+    def fonts
+      @fonts ||= Helpers.parse_to_object(hash_collection_fonts + hash_fonts)
+    end
+
     private
 
-    attr_reader :font_name, :style_name
+    def default_key
+      escaped = Regexp.escape(Fontist.formulas_path.to_s + "/")
+      @path.sub(Regexp.new("^" + escaped), "").sub(/\.yml$/, "")
+    end
+
+    def hash_collection_fonts
+      return [] unless @data["font_collections"]
+
+      @data["font_collections"].flat_map do |coll|
+        filenames = { "font" => coll["filename"],
+                      "source_font" => coll["source_filename"] }
 
-    def formulas
-      @formulas ||= all.to_h
+        coll["fonts"].map do |font|
+          { "name" => font["name"],
+            "styles" => font["styles"].map { |s| filenames.merge(s) } }
+        end
+      end
     end
 
-    def check_and_register_font_formulas
-      $check_and_register_font_formulas ||= Fontist::Formulas.register_formulas
+    def hash_fonts
+      return [] unless @data["fonts"]
+
+      @data["fonts"]
     end
   end
 end