rubyzip 1.1.4 → 1.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d23ddcc769403826e54f22ac7351086bd4dda0ad
-  data.tar.gz: 6e45bc494896b948785b181b843393092c0a6a87
+  metadata.gz: 8f37f5862f1890546a9ceb653b406beea7daec34
+  data.tar.gz: 124b547d2a2999a5fb6cd99597721d8dd45347aa
 SHA512:
-  metadata.gz: b2227b5f2243bf5921259930ab98d82b794b3bd4bfd47d787fbd2c58b0e9fefa3524dc6072eec66cafe79c8ac81f47efb8608c257750d4cab8fca0311c907ffa
-  data.tar.gz: 262be035076ac7b7840190718d5191e47dc15847dec3e1e28c8fa415b1f423919ca444cedc544b22b23af4e1f2cd0de2911cacdd4a9816fb79abb1449fea52d6
+  metadata.gz: a2daaac5e981f3aada2d3426bb51f81e60f61f5e8807efe9a339286923722f7ee0b5b4f5d42f366cfe90d486491f070402b5583d77141c544ea01893da6f40b3
+  data.tar.gz: 9d8efdb1540364455f36610c8d0d7c31f785458d5666176778ce6d1d1fb568902eb87369d6393fa9875177a164b8444a452bcfd7ae2811785be6c89475fa5c6e

data/lib/zip/file.rb

@@ -70,7 +70,7 @@ module Zip
       @comment = ''
       @create  = create
       case
-      when !buffer && ::File.exist?(file_name)
+      when !buffer && ::File.size?(file_name)
         @create = nil
         @exist_file_perms = ::File.stat(file_name).mode
         ::File.open(name, 'rb') do |f|
@@ -97,6 +97,7 @@ module Zip
         return zf unless block_given?
         begin
           yield zf
+          zf
         ensure
           zf.close
         end

data/lib/zip/inflater.rb

@@ -4,42 +4,26 @@ module Zip
       super
       @zlib_inflater           = ::Zlib::Inflate.new(-Zlib::MAX_WBITS)
       @output_buffer           = ''
-      @output_buffer_pos       = 0
       @has_returned_empty_string = false
     end
 
     def sysread(number_of_bytes = nil, buf = '')
-      buf ||= ''
-      buf.clear
       readEverything = number_of_bytes.nil?
-      if readEverything
-        buf << @output_buffer[@output_buffer_pos...@output_buffer.bytesize]
-
-        move_output_buffer_pos(buf.bytesize)
-      else
-        buf << @output_buffer[@output_buffer_pos, number_of_bytes]
-
-        move_output_buffer_pos(buf.bytesize)
-
-        if buf.bytesize == number_of_bytes
-          return buf
-        end
-      end
-      while readEverything || buf.bytesize + @output_buffer.bytesize < number_of_bytes
+      while readEverything || @output_buffer.bytesize < number_of_bytes
         break if internal_input_finished?
-        @output_buffer << internal_produce_input
+        @output_buffer << internal_produce_input(buf)
       end
-      return value_when_finished(number_of_bytes, buf) if @output_buffer.bytesize == 0 && input_finished?
-      end_index = (number_of_bytes.nil? ? @output_buffer.bytesize : number_of_bytes) - buf.bytesize
-      data = @output_buffer[0...end_index]
-
-      move_output_buffer_pos(data.bytesize)
-
-      buf << data
+      return value_when_finished if @output_buffer.bytesize == 0 && input_finished?
+      end_index = number_of_bytes.nil? ? @output_buffer.bytesize : number_of_bytes
+      @output_buffer.slice!(0...end_index)
     end
 
     def produce_input
-      sysread()
+      if (@output_buffer.empty?)
+        internal_produce_input
+      else
+        @output_buffer.slice!(0...(@output_buffer.length))
+      end
     end
 
     # to be used with produce_input, not read (as read may still have more data cached)
@@ -53,16 +37,7 @@ module Zip
 
     private
 
-    def move_output_buffer_pos(inc)
-      @output_buffer_pos += inc
-      if @output_buffer_pos == @output_buffer.bytesize
-        @output_buffer.clear
-        @output_buffer_pos = 0
-      end
-    end
-
-    def internal_produce_input
-      buf = ''
+    def internal_produce_input(buf = '')
       retried = 0
       begin
         @zlib_inflater.inflate(@input_stream.read(Decompressor::CHUNK_SIZE, buf))
@@ -77,14 +52,10 @@ module Zip
       @zlib_inflater.finished?
     end
 
-    def value_when_finished(number_of_bytes, buf) # mimic behaviour of ruby File object.
-      if number_of_bytes.nil?
-        buf
-      elsif buf.bytesize == 0
-        nil
-      else
-        buf
-      end
+    def value_when_finished # mimic behaviour of ruby File object.
+      return if @has_returned_empty_string
+      @has_returned_empty_string = true
+      ''
     end
   end
 end

data/lib/zip/ioextras/abstract_input_stream.rb

@@ -86,6 +86,10 @@ module Zip
         return @output_buffer.slice!(0...sep_index)
       end
 
+      def ungetc(byte)
+        @output_buffer = byte.chr + @output_buffer
+      end
+
       def flush
         ret_val        = @output_buffer
         @output_buffer = ''
@@ -108,4 +112,4 @@ module Zip
       alias_method :each, :each_line
     end
   end
-end
+end

data/lib/zip/version.rb

@@ -1,3 +1,3 @@
 module Zip
-  VERSION = '1.1.4'
+  VERSION = '1.1.5'
 end

data/test/alltests.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+  add_filter '/test'
+end
+Dir.chdir File.join(File.dirname(__FILE__))
+
+$VERBOSE = true
+
+require 'ioextrastest'
+require 'ziptest'
+require 'zipfilesystemtest'

data/test/basic_zip_file_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+class BasicZipFileTest < MiniTest::Unit::TestCase
+  include AssertEntry
+
+  def setup
+    @zip_file = ::Zip::File.new(TestZipFile::TEST_ZIP2.zip_name)
+    @testEntryNameIndex=0
+  end
+
+  def test_entries
+    assert_equal(TestZipFile::TEST_ZIP2.entry_names.sort,
+                 @zip_file.entries.entries.sort.map { |e| e.name })
+  end
+
+  def test_each
+    count = 0
+    visited = {}
+    @zip_file.each {
+        |entry|
+      assert(TestZipFile::TEST_ZIP2.entry_names.include?(entry.name))
+      assert(!visited.include?(entry.name))
+      visited[entry.name] = nil
+      count = count.succ
+    }
+    assert_equal(TestZipFile::TEST_ZIP2.entry_names.length, count)
+  end
+
+  def test_foreach
+    count = 0
+    visited = {}
+    ::Zip::File.foreach(TestZipFile::TEST_ZIP2.zip_name) {
+        |entry|
+      assert(TestZipFile::TEST_ZIP2.entry_names.include?(entry.name))
+      assert(!visited.include?(entry.name))
+      visited[entry.name] = nil
+      count = count.succ
+    }
+    assert_equal(TestZipFile::TEST_ZIP2.entry_names.length, count)
+  end
+
+  def test_get_input_stream
+    count = 0
+    visited = {}
+    @zip_file.each do |entry|
+      assert_entry(entry.name, @zip_file.get_input_stream(entry), entry.name)
+      assert(!visited.include?(entry.name))
+      visited[entry.name] = nil
+      count = count.succ
+    end
+    assert_equal(TestZipFile::TEST_ZIP2.entry_names.length, count)
+  end
+
+  def test_get_input_streamBlock
+    fileAndEntryName = @zip_file.entries.first.name
+    @zip_file.get_input_stream(fileAndEntryName) {
+        |zis|
+      assert_entryContentsForStream(fileAndEntryName,
+                                    zis,
+                                    fileAndEntryName)
+    }
+  end
+
+end

data/test/central_directory_entry_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+class ZipCentralDirectoryEntryTest < MiniTest::Unit::TestCase
+
+  def test_read_from_stream
+    File.open("test/data/testDirectory.bin", "rb") {
+        |file|
+      entry = ::Zip::Entry.read_c_dir_entry(file)
+
+      assert_equal("longAscii.txt", entry.name)
+      assert_equal(::Zip::Entry::DEFLATED, entry.compression_method)
+      assert_equal(106490, entry.size)
+      assert_equal(3784, entry.compressed_size)
+      assert_equal(0xfcd1799c, entry.crc)
+      assert_equal("", entry.comment)
+
+      entry = ::Zip::Entry.read_c_dir_entry(file)
+      assert_equal("empty.txt", entry.name)
+      assert_equal(::Zip::Entry::STORED, entry.compression_method)
+      assert_equal(0, entry.size)
+      assert_equal(0, entry.compressed_size)
+      assert_equal(0x0, entry.crc)
+      assert_equal("", entry.comment)
+
+      entry = ::Zip::Entry.read_c_dir_entry(file)
+      assert_equal("short.txt", entry.name)
+      assert_equal(::Zip::Entry::STORED, entry.compression_method)
+      assert_equal(6, entry.size)
+      assert_equal(6, entry.compressed_size)
+      assert_equal(0xbb76fe69, entry.crc)
+      assert_equal("", entry.comment)
+
+      entry = ::Zip::Entry.read_c_dir_entry(file)
+      assert_equal("longBinary.bin", entry.name)
+      assert_equal(::Zip::Entry::DEFLATED, entry.compression_method)
+      assert_equal(1000024, entry.size)
+      assert_equal(70847, entry.compressed_size)
+      assert_equal(0x10da7d59, entry.crc)
+      assert_equal('', entry.comment)
+
+      entry = ::Zip::Entry.read_c_dir_entry(file)
+      assert_equal(nil, entry)
+# Fields that are not check by this test:
+#          version made by                 2 bytes
+#          version needed to extract       2 bytes
+#          general purpose bit flag        2 bytes
+#          last mod file time              2 bytes
+#          last mod file date              2 bytes
+#          compressed size                 4 bytes
+#          uncompressed size               4 bytes
+#          disk number start               2 bytes
+#          internal file attributes        2 bytes
+#          external file attributes        4 bytes
+#          relative offset of local header 4 bytes
+
+#          file name (variable size)
+#          extra field (variable size)
+#          file comment (variable size)
+
+    }
+  end
+
+  def test_ReadEntryFromTruncatedZipFile
+    fragment=""
+    File.open("test/data/testDirectory.bin") { |f| fragment = f.read(12) } # cdir entry header is at least 46 bytes
+    fragment.extend(IOizeString)
+    entry = ::Zip::Entry.new
+    entry.read_c_dir_entry(fragment)
+    fail "ZipError expected"
+  rescue ::Zip::Error
+  end
+
+end

data/test/central_directory_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+class ZipCentralDirectoryTest < MiniTest::Unit::TestCase
+
+  def test_read_from_stream
+    ::File.open(TestZipFile::TEST_ZIP2.zip_name, "rb") {
+        |zipFile|
+      cdir = ::Zip::CentralDirectory.read_from_stream(zipFile)
+
+      assert_equal(TestZipFile::TEST_ZIP2.entry_names.size, cdir.size)
+      assert(cdir.entries.sort.compare_enumerables(TestZipFile::TEST_ZIP2.entry_names.sort) {
+          |cdirEntry, testEntryName|
+        cdirEntry.name == testEntryName
+      })
+      assert_equal(TestZipFile::TEST_ZIP2.comment, cdir.comment)
+    }
+  end
+
+  def test_readFromInvalidStream
+    File.open("test/data/file2.txt", "rb") {
+        |zipFile|
+      cdir = ::Zip::CentralDirectory.new
+      cdir.read_from_stream(zipFile)
+    }
+    fail "ZipError expected!"
+  rescue ::Zip::Error
+  end
+
+  def test_ReadFromTruncatedZipFile
+    fragment=""
+    File.open("test/data/testDirectory.bin", "rb") { |f| fragment = f.read }
+    fragment.slice!(12) # removed part of first cdir entry. eocd structure still complete
+    fragment.extend(IOizeString)
+    entry = ::Zip::CentralDirectory.new
+    entry.read_from_stream(fragment)
+    fail "ZipError expected"
+  rescue ::Zip::Error
+  end
+
+  def test_write_to_stream
+    entries = [::Zip::Entry.new("file.zip", "flimse", "myComment", "somethingExtra"),
+               ::Zip::Entry.new("file.zip", "secondEntryName"),
+               ::Zip::Entry.new("file.zip", "lastEntry.txt", "Has a comment too")]
+    cdir = ::Zip::CentralDirectory.new(entries, "my zip comment")
+    File.open("test/data/generated/cdirtest.bin", "wb") { |f| cdir.write_to_stream(f) }
+    cdirReadback = ::Zip::CentralDirectory.new
+    File.open("test/data/generated/cdirtest.bin", "rb") { |f| cdirReadback.read_from_stream(f) }
+
+    assert_equal(cdir.entries.sort, cdirReadback.entries.sort)
+  end
+
+  def test_write64_to_stream
+    ::Zip.write_zip64_support = true
+    entries = [::Zip::Entry.new("file.zip", "file1-little", "comment1", "", 200, 101, ::Zip::Entry::STORED, 200),
+               ::Zip::Entry.new("file.zip", "file2-big", "comment2", "", 18000000000, 102, ::Zip::Entry::DEFLATED, 20000000000),
+               ::Zip::Entry.new("file.zip", "file3-alsobig", "comment3", "", 15000000000, 103, ::Zip::Entry::DEFLATED, 21000000000),
+               ::Zip::Entry.new("file.zip", "file4-little", "comment4", "", 100, 104, ::Zip::Entry::DEFLATED, 121)]
+    [0, 250, 18000000300, 33000000350].each_with_index do |offset, index|
+      entries[index].local_header_offset = offset
+    end
+    cdir = ::Zip::CentralDirectory.new(entries, "zip comment")
+    File.open("test/data/generated/cdir64test.bin", "wb") { |f| cdir.write_to_stream(f) }
+    cdirReadback = ::Zip::CentralDirectory.new
+    File.open("test/data/generated/cdir64test.bin", "rb") { |f| cdirReadback.read_from_stream(f) }
+
+    assert_equal(cdir.entries.sort, cdirReadback.entries.sort)
+    assert_equal(::Zip::VERSION_NEEDED_TO_EXTRACT_ZIP64, cdirReadback.instance_variable_get(:@version_needed_for_extract))
+  end
+
+  def test_equality
+    cdir1 = ::Zip::CentralDirectory.new([::Zip::Entry.new("file.zip", "flimse", nil,
+                                                          "somethingExtra"),
+                                         ::Zip::Entry.new("file.zip", "secondEntryName"),
+                                         ::Zip::Entry.new("file.zip", "lastEntry.txt")],
+                                        "my zip comment")
+    cdir2 = ::Zip::CentralDirectory.new([::Zip::Entry.new("file.zip", "flimse", nil,
+                                                          "somethingExtra"),
+                                         ::Zip::Entry.new("file.zip", "secondEntryName"),
+                                         ::Zip::Entry.new("file.zip", "lastEntry.txt")],
+                                        "my zip comment")
+    cdir3 = ::Zip::CentralDirectory.new([::Zip::Entry.new("file.zip", "flimse", nil,
+                                                          "somethingExtra"),
+                                         ::Zip::Entry.new("file.zip", "secondEntryName"),
+                                         ::Zip::Entry.new("file.zip", "lastEntry.txt")],
+                                        "comment?")
+    cdir4 = ::Zip::CentralDirectory.new([::Zip::Entry.new("file.zip", "flimse", nil,
+                                                          "somethingExtra"),
+                                         ::Zip::Entry.new("file.zip", "lastEntry.txt")],
+                                        "comment?")
+    assert_equal(cdir1, cdir1)
+    assert_equal(cdir1, cdir2)
+
+    assert(cdir1 != cdir3)
+    assert(cdir2 != cdir3)
+    assert(cdir2 != cdir3)
+    assert(cdir3 != cdir4)
+
+    assert(cdir3 != "hello")
+  end
+end

data/test/data/file1.txt

@@ -0,0 +1,46 @@
+
+AUTOMAKE_OPTIONS = gnu
+
+EXTRA_DIST = test.zip
+
+CXXFLAGS= -g
+
+noinst_LIBRARIES = libzipios.a
+
+bin_PROGRAMS = test_zip test_izipfilt test_izipstream
+# test_flist 
+
+libzipios_a_SOURCES = backbuffer.h    fcol.cpp           fcol.h           \
+                      fcol_common.h   fcolexceptions.cpp fcolexceptions.h \
+                      fileentry.cpp   fileentry.h        flist.cpp        \
+                      flist.h         flistentry.cpp     flistentry.h     \
+                      flistscanner.h  ifiltstreambuf.cpp ifiltstreambuf.h \
+                      inflatefilt.cpp inflatefilt.h      izipfilt.cpp     \
+                      izipfilt.h      izipstream.cpp     izipstream.h     \
+                      zipfile.cpp     zipfile.h          ziphead.cpp      \
+                      ziphead.h       flistscanner.ll
+
+# test_flist_SOURCES = test_flist.cpp
+
+test_izipfilt_SOURCES = test_izipfilt.cpp
+
+test_izipstream_SOURCES = test_izipstream.cpp
+
+test_zip_SOURCES = test_zip.cpp
+
+# Notice that libzipios.a is not specified as -L. -lzipios
+# If it was, automake would not include it as a dependency.
+
+# test_flist_LDADD = libzipios.a
+
+test_izipfilt_LDADD = libzipios.a -lz
+
+test_zip_LDADD = libzipios.a -lz
+
+test_izipstream_LDADD = libzipios.a -lz
+
+
+
+flistscanner.cc : flistscanner.ll
+	$(LEX) -+ -PFListScanner -o$@ $^
+