fontist 0.1.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6f803c9ce9bd7012252efe69be7ffe684c57c3213d5c995d87e311024b5adc2
-  data.tar.gz: c15139f58b45512e4a07cd3f62a6b51cee37e46f79d0418ee17a027d4851ff34
+  metadata.gz: ec6fb2284e060c8f43ac62c16a9777d25d20886ef2ff687eecdfb963980bb350
+  data.tar.gz: ddcba3ee0f0a7c75f23532d7809c7c40492583ba032b4ebbc204d0730f6af9a4
 SHA512:
-  metadata.gz: 98a1812e2f840eae8f74bce309af758da25e751532ee1184054437bc5f91a3cedf58f5268c522a3eef149364b130250b9c4881ee405ba3666a5cc4f399f1a7fe
-  data.tar.gz: 0357ecd0887b2f7d112ac5082724edff9ada86fafa2f013c8fff00dcd23516b9fc5212c193a4a59280e01c384e904da6400c83780c8c29797177c40c13ea269a
+  metadata.gz: 7bfc0b3cb5597ceca0474c95d47a26e993ccf91773b4a17b10f08c84ac2ec4dfed40d3a271b309c6b2f7c77cd14dca5978b88a274c7aba3ba3ee95b25afcea30
+  data.tar.gz: af007b2fda60f2f53bf2be5c107bf27ec423b9759f62c6827bdecc50ed62bf56a4f4f0969ec9d74f91631f92cad75c0564182424ef2b5754ead6c9335ae87ac1

data/.github/workflows/macosx.yml

@@ -0,0 +1,30 @@
+name: macos
+
+on:
+  push:
+    branches:
+      - master
+
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: macos-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: actions/setup-ruby@v1
+        with:
+          ruby-version: 2.6
+
+      - name: Install bundler
+        run: gem install bundler
+
+      - name: Setup
+        run: bin/setup
+
+      - name: Run tests
+        run: TEST_ENV=CI bin/rspec

data/.github/workflows/ubuntu.yml

@@ -18,7 +18,7 @@ jobs:
 
       - uses: actions/setup-ruby@v1
         with:
-          ruby-version: 2.6.5
+          ruby-version: 2.6
 
       - name: Install bundler
         run: gem install bundler
@@ -27,4 +27,4 @@ jobs:
         run: bin/setup
 
       - name: Run tests
-        run: bin/rspec
+        run: TEST_ENV=CI bin/rspec

data/.github/workflows/windows.yml

@@ -0,0 +1,32 @@
+name: windows
+
+on:
+  push:
+    branches:
+      - master
+
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: actions/setup-ruby@v1
+        with:
+          ruby-version: 2.6
+          architecture: "x64"
+
+      - name: Setup
+        shell: pwsh
+        run: |
+          gem install bundler
+          bundle config --local path vendor/bundle
+          bundle install --jobs 4 --retry 3
+
+      - name: Run tests
+        run: bundle exec rspec --tag ~skip_in_windows

data/.gitignore

@@ -8,5 +8,9 @@
 /tmp/
 Gemfile.lock
 
+# fonts
+/spec/fixtures/fonts/*
+/spec/fixtures/fonts/DejaVuSerif.ttf
+
 # rspec failure tracking
 .rspec_status

data/README.md

@@ -1,5 +1,7 @@
 # Fontist
 
+![windows](https://github.com/fontist/fontist/workflows/windows/badge.svg)
+![macos](https://github.com/fontist/fontist/workflows/macos/badge.svg)
 ![ubuntu](https://github.com/fontist/fontist/workflows/ubuntu/badge.svg)
 
 A simple library to find and download fonts for Windows, Linux and Mac.
@@ -26,7 +28,101 @@ gem install fontist
 
 ## Usage
 
-TODO: Coming soon
+### Font
+
+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::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
 

data/bin/console

@@ -7,8 +7,5 @@ require "fontist"
 # with your gem easier. You can also use a different console, if you like.
 
 # (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start(__FILE__)
+require "pry"
+Pry.start

data/fontist.gemspec

@@ -21,6 +21,11 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files`.split("\n")
   spec.test_files    = `git ls-files -- {spec}/*`.split("\n")
 
+  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"
   spec.add_development_dependency "rake", "~> 12.3.3"
   spec.add_development_dependency "rspec", "~> 3.0"

data/lib/fontist.rb

@@ -1,6 +1,48 @@
+require "down"
+require "digest"
+require "json"
+require "yaml"
+require "singleton"
+
+require "fontist/errors"
 require "fontist/version"
 
+require "fontist/font"
+require "fontist/registry"
+require "fontist/formulas"
+require "fontist/formula"
+require "fontist/system_font"
+
 module Fontist
-  class Error < StandardError; end
-  # Your code goes here...
+  def self.lib_path
+    Fontist.root_path.join("lib")
+  end
+
+  def self.root_path
+    Pathname.new(File.dirname(__dir__))
+  end
+
+  def self.fontist_path
+    Pathname.new(Dir.home).join(".fontist")
+  end
+
+  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

@@ -0,0 +1,9 @@
+module Fontist
+  module Errors
+    class LicensingError < StandardError; end
+    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,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