zip64writer 0.0.1

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+
+require 'rubygems/package_task'
+
+$: << 'lib'
+
+require 'zip64/version'
+
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Zip64 Output Library"
+  s.authors = ["Geoff Youngs"]
+  s.email   = 'git@intersect-uk.co.uk'
+  s.homepage = 'http://github.com/geoffyoungs/zip64writer'
+  s.name = 'zip64writer'
+  s.version = Zip64::VERSION.to_s
+  s.requirements << 'none'
+  s.require_path = 'lib'
+  s.files = FileList['lib/zip64/*.rb']
+  s.test_files = FileList['test/*_test.rb'] + ['Rakefile']
+  s.description = <<EOF
+A simple library to output Zip64 zip files from pure ruby.
+EOF
+end
+
+Gem::PackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+

data/lib/zip64/debug.rb

@@ -0,0 +1,82 @@
+$: << File.dirname(__FILE__)+"/../"
+require 'zip64/structures'
+require 'stringio'
+def find_block_type sig
+	Zip64.constants.each do |nam|
+		klass = Zip64.const_get(nam)
+		if klass.respond_to?(:constants) && klass.constants.include?('SIG')
+			if sig == klass::SIG
+				return klass
+			end
+		end
+	end
+	nil
+end
+
+def zip_debug(arg)
+
+File.open(arg, "rb") do |fp|
+	until fp.eof?
+		until fp.eof? or (fp.tell%2).zero?
+			fp.getc
+		end
+		bs = fp.tell
+		STDOUT.write(sprintf(".%-16i", bs))
+		sig = fp.read(4).unpack('V').first
+		klass = find_block_type sig
+
+		if klass
+			o = klass.read_from(fp, 1)
+			o.signature = sig
+			o.describe(STDOUT)
+
+			case o
+			when Zip64::LocalFileHeader
+				filename = fp.read(o.filename_len)
+				extra = fp.read(o.extra_field_len)
+
+				data_len = o.data_len
+
+				unless extra.empty?
+					extra_fp = StringIO.new(extra)
+					until extra_fp.eof?
+						esig = extra_fp.read(2).unpack('v').first
+						if eklass = find_block_type(esig)
+							e = eklass.read_from(extra_fp, 1)
+							e.signature = sig
+							e.describe(STDOUT)
+						end
+					end
+					#if o.data_len == Zip64::LEN64
+					#	info = Zip64::Zip64ExtraField.read_from(StringIO.new(extra), 0)
+					#	info.describe(STDOUT)
+					#	data_len = info.data_len
+					#end
+				end
+
+				data = fp.read(data_len)
+				p [:filename, filename]
+				p [:extra, extra]
+				if data.size > 50
+					data = data[0..50]+"(#{data.size} bytes, truncated)"
+				end
+				p [:data, data]
+			when Zip64::CDFileHeader
+				filename = fp.read(o.filename_len)
+				extra    = fp.read(o.extra_field_len)
+				comment  = fp.read(o.file_comment_len)
+				p [:filename, filename]
+				p [:extra, extra]
+				p [:comment, comment]
+			end
+		else
+			puts sprintf('%16s %16i', sig.to_s(16), sig) if sig
+		end
+	end
+end
+
+end
+
+if __FILE__.eql?($0)
+	zip_debug ARGV[0]
+end

data/lib/zip64/structures.rb

@@ -0,0 +1,443 @@
+#/usr/bin/env ruby
+
+class Block
+	class FieldFormat
+		def self.from(line)
+			case line
+			when Array
+				new(*line)
+			when self
+				line
+			else
+				raise "#{line.inspect} is not a valid field"
+			end
+		end
+
+		attr_reader :type, :name
+		def initialize(type, name, options = {})
+			if options.is_a?(Hash)
+			else
+				val, options = options, {}
+				options[:default] = val
+			end
+			@type, @name, @options = type, name, options
+		end
+
+		def encode(object, value)
+			val = value || @options[:default]
+			[val].pack(@type).force_encoding("ASCII-8BIT")
+		rescue
+			raise "#{value.inspect} (#{val.inspect}?) is not a valid type for #{self.inspect}"
+		end
+	end
+	class << self
+		# Reader mode:
+		# With no arguments returns the fields defined for this class
+		#
+		# Writer mode:
+		# If args is not empty then each argument is passed to FieldFormat.from(arg)
+		# to convert to a FieldFormat object.
+		#
+		# Also accessors are defined
+		def fields *args
+			if args.empty?
+				@fields
+			else
+				@fields = args.map { |arg| FieldFormat.from(arg) }
+				@fields.each { |f| attr_accessor(f.name) }
+			end
+		end
+	end
+
+	def fields
+		self.class.fields()
+	end
+
+	def self.base_size
+		fields.inject(0) { |t, f| size_of(f.type) + t }
+	end
+
+	def read_field_from(fp, field)
+		if (sz = size_of(field.type)).nonzero?
+			val = fp.read(sz).unpack(field.type).first
+			send("#{field.name}=", val)
+		else
+			fn = "#{field.name}_len"
+			if field.type == "A*" && o.respond_to?(fn) && o.send(fn)
+				send("#{field.name}=", fp.read(o.send(fn)))
+			else
+				puts "#{field.name} un-fetchable"
+			end
+		end
+	end
+
+	def self.read_from(fp, offset)
+		o = new()
+		fields[offset..-1].each do |field|
+			next if o.respond_to?(:skip_read?) && o.skip_read?(field)
+			o.read_field_from(fp, field)
+		end
+		o
+	end
+	def describe(io)
+		io.puts "---- #{self.class.name}"
+		fields.each do |field|
+			val = send(field.name)
+			if val.nil?
+				io.puts sprintf("%33s %s", 'NULL', field.name)
+			else
+				io.puts sprintf("%16s %16i %2i %s", val.to_s(16), val,
+								size_of(field.type), field.name)
+			end
+		end
+	end
+
+
+	def self.size_of(type)
+		case type
+		when 'C', 'c'
+			1
+		when 'v'
+			2
+		when 'V'
+			4
+		when 'Q'
+			8
+		else
+			0
+		end
+	end
+	def size_of(type)
+		self.class.size_of(type)
+	end
+
+	def to_string
+		buf = ''.force_encoding("ASCII-8BIT")
+		fields.each do |f|
+			buf << pack_field(f)
+		end
+		buf
+	end
+	alias :to_s :to_string
+
+	def pack_field(field)
+		field.encode(self, send(field.name))
+	end
+
+	def size
+		to_string.size
+	end
+
+	def initialize(options={})
+		options.each do |key,val|
+			send("#{key}=", val) if respond_to?("#{key}") && respond_to?("#{key}=")
+		end
+	end
+end
+
+module Zip64
+
+LEN64 = 0xFFFFFFFF
+module Flags
+	ENCRYPTED = 1 << 0
+	CRC_IN_CD = 1 << 3
+	UTF8      = 1 << 11
+end
+module Compression
+	NONE      = 0
+end
+
+
+class Zip64ExtraField < Block
+	ID = 0x0001
+	fields ['v', :header_id],
+			['v', :header_len],
+			['Q', :raw_data_len],
+			['Q', :data_len]
+	def to_s; to_string; end
+end
+
+class ::String
+	if RUBY_VERSION <= "1.8.7"
+		def force_encoding(what)
+			self
+		end
+	end
+end
+
+class LocalFileHeader < Block
+	SIG = 0x04034b50
+
+	fields ['V', :signature, SIG],
+		['v', :version, 45],
+		['v', :flags, 0],
+		['v', :compression, 0],
+		['v', :last_mod_file_time],
+		['v', :last_mod_file_date],
+		['V', :crc32],
+		['V', :data_len],
+		['V', :raw_data_len],
+		['v', :filename_len],
+		['v', :extra_field_len]
+
+	def zip64?
+		data_len == LEN64 && raw_data_len == LEN64
+	end
+
+	def version
+		zip64? ? 45 : 10
+	end
+
+	attr_reader :filename
+	def to_string
+		extra = extra_field_str
+		self.extra_field_len = extra.size
+		super + "#{@filename}#{extra}"
+	end
+	def	to_s
+		to_string
+	end
+	def filename=(str)
+		str = str.dup.force_encoding('ASCII-8BIT')
+		self.filename_len = str.size
+		@filename = str
+	end
+	def extra_field=(str)
+		case str
+		when Array
+			@extra_field = str
+		else
+			@extra_field = [str]
+		end
+	end
+	def extra_field
+		(@extra_field ||= [])
+	end
+	def extra_field_str
+		buf = ''.force_encoding('ASCII-8BIT')
+		extra_field.each do |field|
+			if field.respond_to?(:to_string)
+				buf << field.to_string.force_encoding('ASCII-8BIT')
+			else
+				buf << field.to_s.force_encoding('ASCII-8BIT')
+			end
+		end
+		buf
+	end
+end
+
+class CDFileHeader < Block
+	SIG = 0x02014b50
+	fields ['V', :signature, SIG],
+		['v', :made_by],
+		['v', :version, 45],
+		['v', :flags, 0],
+		['v', :compression, 0],
+		['v', :last_mod_file_time],
+		['v', :last_mod_file_date],
+		['V', :crc32, 0],
+		['V', :data_len],
+		['V', :raw_data_len],
+		['v', :filename_len], # auto
+		['v', :extra_field_len], # auto
+		['v', :file_comment_len], #
+		['v', :disk_no],
+		['v', :internal_file_attributes],
+		['V', :external_file_attributes],
+		['V', :rel_offset_of_local_header]
+
+	def zip64?
+		data_len == LEN64 && raw_data_len == LEN64
+	end
+
+	def version
+		zip64? ? 45 : 10
+	end
+
+	attr_reader :filename, :extra_field, :file_comment
+	def to_string
+		super + "#{@filename}#{extra_field}#{file_comment}"
+	end
+	def file_comment=(str)
+		str = str.force_encoding('ASCII-8BIT')
+		self.file_comment_len = str.size
+		@file_comment = str
+	end
+	def filename=(str)
+		str = str.force_encoding('ASCII-8BIT')
+		self.filename_len = str.size
+		@filename = str
+	end
+	def extra_field=(str)
+		str = str.force_encoding('ASCII-8BIT')
+		self.extra_field_len = str.size
+		@extra_field = str
+	end
+end
+
+class Zip64CDExtraField < Block
+	SIG = 0x0001
+	fields ['v', :signature, SIG],
+		['v', :size],
+		['Q', :raw_data_len],
+		['Q', :data_len],
+		['Q', :relative_offset],
+		['V', :disk_no]
+	def to_string
+		@size = 0
+		fields.each { |field| @size += size_of(field.type) }
+		@size -= 4
+		super
+	end
+end
+
+class UnixExtraField < Block
+	SIG = 0x000d
+	fields ['v', :signature, SIG],
+		['v',  :size],
+		['V',  :atime],
+		['V',  :mtime],
+		['v',  :uid],
+		['v',  :gid],
+		['A*', :data, '']
+
+	def to_string
+		@size = @data.to_s.size
+		fields.each { |field| @size += size_of(field.type) }
+		@size -= 4
+		super
+	end
+end
+
+class ExtendedTimestampField < Block
+	SIG = 0x5455
+	fields ['v', :signature, SIG],
+		['v',  :size],
+		['C',  :info_bits],
+		['V',  :mtime],
+		['V',  :atime],
+		['V',  :ctime]
+	def	skip_read?(field)
+		case field.name
+		when :mtime
+			(@info_bits&1).zero?
+		when :atime
+			(@info_bits&2).zero?
+		when :ctime
+			(@info_bits&4).zero?
+		else
+			false
+		end
+	end
+end
+
+class InfoZipNewUnixExtraField < Block
+	SIG = 0x7875
+	fields ['v', :signature, SIG],
+		['v', :size],
+		['C', :version],
+		['C', :uid_size],
+		['V', :uid],
+		['C', :gid_size],
+		['V', :gid]
+	MAP = { 1 => 'C', 2 => 'v', 4 => 'V'}
+
+	def pack_field(field)
+		case field.name
+		when :uid
+			type = MAP[@uid_size]
+			[@uid].pack(type).force_encoding('ASCII-8BIT')
+		when :gid
+			type = MAP[@gid_size]
+			[@gid].pack(type).force_encoding('ASCII-8BIT')
+		else
+			super
+		end
+	end
+
+	def read_field_from(fp, field)
+		case field.name
+		when :uid
+			type = MAP[@uid_size]
+			@uid = fp.read(@uid_size).unpack(type).first
+		when :gid
+			type = MAP[@gid_size]
+			@gid = fp.read(@gid_size).unpack(type).first
+		else
+			super
+		end
+	end
+end
+
+class DigSig < Block
+	SIG = 0x05054b50
+	fields  ['V', :signature, SIG],
+		['v', :size],
+		['A*', :data]
+	def to_string
+		@size = @data.size
+		super
+	end
+end
+
+class DD64 < Block
+	SIG = 0x08074b50
+	fields  ['V', :signature, SIG],
+		['V', :crc32, 0],
+		['Q', :data_len],
+		['Q', :raw_data_len]
+end
+
+class Zip64EOCDR < Block
+#	SIG = 0x02014b50
+	SIG = 0x06064b50
+	fields ['V', :signature, SIG],
+		['Q', :record_len],
+		['v', :made_by],
+		['v', :version, 45],
+		['V', :this_disk_no],
+		['V', :disk_with_cd_no],
+		['Q', :total_no_entries_on_this_disk],
+		['Q', :total_no_entries],
+		['Q', :size_of_cd],
+		['Q', :offset_of_cd_wrt_disk_no]
+		['A*', :data, '']
+	def to_string
+		@record_len = @data.to_s.size - 12
+		fields.each { |field| @record_len += size_of(field.type) }
+		super
+	end
+end
+
+class Zip64EOCDL < Block
+	SIG = 0x07064b50
+	fields ['V', :signature, SIG],
+		['V', :disk_with_z64_eocdr],
+		['Q', :relative_offset],
+		['V', :no_disks]
+end
+
+class EOCDR < Block
+	SIG = 0x06054b50
+	fields ['V', :signature, SIG],
+		['v', :disk_no],
+		['v', :disk_with_cd_no],
+		['v', :total_entries_in_local_cd],
+		['v', :total_entries],
+		['V', :cd_size],
+		['V', :offset_to_cd_start],
+		['v', :file_comment_len]
+	attr_reader :file_comment
+	def to_string
+		super + "#{@file_comment}"
+	end
+	def file_comment=(str)
+		str = str.force_encoding('ASCII-8BIT')
+		@file_comment = str
+		self.file_comment_len = str.size
+	end
+end
+
+end
+
+

data/lib/zip64/version.rb

@@ -0,0 +1,6 @@
+module Zip64
+	VERSION = [0,0,1]
+	def VERSION.to_s
+		map { |v| v.to_s }.join('.')
+	end
+end

data/lib/zip64/writer.rb

@@ -0,0 +1,398 @@
+require 'zlib'
+require 'zip64/structures'
+require 'stringio'
+
+module Zip64
+module_function
+def time_to_msdos_time(time)
+	mt = 0
+
+	mt |= time.sec
+	mt |= time.min << 5
+	mt |= time.hour << 11
+
+	mt
+end
+def date_to_msdos_date(date)
+	md = 0
+
+	md |= date.day
+	md |= date.month << 5
+	md |= (date.year - 1980) << 9
+
+	md
+end
+
+class ZipWriter
+	def initialize(io)
+		@io, @offset = io, 0
+		@dir_entries = []
+		if block_given?
+			yield(self)
+			close
+		end
+	end
+
+	def ensure_metadata(io, info)
+		info = info.dup
+
+		info[:mtime] ||= Time.now
+		info[:gid]   ||= Process.gid
+		info[:uid]   ||= Process.uid
+
+		info[:name] ||= File.basename(io.path) if io.respond_to?(:path) && io.path
+		info[:name] ||= "file-#{@dir_entries.size+2}.dat"
+
+		info
+	end
+
+	def make_entry32(info, data, crc)
+		header = LocalFileHeader.new(
+			:flags => (1<<11),
+			:compression => 0,
+			:last_mod_file_time => Zip64.time_to_msdos_time(info[:mtime]),
+			:last_mod_file_date => Zip64.date_to_msdos_date(info[:mtime]),
+			:crc32 => crc,
+			:data_len => data.size,
+			:raw_data_len => data.size,
+			:filename => info[:name],
+			:extra_field => '')
+
+		header
+	end
+
+	def make_entry64(info, data, crc)
+		header = LocalFileHeader.new(
+			:flags => 0,
+			:last_mod_file_time => Zip64.time_to_msdos_time(info[:mtime]),
+			:last_mod_file_date => Zip64.date_to_msdos_date(info[:mtime]),
+			:crc32 => crc,
+			:data_len => LEN64,
+			:raw_data_len => LEN64,
+			:filename => info[:name],
+			:extra_field => Zip64ExtraField.new(
+				:header_id => Zip64ExtraField::ID,
+				:header_len => 16,
+				:raw_data_len => data.size,
+				:data_len => data.size)
+		)
+
+		header
+	end
+
+	def make_entry(info, data, crc)
+		if info[:use] == 64 || @offset + data.size > self.threshold
+			header = make_entry64(info, data, crc)
+		else
+			header = make_entry32(info, data, crc)
+		end
+	end
+
+	def add_link(target, info)
+		info = ensure_metadata(nil, info)
+		crc = Zlib.crc32('', 0)
+		make_entry(info, '', crc)
+
+		entry = { :offset => @offset, :len => 0 }
+		@dir_entries << entry
+
+		header = make_entry(info, '', crc)
+		header.extra_field.push(UnixExtraField.new(:atime => info[:mtime].to_i,
+												   :mtime => info[:mtime].to_i,
+												   :uid   => info[:uid].to_i,
+												   :gid   => info[:gid].to_i,
+												   :data  => target))
+
+		entry[:zip64] = header.zip64?
+		entry[:local_header] = header
+
+		# write output
+		write header.to_string
+	end
+
+	def add_entry(io, info)
+		info = ensure_metadata(io, info)
+
+		data = io.read.to_s
+		crc = Zlib.crc32(data, 0)
+
+		# XXX: this doesn't fit well with the planned usage :(
+		entry = { :offset => @offset, :len => data.size }
+		@dir_entries << entry
+
+		header = make_entry(info, data, crc)
+
+		entry[:zip64] = header.zip64?
+
+		if info[:russiandolls]
+			first_header = header
+			last_header = header
+
+			info[:russiandolls].each_with_index do |doll,index|
+				io.rewind
+				doll_header = make_entry(info.merge(doll), data, crc)
+				doll_prefix = [0x4343, doll_header.size].pack('vv')
+
+				if (doll_header.to_string.size + doll_prefix.size) +
+						first_header.to_string.size > local_header_max
+					STDERR.puts "Can't add any more dolls! Dolls #{index}-#{dolls.size-1} omitted."
+				else
+					offset = @offset + first_header.to_string.size + doll_prefix.size
+					last_header.extra_field << doll_prefix << doll_header
+					@dir_entries << {
+						:offset => offset,
+						:len => data.size,
+						:local_header => doll_header,
+						:zip64 => doll_header.zip64?
+					}
+					last_header = doll_header
+				end
+			end
+		end
+
+		entry[:local_header] = header
+
+		# write output
+		write header.to_string
+
+		# write data (& any compression?)
+		write data
+
+
+		# write descriptor - not need with current strategy
+		# write DD64.new(:crc32 => crc,
+		#			:data_len => data.size,
+		#			:raw_data_len => data.size).to_string
+	end
+
+	def local_header_max
+		1024 * 64
+	end
+
+	def threshold
+		1024 * # kb
+		1024 * # mb
+		1024 * # gb
+		2 - local_header_max
+	end
+
+	def write_central_directory
+		align
+		@central_directory_offset = @offset
+
+		@dir_entries.each do |entry|
+			offset = entry[:offset]
+			len    = entry[:len]
+			header = entry[:local_header]
+
+			extra_field = Zip64CDExtraField.new(
+				:data_len => len,
+				:raw_data_len => len,
+				:relative_offset => offset,
+				:disk_no => 0
+			)
+			write CDFileHeader.new(
+				:flags => header.flags,
+				:compression => header.compression,
+				:made_by => (3 << 8),
+				:last_mod_file_time => header.last_mod_file_time,
+				:last_mod_file_date => header.last_mod_file_date,
+				:crc32 => header.crc32,
+				:data_len => entry[:zip64] ? LEN64 : len,
+				:raw_data_len => entry[:zip64] ? LEN64 : len,
+				:filename => header.filename,
+				:extra_field => entry[:zip64] ? extra_field.to_string : '',
+				:file_comment => '',
+				:disk_no => entry[:zip64] ? 0xffff : 0,
+				:internal_file_attributes => 0,
+				:external_file_attributes => 0,
+				:rel_offset_of_local_header => entry[:zip64] ? LEN64 : offset
+			).to_string
+		end
+
+		# Central Directory Size
+		@central_directory_size = @offset - @central_directory_offset
+	end
+
+	def write_zip64_end_of_central_directory
+		#align
+		@zip64_central_directory_offset = @offset
+
+		write Zip64EOCDR.new(
+			:made_by => 3 << 8,
+			:this_disk_no => 0,
+			:disk_with_cd_no => 0,
+			:total_no_entries_on_this_disk => @dir_entries.size,
+			:total_no_entries => @dir_entries.size,
+			:size_of_cd => @central_directory_size,
+			:offset_of_cd_wrt_disk_no => @central_directory_offset,
+			:data => ''
+		).to_string
+	end
+
+	def write_zip64_end_of_central_directory_locator
+		#align
+		write Zip64EOCDL.new(
+			:disk_with_z64_eocdr => 0,
+			# Assume relative offset is relative to disk, as
+			# is case elsewhere in Zip spec
+			:relative_offset => @zip64_central_directory_offset,
+			:no_disks => 1
+		).to_string
+	end
+
+	def write_end_of_central_directory_record
+		#align
+		write EOCDR.new(
+			:disk_no => 0,
+			:disk_with_cd_no => 0,
+			:total_entries_in_local_cd => @dir_entries.size,
+			:total_entries => @dir_entries.size,
+			:cd_size => @central_directory_size,
+			:offset_to_cd_start => @central_directory_offset,
+			:file_comment => ''
+		).to_string
+	end
+
+	def close
+		# [archive decryption header]
+		#  ignore
+		# [archive extra data record]
+		#  ignore
+
+		# [central directory]
+		write_central_directory()
+
+		if @dir_entries.any? { |entry| entry[:zip64] }
+			# [zip64 end of central directory record]
+			write_zip64_end_of_central_directory()
+
+			# [zip64 end of central directory locator]
+			write_zip64_end_of_central_directory_locator()
+		end
+
+		# [end of central directory record]
+		write_end_of_central_directory_record()
+
+		write_last()
+	end
+
+	def self.get_io_size(io)
+		if io.respond_to?(:stat)
+			size = io.stat.size
+		elsif io.respond_to?(:size)
+			size = io.size
+		else
+			pos = io.tell
+			io.seek(0, IO::SEEK_END)
+			size = io.tell
+			io.seek(pos, IO::SEEK_START)
+		end
+		size
+	end
+
+	def self.predict_size64(files)
+		file_overhead = LocalFileHeader.base_size +
+				Zip64ExtraField.base_size
+
+		cd_overhead = CDFileHeader.base_size +
+			Zip64CDExtraField.base_size
+
+		total = 0
+		names_size = 0
+		dolls = 0
+		doll_names_size = 0
+		files.each do |file|
+			names_size += file[:name].size
+			total += get_io_size(file[:io]) + file[:name].size + file_overhead
+
+			if file[:russiandolls]
+				file[:russiandolls].each do |doll|
+					total += doll[:name].size + file_overhead + 4
+					dolls += 1
+					doll_names_size += doll[:name].size
+				end
+			end
+		end
+
+		until (total%4).zero?
+			total += 1
+		end
+
+		total += files.size * cd_overhead
+		total += names_size
+
+		total += dolls * cd_overhead
+		total += doll_names_size
+
+		total += EOCDR.base_size + Zip64EOCDL.base_size + Zip64EOCDR.base_size
+
+		total
+	end
+
+	protected
+	def align
+		until (@offset % 4).zero?
+			write_raw "\0"
+		end
+	end
+	def write(bytes)
+		bytes = bytes.to_string unless bytes.is_a?(String)
+		write_raw(bytes)
+	end
+	def write_raw(bytes)
+		#STDERR.puts "Write: #{'%8i' % bytes.size} @#{'%08i' % @offset}"
+		@io << bytes
+		@offset += bytes.size
+	end
+	def write_last(bytes=nil)
+		bytes = bytes.to_string if bytes.respond_to?(:to_string)
+		write_raw(bytes) unless bytes.nil? or bytes.empty?
+	end
+
+	def self.test
+		files = []
+		15.times do |x|
+			files << { :name => ("foo-%02i.txt" % x), :io => StringIO.new("Foo is #{x} and #{x * x}") }
+			info = files.last
+			(x*500).to_i.times do |y|
+				files.last[:io].puts "And some more lines about blah - we are foo #{x}"
+			end
+			files.last[:io].rewind
+
+			(rand()*15).to_i.times do |n|
+				info[:russiandolls] ||= []
+				info[:russiandolls] << { :name => ("%s-doll%02i.txt" % [info[:name],n]) }
+			end #if (i % 2).zero?
+		end
+
+		x = predict_size64(files)
+		File.open("test.zip", "w") do |fp|
+			ZipWriter.new(fp) do |writer|
+				i = 0
+				files.each do |info|
+					info = {:mtime => Time.now, :use => (i < 3 ? 32 : 64)}.merge(info)
+
+					writer.add_entry(info[:io], info)
+					#exit
+					#p info
+					i += 1
+				end
+			end
+			p [:guess, x, :actual, fp.tell, :diff, fp.tell - x]
+		end
+	end
+end
+class EventMachineWriter < ZipWriter
+	def write_raw(bytes)
+		@io.send_data(bytes)
+		@offset += bytes.size
+	end
+	def write_last(bytes=nil)
+		bytes = bytes.to_string if bytes.respond_to?(:to_string)
+		write_raw(bytes) unless bytes.nil? or bytes.empty?
+		@io.close_connection_after_writing
+	end
+end
+end
+

data/test/zip64_test.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require 'stringio'
+$: << File.join(File.dirname(__FILE__), '../lib')
+require 'zip64/writer'
+
+class Zip64Test < Test::Unit::TestCase
+	def test_small_std_zip
+		io = StringIO.new
+		
+		Zip64::ZipWriter.new(io) { |zip| zip.add_entry(StringIO.new("Foo"), :name => 'bar.txt') }
+
+		assert_equal 115, io.string.size
+		assert_match /^PK/, io.string
+		assert_match /bar.txtFoo/, io.string
+	end
+	def test_small_z64_zip
+		io = StringIO.new
+		
+		Zip64::ZipWriter.new(io) { |zip| zip.add_entry(StringIO.new("Foo"), :name => 'bar.txt', :use => 64) }
+
+		assert_equal 243, io.string.size
+		assert_match /^PK/, io.string
+		assert_match /bar.txt.*Foo/, io.string
+
+		assert io.string.include?([Zip64::Zip64EOCDR::SIG].pack('V'))
+	end
+end
+

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: zip64writer
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Geoff Youngs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-11 00:00:00 Z
+dependencies: []
+
+description: |
+  A simple library to output Zip64 zip files from pure ruby.
+
+email: git@intersect-uk.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/zip64/writer.rb
+- lib/zip64/debug.rb
+- lib/zip64/structures.rb
+- lib/zip64/version.rb
+- test/zip64_test.rb
+- Rakefile
+homepage: http://github.com/geoffyoungs/zip64writer
+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: 
+- none
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Zip64 Output Library
+test_files: 
+- test/zip64_test.rb
+- Rakefile