rubyzip 1.1.7 → 2.3.2

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 returnTrue
-    true
-  end
-end

data/test/deflater_test.rb

@@ -1,67 +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_outputOperator
-    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") {
-        |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
-
-  def inflate(fileName)
-    txt = nil
-    File.open(fileName, "rb") {
-        |file|
-      inflater = ::Zip::Inflater.new(file)
-      txt = inflater.sysread
-    }
-  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, lambda { |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,138 +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_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_equal(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
-end

data/test/entry_test.rb

@@ -1,165 +0,0 @@
-require 'test_helper'
-
-class ZipEntryTest < MiniTest::Test
-  TEST_ZIPFILE = "someZipFile.zip"
-  TEST_COMMENT = "a comment"
-  TEST_COMPRESSED_SIZE = 1234
-  TEST_CRC = 325324
-  TEST_EXTRA = "Some data here"
-  TEST_COMPRESSIONMETHOD = ::Zip::Entry::DEFLATED
-  TEST_NAME = "entry name"
-  TEST_SIZE = 8432
-  TEST_ISDIRECTORY = false
-  TEST_TIME = Time.now
-
-  def test_constructorAndGetters
-    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_directoryAndIsFile
-    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, 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)
-
-    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_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/")
-
-    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)
-  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,36 +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,78 +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(1410496497.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

data/test/file_extract_directory_test.rb

@@ -1,56 +0,0 @@
-require 'test_helper'
-
-class ZipFileExtractDirectoryTest < MiniTest::Test
-  include CommonZipFileFixture
-
-  TEST_OUT_NAME = "test/data/generated/emptyOutDir"
-
-  def open_zip(&aProc)
-    assert(aProc != nil)
-    ::Zip::File.open(TestZipFile::TEST_ZIP4.zip_name, &aProc)
-  end
-
-  def extract_test_dir(&aProc)
-    open_zip {
-        |zf|
-      zf.extract(TestFiles::EMPTY_TEST_DIR, TEST_OUT_NAME, &aProc)
-    }
-  end
-
-  def setup
-    super
-
-    Dir.rmdir(TEST_OUT_NAME) if File.directory? TEST_OUT_NAME
-    File.delete(TEST_OUT_NAME) if File.exist? TEST_OUT_NAME
-  end
-
-  def test_extractDirectory
-    extract_test_dir
-    assert(File.directory?(TEST_OUT_NAME))
-  end
-
-  def test_extractDirectoryExistsAsDir
-    Dir.mkdir TEST_OUT_NAME
-    extract_test_dir
-    assert(File.directory?(TEST_OUT_NAME))
-  end
-
-  def test_extractDirectoryExistsAsFile
-    File.open(TEST_OUT_NAME, "w") { |f| f.puts "something" }
-    assert_raises(::Zip::DestinationFileExistsError) { extract_test_dir }
-  end
-
-  def test_extractDirectoryExistsAsFileOverwrite
-    File.open(TEST_OUT_NAME, "w") { |f| f.puts "something" }
-    gotCalled = false
-    extract_test_dir {
-        |entry, destPath|
-      gotCalled = true
-      assert_equal(TEST_OUT_NAME, destPath)
-      assert(entry.directory?)
-      true
-    }
-    assert(gotCalled)
-    assert(File.directory?(TEST_OUT_NAME))
-  end
-end