fontist 1.9.3 → 1.11.2

data/lib/fontist/import/google.rb

@@ -1,11 +1,29 @@
 module Fontist
   module Import
     module Google
+      def self.metadata_name(path)
+        metadata_path = File.join(path, "METADATA.pb")
+        return unless File.exists?(metadata_path)
+
+        File.foreach(metadata_path) do |line|
+          name = line.match(/^name: "(.+)"/)
+          return name[1] if name
+        end
+      end
+
       def self.formula_path(name)
         filename = name.downcase.gsub(" ", "_") + ".yml"
         Fontist.formulas_path.join("google", filename)
       end
 
+      def self.digest(path)
+        checksums = Dir.glob(File.join(path, "*.{ttf,otf,ttc}"))
+          .sort
+          .map { |x| Digest::SHA256.file(x).to_s }
+
+        Digest::SHA256.hexdigest(checksums.to_s)
+      end
+
       def self.style_version(text)
         return unless text
 

data/lib/fontist/import/google_check.rb

@@ -4,17 +4,12 @@ module Fontist
   module Import
     class GoogleCheck
       def call
-        fetch_formulas
         fonts = new_fonts
         indicate(fonts)
       end
 
       private
 
-      def fetch_formulas
-        Formula.update_formulas_repo
-      end
-
       def new_fonts
         Fontist::Import::Google::NewFontsFetcher.new(logging: true).call
       end
@@ -26,8 +21,6 @@ module Fontist
         new_paths.each do |path|
           puts path
         end
-
-        abort
       end
     end
   end

data/lib/fontist/import/google_import.rb

@@ -1,11 +1,7 @@
 require "erb"
 require_relative "google"
 require_relative "google/new_fonts_fetcher"
-require_relative "google/fonts_public.pb"
-require_relative "template_helper"
-require_relative "text_helper"
-require_relative "otf_parser"
-require_relative "otf_style"
+require_relative "create_formula"
 
 module Fontist
   module Import
@@ -13,6 +9,7 @@ module Fontist
       def call
         fonts = new_fonts
         create_formulas(fonts)
+        rebuild_index
       end
 
       private
@@ -22,157 +19,48 @@ module Fontist
       end
 
       def create_formulas(fonts)
+        return puts("Nothing to update") if fonts.empty?
+
         puts "Creating formulas..."
         fonts.each do |path|
           create_formula(path)
         end
       end
 
-      def create_formula(path)
-        puts path
-        metadata = fetch_metadata(path)
-        font = build_font(metadata, path)
-        save_formula(font)
-      end
+      def create_formula(font_path)
+        puts font_path
 
-      def fetch_metadata(path)
-        protobuf = File.read(File.join(path, "METADATA.pb"))
-        ::Google::Fonts::FamilyProto.parse_from_text(protobuf)
-      end
+        path = Fontist::Import::CreateFormula.new(
+          url(font_path),
+          name: Google.metadata_name(font_path),
+          formula_dir: formula_dir,
+          skip_sha: variable_style?(font_path),
+          digest: Google.digest(font_path),
+        ).call
 
-      def build_font(metadata, path)
-        h = from_metadata(metadata)
-          .merge(from_otfinfo(path))
-          .merge(styles: styles_from_otfinfo(path, metadata.fonts))
-          .merge(from_license(path))
-
-        OpenStruct.new(h)
+        Fontist.ui.success("Formula has been successfully created: #{path}")
       end
 
-      def from_metadata(metadata)
-        copyright = metadata.fonts.first.copyright
-
-        Hash.new.tap do |h|
-          h[:fullname] = metadata.name
-          h[:cleanname] = metadata.name.gsub(/ /, "")
-          h[:sha256] = sha256(metadata.name) unless variable_style?(metadata)
-          h[:copyright] = Fontist::Import::TextHelper.cleanup(copyright)
-        end
+      def url(path)
+        name = Google.metadata_name(path)
+        "https://fonts.google.com/download?family=#{ERB::Util.url_encode(name)}"
       end
 
-      def variable_style?(metadata)
-        metadata.fonts.any? do |s|
-          s.filename.match?(/\[(.+,)?wght\]/)
+      def formula_dir
+        @formula_dir ||= Fontist.formulas_path.join("google").tap do |path|
+          FileUtils.mkdir_p(path) unless File.exist?(path)
         end
       end
 
-      def sha256(name)
-        file = Down.download("https://fonts.google.com/download?family=#{name}",
-                             open_timeout: 10,
-                             read_timeout: 10)
-
-        Digest::SHA256.file(file).to_s
-      end
-
-      def from_license(path)
-        file = Dir.glob(File.join(path, "{OFL.txt,UFL.txt,LICENSE.txt}")).first
-        print "warn, no license, " unless file
-        return { license: "" } unless file
-
-        { license: cleanup_text(File.read(file)) }
-      end
-
-      def cleanup_text(text)
-        text.rstrip
-          .gsub("\r\n", "\n")
-          .lines
-          .map(&:rstrip)
-          .drop_while(&:empty?)
-          .join("\n")
-      end
-
-      def from_otfinfo(path)
-        font_file = Dir.glob(File.join(path, "*.ttf")).first
-        otf = OtfParser.new(font_file).call
-
-        { homepage: otf["Vendor URL"],
-          license_url: otf["License URL"] }
-      end
-
-      def styles_from_otfinfo(path, fonts)
-        fonts.map do |f|
-          file_path = File.join(path, f.filename)
-          info = OtfParser.new(file_path).call
-          OtfStyle.new(info, file_path).call
+      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 save_formula(font)
-        hash = formula_hash(font)
-        path = formula_path(font.fullname)
-        save_to_path(hash, path)
-      end
-
-      def formula_hash(font)
-        stringify_keys(name: font.cleanname.sub(/\S/, &:upcase),
-                       description: font.fullname,
-                       homepage: font.homepage,
-                       resources: formula_resource(font),
-                       fonts: [yaml_font(font)],
-                       extract: { format: :zip },
-                       copyright: font.copyright,
-                       license_url: font.license_url,
-                       open_license: font.license)
-      end
-
-      def stringify_keys(hash)
-        JSON.parse(hash.to_json)
-      end
-
-      def formula_resource(font)
-        encoded_name = ERB::Util.url_encode(font.fullname)
-        url = "https://fonts.google.com/download?family=#{encoded_name}"
-
-        options = {}
-        options[:urls] = [url]
-        options[:sha256] = font.sha256 if font.sha256
-
-        { "#{font.cleanname}.zip" => options }
-      end
-
-      def yaml_font(font)
-        { name: font.fullname,
-          styles: yaml_styles(font.styles) }
-      end
-
-      def yaml_styles(styles)
-        styles.map do |s|
-          yaml_style(s)
-        end
-      end
-
-      def yaml_style(style)
-        Hash.new.tap do |h|
-          h.merge!(family_name: style.family_name,
-                   type: style.style,
-                   full_name: style.full_name)
-          h.merge!(style.to_h.select do |k, _|
-            %i(post_script_name version description copyright).include?(k)
-          end.compact)
-          h.merge!(font: fix_variable_filename(style.filename))
-        end
-      end
-
-      def fix_variable_filename(filename)
-        filename.sub("[wght]", "-VariableFont_wght")
-      end
-
-      def formula_path(name)
-        Fontist::Import::Google.formula_path(name)
-      end
-
-      def save_to_path(hash, path)
-        File.write(path, YAML.dump(hash))
+      def rebuild_index
+        Fontist::Index.rebuild
       end
     end
   end

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

@@ -4,7 +4,7 @@ module Fontist
       module SystemHelper
         class << self
           def run(command)
-            Fontist.ui.say("Run `#{command}`")
+            Fontist.ui.say("Run `#{command}`") if Fontist.debug?
 
             result = `#{command}`
             unless $CHILD_STATUS.to_i.zero?

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

@@ -10,7 +10,8 @@ module Fontist
           otfinfo: Otfinfo::OtfinfoRequirement.new,
         }.freeze
 
-        STYLE_ATTRIBUTES = %i[family_name type full_name post_script_name
+        STYLE_ATTRIBUTES = %i[family_name type preferred_family_name
+                              preferred_type full_name post_script_name
                               version description copyright font
                               source_font].freeze
 
@@ -35,11 +36,19 @@ module Fontist
         end
 
         def family_name
-          info["Preferred family"] || info["Family"]
+          info["Family"]
         end
 
         def type
-          info["Preferred subfamily"] || info["Subfamily"]
+          info["Subfamily"]
+        end
+
+        def preferred_family_name
+          info["Preferred family"]
+        end
+
+        def preferred_type
+          info["Preferred subfamily"]
         end
 
         def full_name
@@ -97,7 +106,11 @@ module Fontist
         end
 
         def detect_extension
-          Files::FontDetector.standard_extension(@path)
+          detected = Files::FontDetector.standard_extension(@path)
+          file_extension = File.extname(File.basename(@path)).sub(/^\./, "")
+          return file_extension if file_extension.casecmp?(detected)
+
+          detected
         end
       end
     end

data/lib/fontist/import/otf_parser.rb

@@ -13,6 +13,8 @@ module Fontist
       end
 
       def call
+        raise ArgumentError, "Empty path" unless @path
+
         text = REQUIREMENTS[:otfinfo].call(@path)
         text.split("\n")
           .select { |x| x.include?(":") }

data/lib/fontist/import/otf_style.rb

@@ -7,8 +7,8 @@ module Fontist
       end
 
       def call
-        style = { family_name: @info["Preferred family"] || @info["Family"],
-                  style: @info["Preferred subfamily"] || @info["Subfamily"],
+        style = { family_name: @info["Family"],
+                  style: @info["Subfamily"],
                   full_name: @info["Full name"],
                   post_script_name: @info["PostScript name"],
                   version: version(@info["Version"]),
@@ -16,6 +16,14 @@ module Fontist
                   filename: File.basename(@path),
                   copyright: @info["Copyright"] }
 
+        if @info["Preferred family"]
+          style[:preferred_family_name] = @info["Preferred family"]
+        end
+
+        if @info["Preferred subfamily"]
+          style[:preferred_style] = @info["Preferred subfamily"]
+        end
+
         OpenStruct.new(style)
       end
 

data/lib/fontist/import/otfinfo/template.erb

@@ -2,6 +2,12 @@
           {
             family_name: "<%= s.family_name %>",
             style: "<%= s.style %>",
+            <%- if s.preferred_family_name -%>
+            preferred_family_name: "<%= s.preferred_family_name %>",
+            <%- end -%>
+            <%- if s.preferred_style -%>
+            preferred_type: "<%= s.preferred_style %>",
+            <%- end -%>
             full_name: "<%= s.full_name %>",
             <%- if s.post_script_name -%>
             post_script_name: "<%= s.post_script_name %>",

data/lib/fontist/import/recursive_extraction.rb

@@ -3,7 +3,8 @@ require_relative "files/font_detector"
 module Fontist
   module Import
     class RecursiveExtraction
-      LICENSE_PATTERN = /(ofl\.txt|ufl\.txt|licenses?\.txt|copying)$/i.freeze
+      LICENSE_PATTERN =
+        /(ofl\.txt|ufl\.txt|licenses?\.txt|license|copying)$/i.freeze
 
       def initialize(archive, subarchive: nil, subdir: nil)
         @archive = archive

data/lib/fontist/index.rb

@@ -3,41 +3,17 @@ require_relative "indexes/filename_index"
 
 module Fontist
   class Index
-    def self.rebuild_for_main_repo
-      unless Dir.exist?(Fontist.private_formulas_path)
-        return do_rebuild_for_main_repo_with
-      end
-
-      Dir.mktmpdir do |dir|
-        tmp_private_path = File.join(dir, "private")
-        FileUtils.mv(Fontist.private_formulas_path, tmp_private_path)
-
-        do_rebuild_for_main_repo_with
-
-        FileUtils.mv(tmp_private_path, Fontist.private_formulas_path)
-      end
-    end
-
-    def self.do_rebuild_for_main_repo_with
-      Fontist.formula_index_path = Fontist.formulas_repo_path.join("index.yml")
-      Fontist.formula_filename_index_path =
-        Fontist.formulas_repo_path.join("filename_index.yml")
-
-      rebuild
-
-      Fontist.formula_index_path = nil
-      Fontist.formula_filename_index_path = nil
-    end
-
     def self.rebuild
-      Fontist::Indexes::FontIndex.rebuild
+      Fontist::Indexes::DefaultFamilyFontIndex.rebuild
+      Fontist::Indexes::PreferredFamilyFontIndex.rebuild
       Fontist::Indexes::FilenameIndex.rebuild
 
       reset_cache
     end
 
     def self.reset_cache
-      Fontist::Indexes::FontIndex.reset_cache
+      Fontist::Indexes::DefaultFamilyFontIndex.reset_cache
+      Fontist::Indexes::PreferredFamilyFontIndex.reset_cache
       Fontist::Indexes::FilenameIndex.reset_cache
     end
   end

data/lib/fontist/indexes/default_family_font_index.rb

@@ -0,0 +1,21 @@
+require_relative "base_index"
+
+module Fontist
+  module Indexes
+    class DefaultFamilyFontIndex < BaseIndex
+      def self.path
+        Fontist.formula_index_path
+      end
+
+      def add_formula(formula)
+        formula.fonts.each do |font|
+          add_index_formula(font.name, formula.to_index_formula)
+        end
+      end
+
+      def normalize_key(key)
+        key.downcase
+      end
+    end
+  end
+end

data/lib/fontist/indexes/font_index.rb

@@ -1,21 +1,16 @@
-require_relative "base_index"
+require_relative "default_family_font_index"
+require_relative "preferred_family_font_index"
 
 module Fontist
   module Indexes
-    class FontIndex < BaseIndex
-      def self.path
-        Fontist.formula_index_path
-      end
-
-      def add_formula(formula)
-        formula.fonts.each do |font|
-          add_index_formula(font.name, formula.to_index_formula)
+    class FontIndex
+      def self.from_yaml
+        if Fontist.preferred_family?
+          PreferredFamilyFontIndex.from_yaml
+        else
+          DefaultFamilyFontIndex.from_yaml
         end
       end
-
-      def normalize_key(key)
-        key.downcase
-      end
     end
   end
 end