fontist 1.3.0 → 1.7.0

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

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

@@ -0,0 +1,13 @@
+module Fontist
+  module Import
+    module Helpers
+      module HashHelper
+        class << self
+          def stringify_keys(hash)
+            JSON.parse(hash.to_json)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Fontist
+  module Import
+    module Helpers
+      module SystemHelper
+        class << self
+          def run(command)
+            unless ENV.fetch("TEST_ENV", "") === "CI"
+              Fontist.ui.say("Run `#{command}`")
+            end
+
+            result = `#{command}`
+            unless $CHILD_STATUS.to_i.zero?
+              raise Errors::BinaryCallError,
+                    "Failed to run #{command}, status: #{$CHILD_STATUS}"
+            end
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+require_relative "../otfinfo/otfinfo_requirement"
+require_relative "../text_helper"
+require_relative "../files/font_detector"
+
+module Fontist
+  module Import
+    module Otf
+      class FontFile
+        REQUIREMENTS = {
+          otfinfo: Otfinfo::OtfinfoRequirement.new,
+        }.freeze
+
+        STYLE_ATTRIBUTES = %i[family_name type full_name post_script_name
+                              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
+          STYLE_ATTRIBUTES.map { |name| [name, send(name)] }.to_h.compact
+        end
+
+        def to_collection_style
+          COLLECTION_ATTRIBUTES.map { |name| [name, send(name)] }.to_h.compact
+        end
+
+        def family_name
+          info["Preferred family"] || info["Family"]
+        end
+
+        def type
+          info["Preferred subfamily"] || info["Subfamily"]
+        end
+
+        def full_name
+          info["Full name"]
+        end
+
+        def post_script_name
+          info["PostScript name"]
+        end
+
+        def version
+          return unless info["Version"]
+
+          info["Version"].gsub("Version ", "")
+        end
+
+        def description
+          info["Description"]
+        end
+
+        def font
+          File.basename(@path, ".*") + "." + @extension
+        end
+
+        def source_font
+          File.basename(@path) unless font == File.basename(@path)
+        end
+
+        def copyright
+          info["Copyright"]
+        end
+
+        def homepage
+          info["Vendor URL"]
+        end
+
+        def license_url
+          info["License URL"]
+        end
+
+        private
+
+        attr_reader :info
+
+        def read
+          text = REQUIREMENTS[:otfinfo].call(@path)
+
+          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
+end

data/lib/fontist/import/otf_parser.rb

@@ -0,0 +1,25 @@
+require_relative "otfinfo/otfinfo_requirement"
+require_relative "text_helper"
+
+module Fontist
+  module Import
+    class OtfParser
+      REQUIREMENTS = {
+        otfinfo: Fontist::Import::Otfinfo::OtfinfoRequirement.new,
+      }.freeze
+
+      def initialize(path)
+        @path = path
+      end
+
+      def call
+        text = REQUIREMENTS[:otfinfo].call(@path)
+        text.split("\n")
+          .select { |x| x.include?(":") }
+          .map { |x| x.split(":", 2) }
+          .map { |x| x.map { |y| Fontist::Import::TextHelper.cleanup(y) } }
+          .to_h
+      end
+    end
+  end
+end

data/lib/fontist/import/otf_style.rb

@@ -0,0 +1,29 @@
+module Fontist
+  module Import
+    class OtfStyle
+      def initialize(info, path)
+        @info = info
+        @path = path
+      end
+
+      def call
+        style = { family_name: @info["Preferred family"] || @info["Family"],
+                  style: @info["Preferred subfamily"] || @info["Subfamily"],
+                  full_name: @info["Full name"],
+                  post_script_name: @info["PostScript name"],
+                  version: version(@info["Version"]),
+                  description: @info["Description"],
+                  filename: File.basename(@path),
+                  copyright: @info["Copyright"] }
+
+        OpenStruct.new(style)
+      end
+
+      private
+
+      def version(text)
+        Fontist::Import::Google.style_version(text)
+      end
+    end
+  end
+end

data/lib/fontist/import/otfinfo/otfinfo_requirement.rb

@@ -0,0 +1,22 @@
+require "fontist/import/helpers/system_helper"
+
+module Fontist
+  module Import
+    module Otfinfo
+      class OtfinfoRequirement
+        def initialize
+          otfinfo_path = `which otfinfo`
+          if otfinfo_path.empty?
+            abort "otfinfo is not available. (Or is PATH not setup properly?)"\
+              " You must install otfinfo."\
+              " On macOS it can be installed via `brew install lcdf-typetools`."
+          end
+        end
+
+        def call(path)
+          Helpers::SystemHelper.run("otfinfo --info '#{path}'")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+        <%- resource.each do |s| -%>
+          {
+            family_name: "<%= s.family_name %>",
+            style: "<%= s.style %>",
+            full_name: "<%= s.full_name %>",
+            <%- if s.post_script_name -%>
+            post_script_name: "<%= s.post_script_name %>",
+            <%- end -%>
+            <%- if s.version -%>
+            version: "<%= esc(s.version) %>",
+            <%- end -%>
+            <%- if s.description -%>
+            description: "<%= esc(s.description) %>",
+            <%- end -%>
+            filename: "<%= s.filename %>",
+            <%- if s.copyright -%>
+            copyright: "<%= esc(s.copyright) %>",
+            <%- end -%>
+          },
+        <%- end -%>

data/lib/fontist/import/otfinfo_generate.rb

@@ -0,0 +1,45 @@
+require "erb"
+require_relative "template_helper"
+require_relative "text_helper"
+require_relative "otf_parser"
+require_relative "otf_style"
+
+module Fontist
+  module Import
+    class OtfinfoGenerate
+      TEMPLATE_PATH = File.expand_path("otfinfo/template.erb", __dir__)
+
+      def initialize(font)
+        @font = font
+      end
+
+      def call
+        paths = font_paths(@font)
+        puts paths
+        styles = generate_styles(paths)
+        puts render(styles)
+      end
+
+      private
+
+      def font_paths(font)
+        formula = Fontist::Formula.find(font)
+        font_formula = Object.const_get(formula.installer)
+        font_formula.fetch_font(nil, confirmation: "yes")
+      end
+
+      def generate_styles(paths)
+        paths.map do |path|
+          info = OtfParser.new(path).call
+          OtfStyle.new(info, path).call
+        end
+      end
+
+      def render(styles)
+        template = File.read(TEMPLATE_PATH)
+        renderer = ERB.new(template, trim_mode: "-")
+        renderer.result(Fontist::Import::TemplateHelper.bind(styles))
+      end
+    end
+  end
+end