fontist 0.2.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e446487ef01cae5da6b38d363e22e6a4210880f88a4741762a234598db88940
-  data.tar.gz: 8d622e34e2a80ae41018238d99b7be5781dbd785d8505d8a69e63aa48a70706f
+  metadata.gz: 0eabd37a359d5d16263d7aacc3e3c4ed215619eb257d20bbe9c1505786a4ba70
+  data.tar.gz: 491a3dbdf9b4d2a2b1d74b3f07bb11d65e238bcf87f316d1d48b9707739d8202
 SHA512:
-  metadata.gz: 106f4f4c64991ad9301eb2315e4b98bab19973d393a3daed060ca0d2014c4d8236ebb7de4cf6dceee7e9e4fed849111238d3d2231c83e5c3aeb6f8c3a385a4eb
-  data.tar.gz: 5fb219fb32f6d8616924abaabe4451fba80e0be2f2986ac0b7aa574511884dec670a33635c3edad1eec817f6126f0017b995a7aa876f8711a87be8570efc6c48
+  metadata.gz: a9921980bec05a202f13786302e859f2f7660492ff8db9339c02a7088989d6bb0478139cf1846c05e9967272914c3a87822e827a658c5046ca1611f7ed0588b0
+  data.tar.gz: 2ac883da0ac5488ae0d58fa81da7473e40dfeb610a91bdc1286059c1edad816f99e892ec19a5e4ee57df835af8a27ba511c6359062cf8dba15b9d0fb07ba1619

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,9 +7,10 @@
 /spec/reports/
 /tmp/
 Gemfile.lock
-/assets/*
-!/assets/source.yml
-!/assets/fonts/.keep
+
+# fonts
+/spec/fixtures/fonts/*
+/spec/fixtures/fonts/DejaVuSerif.ttf
 
 # rspec failure tracking
 .rspec_status

data/README.md

@@ -28,16 +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::Font.find(name)
+```
+
+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
-Fontist::Finder.find("CALIBRI.TTF")
+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

@@ -23,6 +23,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_development_dependency "pry"
   spec.add_development_dependency "bundler", "~> 2.0"

data/lib/fontist.rb

@@ -1,11 +1,17 @@
+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/font"
+require "fontist/registry"
+require "fontist/formulas"
+require "fontist/formula"
 require "fontist/system_font"
-require "fontist/ms_vista_font"
 
 module Fontist
   def self.lib_path
@@ -16,10 +22,6 @@ module Fontist
     Pathname.new(File.dirname(__dir__))
   end
 
-  def self.assets_path
-    Fontist.root_path.join("assets")
-  end
-
   def self.fontist_path
     Pathname.new(Dir.home).join(".fontist")
   end
@@ -27,4 +29,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,5 +3,8 @@ module Fontist
     class LicensingError < StandardError; end
     class MissingFontError < StandardError; end
     class NonSupportedFontError < StandardError; end
+    class TemparedFileError < StandardError; end
+    class InvalidResourceError < StandardError; end
+    class TimeoutError < 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,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].sample,
+        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/formula.rb

@@ -0,0 +1,90 @@
+module Fontist
+  class Formula
+    def initialize(options = {})
+      @font_name = options.fetch(:font_name, nil)
+
+      check_and_register_font_formulas
+    end
+
+    def self.all
+      new.all
+    end
+
+    def self.find(font_name)
+      new(font_name: font_name).find
+    end
+
+    def self.find_fonts(name)
+      new(font_name: name).find_fonts
+    end
+
+    def all
+      @all ||= Fontist::Registry.instance.formulas
+    end
+
+    def find
+      [find_formula].flatten.first
+    end
+
+    def find_fonts
+      formulas = [find_formula].flatten
+      match_fonts_by_name(formulas) unless formulas.empty?
+    end
+
+    private
+
+    attr_reader :font_name
+
+    def find_formula
+      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
+      end
+
+      matched_fonts.empty? ? nil : matched_fonts.flatten
+    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
+  end
+end