hotplate 0.0.1

data/lib/hotplate/gems/rubyzip-1.1.7/test/data/mimetype

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

data/lib/hotplate/gems/rubyzip-1.1.7/test/data/notzippedruby.rb

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

data/lib/hotplate/gems/rubyzip-1.1.7/test/deflater_test.rb

@@ -0,0 +1,67 @@
+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/lib/hotplate/gems/rubyzip-1.1.7/test/encryption_test.rb

@@ -0,0 +1,42 @@
+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/lib/hotplate/gems/rubyzip-1.1.7/test/entry_set_test.rb

@@ -0,0 +1,138 @@
+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/lib/hotplate/gems/rubyzip-1.1.7/test/entry_test.rb

@@ -0,0 +1,165 @@
+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/lib/hotplate/gems/rubyzip-1.1.7/test/errors_test.rb

@@ -0,0 +1,36 @@
+# 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/lib/hotplate/gems/rubyzip-1.1.7/test/extra_field_test.rb

@@ -0,0 +1,78 @@
+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/lib/hotplate/gems/rubyzip-1.1.7/test/file_extract_directory_test.rb

@@ -0,0 +1,56 @@
+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