fontist 0.4.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ba98ed24043b39252548b63233baad24570d02b80cc97d46da8e6f82b80abc3
-  data.tar.gz: 0412c264ac03becf765a3c81dad018dcd0ac3607fbe48b58469453a043740d9f
+  metadata.gz: 1f45a43c4f700cd793576c4783b7098beea7d366c8aeb2654fcc5b6a38c986b0
+  data.tar.gz: 01ce25c4eae85e3fb20b7cdf0d106a04a2273e770a4261e937c344520a723651
 SHA512:
-  metadata.gz: a1761bd0c41b66ee758204ee2219505604a8d644cdd96409d7544c8bb528726528e91f9057c4edab6fc7721f336c13a80e5442d7fd148ccb299040f3bface750
-  data.tar.gz: 7c0889d2f66affbe7c9e4f1f798051fd72305c7f89760469e01d1bb7d037d104c143eabbaff0be1bdd83f6e398898cadac9cee090579cdbdbf0eda4f3dc0c448
+  metadata.gz: 6aae04a73aa89e5a7919430cecf56a8da1361bbe7b4a40a5676abe1ca02cc011e95681b7520a2d0ec3f47dd793af48c462f9deb1377b2547ba5d5edbc8c864e4
+  data.tar.gz: 541d57da927636744955a5917ad39d57fe793bb37b0c31d167252da9efea8815c3675d2e998ed7ef585921415733e2b393de19f16be433d2ca62cfdbf0d00f02

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/fontist.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "down", "~> 5.0"
   spec.add_runtime_dependency "libmspack", "~> 0.1.0"
   spec.add_runtime_dependency "rubyzip", "~> 2.3.0"
+  spec.add_runtime_dependency "thor", "~> 1.0.1"
 
   spec.add_development_dependency "pry"
   spec.add_development_dependency "bundler", "~> 2.0"

data/lib/fontist.rb

@@ -1,14 +1,23 @@
+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/registry"
 require "fontist/formulas"
-require "fontist/formula_finder"
+require "fontist/formula"
+require "fontist/system_font"
 
 module Fontist
+  def self.ui
+    Fontist::Utils::UI
+  end
+
   def self.lib_path
     Fontist.root_path.join("lib")
   end
@@ -17,14 +26,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 +33,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/errors.rb

@@ -3,6 +3,8 @@ 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
   end
 end

data/lib/fontist/font.rb

@@ -0,0 +1,113 @@
+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,
+"#{name}"          "Fonts are missing, please run " \
+          "Fontist::Font.install('#{name}', confirmation: 'yes') 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
+  end
+end

data/lib/fontist/font_formula.rb

@@ -0,0 +1,123 @@
+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, :options, :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::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