fontist 1.4.0 → 1.7.1

data/lib/fontist/import/google/skiplist.yml

@@ -4,3 +4,5 @@
 - Overpass Mono
 - Lato
 - Open Sans
+- Work Sans
+- Fira Code

data/lib/fontist/import/helpers/system_helper.rb

@@ -4,7 +4,10 @@ module Fontist
       module SystemHelper
         class << self
           def run(command)
-            puts "Run `#{command}`" unless ENV.fetch("TEST_ENV", "") === "CI"
+            unless ENV.fetch("TEST_ENV", "") === "CI"
+              Fontist.ui.say("Run `#{command}`")
+            end
+
             result = `#{command}`
             unless $CHILD_STATUS.to_i.zero?
               raise Errors::BinaryCallError,

data/lib/fontist/import/otf/font_file.rb

@@ -1,5 +1,6 @@
 require_relative "../otfinfo/otfinfo_requirement"
 require_relative "../text_helper"
+require_relative "../files/font_detector"
 
 module Fontist
   module Import
@@ -10,14 +11,19 @@ module Fontist
         }.freeze
 
         STYLE_ATTRIBUTES = %i[family_name type full_name post_script_name
-                              version description copyright font].freeze
-        COLLECTION_ATTRIBUTES = STYLE_ATTRIBUTES.reject { |a| a == :font }
+                              version description copyright font
+                              source_font].freeze
+
+        COLLECTION_ATTRIBUTES = STYLE_ATTRIBUTES.reject do |a|
+          %i[font source_font].include?(a)
+        end
 
         attr_reader :path
 
         def initialize(path)
           @path = path
           @info = read
+          @extension = detect_extension
         end
 
         def to_style
@@ -55,7 +61,11 @@ module Fontist
         end
 
         def font
-          File.basename(@path)
+          File.basename(@path, ".*") + "." + @extension
+        end
+
+        def source_font
+          File.basename(@path) unless font == File.basename(@path)
         end
 
         def copyright
@@ -77,12 +87,18 @@ module Fontist
         def read
           text = REQUIREMENTS[:otfinfo].call(@path)
 
-          text.split("\n")
+          text
+            .encode("UTF-8", invalid: :replace, replace: "")
+            .split("\n")
             .select { |x| x.include?(":") }
             .map { |x| x.split(":", 2) }
             .map { |x| x.map { |y| Fontist::Import::TextHelper.cleanup(y) } }
             .to_h
         end
+
+        def detect_extension
+          Files::FontDetector.standard_extension(@path)
+        end
       end
     end
   end

data/lib/fontist/import/recursive_extraction.rb

@@ -1,27 +1,40 @@
 require "find"
 require_relative "extractors"
+require_relative "files/font_detector"
 
 module Fontist
   module Import
     class RecursiveExtraction
-      BOTH_FONTS_PATTERN = "**/*.{ttf,otf,ttc}".freeze
+      FONTS_PATTERN = "**/*.{ttf,otf,ttc}".freeze
       ARCHIVE_EXTENSIONS = %w[zip msi exe cab].freeze
+      LICENSE_PATTERN = /(OFL\.txt|UFL\.txt|LICENSE\.txt|COPYING)$/i.freeze
 
-      def initialize(archive)
+      def initialize(archive, subarchive: nil, subdir: nil)
         @archive = archive
+        @subarchive = subarchive
+        @subdir = subdir
         @operations = []
+        @font_files = []
+        @collection_files = []
       end
 
       def extension
         File.extname(filename(@archive)).sub(/^\./, "")
       end
 
-      def extract(pattern)
-        Array.new.tap do |results|
-          Find.find(extracted_path) do |path| # rubocop:disable Style/CollectionMethods, Metrics/LineLength
-            results << yield(path) if path.match(pattern)
-          end
-        end
+      def font_files
+        ensure_extracted
+        @font_files
+      end
+
+      def font_collection_files
+        ensure_extracted
+        @collection_files
+      end
+
+      def license_text
+        ensure_extracted
+        @license_text
       end
 
       def operations
@@ -49,7 +62,11 @@ module Fontist
 
       def extract_recursively(archive)
         path = operate_on_archive(archive)
-        return path if fonts_exist?(path)
+        match_files(path)
+        if matched?
+          save_operation_subdir
+          return path
+        end
 
         next_archive = find_archive(path)
         extract_recursively(next_archive)
@@ -57,6 +74,8 @@ module Fontist
 
       def operate_on_archive(archive)
         extractor = choose_extractor(archive)
+        Fontist.ui.say("Extracting #{archive} with #{extractor.class.name}")
+
         save_operation(extractor)
         extractor.extract
       end
@@ -81,15 +100,80 @@ module Fontist
         @operations << { format: extractor.format }
       end
 
-      def fonts_exist?(path)
-        fonts = Dir.glob(File.join(path, BOTH_FONTS_PATTERN))
-        !fonts.empty?
+      def match_files(dir_path)
+        Find.find(dir_path) do |entry_path| # rubocop:disable Style/CollectionMethods
+          match_license(entry_path)
+          match_font(entry_path) if font_directory?(entry_path, dir_path)
+        end
+      end
+
+      def match_license(path)
+        @license_text ||= File.read(path) if license?(path)
+      end
+
+      def license?(file)
+        file.match?(LICENSE_PATTERN)
+      end
+
+      def font_directory?(path, base_path)
+        return true unless @subdir
+
+        relative_path = Pathname.new(path).relative_path_from(base_path).to_s
+        dirname = File.dirname(relative_path)
+        normalized_pattern = @subdir.chomp("/")
+        File.fnmatch?(normalized_pattern, dirname)
+      end
+
+      def match_font(path)
+        case Files::FontDetector.detect(path)
+        when :font
+          @font_files << Otf::FontFile.new(path)
+        when :collection
+          @collection_files << Files::CollectionFile.new(path)
+        end
+      end
+
+      def matched?
+        [@font_files, @collection_files].any? do |files|
+          files.size.positive?
+        end
+      end
+
+      def save_operation_subdir
+        return unless @subdir
+
+        @operations.last[:options] ||= {}
+        @operations.last[:options][:fonts_sub_dir] = @subdir
       end
 
       def find_archive(path)
-        Dir.children(path)
-          .map    { |file_name| File.join(path, file_name) }
-          .max_by { |file_path| [file_type(file_path), File.size(file_path)] }
+        paths = Dir.children(path).map { |file| File.join(path, file) }
+        by_subarchive(paths) || by_size(paths)
+      end
+
+      def by_subarchive(paths)
+        return unless @subarchive
+
+        path_found = paths.detect do |path|
+          @subarchive == File.basename(path)
+        end
+
+        return unless path_found
+
+        save_operation_subarchive(path_found)
+
+        path_found
+      end
+
+      def save_operation_subarchive(path)
+        @operations.last[:options] ||= {}
+        @operations.last[:options][:subarchive] = File.basename(path)
+      end
+
+      def by_size(paths)
+        paths.max_by do |path|
+          [file_type(path), File.size(path)]
+        end
       end
 
       def file_type(file_path)

data/lib/fontist/manifest.rb

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

data/lib/fontist/manifest/install.rb

@@ -0,0 +1,32 @@
+require_relative "locations"
+
+module Fontist
+  module Manifest
+    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 = super
+        return paths unless paths["paths"].empty?
+
+        install_font(font)
+        super
+      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,60 @@
+module Fontist
+  module Manifest
+    class Locations
+      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)
+        Fontist::SystemFont.find_with_name(font, style).transform_keys(&:to_s)
+      end
+    end
+  end
+end

data/lib/fontist/system_font.rb

@@ -1,7 +1,10 @@
+require_relative "system_index"
+
 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,6 +12,10 @@ module Fontist
       new(font: font, sources: sources).find
     end
 
+    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?
@@ -16,9 +23,17 @@ module Fontist
       paths.empty? ? nil : paths
     end
 
+    def find_with_name
+      styles = find_styles
+      return { full_name: nil, paths: [] } unless styles
+
+      { full_name: styles.first[:full_name],
+        paths: styles.map { |x| x[:path] } }
+    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|
@@ -30,15 +45,27 @@ module Fontist
       end
     end
 
-    def grep_font_paths(font)
+    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(/#{font}/i)
+      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 +
         normalize_default_paths +
         [fontist_fonts_path.join("**")]
@@ -54,7 +81,6 @@ module Fontist
       @fontist_fonts_path ||= Fontist.fonts_path
     end
 
-
     def user_os
       Fontist::Utils::System.user_os
     end
@@ -71,5 +97,45 @@ module Fontist
     def default_sources
       @default_sources ||= YAML.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)
+    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
+    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
+    end
   end
 end