rubyzip 1.1.7 → 1.2.4

data/test/basic_zip_file_test.rb

@@ -5,7 +5,7 @@ class BasicZipFileTest < MiniTest::Test
 
   def setup
     @zip_file = ::Zip::File.new(TestZipFile::TEST_ZIP2.zip_name)
-    @testEntryNameIndex=0
+    @testEntryNameIndex = 0
   end
 
   def test_entries
@@ -16,26 +16,24 @@ class BasicZipFileTest < MiniTest::Test
   def test_each
     count = 0
     visited = {}
-    @zip_file.each {
-        |entry|
+    @zip_file.each do |entry|
       assert(TestZipFile::TEST_ZIP2.entry_names.include?(entry.name))
       assert(!visited.include?(entry.name))
       visited[entry.name] = nil
       count = count.succ
-    }
+    end
     assert_equal(TestZipFile::TEST_ZIP2.entry_names.length, count)
   end
 
   def test_foreach
     count = 0
     visited = {}
-    ::Zip::File.foreach(TestZipFile::TEST_ZIP2.zip_name) {
-        |entry|
+    ::Zip::File.foreach(TestZipFile::TEST_ZIP2.zip_name) do |entry|
       assert(TestZipFile::TEST_ZIP2.entry_names.include?(entry.name))
       assert(!visited.include?(entry.name))
       visited[entry.name] = nil
       count = count.succ
-    }
+    end
     assert_equal(TestZipFile::TEST_ZIP2.entry_names.length, count)
   end
 
@@ -51,14 +49,12 @@ class BasicZipFileTest < MiniTest::Test
     assert_equal(TestZipFile::TEST_ZIP2.entry_names.length, count)
   end
 
-  def test_get_input_streamBlock
+  def test_get_input_stream_block
     fileAndEntryName = @zip_file.entries.first.name
-    @zip_file.get_input_stream(fileAndEntryName) {
-        |zis|
-      assert_entryContentsForStream(fileAndEntryName,
-                                    zis,
-                                    fileAndEntryName)
-    }
+    @zip_file.get_input_stream(fileAndEntryName) do |zis|
+      assert_entry_contents_for_stream(fileAndEntryName,
+                                       zis,
+                                       fileAndEntryName)
+    end
   end
-
 end

data/test/case_sensitivity_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class ZipCaseSensitivityTest < MiniTest::Test
+  include CommonZipFileFixture
+
+  SRC_FILES = [['test/data/file1.txt', 'testfile.rb'],
+               ['test/data/file2.txt', 'testFILE.rb']]
+
+  def teardown
+    ::Zip.case_insensitive_match = false
+  end
+
+  # Ensure that everything functions normally when +case_insensitive_match = false+
+  def test_add_case_sensitive
+    ::Zip.case_insensitive_match = false
+
+    SRC_FILES.each { |fn, _en| assert(::File.exist?(fn)) }
+    zf = ::Zip::File.new(EMPTY_FILENAME, ::Zip::File::CREATE)
+
+    SRC_FILES.each { |fn, en| zf.add(en, fn) }
+    zf.close
+
+    zfRead = ::Zip::File.new(EMPTY_FILENAME)
+    assert_equal(SRC_FILES.size, zfRead.entries.length)
+    SRC_FILES.each_with_index { |a, i|
+      assert_equal(a.last, zfRead.entries[i].name)
+      AssertEntry.assert_contents(a.first,
+                                  zfRead.get_input_stream(a.last) { |zis| zis.read })
+    }
+  end
+
+  # Ensure that names are treated case insensitively when adding files and +case_insensitive_match = false+
+  def test_add_case_insensitive
+    ::Zip.case_insensitive_match = true
+
+    SRC_FILES.each { |fn, _en| assert(::File.exist?(fn)) }
+    zf = ::Zip::File.new(EMPTY_FILENAME, ::Zip::File::CREATE)
+
+    assert_raises Zip::EntryExistsError do
+      SRC_FILES.each { |fn, en| zf.add(en, fn) }
+    end
+  end
+
+  # Ensure that names are treated case insensitively when reading files and +case_insensitive_match = true+
+  def test_add_case_sensitive_read_case_insensitive
+    ::Zip.case_insensitive_match = false
+
+    SRC_FILES.each { |fn, _en| assert(::File.exist?(fn)) }
+    zf = ::Zip::File.new(EMPTY_FILENAME, ::Zip::File::CREATE)
+
+    SRC_FILES.each { |fn, en| zf.add(en, fn) }
+    zf.close
+
+    ::Zip.case_insensitive_match = true
+
+    zfRead = ::Zip::File.new(EMPTY_FILENAME)
+    assert_equal(SRC_FILES.collect { |_fn, en| en.downcase }.uniq.size, zfRead.entries.length)
+    assert_equal(SRC_FILES.last.last.downcase, zfRead.entries.first.name.downcase)
+    AssertEntry.assert_contents(SRC_FILES.last.first,
+                                zfRead.get_input_stream(SRC_FILES.last.last) { |zis| zis.read })
+  end
+
+  private
+
+  def assert_contains(zf, entryName, filename = entryName)
+    assert(zf.entries.detect { |e| e.name == entryName } != nil, "entry #{entryName} not in #{zf.entries.join(', ')} in zip file #{zf}")
+    assert_entry_contents(zf, entryName, filename) if File.exist?(filename)
+  end
+end

data/test/central_directory_entry_test.rb

@@ -1,73 +1,69 @@
 require 'test_helper'
 
 class ZipCentralDirectoryEntryTest < MiniTest::Test
-
   def test_read_from_stream
-    File.open("test/data/testDirectory.bin", "rb") {
-        |file|
+    File.open('test/data/testDirectory.bin', 'rb') do |file|
       entry = ::Zip::Entry.read_c_dir_entry(file)
 
-      assert_equal("longAscii.txt", entry.name)
+      assert_equal('longAscii.txt', entry.name)
       assert_equal(::Zip::Entry::DEFLATED, entry.compression_method)
-      assert_equal(106490, entry.size)
+      assert_equal(106_490, entry.size)
       assert_equal(3784, entry.compressed_size)
       assert_equal(0xfcd1799c, entry.crc)
-      assert_equal("", entry.comment)
+      assert_equal('', entry.comment)
 
       entry = ::Zip::Entry.read_c_dir_entry(file)
-      assert_equal("empty.txt", entry.name)
+      assert_equal('empty.txt', entry.name)
       assert_equal(::Zip::Entry::STORED, entry.compression_method)
       assert_equal(0, entry.size)
       assert_equal(0, entry.compressed_size)
       assert_equal(0x0, entry.crc)
-      assert_equal("", entry.comment)
+      assert_equal('', entry.comment)
 
       entry = ::Zip::Entry.read_c_dir_entry(file)
-      assert_equal("short.txt", entry.name)
+      assert_equal('short.txt', entry.name)
       assert_equal(::Zip::Entry::STORED, entry.compression_method)
       assert_equal(6, entry.size)
       assert_equal(6, entry.compressed_size)
       assert_equal(0xbb76fe69, entry.crc)
-      assert_equal("", entry.comment)
+      assert_equal('', entry.comment)
 
       entry = ::Zip::Entry.read_c_dir_entry(file)
-      assert_equal("longBinary.bin", entry.name)
+      assert_equal('longBinary.bin', entry.name)
       assert_equal(::Zip::Entry::DEFLATED, entry.compression_method)
-      assert_equal(1000024, entry.size)
-      assert_equal(70847, entry.compressed_size)
+      assert_equal(1_000_024, entry.size)
+      assert_equal(70_847, entry.compressed_size)
       assert_equal(0x10da7d59, entry.crc)
       assert_equal('', entry.comment)
 
       entry = ::Zip::Entry.read_c_dir_entry(file)
-      assert_equal(nil, entry)
-# Fields that are not check by this test:
-#          version made by                 2 bytes
-#          version needed to extract       2 bytes
-#          general purpose bit flag        2 bytes
-#          last mod file time              2 bytes
-#          last mod file date              2 bytes
-#          compressed size                 4 bytes
-#          uncompressed size               4 bytes
-#          disk number start               2 bytes
-#          internal file attributes        2 bytes
-#          external file attributes        4 bytes
-#          relative offset of local header 4 bytes
-
-#          file name (variable size)
-#          extra field (variable size)
-#          file comment (variable size)
+      assert_nil(entry)
+      # Fields that are not check by this test:
+      #          version made by                 2 bytes
+      #          version needed to extract       2 bytes
+      #          general purpose bit flag        2 bytes
+      #          last mod file time              2 bytes
+      #          last mod file date              2 bytes
+      #          compressed size                 4 bytes
+      #          uncompressed size               4 bytes
+      #          disk number start               2 bytes
+      #          internal file attributes        2 bytes
+      #          external file attributes        4 bytes
+      #          relative offset of local header 4 bytes
 
-    }
+      #          file name (variable size)
+      #          extra field (variable size)
+      #          file comment (variable size)
+    end
   end
 
-  def test_ReadEntryFromTruncatedZipFile
-    fragment=""
-    File.open("test/data/testDirectory.bin") { |f| fragment = f.read(12) } # cdir entry header is at least 46 bytes
+  def test_read_entry_from_truncated_zip_file
+    fragment = ''
+    File.open('test/data/testDirectory.bin') { |f| fragment = f.read(12) } # cdir entry header is at least 46 bytes
     fragment.extend(IOizeString)
     entry = ::Zip::Entry.new
     entry.read_c_dir_entry(fragment)
-    fail "ZipError expected"
+    fail 'ZipError expected'
   rescue ::Zip::Error
   end
-
 end

data/test/central_directory_test.rb

@@ -1,96 +1,92 @@
 require 'test_helper'
 
 class ZipCentralDirectoryTest < MiniTest::Test
-
   def teardown
     ::Zip.reset!
   end
 
   def test_read_from_stream
-    ::File.open(TestZipFile::TEST_ZIP2.zip_name, "rb") {
-        |zipFile|
+    ::File.open(TestZipFile::TEST_ZIP2.zip_name, 'rb') do |zipFile|
       cdir = ::Zip::CentralDirectory.read_from_stream(zipFile)
 
       assert_equal(TestZipFile::TEST_ZIP2.entry_names.size, cdir.size)
-      assert(cdir.entries.sort.compare_enumerables(TestZipFile::TEST_ZIP2.entry_names.sort) {
-          |cdirEntry, testEntryName|
+      assert(cdir.entries.sort.compare_enumerables(TestZipFile::TEST_ZIP2.entry_names.sort) do |cdirEntry, testEntryName|
         cdirEntry.name == testEntryName
-      })
+      end)
       assert_equal(TestZipFile::TEST_ZIP2.comment, cdir.comment)
-    }
+    end
   end
 
-  def test_readFromInvalidStream
-    File.open("test/data/file2.txt", "rb") {
-        |zipFile|
+  def test_read_from_invalid_stream
+    File.open('test/data/file2.txt', 'rb') do |zipFile|
       cdir = ::Zip::CentralDirectory.new
       cdir.read_from_stream(zipFile)
-    }
-    fail "ZipError expected!"
+    end
+    fail 'ZipError expected!'
   rescue ::Zip::Error
   end
 
-  def test_ReadFromTruncatedZipFile
-    fragment=""
-    File.open("test/data/testDirectory.bin", "rb") { |f| fragment = f.read }
+  def test_read_from_truncated_zip_file
+    fragment = ''
+    File.open('test/data/testDirectory.bin', 'rb') { |f| fragment = f.read }
     fragment.slice!(12) # removed part of first cdir entry. eocd structure still complete
     fragment.extend(IOizeString)
     entry = ::Zip::CentralDirectory.new
     entry.read_from_stream(fragment)
-    fail "ZipError expected"
+    fail 'ZipError expected'
   rescue ::Zip::Error
   end
 
   def test_write_to_stream
-    entries = [::Zip::Entry.new("file.zip", "flimse", "myComment", "somethingExtra"),
-               ::Zip::Entry.new("file.zip", "secondEntryName"),
-               ::Zip::Entry.new("file.zip", "lastEntry.txt", "Has a comment too")]
-    cdir = ::Zip::CentralDirectory.new(entries, "my zip comment")
-    File.open("test/data/generated/cdirtest.bin", "wb") { |f| cdir.write_to_stream(f) }
+    entries = [::Zip::Entry.new('file.zip', 'flimse', 'myComment', 'somethingExtra'),
+               ::Zip::Entry.new('file.zip', 'secondEntryName'),
+               ::Zip::Entry.new('file.zip', 'lastEntry.txt', 'Has a comment too')]
+    cdir = ::Zip::CentralDirectory.new(entries, 'my zip comment')
+    File.open('test/data/generated/cdirtest.bin', 'wb') { |f| cdir.write_to_stream(f) }
     cdirReadback = ::Zip::CentralDirectory.new
-    File.open("test/data/generated/cdirtest.bin", "rb") { |f| cdirReadback.read_from_stream(f) }
+    File.open('test/data/generated/cdirtest.bin', 'rb') { |f| cdirReadback.read_from_stream(f) }
 
     assert_equal(cdir.entries.sort, cdirReadback.entries.sort)
   end
 
   def test_write64_to_stream
     ::Zip.write_zip64_support = true
-    entries = [::Zip::Entry.new("file.zip", "file1-little", "comment1", "", 200, 101, ::Zip::Entry::STORED, 200),
-               ::Zip::Entry.new("file.zip", "file2-big", "comment2", "", 18000000000, 102, ::Zip::Entry::DEFLATED, 20000000000),
-               ::Zip::Entry.new("file.zip", "file3-alsobig", "comment3", "", 15000000000, 103, ::Zip::Entry::DEFLATED, 21000000000),
-               ::Zip::Entry.new("file.zip", "file4-little", "comment4", "", 100, 104, ::Zip::Entry::DEFLATED, 121)]
-    [0, 250, 18000000300, 33000000350].each_with_index do |offset, index|
+    entries = [::Zip::Entry.new('file.zip', 'file1-little', 'comment1', '', 200, 101, ::Zip::Entry::STORED, 200),
+               ::Zip::Entry.new('file.zip', 'file2-big', 'comment2', '', 18_000_000_000, 102, ::Zip::Entry::DEFLATED, 20_000_000_000),
+               ::Zip::Entry.new('file.zip', 'file3-alsobig', 'comment3', '', 15_000_000_000, 103, ::Zip::Entry::DEFLATED, 21_000_000_000),
+               ::Zip::Entry.new('file.zip', 'file4-little', 'comment4', '', 100, 104, ::Zip::Entry::DEFLATED, 121)]
+    [0, 250, 18_000_000_300, 33_000_000_350].each_with_index do |offset, index|
       entries[index].local_header_offset = offset
     end
-    cdir = ::Zip::CentralDirectory.new(entries, "zip comment")
-    File.open("test/data/generated/cdir64test.bin", "wb") { |f| cdir.write_to_stream(f) }
+    cdir = ::Zip::CentralDirectory.new(entries, 'zip comment')
+    File.open('test/data/generated/cdir64test.bin', 'wb') { |f| cdir.write_to_stream(f) }
     cdirReadback = ::Zip::CentralDirectory.new
-    File.open("test/data/generated/cdir64test.bin", "rb") { |f| cdirReadback.read_from_stream(f) }
+    File.open('test/data/generated/cdir64test.bin', 'rb') { |f| cdirReadback.read_from_stream(f) }
 
     assert_equal(cdir.entries.sort, cdirReadback.entries.sort)
     assert_equal(::Zip::VERSION_NEEDED_TO_EXTRACT_ZIP64, cdirReadback.instance_variable_get(:@version_needed_for_extract))
   end
 
   def test_equality
-    cdir1 = ::Zip::CentralDirectory.new([::Zip::Entry.new("file.zip", "flimse", nil,
-                                                          "somethingExtra"),
-                                         ::Zip::Entry.new("file.zip", "secondEntryName"),
-                                         ::Zip::Entry.new("file.zip", "lastEntry.txt")],
-                                        "my zip comment")
-    cdir2 = ::Zip::CentralDirectory.new([::Zip::Entry.new("file.zip", "flimse", nil,
-                                                          "somethingExtra"),
-                                         ::Zip::Entry.new("file.zip", "secondEntryName"),
-                                         ::Zip::Entry.new("file.zip", "lastEntry.txt")],
-                                        "my zip comment")
-    cdir3 = ::Zip::CentralDirectory.new([::Zip::Entry.new("file.zip", "flimse", nil,
-                                                          "somethingExtra"),
-                                         ::Zip::Entry.new("file.zip", "secondEntryName"),
-                                         ::Zip::Entry.new("file.zip", "lastEntry.txt")],
-                                        "comment?")
-    cdir4 = ::Zip::CentralDirectory.new([::Zip::Entry.new("file.zip", "flimse", nil,
-                                                          "somethingExtra"),
-                                         ::Zip::Entry.new("file.zip", "lastEntry.txt")],
-                                        "comment?")
+    cdir1 = ::Zip::CentralDirectory.new([::Zip::Entry.new('file.zip', 'flimse', nil,
+                                                          'somethingExtra'),
+                                         ::Zip::Entry.new('file.zip', 'secondEntryName'),
+                                         ::Zip::Entry.new('file.zip', 'lastEntry.txt')],
+                                        'my zip comment')
+    cdir2 = ::Zip::CentralDirectory.new([::Zip::Entry.new('file.zip', 'flimse', nil,
+                                                          'somethingExtra'),
+                                         ::Zip::Entry.new('file.zip', 'secondEntryName'),
+                                         ::Zip::Entry.new('file.zip', 'lastEntry.txt')],
+                                        'my zip comment')
+    cdir3 = ::Zip::CentralDirectory.new([::Zip::Entry.new('file.zip', 'flimse', nil,
+                                                          'somethingExtra'),
+                                         ::Zip::Entry.new('file.zip', 'secondEntryName'),
+                                         ::Zip::Entry.new('file.zip', 'lastEntry.txt')],
+                                        'comment?')
+    cdir4 = ::Zip::CentralDirectory.new([::Zip::Entry.new('file.zip', 'flimse', nil,
+                                                          'somethingExtra'),
+                                         ::Zip::Entry.new('file.zip', 'lastEntry.txt')],
+                                        'comment?')
     assert_equal(cdir1, cdir1)
     assert_equal(cdir1, cdir2)
 
@@ -99,6 +95,6 @@ class ZipCentralDirectoryTest < MiniTest::Test
     assert(cdir2 != cdir3)
     assert(cdir3 != cdir4)
 
-    assert(cdir3 != "hello")
+    assert(cdir3 != 'hello')
   end
 end

data/test/crypto/null_encryption_test.rb

@@ -4,7 +4,7 @@ class NullEncrypterTest < MiniTest::Test
   def setup
     @encrypter = ::Zip::NullEncrypter.new
   end
-  
+
   def test_header_bytesize
     assert_equal 0, @encrypter.header_bytesize
   end
@@ -18,7 +18,9 @@ class NullEncrypterTest < MiniTest::Test
   end
 
   def test_encrypt
-    [nil, '', 'a' * 10, 0xffffffff].each do |data|
+    assert_nil @encrypter.encrypt(nil)
+
+    ['', 'a' * 10, 0xffffffff].each do |data|
       assert_equal data, @encrypter.encrypt(data)
     end
   end
@@ -32,7 +34,7 @@ class NullDecrypterTest < MiniTest::Test
   def setup
     @decrypter = ::Zip::NullDecrypter.new
   end
-  
+
   def test_header_bytesize
     assert_equal 0, @decrypter.header_bytesize
   end
@@ -42,7 +44,9 @@ class NullDecrypterTest < MiniTest::Test
   end
 
   def test_decrypt
-    [nil, '', 'a' * 10, 0xffffffff].each do |data|
+    assert_nil @decrypter.decrypt(nil)
+
+    ['', 'a' * 10, 0xffffffff].each do |data|
       assert_equal data, @decrypter.decrypt(data)
     end
   end

data/test/crypto/traditional_encryption_test.rb

@@ -16,7 +16,7 @@ class TraditionalEncrypterTest < MiniTest::Test
 
   def test_header
     @encrypter.reset!
-    exepected = [239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack("C*")
+    exepected = [239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack('C*')
     Random.stub(:rand, 1) do
       assert_equal exepected, @encrypter.header(@mtime)
     end
@@ -28,7 +28,7 @@ class TraditionalEncrypterTest < MiniTest::Test
     assert_raises(NoMethodError) { @encrypter.encrypt(nil) }
     assert_raises(NoMethodError) { @encrypter.encrypt(1) }
     assert_equal '', @encrypter.encrypt('')
-    assert_equal [100, 218, 7, 114, 226, 82, 62, 93, 224, 62].pack("C*"), @encrypter.encrypt('a' * 10)
+    assert_equal [100, 218, 7, 114, 226, 82, 62, 93, 224, 62].pack('C*'), @encrypter.encrypt('a' * 10)
   end
 
   def test_reset!
@@ -60,19 +60,19 @@ class TraditionalDecrypterTest < MiniTest::Test
   end
 
   def test_decrypt
-    @decrypter.reset!([239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack("C*"))
+    @decrypter.reset!([239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack('C*'))
     [100, 218, 7, 114, 226, 82, 62, 93, 224, 62].map(&:chr).each do |c|
       assert_equal 'a', @decrypter.decrypt(c)
     end
   end
 
   def test_reset!
-    @decrypter.reset!([239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack("C*"))
+    @decrypter.reset!([239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack('C*'))
     [100, 218, 7, 114, 226, 82, 62, 93, 224, 62].map(&:chr).each do |c|
       assert_equal 'a', @decrypter.decrypt(c)
     end
     assert_equal 91.chr, @decrypter.decrypt(2.chr)
-    @decrypter.reset!([239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack("C*"))
+    @decrypter.reset!([239, 57, 234, 154, 246, 80, 83, 221, 74, 200, 121, 91].pack('C*'))
     [100, 218, 7, 114, 226, 82, 62, 93, 224, 62].map(&:chr).each do |c|
       assert_equal 'a', @decrypter.decrypt(c)
     end