ruby-ole 1.2.2 → 1.2.3

data/ChangeLog

@@ -0,0 +1,22 @@
+== 1.2.3 / 2007-12-28
+
+- MBAT write support re-implmented. Can now write files over ~8mb again.
+- Minor fixes (truncation in #flush, file modification timestamps)
+- More test coverage
+- Initial (read-only) property set support.
+- Complete filesystem api, to pass most of the rubyzip tests.
+- Add a ChangeLog :).
+
+== 1.2.2 / 2007-11-05
+
+- Lots of test updates, 90% coverage.
+- Fix +to_tree+ method to be more efficient, and stream output.
+- Optimizations from benchmarks and profiling, mostly for writes. Fixed
+  AllocationTable#resize_chain, RangesIOResizable#truncate and
+  AllocationTable#free_block.
+- Add in filesystem test file from rubyzip, and start working on a
+  filesystem api.
+
+== 1.2.1 / 2007-08-20
+
+- Separate out from ruby-msg as new project.

data/Rakefile

@@ -47,16 +47,18 @@ spec = Gem::Specification.new do |s|
 	s.version = PKG_VERSION
 	s.summary = %q{Ruby OLE library.}
 	s.description = %q{A library for easy read/write access to OLE compound documents for Ruby.}
-	s.authors = ["Charles Lowe"]
+	s.authors = ['Charles Lowe']
 	s.email = %q{aquasync@gmail.com}
 	s.homepage = %q{http://code.google.com/p/ruby-ole}
-	#s.rubyforge_project = %q{ruby-ole}
+	s.rubyforge_project = %q{ruby-ole}
 
 	s.executables = ['oletool']
-	s.files  = ['Rakefile']
-	s.files += Dir.glob("lib/**/*.rb")
-	s.files += Dir.glob("test/test_*.rb") + Dir.glob("test/*.doc")
-	s.files += Dir.glob("bin/*")
+	s.files  = ['Rakefile', 'ChangeLog']
+	s.files += FileList['lib/**/*.rb']
+	s.files += FileList['test/test_*.rb', 'test/*.doc']
+	s.files += FileList['test/oleWithDirs.ole', 'test/test_SummaryInformation']
+	s.files += FileList['bin/*']
+	s.test_files = FileList['test/test_*.rb']
 
 	s.has_rdoc = true
 	s.rdoc_options += [
@@ -64,13 +66,11 @@ spec = Gem::Specification.new do |s|
 		'--title', "#{PKG_NAME} documentation",
 		'--tab-width', '2'
 	]
-
-	s.autorequire = 'ole/storage'
 end
 
 Rake::GemPackageTask.new(spec) do |t|
 	t.gem_spec = spec
-	t.need_tar = true
+	t.need_tar = false
 	t.need_zip = false
 	t.package_dir = 'build'
 end

data/lib/ole/file_system.rb

@@ -29,8 +29,8 @@
 #
 # TODO
 # 
-# - check for all new_child calls. eg Dir.mkdir, and File.open, and also
-#   File.rename, to add in filename length checks (max 32 / 31 or something).
+# - check Dir.mkdir, and File.open, and File.rename, to add in filename 
+#   length checks (max 32 / 31 or something).
 #   do the automatic truncation, and add in any necessary warnings.
 #
 # - File.split('a/') == File.split('a') == ['.', 'a']
@@ -130,6 +130,8 @@ module Ole # :nodoc:
 				path = "#{pwd}/#{path}" unless path =~ /^\//
 				# at this point its already absolute. we use File.expand_path
 				# just for the .. and . handling
+				# Hmmm, FIXME: won't work on windows i think. on windows it will prepend
+				# the current drive i believe. may just need to strip the first 2 chars.
 				File.expand_path path
 			end
 
@@ -160,8 +162,7 @@ module Ole # :nodoc:
 			end
 
 			def open path, mode='r', &block
-				# FIXME - mode strings are more complex than this.
-				if mode == 'w'
+				if IO::Mode.new(mode).create?
 					begin
 						dirent = dirent_from_path path
 					rescue Errno::ENOENT
@@ -169,8 +170,7 @@ module Ole # :nodoc:
 						# a get_parent_dirent function.
 						parent_path, basename = File.split expand_path(path)
 						parent = @ole.dir.send :dirent_from_path, parent_path, path
-						dirent = parent.new_child :file
-						dirent.name = basename
+						parent.children << dirent = Dirent.new(@ole, :type => :file, :name => basename)
 					end
 				else
 					dirent = dirent_from_path path
@@ -351,7 +351,7 @@ module Ole # :nodoc:
 				# now, we first should ensure that it doesn't already exist
 				# either as a file or a directory.
 				raise Errno::EEXIST, path if parent/basename
-				parent.new_child(:dir) { |child| child.name = basename }
+				parent.children << Dirent.new(@ole, :type => :dir, :name => basename)
 				0
 			end
 

data/lib/ole/property_set.rb

@@ -1,37 +1,42 @@
+require 'ole/types'
 
 module Ole
 	module Types
-		# should have a list of the VT_* variant types, and have all the serialization related code
-		# here... implement dump & load functions like marshalling
-		class Guid
-			SIZE = 16
-
-			def self.load str
-				Types.load_guid str
-			end
-		end
-
-		# see http://poi.apache.org/hpsf/internals.html
+		#
+		# The PropertySet class currently supports readonly access to the properties
+		# serialized in "property set" streams, such as the file "\005SummaryInformation",
+		# in OLE files.
+		#
+		# Think has its roots in MFC property set serialization.
+		#
+		# See http://poi.apache.org/hpsf/internals.html for details
+		#
 		class PropertySet
 			HEADER_SIZE = 28
-			HEADER_UNPACK = "vvVa#{Guid::SIZE}V"
+			HEADER_UNPACK = "vvVa#{Clsid::SIZE}V"
 			OS_MAP = {
 				0 => :win16,
 				1 => :mac,
 				2 => :win32
 			}
 
+			# define a smattering of the property set guids. 
+			FMTID_SummaryInformation		= Clsid.parse '{f29f85e0-4ff9-1068-ab91-08002b27b3d9}'
+			FMTID_DocSummaryInformation	= Clsid.parse '{d5cdd502-2e9c-101b-9397-08002b2cf9ae}'
+			FMTID_UserDefinedProperties	= Clsid.parse '{d5cdd505-2e9c-101b-9397-08002b2cf9ae}'
+
 			class Section < Struct.new(:guid, :offset)
+				include Variant::Constants
 				include Enumerable
 
-				SIZE = Guid::SIZE + 4
-				UNPACK_STR = "a#{Guid::SIZE}v"
+				SIZE = Clsid::SIZE + 4
+				UNPACK_STR = "a#{Clsid::SIZE}v"
 
 				attr_reader :length
 				def initialize str, property_set
 					@property_set = property_set
 					super(*str.unpack(UNPACK_STR))
-					self.guid = Guid.load guid
+					self.guid = Clsid.load guid
 					load_header
 				end
 
@@ -49,14 +54,20 @@ module Ole
 					io.read(length * 8).scan(/.{8}/m).each do |str|
 						id, property_offset = str.unpack 'V2'
 						io.seek offset + property_offset
-						type = io.read(4).unpack('V')[0]
-						yield id, type, io.read(10)
+						type, value = io.read(8).unpack('V2')
+						# is the method of serialization here custom?
+						case type
+						when VT_LPSTR, VT_LPWSTR
+							value = Variant.load type, io.read(value)
+						# ....
+						end
+						yield id, type, value
 					end
 					self
 				end
 
 				def properties
-					to_a
+					to_enum.to_a
 				end
 			end
 
@@ -66,13 +77,13 @@ module Ole
 				load_header io.read(HEADER_SIZE)
 				load_section_list io.read(@num_sections * Section::SIZE)
 				# expect no gap between last section and start of data.
-				Log.warn "gap between section list and property data" unless io.pos == @sections.map(&:offset).min
+				#Log.warn "gap between section list and property data" unless io.pos == @sections.map(&:offset).min
 			end
 
 			def load_header str
 				@signature, @unknown, @os_id, @guid, @num_sections = str.unpack HEADER_UNPACK
 				# should i check that unknown == 0? it usually is. so is the guid actually
-				@guid = Guid.load @guid
+				@guid = Clsid.load @guid
 				@os = OS_MAP[@os_id] || Log.warn("unknown operating system id #{@os_id}")
 			end
 

data/lib/ole/ranges_io.rb

@@ -1,36 +1,5 @@
-class IOModeString
-	def initialize mode='r'
-		@mode = mode
-		if @mode['b']
-			@binary = true
-			@mode = @mode.sub 'b', ''
-		else
-			@binary = false
-		end
-		if @mode[/\+$/]
-			@plus = true
-			@mode = @mode.sub(/\+$/, '')
-		else
-			@plus = false
-		end
-	end
-
-	def explicit_binary?
-		@binary
-	end
-
-	def binary?
-		RUBY_PLATFORM !~ /win/ or @binary
-	end
-
-	def to_s
-		@mode
-	end
-
-	def inspect
-		"#<#{self.class}:#{to_s.inspect}>"
-	end
-end
+# need IO::Mode
+require 'ole/support'
 
 #
 # = Introduction
@@ -71,26 +40,40 @@ end
 # This class isn't ole specific, maybe move it to my general ruby stream project.
 # 
 class RangesIO
-	attr_reader :io, :ranges, :size, :pos
+	attr_reader :io, :mode, :ranges, :size, :pos
 	# +io+:: the parent io object that we are wrapping.
-	# 
-	# +ranges+:: byte offsets, either:
-	# 1. an array of ranges [1..2, 4..5, 6..8] or
-	# 2. an array of arrays, where the second is length [[1, 1], [4, 1], [6, 2]] for the above
-	#    (think the way String indexing works)
+	# +mode+:: the mode to use
+	# +params+:: hash of params.
+	# * :ranges - byte offsets, either:
+	#   1. an array of ranges [1..2, 4..5, 6..8] or
+	#   2. an array of arrays, where the second is length [[1, 1], [4, 1], [6, 2]] for the above
+	#      (think the way String indexing works)
+	# * :close_parent - boolean to close parent when this object is closed
 	#
 	# NOTE: the +ranges+ can overlap.
-	def initialize io, ranges, opts={}
-		@opts = {:close_parent => false}.merge opts
+	def initialize io, mode='r', params={}
+		mode, params = 'r', mode if Hash === mode
+		ranges = params[:ranges]
+		@params = {:close_parent => false}.merge params
+		@mode = IO::Mode.new mode
 		@io = io
 		# convert ranges to arrays. check for negative ranges?
+		ranges ||= [0, io.size]
 		@ranges = ranges.map { |r| Range === r ? [r.begin, r.end - r.begin] : r }
 		# calculate size
 		@size = @ranges.inject(0) { |total, (pos, len)| total + len }
 		# initial position in the file
 		@pos = 0
+
+		# handle some mode flags
+		truncate 0 if @mode.truncate?
+		seek size if @mode.append?
 	end
 
+#IOError: closed stream
+# get this for reading, writing, everything...
+#IOError: not opened for writing
+
 	# add block form. TODO add test for this
 	def self.open(*args, &block)
 		ranges_io = new(*args)
@@ -120,7 +103,7 @@ class RangesIO
 	alias tell :pos
 
 	def close
-		@io.close if @opts[:close_parent]
+		@io.close if @params[:close_parent]
 	end
 
 	# returns the [+offset+, +size+], pair inorder to read/write at +pos+
@@ -169,8 +152,7 @@ class RangesIO
 		data
 	end
 
-	# you may override this call to update @ranges and @size, if applicable. then write
-	# support can grow below
+	# you may override this call to update @ranges and @size, if applicable.
 	def truncate size
 		raise NotImplementedError, 'truncate not supported'
 	end
@@ -232,3 +214,15 @@ class RangesIO
 	end
 end
 
+# this subclass of ranges io explicitly ignores the truncate part of 'w' modes.
+# only really needed for the allocation table writes etc. maybe just use explicit modes
+# for those
+# better yet write a test that breaks before I fix it.
+class RangesIONonResizeable < RangesIO
+	def initialize io, mode='r', params={}
+		mode, params = 'r', mode if Hash === mode
+		flags = IO::Mode.new(mode).flags & ~IO::TRUNC
+		super io, flags, params
+	end
+end
+

data/lib/ole/storage.rb

@@ -1,7 +1,3 @@
-#! /usr/bin/ruby -w
-
-$: << File.dirname(__FILE__) + '/..'
-
 require 'tempfile'
 
 require 'ole/base'
@@ -16,11 +12,6 @@ module Ole # :nodoc:
 	# access to OLE2 structured storage files, such as those produced by
 	# Microsoft Office, eg *.doc, *.msg etc.
 	#
-	# Initially based on chicago's libole, source available at
-	# http://prdownloads.sf.net/chicago/ole.tgz
-	# Later augmented with some corrections by inspecting pole, and (purely
-	# for header definitions) gsf.
-	#
 	# = Usage
 	#
 	# Usage should be fairly straight forward:
@@ -49,24 +40,37 @@ module Ole # :nodoc:
 	#   ole.root["\001CompObj"].open { |f| f.write "blah blah" }
 	#   ole.close
 	#
+	# = Thanks
+	#
+	# * The code contained in this project was initially based on chicago's libole
+	#   (source available at http://prdownloads.sf.net/chicago/ole.tgz).
+	#
+	# * It was later augmented with some corrections by inspecting pole, and (purely
+	#   for header definitions) gsf.
+	#
+	# * The property set parsing code came from the apache java project POIFS.
+	#
+	# * The excellent idea for using a pseudo file system style interface by providing
+	#   #file and #dir methods which mimic File and Dir, was borrowed (along with almost
+	#   unchanged tests!) from Thomas Sondergaard's rubyzip.
+	#
 	# = TODO
 	#
 	# * the custom header cruft for Header and Dirent needs some love.
 	# * i have a number of classes doing load/save combos: Header, AllocationTable, Dirent,
 	#   and, in a manner of speaking, but arguably different, Storage itself.
-	#   they have differing api's which would be nice to clean.
+	#   they have differing api's which would be nice to rethink.
 	#   AllocationTable::Big must be created aot now, as it is used for all subsequent reads.
-	# * need to fix META_BAT support in #flush.
 	#
 	class Storage
 		# thrown for any bogus OLE file errors.
 		class FormatError < StandardError # :nodoc:
 		end
 
-		VERSION = '1.2.2'
+		VERSION = '1.2.3'
 
 		# options used at creation time
-		attr_reader :opts
+		attr_reader :params
 		# The top of the ole tree structure
 		attr_reader :root
 		# The tree structure in its original flattened form. only valid after #load, or #flush.
@@ -79,23 +83,31 @@ module Ole # :nodoc:
 
 		# maybe include an option hash, and allow :close_parent => true, to be more general.
 		# +arg+ should be either a file, or an +IO+ object, and needs to be seekable.
-		def initialize arg, mode=nil, opts={}
-			opts, mode = mode, nil if Hash === mode
-			opts = {:update_timestamps => true}.merge(opts)
-			@opts = opts
+		def initialize arg, mode=nil, params={}
+			params, mode = mode, nil if Hash === mode
+			params = {:update_timestamps => true}.merge(params)
+			@params = params
 	
 			# get the io object
 			@close_parent, @io = if String === arg
-				[true, open(arg, mode || 'rb')]
+				mode ||= 'rb'
+				[true, open(arg, mode)]
 			else
 				raise ArgumentError, 'unable to specify mode string with io object' if mode
 				[false, arg]
 			end
 			# do we have this file opened for writing? don't know of a better way to tell
 			# (unless we parse the mode string in the open case)
+			# hmmm, note that in ruby 1.9 this doesn't work anymore. which is all the more
+			# reason to use mode string parsing when available, and fall back to something like
+			# io.writeable? otherwise.
 			@writeable = begin
-				@io.flush
-				true
+				if mode
+					IO::Mode.new(mode).writeable?
+				else
+					@io.flush
+					true
+				end
 			rescue IOError
 				false
 			end
@@ -106,8 +118,8 @@ module Ole # :nodoc:
 			@io.size > 0 ? load : clear
 		end
 
-		def self.open arg, mode=nil, opts={}
-			ole = new arg, mode, opts
+		def self.open arg, mode=nil, params={}
+			ole = new arg, mode, params
 			if block_given?
 				begin   yield ole
 				ensure; ole.close
@@ -117,6 +129,18 @@ module Ole # :nodoc:
 		end
 
 		# load document from file.
+		#
+		# TODO: implement various allocationtable checks, maybe as a AllocationTable#fsck function :)
+		#
+		# 1. reterminate any chain not ending in EOC.
+		#    compare file size with actually allocated blocks per file.
+		# 2. pass through all chain heads looking for collisions, and making sure nothing points to them
+		#    (ie they are really heads). in both sbat and mbat
+		# 3. we know the locations of the bbat data, and mbat data. ensure that there are placeholder blocks
+		#    in the bat for them.
+		# 4. maybe a check of excess data. if there is data outside the bbat.truncate.length + 1 * block_size,
+		#    (eg what is used for truncate in #flush), then maybe add some sort of message about that. it
+		#    will be automatically thrown away at close time.
 		def load
 			# we always read 512 for the header block. if the block size ends up being different,
 			# what happens to the 109 fat entries. are there more/less entries?
@@ -159,7 +183,8 @@ module Ole # :nodoc:
 
 			# FIXME i don't currently use @header.num_sbat which i should
 			# hmm. nor do i write it. it means what exactly again?
-			@sb_file = RangesIOResizeable.new @bbat, @root.first_block, @root.size
+			# which mode to use here?
+			@sb_file = RangesIOResizeable.new @bbat, :first_block => @root.first_block, :size => @root.size
 			@sbat = AllocationTable::Small.new self
 			@sbat.load @bbat.read(@header.sbat_start)
 		end
@@ -170,25 +195,16 @@ module Ole # :nodoc:
 			@io.close if @close_parent
 		end
 
-		# should have a #open_dirent i think. and use it in load and flush. neater.
-		# also was thinking about Dirent#open_padding. then i can more easily clean up the padding
-		# to be 0.chr
-=begin
-thoughts on fixes:
-1. reterminate any chain not ending in EOC. 
-2. pass through all chain heads looking for collisions, and making sure nothing points to them
-   (ie they are really heads).
-3. we know the locations of the bbat data, and mbat data. ensure that there are placeholder blocks
-   in the bat for them.
-this stuff will ensure reliability of input better. otherwise, its actually worth doing a repack
-directly after read, to ensure the above is probably acounted for, before subsequent writes possibly
-destroy things.
-=end
-
 		# the flush method is the main "save" method. all file contents are always
 		# written directly to the file by the RangesIO objects, all this method does
 		# is write out all the file meta data - dirents, allocation tables, file header
 		# etc.
+		#
+		# maybe add an option to zero the padding, and any remaining avail blocks in the
+		# allocation table.
+		#
+		# TODO: long and overly complex. simplify and test better. eg, perhaps move serialization
+		# of bbat to AllocationTable::Big. 
 		def flush
 			# update root dirent, and flatten dirent tree
 			@root.name = 'Root Entry'
@@ -197,8 +213,7 @@ destroy things.
 			@dirents = @root.flatten
 
 			# serialize the dirents using the bbat
-			RangesIOResizeable.open @bbat, @header.dirent_start do |io|
-				io.truncate 0
+			RangesIOResizeable.open @bbat, 'w', :first_block => @header.dirent_start do |io|
 				@dirents.each { |dirent| io.write dirent.to_s }
 				padding = (io.size / @bbat.block_size.to_f).ceil * @bbat.block_size - io.size
 				io.write 0.chr * padding
@@ -207,8 +222,7 @@ destroy things.
 
 			# serialize the sbat
 			# perhaps the blocks used by the sbat should be marked with BAT?
-			RangesIOResizeable.open @bbat, @header.sbat_start do |io|
-				io.truncate 0
+			RangesIOResizeable.open @bbat, 'w', :first_block => @header.sbat_start do |io|
 				io.write @sbat.to_s
 				@header.sbat_start = io.first_block
 				@header.num_sbat = @bbat.chain(@header.sbat_start).length
@@ -224,50 +238,82 @@ destroy things.
 				b == AllocationTable::BAT || b == AllocationTable::META_BAT ?
 					AllocationTable::AVAIL : b
 			end
-			io = RangesIOResizeable.new @bbat, AllocationTable::EOC
 	
 			# currently we use a loop. this could be better, but basically,
 			# the act of writing out the bat, itself requires blocks which get
 			# recorded in the bat.
+			#
+			# i'm sure that there'd be some simpler closed form solution to this. solve
+			# recursive func:
+			#
+			#   num_mbat_blocks = ceil(max((mbat_len - 109) * 4 / block_size, 0))
+			#   bbat_len = initial_bbat_len + num_mbat_blocks
+			#   mbat_len = ceil(bbat_len * 4 / block_size)
+			#
+			# the actual bbat allocation table is itself stored throughout the file, and that chain
+			# is stored in the initial blocks, and the mbat blocks.
+			num_mbat_blocks = 0
+			io = RangesIOResizeable.new @bbat, 'w', :first_block => AllocationTable::EOC
+			# truncate now, so that we can simplify size calcs - the mbat blocks will be appended in a
+			# contiguous chunk at the end.
+			# hmmm, i think this truncate should be matched with a truncate of the underlying io. if you
+			# delete a lot of stuff, and free up trailing blocks, the file size never shrinks. this can
+			# be fixed easily, add an io truncate
+			@bbat.truncate!
+			before = @io.size
+			@io.truncate @bbat.block_size * (@bbat.length + 1)
 			while true
-				bbat_data = @bbat.to_s
-				mbat_chain = @bbat.chain io.first_block
-				raise NotImplementedError, "don't handle writing out extra META_BAT blocks yet" if mbat_chain.length > 109
-				# so we can ignore meta blocks in this calculation:
-				break if io.size >= bbat_data.length # it shouldn't be bigger right?
-				# this may grow the bbat, depending on existing available blocks
-				io.truncate bbat_data.length
+				# get total bbat size. equivalent to @bbat.to_s.length, but for the factoring in of
+				# the mbat blocks. we can't just add the mbat blocks directly to the bbat, as as this iteration
+				# progresses, more blocks may be needed for the bat itself (if there are no more gaps), and the
+				# mbat must remain contiguous.
+				bbat_data_len = ((@bbat.length + num_mbat_blocks) * 4 / @bbat.block_size.to_f).ceil * @bbat.block_size
+				# now storing the excess mbat blocks also increases the size of the bbat:
+				new_num_mbat_blocks = ([bbat_data_len / @bbat.block_size - 109, 0].max * 4 / @bbat.block_size.to_f).ceil
+				if new_num_mbat_blocks != num_mbat_blocks
+					# need more space for the mbat.
+					num_mbat_blocks = new_num_mbat_blocks
+				elsif io.size != bbat_data_len
+					# need more space for the bat
+					# this may grow the bbat, depending on existing available blocks
+					io.truncate bbat_data_len
+				else
+					break
+				end
 			end
 
 			# now extract the info we want:
 			ranges = io.ranges
-			mbat_chain = @bbat.chain io.first_block
+			bbat_chain = @bbat.chain io.first_block
+			# the extra mbat data is a set of contiguous blocks at the end
 			io.close
-			mbat_chain.each { |b| @bbat[b] = AllocationTable::BAT }
-			@header.num_bat = mbat_chain.length
+			bbat_chain.each { |b| @bbat[b] = AllocationTable::BAT }
+			# tack on the mbat stuff
+			@header.mbat_start = @bbat.length # need to record this here before tacking on the mbat
+			@header.num_bat = bbat_chain.length
+			num_mbat_blocks.times { @bbat << AllocationTable::META_BAT }
 
 			# now finally write the bbat, using a not resizable io.
-			RangesIO.open(@io, ranges) { |io| io.write @bbat.to_s }
-
-			# this is the mbat
-			mbat_chain += [AllocationTable::AVAIL] * (109 - mbat_chain.length)
-			@header.mbat_start = AllocationTable::EOC
-			@header.num_mbat = 0
-
-=begin
-			# now that spanned a number of blocks:
-			mbat = (0...@header.num_bat).map { |i| i + base }
-			mbat += [AllocationTable::AVAIL] * (109 - mbat.length) if mbat.length < 109
-			header_mbat = mbat[0...109]
-			other_mbat_data = mbat[109..-1].pack 'L*'
-			@header.mbat_start = base + @header.num_bat
-			@header.num_mbat = (other_mbat_data.length / new_bbat.block_size.to_f).ceil
-			io.write other_mbat_data
-=end
+			# the mode here will be 'r', which allows write atm. 
+			RangesIO.open(@io, :ranges => ranges) { |io| io.write @bbat.to_s }
+
+			# this is the mbat. pad it out.
+			bbat_chain += [AllocationTable::AVAIL] * [109 - bbat_chain.length, 0].max
+			@header.num_mbat = num_mbat_blocks
+			if num_mbat_blocks == 0
+				@header.mbat_start = AllocationTable::EOC
+			else
+				# write out the mbat blocks now. first of all, where are they going to be?
+				mbat_data = bbat_chain[109..-1]
+				q = @bbat.block_size / 4
+				mbat_data += [AllocationTable::AVAIL] *((mbat_data.length / q.to_f).ceil * q - mbat_data.length)
+				ranges = @bbat.ranges((0...num_mbat_blocks).map { |i| @header.mbat_start + i })
+				RangesIO.open(@io, :ranges => ranges) { |io| io.write mbat_data.pack('L*') }
+			end
 
 			# now seek back and write the header out
 			@io.seek 0
-			@io.write @header.to_s + mbat_chain.pack('L*')
+			@io.write @header.to_s + bbat_chain[0, 109].pack('L*')
 			@io.flush
 		end
 
@@ -280,16 +326,17 @@ destroy things.
 			@dirents = [@root]
 			@root.idx = 0
 			@sb_file.close if @sb_file
-			@sb_file = RangesIOResizeable.new @bbat, AllocationTable::EOC
+			@sb_file = RangesIOResizeable.new @bbat, :first_block => AllocationTable::EOC
 			@sbat = AllocationTable::Small.new self
 			# throw everything else the hell away
 			@io.truncate 0
 		end
 
 		# could be useful with mis-behaving ole documents. or to just clean them up.
+		# FIXME: heard Tempfile is not binary on windows. check
 		def repack temp=:file
 			case temp
-			when :file; Tempfile.open 'w+', &method(:repack_using_io)
+			when :file; Tempfile.open 'ole-repack', &method(:repack_using_io)
 			when :mem;  StringIO.open(&method(:repack_using_io))
 			else raise ArgumentError, "unknown temp backing #{temp.inspect}"
 			end
@@ -299,7 +346,7 @@ destroy things.
 			@io.rewind
 			IO.copy @io, temp_io
 			clear
-			Storage.open temp_io, nil, @opts do |temp_ole|
+			Storage.open temp_io, nil, @params do |temp_ole|
 				#temp_ole.root.type = :dir
 				Dirent.copy temp_ole.root, root
 			end
@@ -428,6 +475,10 @@ destroy things.
 				temp.reverse
 			end
 
+			def truncate!
+				replace truncate
+			end
+
 			def to_s
 				table = truncate
 				# pad it out some
@@ -474,7 +525,7 @@ destroy things.
 			# quick shortcut. chain can be either a head (in which case the table is used to
 			# turn it into a chain), or a chain. it is converted to ranges, then to rangesio.
 			def open chain, size=nil, &block
-				RangesIO.open @io, ranges(chain, size), &block
+				RangesIO.open @io, :ranges => ranges(chain, size), &block
 			end
 
 			def read chain, size=nil
@@ -566,12 +617,15 @@ destroy things.
 		class RangesIOResizeable < RangesIO
 			attr_reader   :bat
 			attr_accessor :first_block
-			def initialize bat, first_block, size=nil
+			def initialize bat, mode='r', params={}
+				mode, params = 'r', mode if Hash === mode
+				first_block, size = params.values_at :first_block, :size
+				raise ArgumentError, 'must specify first_block' unless first_block
 				@bat = bat
 				self.first_block = first_block
-				# we know cache the blocks chain, for faster resizing.
+				# we now cache the blocks chain, for faster resizing.
 				@blocks = @bat.chain first_block
-				super @bat.io, @bat.ranges(@blocks, size)
+				super @bat.io, mode, :ranges => @bat.ranges(@blocks, size)
 			end
 
 			def truncate size
@@ -597,9 +651,10 @@ destroy things.
 		# between bats based on size, and updating the dirent.
 		class RangesIOMigrateable < RangesIOResizeable
 			attr_reader :dirent
-			def initialize dirent
+			def initialize dirent, mode='r'
 				@dirent = dirent
-				super @dirent.ole.bat_for_size(@dirent.size), @dirent.first_block, @dirent.size
+				super @dirent.ole.bat_for_size(@dirent.size), mode,
+					:first_block => @dirent.first_block, :size => @dirent.size
 			end
 
 			def truncate size
@@ -692,30 +747,30 @@ destroy things.
 			attr_accessor :children
 			attr_accessor :name
 			attr_reader :ole, :type, :create_time, :modify_time
-			def initialize ole, values=DEFAULT, opts={}
+			def initialize ole, values=DEFAULT, params={}
 				@ole = ole				
-				values, opts = DEFAULT, values if Hash === values
+				values, params = DEFAULT, values if Hash === values
 				values = values.unpack(PACK) if String === values
 				super(*values)
 
 				# extra parsing from the actual struct values
-				@name = opts[:name] || Types::FROM_UTF16.iconv(name_utf16[0...name_len].sub(/\x00\x00$/, ''))
-				@type = if opts[:type]
-					unless TYPE_MAP.values.include?(opts[:type])
-						raise ArgumentError, "unknown type #{opts[:type].inspect}"
+				@name = params[:name] || Types::Variant.load(Types::VT_LPWSTR, name_utf16[0...name_len].sub(/\x00\x00$/, ''))
+				@type = if params[:type]
+					unless TYPE_MAP.values.include?(params[:type])
+						raise ArgumentError, "unknown type #{params[:type].inspect}"
 					end
-					opts[:type]
+					params[:type]
 				else
 					TYPE_MAP[type_id] or raise FormatError, "unknown type_id #{type_id.inspect}"
 				end
 
 				# further extra type specific stuff
 				if file?
-					default_time = @ole.opts[:update_timestamps] ? Time.now : nil
+					default_time = @ole.params[:update_timestamps] ? Time.now : nil
 					@create_time ||= default_time
 					@modify_time ||= default_time
-					@create_time = Types.load_time(create_time_str) if create_time_str
-					@modify_time = Types.load_time(create_time_str) if modify_time_str
+					@create_time = Types::Variant.load(Types::VT_FILETIME, create_time_str) if create_time_str
+					@modify_time = Types::Variant.load(Types::VT_FILETIME, create_time_str) if modify_time_str
 					@children = nil
 				else
 					@create_time = nil
@@ -727,7 +782,7 @@ destroy things.
 
 			def open mode='r'
 				raise Errno::EISDIR unless file?
-				io = RangesIOMigrateable.new self
+				io = RangesIOMigrateable.new self, mode
 				# TODO work on the mode string stuff a bit more.
 				# maybe let the io object know about the mode, so it can refuse
 				# to work for read/write appropriately. maybe redefine all unusable
@@ -736,9 +791,12 @@ destroy things.
 				# i need to do 'a' etc.
 				case mode
 				when 'r', 'r+'
-					# as i don't enforce reading/writing, nothing changes here
+					# as i don't enforce reading/writing, nothing changes here. kind of
+					# need to enforce tt if i want modify times to work better.
+					@modify_time = Time.now if mode == 'r+'
 				when 'w'
-					io.truncate 0
+					@modify_time = Time.now
+					#io.truncate 0
 				else
 					raise NotImplementedError, "unsupported mode - #{mode.inspect}"
 				end
@@ -763,13 +821,14 @@ destroy things.
 				!file?
 			end
 
+			# maybe need some options regarding case sensitivity.
 			def / name
 				children.find { |child| name === child.name }
 			end
 
 			def [] idx
 				if String === idx
-					warn 'String form of Dirent#[] is deprecated'
+					#warn 'String form of Dirent#[] is deprecated'
 					self / idx
 				else
 					super
@@ -778,7 +837,7 @@ destroy things.
 
 			# move to ruby-msg. and remove from here
 			def time
-				warn 'Dirent#time is deprecated'
+				#warn 'Dirent#time is deprecated'
 				create_time || modify_time
 			end
 
@@ -813,7 +872,7 @@ destroy things.
 			end
 
 			def to_s
-				tmp = Types::TO_UTF16.iconv(name)
+				tmp = Types::Variant.dump(Types::VT_LPWSTR, name)
 				tmp = tmp[0, 62] if tmp.length > 62
 				tmp += 0.chr * 2
 				self.name_len = tmp.length
@@ -824,9 +883,12 @@ destroy things.
 				# note not dir?, so as not to override root's first_block
 				self.first_block = Dirent::EOT if type == :dir
 				if file?
-					if @ole.opts[:update_timestamps]
-						self.create_time_str = Types.save_time @create_time
-						self.modify_time_str = Types.save_time Time.now
+					# this is messed up. it changes the time stamps regardless of whether the file
+					# was actually touched. instead, any open call with a writeable mode, should update
+					# the modify time. create time would be set in new.
+					if @ole.params[:update_timestamps]
+						self.create_time_str = Types::Variant.dump Types::VT_FILETIME, @create_time
+						self.modify_time_str = Types::Variant.dump Types::VT_FILETIME, @modify_time
 					end
 				else
 					self.create_time_str = 0.chr * 8
@@ -850,16 +912,6 @@ destroy things.
 				str + '>'
 			end
 
-			# --------
-			# and for creation of a dirent. don't like the name. is it a file or a directory?
-			# assign to type later? io will be empty.
-			def new_child type
-				child = Dirent.new ole, :type => type
-				children << child
-				yield child if block_given?
-				child
-			end
-
 			def delete child
 				# remove from our child array, so that on reflatten and re-creation of @dirents, it will be gone
 				raise ArgumentError, "#{child.inspect} not a child of #{self.inspect}" unless @children.delete child
@@ -874,7 +926,9 @@ destroy things.
 				dst.name = src.name
 				if src.dir?
 					src.children.each do |src_child|
-						dst.new_child(src_child.type) { |dst_child| Dirent.copy src_child, dst_child }
+						dst_child = Dirent.new dst.ole, :type => src_child.type
+						dst.children << dst_child
+						Dirent.copy src_child, dst_child
 					end
 				else
 					src.open do |src_io|