fontist 1.2.0 → 1.5.1

data/lib/fontist/manifest.rb

@@ -0,0 +1,2 @@
+require_relative "manifest/locations"
+require_relative "manifest/install"

data/lib/fontist/manifest/common.rb

@@ -0,0 +1,60 @@
+module Fontist
+  module Manifest
+    class Common
+      def initialize(manifest)
+        @manifest = manifest
+      end
+
+      def self.call(manifest)
+        new(manifest).call
+      end
+
+      def call
+        font_names.zip(font_paths).to_h
+      end
+
+      private
+
+      def font_names
+        fonts.keys
+      end
+
+      def fonts
+        @fonts ||= begin
+          unless File.exist?(@manifest)
+            raise Fontist::Errors::ManifestCouldNotBeFoundError
+          end
+
+          fonts = YAML.load_file(@manifest)
+          unless fonts.is_a?(Hash)
+            raise Fontist::Errors::ManifestCouldNotBeReadError
+          end
+
+          fonts
+        end
+      end
+
+      def font_paths
+        fonts.map do |font, styles|
+          styles_to_ary = [styles].flatten
+          style_paths_map(font, styles_to_ary)
+        end
+      end
+
+      def style_paths_map(font, names)
+        paths = style_paths(font, names)
+        names.zip(paths).to_h
+      end
+
+      def style_paths(font, names)
+        names.map do |style|
+          file_paths(font, style)
+        end
+      end
+
+      def file_paths(_font, _style)
+        raise NotImplementedError.new("Implement #file_paths in child class")
+      end
+    end
+  end
+end

data/lib/fontist/manifest/install.rb

@@ -0,0 +1,36 @@
+require_relative "common"
+
+module Fontist
+  module Manifest
+    class Install < Common
+      def initialize(manifest, confirmation: "no")
+        @manifest = manifest
+        @confirmation = confirmation
+      end
+
+      def self.call(manifest, confirmation: "no")
+        new(manifest, confirmation: confirmation).call
+      end
+
+      private
+
+      def file_paths(font, style)
+        paths = find_installed_font(font, style)
+        return paths unless paths.empty?
+
+        install_font(font)
+        find_installed_font(font, style)
+      end
+
+      def find_installed_font(font, style)
+        Fontist::SystemFont.find_with_style(font, style)
+      end
+
+      def install_font(font)
+        Fontist::Font.try_install(font, confirmation: @confirmation)
+      rescue Fontist::Errors::LicensingError
+        [] # try to install other fonts
+      end
+    end
+  end
+end

data/lib/fontist/manifest/locations.rb

@@ -0,0 +1,13 @@
+require_relative "common"
+
+module Fontist
+  module Manifest
+    class Locations < Common
+      private
+
+      def file_paths(font, style)
+        Fontist::SystemFont.find_with_style(font, style)
+      end
+    end
+  end
+end

data/lib/fontist/registry.rb

@@ -32,6 +32,7 @@ module Fontist
         license: formula.instance.license,
         homepage: formula.instance.homepage ,
         description: formula.instance.description,
+        license_required: formula.instance.license_required,
       }
     end
 

data/lib/fontist/system.yml

@@ -6,10 +6,13 @@ 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:

data/lib/fontist/system_font.rb

@@ -1,7 +1,8 @@
 module Fontist
   class SystemFont
-    def initialize(font:, sources: nil)
+    def initialize(font:, style: nil, sources: nil)
       @font = font
+      @style = style
       @user_sources = sources || []
     end
 
@@ -9,21 +10,61 @@ module Fontist
       new(font: font, sources: sources).find
     end
 
+    def self.find_with_style(font, style)
+      new(font: font, style: style).find_with_style
+    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
     end
 
+    def find_with_style
+      paths = lookup_using_font_and_style
+      return paths unless paths.empty?
+
+      grep_font_paths(font, style)
+    end
+
     private
 
-    attr_reader :font, :user_sources
+    attr_reader :font, :style, :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, style = nil)
+      pattern = prepare_pattern(font, style)
+
+      paths = font_paths.map { |path| [File.basename(path), path] }.to_h
+      files = paths.keys
+      matched = files.grep(pattern)
+      paths.values_at(*matched).compact
+    end
+
+    def prepare_pattern(font, style = nil)
+      style = nil if style&.casecmp?("regular")
+
+      s = [font, style].compact.map { |x| Regexp.quote(x) }
+        .join(".*")
+        .gsub("\\ ", "\s?") # space independent
+
+      Regexp.new(s, Regexp::IGNORECASE)
+    end
 
     def font_paths
-      Dir.glob((
+      @font_paths ||= Dir.glob((
         user_sources +
-        default_sources["paths"] +
+        normalize_default_paths +
         [fontist_fonts_path.join("**")]
       ).flatten.uniq)
     end
@@ -37,23 +78,8 @@ module Fontist
       @fontist_fonts_path ||= Fontist.fonts_path
     end
 
-
     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,11 +88,25 @@ 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
       @default_sources ||= YAML.load(system_path_file)["system"][user_os.to_s]
     end
+
+    def lookup_using_font_and_style
+      styles = Formula.find_styles(font, style)
+      filenames = styles.map(&:font)
+      filenames.flat_map do |filename|
+        search_font_paths(filename)
+      end
+    end
+
+    def search_font_paths(filename)
+      font_paths.select do |path|
+        File.basename(path) == filename
+      end
+    end
   end
 end

data/lib/fontist/utils.rb

@@ -1,7 +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,72 @@
+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)
+
+        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)
+        path = move_to_downloads(generated_file)
+
+        map = load_cache
+        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

@@ -1,18 +1,22 @@
+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
-        @progress_bar = progress_bar
         @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 = download_file
+        file = @cache.fetch(@file) { download_file }
 
         if !sha.empty? && !sha.include?(Digest::SHA256.file(file).to_s)
-          raise(Fontist::Errors::TemparedFileError.new(
+          raise(Fontist::Errors::TamperedFileError.new(
             "The downloaded file from #{@file} doesn't " \
             "match with the expected sha256 checksum!"
           ))
@@ -41,18 +45,28 @@ module Fontist
         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)
 
-        Down.download(
+        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
@@ -64,6 +78,10 @@ module Fontist
         @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})"

data/lib/fontist/utils/dsl.rb

@@ -65,6 +65,10 @@ module Fontist
         instance.license_required = false
       end
 
+      def copyright(copyright)
+        instance.copyright = copyright
+      end
+
       def license_url(url)
         instance.license_url = url
       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