rubyzip 1.1.4 → 1.1.5

data/test/data/mimetype

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

data/test/data/notzippedruby.rb

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

data/test/deflater_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+class DeflaterTest < MiniTest::Unit::TestCase
+  include CrcTest
+
+  def test_outputOperator
+    txt = load_file("test/data/file2.txt")
+    deflate(txt, "deflatertest.bin")
+    inflatedTxt = inflate("deflatertest.bin")
+    assert_equal(txt, inflatedTxt)
+  end
+
+  def test_default_compression
+    txt = load_file("test/data/file2.txt")
+
+    Zip.default_compression = ::Zlib::BEST_COMPRESSION
+    deflate(txt, "compressiontest_best_compression.bin")
+    Zip.default_compression = ::Zlib::DEFAULT_COMPRESSION
+    deflate(txt, "compressiontest_default_compression.bin")
+    Zip.default_compression = ::Zlib::NO_COMPRESSION
+    deflate(txt, "compressiontest_no_compression.bin")
+
+    best    = File.size("compressiontest_best_compression.bin")
+    default = File.size("compressiontest_default_compression.bin")
+    no      = File.size("compressiontest_no_compression.bin")
+
+    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/dummy.txt

@@ -0,0 +1 @@
+hello worldbingo

data/test/entry_set_test.rb

@@ -0,0 +1,125 @@
+require 'test_helper'
+
+class ZipEntrySetTest < MiniTest::Unit::TestCase
+  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 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_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

@@ -0,0 +1,165 @@
+require 'test_helper'
+
+class ZipEntryTest < MiniTest::Unit::TestCase
+  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.exists?('/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

@@ -0,0 +1,36 @@
+# encoding: utf-8
+require 'test_helper'
+
+class ErrorsTest < MiniTest::Unit::TestCase
+
+  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

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class ZipExtraFieldTest < MiniTest::Unit::TestCase
+  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_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