fontist 1.7.3 → 1.8.1

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,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

data/lib/fontist/formula_paths.rb

@@ -0,0 +1,43 @@
+module Fontist
+  class FormulaPaths
+    attr_reader :font_paths
+
+    def initialize(font_paths)
+      @font_paths = font_paths
+    end
+
+    def find(font, style = nil)
+      styles = find_styles_by_formulas(font, style)
+      return if styles.empty?
+
+      fonts = styles.uniq { |s| s["font"] }.flat_map do |s|
+        paths = search_font_paths(s["font"])
+        paths.map do |path|
+          { full_name: s["full_name"],
+            path: path }
+        end
+      end
+
+      fonts.empty? ? nil : fonts
+    end
+
+    private
+
+    def find_styles_by_formulas(font, style)
+      if style
+        Formula.find_styles(font, style)
+      else
+        fonts = Formula.find_fonts(font)
+        return [] unless fonts
+
+        fonts.flat_map(&:styles)
+      end
+    end
+
+    def search_font_paths(filename)
+      font_paths.select do |path|
+        File.basename(path) == filename
+      end
+    end
+  end
+end

data/lib/fontist/helpers.rb

@@ -0,0 +1,7 @@
+module Fontist
+  module Helpers
+    def self.parse_to_object(data)
+      JSON.parse(data.to_json, object_class: OpenStruct)
+    end
+  end
+end

data/lib/fontist/import/google_check.rb

@@ -12,7 +12,7 @@ module Fontist
       private
 
       def fetch_formulas
-        Formulas.fetch_formulas
+        Formula.update_formulas_repo
       end
 
       def new_fonts

data/lib/fontist/import/google_import.rb

@@ -156,10 +156,9 @@ module Fontist
           h.merge!(family_name: style.family_name,
                    type: style.style,
                    full_name: style.full_name)
-          h.merge!(style.to_h.slice(:post_script_name,
-                                    :version,
-                                    :description,
-                                    :copyright).compact)
+          h.merge!(style.to_h.select do |k, _|
+            %i(post_script_name version description copyright).include?(k)
+          end.compact)
           h.merge!(font: fix_variable_filename(style.filename))
         end
       end

data/lib/fontist/import/otfinfo_generate.rb

@@ -25,7 +25,7 @@ module Fontist
       def font_paths(font)
         formula = Fontist::Formula.find(font)
         font_formula = Object.const_get(formula.installer)
-        font_formula.fetch_font(nil, confirmation: "yes")
+        font_formula.install(confirmation: "yes")
       end
 
       def generate_styles(paths)

data/lib/fontist/import/recursive_extraction.rb

@@ -118,6 +118,9 @@ module Fontist
       def font_directory?(path, base_path)
         return true unless @subdir
 
+        # https://bugs.ruby-lang.org/issues/10011
+        base_path = Pathname.new(base_path)
+
         relative_path = Pathname.new(path).relative_path_from(base_path).to_s
         dirname = File.dirname(relative_path)
         normalized_pattern = @subdir.chomp("/")
@@ -147,7 +150,8 @@ module Fontist
       end
 
       def find_archive(path)
-        paths = Dir.children(path).map { |file| File.join(path, file) }
+        children = Dir.entries(path) - [".", ".."] # ruby 2.4 compat
+        paths = children.map { |file| File.join(path, file) }
         by_subarchive(paths) || by_size(paths)
       end