rubyzip 1.3.0 → 3.0.0.alpha

data/test/data/mimetype

@@ -1 +0,0 @@
-application/epub+zip

data/test/data/notzippedruby.rb

@@ -1,7 +0,0 @@
-#!/usr/bin/env ruby
-
-class NotZippedRuby
-  def return_true
-    true
-  end
-end

data/test/data/path_traversal/Makefile

@@ -1,10 +0,0 @@
-# Based on 'relative2' in https://github.com/jwilk/path-traversal-samples,
-# but create the local `tmp` folder before adding the symlink. Otherwise
-# we may bail out before we get to trying to create the file.
-all: relative1.zip
-relative1.zip:
-	rm -f $(@)
-	mkdir -p -m 755 tmp/tmp
-	umask 022 && echo moo > moo
-	cd tmp && zip -X ../$(@) tmp tmp/../../moo
-	rm -rf tmp moo

data/test/data/path_traversal/jwilk/README.md

@@ -1,5 +0,0 @@
-# Path Traversal Samples
-
-Copied from https://github.com/jwilk/path-traversal-samples on 2018-08-26.
-
-License: MIT

data/test/data/path_traversal/tuzovakaoff/README.md

@@ -1,3 +0,0 @@
-# Path Traversal Samples
-
-Copied from https://github.com/tuzovakaoff/zip_path_traversal on 2018-08-25.

data/test/deflater_test.rb

@@ -1,65 +0,0 @@
-require 'test_helper'
-
-class DeflaterTest < MiniTest::Test
-  include CrcTest
-
-  DEFLATER_TEST_FILE = 'test/data/generated/deflatertest.bin'
-  BEST_COMP_FILE = 'test/data/generated/compressiontest_best_compression.bin'
-  DEFAULT_COMP_FILE = 'test/data/generated/compressiontest_default_compression.bin'
-  NO_COMP_FILE = 'test/data/generated/compressiontest_no_compression.bin'
-
-  def test_output_operator
-    txt = load_file('test/data/file2.txt')
-    deflate(txt, DEFLATER_TEST_FILE)
-    inflatedTxt = inflate(DEFLATER_TEST_FILE)
-    assert_equal(txt, inflatedTxt)
-  end
-
-  def test_default_compression
-    txt = load_file('test/data/file2.txt')
-
-    Zip.default_compression = ::Zlib::BEST_COMPRESSION
-    deflate(txt, BEST_COMP_FILE)
-    Zip.default_compression = ::Zlib::DEFAULT_COMPRESSION
-    deflate(txt, DEFAULT_COMP_FILE)
-    Zip.default_compression = ::Zlib::NO_COMPRESSION
-    deflate(txt, NO_COMP_FILE)
-
-    best    = File.size(BEST_COMP_FILE)
-    default = File.size(DEFAULT_COMP_FILE)
-    no      = File.size(NO_COMP_FILE)
-
-    assert(best < default)
-    assert(best < no)
-    assert(default < no)
-  end
-
-  private
-
-  def load_file(fileName)
-    txt = nil
-    File.open(fileName, 'rb') { |f| txt = f.read }
-  end
-
-  def deflate(data, fileName)
-    File.open(fileName, 'wb') do |file|
-      deflater = ::Zip::Deflater.new(file)
-      deflater << data
-      deflater.finish
-      assert_equal(deflater.size, data.size)
-      file << 'trailing data for zlib with -MAX_WBITS'
-    end
-  end
-
-  def inflate(fileName)
-    txt = nil
-    File.open(fileName, 'rb') do |file|
-      inflater = ::Zip::Inflater.new(file)
-      txt = inflater.sysread
-    end
-  end
-
-  def test_crc
-    run_crc_test(::Zip::Deflater)
-  end
-end

data/test/encryption_test.rb

@@ -1,42 +0,0 @@
-require 'test_helper'
-
-class EncryptionTest < MiniTest::Test
-  ENCRYPT_ZIP_TEST_FILE = 'test/data/zipWithEncryption.zip'
-  INPUT_FILE1 = 'test/data/file1.txt'
-
-  def setup
-    @default_compression = Zip.default_compression
-    Zip.default_compression = ::Zlib::DEFAULT_COMPRESSION
-  end
-
-  def teardown
-    Zip.default_compression = @default_compression
-  end
-
-  def test_encrypt
-    test_file = open(ENCRYPT_ZIP_TEST_FILE, 'rb').read
-
-    @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, ->(_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
-        end.string
-      end
-    end
-
-    @output.unpack('C*').each_with_index do |c, i|
-      assert_equal test_file[i].ord, c
-    end
-  end
-
-  def test_decrypt
-    Zip::InputStream.open(ENCRYPT_ZIP_TEST_FILE, 0, Zip::TraditionalDecrypter.new('password')) do |zis|
-      entry = zis.get_next_entry
-      assert_equal 'file1.txt', entry.name
-      assert_equal 1327, entry.size
-      assert_equal open(INPUT_FILE1, 'r').read, zis.read
-    end
-  end
-end

data/test/entry_set_test.rb

@@ -1,163 +0,0 @@
-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')
-  ]
-
-  def setup
-    @zipEntrySet = ::Zip::EntrySet.new(ZIP_ENTRIES)
-  end
-
-  def teardown
-    ::Zip.reset!
-  end
-
-  def test_include
-    assert(@zipEntrySet.include?(ZIP_ENTRIES.first))
-    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')
-    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')
-    zes << entry1
-    assert(zes.include?(entry1))
-    zes.push(entry2)
-    assert(zes.include?(entry2))
-  end
-
-  def test_delete
-    assert_equal(ZIP_ENTRIES.size, @zipEntrySet.size)
-    entry = @zipEntrySet.delete(ZIP_ENTRIES.first)
-    assert_equal(ZIP_ENTRIES.size - 1, @zipEntrySet.size)
-    assert_equal(ZIP_ENTRIES.first, entry)
-
-    entry = @zipEntrySet.delete(ZIP_ENTRIES.first)
-    assert_equal(ZIP_ENTRIES.size - 1, @zipEntrySet.size)
-    assert_nil(entry)
-  end
-
-  def test_each
-    # Used each instead each_with_index due the bug in jRuby
-    count = 0
-    @zipEntrySet.each do |entry|
-      assert(ZIP_ENTRIES.include?(entry))
-      count += 1
-    end
-    assert_equal(ZIP_ENTRIES.size, count)
-  end
-
-  def test_entries
-    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_nil(zipEntrySet.find_entry('mixedcasename'))
-  end
-
-  def test_entries_with_sort
-    ::Zip.sort_entries = true
-    assert_equal(ZIP_ENTRIES.sort, @zipEntrySet.entries)
-    ::Zip.sort_entries = false
-    assert_equal(ZIP_ENTRIES, @zipEntrySet.entries)
-  end
-
-  def test_entries_sorted_in_each
-    ::Zip.sort_entries = true
-    arr = []
-    @zipEntrySet.each do |entry|
-      arr << entry
-    end
-    assert_equal(ZIP_ENTRIES.sort, arr)
-  end
-
-  def test_compound
-    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)
-    assert(@zipEntrySet.include?(newEntry))
-
-    @zipEntrySet.delete(newEntry)
-    assert_equal(ZIP_ENTRIES.size, @zipEntrySet.size)
-  end
-
-  def test_dup
-    copy = @zipEntrySet.dup
-    assert_equal(@zipEntrySet, copy)
-
-    # demonstrate that this is a deep copy
-    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/')
-    ]
-    entrySet = ::Zip::EntrySet.new(entries)
-
-    assert_nil(entrySet.parent(entries[0]))
-    assert_equal(entries[0], entrySet.parent(entries[1]))
-    assert_equal(entries[1], entrySet.parent(entries[2]))
-  end
-
-  def test_glob
-    res = @zipEntrySet.glob('name[2-4]')
-    assert_equal(3, res.size)
-    assert_equal(ZIP_ENTRIES[1, 3].sort, res.sort)
-  end
-
-  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')
-    ]
-    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 })
-  end
-
-  def test_glob3
-    entries = [
-      ::Zip::Entry.new('zf.zip', 'a/a'),
-      ::Zip::Entry.new('zf.zip', 'a/b'),
-      ::Zip::Entry.new('zf.zip', 'a/c')
-    ]
-    entrySet = ::Zip::EntrySet.new(entries)
-
-    assert_equal(entries[0, 2].sort, entrySet.glob('a/{a,b}').sort)
-  end
-end

data/test/entry_test.rb

@@ -1,154 +0,0 @@
-require 'test_helper'
-
-class ZipEntryTest < MiniTest::Test
-  include ZipEntryData
-
-  def test_constructor_and_getters
-    entry = ::Zip::Entry.new(TEST_ZIPFILE,
-                             TEST_NAME,
-                             TEST_COMMENT,
-                             TEST_EXTRA,
-                             TEST_COMPRESSED_SIZE,
-                             TEST_CRC,
-                             TEST_COMPRESSIONMETHOD,
-                             TEST_SIZE,
-                             TEST_TIME)
-
-    assert_equal(TEST_COMMENT, entry.comment)
-    assert_equal(TEST_COMPRESSED_SIZE, entry.compressed_size)
-    assert_equal(TEST_CRC, entry.crc)
-    assert_instance_of(::Zip::ExtraField, entry.extra)
-    assert_equal(TEST_COMPRESSIONMETHOD, entry.compression_method)
-    assert_equal(TEST_NAME, entry.name)
-    assert_equal(TEST_SIZE, entry.size)
-    assert_equal(TEST_TIME, entry.time)
-  end
-
-  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, '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?)
-  end
-
-  def test_equality
-    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)
-
-    assert(entry2 != entry3)
-    assert(entry3 != entry4)
-    assert(entry4 != entry5)
-    assert(entry5 != entry6)
-    assert(entry6 != entry7)
-    assert(entry7 != entry8)
-
-    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')))
-
-    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')
-    ]
-
-    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)
-  end
-
-  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_nil(entry1.parent_as_string)
-    assert_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)
-  end
-
-  def test_entry_name_cannot_start_with_slash
-    assert_raises(::Zip::EntryNameError) { ::Zip::Entry.new('zf.zip', '/hej/der') }
-  end
-
-  def test_store_file_without_compression
-    File.delete('/tmp/no_compress.zip') if File.exist?('/tmp/no_compress.zip')
-    files = Dir[File.join('test/data/globTest', '**', '**')]
-
-    Zip.setup do |z|
-      z.write_zip64_support = false
-    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
-
-    zipfile.add(mimetype_entry, 'test/data/mimetype')
-
-    files.each do |file|
-      zipfile.add(file.sub('test/data/globTest/', ''), file)
-    end
-    zipfile.close
-
-    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

@@ -1,35 +0,0 @@
-# encoding: utf-8
-
-require 'test_helper'
-
-class ErrorsTest < MiniTest::Test
-  def test_rescue_legacy_zip_error
-    raise ::Zip::Error
-  rescue ::Zip::ZipError
-  end
-
-  def test_rescue_legacy_zip_entry_exists_error
-    raise ::Zip::EntryExistsError
-  rescue ::Zip::ZipEntryExistsError
-  end
-
-  def test_rescue_legacy_zip_destination_file_exists_error
-    raise ::Zip::DestinationFileExistsError
-  rescue ::Zip::ZipDestinationFileExistsError
-  end
-
-  def test_rescue_legacy_zip_compression_method_error
-    raise ::Zip::CompressionMethodError
-  rescue ::Zip::ZipCompressionMethodError
-  end
-
-  def test_rescue_legacy_zip_entry_name_error
-    raise ::Zip::EntryNameError
-  rescue ::Zip::ZipEntryNameError
-  end
-
-  def test_rescue_legacy_zip_internal_error
-    raise ::Zip::InternalError
-  rescue ::Zip::ZipInternalError
-  end
-end

data/test/extra_field_test.rb

@@ -1,76 +0,0 @@
-require 'test_helper'
-
-class ZipExtraFieldTest < MiniTest::Test
-  def test_new
-    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')
-  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(1_410_496_497.405178)
-    assert_equal(t, extra['NTFS'].mtime)
-    assert_equal(t, extra['NTFS'].atime)
-    assert_equal(t, extra['NTFS'].ctime)
-  end
-
-  def test_merge
-    str = "UT\x5\0\x3\250$\r@Ux\0\0"
-    extra1 = ::Zip::ExtraField.new('')
-    extra2 = ::Zip::ExtraField.new(str)
-    assert(!extra1.member?('UniversalTime'))
-    assert(extra2.member?('UniversalTime'))
-    extra1.merge(str)
-    assert_equal(extra1['UniversalTime'].mtime, extra2['UniversalTime'].mtime)
-  end
-
-  def test_length
-    str = "UT\x5\0\x3\250$\r@Ux\0\0Te\0\0testit"
-    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')
-    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')
-    assert_equal(s.length + 3, extra.to_s.length)
-  end
-
-  def test_equality
-    str = "UT\x5\0\x3\250$\r@"
-    extra1 = ::Zip::ExtraField.new(str)
-    extra2 = ::Zip::ExtraField.new(str)
-    extra3 = ::Zip::ExtraField.new(str)
-    assert_equal(extra1, extra2)
-
-    extra2['UniversalTime'].mtime = ::Zip::DOSTime.now
-    assert(extra1 != extra2)
-
-    extra3.create('IUnix')
-    assert(extra1 != extra3)
-
-    extra1.create('IUnix')
-    assert_equal(extra1, extra3)
-  end
-end