rubyzip 1.1.7 → 1.2.0

data/test/ioextras/abstract_output_stream_test.rb

@@ -8,10 +8,10 @@ class AbstractOutputStreamTest < MiniTest::Test
     attr_accessor :buffer
 
     def initialize
-      @buffer = ""
+      @buffer = ''
     end
 
-    def << (data)
+    def <<(data)
       @buffer << data
       self
     end
@@ -30,77 +30,77 @@ class AbstractOutputStreamTest < MiniTest::Test
   end
 
   def test_write
-    count = @output_stream.write("a little string")
-    assert_equal("a little string", @output_stream.buffer)
-    assert_equal("a little string".length, count)
+    count = @output_stream.write('a little string')
+    assert_equal('a little string', @output_stream.buffer)
+    assert_equal('a little string'.length, count)
 
-    count = @output_stream.write(". a little more")
-    assert_equal("a little string. a little more", @output_stream.buffer)
-    assert_equal(". a little more".length, count)
+    count = @output_stream.write('. a little more')
+    assert_equal('a little string. a little more', @output_stream.buffer)
+    assert_equal('. a little more'.length, count)
   end
 
   def test_print
     $\ = nil # record separator set to nil
-    @output_stream.print("hello")
-    assert_equal("hello", @output_stream.buffer)
+    @output_stream.print('hello')
+    assert_equal('hello', @output_stream.buffer)
 
-    @output_stream.print(" world.")
-    assert_equal("hello world.", @output_stream.buffer)
+    @output_stream.print(' world.')
+    assert_equal('hello world.', @output_stream.buffer)
 
-    @output_stream.print(" You ok ", "out ", "there?")
-    assert_equal("hello world. You ok out there?", @output_stream.buffer)
+    @output_stream.print(' You ok ', 'out ', 'there?')
+    assert_equal('hello world. You ok out there?', @output_stream.buffer)
 
     $\ = "\n"
     @output_stream.print
     assert_equal("hello world. You ok out there?\n", @output_stream.buffer)
 
-    @output_stream.print("I sure hope so!")
+    @output_stream.print('I sure hope so!')
     assert_equal("hello world. You ok out there?\nI sure hope so!\n", @output_stream.buffer)
 
-    $, = "X"
-    @output_stream.buffer = ""
-    @output_stream.print("monkey", "duck", "zebra")
+    $, = 'X'
+    @output_stream.buffer = ''
+    @output_stream.print('monkey', 'duck', 'zebra')
     assert_equal("monkeyXduckXzebra\n", @output_stream.buffer)
 
     $\ = nil
-    @output_stream.buffer = ""
+    @output_stream.buffer = ''
     @output_stream.print(20)
-    assert_equal("20", @output_stream.buffer)
+    assert_equal('20', @output_stream.buffer)
   end
 
   def test_printf
-    @output_stream.printf("%d %04x", 123, 123)
-    assert_equal("123 007b", @output_stream.buffer)
+    @output_stream.printf('%d %04x', 123, 123)
+    assert_equal('123 007b', @output_stream.buffer)
   end
 
   def test_putc
-    @output_stream.putc("A")
-    assert_equal("A", @output_stream.buffer)
+    @output_stream.putc('A')
+    assert_equal('A', @output_stream.buffer)
     @output_stream.putc(65)
-    assert_equal("AA", @output_stream.buffer)
+    assert_equal('AA', @output_stream.buffer)
   end
 
   def test_puts
     @output_stream.puts
     assert_equal("\n", @output_stream.buffer)
 
-    @output_stream.puts("hello", "world")
+    @output_stream.puts('hello', 'world')
     assert_equal("\nhello\nworld\n", @output_stream.buffer)
 
-    @output_stream.buffer = ""
+    @output_stream.buffer = ''
     @output_stream.puts("hello\n", "world\n")
     assert_equal("hello\nworld\n", @output_stream.buffer)
 
-    @output_stream.buffer = ""
+    @output_stream.buffer = ''
     @output_stream.puts(["hello\n", "world\n"])
     assert_equal("hello\nworld\n", @output_stream.buffer)
 
-    @output_stream.buffer = ""
-    @output_stream.puts(["hello\n", "world\n"], "bingo")
+    @output_stream.buffer = ''
+    @output_stream.puts(["hello\n", "world\n"], 'bingo')
     assert_equal("hello\nworld\nbingo\n", @output_stream.buffer)
 
-    @output_stream.buffer = ""
-    @output_stream.puts(16, 20, 50, "hello")
+    @output_stream.buffer = ''
+    @output_stream.puts(16, 20, 50, 'hello')
     assert_equal("16\n20\n50\nhello\n", @output_stream.buffer)
   end
 end

data/test/local_entry_test.rb

@@ -1,7 +1,6 @@
 require 'test_helper'
 
 class ZipLocalEntryTest < MiniTest::Test
-
   CEH_FILE = 'test/data/generated/centralEntryHeader.bin'
   LEH_FILE = 'test/data/generated/localEntryHeader.bin'
 
@@ -9,8 +8,8 @@ class ZipLocalEntryTest < MiniTest::Test
     ::Zip.write_zip64_support = false
   end
 
-  def test_read_local_entryHeaderOfFirstTestZipEntry
-    ::File.open(TestZipFile::TEST_ZIP3.zip_name, "rb") do |file|
+  def test_read_local_entry_header_of_first_test_zip_entry
+    ::File.open(TestZipFile::TEST_ZIP3.zip_name, 'rb') do |file|
       entry = ::Zip::Entry.read_local_entry(file)
 
       assert_equal('', entry.comment)
@@ -27,35 +26,33 @@ class ZipLocalEntryTest < MiniTest::Test
     end
   end
 
-  def test_readDateTime
-    ::File.open("test/data/rubycode.zip", "rb") {
-        |file|
+  def test_read_date_time
+    ::File.open('test/data/rubycode.zip', 'rb') do |file|
       entry = ::Zip::Entry.read_local_entry(file)
-      assert_equal("zippedruby1.rb", entry.name)
-      assert_equal(::Zip::DOSTime.at(1019261638), entry.time)
-    }
+      assert_equal('zippedruby1.rb', entry.name)
+      assert_equal(::Zip::DOSTime.at(1_019_261_638), entry.time)
+    end
   end
 
-  def test_read_local_entryFromNonZipFile
-    ::File.open("test/data/file2.txt") {
-        |file|
+  def test_read_local_entry_from_non_zip_file
+    ::File.open('test/data/file2.txt') do |file|
       assert_equal(nil, ::Zip::Entry.read_local_entry(file))
-    }
+    end
   end
 
-  def test_read_local_entryFromTruncatedZipFile
-    zipFragment=""
+  def test_read_local_entry_from_truncated_zip_file
+    zipFragment = ''
     ::File.open(TestZipFile::TEST_ZIP2.zip_name) { |f| zipFragment = f.read(12) } # local header is at least 30 bytes
     zipFragment.extend(IOizeString).reset
     entry = ::Zip::Entry.new
     entry.read_local_entry(zipFragment)
-    fail "ZipError expected"
+    fail 'ZipError expected'
   rescue ::Zip::Error
   end
 
-  def test_writeEntry
-    entry = ::Zip::Entry.new("file.zip", "entryName", "my little comment",
-                             "thisIsSomeExtraInformation", 100, 987654,
+  def test_write_entry
+    entry = ::Zip::Entry.new('file.zip', 'entryName', 'my little comment',
+                             'thisIsSomeExtraInformation', 100, 987_654,
                              ::Zip::Entry::DEFLATED, 400)
     write_to_file(LEH_FILE, CEH_FILE, entry)
     entryReadLocal, entryReadCentral = read_from_file(LEH_FILE, CEH_FILE)
@@ -64,10 +61,10 @@ class ZipLocalEntryTest < MiniTest::Test
     compare_c_dir_entry_headers(entry, entryReadCentral)
   end
 
-  def test_writeEntryWithZip64
+  def test_write_entry_with_zip64
     ::Zip.write_zip64_support = true
-    entry = ::Zip::Entry.new("file.zip", "entryName", "my little comment",
-                             "thisIsSomeExtraInformation", 100, 987654,
+    entry = ::Zip::Entry.new('file.zip', 'entryName', 'my little comment',
+                             'thisIsSomeExtraInformation', 100, 987_654,
                              ::Zip::Entry::DEFLATED, 400)
     write_to_file(LEH_FILE, CEH_FILE, entry)
     entryReadLocal, entryReadCentral = read_from_file(LEH_FILE, CEH_FILE)
@@ -78,10 +75,10 @@ class ZipLocalEntryTest < MiniTest::Test
     compare_c_dir_entry_headers(entry, entryReadCentral)
   end
 
-  def test_write64Entry
+  def test_write_64entry
     ::Zip.write_zip64_support = true
-    entry = ::Zip::Entry.new("bigfile.zip", "entryName", "my little equine",
-                             "malformed extra field because why not",
+    entry = ::Zip::Entry.new('bigfile.zip', 'entryName', 'my little equine',
+                             'malformed extra field because why not',
                              0x7766554433221100, 0xDEADBEEF, ::Zip::Entry::DEFLATED,
                              0x9988776655443322)
     write_to_file(LEH_FILE, CEH_FILE, entry)
@@ -90,12 +87,12 @@ class ZipLocalEntryTest < MiniTest::Test
     compare_c_dir_entry_headers(entry, entryReadCentral)
   end
 
-  def test_rewriteLocalHeader64
+  def test_rewrite_local_header64
     ::Zip.write_zip64_support = true
     buf1 = StringIO.new
-    entry = ::Zip::Entry.new("file.zip", "entryName")
+    entry = ::Zip::Entry.new('file.zip', 'entryName')
     entry.write_local_entry(buf1)
-    assert(entry.extra['Zip64'].nil?, "zip64 extra is unnecessarily present")
+    assert(entry.extra['Zip64'].nil?, 'zip64 extra is unnecessarily present')
 
     buf2 = StringIO.new
     entry.size = 0x123456789ABCDEF0
@@ -106,18 +103,18 @@ class ZipLocalEntryTest < MiniTest::Test
     assert_equal(buf1.size, buf2.size) # it can't grow, or we'd clobber file data
   end
 
-  def test_readLocalOffset
-    entry = ::Zip::Entry.new("file.zip", "entryName")
-    entry.local_header_offset = 12345
+  def test_read_local_offset
+    entry = ::Zip::Entry.new('file.zip', 'entryName')
+    entry.local_header_offset = 12_345
     ::File.open(CEH_FILE, 'wb') { |f| entry.write_c_dir_entry(f) }
     read_entry = nil
     ::File.open(CEH_FILE, 'rb') { |f| read_entry = ::Zip::Entry.read_c_dir_entry(f) }
     compare_c_dir_entry_headers(entry, read_entry)
   end
 
-  def test_read64LocalOffset
+  def test_read64_local_offset
     ::Zip.write_zip64_support = true
-    entry = ::Zip::Entry.new("file.zip", "entryName")
+    entry = ::Zip::Entry.new('file.zip', 'entryName')
     entry.local_header_offset = 0x0123456789ABCDEF
     ::File.open(CEH_FILE, 'wb') { |f| entry.write_c_dir_entry(f) }
     read_entry = nil
@@ -126,6 +123,7 @@ class ZipLocalEntryTest < MiniTest::Test
   end
 
   private
+
   def compare_local_entry_headers(entry1, entry2)
     assert_equal(entry1.compressed_size, entry2.compressed_size)
     assert_equal(entry1.crc, entry2.crc)
@@ -142,15 +140,15 @@ class ZipLocalEntryTest < MiniTest::Test
   end
 
   def write_to_file(localFileName, centralFileName, entry)
-    ::File.open(localFileName, "wb") { |f| entry.write_local_entry(f) }
-    ::File.open(centralFileName, "wb") { |f| entry.write_c_dir_entry(f) }
+    ::File.open(localFileName, 'wb') { |f| entry.write_local_entry(f) }
+    ::File.open(centralFileName, 'wb') { |f| entry.write_c_dir_entry(f) }
   end
 
   def read_from_file(localFileName, centralFileName)
     localEntry = nil
     cdirEntry = nil
-    ::File.open(localFileName, "rb") { |f| localEntry = ::Zip::Entry.read_local_entry(f) }
-    ::File.open(centralFileName, "rb") { |f| cdirEntry = ::Zip::Entry.read_c_dir_entry(f) }
+    ::File.open(localFileName, 'rb') { |f| localEntry = ::Zip::Entry.read_local_entry(f) }
+    ::File.open(centralFileName, 'rb') { |f| cdirEntry = ::Zip::Entry.read_c_dir_entry(f) }
     [localEntry, cdirEntry]
   end
 end

data/test/output_stream_test.rb

@@ -4,7 +4,7 @@ class ZipOutputStreamTest < MiniTest::Test
   include AssertEntry
 
   TEST_ZIP = TestZipFile::TEST_ZIP2.clone
-  TEST_ZIP.zip_name = "test/data/generated/output.zip"
+  TEST_ZIP.zip_name = 'test/data/generated/output.zip'
 
   def test_new
     zos = ::Zip::OutputStream.new(TEST_ZIP.zip_name)
@@ -47,13 +47,13 @@ class ZipOutputStreamTest < MiniTest::Test
     assert_test_zip_contents(TEST_ZIP)
   end
 
-  def test_writingToClosedStream
-    assert_i_o_error_in_closed_stream { |zos| zos << "hello world" }
-    assert_i_o_error_in_closed_stream { |zos| zos.puts "hello world" }
-    assert_i_o_error_in_closed_stream { |zos| zos.write "hello world" }
+  def test_writing_to_closed_stream
+    assert_i_o_error_in_closed_stream { |zos| zos << 'hello world' }
+    assert_i_o_error_in_closed_stream { |zos| zos.puts 'hello world' }
+    assert_i_o_error_in_closed_stream { |zos| zos.write 'hello world' }
   end
 
-  def test_cannotOpenFile
+  def test_cannot_open_file
     name = TestFiles::EMPTY_TEST_DIR
     begin
       ::Zip::OutputStream.open(name)
@@ -66,9 +66,9 @@ class ZipOutputStreamTest < MiniTest::Test
   end
 
   def test_put_next_entry
-    stored_text = "hello world in stored text"
-    entry_name = "file1"
-    comment = "my comment"
+    stored_text = 'hello world in stored text'
+    entry_name = 'file1'
+    comment = 'my comment'
     ::Zip::OutputStream.open(TEST_ZIP.zip_name) do |zos|
       zos.put_next_entry(entry_name, comment, nil, ::Zip::Entry::STORED)
       zos << stored_text
@@ -81,14 +81,14 @@ class ZipOutputStreamTest < MiniTest::Test
   end
 
   def test_put_next_entry_using_zip_entry_creates_entries_with_correct_timestamps
-    file = ::File.open("test/data/file2.txt", "rb")
+    file = ::File.open('test/data/file2.txt', 'rb')
     ::Zip::OutputStream.open(TEST_ZIP.zip_name) do |zos|
-      zip_entry = ::Zip::Entry.new(zos, file.path, "", "", 0, 0, ::Zip::Entry::DEFLATED, 0, ::Zip::DOSTime.at(file.mtime))
+      zip_entry = ::Zip::Entry.new(zos, file.path, '', '', 0, 0, ::Zip::Entry::DEFLATED, 0, ::Zip::DOSTime.at(file.mtime))
       zos.put_next_entry(zip_entry)
       zos << file.read
     end
 
-    ::Zip::InputStream::open(TEST_ZIP.zip_name) do |io|
+    ::Zip::InputStream.open(TEST_ZIP.zip_name) do |io|
       while (entry = io.get_next_entry)
         assert(::Zip::DOSTime.at(file.mtime).dos_equals(::Zip::DOSTime.at(entry.mtime))) # Compare DOS Times, since they are stored with two seconds accuracy
       end
@@ -96,10 +96,10 @@ class ZipOutputStreamTest < MiniTest::Test
   end
 
   def test_chained_put_into_next_entry
-    stored_text = "hello world in stored text"
-    stored_text2 = "with chain"
-    entry_name = "file1"
-    comment = "my comment"
+    stored_text = 'hello world in stored text'
+    stored_text2 = 'with chain'
+    entry_name = 'file1'
+    comment = 'my comment'
     ::Zip::OutputStream.open(TEST_ZIP.zip_name) do |zos|
       zos.put_next_entry(entry_name, comment, nil, ::Zip::Entry::STORED)
       zos << stored_text << stored_text2
@@ -109,21 +109,20 @@ class ZipOutputStreamTest < MiniTest::Test
     ::Zip::File.open(TEST_ZIP.zip_name) do |zf|
       assert_equal(stored_text + stored_text2, zf.read(entry_name))
     end
-
   end
 
   def assert_i_o_error_in_closed_stream
-    assert_raises(IOError) {
-      zos = ::Zip::OutputStream.new("test/data/generated/test_putOnClosedStream.zip")
+    assert_raises(IOError) do
+      zos = ::Zip::OutputStream.new('test/data/generated/test_putOnClosedStream.zip')
       zos.close
       yield zos
-    }
+    end
   end
 
   def write_test_zip(zos)
     TEST_ZIP.entry_names.each do |entryName|
       zos.put_next_entry(entryName)
-      File.open(entryName, "rb") { |f| zos.write(f.read) }
+      File.open(entryName, 'rb') { |f| zos.write(f.read) }
     end
   end
 end

data/test/pass_thru_compressor_test.rb

@@ -4,15 +4,14 @@ class PassThruCompressorTest < MiniTest::Test
   include CrcTest
 
   def test_size
-    File.open("test/data/generated/dummy.txt", "wb") {
-        |file|
+    File.open('test/data/generated/dummy.txt', 'wb') do |file|
       compressor = ::Zip::PassThruCompressor.new(file)
 
       assert_equal(0, compressor.size)
 
-      t1 = "hello world"
-      t2 = ""
-      t3 = "bingo"
+      t1 = 'hello world'
+      t2 = ''
+      t3 = 'bingo'
 
       compressor << t1
       assert_equal(compressor.size, t1.size)
@@ -22,7 +21,7 @@ class PassThruCompressorTest < MiniTest::Test
 
       compressor << t3
       assert_equal(compressor.size, t1.size + t2.size + t3.size)
-    }
+    end
   end
 
   def test_crc

data/test/pass_thru_decompressor_test.rb

@@ -12,4 +12,3 @@ class PassThruDecompressorTest < MiniTest::Test
     @file.close
   end
 end
-

data/test/samples/example_recursive_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+require 'fileutils'
+require_relative '../../samples/example_recursive'
+
+class ExampleRecursiveTest < MiniTest::Test
+  DIRECTORY_TO_ZIP  = 'test/data/globTest'
+  OUTPUT_DIRECTORY  = 'test/data/example_recursive.zip'
+  TEMP_DIRECTORY    = 'test/data/tmp'
+
+  def setup
+    @generator = ::ZipFileGenerator.new(DIRECTORY_TO_ZIP, OUTPUT_DIRECTORY)
+  end
+
+  def teardown
+    FileUtils.rm_rf TEMP_DIRECTORY
+    FileUtils.rm_f OUTPUT_DIRECTORY
+  end
+
+  def test_write
+    @generator.write
+    unzip
+    assert_equal Dir.entries(DIRECTORY_TO_ZIP).sort, Dir.entries(TEMP_DIRECTORY).sort
+  end
+
+  private
+
+  def unzip(file = OUTPUT_DIRECTORY)
+    Zip::File.open(file) do |zip_file|
+      zip_file.each do |f|
+        file_path = File.join(TEMP_DIRECTORY, f.name)
+        FileUtils.mkdir_p(File.dirname(file_path))
+
+        zip_file.extract(f, file_path) unless File.exist?(file_path)
+      end
+    end
+  end
+end