fontist 1.19.0 → 1.21.1

data/lib/fontist/formula_suggestion.rb

@@ -0,0 +1,55 @@
+require "fuzzy_match"
+
+module Fontist
+  class FormulaSuggestion
+    MINIMUM_REQUIRED_SCORE = 0.6
+
+    def initialize
+      @fuzzy_match = prepare_search_engine
+    end
+
+    def find(name)
+      @fuzzy_match.find_all_with_score(normalize(name))
+        .tap { |res| Fontist.ui.debug(prettify_result(res)) }
+        .select { |_key, score, _| score >= MINIMUM_REQUIRED_SCORE }
+        .take(10)
+        .map(&:first)
+        .map { |x| Formula.find_by_key_or_name(x) }
+        .select(&:downloadable?)
+    end
+
+    private
+
+    def normalize(name)
+      name.gsub(" ", "_")
+    end
+
+    def prepare_search_engine
+      dict = Formula.all_keys
+      stop_words = namespaces(dict).map { |ns| /^#{Regexp.escape(ns)}/i }
+
+      FuzzyMatch.new(dict, stop_words: stop_words)
+    end
+
+    def namespaces(keys)
+      keys.map do |key|
+        parts = key.split("/")
+        parts.size
+        parts.take(parts.size - 1).join("/")
+      end.uniq
+    end
+
+    def prettify_result(result)
+      list = result.map do |key, dice, leve|
+        sprintf(
+          "%<dice>.3f %<leve>.3f %<key>s",
+          dice: dice,
+          leve: leve,
+          key: key,
+        )
+      end
+
+      "FuzzyMatch:\n#{list.join("\n")}"
+    end
+  end
+end

data/lib/fontist/helpers.rb

@@ -1,3 +1,5 @@
+require "ostruct"
+
 module Fontist
   module Helpers
     def self.parse_to_object(data)

data/lib/fontist/import/create_formula.rb

@@ -1,6 +1,5 @@
 require "fontist/import"
 require_relative "recursive_extraction"
-require_relative "helpers/hash_helper"
 require_relative "formula_builder"
 
 module Fontist
@@ -12,31 +11,102 @@ module Fontist
       end
 
       def call
-        save(builder)
+        builder.save
       end
 
       private
 
       def builder
         builder = FormulaBuilder.new
-        setup_strings(builder, archive)
+        setup_strings(builder)
         setup_files(builder)
         builder
       end
 
-      def setup_strings(builder, archive)
-        builder.archive = archive
-        builder.url = @url
+      def setup_strings(builder)
         builder.options = @options
+        builder.resources = resources
       end
 
       def setup_files(builder)
-        builder.extractor = extractor
+        builder.operations = extractor.operations
         builder.font_files = extractor.font_files
         builder.font_collection_files = extractor.font_collection_files
         builder.license_text = extractor.license_text
       end
 
+      def resources
+        @resources ||= { filename(archive) => resource_options }
+      end
+
+      def filename(file)
+        if file.respond_to?(:original_filename)
+          file.original_filename
+        else
+          File.basename(file)
+        end
+      end
+
+      def resource_options
+        if @options[:skip_sha]
+          resource_options_without_sha
+        else
+          resource_options_with_sha
+        end
+      end
+
+      def resource_options_without_sha
+        { urls: [@url] + mirrors, file_size: file_size }
+      end
+
+      def resource_options_with_sha
+        urls = []
+        sha = []
+        downloads do |url, path|
+          urls << url
+          sha << Digest::SHA256.file(path).to_s
+        end
+
+        sha = prepare_sha256(sha)
+
+        { urls: urls, sha256: sha, file_size: file_size }
+      end
+
+      def downloads
+        yield @url, archive
+
+        mirrors.each do |url|
+          path = download_mirror(url)
+          next unless path
+
+          yield url, path
+        end
+      end
+
+      def mirrors
+        @options[:mirror] || []
+      end
+
+      def download_mirror(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 file_size
+        File.size(archive)
+      end
+
       def extractor
         @extractor ||=
           RecursiveExtraction.new(archive,
@@ -53,34 +123,6 @@ module Fontist
 
         Fontist::Utils::Downloader.download(url, progress_bar: true).path
       end
-
-      def save(builder)
-        path = vacant_path
-        yaml = YAML.dump(Helpers::HashHelper.stringify_keys(builder.formula))
-        File.write(path, yaml)
-        path
-      end
-
-      def vacant_path
-        path = path_from_name
-        return path unless @options[:keep_existing] && File.exist?(path)
-
-        2.upto(9) do |i|
-          candidate = path.sub(/\.yml$/, "#{i}.yml")
-          return candidate unless File.exist?(candidate)
-        end
-
-        raise Errors::GeneralError, "Formula #{path} already exists."
-      end
-
-      def path_from_name
-        filename = Import.name_to_filename(builder.name)
-        if @options[:formula_dir]
-          File.join(@options[:formula_dir], filename)
-        else
-          filename
-        end
-      end
     end
   end
 end

data/lib/fontist/import/formula_builder.rb

@@ -1,49 +1,70 @@
 require "shellwords"
 require_relative "text_helper"
+require_relative "helpers/hash_helper"
 
 module Fontist
   module Import
     class FormulaBuilder
-      FORMULA_ATTRIBUTES = %i[platforms description homepage resources
+      FORMULA_ATTRIBUTES = %i[name platforms description homepage resources
                               font_collections fonts extract copyright
                               license_url requires_license_agreement
                               open_license digest command].freeze
 
-      attr_writer :archive,
-                  :url,
-                  :extractor,
+      attr_writer :resources,
                   :options,
                   :font_files,
                   :font_collection_files,
                   :license_text,
-                  :homepage
+                  :operations
 
       def initialize
         @options = {}
+        @font_files = []
+        @font_collection_files = []
       end
 
       def formula
         formula_attributes.map { |name| [name, send(name)] }.to_h.compact
       end
 
+      def save
+        path = vacant_path
+        yaml = YAML.dump(Helpers::HashHelper.stringify_keys(formula))
+        File.write(path, yaml)
+        path
+      end
+
+      private
+
+      def formula_attributes
+        FORMULA_ATTRIBUTES
+      end
+
       def name
+        @name ||= generate_name
+      end
+
+      def generate_name
         return @options[:name] if @options[:name]
 
-        common = %i[family_name type]
-          .map { |attr| both_fonts.map(&attr).uniq }
-          .map { |names| TextHelper.longest_common_prefix(names) }
-          .map { |prefix| prefix unless prefix == "Regular" }
-          .compact
-          .join(" ")
+        common = common_prefix
         return common unless common.empty?
 
         both_fonts.map(&:family_name).first
       end
 
-      private
+      def common_prefix
+        family_prefix = common_prefix_by_attr(:family_name)
+        style_prefix = common_prefix_by_attr(:type)
 
-      def formula_attributes
-        FORMULA_ATTRIBUTES
+        [family_prefix, style_prefix].compact.join(" ")
+      end
+
+      def common_prefix_by_attr(attr)
+        names = both_fonts.map(&attr).uniq
+        prefix = TextHelper.longest_common_prefix(names)
+
+        prefix unless prefix == "Regular"
       end
 
       def both_fonts
@@ -70,69 +91,7 @@ module Fontist
       end
 
       def resources
-        filename = name.gsub(" ", "_") + "." + @extractor.extension
-
-        { filename => resource_options }
-      end
-
-      def resource_options
-        if @options[:skip_sha]
-          resource_options_without_sha
-        else
-          resource_options_with_sha
-        end
-      end
-
-      def resource_options_without_sha
-        { urls: [@url] + mirrors, file_size: file_size }
-      end
-
-      def resource_options_with_sha
-        urls = []
-        sha = []
-        downloads do |url, path|
-          urls << url
-          sha << Digest::SHA256.file(path).to_s
-        end
-
-        sha = prepare_sha256(sha)
-
-        { urls: urls, sha256: sha, file_size: file_size }
-      end
-
-      def downloads
-        yield @url, @archive
-
-        mirrors.each do |url|
-          path = download(url)
-          next unless path
-
-          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 file_size
-        File.size(@archive)
+        @resources || raise("Resources should be set.")
       end
 
       def font_collections
@@ -175,7 +134,7 @@ module Fontist
       end
 
       def extract
-        @extractor.operations
+        @operations || {}
       end
 
       def copyright
@@ -197,9 +156,11 @@ module Fontist
 
         return unless @license_text
 
-        Fontist.ui.error("WARN: ensure it's an open license, otherwise " \
-                         "change the 'open_license' attribute to " \
-                         "'requires_license_agreement'")
+        unless @options[:open_license]
+          Fontist.ui.error("WARN: ensure it's an open license, otherwise " \
+                           "change the 'open_license' attribute to " \
+                           "'requires_license_agreement'")
+        end
 
         TextHelper.cleanup(@license_text)
       end
@@ -211,6 +172,27 @@ module Fontist
       def command
         Shellwords.shelljoin(ARGV)
       end
+
+      def vacant_path
+        path = path_from_name
+        return path unless @options[:keep_existing] && File.exist?(path)
+
+        2.upto(9) do |i|
+          candidate = path.sub(/\.yml$/, "#{i}.yml")
+          return candidate unless File.exist?(candidate)
+        end
+
+        raise Errors::GeneralError, "Formula #{path} already exists."
+      end
+
+      def path_from_name
+        filename = Import.name_to_filename(name)
+        if @options[:formula_dir]
+          File.join(@options[:formula_dir], filename)
+        else
+          filename
+        end
+      end
     end
   end
 end

data/lib/fontist/import/google/api.rb

@@ -0,0 +1,25 @@
+module Fontist
+  module Import
+    module Google
+      class Api
+        class << self
+          def items
+            db["items"]
+          end
+
+          def db
+            @db ||= JSON.parse(Net::HTTP.get(URI(url)))
+          end
+
+          def url
+            "https://www.googleapis.com/webfonts/v1/webfonts?key=#{api_key}"
+          end
+
+          def api_key
+            Fontist.google_fonts_key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/google/create_google_formula.rb

@@ -0,0 +1,89 @@
+require "fontist/import"
+require "fontist/import/formula_builder"
+require "fontist/import/otf/font_file"
+
+module Fontist
+  module Import
+    module Google
+      class CreateGoogleFormula
+        REPO_PATH = Fontist.fontist_path.join("google", "fonts")
+        POSSIBLE_LICENSE_FILES = ["LICENSE.txt",
+                                  "LICENCE.txt",
+                                  "OFL.txt",
+                                  "UFL.txt"].freeze
+
+        def initialize(item, options = {})
+          @item = item
+          @options = options
+        end
+
+        def call
+          builder = FormulaBuilder.new
+          builder.options = options
+          builder.resources = resources
+          builder.font_files = font_files
+          builder.license_text = license_text
+          builder.save
+        end
+
+        private
+
+        def options
+          @options.merge(name: formula_name, open_license: true)
+        end
+
+        def formula_name
+          @item["family"]
+        end
+
+        def resources
+          {
+            @item["family"] => {
+              source: "google",
+              family: @item["family"],
+              files: @item["files"].values,
+            },
+          }
+        end
+
+        def font_files
+          @font_files ||= @item["files"].map do |_key, url|
+            font_file(url)
+          end
+        end
+
+        def license_text
+          @license_text ||= find_license_text
+        end
+
+        def font_file(url)
+          path = Utils::Downloader.download(url, use_content_length: false).path
+          Otf::FontFile.new(path)
+        end
+
+        def find_license_text
+          file = license_file
+          return unless file
+
+          File.read(file)
+        end
+
+        def license_file
+          dir = @item["family"].gsub(" ", "").downcase
+          path = repo_paths(dir).first
+          return unless path
+
+          full_paths = POSSIBLE_LICENSE_FILES.map { |f| File.join(path, f) }
+
+          Dir[*full_paths].first
+        end
+
+        def repo_paths(dir)
+          Dir[File.join(REPO_PATH, "apache", dir),
+              File.join(REPO_PATH, "ofl", dir),
+              File.join(REPO_PATH, "ufl", dir)]
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/google_import.rb

@@ -1,54 +1,92 @@
-require "erb"
 require_relative "google"
-require_relative "google/new_fonts_fetcher"
-require_relative "create_formula"
+require_relative "google/api"
+require_relative "google/create_google_formula"
 
 module Fontist
   module Import
     class GoogleImport
+      REPO_PATH = Fontist.fontist_path.join("google", "fonts")
+      REPO_URL = "https://github.com/google/fonts.git".freeze
+
       def initialize(options)
         @max_count = options[:max_count] || Google::DEFAULT_MAX_COUNT
       end
 
       def call
-        fonts = new_fonts
-        create_formulas(fonts)
-        rebuild_index unless fonts.empty?
+        update_repo
+        count = update_formulas
+        rebuild_index if count.positive?
       end
 
       private
 
-      def new_fonts
-        Fontist::Import::Google::NewFontsFetcher.new(logging: true,
-                                                     limit: @max_count).call
+      def update_repo
+        if Dir.exist?(REPO_PATH)
+          `cd #{REPO_PATH} && git pull`
+        else
+          FileUtils.mkdir_p(File.dirname(REPO_PATH))
+          `git clone --depth 1 #{REPO_URL} #{REPO_PATH}`
+        end
       end
 
-      def create_formulas(fonts)
-        return puts("Nothing to update") if fonts.empty?
+      def update_formulas
+        Fontist.ui.say "Updating formulas..."
+
+        items = api_items
 
-        puts "Creating formulas..."
-        fonts.each do |path|
-          create_formula(path)
+        count = 0
+        items.each do |item|
+          break if count >= @max_count
+
+          path = update_formula(item)
+          count += 1 if path
         end
+
+        count
+      end
+
+      def api_items
+        Google::Api.items
+      end
+
+      def update_formula(item)
+        family = item["family"]
+        Fontist.ui.say "Checking #{family}"
+        unless new_changes?(item)
+          Fontist.ui.say "Skip, no changes"
+          return
+        end
+
+        create_formula(item)
       end
 
-      def create_formula(font_path)
-        puts font_path
+      def new_changes?(item)
+        formula = formula(item["family"])
+        return true unless formula
 
-        path = Fontist::Import::CreateFormula.new(
-          url(font_path),
-          name: Google.metadata_name(font_path),
+        item["files"].values != formula.resources.first.files
+      end
+
+      def formula(font_name)
+        path = formula_path(font_name)
+        Formula.new_from_file(path) if File.exist?(path)
+      end
+
+      def formula_path(name)
+        snake_case = name.downcase.gsub(" ", "_")
+        filename = "#{snake_case}.yml"
+        Fontist.formulas_path.join("google", filename)
+      end
+
+      def create_formula(item)
+        path = Google::CreateGoogleFormula.new(
+          item,
           formula_dir: formula_dir,
-          skip_sha: variable_style?(font_path),
-          digest: Google.digest(font_path),
         ).call
 
         Fontist.ui.success("Formula has been successfully created: #{path}")
-      end
 
-      def url(path)
-        name = Google.metadata_name(path)
-        "https://fonts.google.com/download?family=#{ERB::Util.url_encode(name)}"
+        path
       end
 
       def formula_dir
@@ -57,13 +95,6 @@ module Fontist
         end
       end
 
-      def variable_style?(path)
-        fonts = Dir.glob(File.join(path, "*.{ttf,otf}"))
-        fonts.any? do |font|
-          File.basename(font).match?(/\[(.+,)?(wght|opsz)\]/)
-        end
-      end
-
       def rebuild_index
         Fontist::Index.rebuild
       end

data/lib/fontist/import/recursive_extraction.rb

@@ -19,10 +19,6 @@ module Fontist
         save_operation_subdir
       end
 
-      def extension
-        fetch_extension(@archive)
-      end
-
       def font_files
         ensure_extracted
         @font_files
@@ -52,18 +48,6 @@ module Fontist
         @operations[:options][:fonts_sub_dir] = @subdir
       end
 
-      def fetch_extension(file)
-        File.extname(filename(file)).sub(/^\./, "")
-      end
-
-      def filename(file)
-        if file.respond_to?(:original_filename)
-          file.original_filename
-        else
-          File.basename(file)
-        end
-      end
-
       def ensure_extracted
         return if @extracted
 

data/lib/fontist/manifest/locations.rb

@@ -2,6 +2,8 @@ module Fontist
   module Manifest
     class Locations
       def initialize(manifest)
+        Fontist.ui.debug("Manifest: #{manifest}")
+
         @manifest = manifest
       end