rubyzip 1.1.7 → 1.2.0

data/test/encryption_test.rb

@@ -18,7 +18,7 @@ class EncryptionTest < MiniTest::Test
 
     @rand = [250, 143, 107, 13, 143, 22, 155, 75, 228, 150, 12]
     @output = ::Zip::DOSTime.stub(:now, ::Zip::DOSTime.new(2014, 12, 17, 15, 56, 24)) do
-      Random.stub(:rand, lambda { |range| @rand.shift }) do
+      Random.stub(:rand, ->(_range) { @rand.shift }) do
         Zip::OutputStream.write_buffer(::StringIO.new(''), Zip::TraditionalEncrypter.new('password')) do |zos|
           zos.put_next_entry('file1.txt')
           zos.write open(INPUT_FILE1).read
@@ -26,7 +26,7 @@ class EncryptionTest < MiniTest::Test
       end
     end
 
-    @output.unpack("C*").each_with_index do |c, i|
+    @output.unpack('C*').each_with_index do |c, i|
       assert_equal test_file[i].ord, c
     end
   end

data/test/entry_set_test.rb

@@ -2,12 +2,12 @@ require 'test_helper'
 
 class ZipEntrySetTest < MiniTest::Test
   ZIP_ENTRIES = [
-      ::Zip::Entry.new("zipfile.zip", "name1", "comment1"),
-      ::Zip::Entry.new("zipfile.zip", "name3", "comment1"),
-      ::Zip::Entry.new("zipfile.zip", "name2", "comment1"),
-      ::Zip::Entry.new("zipfile.zip", "name4", "comment1"),
-      ::Zip::Entry.new("zipfile.zip", "name5", "comment1"),
-      ::Zip::Entry.new("zipfile.zip", "name6", "comment1")
+    ::Zip::Entry.new('zipfile.zip', 'name1', 'comment1'),
+    ::Zip::Entry.new('zipfile.zip', 'name3', 'comment1'),
+    ::Zip::Entry.new('zipfile.zip', 'name2', 'comment1'),
+    ::Zip::Entry.new('zipfile.zip', 'name4', 'comment1'),
+    ::Zip::Entry.new('zipfile.zip', 'name5', 'comment1'),
+    ::Zip::Entry.new('zipfile.zip', 'name6', 'comment1')
   ]
 
   def setup
@@ -20,20 +20,20 @@ class ZipEntrySetTest < MiniTest::Test
 
   def test_include
     assert(@zipEntrySet.include?(ZIP_ENTRIES.first))
-    assert(!@zipEntrySet.include?(::Zip::Entry.new("different.zip", "different", "aComment")))
+    assert(!@zipEntrySet.include?(::Zip::Entry.new('different.zip', 'different', 'aComment')))
   end
 
   def test_size
     assert_equal(ZIP_ENTRIES.size, @zipEntrySet.size)
     assert_equal(ZIP_ENTRIES.size, @zipEntrySet.length)
-    @zipEntrySet << ::Zip::Entry.new("a", "b", "c")
+    @zipEntrySet << ::Zip::Entry.new('a', 'b', 'c')
     assert_equal(ZIP_ENTRIES.size + 1, @zipEntrySet.length)
   end
 
   def test_add
     zes = ::Zip::EntrySet.new
-    entry1 = ::Zip::Entry.new("zf.zip", "name1")
-    entry2 = ::Zip::Entry.new("zf.zip", "name2")
+    entry1 = ::Zip::Entry.new('zf.zip', 'name1')
+    entry2 = ::Zip::Entry.new('zf.zip', 'name2')
     zes << entry1
     assert(zes.include?(entry1))
     zes.push(entry2)
@@ -65,6 +65,20 @@ class ZipEntrySetTest < MiniTest::Test
     assert_equal(ZIP_ENTRIES, @zipEntrySet.entries)
   end
 
+  def test_find_entry
+    entries = [::Zip::Entry.new('zipfile.zip', 'MiXeDcAsEnAmE', 'comment1')]
+
+    ::Zip.case_insensitive_match = true
+    zipEntrySet = ::Zip::EntrySet.new(entries)
+    assert_equal(entries[0], zipEntrySet.find_entry('MiXeDcAsEnAmE'))
+    assert_equal(entries[0], zipEntrySet.find_entry('mixedcasename'))
+
+    ::Zip.case_insensitive_match = false
+    zipEntrySet = ::Zip::EntrySet.new(entries)
+    assert_equal(entries[0], zipEntrySet.find_entry('MiXeDcAsEnAmE'))
+    assert_equal(nil, zipEntrySet.find_entry('mixedcasename'))
+  end
+
   def test_entries_with_sort
     ::Zip.sort_entries = true
     assert_equal(ZIP_ENTRIES.sort, @zipEntrySet.entries)
@@ -82,7 +96,7 @@ class ZipEntrySetTest < MiniTest::Test
   end
 
   def test_compound
-    newEntry = ::Zip::Entry.new("zf.zip", "new entry", "new entry's comment")
+    newEntry = ::Zip::Entry.new('zf.zip', 'new entry', "new entry's comment")
     assert_equal(ZIP_ENTRIES.size, @zipEntrySet.size)
     @zipEntrySet << newEntry
     assert_equal(ZIP_ENTRIES.size + 1, @zipEntrySet.size)
@@ -97,15 +111,15 @@ class ZipEntrySetTest < MiniTest::Test
     assert_equal(@zipEntrySet, copy)
 
     # demonstrate that this is a deep copy
-    copy.entries[0].name = "a totally different name"
+    copy.entries[0].name = 'a totally different name'
     assert(@zipEntrySet != copy)
   end
 
   def test_parent
     entries = [
-        ::Zip::Entry.new("zf.zip", "a/"),
-        ::Zip::Entry.new("zf.zip", "a/b/"),
-        ::Zip::Entry.new("zf.zip", "a/b/c/")
+      ::Zip::Entry.new('zf.zip', 'a/'),
+      ::Zip::Entry.new('zf.zip', 'a/b/'),
+      ::Zip::Entry.new('zf.zip', 'a/b/c/')
     ]
     entrySet = ::Zip::EntrySet.new(entries)
 
@@ -122,17 +136,17 @@ class ZipEntrySetTest < MiniTest::Test
 
   def test_glob2
     entries = [
-        ::Zip::Entry.new("zf.zip", "a/"),
-        ::Zip::Entry.new("zf.zip", "a/b/b1"),
-        ::Zip::Entry.new("zf.zip", "a/b/c/"),
-        ::Zip::Entry.new("zf.zip", "a/b/c/c1")
+      ::Zip::Entry.new('zf.zip', 'a/'),
+      ::Zip::Entry.new('zf.zip', 'a/b/b1'),
+      ::Zip::Entry.new('zf.zip', 'a/b/c/'),
+      ::Zip::Entry.new('zf.zip', 'a/b/c/c1')
     ]
     entrySet = ::Zip::EntrySet.new(entries)
 
-    assert_equal(entries[0, 1], entrySet.glob("*"))
-#    assert_equal(entries[FIXME], entrySet.glob("**"))
-#    res = entrySet.glob('a*')
-#    assert_equal(entries.size, res.size)
-#    assert_equal(entrySet.map { |e| e.name }, res.map { |e| e.name })
+    assert_equal(entries[0, 1], entrySet.glob('*'))
+    # assert_equal(entries[FIXME], entrySet.glob("**"))
+    # res = entrySet.glob('a*')
+    # assert_equal(entries.size, res.size)
+    # assert_equal(entrySet.map { |e| e.name }, res.map { |e| e.name })
   end
 end

data/test/entry_test.rb

@@ -1,18 +1,18 @@
 require 'test_helper'
 
 class ZipEntryTest < MiniTest::Test
-  TEST_ZIPFILE = "someZipFile.zip"
-  TEST_COMMENT = "a comment"
+  TEST_ZIPFILE = 'someZipFile.zip'
+  TEST_COMMENT = 'a comment'
   TEST_COMPRESSED_SIZE = 1234
-  TEST_CRC = 325324
-  TEST_EXTRA = "Some data here"
+  TEST_CRC = 325_324
+  TEST_EXTRA = 'Some data here'
   TEST_COMPRESSIONMETHOD = ::Zip::Entry::DEFLATED
-  TEST_NAME = "entry name"
+  TEST_NAME = 'entry name'
   TEST_SIZE = 8432
   TEST_ISDIRECTORY = false
   TEST_TIME = Time.now
 
-  def test_constructorAndGetters
+  def test_constructor_and_getters
     entry = ::Zip::Entry.new(TEST_ZIPFILE,
                              TEST_NAME,
                              TEST_COMMENT,
@@ -33,45 +33,45 @@ class ZipEntryTest < MiniTest::Test
     assert_equal(TEST_TIME, entry.time)
   end
 
-  def test_is_directoryAndIsFile
-    assert(::Zip::Entry.new(TEST_ZIPFILE, "hello").file?)
-    assert(!::Zip::Entry.new(TEST_ZIPFILE, "hello").directory?)
+  def test_is_directory_and_is_file
+    assert(::Zip::Entry.new(TEST_ZIPFILE, 'hello').file?)
+    assert(!::Zip::Entry.new(TEST_ZIPFILE, 'hello').directory?)
 
-    assert(::Zip::Entry.new(TEST_ZIPFILE, "dir/hello").file?)
-    assert(!::Zip::Entry.new(TEST_ZIPFILE, "dir/hello").directory?)
+    assert(::Zip::Entry.new(TEST_ZIPFILE, 'dir/hello').file?)
+    assert(!::Zip::Entry.new(TEST_ZIPFILE, 'dir/hello').directory?)
 
-    assert(::Zip::Entry.new(TEST_ZIPFILE, "hello/").directory?)
-    assert(!::Zip::Entry.new(TEST_ZIPFILE, "hello/").file?)
+    assert(::Zip::Entry.new(TEST_ZIPFILE, 'hello/').directory?)
+    assert(!::Zip::Entry.new(TEST_ZIPFILE, 'hello/').file?)
 
-    assert(::Zip::Entry.new(TEST_ZIPFILE, "dir/hello/").directory?)
-    assert(!::Zip::Entry.new(TEST_ZIPFILE, "dir/hello/").file?)
+    assert(::Zip::Entry.new(TEST_ZIPFILE, 'dir/hello/').directory?)
+    assert(!::Zip::Entry.new(TEST_ZIPFILE, 'dir/hello/').file?)
   end
 
   def test_equality
-    entry1 = ::Zip::Entry.new("file.zip", "name", "isNotCompared",
-                              "something extra", 123, 1234,
-                              ::Zip::Entry::DEFLATED, 10000)
-    entry2 = ::Zip::Entry.new("file.zip", "name", "isNotComparedXXX",
-                              "something extra", 123, 1234,
-                              ::Zip::Entry::DEFLATED, 10000)
-    entry3 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
-                              "something extra", 123, 1234,
-                              ::Zip::Entry::DEFLATED, 10000)
-    entry4 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
-                              "something extraXX", 123, 1234,
-                              ::Zip::Entry::DEFLATED, 10000)
-    entry5 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
-                              "something extraXX", 12, 1234,
-                              ::Zip::Entry::DEFLATED, 10000)
-    entry6 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
-                              "something extraXX", 12, 123,
-                              ::Zip::Entry::DEFLATED, 10000)
-    entry7 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
-                              "something extraXX", 12, 123,
-                              ::Zip::Entry::STORED, 10000)
-    entry8 = ::Zip::Entry.new("file.zip", "name2", "isNotComparedXXX",
-                              "something extraXX", 12, 123,
-                              ::Zip::Entry::STORED, 100000)
+    entry1 = ::Zip::Entry.new('file.zip', 'name', 'isNotCompared',
+                              'something extra', 123, 1234,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry2 = ::Zip::Entry.new('file.zip', 'name', 'isNotComparedXXX',
+                              'something extra', 123, 1234,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry3 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extra', 123, 1234,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry4 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extraXX', 123, 1234,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry5 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extraXX', 12, 1234,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry6 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extraXX', 12, 123,
+                              ::Zip::Entry::DEFLATED, 10_000)
+    entry7 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extraXX', 12, 123,
+                              ::Zip::Entry::STORED, 10_000)
+    entry8 = ::Zip::Entry.new('file.zip', 'name2', 'isNotComparedXXX',
+                              'something extraXX', 12, 123,
+                              ::Zip::Entry::STORED, 100_000)
 
     assert_equal(entry1, entry1)
     assert_equal(entry1, entry2)
@@ -83,51 +83,51 @@ class ZipEntryTest < MiniTest::Test
     assert(entry6 != entry7)
     assert(entry7 != entry8)
 
-    assert(entry7 != "hello")
+    assert(entry7 != 'hello')
     assert(entry7 != 12)
   end
 
   def test_compare
-    assert_equal(0, (::Zip::Entry.new("zf.zip", "a") <=> ::Zip::Entry.new("zf.zip", "a")))
-    assert_equal(1, (::Zip::Entry.new("zf.zip", "b") <=> ::Zip::Entry.new("zf.zip", "a")))
-    assert_equal(-1, (::Zip::Entry.new("zf.zip", "a") <=> ::Zip::Entry.new("zf.zip", "b")))
+    assert_equal(0, (::Zip::Entry.new('zf.zip', 'a') <=> ::Zip::Entry.new('zf.zip', 'a')))
+    assert_equal(1, (::Zip::Entry.new('zf.zip', 'b') <=> ::Zip::Entry.new('zf.zip', 'a')))
+    assert_equal(-1, (::Zip::Entry.new('zf.zip', 'a') <=> ::Zip::Entry.new('zf.zip', 'b')))
 
     entries = [
-        ::Zip::Entry.new("zf.zip", "5"),
-        ::Zip::Entry.new("zf.zip", "1"),
-        ::Zip::Entry.new("zf.zip", "3"),
-        ::Zip::Entry.new("zf.zip", "4"),
-        ::Zip::Entry.new("zf.zip", "0"),
-        ::Zip::Entry.new("zf.zip", "2")
+      ::Zip::Entry.new('zf.zip', '5'),
+      ::Zip::Entry.new('zf.zip', '1'),
+      ::Zip::Entry.new('zf.zip', '3'),
+      ::Zip::Entry.new('zf.zip', '4'),
+      ::Zip::Entry.new('zf.zip', '0'),
+      ::Zip::Entry.new('zf.zip', '2')
     ]
 
     entries.sort!
-    assert_equal("0", entries[0].to_s)
-    assert_equal("1", entries[1].to_s)
-    assert_equal("2", entries[2].to_s)
-    assert_equal("3", entries[3].to_s)
-    assert_equal("4", entries[4].to_s)
-    assert_equal("5", entries[5].to_s)
+    assert_equal('0', entries[0].to_s)
+    assert_equal('1', entries[1].to_s)
+    assert_equal('2', entries[2].to_s)
+    assert_equal('3', entries[3].to_s)
+    assert_equal('4', entries[4].to_s)
+    assert_equal('5', entries[5].to_s)
   end
 
-  def test_parentAsString
-    entry1 = ::Zip::Entry.new("zf.zip", "aa")
-    entry2 = ::Zip::Entry.new("zf.zip", "aa/")
-    entry3 = ::Zip::Entry.new("zf.zip", "aa/bb")
-    entry4 = ::Zip::Entry.new("zf.zip", "aa/bb/")
-    entry5 = ::Zip::Entry.new("zf.zip", "aa/bb/cc")
-    entry6 = ::Zip::Entry.new("zf.zip", "aa/bb/cc/")
+  def test_parent_as_string
+    entry1 = ::Zip::Entry.new('zf.zip', 'aa')
+    entry2 = ::Zip::Entry.new('zf.zip', 'aa/')
+    entry3 = ::Zip::Entry.new('zf.zip', 'aa/bb')
+    entry4 = ::Zip::Entry.new('zf.zip', 'aa/bb/')
+    entry5 = ::Zip::Entry.new('zf.zip', 'aa/bb/cc')
+    entry6 = ::Zip::Entry.new('zf.zip', 'aa/bb/cc/')
 
     assert_equal(nil, entry1.parent_as_string)
     assert_equal(nil, entry2.parent_as_string)
-    assert_equal("aa/", entry3.parent_as_string)
-    assert_equal("aa/", entry4.parent_as_string)
-    assert_equal("aa/bb/", entry5.parent_as_string)
-    assert_equal("aa/bb/", entry6.parent_as_string)
+    assert_equal('aa/', entry3.parent_as_string)
+    assert_equal('aa/', entry4.parent_as_string)
+    assert_equal('aa/bb/', entry5.parent_as_string)
+    assert_equal('aa/bb/', entry6.parent_as_string)
   end
 
   def test_entry_name_cannot_start_with_slash
-    assert_raises(::Zip::EntryNameError) { ::Zip::Entry.new("zf.zip", "/hej/der") }
+    assert_raises(::Zip::EntryNameError) { ::Zip::Entry.new('zf.zip', '/hej/der') }
   end
 
   def test_store_file_without_compression
@@ -139,27 +139,25 @@ class ZipEntryTest < MiniTest::Test
     end
 
     zipfile = Zip::File.open('/tmp/no_compress.zip', Zip::File::CREATE)
-    mimetype_entry = Zip::Entry.new(zipfile,                #@zipfile
-                                    'mimetype',             #@name
-                                    '',                     #@comment
-                                    '',                     #@extra
-                                    0,                      #@compressed_size
-                                    0,                      #@crc
-                                    Zip::Entry::STORED)     #@comppressed_method
+    mimetype_entry = Zip::Entry.new(zipfile,                # @zipfile
+                                    'mimetype',             # @name
+                                    '',                     # @comment
+                                    '',                     # @extra
+                                    0,                      # @compressed_size
+                                    0,                      # @crc
+                                    Zip::Entry::STORED)     # @comppressed_method
 
     zipfile.add(mimetype_entry, 'test/data/mimetype')
 
     files.each do |file|
-      zipfile.add(file.sub("test/data/globTest/", ''), file)
+      zipfile.add(file.sub('test/data/globTest/', ''), file)
     end
     zipfile.close
 
-    f= File.open('/tmp/no_compress.zip', 'rb')
+    f = File.open('/tmp/no_compress.zip', 'rb')
     first_100_bytes = f.read(100)
     f.close
 
     assert_match(/mimetypeapplication\/epub\+zip/, first_100_bytes)
   end
-
-
 end

data/test/errors_test.rb

@@ -2,7 +2,6 @@
 require 'test_helper'
 
 class ErrorsTest < MiniTest::Test
-
   def test_rescue_legacy_zip_error
     raise ::Zip::Error
   rescue ::Zip::ZipError
@@ -32,5 +31,4 @@ class ErrorsTest < MiniTest::Test
     raise ::Zip::InternalError
   rescue ::Zip::ZipInternalError
   end
-
 end

data/test/extra_field_test.rb

@@ -2,26 +2,26 @@ require 'test_helper'
 
 class ZipExtraFieldTest < MiniTest::Test
   def test_new
-    extra_pure = ::Zip::ExtraField.new("")
-    extra_withstr = ::Zip::ExtraField.new("foo")
+    extra_pure = ::Zip::ExtraField.new('')
+    extra_withstr = ::Zip::ExtraField.new('foo')
     assert_instance_of(::Zip::ExtraField, extra_pure)
     assert_instance_of(::Zip::ExtraField, extra_withstr)
   end
 
   def test_unknownfield
-    extra = ::Zip::ExtraField.new("foo")
-    assert_equal(extra["Unknown"], "foo")
-    extra.merge("a")
-    assert_equal(extra["Unknown"], "fooa")
-    extra.merge("barbaz")
-    assert_equal(extra.to_s, "fooabarbaz")
+    extra = ::Zip::ExtraField.new('foo')
+    assert_equal(extra['Unknown'], 'foo')
+    extra.merge('a')
+    assert_equal(extra['Unknown'], 'fooa')
+    extra.merge('barbaz')
+    assert_equal(extra.to_s, 'fooabarbaz')
   end
 
   def test_ntfs
     str = "\x0A\x00 \x00\x00\x00\x00\x00\x01\x00\x18\x00\xC0\x81\x17\xE8B\xCE\xCF\x01\xC0\x81\x17\xE8B\xCE\xCF\x01\xC0\x81\x17\xE8B\xCE\xCF\x01"
     extra = ::Zip::ExtraField.new(str)
-    assert(extra.member?("NTFS"))
-    t = ::Zip::DOSTime.at(1410496497.405178)
+    assert(extra.member?('NTFS'))
+    t = ::Zip::DOSTime.at(1_410_496_497.405178)
     assert_equal(t, extra['NTFS'].mtime)
     assert_equal(t, extra['NTFS'].atime)
     assert_equal(t, extra['NTFS'].ctime)
@@ -29,12 +29,12 @@ class ZipExtraFieldTest < MiniTest::Test
 
   def test_merge
     str = "UT\x5\0\x3\250$\r@Ux\0\0"
-    extra1 = ::Zip::ExtraField.new("")
+    extra1 = ::Zip::ExtraField.new('')
     extra2 = ::Zip::ExtraField.new(str)
-    assert(!extra1.member?("UniversalTime"))
-    assert(extra2.member?("UniversalTime"))
+    assert(!extra1.member?('UniversalTime'))
+    assert(extra2.member?('UniversalTime'))
     extra1.merge(str)
-    assert_equal(extra1["UniversalTime"].mtime, extra2["UniversalTime"].mtime)
+    assert_equal(extra1['UniversalTime'].mtime, extra2['UniversalTime'].mtime)
   end
 
   def test_length
@@ -42,19 +42,18 @@ class ZipExtraFieldTest < MiniTest::Test
     extra = ::Zip::ExtraField.new(str)
     assert_equal(extra.local_size, extra.to_local_bin.size)
     assert_equal(extra.c_dir_size, extra.to_c_dir_bin.size)
-    extra.merge("foo")
+    extra.merge('foo')
     assert_equal(extra.local_size, extra.to_local_bin.size)
     assert_equal(extra.c_dir_size, extra.to_c_dir_bin.size)
   end
 
-
   def test_to_s
     str = "UT\x5\0\x3\250$\r@Ux\0\0Te\0\0testit"
     extra = ::Zip::ExtraField.new(str)
     assert_instance_of(String, extra.to_s)
 
     s = extra.to_s
-    extra.merge("foo")
+    extra.merge('foo')
     assert_equal(s.length + 3, extra.to_s.length)
   end
 
@@ -65,14 +64,13 @@ class ZipExtraFieldTest < MiniTest::Test
     extra3 = ::Zip::ExtraField.new(str)
     assert_equal(extra1, extra2)
 
-    extra2["UniversalTime"].mtime = ::Zip::DOSTime.now
+    extra2['UniversalTime'].mtime = ::Zip::DOSTime.now
     assert(extra1 != extra2)
 
-    extra3.create("IUnix")
+    extra3.create('IUnix')
     assert(extra1 != extra3)
 
-    extra1.create("IUnix")
+    extra1.create('IUnix')
     assert_equal(extra1, extra3)
   end
-
 end