fontist 1.3.0 → 1.7.0

data/lib/fontist/import/extractors.rb

@@ -0,0 +1,5 @@
+require_relative "extractors/extractor"
+require_relative "extractors/zip_extractor"
+require_relative "extractors/ole_extractor"
+require_relative "extractors/seven_zip_extractor"
+require_relative "extractors/cab_extractor"

data/lib/fontist/import/extractors/cab_extractor.rb

@@ -0,0 +1,37 @@
+module Fontist
+  module Import
+    module Extractors
+      class CabExtractor < Extractor
+        def extract
+          dir = Dir.mktmpdir
+          extract_exe(@archive, dir)
+          dir
+        end
+
+        def format
+          File.extname(@archive) == ".exe" ? "exe" : "cab"
+        end
+
+        private
+
+        def extract_exe(archive, dir)
+          opened = decompressor.search(archive)
+          file = opened.files
+
+          while file
+            path = File.join(dir, file.filename)
+            decompressor.extract(file, path)
+            file = file.next
+          end
+        end
+
+        def decompressor
+          @decompressor ||= begin
+                              require "libmspack"
+                              LibMsPack::CabDecompressor.new
+                            end
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/extractors/extractor.rb

@@ -0,0 +1,19 @@
+module Fontist
+  module Import
+    module Extractors
+      class Extractor
+        def initialize(archive)
+          @archive = archive
+        end
+
+        def extract
+          raise NotImplementedError.new("You must implement this method")
+        end
+
+        def format
+          raise NotImplementedError.new("You must implement this method")
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/extractors/ole_extractor.rb

@@ -0,0 +1,41 @@
+module Fontist
+  module Import
+    module Extractors
+      class OleExtractor < Extractor
+        def extract
+          dir = Dir.mktmpdir
+          extract_ole(@archive, dir)
+          dir
+        end
+
+        def format
+          "msi"
+        end
+
+        private
+
+        def extract_ole(archive, dir)
+          ole = storage.open(archive)
+          file = the_largest_file(ole)
+
+          content = ole.file.read(file)
+          path = File.join(dir, "data.cab")
+          File.open(path, "wb") { |f| f.write(content) }
+        end
+
+        def storage
+          @storage ||= begin
+                         require "ole/storage"
+                         Ole::Storage
+                       end
+        end
+
+        def the_largest_file(ole)
+          ole.dir.entries(".").max_by do |x|
+            ole.file.size(x)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/extractors/seven_zip_extractor.rb

@@ -0,0 +1,44 @@
+module Fontist
+  module Import
+    module Extractors
+      class SevenZipExtractor < Extractor
+        def extract
+          dir = Dir.mktmpdir
+          extract_7z(@archive, dir)
+          dir
+        end
+
+        def try
+          File.open(@archive, "rb") do |file|
+            reader.open(file)
+          end
+
+          true
+        rescue StandardError => e
+          return false if e.message.start_with?("Invalid file format")
+
+          raise
+        end
+
+        def format
+          "seven_zip"
+        end
+
+        private
+
+        def extract_7z(archive, dir)
+          File.open(archive, "rb") do |file|
+            reader.extract_all(file, dir)
+          end
+        end
+
+        def reader
+          @reader ||= begin
+                        require "seven_zip_ruby"
+                        SevenZipRuby::Reader
+                      end
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/extractors/zip_extractor.rb

@@ -0,0 +1,31 @@
+require "zip"
+
+module Fontist
+  module Import
+    module Extractors
+      class ZipExtractor < Extractor
+        def extract
+          dir = Dir.mktmpdir
+          extract_zip(@archive, dir)
+          dir
+        end
+
+        def format
+          "zip"
+        end
+
+        private
+
+        def extract_zip(archive, dir)
+          Zip::File.open(archive) do |zip_file|
+            zip_file.each do |entry|
+              path = File.join(dir, entry.name)
+              FileUtils.mkdir_p(File.dirname(path))
+              entry.extract(path)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/files/collection_file.rb

@@ -0,0 +1,52 @@
+require "extract_ttc"
+require "fontist/import/helpers/system_helper"
+require_relative "../otf/font_file"
+
+module Fontist
+  module Import
+    module Files
+      class CollectionFile
+        attr_reader :fonts
+
+        def initialize(path)
+          @path = path
+          @fonts = read
+          @extension = "ttc"
+        end
+
+        def filename
+          File.basename(@path, ".*") + "." + @extension
+        end
+
+        def source_filename
+          File.basename(@path) unless filename == File.basename(@path)
+        end
+
+        private
+
+        def read
+          switch_to_temp_dir do |tmp_dir|
+            extract_ttfs(tmp_dir).map do |path|
+              Otf::FontFile.new(path)
+            end
+          end
+        end
+
+        def switch_to_temp_dir
+          Dir.mktmpdir do |tmp_dir|
+            Dir.chdir(tmp_dir) do
+              yield tmp_dir
+            end
+          end
+        end
+
+        def extract_ttfs(tmp_dir)
+          filenames = ExtractTtc.extract(@path)
+          filenames.map do |filename|
+            File.join(tmp_dir, filename)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/files/file_requirement.rb

@@ -0,0 +1,17 @@
+module Fontist
+  module Import
+    module Files
+      class FileRequirement
+        def initialize
+          `file -v`
+        rescue Errno::ENOENT
+          abort "`file` is not available. (Or is PATH not setup properly?)"
+        end
+
+        def call(path)
+          Helpers::SystemHelper.run("file --brief '#{path}'")
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/files/font_detector.rb

@@ -0,0 +1,48 @@
+require_relative "file_requirement"
+
+module Fontist
+  module Import
+    module Files
+      class FontDetector
+        REQUIREMENTS = { file: FileRequirement.new }.freeze
+
+        FONT_LABELS = ["OpenType font data",
+                       "TrueType Font data"].freeze
+
+        COLLECTION_LABEL = "TrueType font collection data".freeze
+
+        FONT_EXTENSIONS = {
+          "OpenType font data" => "otf",
+          "TrueType Font data" => "ttf",
+          "TrueType font collection data" => "ttc",
+        }.freeze
+
+        def self.detect(path)
+          brief = file_brief(path)
+
+          if brief.start_with?(*FONT_LABELS)
+            :font
+          elsif brief.start_with?(COLLECTION_LABEL)
+            :collection
+          else
+            :other
+          end
+        end
+
+        def self.standard_extension(path)
+          brief = file_brief(path)
+
+          FONT_EXTENSIONS.each do |label, extension|
+            return extension if brief.start_with?(label)
+          end
+
+          raise Errors::UnknownFontTypeError.new(path)
+        end
+
+        def self.file_brief(path)
+          REQUIREMENTS[:file].call(path)
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/formula_builder.rb

@@ -0,0 +1,166 @@
+require_relative "text_helper"
+
+module Fontist
+  module Import
+    class FormulaBuilder
+      FORMULA_ATTRIBUTES = %i[name description homepage resources
+                              font_collections fonts extract copyright
+                              license_url open_license].freeze
+
+      attr_accessor :archive,
+                    :url,
+                    :extractor,
+                    :options,
+                    :font_files,
+                    :font_collection_files,
+                    :license_text
+
+      def initialize
+        @options = {}
+      end
+
+      def formula
+        FORMULA_ATTRIBUTES.map { |name| [name, send(name)] }.to_h.compact
+      end
+
+      private
+
+      def name
+        return options[:name] if options[:name]
+
+        unique_names = both_fonts.map(&:family_name).uniq
+        TextHelper.longest_common_prefix(unique_names) ||
+          both_fonts.first.family_name
+      end
+
+      def both_fonts
+        @both_fonts ||= group_fonts
+      end
+
+      def group_fonts
+        files = (@font_files + @font_collection_files.map(&:fonts)).flatten
+        raise Errors::FontNotFoundError, "No font found" if files.empty?
+
+        files
+      end
+
+      def description
+        name
+      end
+
+      def homepage
+        both_fonts.first.homepage
+      end
+
+      def resources
+        filename = name.gsub(" ", "_") + "." + @extractor.extension
+
+        { filename => resource_options }
+      end
+
+      def resource_options
+        urls = []
+        sha = []
+        downloads do |url, path|
+          urls << url
+          sha << Digest::SHA256.file(path).to_s
+        end
+
+        sha = prepare_sha256(sha)
+
+        { urls: urls, sha256: sha }
+      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 font_collections
+        return if @font_collection_files.empty?
+
+        collections = @font_collection_files.map do |file|
+          fonts = fonts_from_files(file.fonts, :to_collection_style)
+
+          { filename: file.filename,
+            source_filename: file.source_filename,
+            fonts: fonts }.compact
+        end
+
+        collections.sort_by do |x|
+          x[:filename]
+        end
+      end
+
+      def fonts
+        return if @font_files.empty?
+
+        fonts_from_files(@font_files, :to_style)
+      end
+
+      def fonts_from_files(files, style_type = :to_style)
+        groups = files.group_by(&:family_name)
+
+        fonts = groups.map do |name, group|
+          { name: name,
+            styles: group.map(&style_type) }
+        end
+
+        fonts.sort_by do |x|
+          x[:name]
+        end
+      end
+
+      def extract
+        @extractor.operations
+      end
+
+      def copyright
+        both_fonts.first.copyright
+      end
+
+      def license_url
+        both_fonts.first.license_url
+      end
+
+      def open_license
+        unless @license_text
+          Fontist.ui.error("WARN: please add license manually")
+          return
+        end
+
+        Fontist.ui.error("WARN: ensure it's an open license, otherwise " \
+                         "change the 'open_license' attribute to " \
+                         "'requires_license_agreement'")
+
+        TextHelper.cleanup(@license_text)
+      end
+    end
+  end
+end