rubyzip 1.0.0 → 2.4.1

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=
+SHA256:
+  metadata.gz: 2d59784cc9a5e884c6537a896b30b1a18206c7a97a0f74e37bd58769f0700497
+  data.tar.gz: 7e4bf8643b179bb0e5415b0f6aa7e92ce4786ed734cf23b902ea9739d5c46bb9
+SHA512:
+  metadata.gz: c65346fc54aa6e931f8975a8e98212323a597583523a251d2d88184971a9469a549e9cd967c2d6015002f07fe8c19b13d96261781131b9bd7a0b099da1c04fe2
+  data.tar.gz: b397b12e1bef39a1cd4ade2698756f3194ed75504fb15ea5494dc26189be4a8d66af1a2411e827b660f67044ef4ee207c3d951d190886912079ce8ffcbf19bac

data/README.md

@@ -1,16 +1,38 @@
 # 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)
 
-rubyzip is a ruby library for reading and writing zip files.
+[![Gem Version](https://badge.fury.io/rb/rubyzip.svg)](http://badge.fury.io/rb/rubyzip)
+[![Tests](https://github.com/rubyzip/rubyzip/actions/workflows/tests.yml/badge.svg)](https://github.com/rubyzip/rubyzip/actions/workflows/tests.yml)
+[![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.
 
 ## Important note
 
-Rubyzip interface changed!!! No need to do `require "zip/zip"` and `Zip` prefix in class names removed.
+Rubyzip 2.4 is intended to be the last release in the 2.x series. Please get ready for version 3.0.
+
+### Updating to version 3.0
+
+The public API of some classes has been modernized to use named parameters for optional arguments. Also some methods have been changed or removed. Please check your usage of the following Rubyzip classes:
+* `File`
+* `Entry`
+* `InputStream`
+* `OutputStream`
+* `DOSTime`
+
+**Please see [Updating to version 3.x](https://github.com/rubyzip/rubyzip/wiki/Updating-to-version-3.x) in the wiki for details.**
+
+## Requirements
+
+Version 3.x requires at least Ruby 3.0.
+
+Version 2.x requires at least Ruby 2.4, and is known to work on Ruby 3.x.
+
+It is not recommended to use any versions of Rubyzip earlier than 2.3 due to security issues.
 
 ## Installation
-rubyzip is available on RubyGems, so:
+
+Rubyzip is available on RubyGems:
 
 ```
 gem install rubyzip
@@ -40,27 +62,148 @@ Zip::File.open(zipfile_name, Zip::File::CREATE) do |zipfile|
     # Two arguments:
     # - The name of the file as it will appear in the archive
     # - The original file, including the path to find it
-    zipfile.add(filename, folder + '/' + filename)
+    zipfile.add(filename, File.join(folder, filename))
   end
+  zipfile.get_output_stream("myFile") { |f| f.write "myFile contains just this" }
 end
 ```
 
 ### Zipping a directory recursively
 
+Copy from [here](https://github.com/rubyzip/rubyzip/blob/9d891f7353e66052283562d3e252fe380bb4b199/samples/example_recursive.rb)
+
 ```ruby
-require 'rubygems'
 require 'zip'
 
-directory = '/Users/me/Desktop/directory_to_zip/'
-zipfile_name = '/Users/me/Desktop/recursive_directory.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:
+#   directory_to_zip = "/tmp/input"
+#   output_file = "/tmp/out.zip"
+#   zf = ZipFileGenerator.new(directory_to_zip, output_file)
+#   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
 
-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 the input directory.
+  def write
+    entries = Dir.entries(@input_dir) - %w[. ..]
+
+    ::Zip::File.open(@output_file, ::Zip::File::CREATE) do |zipfile|
+      write_entries entries, '', zipfile
+    end
+  end
+
+  private
+
+  # A helper method to make the recursion work.
+  def write_entries(entries, path, zipfile)
+    entries.each do |e|
+      zipfile_path = path == '' ? e : File.join(path, e)
+      disk_file_path = File.join(@input_dir, zipfile_path)
+
+      if File.directory? disk_file_path
+        recursively_deflate_directory(disk_file_path, zipfile, zipfile_path)
+      else
+        put_into_archive(disk_file_path, zipfile, zipfile_path)
+      end
+    end
+  end
+
+  def recursively_deflate_directory(disk_file_path, zipfile, zipfile_path)
+    zipfile.mkdir zipfile_path
+    subdir = Dir.entries(disk_file_path) - %w[. ..]
+    write_entries subdir, zipfile_path, zipfile
+  end
+
+  def put_into_archive(disk_file_path, zipfile, zipfile_path)
+    zipfile.add(zipfile_path, disk_file_path)
+  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
+MAX_SIZE = 1024**2 # 1MiB (but of course you can increase this)
+Zip::File.open('foo.zip') do |zip_file|
+  # Handle entries one by one
+  zip_file.each do |entry|
+    puts "Extracting #{entry.name}"
+    raise 'File too large when extracted' if entry.size > MAX_SIZE
+
+    # Extract to file or directory based on name in the archive
+    entry.extract
+
+    # Read into memory
+    content = entry.get_input_stream.read
+  end
+
+  # Find specific entry
+  entry = zip_file.glob('*.csv').first
+  raise 'File too large when extracted' if entry.size > MAX_SIZE
+  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
@@ -83,38 +226,14 @@ buffer = Zip::OutputStream.write_buffer do |out|
   out.write rels.to_xml(:indent => 0).gsub("\n","")
 end
 
-File.open(new_path, "w") {|f| f.write(buffer.string) }
+File.open(new_path, "wb") {|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:
+### Existing Files
+
+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:
 
 ```ruby
 Zip.on_exists_proc = true
@@ -128,25 +247,91 @@ 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:
+### Non-ASCII Names
+
+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
+Sometimes file names inside zip contain non-ASCII characters. If you can assume which encoding was used for such names and want to be able to find such entries using `find_entry` then you can force assumed encoding like so:
+
+```ruby
+Zip.force_entry_names_encoding = 'UTF-8'
+```
+
+Allowed encoding names are the same as accepted by `String#force_encoding`
+
+### Date Validation
+
+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
+```
+
+### Size Validation
+
+By default (in rubyzip >= 2.0), rubyzip's `extract` method checks that an entry's reported uncompressed size is not (significantly) smaller than its actual size. This is to help you protect your application against [zip bombs](https://en.wikipedia.org/wiki/Zip_bomb). Before `extract`ing an entry, you should check that its size is in the range you expect. For example, if your application supports processing up to 100 files at once, each up to 10MiB, your zip extraction code might look like:
+
+```ruby
+MAX_FILE_SIZE = 10 * 1024**2 # 10MiB
+MAX_FILES = 100
+Zip::File.open('foo.zip') do |zip_file|
+  num_files = 0
+  zip_file.each do |entry|
+    num_files += 1 if entry.file?
+    raise 'Too many extracted files' if num_files > MAX_FILES
+    raise 'File too large when extracted' if entry.size > MAX_FILE_SIZE
+    entry.extract
+  end
+end
+```
+
+If you need to extract zip files that report incorrect uncompressed sizes and you really trust them not too be too large, you can disable this setting with
+```ruby
+Zip.validate_entry_sizes = false
+```
+
+Note that if you use the lower level `Zip::InputStream` interface, `rubyzip` does *not* check the entry `size`s. In this case, the caller is responsible for making sure it does not read more data than expected from the input stream.
+
+### Default Compression
+
+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`
+
+### Zip64 Support
+
+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.
+
+### Block Form
+
+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
 ```
 
 ## Developing
 
-To run tests you need run next commands:
+To run the test you need to do this:
 
 ```
 bundle install
@@ -173,5 +358,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,21 @@
 require 'bundler/gem_tasks'
 require 'rake/testtask'
+require 'rubocop/rake_task'
 
-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
 
+RuboCop::RakeTask.new
+
+# 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 :cdir_size
+    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)
@@ -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.empty?
     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.empty?
     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
@@ -99,7 +130,7 @@ module Zip
 
     def read_from_stream(io) #:nodoc:
       buf = start_buf(io)
-      if self.zip64_file?(buf)
+      if zip64_file?(buf)
         read_64_e_o_c_d(buf)
       else
         read_e_o_c_d(buf)
@@ -109,7 +140,8 @@ 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 +166,11 @@ 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)
@@ -147,11 +181,11 @@ module Zip
     end
 
     # For iterating over the entries.
-    def each(&proc)
-      @entry_set.each(&proc)
+    def each(&a_proc)
+      @entry_set.each(&a_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
@@ -160,13 +194,14 @@ module Zip
     def self.read_from_stream(io) #:nodoc:
       cdir = new
       cdir.read_from_stream(io)
-      return cdir
-    rescue ZipError
-      return nil
+      cdir
+    rescue Error
+      nil
     end
 
     def ==(other) #:nodoc:
       return false unless other.kind_of?(CentralDirectory)
+
       @entry_set.entries.sort == other.entries.sort && comment == other.comment
     end
   end

data/lib/zip/compressor.rb

@@ -1,7 +1,6 @@
 module Zip
   class Compressor #:nodoc:all
-    def finish
-    end
+    def finish; end
   end
 end
 

data/lib/zip/constants.rb

@@ -6,12 +6,14 @@ 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
-  FILE_TYPE_SYMLINK = 012
+  FILE_TYPE_FILE    = 0o10
+  FILE_TYPE_DIR     = 0o04
+  FILE_TYPE_SYMLINK = 0o12
 
   FSTYPE_FAT      = 0
   FSTYPE_AMIGA    = 1
@@ -56,6 +58,58 @@ 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
+
+  COMPRESSION_METHOD_STORE = 0
+  COMPRESSION_METHOD_SHRINK = 1
+  COMPRESSION_METHOD_REDUCE_1 = 2
+  COMPRESSION_METHOD_REDUCE_2 = 3
+  COMPRESSION_METHOD_REDUCE_3 = 4
+  COMPRESSION_METHOD_REDUCE_4 = 5
+  COMPRESSION_METHOD_IMPLODE = 6
+  # RESERVED = 7
+  COMPRESSION_METHOD_DEFLATE = 8
+  COMPRESSION_METHOD_DEFLATE_64 = 9
+  COMPRESSION_METHOD_PKWARE_DCLI = 10
+  # RESERVED = 11
+  COMPRESSION_METHOD_BZIP2 = 12
+  # RESERVED = 13
+  COMPRESSION_METHOD_LZMA = 14
+  # RESERVED = 15
+  COMPRESSION_METHOD_IBM_CMPSC = 16
+  # RESERVED = 17
+  COMPRESSION_METHOD_IBM_TERSE = 18
+  COMPRESSION_METHOD_IBM_LZ77 = 19
+  COMPRESSION_METHOD_JPEG = 96
+  COMPRESSION_METHOD_WAVPACK = 97
+  COMPRESSION_METHOD_PPMD = 98
+  COMPRESSION_METHOD_AES = 99
+
+  COMPRESSION_METHODS = {
+    COMPRESSION_METHOD_STORE       => 'Store (no compression)',
+    COMPRESSION_METHOD_SHRINK      => 'Shrink',
+    COMPRESSION_METHOD_REDUCE_1    => 'Reduce with compression factor 1',
+    COMPRESSION_METHOD_REDUCE_2    => 'Reduce with compression factor 2',
+    COMPRESSION_METHOD_REDUCE_3    => 'Reduce with compression factor 3',
+    COMPRESSION_METHOD_REDUCE_4    => 'Reduce with compression factor 4',
+    COMPRESSION_METHOD_IMPLODE     => 'Implode',
+    # RESERVED = 7
+    COMPRESSION_METHOD_DEFLATE     => 'Deflate',
+    COMPRESSION_METHOD_DEFLATE_64  => 'Deflate64(tm)',
+    COMPRESSION_METHOD_PKWARE_DCLI => 'PKWARE Data Compression Library Imploding (old IBM TERSE)',
+    # RESERVED = 11
+    COMPRESSION_METHOD_BZIP2       => 'BZIP2',
+    # RESERVED = 13
+    COMPRESSION_METHOD_LZMA        => 'LZMA',
+    # RESERVED = 15
+    COMPRESSION_METHOD_IBM_CMPSC   => 'IBM z/OS CMPSC Compression',
+    # RESERVED = 17
+    COMPRESSION_METHOD_IBM_TERSE   => 'IBM TERSE (new)',
+    COMPRESSION_METHOD_IBM_LZ77    => 'IBM LZ77 z Architecture (PFS)',
+    COMPRESSION_METHOD_JPEG        => 'JPEG variant',
+    COMPRESSION_METHOD_WAVPACK     => 'WavPack compressed data',
+    COMPRESSION_METHOD_PPMD        => 'PPMd version I, Rev 1',
+    COMPRESSION_METHOD_AES         => 'AES encryption'
   }.freeze
 end