rubyzip 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 68e2727c6e1f49edc93c3081e74a8b8dd6cf8ea8
-  data.tar.gz: c6e0a74722936557ccec3a74f3d2efcf2e4a21b1
+  metadata.gz: e7eca6764ebd3b2104ce779b422472ed1df3f034
+  data.tar.gz: 2f90a3751e1533d46ff864f177f09cd2433b90e0
 SHA512:
-  metadata.gz: 77c0f46c33bfe45177adcc0bddf68fc3ae55624ed5fc95163eaf0546c028fd204fdf8167a2ce041389c4c9fe4961868dfd0ed79dfe3ea3439634542db9aecd1d
-  data.tar.gz: 7a2a4164ce2591204f30a36b337a4e1ce5907b3649487c9a366aff6d366b68cb61b15136cb2c0015845239a40d99158aabba2d635e7b46e5e508813dc1512aae
+  metadata.gz: ebd0ca646df6f8d652fc91f5d5306b101fe56bb8577d6a401b3b46f6a1fc6c9281df3cb88a555bed175c53ae01d437fd92b01487983f1eaf50d03fc94586bd1a
+  data.tar.gz: eff9c8f931440447bf5656720f32748523b792e5189e7bed1d000c7686f09a19cd4a019629d81f058dffd6d770aa1928e28e86cdb93561c801dbc3c6c21f7c56

data/README.md

@@ -9,11 +9,11 @@ rubyzip is a ruby library for reading and writing zip files.
 
 Rubyzip interface changed!!! No need to do `require "zip/zip"` and `Zip` prefix in class names removed.
 
-If you have issues with any third-party gems what required rubyzip you can use next temporary fix:
+If you have issues with any third-party gems what required old version of rubyzip you can use next workaround:
 
 ```ruby
-# Place this line before your library or on the head of your Gemfile
-gem 'rubyzip', '< 1.0.0'
+gem 'rubyzip', '>= 1.0.0' # will load new rubyzip version
+gem 'zip-zip' # will load compatibility for old rubyzip API.
 ```
 
 ## Requirements
@@ -53,6 +53,7 @@ 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
 ```
 
@@ -90,6 +91,26 @@ fruit/orange
 
 After this entries in zip archive will be saved in ordered state.
 
+### 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
+```
+
 ## Known issues
 
 ### Modify docx file with rubyzip
@@ -115,32 +136,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:
@@ -163,6 +158,14 @@ If you want to store non english names and want to open properly file on Windows
 Zip.unicode_names = true
 ```
 
+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`
+
 All settings in same time
 
 ```ruby
@@ -170,9 +173,18 @@ All settings in same time
     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 next:
+
+```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:

data/Rakefile

@@ -4,16 +4,16 @@ require 'rake/testtask'
 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
+#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.rb

@@ -34,7 +34,7 @@ end
 
 module Zip
   extend self
-  attr_accessor :unicode_names, :on_exists_proc, :continue_on_exists_proc, :sort_entries
+  attr_accessor :unicode_names, :on_exists_proc, :continue_on_exists_proc, :sort_entries, :default_compression, :write_zip64_support
 
   def reset!
     @_ran_once = false
@@ -42,6 +42,8 @@ module Zip
     @on_exists_proc = false
     @continue_on_exists_proc = false
     @sort_entries = false
+    @default_compression = ::Zlib::DEFAULT_COMPRESSION
+    @write_zip64_support = false
   end
 
   def setup

data/lib/zip/central_directory.rb

@@ -26,10 +26,13 @@ module Zip
       @entry_set.each { |entry| entry.write_c_dir_entry(io) }
       eocd_offset = io.tell
       cdir_size = eocd_offset - cdir_offset
-      has_zip64_entry = @entry_set.any? { |entry| entry.extra['Zip64'] }
-      if has_zip64_entry || cdir_offset > 0xFFFFFFFF || cdir_size > 0xFFFFFFFF || @entry_set.size > 0xFFFF
-        write_64_e_o_c_d(io, cdir_offset, cdir_size)
-        write_64_eocd_locator(io, eocd_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
@@ -93,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:
@@ -105,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
@@ -137,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)
@@ -162,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)
@@ -179,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
@@ -189,7 +192,7 @@ module Zip
       cdir = new
       cdir.read_from_stream(io)
       return cdir
-    rescue ZipError
+    rescue Error
       return nil
     end
 

data/lib/zip/deflater.rb

@@ -1,7 +1,7 @@
 module Zip
   class Deflater < Compressor #:nodoc:all
 
-    def initialize(output_stream, level = ::Zlib::DEFAULT_COMPRESSION)
+    def initialize(output_stream, level = Zip.default_compression)
       super()
       @output_stream = output_stream
       @zlib_deflater = ::Zlib::Deflate.new(level, -::Zlib::MAX_WBITS)

data/lib/zip/entry.rb

@@ -15,7 +15,7 @@ module Zip
 
     def set_default_vars_values
       @local_header_offset      = 0
-      @local_header_size        = 0
+      @local_header_size        = nil # not known until local entry is created or read
       @internal_file_attributes = 1
       @external_file_attributes = 0
       @header_signature         = ::Zip::CENTRAL_DIRECTORY_ENTRY_SIGNATURE
@@ -46,7 +46,7 @@ module Zip
 
     def check_name(name)
       if name.start_with?('/')
-        raise ::Zip::ZipEntryNameError, "Illegal ZipEntry name '#{name}', name must not start with /"
+        raise ::Zip::EntryNameError, "Illegal ZipEntry name '#{name}', name must not start with /"
       end
     end
 
@@ -92,7 +92,7 @@ module Zip
     end
 
     def file_type_is?(type)
-      raise ZipInternalError, "current filetype is unknown: #{self.inspect}" unless @ftype
+      raise InternalError, "current filetype is unknown: #{self.inspect}" unless @ftype
       @ftype == type
     end
 
@@ -130,9 +130,9 @@ module Zip
     # check before rewriting an entry (after file sizes are known)
     # that we didn't change the header size (and thus clobber file data or something)
     def verify_local_header_size!
-      return if @local_header_size == 0
+      return if @local_header_size.nil?
       new_size = calculate_local_header_size
-      raise ZipError, "local header size changed (#{@local_header_size} -> #{new_size})" if @local_header_size != new_size
+      raise Error, "local header size changed (#{@local_header_size} -> #{new_size})" if @local_header_size != new_size
     end
 
     def cdir_header_size #:nodoc:all
@@ -177,18 +177,23 @@ module Zip
       end
 
       def read_c_dir_entry(io) #:nodoc:all
-        entry = new(io.path)
+        path = if io.is_a?(::IO)
+              io.path
+             else
+               io
+             end
+        entry = new(path)
         entry.read_c_dir_entry(io)
         entry
-      rescue ZipError
+      rescue Error
         nil
       end
 
       def read_local_entry(io)
-        entry = self.new
+        entry = self.new(io)
         entry.read_local_entry(io)
         entry
-      rescue ZipError
+      rescue Error
         nil
       end
 
@@ -217,13 +222,13 @@ module Zip
       static_sized_fields_buf = io.read(::Zip::LOCAL_ENTRY_STATIC_HEADER_LENGTH)
 
       unless static_sized_fields_buf.bytesize == ::Zip::LOCAL_ENTRY_STATIC_HEADER_LENGTH
-        raise ZipError, "Premature end of file. Not enough data for zip entry local header"
+        raise Error, "Premature end of file. Not enough data for zip entry local header"
       end
 
       unpack_local_entry(static_sized_fields_buf)
 
       unless @header_signature == ::Zip::LOCAL_ENTRY_SIGNATURE
-        raise ::Zip::ZipError, "Zip local header magic not found at location '#{local_header_offset}'"
+        raise ::Zip::Error, "Zip local header magic not found at location '#{local_header_offset}'"
       end
       set_time(@last_mod_date, @last_mod_time)
 
@@ -233,7 +238,7 @@ module Zip
       @name.gsub!('\\', '/')
 
       if extra && extra.bytesize != @extra_length
-        raise ::Zip::ZipError, "Truncated local zip entry header"
+        raise ::Zip::Error, "Truncated local zip entry header"
       else
         if ::Zip::ExtraField === @extra
           @extra.merge(extra)
@@ -327,19 +332,19 @@ module Zip
 
     def check_c_dir_entry_static_header_length(buf)
       unless buf.bytesize == ::Zip::CDIR_ENTRY_STATIC_HEADER_LENGTH
-        raise ZipError, 'Premature end of file. Not enough data for zip cdir entry header'
+        raise Error, 'Premature end of file. Not enough data for zip cdir entry header'
       end
     end
 
     def check_c_dir_entry_signature
       unless header_signature == ::Zip::CENTRAL_DIRECTORY_ENTRY_SIGNATURE
-        raise ZipError, "Zip local header magic not found at location '#{local_header_offset}'"
+        raise Error, "Zip local header magic not found at location '#{local_header_offset}'"
       end
     end
 
     def check_c_dir_entry_comment_size
       unless @comment && @comment.bytesize == @comment_length
-        raise ::Zip::ZipError, "Truncated cdir zip entry header"
+        raise ::Zip::Error, "Truncated cdir zip entry header"
       end
     end
 
@@ -363,7 +368,6 @@ module Zip
       check_c_dir_entry_comment_size
       set_ftype_from_c_dir_entry
       parse_zip64_extra(false)
-      @local_header_size = calculate_local_header_size
     end
 
     def file_stat(path) # :nodoc:
@@ -422,7 +426,10 @@ module Zip
         (zip64 && zip64.disk_start_number) ? 0xFFFF : 0, # disk number start
         @internal_file_attributes, # file type (binary=0, text=1)
         @external_file_attributes, # native filesystem attributes
-        (zip64 && zip64.relative_header_offset) ? 0xFFFFFFFF : @local_header_offset
+        (zip64 && zip64.relative_header_offset) ? 0xFFFFFFFF : @local_header_offset,
+        @name,
+        @extra,
+        @comment
       ].pack('VCCvvvvvVVVvvvvvVV')
     end
 
@@ -511,7 +518,7 @@ module Zip
                  end
                  :file
                when 'directory'
-                 @name += "/" unless name_is_directory?
+                 @name += '/' unless name_is_directory?
                  :directory
                when 'link'
                  if name_is_directory?
@@ -530,9 +537,9 @@ module Zip
 
     def write_to_zip_output_stream(zip_output_stream) #:nodoc:all
       if @ftype == :directory
-        zip_output_stream.put_next_entry(self)
+        zip_output_stream.put_next_entry(self, nil, nil, ::Zip::Entry::STORED)
       elsif @filepath
-        zip_output_stream.put_next_entry(self, nil, nil, nil)
+        zip_output_stream.put_next_entry(self, nil, nil, ::Zip::Entry::DEFLATED)
         get_input_stream { |is| ::Zip::IOExtras.copy_stream(zip_output_stream, is) }
       else
         zip_output_stream.copy_raw_entry(self)
@@ -546,7 +553,11 @@ module Zip
     end
 
     def get_raw_input_stream(&block)
-      ::File.open(@zipfile, "rb", &block)
+      if @zipfile.is_a?(::IO) || @zipfile.is_a?(::StringIO)
+        yield @zipfile
+      else
+        ::File.open(@zipfile, "rb", &block)
+      end
     end
 
     private
@@ -558,8 +569,8 @@ module Zip
     end
 
     def create_file(dest_path, continue_on_exists_proc = proc { Zip.continue_on_exists_proc })
-      if ::File.exists?(dest_path) && !yield(self, dest_path)
-        raise ::Zip::ZipDestinationFileExistsError,
+      if ::File.exist?(dest_path) && !yield(self, dest_path)
+        raise ::Zip::DestinationFileExistsError,
               "Destination '#{dest_path}' already exists"
       end
       ::File.open(dest_path, "wb") do |os|
@@ -576,11 +587,11 @@ module Zip
 
     def create_directory(dest_path)
       return if ::File.directory?(dest_path)
-      if ::File.exists?(dest_path)
+      if ::File.exist?(dest_path)
         if block_given? && yield(self, dest_path)
           ::FileUtils::rm_f dest_path
         else
-          raise ::Zip::ZipDestinationFileExistsError,
+          raise ::Zip::DestinationFileExistsError,
                 "Cannot create directory '#{dest_path}'. "+
                   "A file already exists with that name"
         end
@@ -605,12 +616,12 @@ module Zip
           if ::File.readlink(dest_path) == linkto
             return
           else
-            raise ZipDestinationFileExistsError,
+            raise ::Zip::DestinationFileExistsError,
                   "Cannot create symlink '#{dest_path}'. "+
                     "A symlink already exists with that name"
           end
         else
-          raise ZipDestinationFileExistsError,
+          raise ::Zip::DestinationFileExistsError,
                 "Cannot create symlink '#{dest_path}'. "+
                   "A file already exists with that name"
         end
@@ -633,6 +644,7 @@ module Zip
 
     # create a zip64 extra information field if we need one
     def prep_zip64_extra(for_local_header) #:nodoc:all
+      return unless ::Zip.write_zip64_support
       need_zip64 = @size >= 0xFFFFFFFF || @compressed_size >= 0xFFFFFFFF
       unless for_local_header
         need_zip64 ||= @local_header_offset >= 0xFFFFFFFF

data/lib/zip/entry_set.rb

@@ -77,7 +77,7 @@ module Zip
 
     private
     def to_key(entry)
-      entry.to_s.sub(/\/$/, '')
+      entry.to_s.chomp('/')
     end
   end
 end

data/lib/zip/errors.rb

@@ -1,8 +1,8 @@
 module Zip
-  class ZipError < StandardError; end
-  class ZipEntryExistsError < ZipError; end
-  class ZipDestinationFileExistsError < ZipError; end
-  class ZipCompressionMethodError < ZipError; end
-  class ZipEntryNameError < ZipError; end
-  class ZipInternalError < ZipError; end
+  class Error < StandardError; end
+  class EntryExistsError < Error; end
+  class DestinationFileExistsError < Error; end
+  class CompressionMethodError < Error; end
+  class EntryNameError < Error; end
+  class InternalError < Error; end
 end

data/lib/zip/extra_field.rb

@@ -52,7 +52,7 @@ module Zip
 
     def create(name)
       unless field_class = ID_MAP.values.find { |k| k.name == name }
-        raise ZipError, "Unknown extra field '#{name}'"
+        raise Error, "Unknown extra field '#{name}'"
       end
       self[name] = field_class.new
     end
@@ -60,17 +60,19 @@ module Zip
     # place Unknown last, so "extra" data that is missing the proper signature/size
     # does not prevent known fields from being read back in
     def ordered_values
-      self.keys.sort_by { |k| k == 'Unknown' ? 1 : 0 }.map { |k| self[k] }
+      result = []
+      self.each { |k,v| k == 'Unknown' ? result.push(v) : result.unshift(v) }
+      result
     end
 
     def to_local_bin
-      ordered_values.map { |v| v.to_local_bin.force_encoding('BINARY') }.join
+      ordered_values.map! { |v| v.to_local_bin.force_encoding('BINARY') }.join
     end
 
     alias :to_s :to_local_bin
 
     def to_c_dir_bin
-      ordered_values.map { |v| v.to_c_dir_bin.force_encoding('BINARY') }.join
+      ordered_values.map! { |v| v.to_c_dir_bin.force_encoding('BINARY') }.join
     end
 
     def c_dir_size
@@ -88,6 +90,7 @@ end
 
 require 'zip/extra_field/generic'
 require 'zip/extra_field/universal_time'
+require 'zip/extra_field/old_unix'
 require 'zip/extra_field/unix'
 require 'zip/extra_field/zip64'
 require 'zip/extra_field/zip64_placeholder'

data/lib/zip/extra_field/generic.rb

@@ -7,7 +7,7 @@ module Zip
     end
 
     def self.name
-      self.to_s.split("::")[-1]
+      @name ||= self.to_s.split("::")[-1]
     end
 
     # return field [size, content] or false
@@ -32,12 +32,12 @@ module Zip
 
     def to_local_bin
       s = pack_for_local
-      self.class.const_get(:HEADER_ID) + [s.bytesize].pack("v") + s
+      self.class.const_get(:HEADER_ID) + [s.bytesize].pack("v") << s
     end
 
     def to_c_dir_bin
       s = pack_for_c_dir
-      self.class.const_get(:HEADER_ID) + [s.bytesize].pack("v") + s
+      self.class.const_get(:HEADER_ID) + [s.bytesize].pack("v") << s
     end
   end
-end
+end

data/lib/zip/extra_field/old_unix.rb

@@ -0,0 +1,45 @@
+module Zip
+  # Olf Info-ZIP Extra for UNIX uid/gid and file timestampes
+  class ExtraField::OldUnix < ExtraField::Generic
+    HEADER_ID = "UX"
+    register_map
+
+    def initialize(binstr = nil)
+      @uid = 0
+      @gid = 0
+      @atime = nil
+      @mtime = nil
+      binstr and merge(binstr)
+    end
+
+    attr_accessor :uid, :gid, :atime, :mtime
+
+    def merge(binstr)
+      return if binstr.empty?
+      size, content = initial_parse(binstr)
+      # size: 0 for central directory. 4 for local header
+      return if (!size || size == 0)
+      atime, mtime, uid, gid = content.unpack("VVvv")
+      @uid ||= uid
+      @gid ||= gid
+      @atime ||= atime
+      @mtime ||= mtime
+    end
+
+    def ==(other)
+      @uid == other.uid &&
+        @gid == other.gid &&
+          @atime == other.atime &&
+            @mtime == other.mtime
+    end
+
+    def pack_for_local
+      [@atime, @mtime, @uid, @gid].pack("VVvv")
+    end
+
+    def pack_for_c_dir
+      [@atime, @mtime].pack("VV")
+    end
+  end
+
+end

data/lib/zip/file.rb

@@ -70,7 +70,7 @@ module Zip
       @comment = ''
       @create  = create
       case
-      when ::File.exists?(file_name) && !buffer
+      when !buffer && ::File.exist?(file_name)
         @create = nil
         @exist_file_perms = ::File.stat(file_name).mode
         ::File.open(name, 'rb') do |f|
@@ -79,7 +79,7 @@ module Zip
       when create
         @entry_set = EntrySet.new
       else
-        raise ZipError, "File #{file_name} not found"
+        raise Error, "File #{file_name} not found"
       end
       @stored_entries      = @entry_set.dup
       @stored_comment      = @comment
@@ -94,40 +94,38 @@ module Zip
       # ruby's builtin File.open method.
       def open(file_name, create = nil)
         zf = ::Zip::File.new(file_name, create)
-        if block_given?
-          begin
-            yield zf
-          ensure
-            zf.close
-          end
-        else
-          zf
+        return zf unless block_given?
+        begin
+          yield zf
+        ensure
+          zf.close
         end
       end
 
       # Same as #open. But outputs data to a buffer instead of a file
       def add_buffer
-        zf = ::Zip::File.new('', true, true)
+        io = ::StringIO.new('')
+        zf = ::Zip::File.new(io, true, true)
         yield zf
-        zf.write_buffer
+        zf.write_buffer(io)
       end
 
       # Like #open, but reads zip archive contents from a String or open IO
       # stream, and outputs data to a buffer.
-      # (This can be used to extract data from a 
+      # (This can be used to extract data from a
       # downloaded zip archive without first saving it to disk.)
       def open_buffer(io, options = {})
-        unless io.is_a?(IO) || io.is_a?(String)
-          raise "Zip::File.open_buffer expects an argument of class String or IO. Found: #{io.class}"
+        unless io.is_a?(IO) || io.is_a?(String) || io.is_a?(Tempfile)
+          raise "Zip::File.open_buffer expects an argument of class String, IO, or Tempfile. Found: #{io.class}"
         end
-        zf = ::Zip::File.new('', true, true, options)
         if io.is_a?(::String)
           require 'stringio'
           io = ::StringIO.new(io)
         end
+        zf = ::Zip::File.new(io, true, true, options)
         zf.read_from_stream(io)
         yield zf
-        zf.write_buffer
+        zf.write_buffer(io)
       end
 
       # Iterates over the contents of the ZipFile. This is more efficient
@@ -196,7 +194,7 @@ module Zip
 
       # Splits an archive into parts with segment size
       def split(zip_file_name, segment_size = MAX_SEGMENT_SIZE, delete_zip_file = true, partial_zip_file_name = nil)
-        raise ZipError, "File #{zip_file_name} not found" unless ::File.exists?(zip_file_name)
+        raise Error, "File #{zip_file_name} not found" unless ::File.exist?(zip_file_name)
         raise Errno::ENOENT, zip_file_name unless ::File.readable?(zip_file_name)
         zip_file_size = ::File.size(zip_file_name)
         segment_size  = get_segment_size_for_split(segment_size)
@@ -227,24 +225,24 @@ module Zip
 
     # Returns an output stream to the specified entry. If entry is not an instance
     # of Zip::Entry, a new Zip::Entry will be initialized using the arguments
-    # specified. If a block is passed the stream object is passed to the block and 
-    # the stream is automatically closed afterwards just as with ruby's builtin 
+    # specified. If a block is passed the stream object is passed to the block and
+    # the stream is automatically closed afterwards just as with ruby's builtin
     # File.open method.
-    def get_output_stream(entry, permissionInt = nil, comment = nil, extra = nil, compressed_size = nil, crc = nil, compression_method = nil, size = nil, time = nil,  &aProc)
-      newEntry =
+    def get_output_stream(entry, permission_int = nil, comment = nil, extra = nil, compressed_size = nil, crc = nil, compression_method = nil, size = nil, time = nil,  &aProc)
+      new_entry =
         if entry.kind_of?(Entry)
           entry
         else
           Entry.new(@name, entry.to_s, comment, extra, compressed_size, crc, compression_method, size, time)
         end
-      if newEntry.directory?
+      if new_entry.directory?
         raise ArgumentError,
-              "cannot open stream to directory entry - '#{newEntry}'"
+              "cannot open stream to directory entry - '#{new_entry}'"
       end
-      newEntry.unix_perms = permissionInt
-      zipStreamableEntry  = StreamableStream.new(newEntry)
-      @entry_set << zipStreamableEntry
-      zipStreamableEntry.get_output_stream(&aProc)
+      new_entry.unix_perms = permission_int
+      zip_streamable_entry = StreamableStream.new(new_entry)
+      @entry_set << zip_streamable_entry
+      zip_streamable_entry.get_output_stream(&aProc)
     end
 
     # Returns the name of the zip archive
@@ -258,12 +256,13 @@ module Zip
     end
 
     # Convenience method for adding the contents of a file to the archive
-    def add(entry, srcPath, &continue_on_exists_proc)
-      continue_on_exists_proc ||= proc { Zip.continue_on_exists_proc }
+    def add(entry, src_path, &continue_on_exists_proc)
+      continue_on_exists_proc ||= proc { ::Zip.continue_on_exists_proc }
       check_entry_exists(entry, continue_on_exists_proc, "add")
-      newEntry = entry.kind_of?(Entry) ? entry : Entry.new(@name, entry.to_s)
-      newEntry.gather_fileinfo_from_srcpath(srcPath)
-      @entry_set << newEntry
+      new_entry = entry.kind_of?(::Zip::Entry) ? entry : ::Zip::Entry.new(@name, entry.to_s)
+      new_entry.gather_fileinfo_from_srcpath(src_path)
+      new_entry.dirty = true
+      @entry_set << new_entry
     end
 
     # Removes the specified entry.
@@ -290,7 +289,7 @@ module Zip
 
     # Extracts entry to file dest_path.
     def extract(entry, dest_path, &block)
-      block       ||= proc { ::Zip.on_exists_proc }
+      block ||= proc { ::Zip.on_exists_proc }
       found_entry = get_entry(entry)
       found_entry.extract(dest_path, &block)
     end
@@ -298,9 +297,9 @@ module Zip
     # Commits changes that has been made since the previous commit to
     # the zip archive.
     def commit
-      return if !commit_required?
-      on_success_replace do |tmpFile|
-        ::Zip::OutputStream.open(tmpFile) do |zos|
+      return unless commit_required?
+      on_success_replace do |tmp_file|
+        ::Zip::OutputStream.open(tmp_file) do |zos|
           @entry_set.each do |e|
             e.write_to_zip_output_stream(zos)
             e.dirty = false
@@ -313,8 +312,8 @@ module Zip
     end
 
     # Write buffer write changes to buffer and return
-    def write_buffer
-      OutputStream.write_buffer do |zos|
+    def write_buffer(io)
+      ::Zip::OutputStream.write_buffer(io) do |zos|
         @entry_set.each { |e| e.write_to_zip_output_stream(zos) }
         zos.comment = comment
       end
@@ -331,7 +330,7 @@ module Zip
       @entry_set.each do |e|
         return true if e.dirty
       end
-      @comment != @stored_comment || @entry_set != @stored_entries || @create == File::CREATE
+      @comment != @stored_comment || @entry_set != @stored_entries || @create == ::Zip::File::CREATE
     end
 
     # Searches for entry with the specified name. Returns nil if
@@ -388,7 +387,7 @@ module Zip
         if continue_on_exists_proc.call
           remove get_entry(entryName)
         else
-          raise ZipEntryExistsError,
+          raise ::Zip::EntryExistsError,
                 procedureName + " failed. Entry #{entryName} already exists"
         end
       end
@@ -401,7 +400,7 @@ module Zip
     end
 
     def on_success_replace
-      tmpfile     = get_tempfile
+      tmpfile      = get_tempfile
       tmp_filename = tmpfile.path
       tmpfile.close
       if yield tmp_filename

data/lib/zip/inflater.rb

@@ -4,26 +4,42 @@ module Zip
       super
       @zlib_inflater           = ::Zlib::Inflate.new(-Zlib::MAX_WBITS)
       @output_buffer           = ''
+      @output_buffer_pos       = 0
       @has_returned_empty_string = false
     end
 
     def sysread(number_of_bytes = nil, buf = '')
+      buf ||= ''
+      buf.clear
       readEverything = number_of_bytes.nil?
-      while readEverything || @output_buffer.bytesize < number_of_bytes
+      if readEverything
+        buf << @output_buffer[@output_buffer_pos...@output_buffer.bytesize]
+
+        move_output_buffer_pos(buf.bytesize)
+      else
+        buf << @output_buffer[@output_buffer_pos, number_of_bytes]
+
+        move_output_buffer_pos(buf.bytesize)
+
+        if buf.bytesize == number_of_bytes
+          return buf
+        end
+      end
+      while readEverything || buf.bytesize + @output_buffer.bytesize < number_of_bytes
         break if internal_input_finished?
-        @output_buffer << internal_produce_input(buf)
+        @output_buffer << internal_produce_input
       end
-      return value_when_finished if @output_buffer.bytesize == 0 && input_finished?
-      end_index = number_of_bytes.nil? ? @output_buffer.bytesize : number_of_bytes
-      @output_buffer.slice!(0...end_index)
+      return value_when_finished(number_of_bytes, buf) if @output_buffer.bytesize == 0 && input_finished?
+      end_index = (number_of_bytes.nil? ? @output_buffer.bytesize : number_of_bytes) - buf.bytesize
+      data = @output_buffer[0...end_index]
+
+      move_output_buffer_pos(data.bytesize)
+
+      buf << data
     end
 
     def produce_input
-      if (@output_buffer.empty?)
-        internal_produce_input
-      else
-        @output_buffer.slice!(0...(@output_buffer.length))
-      end
+      sysread()
     end
 
     # to be used with produce_input, not read (as read may still have more data cached)
@@ -37,7 +53,16 @@ module Zip
 
     private
 
-    def internal_produce_input(buf = '')
+    def move_output_buffer_pos(inc)
+      @output_buffer_pos += inc
+      if @output_buffer_pos == @output_buffer.bytesize
+        @output_buffer.clear
+        @output_buffer_pos = 0
+      end
+    end
+
+    def internal_produce_input
+      buf = ''
       retried = 0
       begin
         @zlib_inflater.inflate(@input_stream.read(Decompressor::CHUNK_SIZE, buf))
@@ -52,10 +77,14 @@ module Zip
       @zlib_inflater.finished?
     end
 
-    def value_when_finished # mimic behaviour of ruby File object.
-      return if @has_returned_empty_string
-      @has_returned_empty_string = true
-      ''
+    def value_when_finished(number_of_bytes, buf) # mimic behaviour of ruby File object.
+      if number_of_bytes.nil?
+        buf
+      elsif buf.bytesize == 0
+        nil
+      else
+        buf
+      end
     end
   end
 end

data/lib/zip/input_stream.rb

@@ -1,41 +1,41 @@
 module Zip
   # InputStream is the basic class for reading zip entries in a
   # zip file. It is possible to create a InputStream object directly,
-  # passing the zip file name to the constructor, but more often than not 
+  # passing the zip file name to the constructor, but more often than not
   # the InputStream will be obtained from a File (perhaps using the
-  # ZipFileSystem interface) object for a particular entry in the zip 
+  # ZipFileSystem interface) object for a particular entry in the zip
   # archive.
   #
   # A InputStream inherits IOExtras::AbstractInputStream in order
-  # to provide an IO-like interface for reading from a single zip 
-  # entry. Beyond methods for mimicking an IO-object it contains 
-  # the method get_next_entry for iterating through the entries of 
+  # to provide an IO-like interface for reading from a single zip
+  # entry. Beyond methods for mimicking an IO-object it contains
+  # the method get_next_entry for iterating through the entries of
   # an archive. get_next_entry returns a Entry object that describes
   # the zip entry the InputStream is currently reading from.
   #
-  # Example that creates a zip archive with ZipOutputStream and reads it 
+  # Example that creates a zip archive with ZipOutputStream and reads it
   # back again with a InputStream.
   #
   #   require 'zip'
-  #   
+  #
   #   Zip::OutputStream.open("my.zip") do |io|
-  #   
+  #
   #     io.put_next_entry("first_entry.txt")
   #     io.write "Hello world!"
-  #   
+  #
   #     io.put_next_entry("adir/first_entry.txt")
   #     io.write "Hello again!"
   #   end
   #
-  #   
+  #
   #   Zip::InputStream.open("my.zip") do |io|
-  #   
+  #
   #     while (entry = io.get_next_entry)
   #       puts "Contents of #{entry.name}: '#{io.read}'"
   #     end
   #   end
   #
-  # java.util.zip.ZipInputStream is the original inspiration for this 
+  # java.util.zip.ZipInputStream is the original inspiration for this
   # class.
 
   class InputStream
@@ -60,7 +60,7 @@ module Zip
 
     # Returns a Entry object. It is necessary to call this
     # method on a newly created InputStream before reading from
-    # the first entry in the archive. Returns nil when there are 
+    # the first entry in the archive. Returns nil when there are
     # no more entries.
     def get_next_entry
       @archive_io.seek(@current_entry.next_header_offset, IO::SEEK_SET) if @current_entry
@@ -112,7 +112,9 @@ module Zip
     def get_io(io_or_file, offset = 0)
       case io_or_file
       when IO, StringIO
-        io_or_file
+        io = io_or_file.dup
+        io.seek(offset, ::IO::SEEK_SET)
+        io
       else
         file = ::File.open(io_or_file, 'rb')
         file.seek(offset, ::IO::SEEK_SET)
@@ -136,7 +138,7 @@ module Zip
       when @current_entry.compression_method == ::Zip::Entry::DEFLATED
         ::Zip::Inflater.new(@archive_io)
       else
-        raise ZipCompressionMethodError,
+        raise ::Zip::CompressionMethodError,
               "Unsupported compression method #{@current_entry.compression_method}"
       end
     end

data/lib/zip/output_stream.rb

@@ -24,14 +24,17 @@ module Zip
 
     # Opens the indicated zip file. If a file with that name already
     # exists it will be overwritten.
-    def initialize(fileName, stream=false)
+    def initialize(file_name, stream=false)
       super()
-      @fileName = fileName
-      if stream
-        @output_stream = ::StringIO.new
-      else
-        @output_stream = ::File.new(@fileName, "wb")
-      end
+      @file_name = file_name
+      @output_stream = if stream
+                         iostream = @file_name.dup
+                         iostream.reopen
+                         iostream.rewind
+                         iostream
+                       else
+                         ::File.new(@file_name, "wb")
+                       end
       @entry_set = ::Zip::EntrySet.new
       @compressor = ::Zip::NullCompressor.instance
       @closed = false
@@ -43,19 +46,19 @@ module Zip
     # stream is passed to the block and closed when the block
     # returns.
     class << self
-      def open(fileName)
-        return new(fileName) unless block_given?
-        zos = new(fileName)
+      def open(file_name)
+        return new(file_name) unless block_given?
+        zos = new(file_name)
         yield zos
       ensure
         zos.close if zos
       end
 
-	    # Same as #open but writes to a filestream instead
-      def write_buffer
-        zos = new('', true)
+      # Same as #open but writes to a filestream instead
+      def write_buffer(io)
+        zos = new(io, true)
         yield zos
-        return zos.close_buffer
+        zos.close_buffer
       end
     end
 
@@ -79,35 +82,36 @@ module Zip
       @output_stream
     end
 
-	  # Closes the current entry and opens a new for writing.
+    # Closes the current entry and opens a new for writing.
     # +entry+ can be a ZipEntry object or a string.
-    def put_next_entry(entryname, comment = nil, extra = nil, compression_method = Entry::DEFLATED,  level = Zlib::DEFAULT_COMPRESSION)
-      raise ZipError, "zip stream is closed" if @closed
-      if entryname.kind_of?(Entry)
-        new_entry = entryname
+    def put_next_entry(entry_name, comment = nil, extra = nil, compression_method = Entry::DEFLATED, level = Zip.default_compression)
+      raise Error, "zip stream is closed" if @closed
+      if entry_name.kind_of?(Entry)
+        new_entry = entry_name
       else
-        new_entry = Entry.new(@fileName, entryname.to_s)
+        new_entry = Entry.new(@file_name, entry_name.to_s)
       end
-      new_entry.comment = comment if !comment.nil?
-      if (!extra.nil?)
+      new_entry.comment = comment unless comment.nil?
+      unless extra.nil?
         new_entry.extra = ExtraField === extra ? extra : ExtraField.new(extra.to_s)
       end
-      new_entry.compression_method = compression_method if !compression_method.nil?
+      new_entry.compression_method = compression_method unless compression_method.nil?
       init_next_entry(new_entry, level)
       @current_entry = new_entry
     end
 
     def copy_raw_entry(entry)
       entry = entry.dup
-      raise ZipError, "zip stream is closed" if @closed
-      raise ZipError, "entry is not a ZipEntry" if !entry.kind_of?(Entry)
+      raise Error, "zip stream is closed" if @closed
+      raise Error, "entry is not a ZipEntry" unless entry.is_a?(Entry)
       finalize_current_entry
       @entry_set << entry
-      src_pos = entry.local_entry_offset
+      src_pos = entry.local_header_offset
       entry.write_local_entry(@output_stream)
       @compressor = NullCompressor.instance
       entry.get_raw_input_stream do |is|
         is.seek(src_pos, IO::SEEK_SET)
+        ::Zip::Entry.read_local_entry(is)
         IOExtras.copy_stream_n(@output_stream, is, entry.compressed_size)
       end
       @compressor = NullCompressor.instance
@@ -123,10 +127,10 @@ module Zip
       @current_entry.size = @compressor.size
       @current_entry.crc = @compressor.crc
       @current_entry = nil
-      @compressor = NullCompressor.instance
+      @compressor = ::Zip::NullCompressor.instance
     end
 
-    def init_next_entry(entry, level = Zlib::DEFAULT_COMPRESSION)
+    def init_next_entry(entry, level = Zip.default_compression)
       finalize_current_entry
       @entry_set << entry
       entry.write_local_entry(@output_stream)
@@ -135,10 +139,13 @@ module Zip
 
     def get_compressor(entry, level)
       case entry.compression_method
-        when Entry::DEFLATED then Deflater.new(@output_stream, level)
-        when Entry::STORED   then PassThruCompressor.new(@output_stream)
-      else raise ZipCompressionMethodError,
-        "Invalid compression method: '#{entry.compression_method}'"
+      when Entry::DEFLATED then
+        ::Zip::Deflater.new(@output_stream, level)
+      when Entry::STORED then
+        ::Zip::PassThruCompressor.new(@output_stream)
+      else
+        raise ::Zip::CompressionMethodError,
+              "Invalid compression method: '#{entry.compression_method}'"
       end
     end
 
@@ -163,10 +170,13 @@ module Zip
     end
 
     public
+
     # Modeled after IO.<<
     def << (data)
       @compressor << data
+      self
     end
+
   end
 end
 

data/lib/zip/streamable_stream.rb

@@ -2,39 +2,44 @@ module Zip
   class StreamableStream < DelegateClass(Entry) #nodoc:all
     def initialize(entry)
       super(entry)
-      @tempFile = Tempfile.new(::File.basename(name), ::File.dirname(zipfile))
-      @tempFile.binmode
+      dirname = if zipfile.is_a?(::String)
+                  ::File.dirname(zipfile)
+                else
+                  '.'
+                end
+      @temp_file = Tempfile.new(::File.basename(name), dirname)
+      @temp_file.binmode
     end
 
     def get_output_stream
       if block_given?
         begin
-          yield(@tempFile)
+          yield(@temp_file)
         ensure
-          @tempFile.close
+          @temp_file.close
         end
       else
-        @tempFile
+        @temp_file
       end
     end
 
     def get_input_stream
-      if ! @tempFile.closed?
+      if !@temp_file.closed?
         raise StandardError, "cannot open entry for reading while its open for writing - #{name}"
       end
-      @tempFile.open # reopens tempfile from top
-      @tempFile.binmode
+      @temp_file.open # reopens tempfile from top
+      @temp_file.binmode
       if block_given?
         begin
-          yield(@tempFile)
+          yield(@temp_file)
         ensure
-          @tempFile.close
+          @temp_file.close
         end
       else
-        @tempFile
+        @temp_file
       end
     end
-    
+
     def write_to_zip_output_stream(aZipOutputStream)
       aZipOutputStream.put_next_entry(self)
       get_input_stream { |is| ::Zip::IOExtras.copy_stream(aZipOutputStream, is) }

data/lib/zip/version.rb

@@ -1,3 +1,3 @@
 module Zip
-  VERSION = '1.1.0'
+  VERSION = '1.1.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubyzip
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Alexander Simonov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-01 00:00:00.000000000 Z
+date: 2014-03-16 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -34,6 +34,7 @@ files:
 - lib/zip/entry_set.rb
 - lib/zip/errors.rb
 - lib/zip/extra_field/generic.rb
+- lib/zip/extra_field/old_unix.rb
 - lib/zip/extra_field/universal_time.rb
 - lib/zip/extra_field/unix.rb
 - lib/zip/extra_field/zip64.rb