fontist 1.7.2 → 1.8.4

data/lib/fontist/index.rb

@@ -0,0 +1,72 @@
+require_relative "index_formula"
+
+module Fontist
+  class Index
+    def self.from_yaml
+      unless File.exist?(Fontist.formula_index_path)
+        raise Errors::FormulaIndexNotFoundError.new("Please fetch index with `fontist update`.")
+      end
+
+      data = YAML.load_file(Fontist.formula_index_path)
+      new(data)
+    end
+
+    def self.rebuild
+      index = new
+      index.build
+      index.to_yaml
+    end
+
+    def initialize(data = {})
+      @index = {}
+
+      data.each_pair do |font, paths|
+        paths.each do |path|
+          add_index_formula(font, IndexFormula.new(path))
+        end
+      end
+    end
+
+    def build
+      Formula.all.each do |formula|
+        add_formula(formula)
+      end
+    end
+
+    def add_formula(formula)
+      formula.fonts.each do |font|
+        add_index_formula(font.name, formula.to_index_formula)
+      end
+    end
+
+    def add_index_formula(font_raw, index_formula)
+      font = normalize_font(font_raw)
+      @index[font] ||= []
+      @index[font] << index_formula unless @index[font].include?(index_formula)
+    end
+
+    def load_formulas(font)
+      index_formulas(font).map(&:to_full)
+    end
+
+    def to_yaml
+      File.write(Fontist.formula_index_path, YAML.dump(to_h))
+    end
+
+    def to_h
+      @index.map do |font, index_formulas|
+        [font, index_formulas.map(&:to_s)]
+      end.to_h
+    end
+
+    private
+
+    def index_formulas(font)
+      @index[normalize_font(font)] || []
+    end
+
+    def normalize_font(font)
+      font.downcase
+    end
+  end
+end

data/lib/fontist/index_formula.rb

@@ -0,0 +1,30 @@
+module Fontist
+  class IndexFormula
+    def initialize(path)
+      @path = path
+    end
+
+    def to_s
+      normalized
+    end
+
+    def to_full
+      Formula.new_from_file(full_path)
+    end
+
+    def ==(other)
+      to_s == other.to_s
+    end
+
+    private
+
+    def normalized
+      escaped = Regexp.escape(Fontist.formulas_path.to_s + "/")
+      @path.sub(Regexp.new("^" + escaped), "")
+    end
+
+    def full_path
+      Fontist.formulas_path.join(normalized).to_s
+    end
+  end
+end

data/lib/fontist/manifest/install.rb

@@ -8,24 +8,19 @@ module Fontist
         @confirmation = confirmation
       end
 
-      def self.call(manifest, confirmation: "no")
-        new(manifest, confirmation: confirmation).call
-      end
-
       private
 
       def file_paths(font, style)
-        paths = super
+        paths = find_font_with_name(font, style)
         return paths unless paths["paths"].empty?
 
         install_font(font)
-        super
+
+        find_font_with_name(font, style)
       end
 
       def install_font(font)
-        Fontist::Font.try_install(font, confirmation: @confirmation)
-      rescue Fontist::Errors::LicensingError
-        [] # try to install other fonts
+        Fontist::Font.install(font, force: true, confirmation: @confirmation)
       end
     end
   end

data/lib/fontist/manifest/locations.rb

@@ -5,8 +5,21 @@ module Fontist
         @manifest = manifest
       end
 
-      def self.call(manifest)
-        new(manifest).call
+      def self.from_file(file, **keywords)
+        raise Fontist::Errors::ManifestCouldNotBeFoundError unless File.exist?(file)
+
+        manifest = YAML.load_file(file)
+        raise Fontist::Errors::ManifestCouldNotBeReadError unless manifest.is_a?(Hash)
+
+        from_hash(manifest, **keywords)
+      end
+
+      def self.from_hash(manifest, **keywords)
+        if keywords.empty?
+          new(manifest).call
+        else
+          new(manifest, **keywords).call
+        end
       end
 
       def call
@@ -15,27 +28,14 @@ module Fontist
 
       private
 
-      def font_names
-        fonts.keys
-      end
-
-      def fonts
-        @fonts ||= begin
-          unless File.exist?(@manifest)
-            raise Fontist::Errors::ManifestCouldNotBeFoundError
-          end
+      attr_reader :manifest
 
-          fonts = YAML.load_file(@manifest)
-          unless fonts.is_a?(Hash)
-            raise Fontist::Errors::ManifestCouldNotBeReadError
-          end
-
-          fonts
-        end
+      def font_names
+        manifest.keys
       end
 
       def font_paths
-        fonts.map do |font, styles|
+        manifest.map do |font, styles|
           styles_to_ary = [styles].flatten
           style_paths_map(font, styles_to_ary)
         end
@@ -53,7 +53,15 @@ module Fontist
       end
 
       def file_paths(font, style)
-        Fontist::SystemFont.find_with_name(font, style).transform_keys(&:to_s)
+        find_font_with_name(font, style).tap do |x|
+          if x["paths"].empty?
+            raise Errors::MissingFontError.new(font, style)
+          end
+        end
+      end
+
+      def find_font_with_name(font, style)
+        Fontist::SystemFont.find_with_name(font, style).map { |k, v| [k.to_s, v] }.to_h
       end
     end
   end

data/lib/fontist/system_font.rb

@@ -1,4 +1,5 @@
 require_relative "system_index"
+require_relative "formula_paths"
 
 module Fontist
   class SystemFont
@@ -8,6 +9,33 @@ module Fontist
       @user_sources = sources || []
     end
 
+    def self.font_paths
+      system_font_paths + fontist_font_paths
+    end
+
+    def self.system_font_paths
+      config_path = Fontist.system_file_path
+      os = Fontist::Utils::System.user_os.to_s
+      templates = YAML.load_file(config_path)["system"][os]["paths"]
+      patterns = expand_paths(templates)
+
+      Dir.glob(patterns)
+    end
+
+    def self.expand_paths(paths)
+      paths.map do |path|
+        require "etc"
+        passwd = Etc.getpwuid
+        username = passwd ? passwd.name : Etc.getlogin
+
+        username ? path.gsub("{username}", username) : path
+      end
+    end
+
+    def self.fontist_font_paths
+      Dir.glob(Fontist.fonts_path.join("**"))
+    end
+
     def self.find(font, sources: [])
       new(font: font, sources: sources).find
     end
@@ -35,78 +63,20 @@ module Fontist
 
     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 font_paths
-      @font_paths ||= Dir.glob((
-        user_sources +
-        normalize_default_paths +
-        [fontist_fonts_path.join("**")]
-      ).flatten.uniq)
-    end
-
-    def fontist_fonts_path
-      @fontist_fonts_path ||= Fontist.fonts_path
-    end
-
-    def user_os
-      Fontist::Utils::System.user_os
-    end
-
-    def system_path_file
-      File.open(Fontist.system_file_path)
-    end
-
-    def default_sources
-      @default_sources ||= YAML.safe_load(system_path_file)["system"][user_os.to_s]
-    end
-
     def find_styles
       find_by_index || find_by_formulas
     end
 
     def find_by_index
-      SystemIndex.new(font_paths).find(font, style)
+      SystemIndex.new(all_paths).find(font, style)
     end
 
     def find_by_formulas
-      styles = find_styles_by_formulas(font, style)
-      return if styles.empty?
-
-      fonts = styles.uniq { |s| s["font"] }.flat_map do |s|
-        paths = search_font_paths(s["font"])
-        paths.map do |path|
-          { full_name: s["full_name"],
-            path: path }
-        end
-      end
-
-      fonts.empty? ? nil : fonts
+      FormulaPaths.new(all_paths).find(font, style)
     end
 
-    def find_styles_by_formulas(font, style)
-      if style
-        Formula.find_styles(font, style)
-      else
-        fonts = Formula.find_fonts(font)
-        return [] unless fonts
-
-        fonts.flat_map(&:styles)
-      end
-    end
-
-    def search_font_paths(filename)
-      font_paths.select do |path|
-        File.basename(path) == filename
-      end
+    def all_paths
+      @all_paths ||= Dir.glob(user_sources) + self.class.font_paths
     end
   end
 end

data/lib/fontist/system_index.rb

@@ -2,8 +2,18 @@ require "ttfunk"
 
 module Fontist
   class SystemIndex
+    include Utils::Locking
+
     attr_reader :font_paths
 
+    def self.find(font, style)
+      new(SystemFont.font_paths).find(font, style)
+    end
+
+    def self.rebuild
+      new(SystemFont.font_paths).rebuild
+    end
+
     def initialize(font_paths)
       @font_paths = font_paths
     end
@@ -17,6 +27,10 @@ module Fontist
       fonts.empty? ? nil : fonts
     end
 
+    def rebuild
+      build_system_index
+    end
+
     private
 
     def system_index
@@ -24,28 +38,56 @@ module Fontist
     end
 
     def build_system_index
+      lock(lock_path) do
+        do_build_system_index
+      end
+    end
+
+    def lock_path
+      Fontist.system_index_path.to_s + ".lock"
+    end
+
+    def do_build_system_index
       previous_index = load_system_index
       updated_index = detect_paths(font_paths, previous_index)
       updated_index.tap do |index|
-        save_index(index)
+        save_index(index) if changed?(updated_index, previous_index)
       end
     end
 
+    def changed?(this, other)
+      this.map { |x| x[:path] }.uniq.sort != other.map { |x| x[:path] }.uniq.sort
+    end
+
     def load_system_index
       index = File.exist?(Fontist.system_index_path) ? YAML.load_file(Fontist.system_index_path) : []
-      index.group_by { |x| x[:path] }
+
+      index.each do |item|
+        missing_keys = %i[path full_name family_name type] - item.keys
+        unless missing_keys.empty?
+          raise(Errors::FontIndexCorrupted, <<~MSG.chomp)
+            Font index is corrupted.
+            Item #{item.inspect} misses required attributes: #{missing_keys.join(', ')}.
+            You can remove the index file (#{Fontist.system_index_path}) and try again.
+          MSG
+        end
+      end
+
+      index
     end
 
-    def detect_paths(paths, indexed)
+    def detect_paths(paths, index)
+      by_path = index.group_by { |x| x[:path] }
+
       paths.flat_map do |path|
-        next indexed[path] if indexed[path]
+        next by_path[path] if by_path[path]
 
         detect_fonts(path)
       end
     end
 
     def detect_fonts(path)
-      case File.extname(path).delete_prefix(".").downcase
+      case File.extname(path).gsub(/^\./, "").downcase
       when "ttf", "otf"
         detect_file_font(path)
       when "ttc"

data/lib/fontist/utils.rb

@@ -1,4 +1,5 @@
 require "fontist/utils/ui"
+require "fontist/utils/locking"
 require "fontist/utils/system"
 require "fontist/utils/dsl"
 require "fontist/utils/dsl/font"
@@ -8,6 +9,10 @@ require "fontist/utils/zip_extractor"
 require "fontist/utils/exe_extractor"
 require "fontist/utils/msi_extractor"
 require "fontist/utils/seven_zip_extractor"
+require "fontist/utils/rpm_extractor"
+require "fontist/utils/gzip_extractor"
+require "fontist/utils/cpio_extractor"
+require "fontist/utils/tar_extractor"
 
 module Fontist
   module Utils

data/lib/fontist/utils/cache.rb

@@ -1,6 +1,8 @@
 module Fontist
   module Utils
     class Cache
+      include Locking
+
       def fetch(key, bar: nil)
         map = load_cache
         if cache_exist?(map[key])
@@ -26,7 +28,7 @@ module Fontist
       end
 
       def downloaded_file(path)
-        File.new(downloaded_path(path))
+        File.new(downloaded_path(path), "rb")
       end
 
       def cache_exist?(path)
@@ -48,13 +50,19 @@ module Fontist
       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))
+        lock(lock_path) do
+          map = load_cache
+          map[key] = path
+          File.write(cache_map_path, YAML.dump(map))
+        end
 
         path
       end
 
+      def lock_path
+        cache_map_path.to_s + ".lock"
+      end
+
       def move_to_downloads(source)
         create_downloads_directory
         path = generate_file_path(source)