fontist 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ba98ed24043b39252548b63233baad24570d02b80cc97d46da8e6f82b80abc3
-  data.tar.gz: 0412c264ac03becf765a3c81dad018dcd0ac3607fbe48b58469453a043740d9f
+  metadata.gz: 8dbc313275aceace35c9a4f5e39bf17af46e8d0c2d661f4270909c36d6dc855e
+  data.tar.gz: 8abacb5373f59f3e0df5fae5baeb2a81adfab4eb40a5ae55a12867c4da646d88
 SHA512:
-  metadata.gz: a1761bd0c41b66ee758204ee2219505604a8d644cdd96409d7544c8bb528726528e91f9057c4edab6fc7721f336c13a80e5442d7fd148ccb299040f3bface750
-  data.tar.gz: 7c0889d2f66affbe7c9e4f1f798051fd72305c7f89760469e01d1bb7d037d104c143eabbaff0be1bdd83f6e398898cadac9cee090579cdbdbf0eda4f3dc0c448
+  metadata.gz: d5b234dcafb1ad011c508b1972b2b0ba79aa0222cdc5117d6c47250f2a8e4f3ec62f9404ac039ee8452b88aa050200201d1b3957e2ff70c7da1f54556b82a41a
+  data.tar.gz: 49dc8f923c050fc6d793fe5a24315e75728e5baa9c50cb97ca596641d4344d301bdab3bd96b0e6f7157b745daaa78e5755325e22d2dc97dd72aff6bf4ddae8d4

data/.github/workflows/macosx.yml

@@ -27,4 +27,4 @@ jobs:
         run: bin/setup
 
       - name: Run tests
-        run: bin/rspec
+        run: TEST_ENV=CI bin/rspec

data/.github/workflows/ubuntu.yml

@@ -27,4 +27,4 @@ jobs:
         run: bin/setup
 
       - name: Run tests
-        run: bin/rspec
+        run: TEST_ENV=CI bin/rspec

data/.gitignore

@@ -7,8 +7,10 @@
 /spec/reports/
 /tmp/
 Gemfile.lock
-/assets/*
-!/assets/fonts/.keep
+
+# fonts
+/spec/fixtures/fonts/*
+/spec/fixtures/fonts/DejaVuSerif.ttf
 
 # rspec failure tracking
 .rspec_status

data/README.md

@@ -28,40 +28,102 @@ gem install fontist
 
 ## Usage
 
-### Find a font
+### Font
 
-The fontist library allows us to easily locate or download a any of the supported
-fonts and then it returns the complete path for the path. To find any font in a
-user's system we can use the following interface.
+The `Fontist::Font` is your go to place to deal with any font using fontist. This
+interface will allow you to find a font or install a font. Lets start with how
+can we find a font in your system.
+
+#### Finding a font
+
+The `Fontist::Fontist.find` interface can be used a find a font in your system.
+It will look into the operating system specific font directories, and also the
+fontist specific `~/.fontist` directory.
 
 ```ruby
-Fontist::Finder.find("Calibri")
+Fontist::Font.find(name)
 ```
 
-### Supported fonts
+If fontist find a font then it will return the paths, but if not found then it
+will could raise an unsupported font error or maybe an installation instruction
+for that specific font.
+
+#### Install a font
+
+The `Fontist::Font.install` interface can be used to install any supported font.
+This interface first checks if you already have that font installed or not and
+if you do then it will return the paths.
+
+If you don't but supported by fontist, then it will download the font and copy
+it to `~/.fontist` directory and also return the paths.
 
 ```ruby
-[
-  "Arial",
-  "Calibri",
-  "Cambria",
-  "Candara",
-  "Consola",
-  "Constantia",
-  "Corbel",
-  "Courier",
-  "Meiryo",
-  "Meiryo UI",
-  "Source Code Pro",
-  "Source Han Sans",
-  "Source Sans Pro",
-  "Source Serif Pro",
-  "Times New Roman",
-  "Trebuchet",
-  "Verdana"
-]
+Fontist::Font.install(name, confirmation: "no")
 ```
 
+If there are some issue with the provided font, like not supported or some other
+issue then it will raise those errors.
+
+#### List all fonts
+
+The `Fontist::Font` interface exposes an interface to list all supported fonts,
+this might be useful if want to know the name of the font or the available
+styles. You can do that by using:
+
+```ruby
+Fontist::Font.all
+```
+
+The return values are ` OpenStruct` object, so you can easily do any other
+operation you would do in any ruby object.
+
+### Formula
+
+The `fontist` gem internally usages the `Fontist::Formula` interface to find a
+registered formula or fonts supported by any formula. Unless, you need to do
+anything with that you shouldn't need to work with this interface directly. But
+if you do then these are the public interface it offers.
+
+#### Find a formula
+
+The `Fontist::Formula.find` interface allows you to find any of the registered
+formula. This interface takes a font name as an argument and it looks through
+each of the registered formula that offers this font installation. Usages:
+
+```ruby
+Fontist::Formula.find("Calibri")
+```
+
+The above method will find which formula offers this font and then it will
+return a installable formula that can be used to check licences or install that
+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
+fonts and if you want a interface that can return the complete list then this is
+your friend. You can use it as following:
+
+```ruby
+Fontist::Formula.find_fonts("Calibri")
+```
+
+
+#### List all formulas
+
+The `Fontist::Formula` interface exposes an interface to list all registered
+font formula. This might be useful if want to know the name of the formula or
+what type fonts can be installed using that formula. Usages:
+
+```ruby
+Fontist::Formula.all
+```
+
+The return values are ` OpenStruct` object, so you can easily do any other
+operation you would do in any ruby object.
+
+
 ## Development
 
 We are following Sandi Metz's Rules for this gem, you can read the

data/lib/fontist.rb

@@ -1,12 +1,19 @@
+require "down"
+require "digest"
+require "json"
+require "yaml"
+require "singleton"
+
 require "fontist/errors"
 require "fontist/version"
 
-require "fontist/finder"
-require "fontist/source"
-require "fontist/installer"
-require "fontist/system_font"
+require "fontist/font"
+require "fontist/downloader"
+
+require "fontist/registry"
 require "fontist/formulas"
-require "fontist/formula_finder"
+require "fontist/formula"
+require "fontist/system_font"
 
 module Fontist
   def self.lib_path
@@ -17,14 +24,6 @@ module Fontist
     Pathname.new(File.dirname(__dir__))
   end
 
-  def self.assets_path
-    Fontist.root_path.join("assets")
-  end
-
-  def self.data_path
-    Fontist.lib_path.join("fontist", "data")
-  end
-
   def self.fontist_path
     Pathname.new(Dir.home).join(".fontist")
   end
@@ -32,4 +31,20 @@ module Fontist
   def self.fonts_path
     Fontist.fontist_path.join("fonts")
   end
+
+  def self.formulas_path
+    Fontist.lib_path.join("fontist", "formulas")
+  end
 end
+
+# Loading formulas
+#
+# The formula loading behavior is dynamic, so what we are actualy
+# doing here is looking for formulas in the `./fontist/formulas` directory
+# then require thos as we go.
+#
+# There is a caviat, since the `Dir` method depends on absoulate path
+# so moving this loading up or somewhere else might not always ensure
+# the fontist related path helpers.
+#
+Dir[Fontist.formulas_path.join("**.rb").to_s].sort.each { |file| require file }

data/lib/fontist/downloader.rb

@@ -1,26 +1,23 @@
-require "down"
-require "digest"
-
 module Fontist
   class Downloader
     def initialize(file, file_size: nil, sha: nil, progress: nil)
-      @sha = sha
       @file = file
       @progress = progress
+      @sha = [sha].flatten.compact
       @file_size = (file_size || default_file_size).to_i
     end
 
     def download
       file = download_file
-      verify_file_checksum(file) || raise_invalid_file
-    end
 
-    def verify_file_checksum(file)
-      file if Digest::SHA256.file(file) === sha
-    end
+      if !sha.empty? && !sha.include?(Digest::SHA256.file(file).to_s)
+        raise(Fontist::Errors::TemparedFileError.new(
+          "The downloaded file from #{@file} doesn't " \
+          "match with the expected sha256 checksum!"
+        ))
+      end
 
-    def raise_invalid_file
-      raise(Fontist::Errors::TemparedFileError)
+      file
     end
 
     def self.download(file, options = {})
@@ -52,6 +49,9 @@ module Fontist
           bar.increment(progress / byte_to_megabyte) if @progress === true
         }
       )
+
+    rescue Down::NotFound
+      raise(Fontist::Errors::InvalidResourceError.new("Invalid URL: #{@file}"))
     end
   end
 

data/lib/fontist/errors.rb

@@ -4,5 +4,6 @@ module Fontist
     class MissingFontError < StandardError; end
     class NonSupportedFontError < StandardError; end
     class TemparedFileError < StandardError; end
+    class InvalidResourceError < StandardError; end
   end
 end

data/lib/fontist/font.rb

@@ -0,0 +1,78 @@
+module Fontist
+  class Font
+    def initialize(options = {})
+      @name = options.fetch(:name, nil)
+      @confirmation = options.fetch(:confirmation, "no")
+
+      check_or_create_fontist_path!
+    end
+
+    def self.all
+      new.all
+    end
+
+    def self.find(name)
+      new(name: name).find
+    end
+
+    def self.install(name, confirmation: "no")
+      new(name: name, confirmation: confirmation).install
+    end
+
+    def find
+      find_system_font || downloadable_font || raise(
+        Fontist::Errors::NonSupportedFontError
+      )
+    end
+
+    def install
+      find_system_font || download_font || raise(
+        Fontist::Errors::NonSupportedFontError
+      )
+    end
+
+    def all
+      Fontist::Formula.all.to_h.map { |_name, formula| formula.fonts }.flatten
+    end
+
+    private
+
+    attr_reader :name, :confirmation
+
+    def find_system_font
+      Fontist::SystemFont.find(name)
+    end
+
+    def check_or_create_fontist_path!
+      unless Fontist.fonts_path.exist?
+        require "fileutils"
+        FileUtils.mkdir_p(Fontist.fonts_path)
+      end
+    end
+
+    def font_installer(formula)
+      Object.const_get(formula.installer)
+    end
+
+    def formula
+      @formula ||= Fontist::Formula.find(name)
+    end
+
+    def downloadable_font
+      if formula
+        raise(
+          Fontist::Errors::MissingFontError,
+          "Fonts are missing, please run " \
+          "Fontist::Font.install('#{name}', confirmation: 'yes') to " \
+          "download the font"
+        )
+      end
+    end
+
+    def download_font
+      if formula
+        font_installer(formula).fetch_font(name, confirmation: confirmation)
+      end
+    end
+  end
+end

data/lib/fontist/font_formula.rb

@@ -0,0 +1,116 @@
+module Fontist
+  class FontFormula
+    include Singleton
+    extend Fontist::Utils::Dsl
+    include Fontist::Utils::ZipExtractor
+    include Fontist::Utils::ExeExtractor
+
+    attr_accessor :license, :license_url, :license_required
+    attr_accessor :key, :homepage, :description, :temp_resource
+
+    def font_list
+      @font_list ||= []
+    end
+
+    def resources
+      @resources ||= {}
+    end
+
+    def fonts
+      @fonts ||= font_list.uniq
+    end
+
+    def extract_font_styles(options)
+      extract_from_file(options) ||
+        extract_from_collection(options) || default_font
+    end
+
+    def reinitialize
+      @downloaded = false
+      @matched_fonts = []
+    end
+
+    def self.fetch_font(name, confirmation:)
+      if instance.license_required && confirmation.downcase != "yes"
+        raise(Fontist::Errors::LicensingError)
+      end
+
+      instance.reinitialize
+      instance.install_font(name, confirmation)
+    end
+
+    def install_font(name, confirmation)
+      run_in_temp_dir { extract }
+      matched_fonts_uniq = matched_fonts.flatten.uniq
+      matched_fonts_uniq.empty? ? nil : matched_fonts_uniq
+    end
+
+    private
+
+    attr_reader :downloaded, :matched_fonts
+
+    def resource(name, &block)
+      source = resources[name]
+      block_given? ? yield(source) : source
+    end
+
+    def fonts_path
+      @fonts_path ||= Fontist.fonts_path
+    end
+
+    def default_font
+      [{ type: "Regular", font: temp_resource[:filename] }]
+    end
+
+    def run_in_temp_dir(&block)
+      Dir.mktmpdir(nil, Dir.tmpdir) do |dir|
+        @temp_dir = Pathname.new(dir)
+
+        yield
+        @temp_dir = nil
+      end
+    end
+
+    def extract_from_file(options)
+      styles = options.fetch(:match_styles_from_file, [])
+
+      unless styles.empty?
+        styles.map { |type, file | { type: type, font: file } }
+      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
+
+      font
+    end
+
+    def extract_from_collection(options)
+      styles = options.fetch(:extract_styles_from_collection, [])
+
+      unless styles.empty?
+        styles.map do |type, file|
+          { type: type, collection: file, font: temp_resource[: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
+
+      fonts || []
+    end
+
+    def download_file(source)
+      downloaded_file = Fontist::Downloader.download(
+        source[:urls].sample, sha: source[:sha256], file_size: source[:file_size]
+      )
+
+      @downloaded = true
+      downloaded_file
+    end
+  end
+end