fontist 1.3.0 → 1.4.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,48 @@
+require "fontist/import/helpers/system_helper"
+require_relative "../otf/font_file"
+
+module Fontist
+  module Import
+    module Files
+      class CollectionFile
+        STRIP_TTC_BINARY = Fontist.root_path.join("bin", "stripttc")
+
+        attr_reader :fonts
+
+        def initialize(path)
+          @path = path
+          @fonts = read
+        end
+
+        def 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)
+          Helpers::SystemHelper.run("#{STRIP_TTC_BINARY} #{@path}")
+
+          basename = File.basename(@path, ".ttc")
+          Dir.glob(File.join(tmp_dir, "#{basename}_[0-9][0-9].ttf"))
+        end
+      end
+    end
+  end
+end

data/lib/fontist/import/formula_builder.rb

@@ -0,0 +1,115 @@
+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 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
+
+        options = { urls: [@url] + (@options[:mirror] || []),
+                    sha256: Digest::SHA256.file(@archive).to_s }
+
+        { filename => options }
+      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, fonts: fonts }
+        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
+        return unless @license_text
+
+        TextHelper.cleanup(@license_text)
+      end
+    end
+  end
+end

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