rubyzip 1.0.0 → 1.2.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NjQ3YjE3YmQ0MDUyYzViOThmNDBjNGVhYTRmNDdiNzAzZjYzNjZkOA==
-  data.tar.gz: !binary |-
-    OGI5ZjFlYTk3NmQwMGY2NmM2NmVkYWI3ZjczMTVjNDAxYzg0YzY3Zg==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    ODI3NzAwZDg5NzYyZDdjZTNlNDUyOWJjYmY0YTU0MGEzMjUwOTE5MjdkOTM3
-    ZjkzMTFjNzQzZmRlZDA4MTllZmU2N2NjMDQyMDM5NTRjMjg5ODVmMzUyODMw
-    ZGExYjk3MDkwNzRmYTJkYjhhYjNmMmY4YTIyYTQ2ODA4MDdiNzk=
-  data.tar.gz: !binary |-
-    MWM5ODRlNzdmNDNiOGE4ZjkzMWYzZTIxZTE4OTU1ZTVhZmQ4YzhhZGQ0ZWNi
-    N2Q4N2NhZmE1ZmJiZjFjMzcxMWI3YzgzNmRiNDVlZGYwZmYyZTJiNTljY2Yx
-    MTY4NGM1YjNhOGJiZmE2MGUyZTBjYTc2YzdjMzc0ZTE3NTIyZDc=
+SHA1:
+  metadata.gz: 4af5fd26173e16759a74f190b293f84cc02d605b
+  data.tar.gz: 05666235e929fdb9bd6abe6807d3bf9583e65244
+SHA512:
+  metadata.gz: 2f4b82040f81e517ddb65660bea4a3368ec5e150bd094051d0ae3a515184c2eef55e32bcf5f49877bd432b3331a809402977e1c4b2a045695c8d2f45ab86f43c
+  data.tar.gz: 31fdb0e8c66d737d341161d02faf343786d0a0d1beca058cff4532886a2cfe268b738c6307b042c22a3186909953cd6879656a7660ef607eea906f407f1aada1

data/README.md

@@ -1,16 +1,28 @@
 # rubyzip
-[![Build Status](https://secure.travis-ci.org/rubyzip/rubyzip.png)](http://travis-ci.org/rubyzip/rubyzip)
-[![Code Climate](https://codeclimate.com/github/rubyzip/rubyzip.png)](https://codeclimate.com/github/rubyzip/rubyzip)
-[![Coverage Status](https://coveralls.io/repos/rubyzip/rubyzip/badge.png?branch=master)](https://coveralls.io/r/rubyzip/rubyzip?branch=master)
+[![Gem Version](https://badge.fury.io/rb/rubyzip.svg)](http://badge.fury.io/rb/rubyzip)
+[![Build Status](https://secure.travis-ci.org/rubyzip/rubyzip.svg)](http://travis-ci.org/rubyzip/rubyzip)
+[![Code Climate](https://codeclimate.com/github/rubyzip/rubyzip.svg)](https://codeclimate.com/github/rubyzip/rubyzip)
+[![Coverage Status](https://img.shields.io/coveralls/rubyzip/rubyzip.svg)](https://coveralls.io/r/rubyzip/rubyzip?branch=master)
 
-rubyzip is a ruby library for reading and writing zip files.
+Rubyzip is a ruby library for reading and writing zip files.
 
 ## Important note
 
-Rubyzip interface changed!!! No need to do `require "zip/zip"` and `Zip` prefix in class names removed.
+The Rubyzip interface has changed!!! No need to do `require "zip/zip"` and `Zip` prefix in class names removed.
+
+If you have issues with any third-party gems that require an old version of rubyzip, you can use this workaround:
+
+```ruby
+gem 'rubyzip', '>= 1.0.0' # will load new rubyzip version
+gem 'zip-zip' # will load compatibility for old rubyzip API.
+```
+
+## Requirements
+
+* Ruby 1.9.2 or greater
 
 ## Installation
-rubyzip is available on RubyGems, so:
+Rubyzip is available on RubyGems:
 
 ```
 gem install rubyzip
@@ -42,25 +54,148 @@ Zip::File.open(zipfile_name, Zip::File::CREATE) do |zipfile|
     # - The original file, including the path to find it
     zipfile.add(filename, folder + '/' + filename)
   end
+  zipfile.get_output_stream("myFile") { |os| os.write "myFile contains just this" }
 end
 ```
 
 ### Zipping a directory recursively
+Copy from [here](https://github.com/rubyzip/rubyzip/blob/05916bf89181e1955118fd3ea059f18acac28cc8/samples/example_recursive.rb )
 
 ```ruby
 require 'rubygems'
 require 'zip'
+# This is a simple example which uses rubyzip to
+# recursively generate a zip file from the contents of
+# a specified directory. The directory itself is not
+# included in the archive, rather just its contents.
+#
+# Usage:
+# require /path/to/the/ZipFileGenerator/Class
+# directoryToZip = "/tmp/input"
+# outputFile = "/tmp/out.zip"
+# zf = ZipFileGenerator.new(directoryToZip, outputFile)
+# zf.write()
+
+class ZipFileGenerator
+  # Initialize with the directory to zip and the location of the output archive.
+  def initialize(input_dir, output_file)
+    @input_dir = input_dir
+    @output_file = output_file
+  end
 
-directory = '/Users/me/Desktop/directory_to_zip/'
-zipfile_name = '/Users/me/Desktop/recursive_directory.zip'
+  # Zip the input directory.
+  def write
+    entries = Dir.entries(@input_dir) - %w(. ..)
 
-Zip::File.open(zipfile_name, Zip::File::CREATE) do |zipfile|
-	Dir[File.join(directory, '**', '**')].each do |file|
-	  zipfile.add(file.sub(directory, ''), file)
-	end
+    ::Zip::File.open(@output_file, ::Zip::File::CREATE) do |io|
+      write_entries entries, '', io
+    end
+  end
+
+  private
+
+  # A helper method to make the recursion work.
+  def write_entries(entries, path, io)
+    entries.each do |e|
+      zip_file_path = path == '' ? e : File.join(path, e)
+      disk_file_path = File.join(@input_dir, zip_file_path)
+      puts "Deflating #{disk_file_path}"
+
+      if File.directory? disk_file_path
+        recursively_deflate_directory(disk_file_path, io, zip_file_path)
+      else
+        put_into_archive(disk_file_path, io, zip_file_path)
+      end
+    end
+  end
+
+  def recursively_deflate_directory(disk_file_path, io, zip_file_path)
+    io.mkdir zip_file_path
+    subdir = Dir.entries(disk_file_path) - %w(. ..)
+    write_entries subdir, zip_file_path, io
+  end
+
+  def put_into_archive(disk_file_path, io, zip_file_path)
+    io.get_output_stream(zip_file_path) do |f|
+      f.puts(File.open(disk_file_path, 'rb').read)
+    end
+  end
+end
+```
+
+### Save zip archive entries in sorted by name state
+
+To save zip archives in sorted order like below, you need to set `::Zip.sort_entries` to `true`
+
+```
+Vegetable/
+Vegetable/bean
+Vegetable/carrot
+Vegetable/celery
+fruit/
+fruit/apple
+fruit/kiwi
+fruit/mango
+fruit/orange
+```
+
+After this, entries in the zip archive will be saved in ordered state.
+
+### Default permissions of zip archives
+
+On Posix file systems the default file permissions applied to a new archive
+are (0666 - umask), which mimics the behavior of standard tools such as `touch`.
+
+On Windows the default file permissions are set to 0644 as suggested by the
+[Ruby File documentation](http://ruby-doc.org/core-2.2.2/File.html).
+
+When modifying a zip archive the file permissions of the archive are preserved.
+
+### Reading a Zip file
+
+```ruby
+Zip::File.open('foo.zip') do |zip_file|
+  # Handle entries one by one
+  zip_file.each do |entry|
+    # Extract to file/directory/symlink
+    puts "Extracting #{entry.name}"
+    entry.extract(dest_file)
+
+    # Read into memory
+    content = entry.get_input_stream.read
+  end
+
+  # Find specific entry
+  entry = zip_file.glob('*.csv').first
+  puts entry.get_input_stream.read
 end
 ```
 
+#### Notice about ::Zip::InputStream
+
+`::Zip::InputStream` usable for fast reading zip file content because it not read Central directory.
+
+But there is one exception when it is not working - General Purpose Flag Bit 3.
+
+```
+If bit 3 (0x08) of the general-purpose flags field is set, then the CRC-32 and file sizes are not known when the header is written. The fields in the local header are filled with zero, and the CRC-32 and size are appended in a 12-byte structure (optionally preceded by a 4-byte signature) immediately after the compressed data
+```
+
+If `::Zip::InputStream` finds such entry in the zip archive it will raise an exception.
+
+### Password Protection (Experimental)
+
+Rubyzip supports reading/writing zip files with traditional zip encryption (a.k.a. "ZipCrypto"). AES encryption is not yet supported. It can be used with buffer streams, e.g.:
+
+```ruby
+Zip::OutputStream.write_buffer(::StringIO.new(''), Zip::TraditionalEncrypter.new('password')) do |out|
+  out.put_next_entry("my_file.txt")
+  out.write my_data
+end.string
+```
+
+This is an experimental feature and the interface for encryption may change in future versions.
+
 ## Known issues
 
 ### Modify docx file with rubyzip
@@ -86,32 +221,6 @@ end
 File.open(new_path, "w") {|f| f.write(buffer.string) }
 ```
 
-## Further Documentation
-
-There is more than one way to access or create a zip archive with
-rubyzip. The basic API is modeled after the classes in
-java.util.zip from the Java SDK. This means there are classes such
-as Zip::InputStream, Zip::OutputStream and
-Zip::File. Zip::InputStream provides a basic interface for
-iterating through the entries in a zip archive and reading from the
-entries in the same way as from a regular File or IO
-object. OutputStream is the corresponding basic output
-facility. Zip::File provides a mean for accessing the archives
-central directory and provides means for accessing any entry without
-having to iterate through the archive. Unlike Java's
-java.util.zip.ZipFile rubyzip's Zip::File is mutable, which means
-it can be used to change zip files as well.
-
-Another way to access a zip archive with rubyzip is to use rubyzip's
-Zip::FileSystem API. Using this API files can be read from and
-written to the archive in much the same manner as ruby's builtin
-classes allows files to be read from and written to the file system.
-
-For details about the specific behaviour of classes and methods refer
-to the test suite. Finally you can generate the rdoc documentation or
-visit http://rubyzip.sourceforge.net.
-
-
 ## Configuration
 
 By default, rubyzip will not overwrite files if they already exist inside of the extracted path.  To change this behavior, you may specify a configuration option like so:
@@ -128,25 +237,47 @@ Additionally, if you want to configure rubyzip to overwrite existing files while
 Zip.continue_on_exists_proc = true
 ```
 
-If you want to store non english names and want to open properly file on Windows(pre 7) you need to set next option:
+If you want to store non-english names and want to open them on Windows(pre 7) you need to set this option:
 
 ```ruby
 Zip.unicode_names = true
 ```
 
-All settings in same time
+Some zip files might have an invalid date format, which will raise a warning. You can hide this warning with the following setting:
+
+```ruby
+Zip.warn_invalid_date = false
+```
+
+You can set the default compression level like so:
+
+```ruby
+Zip.default_compression = Zlib::DEFAULT_COMPRESSION
+```
+It defaults to `Zlib::DEFAULT_COMPRESSION`. Possible values are `Zlib::BEST_COMPRESSION`, `Zlib::DEFAULT_COMPRESSION` and `Zlib::NO_COMPRESSION`
+
+You can set multiple settings at the same time by using a block:
 
 ```ruby
   Zip.setup do |c|
     c.on_exists_proc = true
     c.continue_on_exists_proc = true
     c.unicode_names = true
+    c.default_compression = Zlib::BEST_COMPRESSION
   end
 ```
 
+By default, Zip64 support is disabled for writing. To enable it do this:
+
+```ruby
+Zip.write_zip64_support = true
+```
+
+_NOTE_: If you will enable Zip64 writing then you will need zip extractor with Zip64 support to extract archive.
+
 ## Developing
 
-To run tests you need run next commands:
+To run the test you need to do this:
 
 ```
 bundle install
@@ -173,5 +304,5 @@ extra-field support contributed by Tatsuki Sugiura (sugi at nemui.org)
 
 ## License
 
-rubyzip is distributed under the same license as ruby. See
+Rubyzip is distributed under the same license as ruby. See
 http://www.ruby-lang.org/en/LICENSE.txt

data/Rakefile

@@ -1,13 +1,18 @@
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 
-task :default => :test
+task default: :test
 
 Rake::TestTask.new(:test) do |test|
-  test.libs << File.join(File.dirname(__FILE__), 'lib')
-  test.libs << File.join(File.dirname(__FILE__), 'test')
-  test.pattern = File.join(File.dirname(__FILE__), 'test/alltests.rb')
+  test.libs << 'lib'
+  test.libs << 'test'
+  test.pattern = 'test/**/*_test.rb'
   test.verbose = true
-
 end
 
+# Rake::TestTask.new(:zip64_full_test) do |test|
+#  test.libs << File.join(File.dirname(__FILE__), 'lib')
+#  test.libs << File.join(File.dirname(__FILE__), 'test')
+#  test.pattern = File.join(File.dirname(__FILE__), 'test/zip64_full_test.rb')
+#  test.verbose = true
+# end

data/TODO

@@ -4,7 +4,6 @@
 * Suggestion: Add ZipFile/ZipInputStream example that demonstrates extracting all entries.
 * Suggestion: ZipFile#extract destination should default to "."
 * Suggestion: ZipEntry should have extract(), get_input_stream() methods etc
-* Suggestion: ZipInputStream/ZipOutputStream should accept an IO object in addition to a filename.
 * (is buffering used anywhere with write?)
 * Inflater.sysread should pass the buffer to produce_input.
 * Implement ZipFsDir.glob

data/lib/zip/central_directory.rb

@@ -5,7 +5,7 @@ module Zip
     END_OF_CDS             = 0x06054b50
     ZIP64_END_OF_CDS       = 0x06064b50
     ZIP64_EOCD_LOCATOR     = 0x07064b50
-    MAX_END_OF_CDS_SIZE    = 65536 + 18
+    MAX_END_OF_CDS_SIZE    = 65_536 + 18
     STATIC_EOCD_SIZE       = 22
 
     attr_reader :comment
@@ -22,21 +22,31 @@ module Zip
     end
 
     def write_to_stream(io) #:nodoc:
-      offset = io.tell
+      cdir_offset = io.tell
       @entry_set.each { |entry| entry.write_c_dir_entry(io) }
-      write_e_o_c_d(io, offset)
+      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) #:nodoc:
+    def write_e_o_c_d(io, offset, cdir_size) #:nodoc:
       tmp = [
         END_OF_CDS,
         0, # @numberOfThisDisk
         0, # @numberOfDiskWithStartOfCDir
-        @entry_set ? @entry_set.size : 0,
-        @entry_set ? @entry_set.size : 0,
-        cdir_size,
-        offset,
-        @comment ? @comment.length : 0
+        @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
@@ -44,14 +54,35 @@ module Zip
 
     private :write_e_o_c_d
 
-    def cdir_size #:nodoc:
-      # does not include eocd
-      @entry_set.inject(0) do |value, entry|
-        entry.cdir_header_size + value
-      end
+    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 :cdir_size
+    private :write_64_eocd_locator
 
     def read_64_e_o_c_d(buf) #:nodoc:
       buf                                           = get_64_e_o_c_d(buf)
@@ -65,7 +96,7 @@ module Zip
       @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 ZipError, "Zip consistency problem while reading eocd structure" unless buf.size == 0
+      raise Error, 'Zip consistency problem while reading eocd structure' unless buf.size == 0
     end
 
     def read_e_o_c_d(buf) #:nodoc:
@@ -77,19 +108,19 @@ module Zip
       @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 <= 0
+      @comment                                      = if comment_length.to_i <= 0
                                                         buf.slice!(0, buf.size)
                                                       else
                                                         buf.read(comment_length)
                                                       end
-      raise ZipError, "Zip consistency problem while reading eocd structure" unless buf.size == 0
+      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 ZipError, "Zip consistency problem while reading central directory entry"
+        raise Error, 'Zip consistency problem while reading central directory entry'
       end
       @entry_set = EntrySet.new
       @size.times do
@@ -109,7 +140,7 @@ module Zip
 
     def get_e_o_c_d(buf) #:nodoc:
       sig_index = buf.rindex([END_OF_CDS].pack('V'))
-      raise ZipError, "Zip end of central directory signature not found" unless sig_index
+      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)
@@ -134,9 +165,9 @@ module Zip
 
     def get_64_e_o_c_d(buf) #:nodoc:
       zip_64_start = buf.rindex([ZIP64_END_OF_CDS].pack('V'))
-      raise ZipError, "Zip64 end of central directory signature not found" unless zip_64_start
+      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 ZipError, "Zip64 end of central directory signature locator not found" unless zip_64_locator
+      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)
@@ -151,7 +182,7 @@ module Zip
       @entry_set.each(&proc)
     end
 
-    # Returns the number of entries in the central directory (and 
+    # Returns the number of entries in the central directory (and
     # consequently in the zip archive).
     def size
       @entry_set.size
@@ -161,7 +192,7 @@ module Zip
       cdir = new
       cdir.read_from_stream(io)
       return cdir
-    rescue ZipError
+    rescue Error
       return nil
     end
 

data/lib/zip/constants.rb

@@ -6,8 +6,10 @@ module Zip
 
   LOCAL_ENTRY_SIGNATURE                  = 0x04034b50
   LOCAL_ENTRY_STATIC_HEADER_LENGTH       = 30
-  LOCAL_ENTRY_TRAILING_DESCRIPTOR_LENGTH = 4+4+4
+  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
@@ -56,6 +58,6 @@ module Zip
     FSTYPE_TANDEM   => 'Tandem NSK'.freeze,
     FSTYPE_THEOS    => 'Theos'.freeze,
     FSTYPE_MAC_OSX  => 'Mac OS/X (Darwin)'.freeze,
-    FSTYPE_ATHEOS   => 'AtheOS'.freeze,
+    FSTYPE_ATHEOS   => 'AtheOS'.freeze
   }.freeze
 end

data/lib/zip/crypto/encryption.rb

@@ -0,0 +1,11 @@
+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/zip/crypto/null_encryption.rb

@@ -0,0 +1,45 @@
+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/zip/crypto/traditional_encryption.rb

@@ -0,0 +1,99 @@
+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)) * 134_775_813 + 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/zip/decompressor.rb

@@ -1,9 +1,9 @@
 module Zip
   class Decompressor  #:nodoc:all
-    CHUNK_SIZE = 32768
+    CHUNK_SIZE = 32_768
     def initialize(input_stream)
       super()
-      @input_stream=input_stream
+      @input_stream = input_stream
     end
   end
 end