fontist 1.6.0 → 1.8.1

data/lib/fontist/errors.rb

@@ -1,15 +1,18 @@
 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 FontNotFoundError < StandardError; end
-    class BinaryCallError < StandardError; end
-    class ManifestCouldNotBeReadError < StandardError; end
-    class ManifestCouldNotBeFoundError < StandardError; end
+    class GeneralError < StandardError; end
+    class BinaryCallError < 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 MissingFontError < GeneralError; end
+    class NonSupportedFontError < GeneralError; end
+    class TamperedFileError < GeneralError; end
+    class TimeoutError < GeneralError; end
+    class UnknownFontTypeError < GeneralError; end
   end
 end

data/lib/fontist/font.rb

@@ -1,3 +1,5 @@
+require "fontist/font_installer"
+
 module Fontist
   class Font
     def initialize(options = {})
@@ -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
@@ -122,8 +108,7 @@ module Fontist
     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|
@@ -186,7 +171,7 @@ module Fontist
     end
 
     def all_formulas
-      Fontist::Formula.all.to_h.values
+      Fontist::Formula.all
     end
 
     def font_status
@@ -213,7 +198,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 +234,16 @@ module Fontist
     def installed(style)
       path(style) ? true : false
     end
+
+    def raise_non_supported_font
+      raise Fontist::Errors::NonSupportedFontError.new(
+        "Font '#{@name}' not found locally nor available in the Fontist " \
+        "formula repository.\n" \
+        "Perhaps it is available at the latest Fontist formula " \
+        "repository.\n" \
+        "You can update the formula repository using the command " \
+        "`fontist update` and try again."
+      )
+    end
   end
 end

data/lib/fontist/font_installer.rb

@@ -0,0 +1,114 @@
+require "fontist/utils"
+
+module Fontist
+  class FontInstaller
+    include Utils::ZipExtractor
+    include Utils::ExeExtractor
+    include Utils::MsiExtractor
+    include Utils::SevenZipExtractor
+
+    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,108 +1,134 @@
+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
+    def self.find_fonts(font_name)
+      formulas = Index.from_yaml.load_formulas(font_name)
+
+      formulas.map do |formula|
+        formula.fonts.select do |f|
+          f.name.casecmp?(font_name)
+        end
+      end.flatten
     end
 
-    def self.find_styles(font, style)
-      new(font_name: font, style_name: style).find_styles
+    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)
+          end
+        end
+      end.flatten
     end
 
-    def all
-      @all ||= Fontist::Registry.instance.formulas
+    def self.new_from_file(path)
+      data = YAML.load_file(path)
+      new(data, path)
     end
 
-    def find
-      [find_formula].flatten.first
+    def initialize(data, path)
+      @data = data
+      @path = path
     end
 
-    def find_fonts
-      formulas = [find_formula].flatten
-      fonts = take_fonts(formulas)
-      fonts.empty? ? nil : fonts
+    def to_index_formula
+      IndexFormula.new(path)
     end
 
-    def find_styles
-      formulas.values.flat_map do |formula|
-        formula.fonts.flat_map do |f|
-          f.styles.select do |s|
-            f.name.casecmp?(font_name) && s.type.casecmp?(style_name)
-          end
-        end
-      end
+    def path
+      @path
     end
 
-    private
+    def key
+      @data["key"] || default_key
+    end
 
-    attr_reader :font_name, :style_name
+    def description
+      @data["description"]
+    end
 
-    def find_formula
-      find_by_key || find_by_font_name || find_by_font || []
+    def homepage
+      @data["homepage"]
     end
 
-    def formulas
-      @formulas ||= all.to_h
+    def copyright
+      @data["copyright"]
     end
 
-    def take_fonts(formulas)
-      formulas.map(&:fonts).flatten
+    def license_url
+      @data["license_url"]
     end
 
-    def find_by_key
-      matched_formulas = formulas.select do |key, _value|
-        key.to_s.casecmp?(font_name)
-      end
+    def license
+      @data["open_license"] || @data["requires_license_agreement"]
+    end
 
-      matched_formulas.empty? ? nil : matched_formulas.values
+    def license_required
+      @data["requires_license_agreement"] ? true : false
     end
 
-    def find_by_font_name
-      matched_formulas = formulas.select do |key, value|
-        !value.fonts.map(&:name).grep(/#{font_name}/i).empty?
-      end
+    def extract
+      Helpers.parse_to_object(@data["extract"])
+    end
 
-      matched_formulas.empty? ? nil : matched_formulas.values
+    def resources
+      Helpers.parse_to_object(@data["resources"].values)
     end
 
-    # Note
-    #
-    # These interface recursively look into every single font styles,
-    # so ideally try to avoid using it when possible, and that's why
-    # we've added it as last option in formula finder.
-    #
-    def find_by_font
-      matched_formulas = formulas.select do |key, value|
-        match_in_font_styles?(value[:fonts])
-      end
+    def fonts
+      @fonts ||= Helpers.parse_to_object(hash_collection_fonts + hash_fonts)
+    end
+
+    private
 
-      matched_formulas.empty? ? nil : matched_formulas.values
+    def default_key
+      escaped = Regexp.escape(Fontist.formulas_path.to_s + "/")
+      @path.sub(Regexp.new("^" + escaped), "").sub(/\.yml$/, "")
     end
 
-    def match_in_font_styles?(fonts)
-      styles = fonts.select do |font|
-        !font.styles.map(&:font).grep(/#{font_name}/i).empty?
-      end
+    def hash_collection_fonts
+      return [] unless @data["font_collections"]
 
-      styles.empty? ? false : true
+      @data["font_collections"].flat_map do |coll|
+        filenames = { "font" => coll["filename"],
+                      "source_font" => coll["source_filename"] }
+
+        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