rubyzip 1.1.7 → 1.2.4

data/test/ioextras/abstract_input_stream_test.rb

@@ -6,7 +6,7 @@ class AbstractInputStreamTest < MiniTest::Test
 
   TEST_LINES = ["Hello world#{$/}",
                 "this is the second line#{$/}",
-                "this is the last line"]
+                'this is the last line']
   TEST_STRING = TEST_LINES.join
   class TestAbstractInputStream
     include ::Zip::IOExtras::AbstractInputStream
@@ -17,10 +17,10 @@ class AbstractInputStreamTest < MiniTest::Test
       @readPointer = 0
     end
 
-    def sysread(charsToRead, buf = nil)
-      retVal=@contents[@readPointer, charsToRead]
-      @readPointer+=charsToRead
-      return retVal
+    def sysread(charsToRead, _buf = nil)
+      retVal = @contents[@readPointer, charsToRead]
+      @readPointer += charsToRead
+      retVal
     end
 
     def produce_input
@@ -28,7 +28,7 @@ class AbstractInputStreamTest < MiniTest::Test
     end
 
     def input_finished?
-      @contents[@readPointer] == nil
+      @contents[@readPointer].nil?
     end
   end
 
@@ -44,48 +44,47 @@ class AbstractInputStreamTest < MiniTest::Test
     assert_equal(2, @io.lineno)
     assert_equal(TEST_LINES[2], @io.gets)
     assert_equal(3, @io.lineno)
-    assert_equal(nil, @io.gets)
+    assert_nil(@io.gets)
     assert_equal(4, @io.lineno)
   end
 
-  def test_getsMultiCharSeperator
-    assert_equal("Hell", @io.gets("ll"))
-    assert_equal("o world#{$/}this is the second l", @io.gets("d l"))
+  def test_gets_multi_char_seperator
+    assert_equal('Hell', @io.gets('ll'))
+    assert_equal("o world#{$/}this is the second l", @io.gets('d l'))
   end
 
   LONG_LINES = [
-      'x'*48 + "\r\n",
-      'y'*49 + "\r\n",
-      'rest',
+    'x' * 48 + "\r\n",
+    'y' * 49 + "\r\n",
+    'rest'
   ]
 
-  def test_getsMulitCharSeperator_split
+  def test_gets_mulit_char_seperator_split
     io = TestAbstractInputStream.new(LONG_LINES.join)
     assert_equal(LONG_LINES[0], io.gets("\r\n"))
     assert_equal(LONG_LINES[1], io.gets("\r\n"))
     assert_equal(LONG_LINES[2], io.gets("\r\n"))
   end
 
-  def test_getsWithSepAndIndex
+  def test_gets_with_sep_and_index
     io = TestAbstractInputStream.new(LONG_LINES.join)
     assert_equal('x', io.gets("\r\n", 1))
-    assert_equal('x'*47 + "\r", io.gets("\r\n", 48))
+    assert_equal('x' * 47 + "\r", io.gets("\r\n", 48))
     assert_equal("\n", io.gets(nil, 1))
     assert_equal('yy', io.gets(nil, 2))
   end
 
-  def test_getsWithIndex
+  def test_gets_with_index
     assert_equal(TEST_LINES[0], @io.gets(100))
     assert_equal('this', @io.gets(4))
   end
 
   def test_each_line
-    lineNumber=0
-    @io.each_line {
-        |line|
+    lineNumber = 0
+    @io.each_line do |line|
       assert_equal(TEST_LINES[lineNumber], line)
-      lineNumber+=1
-    }
+      lineNumber += 1
+    end
   end
 
   def test_readlines
@@ -96,7 +95,7 @@ class AbstractInputStreamTest < MiniTest::Test
     test_gets
     begin
       @io.readline
-      fail "EOFError expected"
+      fail 'EOFError expected'
     rescue EOFError
     end
   end

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.puts(["hello\n", "world\n"])
+    @output_stream.buffer = ''
+    @output_stream.puts(%W[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(%W[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/ioextras/fake_io_test.rb

@@ -12,7 +12,7 @@ class FakeIOTest < MiniTest::Test
     assert(obj.kind_of?(Object))
     assert(obj.kind_of?(FakeIOUsingClass))
     assert(obj.kind_of?(IO))
-    assert(!obj.kind_of?(Fixnum))
+    assert(!obj.kind_of?(Integer))
     assert(!obj.kind_of?(String))
   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|
-      assert_equal(nil, ::Zip::Entry.read_local_entry(file))
-    }
+  def test_read_local_entry_from_non_zip_file
+    ::File.open('test/data/file2.txt') do |file|
+      assert_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