fontist 0.3.0 → 1.2.1

data/lib/fontist/{data/source.yml → system.yml}

@@ -6,16 +6,15 @@ system:
   windows:
     paths:
       - C:/Windows/Fonts/**/**.{ttc,ttf}
+      - C:/Users/{username}/AppData/Local/Microsoft/Windows/Fonts/**/**.{ttc,ttf}
 
-  macosx:
+  macos:
     paths:
+      - /Library/Fonts/**/**.{ttf,ttc}
       - /System/Library/Fonts/**/**.{ttf,ttc}
+      - /Users/{username}/Library/Fonts/**.{ttf,ttc}
+      - /Applications/Microsoft**/Contents/Resources/**/**.{ttf,ttc}
 
   unix:
     paths:
       - /usr/share/fonts/**/**.{ttf,ttc}
-
-remote:
-  formulas:
-    - ./formulas/ms_vista.yml
-    - ./formulas/source_font.yml

data/lib/fontist/system_font.rb

@@ -3,8 +3,6 @@ module Fontist
     def initialize(font:, sources: nil)
       @font = font
       @user_sources = sources || []
-
-      check_or_create_fontist_path
     end
 
     def self.find(font, sources: [])
@@ -13,6 +11,8 @@ module Fontist
 
     def find
       paths = font_paths.grep(/#{font}/i)
+      paths = lookup_using_font_name || []  if paths.empty?
+
       paths.empty? ? nil : paths
     end
 
@@ -20,28 +20,32 @@ module Fontist
 
     attr_reader :font, :user_sources
 
-    def check_or_create_fontist_path
-      unless fontist_fonts_path.exist?
-        require "fileutils"
-        FileUtils.mkdir_p(fontist_fonts_path)
+    def normalize_default_paths
+      @normalize_default_paths ||= default_sources["paths"].map do |path|
+        require "etc"
+        passwd = Etc.getpwuid
+
+        passwd ? path.gsub("{username}", passwd.name) : path
       end
     end
 
     def font_paths
       Dir.glob((
         user_sources +
-        default_sources["paths"] +
+        normalize_default_paths +
         [fontist_fonts_path.join("**")]
       ).flatten.uniq)
     end
 
+    def lookup_using_font_name
+      font_names = map_name_to_valid_font_names || []
+      font_paths.grep(/#{font_names.join("|")}/i) unless font_names.empty?
+    end
+
     def fontist_fonts_path
       @fontist_fonts_path ||= Fontist.fonts_path
     end
 
-    def default_sources
-      @default_sources ||= Source.all.system[user_os.to_s]
-    end
 
     def user_os
       @user_os ||= (
@@ -50,7 +54,7 @@ module Fontist
         when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
           :windows
         when /darwin|mac os/
-          :macosx
+          :macos
         when /linux/
           :linux
         when /solaris|bsd/
@@ -61,5 +65,17 @@ module Fontist
       )
     end
 
+    def map_name_to_valid_font_names
+      fonts =  Formula.find_fonts(font)
+      fonts.map { |font| font.styles.map(&:font) }.flatten if fonts
+    end
+
+    def system_path_file
+      File.open(Fontist.lib_path.join("fontist", "system.yml"))
+    end
+
+    def default_sources
+      @default_sources ||= YAML.load(system_path_file)["system"][user_os.to_s]
+    end
   end
 end

data/lib/fontist/utils.rb

@@ -0,0 +1,9 @@
+require "fontist/utils/dsl"
+require "fontist/utils/downloader"
+require "fontist/utils/zip_extractor"
+require "fontist/utils/exe_extractor"
+
+module Fontist
+  module Utils
+  end
+end

data/lib/fontist/utils/downloader.rb

@@ -0,0 +1,75 @@
+module Fontist
+  module Utils
+    class Downloader
+      def initialize(file, file_size: nil, sha: nil, progress_bar: nil)
+        # TODO: If the first mirror fails, try the second one
+        @file = file
+        @progress_bar = progress_bar
+        @sha = [sha].flatten.compact
+        @file_size = (file_size || default_file_size).to_i
+      end
+
+      def download
+        file = download_file
+
+        if !sha.empty? && !sha.include?(Digest::SHA256.file(file).to_s)
+          raise(Fontist::Errors::TamperedFileError.new(
+            "The downloaded file from #{@file} doesn't " \
+            "match with the expected sha256 checksum!"
+          ))
+        end
+
+        file
+      end
+
+      def self.download(file, options = {})
+        new(file, options).download
+      end
+
+      private
+
+      attr_reader :file, :sha, :file_size
+
+      def default_file_size
+        5 * byte_to_megabyte
+      end
+
+      def byte_to_megabyte
+        @byte_to_megabyte ||= 1024 * 1024
+      end
+
+      def download_path
+        options[:download_path] || Fontist.root_path.join("tmp")
+      end
+
+      def download_file
+        bar = ProgressBar.new(file_size / byte_to_megabyte)
+
+        Down.download(
+          @file,
+          open_timeout: 10,
+          read_timeout: 10,
+          progress_proc: -> (progress) {
+            bar.increment(progress / byte_to_megabyte) if @progress_bar === true
+          }
+        )
+
+      rescue Down::NotFound
+        raise(Fontist::Errors::InvalidResourceError.new("Invalid URL: #{@file}"))
+      end
+    end
+
+    class ProgressBar
+      def initialize(total)
+        @counter = 1
+        @total  = total
+      end
+
+      def increment(progress)
+        complete = sprintf("%#.2f%%", ((@counter.to_f / @total.to_f) * 100))
+        print "\r\e[0KDownloads: #{@counter}MB/#{@total}MB (#{complete})"
+        @counter = progress
+      end
+    end
+  end
+end

data/lib/fontist/utils/dsl.rb

@@ -0,0 +1,77 @@
+module Fontist
+  module Utils
+    module Dsl
+      def key(key)
+        instance.key = key
+      end
+
+      def desc(description)
+        instance.description = description
+      end
+
+      def homepage(homepage)
+        instance.homepage = homepage
+      end
+
+      def resource(resource_name, &block)
+        instance.resources[resource_name] ||= {}
+        instance.temp_resource = instance.resources[resource_name]
+
+        yield(block) if block_given?
+        instance.temp_resource = {}
+      end
+
+      def url(url)
+        instance.temp_resource.merge!(urls: [url])
+      end
+
+      def urls(urls = [])
+        instance.temp_resource.merge!(urls: urls)
+      end
+
+      def sha256(sha256)
+        instance.temp_resource.merge!(sha256: sha256)
+      end
+
+      def file_size(file_size)
+        instance.temp_resource.merge!(file_size: file_size )
+      end
+
+      def provides_font_collection(name = nil, &block)
+        instance.temp_resource = {}
+        yield(block) if block_given?
+        instance.temp_resource = {}
+      end
+
+      def filename(name)
+        instance.temp_resource.merge!(filename: name)
+      end
+
+      def provides_font(font, options = {})
+        font_styles = instance.extract_font_styles(options)
+        instance.font_list.push(name: font, styles: font_styles)
+      end
+
+      def test
+      end
+
+      def requires_license_agreement(license)
+        instance.license = license
+        instance.license_required = true
+      end
+
+      def open_license(license)
+        instance.license = license
+        instance.license_required = false
+      end
+
+      def license_url(url)
+        instance.license_url = url
+      end
+
+      def display_progress_bar(value )
+        instance.options = (instance.options || {}).merge(progress_bar: value )
+      end
+    end
+  end
+end

data/lib/fontist/utils/exe_extractor.rb

@@ -0,0 +1,72 @@
+module Fontist
+  module Utils
+    module ExeExtractor
+      def cab_extract(exe_file, download: true,  font_ext: /.tt|.ttc/i)
+        download = @downloaded === true ? false : download
+
+        exe_file = download_file(exe_file).path if download
+        cab_file = decompressor.search(exe_file)
+        cabbed_fonts = grep_fonts(cab_file.files, font_ext) || []
+        fonts_paths = extract_cabbed_fonts_to_assets(cabbed_fonts)
+
+        yield(fonts_paths) if block_given?
+      end
+
+      def exe_extract(source)
+        cab_file = decompressor.search(download_file(source).path)
+        yield(build_cab_file_hash(cab_file.files)) if block_given?
+      end
+
+      private
+
+      def decompressor
+        @decompressor ||= (
+          require "libmspack"
+          LibMsPack::CabDecompressor.new
+        )
+      end
+
+      def grep_fonts(file, font_ext)
+        Array.new.tap do |fonts|
+          while file
+            fonts.push(file) if file.filename.match(font_ext)
+            file = file.next
+          end
+        end
+      end
+
+      def extract_cabbed_fonts_to_assets(cabbed_fonts)
+        Array.new.tap do |fonts|
+          cabbed_fonts.each do |font|
+            font_path = fonts_path.join(font.filename).to_s
+            decompressor.extract(font, font_path)
+
+            fonts.push(font_path)
+          end
+        end
+      end
+
+      def build_cab_file_hash(file)
+        Hash.new.tap do |cab_files|
+          while file
+            filename = file.filename
+            if filename.include?("cab")
+              file_path = temp_dir.join(filename).to_s
+
+              decompressor.extract(file, file_path)
+              cab_files[filename.to_s] = file_path
+            end
+
+            file = file.next
+          end
+        end
+      end
+
+      def temp_dir
+        @temp_dir ||= raise(
+          NotImplementedError.new("You must implement this method"),
+        )
+      end
+    end
+  end
+end

data/lib/fontist/utils/zip_extractor.rb

@@ -0,0 +1,38 @@
+require "zip"
+require "pathname"
+
+module Fontist
+  module Utils
+    module ZipExtractor
+      def zip_extract(resource, download: true, fonts_sub_dir: "")
+        zip_file = download_file(resource) if download
+        zip_file ||= resource.urls.first
+
+        fonts_paths = unzip_fonts(zip_file, fonts_sub_dir)
+        block_given? ? yield(fonts_paths) : fonts_paths
+      end
+
+      alias_method :unzip, :zip_extract
+
+      private
+
+      def unzip_fonts(file, fonts_sub_dir = "")
+        Zip.on_exists_proc = true
+        Array.new.tap do |fonts|
+
+          Zip::File.open(file) do |zip_file|
+            zip_file.glob("#{fonts_sub_dir}*.{ttf,ttc,otf}").each do |entry|
+              if entry.name
+                filename = Pathname.new(entry.name).basename
+                font_path = fonts_path.join(filename.to_s)
+                fonts.push(font_path.to_s)
+
+                entry.extract(font_path)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontist/version.rb

@@ -1,3 +1,3 @@
 module Fontist
-  VERSION = "0.3.0".freeze
+  VERSION = "1.2.1".freeze
 end

data/spec/fontist/font_formula_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+RSpec.describe "Fontist::Formulas::DemoFormula" do
+  describe "initialization" do
+    it "registers formula resources through the DSL" do
+      formula = Fontist::Formulas::DemoFormula.instance
+      resource = formula.resources["demo-formula"]
+      demo_font = formula.font_list.first
+
+      expect(formula.key).to eq(:demo_formula)
+      expect(formula.license_required).to be_truthy
+      expect(formula.description).to eq("Demo font formula")
+      expect(formula.license).to eq("Vendor specific font licences")
+      expect(formula.homepage).to eq("https://github.com/fontist/fontist")
+
+      expect(resource[:file_size]).to eq("1234567890")
+      expect(resource[:urls].first).to eq("https://github.com/fontist/fontist")
+      expect(resource[:sha256]).to eq("594e0f42e6581add4dead70c1dfb9")
+
+      expect(demo_font[:styles].count).to eq(2)
+      expect(demo_font[:name]).to eq("Demo font")
+      expect(demo_font[:styles].first[:font]).to eq("demo-font.ttf")
+    end
+  end
+
+  describe "method invokation" do
+    it "invokes the correct method for installation" do
+      expect {
+        Fontist::Formulas::DemoFormula.fetch_font("Demo font", confirmation: "yes")
+      }.not_to raise_error
+    end
+  end
+
+  module Fontist
+    module Formulas
+      class DemoFormula < FontFormula
+        key :demo_formula
+        desc "Demo font formula"
+        homepage "https://github.com/fontist/fontist"
+        requires_license_agreement "Vendor specific font licences"
+
+        resource "demo-formula" do
+          urls [ "https://github.com/fontist/fontist" ]
+          sha256 "594e0f42e6581add4dead70c1dfb9"
+          file_size "1234567890"
+        end
+
+        provides_font "Demo font", match_styles_from_file: {
+          "Regular" => "demo-font.ttf",
+          "Italic" => "demo-fonti.ttf"
+        }
+
+        provides_font_collection("Meiryo Bold") do |coll|
+          filename "demo-font.ttc"
+          provides_font "Demo collection", extract_styles_from_collection: {
+            "Regular" => "demo-col-font.ttf",
+            "Italic" => "demo-col-fonti.ttf"
+          }
+        end
+
+        def extract
+          []
+        end
+      end
+    end
+  end
+end