hotplate 0.1.1 → 1.0.0

data/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/central_directory.rb

@@ -1,208 +0,0 @@
-module Zip
-  class CentralDirectory
-    include Enumerable
-
-    END_OF_CDS             = 0x06054b50
-    ZIP64_END_OF_CDS       = 0x06064b50
-    ZIP64_EOCD_LOCATOR     = 0x07064b50
-    MAX_END_OF_CDS_SIZE    = 65536 + 18
-    STATIC_EOCD_SIZE       = 22
-
-    attr_reader :comment
-
-    # Returns an Enumerable containing the entries.
-    def entries
-      @entry_set.entries
-    end
-
-    def initialize(entries = EntrySet.new, comment = '') #:nodoc:
-      super()
-      @entry_set = entries.kind_of?(EntrySet) ? entries : EntrySet.new(entries)
-      @comment   = comment
-    end
-
-    def write_to_stream(io) #:nodoc:
-      cdir_offset = io.tell
-      @entry_set.each { |entry| entry.write_c_dir_entry(io) }
-      eocd_offset = io.tell
-      cdir_size = eocd_offset - cdir_offset
-      if ::Zip.write_zip64_support
-        need_zip64_eocd = cdir_offset > 0xFFFFFFFF || cdir_size > 0xFFFFFFFF || @entry_set.size > 0xFFFF
-        need_zip64_eocd ||= @entry_set.any? { |entry| entry.extra['Zip64'] }
-        if need_zip64_eocd
-          write_64_e_o_c_d(io, cdir_offset, cdir_size)
-          write_64_eocd_locator(io, eocd_offset)
-        end
-      end
-      write_e_o_c_d(io, cdir_offset, cdir_size)
-    end
-
-    def write_e_o_c_d(io, offset, cdir_size) #:nodoc:
-      tmp = [
-        END_OF_CDS,
-        0, # @numberOfThisDisk
-        0, # @numberOfDiskWithStartOfCDir
-        @entry_set ? [@entry_set.size, 0xFFFF].min : 0,
-        @entry_set ? [@entry_set.size, 0xFFFF].min : 0,
-        [cdir_size, 0xFFFFFFFF].min,
-        [offset, 0xFFFFFFFF].min,
-        @comment ? @comment.bytesize : 0
-      ]
-      io << tmp.pack('VvvvvVVv')
-      io << @comment
-    end
-
-    private :write_e_o_c_d
-
-    def write_64_e_o_c_d(io, offset, cdir_size) #:nodoc:
-      tmp = [
-        ZIP64_END_OF_CDS,
-        44, # size of zip64 end of central directory record (excludes signature and field itself)
-        VERSION_MADE_BY,
-        VERSION_NEEDED_TO_EXTRACT_ZIP64,
-        0, # @numberOfThisDisk
-        0, # @numberOfDiskWithStartOfCDir
-        @entry_set ? @entry_set.size : 0, # number of entries on this disk
-        @entry_set ? @entry_set.size : 0, # number of entries total
-        cdir_size, # size of central directory
-        offset, # offset of start of central directory in its disk
-      ]
-      io << tmp.pack('VQ<vvVVQ<Q<Q<Q<')
-    end
-
-    private :write_64_e_o_c_d
-
-    def write_64_eocd_locator(io, zip64_eocd_offset)
-      tmp = [
-        ZIP64_EOCD_LOCATOR,
-        0, # number of disk containing the start of zip64 eocd record
-        zip64_eocd_offset, # offset of the start of zip64 eocd record in its disk
-        1 # total number of disks
-      ]
-      io << tmp.pack('VVQ<V')
-    end
-
-    private :write_64_eocd_locator
-
-    def read_64_e_o_c_d(buf) #:nodoc:
-      buf                                           = get_64_e_o_c_d(buf)
-      @size_of_zip64_e_o_c_d                        = Entry.read_zip_64_long(buf)
-      @version_made_by                              = Entry.read_zip_short(buf)
-      @version_needed_for_extract                   = Entry.read_zip_short(buf)
-      @number_of_this_disk                          = Entry.read_zip_long(buf)
-      @number_of_disk_with_start_of_cdir            = Entry.read_zip_long(buf)
-      @total_number_of_entries_in_cdir_on_this_disk = Entry.read_zip_64_long(buf)
-      @size                                         = Entry.read_zip_64_long(buf)
-      @size_in_bytes                                = Entry.read_zip_64_long(buf)
-      @cdir_offset                                  = Entry.read_zip_64_long(buf)
-      @zip_64_extensible                            = buf.slice!(0, buf.bytesize)
-      raise Error, "Zip consistency problem while reading eocd structure" unless buf.size == 0
-    end
-
-    def read_e_o_c_d(buf) #:nodoc:
-      buf                                           = get_e_o_c_d(buf)
-      @number_of_this_disk                          = Entry.read_zip_short(buf)
-      @number_of_disk_with_start_of_cdir            = Entry.read_zip_short(buf)
-      @total_number_of_entries_in_cdir_on_this_disk = Entry.read_zip_short(buf)
-      @size                                         = Entry.read_zip_short(buf)
-      @size_in_bytes                                = Entry.read_zip_long(buf)
-      @cdir_offset                                  = Entry.read_zip_long(buf)
-      comment_length                                = Entry.read_zip_short(buf)
-      @comment                                      = if comment_length.to_i <= 0
-                                                        buf.slice!(0, buf.size)
-                                                      else
-                                                        buf.read(comment_length)
-                                                      end
-      raise Error, "Zip consistency problem while reading eocd structure" unless buf.size == 0
-    end
-
-    def read_central_directory_entries(io) #:nodoc:
-      begin
-        io.seek(@cdir_offset, IO::SEEK_SET)
-      rescue Errno::EINVAL
-        raise Error, "Zip consistency problem while reading central directory entry"
-      end
-      @entry_set = EntrySet.new
-      @size.times do
-        @entry_set << Entry.read_c_dir_entry(io)
-      end
-    end
-
-    def read_from_stream(io) #:nodoc:
-      buf = start_buf(io)
-      if self.zip64_file?(buf)
-        read_64_e_o_c_d(buf)
-      else
-        read_e_o_c_d(buf)
-      end
-      read_central_directory_entries(io)
-    end
-
-    def get_e_o_c_d(buf) #:nodoc:
-      sig_index = buf.rindex([END_OF_CDS].pack('V'))
-      raise Error, "Zip end of central directory signature not found" unless sig_index
-      buf = buf.slice!((sig_index + 4)..(buf.bytesize))
-
-      def buf.read(count)
-        slice!(0, count)
-      end
-
-      buf
-    end
-
-    def zip64_file?(buf)
-      buf.rindex([ZIP64_END_OF_CDS].pack('V')) && buf.rindex([ZIP64_EOCD_LOCATOR].pack('V'))
-    end
-
-    def start_buf(io)
-      begin
-        io.seek(-MAX_END_OF_CDS_SIZE, IO::SEEK_END)
-      rescue Errno::EINVAL
-        io.seek(0, IO::SEEK_SET)
-      end
-      io.read
-    end
-
-    def get_64_e_o_c_d(buf) #:nodoc:
-      zip_64_start = buf.rindex([ZIP64_END_OF_CDS].pack('V'))
-      raise Error, "Zip64 end of central directory signature not found" unless zip_64_start
-      zip_64_locator = buf.rindex([ZIP64_EOCD_LOCATOR].pack('V'))
-      raise Error, "Zip64 end of central directory signature locator not found" unless zip_64_locator
-      buf = buf.slice!((zip_64_start + 4)..zip_64_locator)
-
-      def buf.read(count)
-        slice!(0, count)
-      end
-
-      buf
-    end
-
-    # For iterating over the entries.
-    def each(&proc)
-      @entry_set.each(&proc)
-    end
-
-    # Returns the number of entries in the central directory (and
-    # consequently in the zip archive).
-    def size
-      @entry_set.size
-    end
-
-    def self.read_from_stream(io) #:nodoc:
-      cdir = new
-      cdir.read_from_stream(io)
-      return cdir
-    rescue Error
-      return nil
-    end
-
-    def ==(other) #:nodoc:
-      return false unless other.kind_of?(CentralDirectory)
-      @entry_set.entries.sort == other.entries.sort && comment == other.comment
-    end
-  end
-end
-
-# Copyright (C) 2002, 2003 Thomas Sondergaard
-# rubyzip is free software; you can redistribute it and/or
-# modify it under the terms of the ruby license.

data/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/compressor.rb

@@ -1,10 +0,0 @@
-module Zip
-  class Compressor #:nodoc:all
-    def finish
-    end
-  end
-end
-
-# Copyright (C) 2002, 2003 Thomas Sondergaard
-# rubyzip is free software; you can redistribute it and/or
-# modify it under the terms of the ruby license.

data/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/constants.rb

@@ -1,63 +0,0 @@
-module Zip
-  RUNNING_ON_WINDOWS = RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/i
-
-  CENTRAL_DIRECTORY_ENTRY_SIGNATURE = 0x02014b50
-  CDIR_ENTRY_STATIC_HEADER_LENGTH   = 46
-
-  LOCAL_ENTRY_SIGNATURE                  = 0x04034b50
-  LOCAL_ENTRY_STATIC_HEADER_LENGTH       = 30
-  LOCAL_ENTRY_TRAILING_DESCRIPTOR_LENGTH = 4+4+4
-  VERSION_MADE_BY                        = 52 # this library's version
-  VERSION_NEEDED_TO_EXTRACT              = 20
-  VERSION_NEEDED_TO_EXTRACT_ZIP64        = 45
-
-  FILE_TYPE_FILE    = 010
-  FILE_TYPE_DIR     = 004
-  FILE_TYPE_SYMLINK = 012
-
-  FSTYPE_FAT      = 0
-  FSTYPE_AMIGA    = 1
-  FSTYPE_VMS      = 2
-  FSTYPE_UNIX     = 3
-  FSTYPE_VM_CMS   = 4
-  FSTYPE_ATARI    = 5
-  FSTYPE_HPFS     = 6
-  FSTYPE_MAC      = 7
-  FSTYPE_Z_SYSTEM = 8
-  FSTYPE_CPM      = 9
-  FSTYPE_TOPS20   = 10
-  FSTYPE_NTFS     = 11
-  FSTYPE_QDOS     = 12
-  FSTYPE_ACORN    = 13
-  FSTYPE_VFAT     = 14
-  FSTYPE_MVS      = 15
-  FSTYPE_BEOS     = 16
-  FSTYPE_TANDEM   = 17
-  FSTYPE_THEOS    = 18
-  FSTYPE_MAC_OSX  = 19
-  FSTYPE_ATHEOS   = 30
-
-  FSTYPES = {
-    FSTYPE_FAT      => 'FAT'.freeze,
-    FSTYPE_AMIGA    => 'Amiga'.freeze,
-    FSTYPE_VMS      => 'VMS (Vax or Alpha AXP)'.freeze,
-    FSTYPE_UNIX     => 'Unix'.freeze,
-    FSTYPE_VM_CMS   => 'VM/CMS'.freeze,
-    FSTYPE_ATARI    => 'Atari ST'.freeze,
-    FSTYPE_HPFS     => 'OS/2 or NT HPFS'.freeze,
-    FSTYPE_MAC      => 'Macintosh'.freeze,
-    FSTYPE_Z_SYSTEM => 'Z-System'.freeze,
-    FSTYPE_CPM      => 'CP/M'.freeze,
-    FSTYPE_TOPS20   => 'TOPS-20'.freeze,
-    FSTYPE_NTFS     => 'NTFS'.freeze,
-    FSTYPE_QDOS     => 'SMS/QDOS'.freeze,
-    FSTYPE_ACORN    => 'Acorn RISC OS'.freeze,
-    FSTYPE_VFAT     => 'Win32 VFAT'.freeze,
-    FSTYPE_MVS      => 'MVS'.freeze,
-    FSTYPE_BEOS     => 'BeOS'.freeze,
-    FSTYPE_TANDEM   => 'Tandem NSK'.freeze,
-    FSTYPE_THEOS    => 'Theos'.freeze,
-    FSTYPE_MAC_OSX  => 'Mac OS/X (Darwin)'.freeze,
-    FSTYPE_ATHEOS   => 'AtheOS'.freeze,
-  }.freeze
-end

data/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/crypto/encryption.rb

@@ -1,11 +0,0 @@
-module Zip
-  class Encrypter #:nodoc:all
-  end
-
-  class Decrypter
-  end
-end
-
-# Copyright (C) 2002, 2003 Thomas Sondergaard
-# rubyzip is free software; you can redistribute it and/or
-# modify it under the terms of the ruby license.

data/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/crypto/null_encryption.rb

@@ -1,45 +0,0 @@
-module Zip
-  module NullEncryption
-    def header_bytesize
-      0
-    end
-
-    def gp_flags
-      0
-    end
-  end
-
-  class NullEncrypter < Encrypter
-    include NullEncryption
-
-    def header(mtime)
-      ''
-    end
-
-    def encrypt(data)
-      data
-    end
-
-    def data_descriptor(crc32, compressed_size, uncomprssed_size)
-      ''
-    end
-
-    def reset!
-    end
-  end
-
-  class NullDecrypter < Decrypter
-    include NullEncryption
-
-    def decrypt(data)
-      data
-    end
-
-    def reset!(header)
-    end
-  end
-end
-
-# Copyright (C) 2002, 2003 Thomas Sondergaard
-# rubyzip is free software; you can redistribute it and/or
-# modify it under the terms of the ruby license.

data/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/crypto/traditional_encryption.rb

@@ -1,99 +0,0 @@
-module Zip
-  module TraditionalEncryption
-    def initialize(password)
-      @password = password
-      reset_keys!
-    end
-
-    def header_bytesize
-      12
-    end
-
-    def gp_flags
-      0x0001 | 0x0008
-    end
-
-    protected
-
-    def reset_keys!
-      @key0 = 0x12345678
-      @key1 = 0x23456789
-      @key2 = 0x34567890
-      @password.each_byte do |byte|
-        update_keys(byte.chr)
-      end
-    end
-
-    def update_keys(n)
-      @key0 = ~Zlib.crc32(n, ~@key0)
-      @key1 = ((@key1 + (@key0 & 0xff)) * 134775813 + 1) & 0xffffffff
-      @key2 = ~Zlib.crc32((@key1 >> 24).chr, ~@key2)
-    end
-
-    def decrypt_byte
-      temp = (@key2 & 0xffff) | 2
-      ((temp * (temp ^ 1)) >> 8) & 0xff
-    end
-  end
-
-  class TraditionalEncrypter < Encrypter
-    include TraditionalEncryption
-
-    def header(mtime)
-      [].tap do |header|
-        (header_bytesize - 2).times do
-          header << Random.rand(0..255)
-        end
-        header << (mtime.to_binary_dos_time & 0xff)
-        header << (mtime.to_binary_dos_time >> 8)
-      end.map{|x| encode x}.pack("C*")
-    end
-
-    def encrypt(data)
-      data.unpack("C*").map{|x| encode x}.pack("C*")
-    end
-
-    def data_descriptor(crc32, compressed_size, uncomprssed_size)
-      [0x08074b50, crc32, compressed_size, uncomprssed_size].pack("VVVV")
-    end
-
-    def reset!
-      reset_keys!
-    end
-
-    private
-
-    def encode(n)
-      t = decrypt_byte
-      update_keys(n.chr)
-      t ^ n
-    end
-  end
-
-  class TraditionalDecrypter < Decrypter
-    include TraditionalEncryption
-
-    def decrypt(data)
-      data.unpack("C*").map{|x| decode x}.pack("C*")
-    end
-
-    def reset!(header)
-      reset_keys!
-      header.each_byte do |x|
-        decode x
-      end
-    end
-
-    private
-
-    def decode(n)
-      n ^= decrypt_byte
-      update_keys(n.chr)
-      n
-    end
-  end
-end
-
-# Copyright (C) 2002, 2003 Thomas Sondergaard
-# rubyzip is free software; you can redistribute it and/or
-# modify it under the terms of the ruby license.

data/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/decompressor.rb

@@ -1,13 +0,0 @@
-module Zip
-  class Decompressor  #:nodoc:all
-    CHUNK_SIZE = 32768
-    def initialize(input_stream)
-      super()
-      @input_stream=input_stream
-    end
-  end
-end
-
-# Copyright (C) 2002, 2003 Thomas Sondergaard
-# rubyzip is free software; you can redistribute it and/or
-# modify it under the terms of the ruby license.

data/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/deflater.rb

@@ -1,32 +0,0 @@
-module Zip
-  class Deflater < Compressor #:nodoc:all
-
-    def initialize(output_stream, level = Zip.default_compression, encrypter = NullEncrypter.new)
-      super()
-      @output_stream = output_stream
-      @zlib_deflater = ::Zlib::Deflate.new(level, -::Zlib::MAX_WBITS)
-      @size          = 0
-      @crc           = ::Zlib.crc32
-      @encrypter     = encrypter
-      @buffer_stream = ::StringIO.new('')
-    end
-
-    def << (data)
-      val   = data.to_s
-      @crc  = Zlib::crc32(val, @crc)
-      @size += val.bytesize
-      @buffer_stream << @zlib_deflater.deflate(data)
-    end
-
-    def finish
-      @output_stream << @encrypter.encrypt(@buffer_stream.string)
-      @output_stream << @encrypter.encrypt(@zlib_deflater.finish) until @zlib_deflater.finished?
-    end
-
-    attr_reader :size, :crc
-  end
-end
-
-# Copyright (C) 2002, 2003 Thomas Sondergaard
-# rubyzip is free software; you can redistribute it and/or
-# modify it under the terms of the ruby license.

data/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/dos_time.rb

@@ -1,49 +0,0 @@
-module Zip
-  class DOSTime < Time #:nodoc:all
-
-    #MS-DOS File Date and Time format as used in Interrupt 21H Function 57H:
-
-    # Register CX, the Time:
-    # Bits 0-4  2 second increments (0-29)
-    # Bits 5-10 minutes (0-59)
-    # bits 11-15 hours (0-24)
-
-    # Register DX, the Date:
-    # Bits 0-4 day (1-31)
-    # bits 5-8 month (1-12)
-    # bits 9-15 year (four digit year minus 1980)
-
-    def to_binary_dos_time
-      (sec/2) +
-        (min << 5) +
-        (hour << 11)
-    end
-
-    def to_binary_dos_date
-      (day) +
-        (month << 5) +
-        ((year - 1980) << 9)
-    end
-
-    # Dos time is only stored with two seconds accuracy
-    def dos_equals(other)
-      to_i/2 == other.to_i/2
-    end
-
-    def self.parse_binary_dos_format(binaryDosDate, binaryDosTime)
-      second = 2 * (0b11111 & binaryDosTime)
-      minute = (0b11111100000 & binaryDosTime) >> 5
-      hour   = (0b1111100000000000 & binaryDosTime) >> 11
-      day    = (0b11111 & binaryDosDate)
-      month  = (0b111100000 & binaryDosDate) >> 5
-      year   = ((0b1111111000000000 & binaryDosDate) >> 9) + 1980
-      begin
-        self.local(year, month, day, hour, minute, second)
-      end
-    end
-  end
-end
-
-# Copyright (C) 2002, 2003 Thomas Sondergaard
-# rubyzip is free software; you can redistribute it and/or
-# modify it under the terms of the ruby license.