doo_dah 0.1.0

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/README

@@ -0,0 +1,3 @@
+DooDah is a simple Ruby gem for creating zip files that are well suited to streaming. This is achieved by only supporting the zip STORE method (for predictable size), and by use of the optional data descriptor after each file so that output of file data can start before a whole file has been processed. 
+
+

data/Rakefile

@@ -0,0 +1,66 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "doo_dah"
+    gem.summary = 'Creates zip files suitable for streaming.'
+    gem.description = <<-END_DESCRIPTION
+      This gem creates zip files using the STORE method - i.e. with no compression. This enables the generation of
+      zip files with a known size from streamed data, providing the size of the input files is known. 
+    END_DESCRIPTION
+    gem.email = "mcollas@yahoo.com"
+    gem.homepage = "http://github.com/michaelcollas/doo_dah"
+    gem.authors = ["Michael Collas"]
+    gem.add_development_dependency "rspec", ">= 2.8.0"
+    gem.add_development_dependency "reek", ">= 1.2.8"
+    gem.add_development_dependency "sexp_processor", ">= 3.0.4"
+    gem.files.exclude('.gitignore')
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+  #spec.rcov_opts = ['-T', '--include-file', 'lib\/doo_dah', '--exclude', 'spec\/']
+  spec.rcov_opts = ['-T', '--spec-only', '--include-file', 'lib\/doo_dah', '--exclude', 'spec\/,gems\/']
+end
+
+task :spec => :check_dependencies
+
+begin
+  require 'reek/rake/task'
+  Reek::Rake::Task.new do |t|
+    t.fail_on_error = true
+    t.verbose = false
+    t.source_files = 'lib/**/*.rb'
+    t.reek_opts << ' --quiet'
+    t.ruby_opts << '-r' << 'rubygems' 
+  end
+rescue LoadError
+  task :reek do
+    abort "Reek is not available. In order to run reek, you must: sudo gem install reek"
+  end
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "doo_dah #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/config/defaults.reek

@@ -0,0 +1,3 @@
+---
+Duplication:
+  max_calls: 2

data/example/multi-language.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'doo_dah'
+
+z = DooDah::ZipOutputStream.new(STDOUT)
+
+content = "the name of this file is written in simplified Chinese\n"
+z.create_entry('这里插入一个聪明的说', content.size) do |e|
+  e.write_file_data(content)
+end
+
+content = "the name of this file is written in Japanese\n"
+z.create_entry('ここに巧妙なことわざを挿入', content.size) do |e|
+  e.write_file_data(content)
+end
+
+content = "the name of this file is written in Hebrew\n"
+z.create_entry('הכנס אומרים חכם פה', content.size) do |e|
+  e.write_file_data(content)
+end
+
+content = "the name of this file is written in Arabic\n"
+z.create_entry('إدراج قائلا ذكي هنا', content.size) do |e|
+  e.write_file_data(content)
+end
+
+content = "This zip file contains five files (including this one). If the text \n"+
+        "encoding has worked correctly, the first file name should be in \n" + 
+        "Chinese, the second in Japanese, the third in Hebrew, and the fourth \n" + 
+        "in Arabic. Hebrew and Arabic are both right-to-left reading languages, \n" +
+        "so some zip programs may present a listing that has the whole row \n" +
+        "reversed.\n"
+z.create_entry('readme.txt', content.size) do |e|
+  e.write_file_data(content)
+end
+
+z.close

data/lib/doo_dah/dos_time.rb

@@ -0,0 +1,13 @@
+module DosTime
+  module Formatter
+
+    def to_dos_time
+      (sec >> 1) + (min << 5) + (hour << 11)
+    end
+  
+    def to_dos_date
+      day + (month << 5) + ((year - 1980) << 9)
+    end
+
+  end
+end

data/lib/doo_dah/zip_entry.rb

@@ -0,0 +1,50 @@
+require 'forwardable'
+
+module DooDah
+
+  class ZipEntry
+    include LocalDirectoryHeader
+    include CentralDirectoryHeader
+
+    attr_reader :size, :crc, :name, :closed
+    alias_method :closed?, :closed
+
+    extend ::Forwardable
+    def_delegators :@zip_stream, :write, :current_offset
+
+    def initialize(zip_stream, name, size = 0)
+      @zip_stream = zip_stream
+      @name = name
+      @crc = 0
+      @size = size
+      @closed = false
+      write_local_header
+    end
+
+    def close
+      return if closed
+      write_local_footer
+      @closed = true
+    end
+
+    def write_file_data(data)
+      raise 'Zip entry already closed' if closed
+      @size += write(data)
+      @crc = Zlib::crc32(data, @crc)
+    end
+
+    def last_modified_time
+      @last_modified_time ||= Time.now.extend(DosTime::Formatter).to_dos_time
+    end
+
+    def last_modified_date
+      @last_modified_date ||= Time.now.extend(DosTime::Formatter).to_dos_date
+    end
+
+    private
+    
+    attr_accessor :local_header_offset
+
+  end
+
+end

data/lib/doo_dah/zip_header.rb

@@ -0,0 +1,128 @@
+module DooDah
+
+  module LittleEndianByteWriter
+
+    def write_byte(value)
+      write([value].pack('C'))
+    end
+
+    alias_method :write_u8, :write_byte
+   
+    def write_word(value)
+      write([value].pack('v'))
+    end
+
+    alias_method :write_u16, :write_word
+   
+    def write_dword(value)
+      write([value].pack('V'))
+    end
+
+    alias_method :write_u32, :write_dword
+
+  end
+
+  module ZipHeader
+    def write_signature(signature)
+      write([signature].pack('V'))
+    end
+  end
+
+  module ZipEntryHeader
+    include ZipHeader
+
+    STORED = 0
+    DEFLATED = 8
+    LOCAL_ENTRY_HEADER_SIGNATURE = 0x04034b50
+    CENTRAL_ENTRY_HEADER_SIGNATURE = 0x02014b50
+    END_CENTRAL_DIRECTORY_SIGNATURE = 0x06054b50
+    LOCAL_ENTRY_FOOTER_SIGNATURE = 0x08074b50
+    LOCAL_ENTRY_STATIC_HEADER_LENGTH = 30
+    LOCAL_ENTRY_TRAILING_DESCRIPTOR_LENGTH = 4+4+4
+    VERSION_NEEDED_TO_EXTRACT = 10
+    GP_FLAGS_CRC_UNKNOWN = 0x0008
+    GP_FLAGS_UTF8 = 0x0800
+
+    def write_common_header()
+      flags = GP_FLAGS_UTF8
+      flags |= GP_FLAGS_CRC_UNKNOWN if crc.zero?
+      write([
+        VERSION_NEEDED_TO_EXTRACT, # version needed to extract
+        flags,
+        STORED,
+        last_modified_time,
+        last_modified_date,
+        crc,
+        size,                      # compressed_size = size (stored)
+        size,
+        name ? name.length : 0,
+        0                          # extra length
+      ].pack('vvvvvVVVvv'))
+    end
+
+    def write_name
+      write name
+    end
+
+    def write_infozip_utf8_name
+      [0x7075, name.size + 5, 1, file-name-crc].pack('vvCV')
+    end
+
+  end
+
+  module LocalDirectoryHeader
+    include ZipEntryHeader
+
+    def write_local_header
+      self.local_header_offset = current_offset
+      write_signature(LOCAL_ENTRY_HEADER_SIGNATURE)
+      write_common_header
+      write_name
+    end
+
+    def write_local_footer
+      write_signature(LOCAL_ENTRY_FOOTER_SIGNATURE)
+      write([crc, size, size].pack('VVV'))
+    end
+
+  end
+
+  module CentralDirectoryHeader
+    include ZipEntryHeader
+
+    def write_central_header
+      write_signature(CENTRAL_ENTRY_HEADER_SIGNATURE)
+      write_version_made_by
+      write_common_header
+      write([
+        0,                         # file comment length
+        0,                         # start of file disk number
+        0,                         # internal attributes = binary
+        (010 << 12 | 0644) << 16,  # external attributes = file, rw-r--r--
+        local_header_offset
+      ].pack('vvvVV'))
+      write_name
+    end
+
+    def write_end_of_central_directory
+      central_directory_size = current_offset - central_directory_offset
+      write_signature(END_CENTRAL_DIRECTORY_SIGNATURE)
+      end_of_central_directory = [ 
+        0,                               # disk number
+        0,                               # disk with directory
+        entry_count,                   # entries on this disk
+        entry_count,                   # total entries
+        central_directory_size,
+        central_directory_offset,
+        0                                # zip file comment length
+      ].pack('vvvvVVv')
+      write(end_of_central_directory)
+    end
+
+    def write_version_made_by
+      write([10, 3].pack('CC'))         # version, file system type
+    end
+
+  end
+
+end

data/lib/doo_dah/zip_output_stream.rb

@@ -0,0 +1,76 @@
+$KCODE = 'U'
+require 'zlib'
+
+module DooDah
+
+  class ZipOutputStream
+
+    class EntryOpen < Exception
+    end
+
+    def initialize(output_stream)
+      @output_stream = output_stream
+      @total_bytes_written = 0
+      @entries = []
+    end
+
+    def create_entry(name, size=0)
+      raise EntryOpen if entry_open?
+      begin
+        yield start_entry(name, size)
+      ensure
+        end_current_entry
+      end
+    end
+
+    # TODO: take block instead of using a start/end method pair?
+    def start_entry(name, size=0)
+      end_current_entry
+      new_entry = ZipEntry.new(self, name, size)
+      @entries << new_entry
+      new_entry
+    end
+
+    def end_current_entry
+      return unless current_entry
+      current_entry.close
+    end
+
+    def entry_count
+      @entries.size
+    end
+
+    def close
+      end_current_entry
+      @central_directory_offset = current_offset
+      @entries.each { |entry| entry.write_central_header }
+      write_end_of_central_directory
+    end
+
+    def current_offset
+      @total_bytes_written
+    end
+
+    def write(data)
+      bytes_written = @output_stream.write(data)
+      @total_bytes_written += bytes_written
+      bytes_written
+    end
+
+    private
+    
+    attr_reader :central_directory_offset
+    include CentralDirectoryHeader
+    
+    def current_entry
+      @entries.last
+    end
+
+    def entry_open?
+      current_entry && !current_entry.closed?
+    end
+
+  end
+
+end
+

data/lib/doo_dah.rb

@@ -0,0 +1,4 @@
+require 'doo_dah/dos_time'
+require 'doo_dah/zip_header'
+require 'doo_dah/zip_entry'
+require 'doo_dah/zip_output_stream'

data/spec/central_directory_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+module DooDah
+
+  describe CentralDirectoryHeader, :type => :write_capturing do
+
+    before do
+      @entry = stub().extend(CentralDirectoryHeader)
+      record_writes @entry
+    end
+
+    describe '#write_central_header' do
+
+      before do
+        @entry.stub(:local_header_offset => 0, :write_signature => nil, :write_common_header => nil, :write_name => nil)
+      end
+
+      it 'should write the central directory signature bytes' do
+        @entry.should_receive(:write_signature).with(0x02014b50)
+        @entry.write_central_header
+      end
+
+      it 'should write the zip specification version in version made by as 1.0 at first byte after signature' do
+        @entry.write_central_header
+        written[0,1].should have_bytes(10)
+      end
+
+      it 'should write the attribute compatability as type 3 (unix) in version made by at the second byte after the signature' do
+        @entry.write_central_header
+        written[1,1].should have_bytes(3)
+      end
+
+      it 'should write the common header' do
+        @entry.should_receive(:write_common_header)
+        @entry.write_central_header
+      end
+
+      it 'should write 2 bytes of 0 as file comment length in first  bytes after common header' do
+        @entry.write_central_header
+        written[2,2].should have_bytes(0, 0)
+      end
+
+      it 'should write 2 bytes of 0 as disk number for start of file 2 bytes after common header' do
+        @entry.write_central_header
+        written[4,2].should have_bytes(0, 0)
+      end
+
+      it 'should write 2 bytes of 0 as internal attributes 4 bytes after common header' do
+        @entry.write_central_header
+        written[6,2].should have_bytes(0, 0)
+      end
+
+      it 'should write 4 bytes of attributes for unix file rw-r--r-- 6 bytes after common header' do
+        @entry.write_central_header
+        written[8, 4].should have_bytes(0x00, 0x00, 0xa4, 0x81)
+      end
+
+      it 'should write 4 bytes of offset to the local header record 10 bytes after the common header' do
+        @entry.stub(:local_header_offset => 0x98765432)
+        @entry.write_central_header
+        written[12, 4].should have_bytes(0x32, 0x54, 0x76, 0x98)
+      end
+
+      it 'should write the file name' do
+        @entry.should_receive(:write_name)
+        @entry.write_central_header
+      end
+
+    end
+
+    describe '#write_end_of_central_directory' do
+
+      before do
+        @entry.stub(:central_directory_offset => 0, :current_offset => 0, :write_signature => nil, :entry_count => 0)
+      end
+
+      it 'should write the end of central directory signature' do
+        @entry.should_receive(:write_signature).with(0x06054b50)
+        @entry.write_end_of_central_directory
+      end
+
+      it 'should write the disk number as 0 in the 2 bytes following the signature' do
+        @entry.write_end_of_central_directory
+        written[0, 2].should have_bytes(0, 0)
+      end
+
+      it 'should write 2 bytes of zero as the directory disk number  2 bytes after the signature' do
+        @entry.write_end_of_central_directory
+        written[2, 2].should have_bytes(0, 0)
+      end
+
+      it 'should write 2 bytes of entry count on this disk 4 bytes after the signature' do
+        @entry.stub(:entry_count => 0x0123)
+        @entry.write_end_of_central_directory
+        written[4, 2].should have_bytes(0x23, 0x01)
+      end
+
+      it 'should write 2 bytes of entry count on this disk 6 bytes after the signature' do
+        @entry.stub(:entry_count => 0x0234)
+        @entry.write_end_of_central_directory
+        written[6, 2].should have_bytes(0x34, 0x02)
+      end
+
+      it 'should write 4 bytes of central directory size 8 bytes after the signature' do
+        @entry.stub(:current_offset => 0x98765432, :central_directory_offset => 0x90000000)
+        @entry.write_end_of_central_directory
+        written[8, 4].should have_bytes(0x32, 0x54, 0x76, 0x08)
+      end
+
+      it 'should write 4 bytes of central directory offset 12 bytes after the signature' do
+        @entry.stub(:central_directory_offset => 0x13243546)
+        @entry.write_end_of_central_directory
+        written[12, 4].should have_bytes(0x46, 0x35, 0x24, 0x13)
+      end
+
+      it 'should write 2 bytes of zero as the zip file comment length 16 bytes after the signature' do
+        @entry.write_end_of_central_directory
+        written[16, 2].should have_bytes(0, 0)
+      end
+
+    end
+
+  end
+
+end

data/spec/dos_time_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe DosTime::Formatter do
+
+  def dos_time(time)
+    time.extend(DosTime::Formatter)
+  end
+
+  describe '#to_dos_date' do
+
+    before do
+      @sample_dos_date = dos_time(Time.local(2011, 11, 14)).to_dos_date
+    end
+
+    it 'should have the day number in the lowest 5 bits' do
+      (@sample_dos_date & 0x1f).should == 14
+    end
+
+    it 'should have the month number in the four bits starting at bit 5' do
+      (@sample_dos_date >> 5 & 0x0f).should == 11
+    end
+
+    it 'should the have the year as an offset from 1980 in the 7 bits starting at bit 9' do
+      (@sample_dos_date >> 9 & 0x7f).should == 2011 - 1980
+    end
+
+  end
+
+  describe '#to_dos_time' do
+
+    before do
+      @sample_dos_time = dos_time(Time.local(2011, 11, 14, 18, 58, 37)).to_dos_time
+    end
+
+    it 'should have half the second number in the lowest 5 bits' do
+      (@sample_dos_time & 0x1f).should == 37.div(2)
+    end
+
+    it 'should have the minute number in the six bits starting at bit 5' do
+      (@sample_dos_time >> 5 & 0x3f).should == 58
+    end
+
+    it 'should the have the hour number in the 5 bits starting at bit 11' do
+      (@sample_dos_time >> 11 & 0x1f).should == 18
+    end
+
+  end
+
+end
+

data/spec/local_directory_header_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+module DooDah
+  
+  describe LocalDirectoryHeader, :type => :write_capturing do
+  
+    before do
+      @entry = Object.new.extend(LocalDirectoryHeader)
+    end
+  
+    describe '#write_local_header' do
+
+      before do
+        @entry.stub(:current_offset => 0, :local_header_offset= => nil, :write_signature => nil, :write_common_header => nil, :write_name => nil)
+      end
+  
+      it 'should write a local directory entry signature' do
+        @entry.should_receive(:write_signature).with(0x04034b50)
+        @entry.write_local_header
+      end
+  
+      it 'should write a common header' do
+        @entry.should_receive(:write_common_header)
+        @entry.write_local_header
+      end
+  
+      it 'should write the file name' do
+        @entry.should_receive(:write_name)
+        @entry.write_local_header
+      end
+  
+      it 'should capture the current output stream position' do
+        @entry.stub(:current_offset => 1234)
+        @entry.should_receive(:local_header_offset=).with(1234)
+        @entry.write_local_header
+      end
+ 
+    end
+  
+    describe '#write_local_footer' do
+
+      before do
+        @entry.stub(:write_signature => nil, :crc => 0, :size => 0)
+        record_writes(@entry)
+      end
+    
+      it 'should write a local directory entry footer' do
+        @entry.should_receive(:write_signature).with(0x08074b50)
+        @entry.write_local_footer
+      end
+
+      it 'should write the crc value in the four bytes after the signature' do
+        @entry.stub(:crc => 0x1234)
+        @entry.write_local_footer
+        written[0, 4].should have_bytes(0x34, 0x12)
+      end
+
+      it 'should write the uncompressed file size in the four bytes starting at byte 4 after the signature' do
+        @entry.stub(:size => 0x5678)
+        @entry.write_local_footer
+        written[4, 4].should have_bytes(0x78, 0x56)
+      end
+
+      it 'should write the compressed file size in the four bytes starting at byte 8 after the signature' do
+        @entry.stub(:size => 0x1324)
+        @entry.write_local_footer
+        written[8, 4].should have_bytes(0x24, 0x13)
+      end
+
+    end
+  
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'doo_dah'
+require 'rspec'
+require 'rspec/autorun'
+require 'spec/support/byte_matcher'
+require 'spec/support/write_capturing_example_group'
+
+RSpec.configure do |config|
+  
+end

data/spec/support/byte_matcher.rb

@@ -0,0 +1,29 @@
+RSpec::Matchers.define :bytes do |*expected|
+
+  match do |actual|
+    @start_byte ||= 0
+    actual.bytes.to_a[@start_byte, expected.length] == expected
+  end
+
+  chain :at do |start_byte|
+    @start_byte = start_byte
+  end
+
+  failure_message_for_should do |actual|
+    actual_bytes = actual.bytes.to_a.collect {|b| "0x%02x" % b }.join(',')
+    "expected #{expected_bytes_description} to be #{actual_bytes}"
+  end
+
+  description do
+    "#{expected_bytes_description} starting at byte #{@start_byte}"
+  end
+
+  def expected_bytes_description
+    expected.collect {|b| "0x%02x" % b }.join(',')
+  end
+
+end
+
+module RSpec::Matchers
+  alias_method(:have_bytes, :bytes)
+end

data/spec/support/write_capturing_example_group.rb

@@ -0,0 +1,22 @@
+module WriteCapturing
+
+  attr_reader :writer
+  attr_reader :written
+
+  def self.included(target)
+    target.before do
+      @written = ''
+    end
+  end
+
+  def record_writes(new_writer)
+    @writer = new_writer
+    writer.stub(:write) { |new_value| @written << new_value; new_value.size }
+  end
+
+end
+
+RSpec.configure do |configuration|
+  configuration.include(WriteCapturing, :type => :write_capturing)
+end
+

data/spec/zip_entry_header_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+module DooDah
+
+  describe ZipEntryHeader, :type => :write_capturing do
+
+    before do
+      @header = stub(:crc => 0, :last_modified_time => 0, :last_modified_date => 0, :size => 0, :name => '')
+      @header.extend(ZipEntryHeader)
+      record_writes @header
+    end
+
+    describe '#write_common_header' do
+
+      it 'should write the version needed to extract in the first 2 bytes' do
+        @header.write_common_header
+        written[0, 2].should have_bytes(10, 0)
+      end
+
+      it 'should write the flag bytes with the UTF8 bit set' do
+        @header.write_common_header
+        written[3, 1].should have_bytes(0x08)
+      end
+
+      it 'should write the flag bytes with the CRC_UNKNOWN bit set if the crc is zero' do
+        @header.write_common_header
+        written[2, 1].should have_bytes(0x08)
+      end
+
+      it 'should write the flag bytes with the CRC_UNKNOWN bit unset if the crc is non-zero' do
+        @header.stub(:crc => 1234)
+        @header.write_common_header
+        written[2, 1].should have_bytes(0x00)
+      end
+
+      it 'should write the compression method as STORED' do
+        @header.write_common_header
+        written[4, 2].should have_bytes(0,0)
+      end
+
+      it 'should write the last modified time as a 2 byte long starting at byte 6' do
+        @header.stub(:last_modified_time => 0x1234)
+        @header.write_common_header
+        written[6, 2].should have_bytes(0x34, 0x12)
+      end
+
+      it 'should write the last modified date as a 2 byte long starting at byte 8' do
+        @header.stub(:last_modified_date => 0x5678)
+        @header.write_common_header
+        written[8, 2].should have_bytes(0x78, 0x56)
+      end
+
+      it 'should write the crc in the four bytes starting at byte 10' do
+        @header.stub(:crc => 0x13243546)
+        @header.write_common_header
+        written[10, 4].should have_bytes(0x46, 0x35, 0x24, 0x13)
+      end
+
+      it 'should write the file size in the four bytes starting at byte 14' do
+        @header.stub(:size => 0x24354657)
+        @header.write_common_header
+        written[14, 4].should have_bytes(0x57, 0x46, 0x35, 0x24)
+      end
+
+      it 'should write the file size in the four bytes starting at byte 18' do
+        @header.stub(:size => 0x31425364)
+        @header.write_common_header
+        written[18, 4].should have_bytes(0x64, 0x53, 0x42, 0x31)
+      end
+
+      it 'should write the length of the file name in the two bytes starting at byte 22' do
+        @header.stub(:name => 'x' * 258)
+        @header.write_common_header
+        written[22, 2].should have_bytes(0x02, 0x01)
+      end
+
+      it 'should write 0 as the length of the extra fields in the two bytes starting at byte 24' do
+        @header.write_common_header
+        written[24, 2].should have_bytes(0, 0)
+      end
+
+    end
+
+    describe '#write_name' do
+
+      it 'should write the file name to the output' do
+        @header.stub(:name => 'foo')
+        @header.write_name
+        written.should == 'foo'
+      end  
+
+    end
+
+  end
+
+end

data/spec/zip_entry_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module DooDah
+
+  describe ZipEntry do
+  
+    before do
+      @bytes_per_write = 123
+      @zip_stream = stub(:write => @bytes_per_write, :current_offset => 0)
+      @zip_entry = ZipEntry.new(@zip_stream, 'file name')
+    end
+  
+    it 'should retain its name' do
+      @zip_entry.name.should == 'file name'
+    end
+  
+    it 'should write a local entry header when created' do
+      zip_entry = ZipEntry.allocate
+      zip_entry.should_receive(:write_local_header)
+      zip_entry.send(:initialize, @zip_stream, 'file name')
+    end
+  
+    it 'should write file data through to the zip stream when file data is written' do
+      file_contents = 'this is the content of a file added to the zip file'
+      @zip_stream.should_receive(:write).with(file_contents)
+      @zip_entry.write_file_data(file_contents)
+    end
+  
+    it 'should keep a count of total file data written for the entry' do
+      @zip_entry.write_file_data('')
+      @zip_entry.write_file_data('')
+      @zip_entry.size.should == 2 * @bytes_per_write
+    end
+  
+    it 'should maintain a crc32 for all of the file data written for the entry' do
+      @zip_entry.write_file_data "this is part 1 of the file content\n"
+      @zip_entry.write_file_data "and this is part 2"
+      @zip_entry.crc.should == 2192856224
+    end
+  
+    it 'should write a local entry footer when closed' do
+      @zip_entry.should_receive(:write_local_footer)
+      @zip_entry.close
+    end
+  
+    describe 'after being closed' do
+   
+      before do
+        @zip_entry.close
+      end
+  
+      it 'should not write a local footer if close is called again' do
+        @zip_entry.should_not_receive(:write_zip_footer)
+        @zip_entry.close
+      end
+  
+      it 'should raise an error if an attempt is made to write file data' do
+        proc { @zip_entry.write_file_data('something irrelevant') }.should raise_error
+      end
+  
+    end
+  
+  end
+
+end

data/spec/zip_header_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module DooDah
+
+  describe ZipHeader, :type => :write_capturing do
+
+    it 'should write signature as a four byte little endian unsigned long' do
+      header = Object.new.extend(ZipHeader)
+      record_writes(header)
+      header.write_signature(0x02FD01FE)
+      written.should have_bytes(0xFE, 0x01, 0xFD, 0x02)
+    end
+
+  end
+
+end

data/spec/zip_output_stream_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+module DooDah
+
+  describe ZipOutputStream do
+  
+    before do
+      @output_stream = stub(:write => 7)
+      @zip = ZipOutputStream.new(@output_stream)
+      @entry = stub(:close => nil, :closed? => false)
+      ZipEntry.stub(:new => @entry)
+    end
+
+    describe '#start_entry' do
+
+      it 'should create a ZipEntry with the zip output stream as its owner' do
+        ZipEntry.should_receive(:new).with(@zip, 'entry name', 123)
+        @zip.start_entry('entry name', 123)
+      end
+
+      it 'should return the new entry' do
+        @zip.start_entry('entry name', 123).should == @entry
+      end
+
+      it 'should ensure that the next most recently created entry is closed' do
+        entry1 = @zip.start_entry('first entry', 0)
+        entry1.should_receive(:close)
+        @zip.start_entry('entry2', 0)
+      end
+
+    end
+
+    describe '#create_entry' do
+
+      it 'should create a new ZipEntry' do
+        ZipEntry.should_receive(:new).with(@zip, 'entry name', 123)
+        @zip.create_entry('entry name', 123) {}
+      end
+
+      it 'should yield the new entry to a block' do
+       	yielded_zip_entry = nil
+        @zip.create_entry('entry name', 123) {|zip_entry| yielded_zip_entry = zip_entry}
+        yielded_zip_entry.should == @entry
+      end
+
+      it 'should close the new entry on return from the block' do
+        @entry.should_receive(:close)
+        @zip.create_entry('entry name', 123) {}
+      end
+
+      it 'should close the new entry if an exception is raised during execution of the provided block' do
+        @entry.should_receive(:close)
+        expected_error = Class.new(Exception)
+        begin
+          @zip.create_entry('entry name', 123) { |zip_entry| raise expected_error } 
+        rescue expected_error
+        end
+      end
+
+      describe 'when there is already a zip entry started but not ended' do
+    
+        before do
+          @zip.start_entry('existing entry')
+        end
+
+        it 'should raise an error' do
+          lambda { @zip.create_entry('another entry') {} }.should raise_error(ZipOutputStream::EntryOpen)
+        end
+
+        it 'should not create a new ZipEntry' do
+          ZipEntry.should_not_receive(:new)
+          begin
+            @zip.create_entry('another entry')
+          rescue ZipOutputStream::EntryOpen
+          end
+        end
+
+      end
+
+    end
+
+    describe '#end_current_entry' do
+
+      it 'should close the most recently created entry' do
+        entry = @zip.start_entry('name', 0)
+        entry.should_receive(:close)
+        @zip.end_current_entry
+      end
+
+      it 'should not fail if no entry has been created' do
+        lambda { @zip.end_current_entry }.should_not raise_error
+      end
+
+    end
+
+    describe '#close' do
+
+      before do
+        ZipEntry.stub(:new => stub(:close => nil, :write_central_header => nil))
+      end
+
+      it 'should ensure that the most recently started entry is closed' do
+        entry = @zip.start_entry('first entry', 0)
+        entry.should_receive(:close)
+        @zip.close
+      end
+
+      it 'should cause each entry created by the zip output stream to write a central directory header' do
+        entries = [@zip.start_entry('first', 0), @zip.start_entry('second', 0), @zip.start_entry('third', 0)]
+        entries.each { |entry| entry.should_receive(:write_central_header) }
+        @zip.close
+      end
+
+      it 'should write an end of central directory record' do
+        @zip.should_receive(:write_end_of_central_directory)
+        @zip.close
+      end
+
+      it 'should record the current offset as the start of the central directory before writing central header records' do
+        @zip.stub(:current_offset => 789)
+        entry = @zip.start_entry('first entry', 0)
+        entry.stub(:write_central_header) do
+          @zip.send(:central_directory_offset).should == 789
+        end
+        @zip.close
+      end
+
+    end
+  
+    it 'should have a count of the number of entries it has created' do
+      @zip.start_entry('name', 0)
+      @zip.start_entry('name', 0)
+      @zip.entry_count.should == 2
+    end
+
+    it 'should send data unchanged to the output stream when #write() is called' do
+      @output_stream.should_receive(:write).with('7 bytes')
+      @zip.write('7 bytes')
+    end
+
+    it '#current_offset should provide a total count of the number of bytes written' do
+      @zip.write('7 bytes')
+      @zip.write('7 bytes')
+      @zip.current_offset.should == 14
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification 
+name: doo_dah
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Michael Collas
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-04 00:00:00 +10:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 47
+        segments: 
+        - 2
+        - 8
+        - 0
+        version: 2.8.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: reek
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 2
+        - 8
+        version: 1.2.8
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sexp_processor
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 3
+        - 0
+        - 4
+        version: 3.0.4
+  type: :development
+  version_requirements: *id003
+description: "      This gem creates zip files using the STORE method - i.e. with no compression. This enables the generation of\n      zip files with a known size from streamed data, providing the size of the input files is known. \n"
+email: mcollas@yahoo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- .rspec
+- README
+- Rakefile
+- VERSION
+- config/defaults.reek
+- example/multi-language.rb
+- lib/doo_dah.rb
+- lib/doo_dah/dos_time.rb
+- lib/doo_dah/zip_entry.rb
+- lib/doo_dah/zip_header.rb
+- lib/doo_dah/zip_output_stream.rb
+- spec/central_directory_spec.rb
+- spec/dos_time_spec.rb
+- spec/local_directory_header_spec.rb
+- spec/spec_helper.rb
+- spec/support/byte_matcher.rb
+- spec/support/write_capturing_example_group.rb
+- spec/zip_entry_header_spec.rb
+- spec/zip_entry_spec.rb
+- spec/zip_header_spec.rb
+- spec/zip_output_stream_spec.rb
+has_rdoc: true
+homepage: http://github.com/michaelcollas/doo_dah
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Creates zip files suitable for streaming.
+test_files: []
+