fontist 1.8.6 → 1.8.11

data/lib/fontist/import/extractors.rb

@@ -1,9 +0,0 @@
-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"
-require_relative "extractors/rpm_extractor"
-require_relative "extractors/gzip_extractor"
-require_relative "extractors/cpio_extractor"
-require_relative "extractors/tar_extractor"

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

@@ -1,37 +0,0 @@
-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/cpio_extractor.rb

@@ -1,39 +0,0 @@
-module Fontist
-  module Import
-    module Extractors
-      class CpioExtractor < Extractor
-        def extract
-          dir = Dir.mktmpdir
-          extract_cpio(@archive, dir)
-          dir
-        end
-
-        def format
-          "cpio"
-        end
-
-        private
-
-        def extract_cpio(archive, dir)
-          archive_file = File.open(archive, "rb")
-
-          reader_class.new(archive_file).each do |entry, file|
-            path = File.join(dir, entry.name)
-            if entry.directory?
-              FileUtils.mkdir_p(path)
-            else
-              File.write(path, file.read)
-            end
-          end
-        end
-
-        def reader_class
-          @reader_class ||= begin
-                              require "fontist/utils/cpio/cpio"
-                              CPIO::ASCIIReader
-                            end
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-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/gzip_extractor.rb

@@ -1,27 +0,0 @@
-module Fontist
-  module Import
-    module Extractors
-      class GzipExtractor < Extractor
-        def extract
-          dir = Dir.mktmpdir
-          extract_gzip(@archive, dir)
-          dir
-        end
-
-        def format
-          "gzip"
-        end
-
-        private
-
-        def extract_gzip(archive, dir)
-          Zlib::GzipReader.open(archive) do |gz|
-            basename = File.basename(archive, ".*")
-            path = File.join(dir, basename)
-            File.write(path, gz.read)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-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/rpm_extractor.rb

@@ -1,45 +0,0 @@
-module Fontist
-  module Import
-    module Extractors
-      class RpmExtractor < Extractor
-        def extract
-          dir = Dir.mktmpdir
-          extract_rpm(@archive, dir)
-          dir
-        end
-
-        def format
-          "rpm"
-        end
-
-        private
-
-        def extract_rpm(archive, dir)
-          file = File.open(archive, "rb")
-          rpm = rpm_class.new(file)
-          content = rpm.payload.read
-          path = target_path(archive, rpm.tags, dir)
-
-          File.write(path, content)
-        ensure
-          file.close
-        end
-
-        def rpm_class
-          @rpm_class ||= begin
-                              require "arr-pm"
-                              RPM::File
-                            end
-        end
-
-        def target_path(archive, tags, dir)
-          archive_format = tags[:payloadformat]
-          compression_format = tags[:payloadcompressor] == "gzip" ? "gz" : tags[:payloadcompressor]
-          basename = File.basename(archive, ".*")
-          filename = basename + "." + archive_format + "." + compression_format
-          File.join(dir, filename)
-        end
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-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/tar_extractor.rb

@@ -1,47 +0,0 @@
-module Fontist
-  module Import
-    module Extractors
-      class TarExtractor < Extractor
-        def extract
-          dir = Dir.mktmpdir
-          extract_tar(@archive, dir)
-          dir
-        end
-
-        def format
-          "tar"
-        end
-
-        private
-
-        def extract_tar(archive, dir)
-          archive_file = File.open(archive, "rb")
-          reader_class.new(archive_file) do |tar|
-            tar.each do |tarfile|
-              save_tar_file(tarfile, dir)
-            end
-          end
-        end
-
-        def reader_class
-          @reader_class ||= begin
-                              require "rubygems/package"
-                              Gem::Package::TarReader
-                            end
-        end
-
-        def save_tar_file(file, dir)
-          path = File.join(dir, file.full_name)
-
-          if file.directory?
-            FileUtils.mkdir_p(path)
-          else
-            File.open(path, "wb") do |f|
-              f.print(file.read)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-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/utils/cpio/cpio.rb

@@ -1,199 +0,0 @@
-# code is obtained from https://github.com/jordansissel/ruby-arr-pm/blob/8071591173ebb90dea27d5acfdde69a37dcb2744/cpio.rb
-# rubocop:disable all
-class BoundedIO
-  attr_reader :length
-  attr_reader :remaining
-
-  def initialize(io, length, &eof_callback)
-    @io = io
-    @length = length
-    @remaining = length
-
-    @eof_callback = eof_callback
-    @eof = false
-  end
-
-  def read(size=nil)
-    return nil if eof?
-    size = @remaining if size.nil?
-    data = @io.read(size)
-    @remaining -= data.bytesize
-    eof?
-    data
-  end
-
-  def sysread(size)
-    raise EOFError, "end of file reached" if eof?
-    read(size)
-  end
-
-  def eof?
-    return false if @remaining > 0
-    return @eof if @eof
-
-    @eof_callback.call
-    @eof = true
-  end
-end
-
-module CPIO
-  FIELDS = [
-    :magic, :ino, :mode, :uid, :gid, :nlink, :mtime, :filesize, :devmajor,
-    :devminor, :rdevmajor, :rdevminor, :namesize, :check
-  ]
-end
-
-class CPIO::ASCIIReader
-  FIELD_SIZES = {
-    :magic => 6,
-    :ino => 8,
-    :mode => 8,
-    :uid => 8,
-    :gid => 8,
-    :nlink => 8,
-    :mtime => 8,
-    :filesize => 8,
-    :devmajor => 8,
-    :devminor => 8,
-    :rdevmajor => 8,
-    :rdevminor => 8,
-    :namesize => 8,
-    :check => 8
-  }
-  HEADER_LENGTH = FIELD_SIZES.reduce(0) { |m, (_, v)| m + v }
-  HEADER_PACK = FIELD_SIZES.collect { |_, v| "A#{v}" }.join
-
-  FIELD_ORDER = [
-    :magic, :ino, :mode, :uid, :gid, :nlink, :mtime, :filesize, :devmajor,
-    :devminor, :rdevmajor, :rdevminor, :namesize, :check
-  ]
-
-  def initialize(io)
-    @io = io
-  end
-
-  private
-
-  def io
-    @io
-  end
-
-  def each(&block)
-    while true
-      entry = read
-      break if entry.nil?
-      # The CPIO format has the end-of-stream marker as a file called "TRAILER!!!"
-      break if entry.name == "TRAILER!!!"
-      block.call(entry, entry.file)
-      verify_correct_read(entry) unless entry.directory?
-    end
-  end
-
-  def verify_correct_read(entry)
-    # Read and throw away the whole file if not read at all.
-    entry.file.tap do |file|
-      if file.nil? ||  file.remaining == 0
-        # All OK! :)
-      elsif file.remaining == file.length
-        file.read(16384) while !file.eof?
-      else
-        # The file was only partially read? This should be an error by the
-        # user.
-        consumed = file.length - file.remaining
-        raise BadState, "Only #{consumed} bytes were read of the #{file.length} byte file: #{entry.name}"
-      end
-    end
-  end
-
-  def read
-    entry = CPIOEntry.new
-    header = io.read(HEADER_LENGTH)
-    return nil if header.nil?
-    FIELD_ORDER.zip(header.unpack(HEADER_PACK)).each do |field, value|
-      entry.send("#{field}=", value.to_i(16))
-    end
-
-    entry.validate
-    entry.mtime = Time.at(entry.mtime)
-    read_name(entry, @io)
-    read_file(entry, @io)
-    entry
-  end
-
-  def read_name(entry, io)
-    entry.name = io.read(entry.namesize - 1) # - 1 for null terminator
-    nul = io.read(1)
-    raise ArgumentError, "Corrupt CPIO or bug? Name null terminator was not null: #{nul.inspect}" if nul != "\0"
-    padding_data = io.read(padding_name(entry))
-    # Padding should be all null bytes
-    if padding_data != ("\0" * padding_data.bytesize)
-      raise ArgumentError, "Corrupt CPIO or bug? Name null padding was #{padding_name(entry)} bytes: #{padding_data.inspect}"
-    end
-  end
-
-  def read_file(entry, io)
-    if entry.directory?
-      entry.file = nil
-      #read_file_padding(entry, io)
-      nil
-    else
-      entry.file = BoundedIO.new(io, entry.filesize) do
-        read_file_padding(entry, io)
-      end
-    end
-  end
-
-  def read_file_padding(entry, io)
-    padding_data = io.read(padding_file(entry))
-    if padding_data != ("\0" * padding_data.bytesize)
-      raise ArgumentError, "Corrupt CPIO or bug? File null padding was #{padding_file(entry)} bytes: #{padding_data.inspect}"
-    end
-  end
-
-  def padding_name(entry)
-    # name padding is padding up to a multiple of 4 after header+namesize
-    -(HEADER_LENGTH + entry.namesize) % 4
-  end
-
-  def padding_file(entry)
-    (-(HEADER_LENGTH + entry.filesize + 2) % 4)
-  end
-  public(:each)
-end
-
-class CPIOEntry
-  CPIO::FIELDS.each do |field|
-    attr_accessor field
-  end
-
-  attr_accessor :name
-  attr_accessor :file
-
-  DIRECTORY_FLAG = 0040000
-
-  def validate
-    raise "Invalid magic #{magic.inspect}" if magic != 0x070701
-    raise "Invalid ino #{ino.inspect}" if ino < 0
-    raise "Invalid mode #{mode.inspect}" if mode < 0
-    raise "Invalid uid #{uid.inspect}" if uid < 0
-    raise "Invalid gid #{gid.inspect}" if gid < 0
-    raise "Invalid nlink #{nlink.inspect}" if nlink < 0
-    raise "Invalid mtime #{mtime.inspect}" if mtime < 0
-    raise "Invalid filesize #{filesize.inspect}" if filesize < 0
-    raise "Invalid devmajor #{devmajor.inspect}" if devmajor < 0
-    raise "Invalid devminor #{devminor.inspect}" if devminor < 0
-    raise "Invalid rdevmajor #{rdevmajor.inspect}" if rdevmajor < 0
-    raise "Invalid rdevminor #{rdevminor.inspect}" if rdevminor < 0
-    raise "Invalid namesize #{namesize.inspect}" if namesize < 0
-    raise "Invalid check #{check.inspect}" if check < 0
-  end # def validate
-
-  def read(*args)
-    return nil if directory?
-    file.read(*args)
-  end
-
-  def directory?
-    mode & DIRECTORY_FLAG > 0
-  end
-end