fontist 1.6.0 → 1.8.1

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

@@ -1,35 +1,26 @@
-require_relative "common"
+require_relative "locations"
 
 module Fontist
   module Manifest
-    class Install < Common
+    class Install < Locations
       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?
+        paths = find_font_with_name(font, style)
+        return paths unless paths["paths"].empty?
 
         install_font(font)
-        find_installed_font(font, style)
-      end
 
-      def find_installed_font(font, style)
-        Fontist::SystemFont.find_with_style(font, style)
+        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

@@ -1,12 +1,67 @@
-require_relative "common"
-
 module Fontist
   module Manifest
-    class Locations < Common
+    class Locations
+      def initialize(manifest)
+        @manifest = manifest
+      end
+
+      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
+        font_names.zip(font_paths).to_h
+      end
+
       private
 
+      attr_reader :manifest
+
+      def font_names
+        manifest.keys
+      end
+
+      def font_paths
+        manifest.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)
-        Fontist::SystemFont.find_with_style(font, style)
+        find_font_with_name(font, style).tap do |x|
+          if x["paths"].empty?
+            raise Errors::MissingFontError.new("Could not find font #{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,3 +1,6 @@
+require_relative "system_index"
+require_relative "formula_paths"
+
 module Fontist
   class SystemFont
     def initialize(font:, style: nil, sources: nil)
@@ -10,22 +13,23 @@ module Fontist
       new(font: font, sources: sources).find
     end
 
-    def self.find_with_style(font, style)
-      new(font: font, style: style).find_with_style
+    def self.find_with_name(font, style)
+      new(font: font, style: style).find_with_name
     end
 
     def find
-      paths = grep_font_paths(font)
-      paths = lookup_using_font_name || []  if paths.empty?
+      styles = find_styles
+      return unless styles
 
-      paths.empty? ? nil : paths
+      styles.map { |x| x[:path] }
     end
 
-    def find_with_style
-      paths = lookup_using_font_and_style
-      return paths unless paths.empty?
+    def find_with_name
+      styles = find_styles
+      return { full_name: nil, paths: [] } unless styles
 
-      grep_font_paths(font, style)
+      { full_name: styles.first[:full_name],
+        paths: styles.map { |x| x[:path] } }
     end
 
     private
@@ -42,25 +46,6 @@ module Fontist
       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
       @font_paths ||= Dir.glob((
         user_sources +
@@ -69,11 +54,6 @@ module Fontist
       ).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
@@ -82,31 +62,24 @@ module Fontist
       Fontist::Utils::System.user_os
     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.system_file_path)
     end
 
     def default_sources
-      @default_sources ||= YAML.load(system_path_file)["system"][user_os.to_s]
+      @default_sources ||= YAML.safe_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
+    def find_styles
+      find_by_index || find_by_formulas
     end
 
-    def search_font_paths(filename)
-      font_paths.select do |path|
-        File.basename(path) == filename
-      end
+    def find_by_index
+      SystemIndex.new(font_paths).find(font, style)
+    end
+
+    def find_by_formulas
+      FormulaPaths.new(font_paths).find(font, style)
     end
   end
 end

data/lib/fontist/system_index.rb

@@ -0,0 +1,92 @@
+require "ttfunk"
+
+module Fontist
+  class SystemIndex
+    attr_reader :font_paths
+
+    def initialize(font_paths)
+      @font_paths = font_paths
+    end
+
+    def find(font, style)
+      fonts = system_index.select do |file|
+        file[:family_name].casecmp?(font) &&
+          (style.nil? || file[:type].casecmp?(style))
+      end
+
+      fonts.empty? ? nil : fonts
+    end
+
+    private
+
+    def system_index
+      @system_index ||= build_system_index
+    end
+
+    def build_system_index
+      previous_index = load_system_index
+      updated_index = detect_paths(font_paths, previous_index)
+      updated_index.tap do |index|
+        save_index(index)
+      end
+    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] }
+    end
+
+    def detect_paths(paths, indexed)
+      paths.flat_map do |path|
+        next indexed[path] if indexed[path]
+
+        detect_fonts(path)
+      end
+    end
+
+    def detect_fonts(path)
+      case File.extname(path).gsub(/^\./, "").downcase
+      when "ttf", "otf"
+        detect_file_font(path)
+      when "ttc"
+        detect_collection_fonts(path)
+      else
+        raise Errors::UnknownFontTypeError.new(path)
+      end
+    end
+
+    def detect_file_font(path)
+      file = TTFunk::File.open(path)
+      parse_font(file, path)
+    end
+
+    def detect_collection_fonts(path)
+      TTFunk::Collection.open(path) do |collection|
+        collection.map do |file|
+          parse_font(file, path)
+        end
+      end
+    end
+
+    def parse_font(file, path)
+      x = file.name
+
+      {
+        path: path,
+        full_name: parse_text(x.font_name.first),
+        family_name: parse_text(x.preferred_family.first || x.font_family.first),
+        type: parse_text(x.preferred_subfamily.first || x.font_subfamily.first),
+      }
+    end
+
+    def parse_text(text)
+      text.gsub(/[^[:print:]]/, "").to_s
+    end
+
+    def save_index(index)
+      dir = File.dirname(Fontist.system_index_path)
+      FileUtils.mkdir_p(dir) unless File.exist?(dir)
+      File.write(Fontist.system_index_path, YAML.dump(index))
+    end
+  end
+end

data/lib/fontist/utils.rb

@@ -2,6 +2,7 @@ require "fontist/utils/ui"
 require "fontist/utils/system"
 require "fontist/utils/dsl"
 require "fontist/utils/dsl/font"
+require "fontist/utils/dsl/collection_font"
 require "fontist/utils/downloader"
 require "fontist/utils/zip_extractor"
 require "fontist/utils/exe_extractor"

data/lib/fontist/utils/dsl.rb

@@ -47,6 +47,10 @@ module Fontist
         instance.temp_resource.merge!(filename: name)
       end
 
+      def source_filename(name)
+        instance.temp_resource.merge!(source_filename: name)
+      end
+
       def provides_font(font, options = {})
         font_styles = instance.extract_font_styles(options)
         instance.font_list.push(name: font, styles: font_styles)

data/lib/fontist/utils/dsl/collection_font.rb

@@ -0,0 +1,36 @@
+module Fontist
+  module Utils
+    module Dsl
+      class CollectionFont
+        REQUIRED_ATTRIBUTES = %i[style].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],
+                          collection: attrs[:full_name],
+                          full_name: attrs[:full_name],
+                          post_script_name: attrs[:post_script_name],
+                          version: attrs[:version],
+                          description: attrs[:description],
+                          copyright: attrs[:copyright],
+                          font: attrs[:filename],
+                          source_font: attrs[:source_filename] }
+        end
+      end
+    end
+  end
+end

data/lib/fontist/utils/dsl/font.rb

@@ -29,7 +29,8 @@ module Fontist
                           version: attrs[:version],
                           description: attrs[:description],
                           copyright: attrs[:copyright],
-                          font: attrs[:filename] }
+                          font: attrs[:filename],
+                          source_font: attrs[:source_filename] }
         end
       end
     end

data/lib/fontist/utils/exe_extractor.rb

@@ -6,9 +6,9 @@ module Fontist
 
         exe_file = download_file(exe_file).path if download
 
-        Fontist.ui.say(%(Installing font "#{key}".))
+        Fontist.ui.say(%(Installing font "#{formula.key}".))
         cab_file = decompressor.search(exe_file)
-        cabbed_fonts = grep_fonts(cab_file.files, font_ext) || []
+        cabbed_fonts = grep_fonts(cab_file.files) || []
         fonts_paths = extract_cabbed_fonts_to_assets(cabbed_fonts)
 
         block_given? ? yield(fonts_paths) : fonts_paths
@@ -29,10 +29,10 @@ module Fontist
         )
       end
 
-      def grep_fonts(file, font_ext)
+      def grep_fonts(file)
         Array.new.tap do |fonts|
           while file
-            fonts.push(file) if file.filename.match(font_ext)
+            fonts.push(file) if font_file?(file.filename)
             file = file.next
           end
         end
@@ -41,7 +41,8 @@ module Fontist
       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
+            target_filename = target_filename(font.filename)
+            font_path = fonts_path.join(target_filename).to_s
             decompressor.extract(font, font_path)
 
             fonts.push(font_path)