fontist 1.5.1 → 1.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a35bdc7e99674109bec5810eb8e57d91516ff93f7cf4aefbb608e0298a010f76
-  data.tar.gz: fc886de884ebc5309acb9dc6168fd6c2d7f460f11e05d9be8a1ffca8177e3b6f
+  metadata.gz: bfbc7b0d13e8084d44fe41d69ff1719a203a375cd75970cf8efa0abd2cd711af
+  data.tar.gz: 1a259f0e45ea264ca55c1e112cb25bd672f41532ae82c58989cf368f058d2374
 SHA512:
-  metadata.gz: 05f4a699ac69711925ebf9f036be06e5f5c302b9fe3cec23974bc7892ff18a73115d2373694784ee11ac8c0620b5df215a50cb9c2f173a6448a1ceb0b688753b
-  data.tar.gz: a41c8f091f5783cb0f2d0beabc0d92e9059f78415f36593f9de6b18eb1175d4059a38cb60710dd5064f0a8280aaa6ab9a13e68190903ed7ebe011e8b9068d39c
+  metadata.gz: 82a25bf83f43b02f1e8a77717d9d240ebd55910bc0c529ce0ff09d434cad829c862c8db9564597159a3214b6cffa9dce2ee8f64a6f841f5dc589e10571a94c44
+  data.tar.gz: 91771cd423b516b6db27db7ef5e55cd24f01bea9fb368aa4331e0bc75a887e3df35d84a4fa08748e98bc41a16d8f80861cf584ff9cc6a61e938c3b7392ee94ee

data/README.md

@@ -109,7 +109,7 @@ fonts in your system.
 #### Find formula fonts
 
 Normally, each font name can be associated with multiple styles or collection, for
-example the `Calibri` font might contains a `regular`, `bola` or `italic` styles
+example the `Calibri` font might contains a `regular`, `bold` or `italic` styles
 fonts and if you want a interface that can return the complete list then this is
 your friend. You can use it as following:
 
@@ -136,28 +136,29 @@ operation you would do in any ruby object.
 
 #### Locations
 
-Fontist lets find font locations from a YAML manifest of the following format:
+Fontist lets find font locations from a manifest of the following format:
 
-```yml
-Segoe UI:
-- Regular
-- Bold
-Roboto Mono:
-- Regular
+```ruby
+{"Segoe UI"=>["Regular", "Bold"],
+ "Roboto Mono"=>["Regular"]}
 ```
 
-Calling the following code returns a nested hash with font paths.
+Calling the following code returns a nested hash with font paths and names.
+Font name is useful to choose a specific font in a font collection file (TTC).
 
 ```ruby
-Fontist::Manifest::Locations.call(manifest_path)
+Fontist::Manifest::Locations.from_hash(manifest)
 ```
 
 ```ruby
-{"Segoe UI"=>
-  {"Regular"=>["/Users/user/.fontist/fonts/SEGOEUI.TTF"],
-   "Bold"=>["/Users/user/.fontist/fonts/SEGOEUIB.TTF"]},
- "Roboto Mono"=>
-  {"Regular"=>[]}}
+{"Segoe UI"=> {
+   "Regular"=>{"full_name"=>"Segoe UI",
+               "paths"=>["/Users/user/.fontist/fonts/SEGOEUI.TTF"]},
+   "Bold"=>{"full_name"=>"Segoe UI Bold",
+            "paths"=>["/Users/user/.fontist/fonts/SEGOEUIB.TTF"]}},
+ "Roboto Mono"=> {
+   "Regular"=>{"full_name"=>nil,
+               "paths"=>[]}}}
 ```
 
 #### Install
@@ -166,17 +167,41 @@ Fontist lets not only to get font locations but also to install fonts from the
 manifest:
 
 ```ruby
-Fontist::Manifest::Install.call(manifest, confirmation: "yes")
+Fontist::Manifest::Install.from_hash(manifest, confirmation: "yes")
 ```
 
 It will install fonts and return their locations:
 
 ```ruby
-{"Segoe UI"=>
-  {"Regular"=>["/Users/user/.fontist/fonts/SEGOEUI.TTF"],
-   "Bold"=>["/Users/user/.fontist/fonts/SEGOEUIB.TTF"]},
- "Roboto Mono"=>
-  {"Regular"=>["/Users/user/.fontist/fonts/RobotoMono-VariableFont_wght.ttf"]}}
+{"Segoe UI"=> {
+   "Regular"=>{"full_name"=>"Segoe UI",
+               "paths"=>["/Users/user/.fontist/fonts/SEGOEUI.TTF"]},
+   "Bold"=>{"full_name"=>"Segoe UI Bold",
+            "paths"=>["/Users/user/.fontist/fonts/SEGOEUIB.TTF"]}},
+ "Roboto Mono"=> {
+   "Regular"=>{"full_name"=>"Roboto Mono Regular",
+               "paths"=>["/Users/user/.fontist/fonts/RobotoMono-VariableFont_wght.ttf"]}}}
+```
+
+#### Support of YAML format
+
+Both commands support a YAML file as an input with a `from_file` method. For
+example, if there is a `manifest.yml` file containing:
+
+```yaml
+Segoe UI:
+- Regular
+- Bold
+Roboto Mono:
+- Regular
+```
+
+Then the following calls would return font names and paths, as from the
+`from_hash` method (see [Locations](#locations) and [Install](#install)).
+
+```ruby
+Fontist::Manifest::Locations.from_file("manifest.yml")
+Fontist::Manifest::Install.from_file("manifest.yml", confirmation: "yes")
 ```
 
 ### CLI
@@ -191,7 +216,8 @@ All searches are case-insensitive for ease of use.
 
 The `install` command is similar to the `Font.install` call. It first checks
 whether this font is already installed, and if not, then installs the font and
-returns its paths. Font or formula could be specified as a name.
+returns its paths. Only font name (not formula name, nor font filename) could
+be used as a parameter.
 
 ```
 $ fontist install "segoe ui"
@@ -274,11 +300,17 @@ $ fontist manifest-locations manifest.yml
 ---
 Segoe UI:
   Regular:
-  - "/Users/user/.fontist/fonts/SEGOEUI.TTF"
+    full_name: Segoe UI
+    paths:
+    - "/Users/user/.fontist/fonts/SEGOEUI.TTF"
   Bold:
-  - "/Users/user/.fontist/fonts/SEGOEUIB.TTF"
+    full_name: Segoe UI Bold
+    paths:
+    - "/Users/user/.fontist/fonts/SEGOEUIB.TTF"
 Roboto Mono:
-  Regular: []
+  Regular:
+    full_name:
+    paths: []
 ```
 
 Since Segoe UI is installed, but Roboto Mono is not.
@@ -292,12 +324,18 @@ $ fontist manifest-install --confirm-license manifest.yml
 ---
 Segoe UI:
   Regular:
-  - "/Users/user/.fontist/fonts/SEGOEUI.TTF"
+    full_name: Segoe UI
+    paths:
+    - "/Users/user/.fontist/fonts/SEGOEUI.TTF"
   Bold:
-  - "/Users/user/.fontist/fonts/SEGOEUIB.TTF"
+    full_name: Segoe UI Bold
+    paths:
+    - "/Users/user/.fontist/fonts/SEGOEUIB.TTF"
 Roboto Mono:
   Regular:
-  - "/Users/user/.fontist/fonts/RobotoMono-VariableFont_wght.ttf"
+    full_name: Roboto Mono Regular
+    paths:
+    - "/Users/user/.fontist/fonts/RobotoMono-VariableFont_wght.ttf"
 ```
 
 #### Help
@@ -308,6 +346,15 @@ List of all commands could be seen by:
 fontist help
 ```
 
+### Configuration
+
+By default Fontist uses the `~/.fontist` directory to store fonts and its
+files. It could be changed with the `FONTIST_PATH` environment variable.
+
+```sh
+FONTIST_PATH=~/.fontist_new fontist update
+```
+
 ## Development
 
 We are following Sandi Metz's Rules for this gem, you can read the

data/fontist.gemspec

@@ -34,6 +34,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "ruby-ole", "~> 1.0"
   spec.add_runtime_dependency "thor", "~> 1.0.1"
   spec.add_runtime_dependency "git", "~> 1.0"
+  spec.add_runtime_dependency "ttfunk", "~> 1.0"
 
   spec.add_development_dependency "extract_ttc", "~> 0.1"
   spec.add_development_dependency "pry"

data/lib/fontist.rb

@@ -29,7 +29,7 @@ module Fontist
   end
 
   def self.fontist_path
-    Pathname.new(Dir.home).join(".fontist")
+    Pathname.new(ENV["FONTIST_PATH"] || File.join(Dir.home, ".fontist"))
   end
 
   def self.fonts_path
@@ -55,4 +55,8 @@ module Fontist
   def self.system_file_path
     Fontist.lib_path.join("fontist", "system.yml")
   end
+
+  def self.system_index_path
+    Fontist.fontist_path.join("system_index.yml")
+  end
 end

data/lib/fontist/cli.rb

@@ -9,17 +9,19 @@ module Fontist
       false
     end
 
-    desc "install FONT", "Install font by font or formula"
+    desc "install FONT", "Install font"
     option :force, type: :boolean, aliases: :f,
                    desc: "Install even if it's already installed in system"
+    option :confirm_license, type: :boolean, desc: "Confirm license agreement"
     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"))
+      Fontist::Font.install(
+        font,
+        force: options[:force],
+        confirmation: options[:confirm_license] ? "yes" : "no"
+      )
       STATUS_SUCCESS
     rescue Fontist::Errors::NonSupportedFontError
-      Fontist.ui.error("Could not find font '#{font}'.")
-      STATUS_ERROR
+      could_not_find_font(font)
     end
 
     desc "uninstall/remove FONT", "Uninstall font by font or formula"
@@ -32,8 +34,7 @@ module Fontist
       Fontist.ui.error(e.message)
       STATUS_ERROR
     rescue Fontist::Errors::NonSupportedFontError
-      Fontist.ui.error("Could not find font '#{font}'.")
-      STATUS_ERROR
+      could_not_find_font(font)
     end
     map remove: :uninstall
 
@@ -47,7 +48,7 @@ module Fontist
     rescue Fontist::Errors::MissingFontError => e
       error(e.message)
     rescue Fontist::Errors::NonSupportedFontError
-      error("Could not find font '#{font}'.")
+      could_not_find_font(font)
     end
 
     desc "list [FONT]", "List installation status of FONT or fonts in fontist"
@@ -56,7 +57,7 @@ module Fontist
       print_list(formulas)
       success
     rescue Fontist::Errors::NonSupportedFontError
-      error("Could not find font '#{font}'.")
+      could_not_find_font(font)
     end
 
     desc "update", "Update formulas"
@@ -69,7 +70,7 @@ module Fontist
     desc "manifest-locations MANIFEST",
          "Get locations of fonts from MANIFEST (yaml)"
     def manifest_locations(manifest)
-      paths = Fontist::Manifest::Locations.call(manifest)
+      paths = Fontist::Manifest::Locations.from_file(manifest)
       print_yaml(paths)
       success
     rescue Fontist::Errors::ManifestCouldNotBeFoundError
@@ -81,7 +82,7 @@ module Fontist
     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(
+      paths = Fontist::Manifest::Install.from_file(
         manifest,
         confirmation: options[:confirm_license] ? "yes" : "no"
       )
@@ -98,6 +99,7 @@ module Fontist
     option :name, desc: "Example: Times New Roman"
     option :mirror, repeatable: true
     option :subarchive, desc: "Subarchive to choose when there are several ones"
+    option :subdir, desc: "Subdirectory to take fonts from"
     def create_formula(url)
       require "fontist/import/create_formula"
       name = Fontist::Import::CreateFormula.new(url, options).call
@@ -111,6 +113,15 @@ module Fontist
       STATUS_SUCCESS
     end
 
+    def could_not_find_font(font)
+      error("Font '#{font}' 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
+
     def error(message)
       Fontist.ui.error(message)
       STATUS_ERROR

data/lib/fontist/errors.rb

@@ -7,6 +7,7 @@ module Fontist
     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

data/lib/fontist/font.rb

@@ -81,7 +81,16 @@ module Fontist
     attr_reader :name, :confirmation
 
     def find_system_font
-      Fontist::SystemFont.find(name)
+      paths = Fontist::SystemFont.find(name)
+      unless paths
+        Fontist.ui.say(%(Font "#{name}" not found locally.))
+        return
+      end
+
+      Fontist.ui.say("Fonts found at:")
+      paths.each do |path|
+        Fontist.ui.say("- #{path}")
+      end
     end
 
     def check_or_create_fontist_path!
@@ -113,7 +122,13 @@ module Fontist
     def download_font
       if formula
         check_and_confirm_required_license(formula)
-        font_installer(formula).fetch_font(name, confirmation: confirmation)
+        paths = font_installer(formula).fetch_font(name,
+                                                   confirmation: confirmation)
+
+        Fontist.ui.say("Fonts installed at:")
+        paths.each do |path|
+          Fontist.ui.say("- #{path}")
+        end
       end
     end
 
@@ -232,6 +247,5 @@ module Fontist
     def installed(style)
       path(style) ? true : false
     end
-
   end
 end

data/lib/fontist/font_formula.rb

@@ -83,34 +83,50 @@ module Fontist
       end
     end
 
-    def match_fonts(fonts_dir, font_name)
-      fonts = map_names_to_fonts(font_name).join("|")
-      font = fonts_dir.grep(/#{fonts}/i)
-      @matched_fonts.push(font) if font
+    def match_fonts(fonts_paths, font_name)
+      filenames = filenames_by_font_name(font_name)
+      paths = search_for_filenames(fonts_paths, filenames)
+      @matched_fonts.push(*paths)
 
-      font
+      paths
     end
 
-    def extract_from_collection(options)
-      styles = options.fetch(:extract_styles_from_collection, [])
+    def filenames_by_font_name(font_name)
+      fonts.map do |f|
+        if f[:name].casecmp?(font_name)
+          f[:styles].map do |s|
+            s[:font]
+          end
+        end
+      end.flatten.compact
+    end
 
-      unless styles.empty?
-        styles.map do |type, file|
-          { type: type, collection: file, font: temp_resource[:filename] }
+    def search_for_filenames(paths, filenames)
+      paths.select do |path|
+        filenames.any? do |filename|
+          File.basename(path) == filename
         end
       end
     end
 
-    def map_names_to_fonts(font_name)
-      fonts = Fontist::Formula.find_fonts(font_name)
-      fonts = fonts.map { |font| font.styles.map(&:font) }.flatten if fonts
+    def extract_from_collection(options)
+      styles = options.fetch(:extract_styles_from_collection, [])
 
-      fonts || []
+      unless styles.empty?
+        styles.map do |attributes|
+          filenames = temp_resource.slice(:filename, :source_filename)
+          Fontist::Utils::Dsl::CollectionFont.new(attributes.merge(filenames))
+            .attributes
+        end
+      end
     end
 
     def download_file(source)
+      url = source[:urls].first
+      Fontist.ui.say(%(Downloading font "#{key}" from #{url}))
+
       downloaded_file = Fontist::Utils::Downloader.download(
-        source[:urls].first,
+        url,
         sha: source[:sha256],
         file_size: source[:file_size],
         progress_bar: is_progress_bar_enabled
@@ -121,7 +137,33 @@ module Fontist
     end
 
     def is_progress_bar_enabled
-      options.nil? ? false : options.fetch(:progress_bar, false)
+      options.nil? ? true : options.fetch(:progress_bar, true)
+    end
+
+    def font_file?(filename)
+      source_files.include?(filename)
+    end
+
+    def source_files
+      @source_files ||= 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 ||= 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/formula.rb

@@ -28,79 +28,39 @@ module Fontist
     end
 
     def find
-      [find_formula].flatten.first
+      formulas.values.detect do |formula|
+        formula.fonts.any? do |f|
+          f.name.casecmp?(font_name)
+        end
+      end
     end
 
     def find_fonts
-      formulas = [find_formula].flatten
-      fonts = take_fonts(formulas)
-      fonts.empty? ? nil : fonts
+      formulas.values.map do |formula|
+        formula.fonts.select do |f|
+          f.name.casecmp?(font_name)
+        end
+      end.flatten
     end
 
     def find_styles
-      formulas.values.flat_map do |formula|
-        formula.fonts.flat_map do |f|
+      formulas.values.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
+      end.flatten
     end
 
     private
 
     attr_reader :font_name, :style_name
 
-    def find_formula
-      find_by_key || find_by_font_name || find_by_font || []
-    end
-
     def formulas
       @formulas ||= all.to_h
     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_formulas.empty? ? nil : matched_formulas.values
-    end
-
-    def find_by_font_name
-      matched_formulas = formulas.select do |key, value|
-        !value.fonts.map(&:name).grep(/#{font_name}/i).empty?
-      end
-
-      matched_formulas.empty? ? nil : matched_formulas.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
-
-      matched_formulas.empty? ? nil : matched_formulas.values
-    end
-
-    def match_in_font_styles?(fonts)
-      styles = fonts.select do |font|
-        !font.styles.map(&:font).grep(/#{font_name}/i).empty?
-      end
-
-      styles.empty? ? false : true
-    end
-
     def check_and_register_font_formulas
       $check_and_register_font_formulas ||= Fontist::Formulas.register_formulas
     end