fontist 1.1.0 → 1.5.0

data/lib/fontist/cli.rb

@@ -0,0 +1,156 @@
+require "thor"
+
+module Fontist
+  class CLI < Thor
+    STATUS_SUCCESS = 0
+    STATUS_ERROR = 1
+
+    def self.exit_on_failure?
+      false
+    end
+
+    desc "install FONT", "Install font by font or formula"
+    option :force, type: :boolean, aliases: :f,
+                   desc: "Install even if it's already installed in system"
+    def install(font)
+      fonts_paths = Fontist::Font.install(font, force: options[:force])
+      Fontist.ui.success("These fonts are found or installed:")
+      Fontist.ui.success(fonts_paths.join("\n"))
+      STATUS_SUCCESS
+    rescue Fontist::Errors::NonSupportedFontError
+      Fontist.ui.error("Could not find font '#{font}'.")
+      STATUS_ERROR
+    end
+
+    desc "uninstall/remove FONT", "Uninstall font by font or formula"
+    def uninstall(font)
+      fonts_paths = Fontist::Font.uninstall(font)
+      Fontist.ui.success("These fonts are removed:")
+      Fontist.ui.success(fonts_paths.join("\n"))
+      STATUS_SUCCESS
+    rescue Fontist::Errors::MissingFontError => e
+      Fontist.ui.error(e.message)
+      STATUS_ERROR
+    rescue Fontist::Errors::NonSupportedFontError
+      Fontist.ui.error("Could not find font '#{font}'.")
+      STATUS_ERROR
+    end
+    map remove: :uninstall
+
+    desc "status [FONT]", "Show status of FONT or all fonts in fontist"
+    def status(font = nil)
+      formulas = Fontist::Font.status(font)
+      return error("No font is installed.") if formulas.empty?
+
+      print_formulas(formulas)
+      success
+    rescue Fontist::Errors::MissingFontError => e
+      error(e.message)
+    rescue Fontist::Errors::NonSupportedFontError
+      error("Could not find font '#{font}'.")
+    end
+
+    desc "list [FONT]", "List installation status of FONT or fonts in fontist"
+    def list(font = nil)
+      formulas = Fontist::Font.list(font)
+      print_list(formulas)
+      success
+    rescue Fontist::Errors::NonSupportedFontError
+      error("Could not find font '#{font}'.")
+    end
+
+    desc "update", "Update formulas"
+    def update
+      Formulas.fetch_formulas
+      Fontist.ui.say("Formulas have been successfully updated")
+      STATUS_SUCCESS
+    end
+
+    desc "manifest-locations MANIFEST",
+         "Get locations of fonts from MANIFEST (yaml)"
+    def manifest_locations(manifest)
+      paths = Fontist::Manifest::Locations.call(manifest)
+      print_yaml(paths)
+      success
+    rescue Fontist::Errors::ManifestCouldNotBeFoundError
+      error("Manifest could not be found.")
+    rescue Fontist::Errors::ManifestCouldNotBeReadError
+      error("Manifest could not be read.")
+    end
+
+    desc "manifest-install MANIFEST", "Install fonts from MANIFEST (yaml)"
+    option :confirm_license, type: :boolean, desc: "Confirm license agreement"
+    def manifest_install(manifest)
+      paths = Fontist::Manifest::Install.call(
+        manifest,
+        confirmation: options[:confirm_license] ? "yes" : "no"
+      )
+
+      print_yaml(paths)
+      success
+    rescue Fontist::Errors::ManifestCouldNotBeFoundError
+      error("Manifest could not be found.")
+    rescue Fontist::Errors::ManifestCouldNotBeReadError
+      error("Manifest could not be read.")
+    end
+
+    desc "create-formula URL", "Create a new formula with fonts from URL"
+    option :name, desc: "Example: Times New Roman"
+    option :mirror, repeatable: true
+    def create_formula(url)
+      require "fontist/import/create_formula"
+      name = Fontist::Import::CreateFormula.new(url, options).call
+      Fontist.ui.say("#{name} formula has been successfully created")
+      STATUS_SUCCESS
+    end
+
+    private
+
+    def success
+      STATUS_SUCCESS
+    end
+
+    def error(message)
+      Fontist.ui.error(message)
+      STATUS_ERROR
+    end
+
+    def print_yaml(object)
+      Fontist.ui.say(YAML.dump(object))
+    end
+
+    def print_formulas(formulas)
+      formulas.each do |formula, fonts|
+        Fontist.ui.success(formula.installer)
+
+        fonts.each do |font, styles|
+          Fontist.ui.success(" #{font.name}")
+
+          styles.each do |style, path|
+            Fontist.ui.success("  #{style.type} (#{path})")
+          end
+        end
+      end
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def print_list(formulas)
+      formulas.each do |formula, fonts|
+        Fontist.ui.say(formula.installer)
+
+        fonts.each do |font, styles|
+          Fontist.ui.say(" #{font.name}")
+
+          styles.each do |style, installed|
+            if installed
+              Fontist.ui.success("  #{style.type} (installed)")
+            else
+              Fontist.ui.error("  #{style.type} (uninstalled)")
+            end
+          end
+        end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+  end
+end

data/lib/fontist/errors.rb

@@ -3,7 +3,13 @@ module Fontist
     class LicensingError < StandardError; end
     class MissingFontError < StandardError; end
     class NonSupportedFontError < StandardError; end
-    class TemparedFileError < 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
   end
 end

data/lib/fontist/font.rb

@@ -3,6 +3,7 @@ module Fontist
     def initialize(options = {})
       @name = options.fetch(:name, nil)
       @confirmation = options.fetch(:confirmation, "no")
+      @force = options.fetch(:force, false)
 
       check_or_create_fontist_path!
     end
@@ -15,8 +16,24 @@ module Fontist
       new(name: name).find
     end
 
-    def self.install(name, confirmation: "no")
-      new(name: name, confirmation: confirmation).install
+    def self.install(name, confirmation: "no", force: false)
+      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
+
+    def self.status(name)
+      new(name: name).status
+    end
+
+    def self.list(name)
+      new(name: name).list
     end
 
     def find
@@ -26,11 +43,35 @@ module Fontist
     end
 
     def install
-      find_system_font || download_font || raise(
+      (find_system_font unless @force) || download_font || raise(
+        Fontist::Errors::NonSupportedFontError
+      )
+    end
+
+    def try_install
+      download_font
+    end
+
+    def uninstall
+      uninstall_font || downloadable_font || raise(
         Fontist::Errors::NonSupportedFontError
       )
     end
 
+    def status
+      return installed_statuses unless @name
+
+      font_status || downloadable_font || raise(
+        Fontist::Errors::NonSupportedFontError
+      )
+    end
+
+    def list
+      return all_list unless @name
+
+      font_list || raise(Fontist::Errors::NonSupportedFontError)
+    end
+
     def all
       Fontist::Formula.all.to_h.map { |_name, formula| formula.fonts }.flatten
     end
@@ -62,17 +103,135 @@ module Fontist
       if formula
         raise(
           Fontist::Errors::MissingFontError,
-          "Fonts are missing, please run " \
-          "Fontist::Font.install('#{name}', confirmation: 'yes') to " \
-          "download the font"
+          "#{name} fonts are missing, please run " \
+          "`fontist install '#{name}'` to " \
+          "download the font."
         )
       end
     end
 
     def download_font
       if formula
+        check_and_confirm_required_license(formula)
         font_installer(formula).fetch_font(name, confirmation: confirmation)
       end
     end
+
+    def check_and_confirm_required_license(formula)
+      if formula.license_required && !confirmation.casecmp("yes").zero?
+        @confirmation = show_license_and_ask_for_input(formula.license)
+
+        if !confirmation.casecmp("yes").zero?
+          raise Fontist::Errors::LicensingError.new(
+            "Fontist will not download these fonts unless you accept the terms."
+          )
+        end
+      end
+    end
+
+    def show_license_and_ask_for_input(license)
+      Fontist.ui.say(license_agrement_message(license))
+      Fontist.ui.ask(
+        "\nDo you accept all presented font licenses, and want Fontist " \
+        "to download these fonts for you? => TYPE 'Yes' or 'No':"
+      )
+    end
+
+    def license_agrement_message(license)
+      <<~MSG
+        FONT LICENSE ACCEPTANCE REQUIRED FOR "#{name}":
+
+        Fontist can install this font if you accept its licensing conditions.
+
+        FONT LICENSE BEGIN ("#{name}")
+        -----------------------------------------------------------------------
+        #{license}
+        -----------------------------------------------------------------------
+        FONT LICENSE END ("#{name}")
+      MSG
+    end
+
+    def uninstall_font
+      paths = find_fontist_font
+      return unless paths
+
+      paths.each do |path|
+        File.delete(path)
+      end
+
+      paths
+    end
+
+    def find_fontist_font
+      Fontist::FontistFont.find(name)
+    end
+
+    def installed_statuses
+      installed_styles(all_formulas)
+    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? }
+    end
+
+    def path(style)
+      font_paths.grep(/#{style.font}/i).first
+    end
+
+    def font_paths
+      @font_paths ||= Dir.glob(Fontist.fonts_path.join("**"))
+    end
+
+    def all_list
+      list_styles(all_formulas)
+    end
+
+    def font_list
+      return unless formula
+
+      list_styles([formula])
+    end
+
+    def list_styles(formulas)
+      map_to_hash(formulas) do |formula|
+        map_to_hash(formula.fonts) do |font|
+          map_to_hash(font.styles) do |style|
+            installed(style)
+          end
+        end
+      end
+    end
+
+    def map_to_hash(elements)
+      elements.map { |e| [e, yield(e)] }.to_h
+    end
+
+    def installed(style)
+      path(style) ? true : false
+    end
+
   end
 end

data/lib/fontist/font_formula.rb

@@ -4,8 +4,10 @@ module Fontist
     extend Fontist::Utils::Dsl
     include Fontist::Utils::ZipExtractor
     include Fontist::Utils::ExeExtractor
+    include Fontist::Utils::MsiExtractor
+    include Fontist::Utils::SevenZipExtractor
 
-    attr_accessor :license, :license_url, :license_required
+    attr_accessor :license, :license_url, :license_required, :copyright
     attr_accessor :key, :homepage, :description, :options, :temp_resource
 
     def font_list
@@ -55,7 +57,7 @@ module Fontist
     end
 
     def fonts_path
-      @fonts_path ||= Fontist.fonts_path
+      @fonts_path = Fontist.fonts_path
     end
 
     def default_font
@@ -75,7 +77,9 @@ module Fontist
       styles = options.fetch(:match_styles_from_file, [])
 
       unless styles.empty?
-        styles.map { |type, file | { type: type, font: file } }
+        styles.map do |attributes|
+          Fontist::Utils::Dsl::Font.new(attributes).attributes
+        end
       end
     end
 
@@ -106,7 +110,7 @@ module Fontist
 
     def download_file(source)
       downloaded_file = Fontist::Utils::Downloader.download(
-        source[:urls].sample,
+        source[:urls].first,
         sha: source[:sha256],
         file_size: source[:file_size],
         progress_bar: is_progress_bar_enabled

data/lib/fontist/fontist_font.rb

@@ -0,0 +1,70 @@
+module Fontist
+  class FontistFont
+    def initialize(font_name:)
+      @font_name = font_name
+
+      check_and_register_font_formulas
+    end
+
+    def self.find(name)
+      new(font_name: name).find
+    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
+
+      paths.empty? ? nil : paths
+    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