zippo 0.2.0

data/spec/binary_structure_spec.rb

@@ -0,0 +1,132 @@
+require "spec_helper"
+
+# TODO - spec that unpackers can take strings
+
+require 'zippo/binary_structure'
+
+module Zippo
+  describe BinaryStructure do
+    let(:klass) { Class.new }
+    let(:obj) { klass.new }
+    let(:unpacker) { klass::Unpacker }
+    before(:each) do
+      klass.send :extend, BinaryStructure
+    end
+    context "when used to configure a class as a binary structure" do
+      before(:each) do
+        klass.class_eval do
+          binary_structure do
+            field :foo, 'L'
+            field :yay, 'a4', :signature => "baz"
+            field :bar, 'S'
+            field :quux, 'a*', :size => :foo
+          end
+        end
+      end
+      it "should store field information in the class" do
+        klass.structure.should have(4).fields
+        klass.structure.fields[0].name.should eq :foo
+        klass.structure.fields[3].options[:size].should eq :foo
+        klass.structure.fields[1].should be_signature
+      end
+      it "should have dependent fields" do
+        obj.quux = "foobar"
+        obj.foo.should eq 6
+        obj.quux.should eq "foobar"
+      end
+      it "should not allow mutation of dependent fields" do
+        -> { obj.foo = 5 }.should raise_error
+      end
+      it "should have regular fields" do
+        obj.bar = 10
+        obj.bar.should eq 10
+      end
+      it "should have an unpacker" do
+        array = [10,"baz", 42,"foobar baz"]
+        packed = array.pack 'La4Sa*'
+        io = StringIO.new packed
+        obj = klass::Unpacker.new(io).unpack
+        obj.foo.should eq 10
+        obj.bar.should eq 42
+        obj.quux.should eq "foobar baz"
+      end
+      it "should unpack oversized strings correctly" do
+        array = [3,"baz", 42,"foobar baz"]
+        packed = array.pack 'La4Sa*'
+        io = StringIO.new packed
+        obj = klass::Unpacker.new(io).unpack
+        obj.quux.should eq "foo"
+      end
+      it "should have a packer" do
+        array = [10,"baz", 42,"foobar baz"]
+        packed = array.pack 'La4Sa*'
+        io = StringIO.new
+        obj.bar = 42
+        obj.yay = "baz"
+        obj.quux = "foobar baz"
+        klass::Packer.new(io).pack obj
+        io.string.should eq packed
+      end
+      it "should have a .size method" do
+        obj.bar = 42
+        obj.quux = "foobar baz"
+        obj.size.should eq 20
+      end
+      context "when there is another class" do
+        let(:other_klass) { Class.new }
+        before(:each) do
+          other_klass.send :extend, BinaryStructure
+          other_klass.class_eval do
+            binary_structure do
+              field :bar, 'S'
+              field :yay, 'a4', :signature => "quux"
+            end
+          end
+        end
+        describe ".convert_to" do
+          it "should convert to the other class" do
+            obj.quux = "foobar"
+            obj.bar = 5
+            other_obj = obj.convert_to other_klass
+            other_obj.bar.should eq 5
+          end
+          it "should not convert a signature" do
+            obj.quux = "foobar"
+            obj.bar = 5
+            obj.yay = "baz"
+            other_obj = obj.convert_to other_klass
+            other_obj.bar.should eq 5
+            other_obj.yay.should eq "quux"
+          end
+        end
+      end
+    end
+    pending "should handle binary structures with multiple lots of fixed fields interspersed with variable length fields"
+    # none of the current binary structures use a
+    # feature like this, they're all a bunch of fixed
+    # fields followed by some variable length fields.
+    # need to test a few fixed fields, followed by a
+    # variable length field, then a few more fixed
+    # fields
+=begin
+    it "should complain if the order is bad" do
+      pending
+      klass = Class.new BinaryStructure
+      lambda { klass.class_eval do
+        field :foo, 'S'
+        field :bar, 'a*', :size => :baz
+        field :baz, 'S'
+      end }.should raise_error "size not found"
+    end
+    it "should remain silent if the order is ok" do
+      pending
+      klass = Class.new BinaryStructure
+      lambda { klass.class_eval do
+        field :foo, 'S'
+        field :baz, 'S'
+        field :bar, 'a*', :size => :baz
+      end }.should_not raise_error
+    end
+=end
+  end
+end

data/spec/central_directory_entries_unpacker_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+require "zippo/central_directory_entries_unpacker"
+
+module Zippo
+  describe CentralDirectoryEntriesUnpacker do
+    subject { CentralDirectoryEntriesUnpacker.new(io, size, offset).unpack }
+
+    context "when it's a simple file" do
+      let(:io) { File.open(test_file "test.zip") }
+      let(:offset) { 112 }
+      let(:size) { 79 }
+
+      specify { subject.should have(1).items }
+      specify { subject.first.name.should eq "test.file" }
+    end
+
+    context "when it's a complex file" do
+      let(:io) { File.open(test_file "multi.zip") }
+      let(:offset) { 242 }
+      let(:size) { 158 }
+
+      specify { subject.should have(2).items }
+      specify { subject[0].name.should eq "test.file" }
+      specify { subject[1].name.should eq "other.test" }
+    end
+
+  end
+end

data/spec/central_directory_parser_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+require "zippo/central_directory_reader"
+require "zippo/zip_file"
+
+module Zippo
+  describe CentralDirectoryReader do
+    let(:io) { File.open(file, "rb:ASCII-8BIT") }
+      let(:file) { test_file "test.zip" }
+    let(:parser) { CentralDirectoryReader.new(io) }
+    after(:each) { io.close }
+
+    context "when parsing a simple file" do
+      let(:file) { test_file "test.zip" }
+      it "should parse the End of Central Directory Record" do
+        parser.end_of_cd_record.total_records.should eq 1
+      end
+
+      specify { parser.end_of_cd_record_position.should eq 0xbf }
+      specify { parser.should have(1).cd_file_headers }
+    end
+
+    context "when parsing a file with a comment" do
+      let(:file) { test_file "comment.zip" }
+      specify { parser.end_of_cd_record_position.should eq 0xbf }
+      specify { parser.end_of_cd_record.comment.should eq "this is a comment to make things tricky" }
+    end
+
+    context "when parsing a multi-entry file" do
+      let(:file) { test_file "multi.zip" }
+      specify { parser.end_of_cd_record_position.should eq 0x191 }
+    end
+
+    context "when parsing a file that is not a zip" do
+      let(:file) { test_file "not_a.zip" }
+      specify { -> {parser.end_of_cd_record_position}.should raise_error(/not found/) }
+    end
+
+    context "when parsing a zip file larger than the maximum comment size" do
+      it "should not barf" do
+        in_working_directory do
+          Zippo::ZipFile.open("large.zip", "w") do |v|
+            v["test.file"] = "a" * 65535
+          end
+          Zippo::ZipFile.open("large.zip") {|v| v["test.file"].read }.should eq "a" * 65535
+        end
+      end
+    end
+  end
+end

data/spec/central_directory_unpacker_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+require "zippo/end_cd_record"
+
+module Zippo
+  describe "EndCdRecord::Unpacker" do
+    subject { EndCdRecord::Unpacker.new(str).unpack }
+
+    context "when it's a simple file" do
+      let(:str) { File.binread(test_file("test.zip"))[-22..-1] }
+
+      specify { subject.comment.should eq "" }
+      specify { subject.total_records.should eq 1 }
+      specify { subject.cd_offset.should eq 112 }
+    end
+
+    context "when it's a multi entry file" do
+      let(:str) { File.binread(test_file("multi.zip"))[-22..-1] }
+
+      specify { subject.total_records.should eq 2 }
+    end
+
+    context "when there is a comment" do
+      let(:str) { File.binread(test_file("comment.zip"))[-61..-1] }
+
+      specify { subject.total_records.should eq 1 }
+      specify { subject.comment.should eq "this is a comment to make things tricky" }
+    end
+
+  end
+end

data/spec/compressor_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+require "zippo/filter/compressor"
+require "zippo/filter/compressors"
+
+module Zippo::Filter
+  describe Compressor do
+    it "should be a factory for compressors" do
+      Compressor.for(StoreCompressor::METHOD).should eq StoreCompressor
+      Compressor.for(DeflateCompressor::METHOD).should eq DeflateCompressor
+      -> { Compressor.for(113) }.should raise_error(/unknown compression method/)
+    end
+  end
+end

data/spec/data/not_a.zip

@@ -0,0 +1 @@
+this is not a zip file

data/spec/deflate_compressor_spec.rb

@@ -0,0 +1,21 @@
+# Encoding: BINARY
+require "spec_helper"
+
+require "zippo/filter/compressor/deflate"
+
+module Zippo::Filter
+  describe DeflateCompressor do
+    let (:data) { "a" * 20 }
+    let (:zdata) { "KL\xC4\u0004\u0000" }
+    let (:io) { StringIO.new data }
+    let (:out) { StringIO.new "" }
+    it "should write the data" do
+      compressor = DeflateCompressor.new(io)
+      csize, size, crc32 = compressor.compress_to out
+      size.should eq 20
+      csize.should eq zdata.size
+      crc32.should eq Zlib.crc32(data)
+      out.string.should eq zdata
+    end
+  end
+end

data/spec/deflate_uncompressor_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+require "zippo/filter/uncompressor/deflate"
+
+module Zippo::Filter
+  describe DeflateUncompressor do
+
+    let (:zstring) { Zlib::Deflate.new(Zlib::BEST_COMPRESSION, -Zlib::MAX_WBITS).deflate("a" * 20, Zlib::FINISH) }
+    let (:size) { zstring.size }
+    let (:string) { "aaa" + zstring + "bbb" }
+    let (:out) { StringIO.new }
+    let (:io) { StringIO.new string }
+    it "should deflate only the compressed string" do
+      io.seek 3
+      DeflateUncompressor.new(io, size).uncompress.should eq "a" * 20
+    end
+    it "should deflate to an IO" do
+      io.seek 3
+      DeflateUncompressor.new(io, size).uncompress_to(out)
+      out.string.should eq "a" * 20
+    end
+  end
+end

data/spec/integration/compressors_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+require "zippo/filter/uncompressor"
+require "zippo/filter/uncompressors"
+require "zippo/filter/compressor"
+require 'zippo/filter/compressors'
+
+module Zippo::Filter
+  describe Uncompressor do
+    let (:zstring) { Zlib::Deflate.new(Zlib::BEST_COMPRESSION, -Zlib::MAX_WBITS).deflate("a" * 20, Zlib::FINISH) }
+    it "should allow uncompressors to work with compressors" do
+      stream = StringIO.new zstring
+      deflater = DeflateUncompressor.new(stream, zstring.size)
+      storer = StoreCompressor.new(deflater)
+      out = StringIO.new
+      out.set_encoding "BINARY"
+      storer.compress_to(out)
+      out.string.should eq "a" * 20
+    end
+  end
+end

data/spec/integration/zippo_spec.rb

@@ -0,0 +1,55 @@
+# Encoding: BINARY
+require 'spec_helper'
+
+require 'zippo'
+
+module Zippo
+  describe ZipFile do
+    let(:file) { test_file "test.zip" }
+    let(:member_data) { "The quick brown fox jumps over the lazy dog.\n" }
+    let(:zip) { Zippo::ZipFile.open(file) }
+    describe "when reading a zip file" do
+      after(:each) do
+        zip.close
+      end
+      it "should be able to read a member of the file" do
+        data = zip["test.file"].read
+        data.should eq member_data
+      end
+
+      it "should read a compressed file" do
+        zip = Zippo::ZipFile.open(test_file("deflate.zip"))
+        zip["weasels.txt"].read.should eq "Methinks it is like a weasel.\n" * 10
+      end
+
+      it "should work like File.open" do
+        io = File.open(file)
+        File.should_receive(:open).with(file, 'r:ASCII-8BIT').and_return(io)
+        s = Zippo.open(file) { |v| v['test.file'].read }
+        s.should eq member_data
+        io.should be_closed
+      end
+
+      it "should create zip files" do
+        in_working_directory do
+          File.write "xyzzy.txt", "plugh"
+          Zippo.open("new.zip", "w") {|v| v['xyzzy.txt'] = "plugh" }
+          Pathname.new("new.zip").should exist
+          Zippo.open("new.zip") {|v| v['xyzzy.txt'].read }.should eq "plugh"
+        end
+      end
+
+      it "should update in place with mode rw" do
+        in_working_directory do
+          Zippo.open("out.zip", "w")  { |v| v['foo1'] = "data1" }
+          Zippo.open("out.zip", "rw") { |v| v['foo2'] = "data2" }
+          IO.write "/tmp/bar.zip", IO.read("out.zip")
+          Zippo.open("out.zip") do |v|
+            v['foo1'].read.should eq "data1"
+            v['foo2'].read.should eq "data2"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/io_zip_member_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+require "zippo/io_zip_member"
+require "zippo/filter/compressor/store"
+
+module Zippo
+  describe IOZipMember do
+    let(:io) { StringIO.new "foobar" }
+    let(:out) { StringIO.new "" }
+    let(:name) { "name" }
+    subject { IOZipMember.new name, io }
+    specify { subject.name.should eq "name" }
+    specify { subject.read.should eq "foobar" }
+    context "when writing" do
+      before(:each) do
+        @size, @csize, @crc32 = subject.write_to out, 0
+      end
+      it "should write to the io" do
+        out.string.should eq "foobar"
+      end
+      it "should have returned the original size" do
+        @size.should eq 6
+      end
+      it "should return the compressed size" do
+        @csize.should eq 6
+      end
+      it "should return the CRC32" do
+        @crc32.should eq Zlib.crc32("foobar")
+      end
+    end
+  end
+end

data/spec/local_file_header_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+require "zippo/local_file_header"
+
+module Zippo
+  describe "LocalFileHeader::Unpacker" do
+    before(:each) do
+      @io = File.open test_file("test.zip"), "rb:ASCII-8BIT"
+      @io.seek 0
+    end
+    after(:each) do
+      @io.close
+    end
+    it "should unpack from an io" do
+      LocalFileHeader::Unpacker.new(@io.read).unpack.name.should eq "test.file"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+def io_for(filename)
+  File.open test_file(filename), "rb:ASCII-8BIT"
+end
+def test_file(filename)
+  File.join(File.join(File.dirname(__FILE__), 'data'), filename)
+end
+require 'tmpdir'
+def in_working_directory
+  Dir.mktmpdir do |dir|
+    Dir.chdir(dir) { yield }
+  end
+end

data/spec/store_compressor_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+require "zippo/filter/compressor/store"
+
+module Zippo::Filter
+  describe StoreCompressor do
+    let (:data) { "a" * 20 }
+    let (:io) { StringIO.new data }
+    let (:out) { StringIO.new }
+    it "should write the data" do
+      compressor = StoreCompressor.new(io)
+      size, csize, crc32 = compressor.compress_to out
+      size.should eq 20
+      csize.should eq 20
+      crc32.should eq Zlib.crc32(data)
+      out.string.should eq data
+    end
+  end
+end

data/spec/store_uncompressor_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+require "zippo/filter/uncompressor/store"
+
+module Zippo::Filter
+  describe StoreUncompressor do
+    let(:io) { StringIO.new "foobarbazquux" }
+    let (:out) { StringIO.new }
+    it "should read only the specified amount" do
+      io.seek 3
+      StoreUncompressor.new(io, 3).uncompress.should eq "bar"
+    end
+    it "should deflate to an IO" do
+      io.seek 3
+      StoreUncompressor.new(io, 3).uncompress_to(out)
+      out.string.should eq "bar"
+    end
+  end
+end

data/spec/uncompressor_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+require "zippo/filter/uncompressor"
+require "zippo/filter/uncompressors"
+
+module Zippo::Filter
+  describe Uncompressor do
+    it "should be a factory for uncompressors" do
+      Uncompressor.for(0).should eq StoreUncompressor
+      Uncompressor.for(8).should eq DeflateUncompressor
+      -> { Uncompressor.for(113) }.should raise_error(/unknown compression method/)
+    end
+  end
+end

data/spec/zip_directory_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+require 'zippo/zip_file'
+
+module Zippo
+  describe ZipDirectory do
+    context "when opening a file" do
+    let(:io) { File.open(file, "rb:ASCII-8BIT") }
+    after(:each) { io.close }
+    subject { ZipDirectory.new io }
+    context "when reading a simple file" do
+      let(:file) { test_file "test.zip" }
+      it { should have(1).entries }
+      specify { subject["test.file"].should_not be_nil }
+      it { should_not be_empty }
+    end
+    context "when reading a larger zip" do
+      let(:file) { test_file "multi.zip" }
+      it { should have(2).entries }
+      specify { subject["test.file"].should_not be_nil }
+      specify { subject["other.test"].should_not be_nil }
+    end
+    end
+    context "when inserting" do
+      let(:io) { StringIO.new "" }
+      it "should allow the insertion of new members" do
+        subject["new.file"] = "file data"
+        subject["new.file"].read.should eq "file data"
+        subject["new.file"].write_to io, 0
+        io.string.should eq "file data"
+      end
+      it "should allow the insertion of IO objects" do
+        in_working_directory do
+          File.write "xyzzy.txt", "plugh"
+          file = File.open "xyzzy.txt"
+          subject.insert "woo.txt", file
+          subject["woo.txt"].read.should eq "plugh"
+          subject["woo.txt"].write_to io, 0
+          file.close
+          io.string.should eq "plugh"
+        end
+      end
+      it "should allow insertion of file contents" do
+        in_working_directory do
+          File.write "xyzzy.txt", "plugh"
+          subject.insert "woo.txt", "xyzzy.txt"
+          subject["woo.txt"].read.should eq "plugh"
+          subject["woo.txt"].write_to io, 0
+          io.string.should eq "plugh"
+        end
+      end
+      it "should allow the insertion of ZipMember contents" do
+        zip = Zippo::ZipFile.open test_file "test.zip"
+        subject.insert "hmm.txt", zip['test.file']
+        subject["hmm.txt"].read.should eq "The quick brown fox jumps over the lazy dog.\n"
+        subject["hmm.txt"].write_to io, 0
+        zip.close
+        io.string.should eq "The quick brown fox jumps over the lazy dog.\n"
+        -> { subject["hmm.txt"].read }.should raise_error # after closing original zip
+      end
+    end
+  end
+end

data/spec/zip_file_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+require "zippo/zip_file"
+require "zippo/filter/uncompressors"
+require "zippo/filter/compressors"
+
+module Zippo
+  describe ZipFile do
+    # XXX unit test for open
+    describe ".open" do
+      let(:zip) { ZipFile.open(file, mode) }
+      let(:file) { test_file "test.zip" }
+      context "when in read mode" do
+        let(:mode) { "r" }
+        it "should allow reading of zip members" do
+          zip['test.file'].should be_a ZipMember
+          zip['test.file'].read.should eq "The quick brown fox jumps over the lazy dog.\n"
+        end
+        it "should allow iterating over the directory" do
+          files = []
+          zip.each { |m| files << m.name }
+          files.should include("test.file")
+        end
+      end
+      context "when in write mode" do
+        let(:mode) { "w" }
+        let(:file) { "/tmp/foo.zip" }
+        it "should not allow reading of zip members that haven't been written" do
+          zip['test.file'].should be_nil
+        end
+        context "when a member is inserted" do
+          before(:each) do
+            zip['new.file'] = "foo"
+          end
+          it "should write the file when closed" do
+            zip.close
+            Pathname.new(file).should exist
+            Zippo::ZipFile.open(file) {|f| f["new.file"].read }.should eq "foo"
+          end
+        end
+      end
+      context "when in update mode" do
+        let(:mode) { "rw" }
+        it "should read the zip file" do
+          zip.directory.should_not be_empty
+        end
+      end
+    end
+  end
+end

data/spec/zip_file_writer_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+require "zippo" #
+require "zippo/zip_file_writer"
+require "zippo/zip_directory"
+
+module Zippo
+  describe ZipFileWriter do
+    describe ".write" do
+      it "should write the zip file" do
+        in_working_directory do
+          directory = ZipDirectory.new
+          directory["file.ext"] = "foo"
+          writer = ZipFileWriter.new directory, "out.zip"
+          writer.write
+          File.open("/home/jma/yay.zip","w") {|f| f.write File.read("out.zip") }
+          Zippo.open("out.zip") do |f|
+            f['file.ext'].crc32.should eq 0x8c736521
+            f['file.ext'].compressed_size.should eq 5
+            f['file.ext'].uncompressed_size.should eq 3
+            f['file.ext'].read.should eq "foo"
+          end
+        end
+      end
+      it "should perform direct zip copying" do
+        in_working_directory do
+          zip = Zippo.open(test_file "test.zip")
+          Zippo.open("out.zip", "w") do |out|
+            out.directory.insert 'out.file', zip['test.file']
+          end
+          zip.close
+
+          IO.write "/tmp/out.zip", IO.read("out.zip")
+
+          Zippo.open("out.zip") { |v| v['out.file'].read }.should eq "The quick brown fox jumps over the lazy dog.\n"
+        end
+      end
+      pending "should be able to peform direct zip copying after the source zip is closed"
+      pending "should be configurable in terms of compression method and effort"
+    end
+  end
+end