rubyzip 1.1.7 → 2.3.2

data/lib/zip/streamable_stream.rb

@@ -1,13 +1,8 @@
 module Zip
-  class StreamableStream < DelegateClass(Entry) #nodoc:all
+  class StreamableStream < DelegateClass(Entry) # :nodoc:all
     def initialize(entry)
       super(entry)
-      dirname = if zipfile.is_a?(::String)
-                  ::File.dirname(zipfile)
-                else
-                  '.'
-                end
-      @temp_file = Tempfile.new(::File.basename(name), dirname)
+      @temp_file = Tempfile.new(::File.basename(name))
       @temp_file.binmode
     end
 
@@ -24,9 +19,10 @@ module Zip
     end
 
     def get_input_stream
-      if !@temp_file.closed?
+      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?
@@ -40,9 +36,9 @@ module Zip
       end
     end
 
-    def write_to_zip_output_stream(aZipOutputStream)
-      aZipOutputStream.put_next_entry(self)
-      get_input_stream { |is| ::Zip::IOExtras.copy_stream(aZipOutputStream, is) }
+    def write_to_zip_output_stream(output_stream)
+      output_stream.put_next_entry(self)
+      get_input_stream { |is| ::Zip::IOExtras.copy_stream(output_stream, is) }
     end
 
     def clean_up

data/lib/zip/version.rb

@@ -1,3 +1,3 @@
 module Zip
-  VERSION = '1.1.7'
+  VERSION = '2.3.2'
 end

data/lib/zip.rb

@@ -1,9 +1,11 @@
+require 'English'
 require 'delegate'
 require 'singleton'
 require 'tempfile'
 require 'fileutils'
 require 'stringio'
 require 'zlib'
+require 'zip/constants'
 require 'zip/dos_time'
 require 'zip/ioextras'
 require 'rbconfig'
@@ -21,6 +23,7 @@ require 'zip/null_compressor'
 require 'zip/null_input_stream'
 require 'zip/pass_thru_compressor'
 require 'zip/pass_thru_decompressor'
+require 'zip/crypto/decrypted_io'
 require 'zip/crypto/encryption'
 require 'zip/crypto/null_encryption'
 require 'zip/crypto/traditional_encryption'
@@ -28,16 +31,20 @@ require 'zip/inflater'
 require 'zip/deflater'
 require 'zip/streamable_stream'
 require 'zip/streamable_directory'
-require 'zip/constants'
 require 'zip/errors'
-if defined? JRUBY_VERSION
-  require 'jruby'
-  JRuby.objectspace = true
-end
 
 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
+  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
@@ -48,6 +55,8 @@ module Zip
     @default_compression = ::Zlib::DEFAULT_COMPRESSION
     @write_zip64_support = false
     @warn_invalid_date = true
+    @case_insensitive_match = false
+    @validate_entry_sizes = true
   end
 
   def setup

data/samples/example.rb

@@ -1,89 +1,79 @@
 #!/usr/bin/env ruby
 
-$: << "../lib"
-system("zip example.zip example.rb gtkRubyzip.rb")
+$LOAD_PATH << '../lib'
+system('zip example.zip example.rb gtk_ruby_zip.rb')
 
 require 'zip'
 
 ####### Using ZipInputStream alone: #######
 
-Zip::InputStream.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::File.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::OutputStream.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::File.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::File.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..."
+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
+    zos.puts 'Hello' * 104_857_600
   end
 end
 
 # Splitting created large zip file
-part_zips_count = Zip::File.split("large_zip_file.zip", 2097152, false)
+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", 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}%"
+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 * 100).to_i}%"
 end
 
-
 # For other examples, look at zip.rb and ziptest.rb
 
 # Copyright (C) 2002 Thomas Sondergaard

data/samples/example_filesystem.rb

@@ -1,30 +1,28 @@
 #!/usr/bin/env ruby
 
-$: << "../lib"
+$LOAD_PATH << '../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::File.open(EXAMPLE_ZIP, Zip::File::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::File.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

@@ -6,43 +6,49 @@ require '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::File.open(@outputFile, Zip::File::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
 
+  def put_into_archive(disk_file_path, zipfile, zipfile_path)
+    zipfile.add(zipfile_path, disk_file_path)
+  end
 end

data/samples/gtk_ruby_zip.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << '../lib'
+
+$VERBOSE = true
+
+require 'gtk'
+require 'zip'
+
+class MainApp < Gtk::Window
+  def initialize
+    super()
+    set_usize(400, 256)
+    set_title('rubyzip')
+    signal_connect(Gtk::Window::SIGNAL_DESTROY) { Gtk.main_quit }
+
+    box = Gtk::VBox.new(false, 0)
+    add(box)
+
+    @zipfile = nil
+    @button_panel = ButtonPanel.new
+    @button_panel.open_button.signal_connect(Gtk::Button::SIGNAL_CLICKED) do
+      show_file_selector
+    end
+    @button_panel.extract_button.signal_connect(Gtk::Button::SIGNAL_CLICKED) do
+      puts 'Not implemented!'
+    end
+    box.pack_start(@button_panel, false, false, 0)
+
+    sw = Gtk::ScrolledWindow.new
+    sw.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC)
+    box.pack_start(sw, true, true, 0)
+
+    @clist = Gtk::CList.new(%w[Name Size Compression])
+    @clist.set_selection_mode(Gtk::SELECTION_BROWSE)
+    @clist.set_column_width(0, 120)
+    @clist.set_column_width(1, 120)
+    @clist.signal_connect(Gtk::CList::SIGNAL_SELECT_ROW) do |_w, row, _column, _event|
+      @selected_row = row
+    end
+    sw.add(@clist)
+  end
+
+  class ButtonPanel < Gtk::HButtonBox
+    attr_reader :open_button, :extract_button
+    def initialize
+      super
+      set_layout(Gtk::BUTTONBOX_START)
+      set_spacing(0)
+      @open_button = Gtk::Button.new('Open archive')
+      @extract_button = Gtk::Button.new('Extract entry')
+      pack_start(@open_button)
+      pack_start(@extract_button)
+    end
+  end
+
+  def show_file_selector
+    @file_selector = Gtk::FileSelection.new('Open zip file')
+    @file_selector.show
+    @file_selector.ok_button.signal_connect(Gtk::Button::SIGNAL_CLICKED) do
+      open_zip(@file_selector.filename)
+      @file_selector.destroy
+    end
+    @file_selector.cancel_button.signal_connect(Gtk::Button::SIGNAL_CLICKED) do
+      @file_selector.destroy
+    end
+  end
+
+  def open_zip(filename)
+    @zipfile = Zip::File.open(filename)
+    @clist.clear
+    @zipfile.each do |entry|
+      @clist.append([entry.name,
+                     entry.size.to_s,
+                     (100.0 * entry.compressedSize / entry.size).to_s + '%'])
+    end
+  end
+end
+
+main_app = MainApp.new
+
+main_app.show_all
+
+Gtk.main

data/samples/qtzip.rb

@@ -1,22 +1,18 @@
 #!/usr/bin/env ruby
 
-$VERBOSE=true
+$VERBOSE = true
 
-$: << "../lib"
+$LOAD_PATH << '../lib'
 
 require 'Qt'
 system('rbuic -o zipdialogui.rb zipdialogui.ui')
 require 'zipdialogui.rb'
 require 'zip'
 
-
-
 a = Qt::Application.new(ARGV)
 
 class ZipDialog < ZipDialogUI
-
-
-  def initialize()
+  def initialize
     super()
     connect(child('add_button'), SIGNAL('clicked()'),
             self, SLOT('add_files()'))
@@ -24,24 +20,22 @@ class ZipDialog < ZipDialogUI
             self, SLOT('extract_files()'))
   end
 
-  def zipfile(&proc)
-    Zip::File.open(@zip_filename, &proc)
+  def zipfile(&a_proc)
+    Zip::File.open(@zip_filename, &a_proc)
   end
 
-  def each(&proc)
-    Zip::File.foreach(@zip_filename, &proc)
+  def each(&a_proc)
+    Zip::File.foreach(@zip_filename, &a_proc)
   end
 
-  def refresh()
-    lv = child("entry_list_view")
+  def refresh
+    lv = child('entry_list_view')
     lv.clear
-    each {
-      |e|
+    each do |e|
       lv.insert_item(Qt::ListViewItem.new(lv, e.name, e.size.to_s))
-    }
+    end
   end
 
-
   def load(zipfile)
     @zip_filename = zipfile
     refresh
@@ -49,13 +43,11 @@ class ZipDialog < ZipDialogUI
 
   def add_files
     l = Qt::FileDialog.getOpenFileNames(nil, nil, self)
-    zipfile {
-      |zf|
-      l.each {
-        |path|
+    zipfile do |zf|
+      l.each do |path|
         zf.add(File.basename(path), path)
-      }
-    }
+      end
+    end
     refresh
   end
 
@@ -63,7 +55,7 @@ class ZipDialog < ZipDialogUI
     selected_items = []
     unselected_items = []
     lv_item = entry_list_view.first_child
-    while (lv_item)
+    while lv_item
       if entry_list_view.is_selected(lv_item)
         selected_items << lv_item.text(0)
       else
@@ -73,23 +65,22 @@ class ZipDialog < ZipDialogUI
     end
     puts "selected_items.size = #{selected_items.size}"
     puts "unselected_items.size = #{unselected_items.size}"
-    items = selected_items.size > 0 ? selected_items : unselected_items
+    items = !selected_items.empty? ? selected_items : unselected_items
     puts "items.size = #{items.size}"
 
     d = Qt::FileDialog.get_existing_directory(nil, self)
-    if (!d)
-      puts "No directory chosen"
+    if !d
+      puts 'No directory chosen'
     else
       zipfile { |zf| items.each { |e| zf.extract(e, File.join(d, e)) } }
     end
-
   end
 
   slots 'add_files()', 'extract_files()'
 end
 
-if !ARGV[0]
-  puts "usage: #{$0} zipname"
+unless ARGV[0]
+  puts "usage: #{$PROGRAM_NAME} zipname"
   exit
 end
 
@@ -97,5 +88,5 @@ zd = ZipDialog.new
 zd.load(ARGV[0])
 
 a.mainWidget = zd
-zd.show()
-a.exec()
+zd.show
+a.exec

data/samples/write_simple.rb

@@ -1,13 +1,10 @@
-#!/usr/bin/env ruby
-
-$: << "../lib"
-
-require 'zip'
-
-include Zip
-
-OutputStream.open('simple.zip') {
-  |zos|
-  ze = zos.put_next_entry 'entry.txt'
-  zos.puts "Hello world"
-}
+#!/usr/bin/env ruby
+
+$LOAD_PATH << '../lib'
+
+require 'zip'
+
+::Zip::OutputStream.open('simple.zip') do |zos|
+  zos.put_next_entry 'entry.txt'
+  zos.puts 'Hello world'
+end