rubyzip 0.9.9 → 1.0.0.beta1

data/lib/zip/null_compressor.rb

@@ -2,7 +2,7 @@ module Zip
   class NullCompressor < Compressor #:nodoc:all
     include Singleton
 
-    def << (data)
+    def <<(data)
       raise IOError, "closed stream"
     end
 

data/lib/zip/null_decompressor.rb

@@ -1,14 +1,15 @@
 module Zip
-  class NullDecompressor  #:nodoc:all
+  class NullDecompressor #:nodoc:all
     include Singleton
+
     def sysread(numberOfBytes = nil, buf = nil)
       nil
     end
-    
+
     def produce_input
       nil
     end
-    
+
     def input_finished?
       true
     end
@@ -16,6 +17,7 @@ module Zip
     def eof
       true
     end
+
     alias :eof? :eof
   end
 end

data/lib/zip/null_input_stream.rb

@@ -1,6 +1,6 @@
 module Zip
-  class NullInputStream < NullDecompressor  #:nodoc:all
-    include IOExtras::AbstractInputStream
+  class NullInputStream < NullDecompressor #:nodoc:all
+    include ::Zip::IOExtras::AbstractInputStream
   end
 end
 

data/lib/zip/{zip_output_stream.rb → output_stream.rb}

@@ -17,8 +17,8 @@ module Zip
   # java.util.zip.ZipOutputStream is the original inspiration for this
   # class.
 
-  class ZipOutputStream
-    include IOExtras::AbstractOutputStream
+  class OutputStream
+    include ::Zip::IOExtras::AbstractOutputStream
 
     attr_accessor :comment
 
@@ -28,12 +28,12 @@ module Zip
       super()
       @fileName = fileName
       if stream
-        @outputStream = StringIO.new
+        @output_stream = ::StringIO.new
       else
-        @outputStream = ::File.new(@fileName, "wb")
+        @output_stream = ::File.new(@fileName, "wb")
       end
-      @entrySet = ZipEntrySet.new
-      @compressor = NullCompressor.instance
+      @entry_set = ::Zip::EntrySet.new
+      @compressor = ::Zip::NullCompressor.instance
       @closed = false
       @currentEntry = nil
       @comment = nil
@@ -42,19 +42,21 @@ module Zip
     # Same as #initialize but if a block is passed the opened
     # stream is passed to the block and closed when the block
     # returns.
-    def ZipOutputStream.open(fileName)
-      return new(fileName) unless block_given?
-      zos = new(fileName)
-      yield zos
-    ensure
-      zos.close if zos
-    end
+    class << self
+      def open(fileName)
+        return new(fileName) unless block_given?
+        zos = new(fileName)
+        yield zos
+      ensure
+        zos.close if zos
+      end
 
-	# Same as #open but writes to a filestream instead
-    def ZipOutputStream.write_buffer
-      zos = new('', true)
-      yield zos
-      return zos.close_buffer
+	    # Same as #open but writes to a filestream instead
+      def write_buffer
+        zos = new('', true)
+        yield zos
+        return zos.close_buffer
+      end
     end
 
     # Closes the stream and writes the central directory to the zip file
@@ -63,32 +65,32 @@ module Zip
       finalize_current_entry
       update_local_headers
       write_central_directory
-      @outputStream.close
+      @output_stream.close
       @closed = true
     end
 
     # Closes the stream and writes the central directory to the zip file
     def close_buffer
-      return @outputStream if @closed
+      return @output_stream if @closed
       finalize_current_entry
       update_local_headers
       write_central_directory
       @closed = true
-      @outputStream
+      @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(entryname, comment = nil, extra = nil, compression_method = ZipEntry::DEFLATED,  level = Zlib::DEFAULT_COMPRESSION)
+    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?(ZipEntry)
+      if entryname.kind_of?(Entry)
         new_entry = entryname
       else
-        new_entry = ZipEntry.new(@fileName, entryname.to_s)
+        new_entry = Entry.new(@fileName, entryname.to_s)
       end
       new_entry.comment = comment if !comment.nil?
       if (!extra.nil?)
-        new_entry.extra = ZipExtraField === extra ? extra : ZipExtraField.new(extra.to_s)
+        new_entry.extra = ExtraField === extra ? extra : ExtraField.new(extra.to_s)
       end
       new_entry.compression_method = compression_method if !compression_method.nil?
       init_next_entry(new_entry, level)
@@ -98,15 +100,15 @@ module Zip
     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?(ZipEntry)
+      raise ZipError, "entry is not a ZipEntry" if !entry.kind_of?(Entry)
       finalize_current_entry
-      @entrySet << entry
+      @entry_set << entry
       src_pos = entry.local_entry_offset
-      entry.write_local_entry(@outputStream)
+      entry.write_local_entry(@output_stream)
       @compressor = NullCompressor.instance
       entry.get_raw_input_stream do |is|
         is.seek(src_pos, IO::SEEK_SET)
-        IOExtras.copy_stream_n(@outputStream, is, entry.compressed_size)
+        IOExtras.copy_stream_n(@output_stream, is, entry.compressed_size)
       end
       @compressor = NullCompressor.instance
       @currentEntry = nil
@@ -117,7 +119,7 @@ module Zip
     def finalize_current_entry
       return unless @currentEntry
       finish
-      @currentEntry.compressed_size = @outputStream.tell - @currentEntry.localHeaderOffset - @currentEntry.calculate_local_header_size
+      @currentEntry.compressed_size = @output_stream.tell - @currentEntry.local_header_offset - @currentEntry.calculate_local_header_size
       @currentEntry.size = @compressor.size
       @currentEntry.crc = @compressor.crc
       @currentEntry = nil
@@ -126,32 +128,32 @@ module Zip
 
     def init_next_entry(entry, level = Zlib::DEFAULT_COMPRESSION)
       finalize_current_entry
-      @entrySet << entry
-      entry.write_local_entry(@outputStream)
+      @entry_set << entry
+      entry.write_local_entry(@output_stream)
       @compressor = get_compressor(entry, level)
     end
 
     def get_compressor(entry, level)
       case entry.compression_method
-        when ZipEntry::DEFLATED then Deflater.new(@outputStream, level)
-        when ZipEntry::STORED   then PassThruCompressor.new(@outputStream)
+        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}'"
       end
     end
 
     def update_local_headers
-      pos = @outputStream.pos
-      @entrySet.each do |entry|
-        @outputStream.pos = entry.localHeaderOffset
-        entry.write_local_entry(@outputStream)
+      pos = @output_stream.pos
+      @entry_set.each do |entry|
+        @output_stream.pos = entry.local_header_offset
+        entry.write_local_entry(@output_stream)
       end
-      @outputStream.pos = pos
+      @output_stream.pos = pos
     end
 
     def write_central_directory
-      cdir = ZipCentralDirectory.new(@entrySet, @comment)
-      cdir.write_to_stream(@outputStream)
+      cdir = CentralDirectory.new(@entry_set, @comment)
+      cdir.write_to_stream(@output_stream)
     end
 
     protected

data/lib/zip/pass_thru_compressor.rb

@@ -2,7 +2,7 @@ module Zip
   class PassThruCompressor < Compressor #:nodoc:all
     def initialize(outputStream)
       super()
-      @outputStream = outputStream
+      @output_stream = outputStream
       @crc = Zlib::crc32
       @size = 0
     end
@@ -11,7 +11,7 @@ module Zip
       val = data.to_s
       @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,35 +1,36 @@
 module Zip
   class PassThruDecompressor < Decompressor  #:nodoc:all
-    def initialize(inputStream, charsToRead)
-      super inputStream
-      @charsToRead = charsToRead
-      @readSoFar = 0
-      @hasReturnedEmptyString = ! EMPTY_FILE_RETURNS_EMPTY_STRING_FIRST
+
+    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 = nil)
       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?
   end

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

@@ -1,5 +1,5 @@
 module Zip
-  class ZipStreamableDirectory < ZipEntry
+  class StreamableDirectory < Entry
     def initialize(zipfile, entry, srcPath = nil, permissionInt = nil)
       super(zipfile, entry)
 

data/lib/zip/{zip_streamable_stream.rb → streamable_stream.rb}

@@ -1,5 +1,5 @@
 module Zip
-  class ZipStreamableStream < DelegateClass(ZipEntry) #nodoc:all
+  class StreamableStream < DelegateClass(Entry) #nodoc:all
     def initialize(entry)
       super(entry)
       @tempFile = Tempfile.new(::File.basename(name), ::File.dirname(zipfile))
@@ -37,7 +37,7 @@ module Zip
     
     def write_to_zip_output_stream(aZipOutputStream)
       aZipOutputStream.put_next_entry(self)
-      get_input_stream { |is| IOExtras.copy_stream(aZipOutputStream, is) } 
+      get_input_stream { |is| ::Zip::IOExtras.copy_stream(aZipOutputStream, is) }
     end
   end
 end

data/lib/zip/version.rb

@@ -0,0 +1,3 @@
+module Zip
+  VERSION = '1.0.0.beta1'
+end

data/samples/example.rb

@@ -7,7 +7,7 @@ require 'zip/zip'
 
 ####### Using ZipInputStream alone: #######
 
-Zip::ZipInputStream.open("example.zip") {
+Zip::InputStream.open("example.zip") {
   |zis|
   entry = zis.get_next_entry
   print "First line of '#{entry.name} (#{entry.size} bytes):  "
@@ -20,7 +20,7 @@ Zip::ZipInputStream.open("example.zip") {
 
 ####### Using ZipFile to read the directory of a zip file: #######
 
-zf = Zip::ZipFile.new("example.zip")
+zf = Zip::File.new("example.zip")
 zf.each_with_index {
   |entry, index|
   
@@ -33,7 +33,7 @@ zf.each_with_index {
 
 ####### Using ZipOutputStream to write a zip file: #######
 
-Zip::ZipOutputStream.open("exampleout.zip") {
+Zip::OutputStream.open("exampleout.zip") {
   |zos|
   zos.put_next_entry("the first little entry")
   zos.puts "Hello hello hello hello hello hello hello hello hello"
@@ -47,7 +47,7 @@ Zip::ZipOutputStream.open("exampleout.zip") {
 
 ####### Using ZipFile to change a zip file: #######
 
-Zip::ZipFile.open("exampleout.zip") {
+Zip::File.open("exampleout.zip") {
   |zf|
   zf.add("thisFile.rb", "example.rb")
   zf.rename("thisFile.rb", "ILikeThisName.rb")
@@ -55,13 +55,35 @@ Zip::ZipFile.open("exampleout.zip") {
 }
 
 # Lets check
-Zip::ZipFile.open("exampleout.zip") {
+Zip::File.open("exampleout.zip") {
   |zf|
   puts "Changed zip file contains: #{zf.entries.join(', ')}"
   zf.remove("Again")
   puts "Without 'Again': #{zf.entries.join(', ')}"
 }
 
+####### 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" * 104857600
+  end
+end
+
+# Splitting created large zip file
+part_zips_count = Zip::File.split("large_zip_file.zip", 2097152, false)
+puts "Zip file splitted in #{part_zips_count} parts"
+
+# Track splitting an archive
+Zip::File.split("large_zip_file.zip", 1048576, 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
 
 # Copyright (C) 2002 Thomas Sondergaard

data/samples/example_filesystem.rb

@@ -8,7 +8,7 @@ EXAMPLE_ZIP = "filesystem.zip"
 
 File.delete(EXAMPLE_ZIP) if File.exists?(EXAMPLE_ZIP)
 
-Zip::ZipFile.open(EXAMPLE_ZIP, Zip::ZipFile::CREATE) {
+Zip::File.open(EXAMPLE_ZIP, Zip::File::CREATE) {
   |zf|
   zf.file.open("file1.txt", "w") { |os| os.write "first file1.txt" }
   zf.dir.mkdir("dir1")
@@ -21,7 +21,7 @@ Zip::ZipFile.open(EXAMPLE_ZIP, Zip::ZipFile::CREATE) {
   puts "Entries:                   #{zf.entries.join(', ')}"
 }
 
-Zip::ZipFile.open(EXAMPLE_ZIP) {
+Zip::File.open(EXAMPLE_ZIP) {
   |zf|
   puts "Entries from reloaded zip: #{zf.entries.join(', ')}"
 }

data/samples/example_recursive.rb

@@ -21,7 +21,7 @@ class ZipFileGenerator
   # Zip the input directory.
   def write()
     entries = Dir.entries(@inputDir); entries.delete("."); entries.delete("..") 
-    io = Zip::ZipFile.open(@outputFile, Zip::ZipFile::CREATE); 
+    io = Zip::File.open(@outputFile, Zip::File::CREATE);
 
     writeEntries(entries, "", io)
     io.close();

data/samples/gtkRubyzip.rb

@@ -68,7 +68,7 @@ class MainApp < Gtk::Window
   end
 
   def open_zip(filename)
-    @zipfile = Zip::ZipFile.open(filename)
+    @zipfile = Zip::File.open(filename)
     @clist.clear
     @zipfile.each { 
       |entry|

data/samples/qtzip.rb

@@ -25,11 +25,11 @@ class ZipDialog < ZipDialogUI
   end
 
   def zipfile(&proc)
-    Zip::ZipFile.open(@zip_filename, &proc)
+    Zip::File.open(@zip_filename, &proc)
   end
 
   def each(&proc)
-    Zip::ZipFile.foreach(@zip_filename, &proc)
+    Zip::File.foreach(@zip_filename, &proc)
   end
   
   def refresh()

data/samples/write_simple.rb

@@ -6,7 +6,7 @@ require 'zip/zip'
 
 include Zip
 
-ZipOutputStream.open('simple.zip') {
+OutputStream.open('simple.zip') {
   |zos|
   ze = zos.put_next_entry 'entry.txt'
   zos.puts "Hello world"