fontist 1.0.0 → 1.4.0

data/lib/fontist/font.rb

@@ -19,6 +19,18 @@ module Fontist
       new(name: name, confirmation: confirmation).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
       find_system_font || downloadable_font || raise(
         Fontist::Errors::NonSupportedFontError
@@ -31,6 +43,26 @@ module Fontist
       )
     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 +94,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,9 +4,11 @@ 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 :key, :homepage, :description, :temp_resource
+    attr_accessor :license, :license_url, :license_required, :copyright
+    attr_accessor :key, :homepage, :description, :options, :temp_resource
 
     def font_list
       @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
 
@@ -105,12 +109,19 @@ module Fontist
     end
 
     def download_file(source)
-      downloaded_file = Fontist::Downloader.download(
-        source[:urls].sample, sha: source[:sha256], file_size: source[:file_size]
+      downloaded_file = Fontist::Utils::Downloader.download(
+        source[:urls].first,
+        sha: source[:sha256],
+        file_size: source[:file_size],
+        progress_bar: is_progress_bar_enabled
       )
 
       @downloaded = true
       downloaded_file
     end
+
+    def is_progress_bar_enabled
+      options.nil? ? false : options.fetch(:progress_bar, false)
+    end
   end
 end

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

data/lib/fontist/formula.rb

@@ -28,7 +28,8 @@ module Fontist
 
     def find_fonts
       formulas = [find_formula].flatten
-      match_fonts_by_name(formulas) unless formulas.empty?
+      fonts = take_fonts(formulas)
+      fonts.empty? ? nil : fonts
     end
 
     private
@@ -36,21 +37,23 @@ module Fontist
     attr_reader :font_name
 
     def find_formula
-      find_by_font_name || find_by_font || []
+      find_by_key || find_by_font_name || find_by_font || []
     end
 
     def formulas
       @formulas ||= all.to_h
     end
 
-    def match_fonts_by_name(formulas)
-      matched_fonts = formulas.map do |formula|
-        formula.fonts.select do |font|
-          font.name.downcase == font_name.downcase
-        end
+    def take_fonts(formulas)
+      formulas.map(&:fonts).flatten
+    end
+
+    def find_by_key
+      matched_formulas = formulas.select do |key, _value|
+        key.to_s.casecmp?(font_name)
       end
 
-      matched_fonts.empty? ? nil : matched_fonts.flatten
+      matched_formulas.empty? ? nil : matched_formulas.values
     end
 
     def find_by_font_name

data/lib/fontist/formula_template.rb

@@ -0,0 +1,103 @@
+module Fontist
+  class FormulaTemplate
+    def self.create_formula_class(formula)
+      Class.new(FontFormula) do |klass|
+        cleanname = formula.fonts.first.name.gsub(/ /, "")
+        resource_name = formula.resources.to_h.keys.first
+        font_filename = formula.fonts.first.styles.first.font
+
+        key formula.key&.to_sym || formula.name.gsub(/ /, "_").downcase.to_sym
+        display_progress_bar formula.display_progress_bar if formula.display_progress_bar
+        desc formula.description
+        homepage formula.homepage
+
+        formula.resources.to_h.each do |filename, options|
+          resource filename do
+            urls options.urls
+            sha256 options.sha256
+          end
+        end
+
+        if formula.font_collections
+          formula.font_collections.each do |collection|
+            provides_font_collection do
+              filename collection.filename
+
+              collection.fonts.each do |font|
+                styles = font.styles.map { |s| [s.type, s.full_name] }.to_h
+                provides_font font.name, extract_styles_from_collection: styles
+              end
+            end
+          end
+        end
+
+        formula.fonts.each do |font|
+          provides_font(
+            font.name,
+            match_styles_from_file: font.styles.map do |style|
+              {
+                family_name: style.family_name,
+                style: style.type,
+                full_name: style.full_name,
+                post_script_name: style.post_script_name,
+                version: style.version,
+                description: style.description,
+                filename: style.font,
+                copyright: style.copyright,
+              }
+            end
+          )
+        end
+
+        klass.define_method :extract do
+          resource = resource(resource_name)
+
+          [formula.extract].flatten.each do |operation|
+            method = "#{operation.format}_extract"
+            resource = if operation.options
+                         send(method, resource, **operation.options.to_h)
+                       else
+                         send(method, resource)
+                       end
+          end
+
+          formula.fonts.each do |font|
+            match_fonts(resource, font.name)
+          end
+
+          if formula.font_collections
+            formula.font_collections.each do |collection|
+              collection.fonts.each do |font|
+                match_fonts(resource, font.name)
+              end
+            end
+          end
+        end
+
+        klass.define_method :install do
+          case platform
+          when :macos
+            install_matched_fonts "$HOME/Library/Fonts/#{cleanname}"
+          when :linux
+            install_matched_fonts "/usr/share/fonts/truetype/#{cleanname.downcase}"
+          end
+        end
+
+        test do
+          case platform
+          when :macos
+            assert_predicate "$HOME/Library/Fonts/#{cleanname}/#{font_filename}", :exist?
+          when :linux
+            assert_predicate "/usr/share/fonts/truetype/#{cleanname.downcase}/#{font_filename}", :exist?
+          end
+        end
+
+        copyright formula.copyright
+        license_url formula.license_url
+
+        open_license formula.open_license if formula.open_license
+        requires_license_agreement formula.requires_license_agreement if formula.requires_license_agreement
+      end
+    end
+  end
+end