fontist 1.4.0 → 1.7.1

data/lib/fontist/font_formula.rb

@@ -95,8 +95,10 @@ module Fontist
       styles = options.fetch(:extract_styles_from_collection, [])
 
       unless styles.empty?
-        styles.map do |type, file|
-          { type: type, collection: file, font: temp_resource[:filename] }
+        styles.map do |attributes|
+          filenames = temp_resource.slice(:filename, :source_filename)
+          Fontist::Utils::Dsl::CollectionFont.new(attributes.merge(filenames))
+            .attributes
         end
       end
     end
@@ -109,8 +111,11 @@ module Fontist
     end
 
     def download_file(source)
+      url = source[:urls].first
+      Fontist.ui.say(%(Downloading font "#{key}" from #{url}))
+
       downloaded_file = Fontist::Utils::Downloader.download(
-        source[:urls].first,
+        url,
         sha: source[:sha256],
         file_size: source[:file_size],
         progress_bar: is_progress_bar_enabled
@@ -121,7 +126,33 @@ module Fontist
     end
 
     def is_progress_bar_enabled
-      options.nil? ? false : options.fetch(:progress_bar, false)
+      options.nil? ? true : options.fetch(:progress_bar, true)
+    end
+
+    def font_file?(filename)
+      source_files.include?(filename)
+    end
+
+    def source_files
+      @source_files ||= fonts.flat_map do |font|
+        font[:styles].map do |style|
+          style[:source_font] || style[:font]
+        end
+      end
+    end
+
+    def target_filename(source_filename)
+      target_filenames[source_filename]
+    end
+
+    def target_filenames
+      @target_filenames ||= fonts.flat_map do |font|
+        font[:styles].map do |style|
+          source = style[:source_font] || style[:font]
+          target = style[:font]
+          [source, target]
+        end
+      end.to_h
     end
   end
 end

data/lib/fontist/formula.rb

@@ -2,6 +2,7 @@ module Fontist
   class Formula
     def initialize(options = {})
       @font_name = options.fetch(:font_name, nil)
+      @style_name = options.fetch(:style_name, nil)
 
       check_and_register_font_formulas
     end
@@ -18,6 +19,10 @@ module Fontist
       new(font_name: name).find_fonts
     end
 
+    def self.find_styles(font, style)
+      new(font_name: font, style_name: style).find_styles
+    end
+
     def all
       @all ||= Fontist::Registry.instance.formulas
     end
@@ -32,9 +37,19 @@ module Fontist
       fonts.empty? ? nil : fonts
     end
 
+    def find_styles
+      formulas.values.flat_map do |formula|
+        formula.fonts.flat_map do |f|
+          f.styles.select do |s|
+            f.name.casecmp?(font_name) && s.type.casecmp?(style_name)
+          end
+        end
+      end
+    end
+
     private
 
-    attr_reader :font_name
+    attr_reader :font_name, :style_name
 
     def find_formula
       find_by_key || find_by_font_name || find_by_font || []

data/lib/fontist/formula_template.rb

@@ -2,9 +2,10 @@ module Fontist
   class FormulaTemplate
     def self.create_formula_class(formula)
       Class.new(FontFormula) do |klass|
-        cleanname = formula.fonts.first.name.gsub(/ /, "")
+        first_font = (formula.fonts || formula.font_collections.first.fonts).first
+        cleanname = first_font.name.gsub(/ /, "")
         resource_name = formula.resources.to_h.keys.first
-        font_filename = formula.fonts.first.styles.first.font
+        font_filename = first_font.styles.first.font
 
         key formula.key&.to_sym || formula.name.gsub(/ /, "_").downcase.to_sym
         display_progress_bar formula.display_progress_bar if formula.display_progress_bar
@@ -22,31 +23,47 @@ module Fontist
           formula.font_collections.each do |collection|
             provides_font_collection do
               filename collection.filename
+              source_filename collection.source_filename
 
               collection.fonts.each do |font|
-                styles = font.styles.map { |s| [s.type, s.full_name] }.to_h
-                provides_font font.name, extract_styles_from_collection: styles
+                provides_font(
+                  font.name,
+                  extract_styles_from_collection: font.styles.map do |style|
+                    {
+                      family_name: style.family_name,
+                      style: style.type,
+                      full_name: style.full_name,
+                      post_script_name: style.post_script_name,
+                      version: style.version,
+                      description: style.description,
+                      copyright: style.copyright,
+                    }
+                  end
+                )
               end
             end
           end
         end
 
-        formula.fonts.each do |font|
-          provides_font(
-            font.name,
-            match_styles_from_file: font.styles.map do |style|
-              {
-                family_name: style.family_name,
-                style: style.type,
-                full_name: style.full_name,
-                post_script_name: style.post_script_name,
-                version: style.version,
-                description: style.description,
-                filename: style.font,
-                copyright: style.copyright,
-              }
-            end
-          )
+        if formula.fonts
+          formula.fonts.each do |font|
+            provides_font(
+              font.name,
+              match_styles_from_file: font.styles.map do |style|
+                {
+                  family_name: style.family_name,
+                  style: style.type,
+                  full_name: style.full_name,
+                  post_script_name: style.post_script_name,
+                  version: style.version,
+                  description: style.description,
+                  filename: style.font,
+                  source_filename: style.source_font,
+                  copyright: style.copyright,
+                }
+              end
+            )
+          end
         end
 
         klass.define_method :extract do
@@ -61,8 +78,10 @@ module Fontist
                        end
           end
 
-          formula.fonts.each do |font|
-            match_fonts(resource, font.name)
+          if formula.fonts
+            formula.fonts.each do |font|
+              match_fonts(resource, font.name)
+            end
           end
 
           if formula.font_collections

data/lib/fontist/import/create_formula.rb

@@ -8,10 +8,6 @@ require_relative "formula_builder"
 module Fontist
   module Import
     class CreateFormula
-      FONT_PATTERN = /(\.ttf|\.otf)$/i.freeze
-      FONT_COLLECTION_PATTERN = /\.ttc$/i.freeze
-      LICENSE_PATTERN = /(OFL\.txt|UFL\.txt|LICENSE\.txt)$/i.freeze
-
       def initialize(url, options = {})
         @url = url
         @options = options
@@ -26,41 +22,30 @@ module Fontist
       def formula
         builder = FormulaBuilder.new
         builder.url = @url
-        builder.archive = download(@url)
-        builder.extractor = extractor(builder.archive)
+        builder.archive = archive
+        builder.extractor = extractor
         builder.options = @options
-        builder.font_files = font_files(builder.extractor)
-        builder.font_collection_files = font_collection_files(builder.extractor)
-        builder.license_text = license_texts(builder.extractor).first
+        builder.font_files = extractor.font_files
+        builder.font_collection_files = extractor.font_collection_files
+        builder.license_text = extractor.license_text
         builder.formula
       end
 
-      def download(url)
-        return url if File.exist?(url)
-
-        Fontist::Utils::Downloader.download(url, progress_bar: true).path
+      def extractor
+        @extractor ||=
+          RecursiveExtraction.new(archive,
+                                  subarchive: @options[:subarchive],
+                                  subdir: @options[:subdir])
       end
 
-      def extractor(archive)
-        RecursiveExtraction.new(archive)
+      def archive
+        @archive ||= download(@url)
       end
 
-      def font_files(extractor)
-        extractor.extract(FONT_PATTERN) do |path|
-          Otf::FontFile.new(path)
-        end
-      end
-
-      def font_collection_files(extractor)
-        extractor.extract(FONT_COLLECTION_PATTERN) do |path|
-          Files::CollectionFile.new(path)
-        end
-      end
+      def download(url)
+        return url if File.exist?(url)
 
-      def license_texts(extractor)
-        extractor.extract(LICENSE_PATTERN) do |path|
-          File.read(path)
-        end
+        Fontist::Utils::Downloader.download(url, progress_bar: true).path
       end
 
       def save(hash)

data/lib/fontist/import/files/collection_file.rb

@@ -1,3 +1,4 @@
+require "extract_ttc"
 require "fontist/import/helpers/system_helper"
 require_relative "../otf/font_file"
 
@@ -5,17 +6,20 @@ module Fontist
   module Import
     module Files
       class CollectionFile
-        STRIP_TTC_BINARY = Fontist.root_path.join("bin", "stripttc")
-
         attr_reader :fonts
 
         def initialize(path)
           @path = path
           @fonts = read
+          @extension = "ttc"
         end
 
         def filename
-          File.basename(@path)
+          File.basename(@path, ".*") + "." + @extension
+        end
+
+        def source_filename
+          File.basename(@path) unless filename == File.basename(@path)
         end
 
         private
@@ -37,10 +41,10 @@ module Fontist
         end
 
         def extract_ttfs(tmp_dir)
-          Helpers::SystemHelper.run("#{STRIP_TTC_BINARY} #{@path}")
-
-          basename = File.basename(@path, ".ttc")
-          Dir.glob(File.join(tmp_dir, "#{basename}_[0-9][0-9].ttf"))
+          filenames = ExtractTtc.extract(@path)
+          filenames.map do |filename|
+            File.join(tmp_dir, filename)
+          end
         end
       end
     end

data/lib/fontist/import/files/file_requirement.rb

@@ -0,0 +1,17 @@
+module Fontist
+  module Import
+    module Files
+      class FileRequirement
+        def initialize
+          `file -v`
+        rescue Errno::ENOENT
+          abort "`file` is not available. (Or is PATH not setup properly?)"
+        end
+
+        def call(path)
+          Helpers::SystemHelper.run("file --brief '#{path}'")
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/files/font_detector.rb

@@ -0,0 +1,48 @@
+require_relative "file_requirement"
+
+module Fontist
+  module Import
+    module Files
+      class FontDetector
+        REQUIREMENTS = { file: FileRequirement.new }.freeze
+
+        FONT_LABELS = ["OpenType font data",
+                       "TrueType Font data"].freeze
+
+        COLLECTION_LABEL = "TrueType font collection data".freeze
+
+        FONT_EXTENSIONS = {
+          "OpenType font data" => "otf",
+          "TrueType Font data" => "ttf",
+          "TrueType font collection data" => "ttc",
+        }.freeze
+
+        def self.detect(path)
+          brief = file_brief(path)
+
+          if brief.start_with?(*FONT_LABELS)
+            :font
+          elsif brief.start_with?(COLLECTION_LABEL)
+            :collection
+          else
+            :other
+          end
+        end
+
+        def self.standard_extension(path)
+          brief = file_brief(path)
+
+          FONT_EXTENSIONS.each do |label, extension|
+            return extension if brief.start_with?(label)
+          end
+
+          raise Errors::UnknownFontTypeError.new(path)
+        end
+
+        def self.file_brief(path)
+          REQUIREMENTS[:file].call(path)
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/formula_builder.rb

@@ -39,7 +39,7 @@ module Fontist
 
       def group_fonts
         files = (@font_files + @font_collection_files.map(&:fonts)).flatten
-        raise FontNotFoundError, "No font found" if files.empty?
+        raise Errors::FontNotFoundError, "No font found" if files.empty?
 
         files
       end
@@ -55,10 +55,51 @@ module Fontist
       def resources
         filename = name.gsub(" ", "_") + "." + @extractor.extension
 
-        options = { urls: [@url] + (@options[:mirror] || []),
-                    sha256: Digest::SHA256.file(@archive).to_s }
+        { filename => resource_options }
+      end
+
+      def resource_options
+        urls = []
+        sha = []
+        downloads do |url, path|
+          urls << url
+          sha << Digest::SHA256.file(path).to_s
+        end
+
+        sha = prepare_sha256(sha)
+
+        { urls: urls, sha256: sha }
+      end
+
+      def downloads
+        yield @url, @archive
+
+        mirrors.each do |url|
+          path = download(url)
+          next unless path
 
-        { filename => options }
+          yield url, path
+        end
+      end
+
+      def mirrors
+        @options[:mirror] || []
+      end
+
+      def download(url)
+        Fontist::Utils::Downloader.download(url, progress_bar: true).path
+      rescue Errors::InvalidResourceError
+        Fontist.ui.error("WARN: a mirror is not found '#{url}'")
+        nil
+      end
+
+      def prepare_sha256(input)
+        output = input.uniq
+        return output.first if output.size == 1
+
+        checksums = output.join(", ")
+        Fontist.ui.error("WARN: SHA256 differs (#{checksums})")
+        output
       end
 
       def font_collections
@@ -66,7 +107,10 @@ module Fontist
 
         collections = @font_collection_files.map do |file|
           fonts = fonts_from_files(file.fonts, :to_collection_style)
-          { filename: file.filename, fonts: fonts }
+
+          { filename: file.filename,
+            source_filename: file.source_filename,
+            fonts: fonts }.compact
         end
 
         collections.sort_by do |x|
@@ -106,7 +150,14 @@ module Fontist
       end
 
       def open_license
-        return unless @license_text
+        unless @license_text
+          Fontist.ui.error("WARN: please add license manually")
+          return
+        end
+
+        Fontist.ui.error("WARN: ensure it's an open license, otherwise " \
+                         "change the 'open_license' attribute to " \
+                         "'requires_license_agreement'")
 
         TextHelper.cleanup(@license_text)
       end