fontist 1.2.1 → 1.6.0

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,91 @@
+require_relative "../otfinfo/otfinfo_requirement"
+require_relative "../text_helper"
+
+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].freeze
+        COLLECTION_ATTRIBUTES = STYLE_ATTRIBUTES.reject { |a| a == :font }
+
+        attr_reader :path
+
+        def initialize(path)
+          @path = path
+          @info = read
+        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)
+        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
+      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

data/lib/fontist/import/recursive_extraction.rb

@@ -0,0 +1,128 @@
+require "find"
+require_relative "extractors"
+
+module Fontist
+  module Import
+    class RecursiveExtraction
+      BOTH_FONTS_PATTERN = "**/*.{ttf,otf,ttc}*".freeze
+      ARCHIVE_EXTENSIONS = %w[zip msi exe cab].freeze
+
+      def initialize(archive, subarchive: nil)
+        @archive = archive
+        @subarchive = subarchive
+        @operations = []
+      end
+
+      def extension
+        File.extname(filename(@archive)).sub(/^\./, "")
+      end
+
+      def extract(pattern)
+        Array.new.tap do |results|
+          Find.find(extracted_path) do |path| # rubocop:disable Style/CollectionMethods, Metrics/LineLength
+            results << yield(path) if path.match(pattern)
+          end
+        end
+      end
+
+      def operations
+        ensure_extracted
+        @operations.size == 1 ? @operations.first : @operations
+      end
+
+      private
+
+      def filename(file)
+        if file.respond_to?(:original_filename)
+          file.original_filename
+        else
+          File.basename(file)
+        end
+      end
+
+      def ensure_extracted
+        extracted_path
+      end
+
+      def extracted_path
+        @extracted_path ||= extract_recursively(@archive)
+      end
+
+      def extract_recursively(archive)
+        path = operate_on_archive(archive)
+        return path if fonts_exist?(path)
+
+        next_archive = find_archive(path)
+        extract_recursively(next_archive)
+      end
+
+      def operate_on_archive(archive)
+        extractor = choose_extractor(archive)
+        Fontist.ui.say("Extracting #{archive} with #{extractor.class.name}")
+
+        save_operation(extractor)
+        extractor.extract
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def choose_extractor(archive)
+        case filename(archive)
+        when /\.msi$/i
+          Extractors::OleExtractor.new(archive)
+        when /\.cab$/i
+          Extractors::CabExtractor.new(archive)
+        when /\.exe$/i
+          extractor = Extractors::SevenZipExtractor.new(archive)
+          extractor.try ? extractor : Extractors::CabExtractor.new(archive)
+        else
+          Extractors::ZipExtractor.new(archive)
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def save_operation(extractor)
+        @operations << { format: extractor.format }
+      end
+
+      def fonts_exist?(path)
+        fonts = Dir.glob(File.join(path, BOTH_FONTS_PATTERN))
+        !fonts.empty?
+      end
+
+      def find_archive(path)
+        paths = Dir.children(path).map { |file| File.join(path, file) }
+        by_subarchive(paths) || by_size(paths)
+      end
+
+      def by_subarchive(paths)
+        return unless @subarchive
+
+        path_found = paths.detect do |path|
+          @subarchive == File.basename(path)
+        end
+
+        return unless path_found
+
+        save_operation_subarchive(path_found)
+
+        path_found
+      end
+
+      def save_operation_subarchive(path)
+        @operations.last[:options] ||= {}
+        @operations.last[:options][:subarchive] = File.basename(path)
+      end
+
+      def by_size(paths)
+        paths.max_by do |path|
+          [file_type(path), File.size(path)]
+        end
+      end
+
+      def file_type(file_path)
+        extension = File.extname(file_path).delete(".")
+        ARCHIVE_EXTENSIONS.include?(extension) ? 1 : 0
+      end
+    end
+  end
+end

data/lib/fontist/import/template_helper.rb

@@ -0,0 +1,19 @@
+module Fontist
+  module Import
+    module TemplateHelper
+      class << self
+        def bind(resource, name = nil)
+          b = binding
+          b.local_variable_set(name, resource) if name
+          b
+        end
+
+        def escape_double_quotes(text)
+          text.gsub('"', '\"')
+        end
+
+        alias esc escape_double_quotes
+      end
+    end
+  end
+end

data/lib/fontist/import/text_helper.rb

@@ -0,0 +1,30 @@
+module Fontist
+  module Import
+    module TextHelper
+      class << self
+        def cleanup(text)
+          return unless text
+
+          text.gsub("\r\n", "\n")
+            .gsub("\r", "\n")
+            .strip
+            .lines
+            .map(&:rstrip)
+            .drop_while(&:empty?)
+            .join("\n")
+        end
+
+        def longest_common_prefix(strs)
+          return if strs.empty?
+
+          min, max = strs.minmax
+          idx = min.size.times { |i| break i if min[i] != max[i] }
+          prefix = min[0...idx].strip
+          return if prefix.empty?
+
+          prefix
+        end
+      end
+    end
+  end
+end