fontist 1.0.0 → 1.4.0

data/lib/fontist/system_font.rb

@@ -10,7 +10,7 @@ module Fontist
     end
 
     def find
-      paths = font_paths.grep(/#{font}/i)
+      paths = grep_font_paths(font)
       paths = lookup_using_font_name || []  if paths.empty?
 
       paths.empty? ? nil : paths
@@ -20,17 +20,34 @@ module Fontist
 
     attr_reader :font, :user_sources
 
+    def normalize_default_paths
+      @normalize_default_paths ||= default_sources["paths"].map do |path|
+        require "etc"
+        passwd = Etc.getpwuid
+        username = passwd ? passwd.name : Etc.getlogin
+
+        username ? path.gsub("{username}", username) : path
+      end
+    end
+
+    def grep_font_paths(font)
+      paths = font_paths.map { |path| [File.basename(path), path] }.to_h
+      files = paths.keys
+      matched = files.grep(/#{font}/i)
+      paths.values_at(*matched).compact
+    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) if font_names
+      font_names = map_name_to_valid_font_names || []
+      font_paths.grep(/#{font_names.join("|")}/i) unless font_names.empty?
     end
 
     def fontist_fonts_path
@@ -39,21 +56,7 @@ module Fontist
 
 
     def user_os
-      @user_os ||= (
-        host_os = RbConfig::CONFIG["host_os"]
-        case host_os
-        when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
-          :windows
-        when /darwin|mac os/
-          :macosx
-        when /linux/
-          :linux
-        when /solaris|bsd/
-          :unix
-        else
-          raise Fontist::Error, "unknown os: #{host_os.inspect}"
-        end
-      )
+      Fontist::Utils::System.user_os
     end
 
     def map_name_to_valid_font_names
@@ -62,7 +65,7 @@ module Fontist
     end
 
     def system_path_file
-      File.open(Fontist.lib_path.join("fontist", "system.yml"))
+      File.open(Fontist.system_file_path)
     end
 
     def default_sources

data/lib/fontist/utils.rb

@@ -1,6 +1,12 @@
+require "fontist/utils/ui"
+require "fontist/utils/system"
 require "fontist/utils/dsl"
+require "fontist/utils/dsl/font"
+require "fontist/utils/downloader"
 require "fontist/utils/zip_extractor"
 require "fontist/utils/exe_extractor"
+require "fontist/utils/msi_extractor"
+require "fontist/utils/seven_zip_extractor"
 
 module Fontist
   module Utils

data/lib/fontist/utils/cache.rb

@@ -0,0 +1,69 @@
+module Fontist
+  module Utils
+    class Cache
+      def fetch(key)
+        map = load_cache
+        return downloaded_path(map[key]) if cache_exist?(map[key])
+
+        generated_file = yield
+        path = save_cache(generated_file, key, map)
+
+        downloaded_path(path)
+      end
+
+      private
+
+      def cache_map_path
+        Fontist.downloads_path.join("map.yml")
+      end
+
+      def load_cache
+        cache_map_path.exist? ? YAML.load_file(cache_map_path) : {}
+      end
+
+      def downloaded_path(path)
+        File.new(Fontist.downloads_path.join(path))
+      end
+
+      def cache_exist?(path)
+        path && File.exist?(Fontist.downloads_path.join(path))
+      end
+
+      def save_cache(generated_file, key, map)
+        path = move_to_downloads(generated_file)
+        map[key] = path
+        File.write(cache_map_path, YAML.dump(map))
+        path
+      end
+
+      def move_to_downloads(source)
+        create_downloads_directory
+        path = generate_file_path(source)
+        move(source, path)
+        relative_to_downloads(path)
+      end
+
+      def create_downloads_directory
+        unless Fontist.downloads_path.exist?
+          FileUtils.mkdir_p(Fontist.downloads_path)
+        end
+      end
+
+      def generate_file_path(source)
+        dir = Dir.mktmpdir(nil, Fontist.downloads_path)
+        filename = source.original_filename
+        File.join(dir, filename)
+      end
+
+      def move(source_file, target_path)
+        # Windows requires file descriptors to be closed before files are moved
+        source_file.close
+        FileUtils.mv(source_file.path, target_path)
+      end
+
+      def relative_to_downloads(path)
+        Pathname.new(path).relative_path_from(Fontist.downloads_path).to_s
+      end
+    end
+  end
+end

data/lib/fontist/utils/downloader.rb

@@ -0,0 +1,92 @@
+require_relative "cache"
+
+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
+        @sha = [sha].flatten.compact
+        @progress_bar = set_progress_bar(progress_bar)
+        @file_size = (file_size || default_file_size).to_i
+        @cache = Cache.new
+      end
+
+      def download
+        file = @cache.fetch(@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 set_progress_bar(progress_bar)
+        ENV.fetch("TEST_ENV", "") === "CI" ? false : progress_bar
+      end
+
+      def download_file
+        bar = ProgressBar.new(file_size / byte_to_megabyte)
+
+        file = Down.download(
+          @file,
+          open_timeout: 10,
+          read_timeout: 10,
+          content_length_proc: ->(content_length) {
+            bar.total = content_length / byte_to_megabyte if content_length
+          },
+          progress_proc: -> (progress) {
+            bar.increment(progress / byte_to_megabyte) if @progress_bar === true
+          }
+        )
+
+        puts if @progress_bar === true
+
+        file
+      rescue Down::NotFound
+        raise(Fontist::Errors::InvalidResourceError.new("Invalid URL: #{@file}"))
+      end
+    end
+
+    class ProgressBar
+      def initialize(total)
+        @counter = 1
+        @total  = total
+      end
+
+      def total=(total)
+        @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

@@ -65,9 +65,17 @@ module Fontist
         instance.license_required = false
       end
 
+      def copyright(copyright)
+        instance.copyright = copyright
+      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/dsl/font.rb

@@ -0,0 +1,37 @@
+module Fontist
+  module Utils
+    module Dsl
+      class Font
+        REQUIRED_ATTRIBUTES = %i[family_name
+                                 style
+                                 full_name
+                                 filename].freeze
+
+        attr_reader :attributes
+
+        def initialize(attributes)
+          REQUIRED_ATTRIBUTES.each do |required_attribute|
+            unless attributes[required_attribute]
+              raise(Fontist::Errors::MissingAttributeError.new(
+                      "Missing attribute: #{required_attribute}"
+                    ))
+            end
+          end
+
+          self.attributes = attributes
+        end
+
+        def attributes=(attrs)
+          @attributes = { family_name: attrs[:family_name],
+                          type: attrs[:style],
+                          full_name: attrs[:full_name],
+                          post_script_name: attrs[:post_script_name],
+                          version: attrs[:version],
+                          description: attrs[:description],
+                          copyright: attrs[:copyright],
+                          font: attrs[:filename] }
+        end
+      end
+    end
+  end
+end

data/lib/fontist/utils/exe_extractor.rb

@@ -1,7 +1,7 @@
 module Fontist
   module Utils
     module ExeExtractor
-      def cab_extract(exe_file, download: true,  font_ext: /.tt|.ttc/i)
+      def cab_extract(exe_file, download: true, font_ext: /.ttf|.otf|.ttc/i)
         download = @downloaded === true ? false : download
 
         exe_file = download_file(exe_file).path if download
@@ -9,12 +9,13 @@ module Fontist
         cabbed_fonts = grep_fonts(cab_file.files, font_ext) || []
         fonts_paths = extract_cabbed_fonts_to_assets(cabbed_fonts)
 
-        yield(fonts_paths) if block_given?
+        block_given? ? yield(fonts_paths) : fonts_paths
       end
 
       def exe_extract(source)
         cab_file = decompressor.search(download_file(source).path)
-        yield(build_cab_file_hash(cab_file.files)) if block_given?
+        fonts_paths = build_cab_file_hash(cab_file.files)
+        block_given? ? yield(fonts_paths) : fonts_paths
       end
 
       private
@@ -47,25 +48,17 @@ module Fontist
       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
+        while file
+          filename = file.filename
+          if filename.include?("cab") || filename.include?("msi")
+            file_path = File.join(Dir.mktmpdir, filename)
+            decompressor.extract(file, file_path)
 
-            file = file.next
+            return file_path
           end
-        end
-      end
 
-      def temp_dir
-        @temp_dir ||= raise(
-          NotImplementedError.new("You must implement this method"),
-        )
+          file = file.next
+        end
       end
     end
   end

data/lib/fontist/utils/msi_extractor.rb

@@ -0,0 +1,31 @@
+module Fontist
+  module Utils
+    module MsiExtractor
+      def msi_extract(resource)
+        file = @downloaded ? resource : download_file(resource)
+
+        cab_content = read_the_largest_file(file)
+
+        cab_file = Tempfile.new(["data", ".cab"], mode: File::BINARY)
+        cab_file.write(cab_content)
+
+        block_given? ? yield(cab_file.path) : cab_file.path
+      end
+
+      private
+
+      def read_the_largest_file(file)
+        ole = storage.open(file)
+        the_largest_file = ole.dir.entries(".").max_by { |x| ole.file.size(x) }
+        ole.file.read(the_largest_file)
+      end
+
+      def storage
+        @storage ||= begin
+                       require "ole/storage"
+                       Ole::Storage
+                     end
+      end
+    end
+  end
+end

data/lib/fontist/utils/seven_zip_extractor.rb

@@ -0,0 +1,41 @@
+module Fontist
+  module Utils
+    module SevenZipExtractor
+      def seven_zip_extract(resource, extension: /\.cab$/)
+        file = download_file(resource)
+
+        extract_seven_zip_file(file, extension)
+      end
+
+      private
+
+      def extract_seven_zip_file(file, extension)
+        File.open(file, "rb") do |zip_file|
+          reader.open(zip_file) do |szr|
+            path = extract_by_extension(szr, extension)
+
+            return block_given? ? yield(path) : path
+          end
+        end
+      end
+
+      def reader
+        @reader ||= begin
+                      require "seven_zip_ruby"
+                      SevenZipRuby::Reader
+                    end
+      end
+
+      def extract_by_extension(szr, extension)
+        cab_entry = szr.entries.detect do |entry|
+          entry.file? && entry.path.match(extension)
+        end
+
+        tmp_dir = Dir.mktmpdir
+        szr.extract(cab_entry, tmp_dir)
+        filename = Pathname.new(cab_entry.path).basename
+        File.join(tmp_dir, filename)
+      end
+    end
+  end
+end

data/lib/fontist/utils/system.rb

@@ -0,0 +1,23 @@
+module Fontist
+  module Utils
+    module System
+      def self.user_os # rubocop:disable Metrics/MethodLength
+        @user_os ||= begin
+          host_os = RbConfig::CONFIG["host_os"]
+          case host_os
+          when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+            :windows
+          when /darwin|mac os/
+            :macos
+          when /linux/
+            :linux
+          when /solaris|bsd/
+            :unix
+          else
+            raise Fontist::Error, "unknown os: #{host_os.inspect}"
+          end
+        end
+      end
+    end
+  end
+end