fontist 1.0.0 → 1.4.0

data/lib/fontist/import/formula_serializer.rb

@@ -0,0 +1,133 @@
+module Fontist
+  module Import
+    class FormulaSerializer
+      def initialize(formula, code)
+        @formula = formula
+        @code = code
+      end
+
+      def call
+        to_h.compact
+      end
+
+      private
+
+      def to_h
+        info_attributes.merge(fonts_attributes).merge(license_attributes)
+      end
+
+      def info_attributes
+        { key: @formula.key,
+          name: formula_name(@formula),
+          description: @formula.description,
+          homepage: @formula.homepage }
+      end
+
+      def fonts_attributes
+        { display_progress_bar: formula_progress_bar(@formula),
+          resources: @formula.resources,
+          font_collections: font_collections(@formula.fonts),
+          fonts: standalone_fonts(@formula.fonts),
+          extract: extract_type(@code) }
+      end
+
+      def license_attributes
+        { copyright: @formula.copyright,
+          license_url: @formula.license_url,
+          requires_license_agreement: requires_license_agreement(@formula),
+          open_license: open_license(@formula) }
+      end
+
+      def formula_name(formula)
+        formula.class.name.match(/Formulas::(.+)Fonts?/)[1]
+      end
+
+      def formula_progress_bar(formula)
+        formula.options&.dig(:progress_bar)
+      end
+
+      def font_collections(fonts)
+        collections = collections(fonts)
+        return if collections.empty?
+
+        collections.map do |filename, coll_fonts|
+          { filename: filename,
+            fonts: collection_fonts(coll_fonts) }
+        end
+      end
+
+      def collections(fonts)
+        fonts.select { |f| collection_font?(f) }
+          .group_by { |f| f[:styles].first[:font] }
+      end
+
+      def collection_font?(font)
+        font[:styles].first[:font].end_with?(".ttc", ".TTC")
+      end
+
+      def collection_fonts(fonts)
+        fonts.map do |f|
+          { name: f[:name], styles: collection_font_styles(f[:styles]) }
+        end
+      end
+
+      def collection_font_styles(styles)
+        styles.map do |s|
+          collection_font_style(s)
+        end
+      end
+
+      def collection_font_style(style)
+        Hash.new.tap do |h|
+          h[:type] = style[:type]
+
+          if style[:collection]
+            h[:full_name] = collection_full_name(style[:collection])
+          end
+        end
+      end
+
+      def collection_full_name(collection_label)
+        if collection_label.is_a?(Hash)
+          collection_label.values_at(:name, :style).join(" ")
+        else
+          collection_label
+        end
+      end
+
+      def standalone_fonts(fonts)
+        standalone = fonts.reject do |f|
+          collection_font?(f)
+        end
+
+        standalone.empty? ? nil : standalone
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/LineLength
+      def extract_type(code)
+        case code
+        when /def extract.+exe_extract.+cab_extract.+ppviewer\.cab/m
+          [{ format: :exe }, { format: :cab, file: "ppviewer.cab" }]
+        when /def extract.+cab_extract/m
+          { format: :cab }
+        when /def extract.+(zip_extract|unzip).+fonts_sub_dir: "(.+?)"/m
+          dir = code.match(/def extract.+(zip_extract|unzip).+fonts_sub_dir: "(.+?)"/m)[2]
+          { format: :zip, options: { fonts_sub_dir: dir } }
+        when /def extract.+(zip_extract|unzip)/m
+          { format: :zip }
+        else
+          raise NotImplementedError, "Please implement an extract format"
+        end
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/LineLength
+
+      def requires_license_agreement(formula)
+        formula.license if formula.license && formula.license_required
+      end
+
+      def open_license(formula)
+        formula.license if formula.license && !formula.license_required
+      end
+    end
+  end
+end

data/lib/fontist/import/google.rb

@@ -0,0 +1,16 @@
+module Fontist
+  module Import
+    module Google
+      def self.formula_path(name)
+        filename = name.downcase.gsub(" ", "_") + ".yml"
+        Fontist.formulas_path.join("google", filename)
+      end
+
+      def self.style_version(text)
+        return unless text
+
+        text.gsub("Version ", "")
+      end
+    end
+  end
+end

data/lib/fontist/import/google/fonts_public.md

@@ -0,0 +1,10 @@
+# How to work with Protobuf
+
+Protobuf file could be downloaded from
+https://raw.githubusercontent.com/googlefonts/gftools/master/Lib/gftools/fonts_public.proto
+
+To compile Protobuf to Ruby use
+
+```sh
+ruby-protoc lib/fontist/import/google/fonts_public.proto
+```

data/lib/fontist/import/google/fonts_public.pb.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+
+require 'protocol_buffers'
+
+module Google
+  module Fonts
+    # forward declarations
+    class FamilyProto < ::ProtocolBuffers::Message; end
+    class FontProto < ::ProtocolBuffers::Message; end
+    class AxisProto < ::ProtocolBuffers::Message; end
+    class SourceProto < ::ProtocolBuffers::Message; end
+
+    class FamilyProto < ::ProtocolBuffers::Message
+      # forward declarations
+      class ApiDefaultOverridesEntry < ::ProtocolBuffers::Message; end
+
+      set_fully_qualified_name "google.fonts.FamilyProto"
+
+      # nested messages
+      class ApiDefaultOverridesEntry < ::ProtocolBuffers::Message
+        set_fully_qualified_name "google.fonts.FamilyProto.ApiDefaultOverridesEntry"
+
+        optional :string, :key, 1
+        optional :float, :value, 2
+      end
+
+      required :string, :name, 1
+      required :string, :designer, 2
+      required :string, :license, 3
+      required :string, :category, 4
+      required :string, :date_added, 5
+      repeated ::Google::Fonts::FontProto, :fonts, 6
+      repeated :string, :aliases, 7
+      repeated :string, :subsets, 8
+      optional :string, :ttf_autohint_args, 9
+      repeated ::Google::Fonts::AxisProto, :axes, 10
+      repeated ::Google::Fonts::FamilyProto::ApiDefaultOverridesEntry, :api_default_overrides, 11
+      optional ::Google::Fonts::SourceProto, :source, 12
+    end
+
+    class FontProto < ::ProtocolBuffers::Message
+      set_fully_qualified_name "google.fonts.FontProto"
+
+      required :string, :name, 1
+      required :string, :style, 2
+      required :int32, :weight, 3
+      required :string, :filename, 4
+      required :string, :post_script_name, 5
+      required :string, :full_name, 6
+      optional :string, :copyright, 7
+    end
+
+    class AxisProto < ::ProtocolBuffers::Message
+      set_fully_qualified_name "google.fonts.AxisProto"
+
+      optional :string, :tag, 1
+      optional :float, :min_value, 2
+      optional :float, :default_value, 3
+      optional :float, :max_value, 4
+    end
+
+    class SourceProto < ::ProtocolBuffers::Message
+      set_fully_qualified_name "google.fonts.SourceProto"
+
+      optional :string, :repository_url, 1
+      optional :string, :commit, 2
+    end
+
+  end
+end

data/lib/fontist/import/google/fonts_public.proto

@@ -0,0 +1,46 @@
+syntax = "proto2";
+
+/**
+ * Open Source'd font metadata proto formats.
+ */
+package google.fonts;
+
+option java_package = "com.google.fonts.proto";
+option java_outer_classname = "FontsPublic";
+
+message FamilyProto {
+  required string name = 1;
+  required string designer = 2;
+  required string license = 3;
+  required string category = 4;
+  required string date_added = 5;
+  repeated FontProto fonts = 6;
+  repeated string aliases = 7;
+  repeated string subsets = 8;
+  optional string ttf_autohint_args = 9;
+  repeated AxisProto axes = 10;
+  map<string, float> api_default_overrides = 11;
+  optional SourceProto source = 12;
+};
+
+message FontProto {
+  required string name = 1;
+  required string style = 2;
+  required int32 weight = 3;
+  required string filename = 4;
+  required string post_script_name = 5;
+  required string full_name = 6;
+  optional string copyright = 7;
+};
+
+message AxisProto {
+  optional string tag = 1;
+  optional float min_value = 2;
+  optional float default_value = 3;
+  optional float max_value = 4;
+};
+
+message SourceProto {
+  optional string repository_url = 1;
+  optional string commit = 2;
+}

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

@@ -0,0 +1,121 @@
+require_relative "fonts_public.pb"
+require_relative "../google"
+require_relative "../otf_parser"
+
+module Fontist
+  module Import
+    module Google
+      class NewFontsFetcher
+        REPO_PATH = Fontist.root_path.join("tmp", "fonts")
+        REPO_URL = "https://github.com/google/fonts.git".freeze
+        SKIPLIST_PATH = File.expand_path("skiplist.yml", __dir__)
+
+        def initialize(logging: false)
+          @logging = logging
+        end
+
+        def call
+          update_repo
+          fetch_new_paths
+        end
+
+        private
+
+        def update_repo
+          if Dir.exist?(REPO_PATH)
+            `cd #{REPO_PATH} && git pull`
+          else
+            `git clone #{REPO_URL} #{REPO_PATH}`
+          end
+        end
+
+        def fetch_new_paths
+          fetch_fonts_paths.select do |path|
+            log_font(path) do
+              new?(path)
+            end
+          end
+        end
+
+        def fetch_fonts_paths
+          Dir[File.join(REPO_PATH, "apache", "*"),
+              File.join(REPO_PATH, "ofl", "*"),
+              File.join(REPO_PATH, "ufl", "*")].sort
+        end
+
+        def log_font(path)
+          return yield unless @logging
+
+          print "#{path}, "
+          new = yield
+          puts(new ? "new" : "skipped")
+          new
+        end
+
+        def new?(path)
+          metadata = fetch_metadata(path)
+          return unless metadata
+
+          font_new?(metadata, path)
+        end
+
+        def fetch_metadata(path)
+          metadata_path = File.join(path, "METADATA.pb")
+          return unless File.exists?(metadata_path)
+
+          ::Google::Fonts::FamilyProto.parse_from_text(File.read(metadata_path))
+        end
+
+        def font_new?(metadata, path)
+          return if in_skiplist?(metadata.name)
+          return if up_to_date?(metadata, path)
+          return unless downloadable?(metadata.name)
+
+          true
+        end
+
+        def in_skiplist?(name)
+          @skiplist ||= YAML.safe_load(File.open(SKIPLIST_PATH))
+          @skiplist.include?(name)
+        end
+
+        def up_to_date?(metadata, path)
+          formula = formula(metadata.name)
+          return false unless formula
+
+          styles = formula.fonts.map(&:styles).flatten
+
+          styles.all? do |style|
+            style.version == otfinfo_version(font_path(style.font, path))
+          end
+        end
+
+        def formula(font_name)
+          klass = font_name.gsub(/ /, "").sub(/\S/, &:upcase)
+          @formulas ||= Fontist::Formula.all
+          @formulas["Fontist::Formulas::#{klass}Font"]
+        end
+
+        def font_path(filename, directory)
+          File.join(directory, fix_variable_filename(filename))
+        end
+
+        def fix_variable_filename(filename)
+          filename.sub("-VariableFont_wght", "[wght]")
+        end
+
+        def otfinfo_version(path)
+          info = OtfParser.new(path).call
+          Fontist::Import::Google.style_version(info["Version"])
+        end
+
+        def downloadable?(name)
+          Down.open("https://fonts.google.com/download?family=#{name}")
+          true
+        rescue Down::NotFound
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+- Montserrat
+- Montserrat Alternates
+- Overpass
+- Overpass Mono
+- Lato
+- Open Sans

data/lib/fontist/import/google_check.rb

@@ -0,0 +1,34 @@
+require_relative "google/new_fonts_fetcher"
+
+module Fontist
+  module Import
+    class GoogleCheck
+      def call
+        fetch_formulas
+        fonts = new_fonts
+        indicate(fonts)
+      end
+
+      private
+
+      def fetch_formulas
+        Formulas.fetch_formulas
+      end
+
+      def new_fonts
+        Fontist::Import::Google::NewFontsFetcher.new(logging: true).call
+      end
+
+      def indicate(new_paths)
+        return if new_paths.empty?
+
+        puts "New fonts are available in:"
+        new_paths.each do |path|
+          puts path
+        end
+
+        abort
+      end
+    end
+  end
+end

data/lib/fontist/import/google_import.rb

@@ -0,0 +1,180 @@
+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"
+
+module Fontist
+  module Import
+    class GoogleImport
+      def call
+        fonts = new_fonts
+        create_formulas(fonts)
+      end
+
+      private
+
+      def new_fonts
+        Fontist::Import::Google::NewFontsFetcher.new(logging: true).call
+      end
+
+      def create_formulas(fonts)
+        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 fetch_metadata(path)
+        protobuf = File.read(File.join(path, "METADATA.pb"))
+        ::Google::Fonts::FamilyProto.parse_from_text(protobuf)
+      end
+
+      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)
+      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
+      end
+
+      def variable_style?(metadata)
+        metadata.fonts.any? do |s|
+          s.filename.match?(/\[(.+,)?wght\]/)
+        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
+        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.slice(:post_script_name,
+                                    :version,
+                                    :description,
+                                    :copyright).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))
+      end
+    end
+  end
+end