rubyzip 0.9.9 → 1.3.0

data/lib/zip/output_stream.rb

@@ -0,0 +1,189 @@
+module Zip
+  # ZipOutputStream is the basic class for writing zip files. It is
+  # possible to create a ZipOutputStream object directly, passing
+  # the zip file name to the constructor, but more often than not
+  # the ZipOutputStream will be obtained from a ZipFile (perhaps using the
+  # ZipFileSystem interface) object for a particular entry in the zip
+  # archive.
+  #
+  # A ZipOutputStream inherits IOExtras::AbstractOutputStream in order
+  # to provide an IO-like interface for writing to a single zip
+  # entry. Beyond methods for mimicking an IO-object it contains
+  # the method put_next_entry that closes the current entry
+  # and creates a new.
+  #
+  # Please refer to ZipInputStream for example code.
+  #
+  # java.util.zip.ZipOutputStream is the original inspiration for this
+  # class.
+
+  class OutputStream
+    include ::Zip::IOExtras::AbstractOutputStream
+
+    attr_accessor :comment
+
+    # Opens the indicated zip file. If a file with that name already
+    # exists it will be overwritten.
+    def initialize(file_name, stream = false, encrypter = nil)
+      super()
+      @file_name = file_name
+      @output_stream = if stream
+                         iostream = @file_name.dup
+                         iostream.reopen(@file_name)
+                         iostream.rewind
+                         iostream
+                       else
+                         ::File.new(@file_name, 'wb')
+                       end
+      @entry_set = ::Zip::EntrySet.new
+      @compressor = ::Zip::NullCompressor.instance
+      @encrypter = encrypter || ::Zip::NullEncrypter.new
+      @closed = false
+      @current_entry = nil
+      @comment = nil
+    end
+
+    # Same as #initialize but if a block is passed the opened
+    # stream is passed to the block and closed when the block
+    # returns.
+    class << self
+      def open(file_name, encrypter = nil)
+        return new(file_name) unless block_given?
+        zos = new(file_name, false, encrypter)
+        yield zos
+      ensure
+        zos.close if zos
+      end
+
+      # Same as #open but writes to a filestream instead
+      def write_buffer(io = ::StringIO.new(''), encrypter = nil)
+        zos = new(io, true, encrypter)
+        yield zos
+        zos.close_buffer
+      end
+    end
+
+    # Closes the stream and writes the central directory to the zip file
+    def close
+      return if @closed
+      finalize_current_entry
+      update_local_headers
+      write_central_directory
+      @output_stream.close
+      @closed = true
+    end
+
+    # Closes the stream and writes the central directory to the zip file
+    def close_buffer
+      return @output_stream if @closed
+      finalize_current_entry
+      update_local_headers
+      write_central_directory
+      @closed = true
+      @output_stream
+    end
+
+    # Closes the current entry and opens a new for writing.
+    # +entry+ can be a ZipEntry object or a string.
+    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
+      new_entry = if entry_name.kind_of?(Entry)
+                    entry_name
+                  else
+                    Entry.new(@file_name, entry_name.to_s)
+                  end
+      new_entry.comment = comment unless comment.nil?
+      unless extra.nil?
+        new_entry.extra = extra.is_a?(ExtraField) ? extra : ExtraField.new(extra.to_s)
+      end
+      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 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_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
+      @current_entry = nil
+    end
+
+    private
+
+    def finalize_current_entry
+      return unless @current_entry
+      finish
+      @current_entry.compressed_size = @output_stream.tell - @current_entry.local_header_offset - @current_entry.calculate_local_header_size
+      @current_entry.size = @compressor.size
+      @current_entry.crc = @compressor.crc
+      @output_stream << @encrypter.data_descriptor(@current_entry.crc, @current_entry.compressed_size, @current_entry.size)
+      @current_entry.gp_flags |= @encrypter.gp_flags
+      @current_entry = nil
+      @compressor = ::Zip::NullCompressor.instance
+    end
+
+    def init_next_entry(entry, level = Zip.default_compression)
+      finalize_current_entry
+      @entry_set << entry
+      entry.write_local_entry(@output_stream)
+      @encrypter.reset!
+      @output_stream << @encrypter.header(entry.mtime)
+      @compressor = get_compressor(entry, level)
+    end
+
+    def get_compressor(entry, level)
+      case entry.compression_method
+      when Entry::DEFLATED then
+        ::Zip::Deflater.new(@output_stream, level, @encrypter)
+      when Entry::STORED then
+        ::Zip::PassThruCompressor.new(@output_stream)
+      else
+        raise ::Zip::CompressionMethodError,
+              "Invalid compression method: '#{entry.compression_method}'"
+      end
+    end
+
+    def update_local_headers
+      pos = @output_stream.pos
+      @entry_set.each do |entry|
+        @output_stream.pos = entry.local_header_offset
+        entry.write_local_entry(@output_stream, true)
+      end
+      @output_stream.pos = pos
+    end
+
+    def write_central_directory
+      cdir = CentralDirectory.new(@entry_set, @comment)
+      cdir.write_to_stream(@output_stream)
+    end
+
+    protected
+
+    def finish
+      @compressor.finish
+    end
+
+    public
+
+    # Modeled after IO.<<
+    def <<(data)
+      @compressor << data
+      self
+    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/pass_thru_compressor.rb

@@ -2,16 +2,16 @@ module Zip
   class PassThruCompressor < Compressor #:nodoc:all
     def initialize(outputStream)
       super()
-      @outputStream = outputStream
-      @crc = Zlib::crc32
+      @output_stream = outputStream
+      @crc = Zlib.crc32
       @size = 0
     end
-    
-    def << (data)
+
+    def <<(data)
       val = data.to_s
-      @crc = Zlib::crc32(val, @crc)
+      @crc = Zlib.crc32(val, @crc)
       @size += val.bytesize
-      @outputStream << val
+      @output_stream << val
     end
 
     attr_reader :size, :crc

data/lib/zip/pass_thru_decompressor.rb

@@ -1,37 +1,37 @@
 module Zip
-  class PassThruDecompressor < Decompressor  #:nodoc:all
-    def initialize(inputStream, charsToRead)
-      super inputStream
-      @charsToRead = charsToRead
-      @readSoFar = 0
-      @hasReturnedEmptyString = ! EMPTY_FILE_RETURNS_EMPTY_STRING_FIRST
+  class PassThruDecompressor < Decompressor #:nodoc:all
+    def initialize(input_stream, chars_to_read)
+      super(input_stream)
+      @chars_to_read = chars_to_read
+      @read_so_far = 0
+      @has_returned_empty_string = false
     end
 
-    # TODO: Specialize to handle different behaviour in ruby > 1.7.0 ?
-    def sysread(numberOfBytes = nil, buf = nil)
+    def sysread(number_of_bytes = nil, buf = '')
       if input_finished?
-        hasReturnedEmptyStringVal = @hasReturnedEmptyString
-        @hasReturnedEmptyString = true
-        return "" unless hasReturnedEmptyStringVal
+        has_returned_empty_string_val = @has_returned_empty_string
+        @has_returned_empty_string = true
+        return '' unless has_returned_empty_string_val
         return
       end
 
-      if (numberOfBytes == nil || @readSoFar + numberOfBytes > @charsToRead)
-        numberOfBytes = @charsToRead - @readSoFar
+      if number_of_bytes.nil? || @read_so_far + number_of_bytes > @chars_to_read
+        number_of_bytes = @chars_to_read - @read_so_far
       end
-      @readSoFar += numberOfBytes
-      @inputStream.read(numberOfBytes, buf)
+      @read_so_far += number_of_bytes
+      @input_stream.read(number_of_bytes, buf)
     end
 
     def produce_input
-      sysread(Decompressor::CHUNK_SIZE)
+      sysread(::Zip::Decompressor::CHUNK_SIZE)
     end
 
     def input_finished?
-      (@readSoFar >= @charsToRead)
+      @read_so_far >= @chars_to_read
     end
-    alias :eof :input_finished?
-    alias :eof? :input_finished?
+
+    alias eof input_finished?
+    alias eof? input_finished?
   end
 end
 

data/lib/zip/{zip_streamable_directory.rb → streamable_directory.rb}

@@ -1,11 +1,11 @@
 module Zip
-  class ZipStreamableDirectory < ZipEntry
+  class StreamableDirectory < Entry
     def initialize(zipfile, entry, srcPath = nil, permissionInt = nil)
       super(zipfile, entry)
 
       @ftype = :directory
-      entry.get_extra_attributes_from_path(srcPath) if (srcPath)
-      @unix_perms = permissionInt if (permissionInt)
+      entry.get_extra_attributes_from_path(srcPath) if srcPath
+      @unix_perms = permissionInt if permissionInt
     end
   end
 end

data/lib/zip/streamable_stream.rb

@@ -0,0 +1,56 @@
+module Zip
+  class StreamableStream < DelegateClass(Entry) # nodoc:all
+    def initialize(entry)
+      super(entry)
+      dirname = if zipfile.is_a?(::String)
+                  ::File.dirname(zipfile)
+                else
+                  nil
+                end
+      @temp_file = Tempfile.new(::File.basename(name), dirname)
+      @temp_file.binmode
+    end
+
+    def get_output_stream
+      if block_given?
+        begin
+          yield(@temp_file)
+        ensure
+          @temp_file.close
+        end
+      else
+        @temp_file
+      end
+    end
+
+    def get_input_stream
+      unless @temp_file.closed?
+        raise StandardError, "cannot open entry for reading while its open for writing - #{name}"
+      end
+      @temp_file.open # reopens tempfile from top
+      @temp_file.binmode
+      if block_given?
+        begin
+          yield(@temp_file)
+        ensure
+          @temp_file.close
+        end
+      else
+        @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) }
+    end
+
+    def clean_up
+      @temp_file.unlink
+    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/version.rb

@@ -0,0 +1,3 @@
+module Zip
+  VERSION = '1.3.0'
+end

data/lib/zip.rb

@@ -0,0 +1,71 @@
+require 'delegate'
+require 'singleton'
+require 'tempfile'
+require 'tmpdir'
+require 'fileutils'
+require 'stringio'
+require 'zlib'
+require 'zip/dos_time'
+require 'zip/ioextras'
+require 'rbconfig'
+require 'zip/entry'
+require 'zip/extra_field'
+require 'zip/entry_set'
+require 'zip/central_directory'
+require 'zip/file'
+require 'zip/input_stream'
+require 'zip/output_stream'
+require 'zip/decompressor'
+require 'zip/compressor'
+require 'zip/null_decompressor'
+require 'zip/null_compressor'
+require 'zip/null_input_stream'
+require 'zip/pass_thru_compressor'
+require 'zip/pass_thru_decompressor'
+require 'zip/crypto/encryption'
+require 'zip/crypto/null_encryption'
+require 'zip/crypto/traditional_encryption'
+require 'zip/inflater'
+require 'zip/deflater'
+require 'zip/streamable_stream'
+require 'zip/streamable_directory'
+require 'zip/constants'
+require 'zip/errors'
+
+module Zip
+  extend self
+  attr_accessor :unicode_names,
+                :on_exists_proc,
+                :continue_on_exists_proc,
+                :sort_entries,
+                :default_compression,
+                :write_zip64_support,
+                :warn_invalid_date,
+                :case_insensitive_match,
+                :force_entry_names_encoding,
+                :validate_entry_sizes
+
+  def reset!
+    @_ran_once = false
+    @unicode_names = false
+    @on_exists_proc = false
+    @continue_on_exists_proc = false
+    @sort_entries = false
+    @default_compression = ::Zlib::DEFAULT_COMPRESSION
+    @write_zip64_support = false
+    @warn_invalid_date = true
+    @case_insensitive_match = false
+    @validate_entry_sizes = false
+  end
+
+  def setup
+    yield self unless @_ran_once
+    @_ran_once = true
+  end
+
+  reset!
+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/samples/example.rb

@@ -1,66 +1,78 @@
 #!/usr/bin/env ruby
 
-$: << "../lib"
-system("zip example.zip example.rb gtkRubyzip.rb")
+$: << '../lib'
+system('zip example.zip example.rb gtk_ruby_zip.rb')
 
-require 'zip/zip'
+require 'zip'
 
 ####### Using ZipInputStream alone: #######
 
-Zip::ZipInputStream.open("example.zip") {
-  |zis|
+Zip::InputStream.open('example.zip') do |zis|
   entry = zis.get_next_entry
   print "First line of '#{entry.name} (#{entry.size} bytes):  "
   puts "'#{zis.gets.chomp}'"
   entry = zis.get_next_entry
   print "First line of '#{entry.name} (#{entry.size} bytes):  "
   puts "'#{zis.gets.chomp}'"
-}
-
+end
 
 ####### Using ZipFile to read the directory of a zip file: #######
 
-zf = Zip::ZipFile.new("example.zip")
-zf.each_with_index {
-  |entry, index|
-  
+zf = Zip::File.new('example.zip')
+zf.each_with_index do |entry, index|
   puts "entry #{index} is #{entry.name}, size = #{entry.size}, compressed size = #{entry.compressed_size}"
   # use zf.get_input_stream(entry) to get a ZipInputStream for the entry
   # entry can be the ZipEntry object or any object which has a to_s method that
   # returns the name of the entry.
-}
-
+end
 
 ####### Using ZipOutputStream to write a zip file: #######
 
-Zip::ZipOutputStream.open("exampleout.zip") {
-  |zos|
-  zos.put_next_entry("the first little entry")
-  zos.puts "Hello hello hello hello hello hello hello hello hello"
+Zip::OutputStream.open('exampleout.zip') do |zos|
+  zos.put_next_entry('the first little entry')
+  zos.puts 'Hello hello hello hello hello hello hello hello hello'
 
-  zos.put_next_entry("the second little entry")
-  zos.puts "Hello again"
+  zos.put_next_entry('the second little entry')
+  zos.puts 'Hello again'
 
   # Use rubyzip or your zip client of choice to verify
   # the contents of exampleout.zip
-}
+end
 
 ####### Using ZipFile to change a zip file: #######
 
-Zip::ZipFile.open("exampleout.zip") {
-  |zf|
-  zf.add("thisFile.rb", "example.rb")
-  zf.rename("thisFile.rb", "ILikeThisName.rb")
-  zf.add("Again", "example.rb")
-}
+Zip::File.open('exampleout.zip') do |zip_file|
+  zip_file.add('thisFile.rb', 'example.rb')
+  zip_file.rename('thisFile.rb', 'ILikeThisName.rb')
+  zip_file.add('Again', 'example.rb')
+end
 
 # Lets check
-Zip::ZipFile.open("exampleout.zip") {
-  |zf|
-  puts "Changed zip file contains: #{zf.entries.join(', ')}"
-  zf.remove("Again")
-  puts "Without 'Again': #{zf.entries.join(', ')}"
-}
+Zip::File.open('exampleout.zip') do |zip_file|
+  puts "Changed zip file contains: #{zip_file.entries.join(', ')}"
+  zip_file.remove('Again')
+  puts "Without 'Again': #{zip_file.entries.join(', ')}"
+end
+
+####### Using ZipFile to split a zip file: #######
+
+# Creating large zip file for splitting
+Zip::OutputStream.open('large_zip_file.zip') do |zos|
+  puts 'Creating zip file...'
+  10.times do |i|
+    zos.put_next_entry("large_entry_#{i}.txt")
+    zos.puts 'Hello' * 104_857_600
+  end
+end
+
+# Splitting created large zip file
+part_zips_count = Zip::File.split('large_zip_file.zip', 2_097_152, false)
+puts "Zip file splitted in #{part_zips_count} parts"
+
+# Track splitting an archive
+Zip::File.split('large_zip_file.zip', 1_048_576, true, 'part_zip_file') do |part_count, part_index, chunk_bytes, segment_bytes|
+  puts "#{part_index} of #{part_count} part splitting: #{(chunk_bytes.to_f / segment_bytes.to_f * 100).to_i}%"
+end
 
 # For other examples, look at zip.rb and ziptest.rb
 

data/samples/example_filesystem.rb

@@ -1,30 +1,28 @@
 #!/usr/bin/env ruby
 
-$: << "../lib"
+$: << '../lib'
 
-require 'zip/zipfilesystem'
+require 'zip/filesystem'
 
-EXAMPLE_ZIP = "filesystem.zip"
+EXAMPLE_ZIP = 'filesystem.zip'
 
-File.delete(EXAMPLE_ZIP) if File.exists?(EXAMPLE_ZIP)
+File.delete(EXAMPLE_ZIP) if File.exist?(EXAMPLE_ZIP)
 
-Zip::ZipFile.open(EXAMPLE_ZIP, Zip::ZipFile::CREATE) {
-  |zf|
-  zf.file.open("file1.txt", "w") { |os| os.write "first file1.txt" }
-  zf.dir.mkdir("dir1")
-  zf.dir.chdir("dir1")
-  zf.file.open("file1.txt", "w") { |os| os.write "second file1.txt" }
-  puts zf.file.read("file1.txt")
-  puts zf.file.read("../file1.txt")
-  zf.dir.chdir("..")
-  zf.file.open("file2.txt", "w") { |os| os.write "first file2.txt" }
+Zip::File.open(EXAMPLE_ZIP, Zip::File::CREATE) do |zf|
+  zf.file.open('file1.txt', 'w') { |os| os.write 'first file1.txt' }
+  zf.dir.mkdir('dir1')
+  zf.dir.chdir('dir1')
+  zf.file.open('file1.txt', 'w') { |os| os.write 'second file1.txt' }
+  puts zf.file.read('file1.txt')
+  puts zf.file.read('../file1.txt')
+  zf.dir.chdir('..')
+  zf.file.open('file2.txt', 'w') { |os| os.write 'first file2.txt' }
   puts "Entries:                   #{zf.entries.join(', ')}"
-}
+end
 
-Zip::ZipFile.open(EXAMPLE_ZIP) {
-  |zf|
+Zip::File.open(EXAMPLE_ZIP) do |zf|
   puts "Entries from reloaded zip: #{zf.entries.join(', ')}"
-}
+end
 
 # For other examples, look at zip.rb and ziptest.rb
 

data/samples/example_recursive.rb

@@ -1,4 +1,4 @@
-require 'zip/zip'
+require 'zip'
 
 # This is a simple example which uses rubyzip to
 # recursively generate a zip file from the contents of
@@ -6,44 +6,49 @@ require 'zip/zip'
 # included in the archive, rather just its contents.
 #
 # Usage:
-#   directoryToZip = "/tmp/input"
-#   outputFile = "/tmp/out.zip"   
-#   zf = ZipFileGenerator.new(directoryToZip, outputFile)
+#   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(inputDir, outputFile)
-    @inputDir = inputDir
-    @outputFile = outputFile
+  def initialize(input_dir, output_file)
+    @input_dir = input_dir
+    @output_file = output_file
   end
 
   # Zip the input directory.
-  def write()
-    entries = Dir.entries(@inputDir); entries.delete("."); entries.delete("..") 
-    io = Zip::ZipFile.open(@outputFile, Zip::ZipFile::CREATE); 
+  def write
+    entries = Dir.entries(@input_dir) - %w[. ..]
 
-    writeEntries(entries, "", io)
-    io.close();
+    ::Zip::File.open(@output_file, ::Zip::File::CREATE) do |zipfile|
+      write_entries entries, '', zipfile
+    end
   end
 
-  # A helper method to make the recursion work.
   private
-  def writeEntries(entries, path, io)
-    
-    entries.each { |e|
-      zipFilePath = path == "" ? e : File.join(path, e)
-      diskFilePath = File.join(@inputDir, zipFilePath)
-      puts "Deflating " + diskFilePath
-      if  File.directory?(diskFilePath)
-        io.mkdir(zipFilePath)
-        subdir =Dir.entries(diskFilePath); subdir.delete("."); subdir.delete("..") 
-        writeEntries(subdir, zipFilePath, io)
+
+  # 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
-        io.get_output_stream(zipFilePath) { |f| f.puts(File.open(diskFilePath, "rb").read())}
+        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
-    
-end
 
+  def put_into_archive(disk_file_path, zipfile, zipfile_path)
+    zipfile.add(zipfile_path, disk_file_path)
+  end
+end