ruby-ole 1.2.2 → 1.2.3

data/lib/ole/support.rb

@@ -1,4 +1,3 @@
-
 # 
 # A file with general support functions used by most files in the project.
 # 
@@ -158,3 +157,83 @@ module RecursivelyEnumerable
 	protected :to_tree_helper
 end
 
+# can include File::Constants
+class IO
+	BINARY = 0x4 unless defined?(BINARY)
+
+	# nabbed from rubinius, and modified
+	def self.parse_mode mode
+		ret = 0
+
+		case mode[0]
+		when ?r; ret |= RDONLY
+		when ?w; ret |= WRONLY | CREAT | TRUNC
+		when ?a; ret |= WRONLY | CREAT | APPEND
+		else raise ArgumentError, "illegal access mode #{mode}"
+		end
+
+		(1...mode.length).each do |i|
+			case mode[i]
+			when ?+; ret = (ret & ~(RDONLY | WRONLY)) | RDWR
+			when ?b; ret |= BINARY
+			else raise ArgumentError, "illegal access mode #{mode}"
+			end
+		end
+	
+		ret
+	end
+
+	class Mode
+		NAMES = %w[rdonly wronly rdwr creat trunc append binary]
+
+		attr_reader :flags
+		def initialize flags
+			flags = IO.parse_mode flags.to_str if flags.respond_to? :to_str
+			raise ArgumentError, "invalid flags - #{flags.inspect}" unless Fixnum === flags
+			@flags = flags
+		end
+
+		def writeable?
+			#(@flags & IO::RDONLY) == 0
+			(@flags & 0x3) != IO::RDONLY
+		end
+
+		def readable?
+			(@flags & IO::WRONLY) == 0
+		end
+
+		def truncate?
+			(@flags & IO::TRUNC) != 0
+		end
+
+		def append?
+			(@flags & IO::APPEND) != 0
+		end
+
+		def create?
+			(@flags & IO::CREAT) != 0
+		end
+
+		def binary?
+			(@flags & IO::BINARY) != 0
+		end
+
+=begin
+		# revisit this
+		def apply io
+			if truncate?
+				io.truncate 0
+			elsif append?
+				io.seek IO::SEEK_END, 0
+			end
+		end
+=end
+
+		def inspect
+			names = NAMES.map { |name| name if (flags & IO.const_get(name.upcase)) != 0 }
+			names.unshift 'rdonly' if (flags & 0x3) == 0
+			"#<#{self.class} #{names.compact * '|'}>"
+		end
+	end
+end
+

data/lib/ole/types.rb

@@ -4,8 +4,120 @@ require 'date'
 require 'ole/base'
 
 module Ole # :nodoc:
-	# FIXME
+	#
+	# The Types module contains all the serialization and deserialization code for standard ole
+	# types.
+	#
+	# It also defines all the variant type constants, and symbolic names.
+	#
 	module Types
+		# for anything that we don't have serialization code for
+		class Data < String
+			def self.load str
+				new str
+			end
+			
+			def self.dump str
+				str.to_s
+			end
+		end
+
+		class Lpstr < Data
+		end
+
+		# for VT_LPWSTR
+		class Lpwstr < String
+			FROM_UTF16 = Iconv.new 'utf-8', 'utf-16le'
+			TO_UTF16   = Iconv.new 'utf-16le', 'utf-8'
+			
+			def self.load str
+				new FROM_UTF16.iconv(str)
+			end
+			
+			def self.dump str
+				TO_UTF16.iconv str
+			end
+		end
+
+		# for VT_FILETIME
+		class FileTime < DateTime
+			SIZE = 8
+			EPOCH = new 1601, 1, 1
+
+			# Create a +DateTime+ object from a struct +FILETIME+
+			# (http://msdn2.microsoft.com/en-us/library/ms724284.aspx).
+			#
+			# Converts +str+ to two 32 bit time values, comprising the high and low 32 bits of
+			# the 100's of nanoseconds since 1st january 1601 (Epoch).
+			def self.load str
+				low, high = str.to_s.unpack 'L2'
+				# we ignore these, without even warning about it
+				return nil if low == 0 and high == 0
+				# switched to rational, and fixed the off by 1 second error i sometimes got.
+				# time = EPOCH + (high * (1 << 32) + low) / 1e7 / 86400 rescue return
+				# use const_get to ensure we can return anything which subclasses this (VT_DATE?)
+				const_get('EPOCH') + Rational(high * (1 << 32) + low, 1e7.to_i * 86400) rescue return
+				# extra sanity check...
+				#unless (1800...2100) === time.year
+				#	Log.warn "ignoring unlikely time value #{time.to_s}"
+				#	return nil
+				#end
+				#time
+			end
+			
+			# +time+ should be able to be either a Time, Date, or DateTime.
+			def self.dump time
+				# i think i'll convert whatever i get to be a datetime, because of
+				# the covered range.
+				return 0.chr * SIZE unless time
+				time = time.send(:to_datetime) if Time === time
+				# don't bother to use const_get here
+				bignum = (time - EPOCH) * 86400 * 1e7.to_i
+				high, low = bignum.divmod 1 << 32
+				[low, high].pack 'L2'
+			end
+		end
+
+		# for VT_CLSID
+		# Unlike most of the other conversions, the Guid's are serialized/deserialized by actually
+		# doing nothing! (eg, _load & _dump are null ops)
+		# Rather, its just a string with a different inspect string, and it includes a
+		# helper method for creating a Guid from that readable form (#format).
+		class Clsid < String
+			SIZE = 16
+			UNPACK = 'L S S CC C6'
+
+			def self.load str
+				new str.to_s
+			end
+			
+			def self.dump guid
+				return 0.chr * SIZE unless guid
+				# allow use of plain strings in place of guids.
+				guid['-'] ? parse(guid) : guid
+			end
+			
+			def self.parse str
+				vals = str.scan(/[a-f\d]+/i).map(&:hex)
+				if vals.length == 5
+					# this is pretty ugly
+					vals[3] = ('%04x' % vals[3]).scan(/../).map(&:hex)
+					vals[4] = ('%012x' % vals[4]).scan(/../).map(&:hex)
+					guid = new vals.flatten.pack(UNPACK)
+					return guid unless guid.delete('{}') == str.downcase.delete('{}')
+				end
+				raise ArgumentError, 'invalid guid - %p' % str
+			end
+
+			def format
+				"%08x-%04x-%04x-%02x%02x-#{'%02x' * 6}" % unpack(UNPACK)
+			end
+			
+			def inspect
+				"#<#{self.class}:{#{format}}>"
+			end
+		end
+
 		#
 		# The OLE variant types, extracted from
 		# http://www.marin.clara.net/COM/variant_type_definitions.htm.
@@ -77,55 +189,44 @@ module Ole # :nodoc:
 				0xffff => 'VT_ILLEGAL'
 			}
 
+			CLASS_MAP = {
+				# haven't seen one of these. wonder if its same as FILETIME?
+				#'VT_DATE' => ?,
+				'VT_LPSTR' => Lpstr,
+				'VT_LPWSTR' => Lpwstr,
+				'VT_FILETIME' => FileTime,
+				'VT_CLSID' => Clsid
+			}
+
 			module Constants
 				NAMES.each { |num, name| const_set name, num }
 			end
+			
+			def self.load type, str
+				type = NAMES[type] or raise ArgumentError, 'unknown ole type - 0x%04x' % type
+				(CLASS_MAP[type] || Data).load str
+			end
+			
+			def self.dump type, variant
+				type = NAMES[type] or raise ArgumentError, 'unknown ole type - 0x%04x' % type
+				(CLASS_MAP[type] || Data).dump variant
+			end
 		end
 
 		include Variant::Constants
-
-		# the rest of this file is all a bit of adhoc marshal/unmarshal stuff
-
-		# for VT_LPWSTR
-		FROM_UTF16 = Iconv.new 'utf-8', 'utf-16le'
-		TO_UTF16   = Iconv.new 'utf-16le', 'utf-8'
-
-		# for VT_FILETIME
-		EPOCH = DateTime.parse '1601-01-01'
-		# Create a +DateTime+ object from a struct +FILETIME+
-		# (http://msdn2.microsoft.com/en-us/library/ms724284.aspx).
-		#
-		# Converts +str+ to two 32 bit time values, comprising the high and low 32 bits of
-		# the 100's of nanoseconds since 1st january 1601 (Epoch).
-		def self.load_time str
-			low, high = str.unpack 'L2'
-			# we ignore these, without even warning about it
-			return nil if low == 0 and high == 0
-			time = EPOCH + (high * (1 << 32) + low) / 1e7 / 86400 rescue return
-			# extra sanity check...
-			unless (1800...2100) === time.year
-				Log.warn "ignoring unlikely time value #{time.to_s}"
-				return nil
-			end
-			time
+		
+		# deprecated aliases, kept mostly for the benefit of ruby-msg, until
+		# i release a new version.
+		def self.load_guid str
+			Variant.load VT_CLSID, str
 		end
 
-		# +time+ should be able to be either a Time, Date, or DateTime.
-		def self.save_time time
-			# i think i'll convert whatever i get to be a datetime, because of
-			# the covered range.
-			return 0.chr * 8 unless time
-			time = time.send(:to_datetime) if Time === time
-			bignum = ((time - Ole::Types::EPOCH) * 86400 * 1e7.to_i)
-			high, low = bignum.divmod 1 << 32
-			[low, high].pack 'L2'
+		def self.load_time str
+			Variant.load VT_FILETIME, str
 		end
 
-		# for VT_CLSID
-		# Convert a binary guid into a plain string (will move to proper class later).
-		def self.load_guid str
-			"{%08x-%04x-%04x-%02x%02x-#{'%02x' * 6}}" % str.unpack('L S S CC C6')
-		end
+		FROM_UTF16 = Lpwstr::FROM_UTF16
+		TO_UTF16 = Lpwstr::TO_UTF16
 	end
 end
 

data/test/test_mbat.rb

@@ -0,0 +1,39 @@
+#! /usr/bin/ruby
+
+$: << File.dirname(__FILE__) + '/../lib'
+
+require 'test/unit'
+require 'ole/storage'
+require 'ole/file_system'
+require 'tempfile'
+
+class TestWriteMbat < Test::Unit::TestCase
+	def test_write_mbat
+		Tempfile.open 'myolefile' do |temp|
+			# this used to raise an error at flush time, due to failure to write the mbat
+			Ole::Storage.open temp do |ole|
+				# create a 10mb file
+				ole.file.open 'myfile', 'w' do |f|
+					s = 0.chr * 1_000_000
+					10.times { f.write s }
+				end
+			end
+
+			assert((10_000_000..10_100_000) === temp.size, 'check file size')
+
+			Ole::Storage.open temp do |ole|
+				assert_equal 10_000_000, ole.file.size('myfile')
+				compare = ole.bbat.truncate[(0...ole.bbat.length).find { |i| ole.bbat[i] > 50_000 }..-1]
+				c = Ole::Storage::AllocationTable
+				# 10_000_000 * 4 / 512 / 512 rounded up is 153. but then there is room needed to store the
+				# bat in the bat, and the mbat too. hence 154. 
+				expect = [c::EOC] * 2 + [c::BAT] * 154 + [c::META_BAT]
+				assert_equal expect, compare, 'allocation table structure'
+				# the sbat should be empty. in fact the file shouldn't exist at all, so the root's first
+				# block should be EOC
+				assert ole.sbat.empty?
+				assert_equal c::EOC, ole.root.first_block
+			end
+		end
+	end
+end

data/test/test_property_set.rb

@@ -0,0 +1,30 @@
+#! /usr/bin/ruby
+
+$: << File.dirname(__FILE__) + '/../lib'
+
+require 'test/unit'
+require 'ole/property_set'
+
+class TestTypes < Test::Unit::TestCase
+	include Ole::Types
+
+	def setup
+		@io = open File.dirname(__FILE__) + '/test_SummaryInformation'
+	end
+
+	def teardown
+		@io.close
+	end
+
+	def test_property_set
+		propset = PropertySet.new @io
+		assert_equal 1, propset.sections.length
+		section = propset.sections.first
+		assert_equal 14, section.length
+		assert_equal 'f29f85e0-4ff9-1068-ab91-08002b27b3d9', section.guid.format
+		assert_equal PropertySet::FMTID_SummaryInformation, section.guid
+		# i expect this null byte should have be stripped. need to fix the encoding functions.
+		assert_equal "Charles Lowe\000", section.properties.assoc(4).last
+	end
+end
+

data/test/test_ranges_io.rb

@@ -12,7 +12,7 @@ class TestRangesIO < Test::Unit::TestCase
 	def setup
 		# read from ourself, also using overlaps.
 		ranges = [100..200, 0..10, 100..150]
-		@io = RangesIO.new open("#{TEST_DIR}/test_ranges_io.rb"), ranges, :close_parent => true
+		@io = RangesIO.new open("#{TEST_DIR}/test_ranges_io.rb"), :ranges => ranges, :close_parent => true
 	end
 
 	def teardown
@@ -23,9 +23,9 @@ class TestRangesIO < Test::Unit::TestCase
 		# block form
 		f = open("#{TEST_DIR}/test_ranges_io.rb")
 		assert_equal false, f.closed?
-		RangesIO.open f, []
+		RangesIO.open f, :ranges => []
 		assert_equal false, f.closed?
-		RangesIO.open(f, [], :close_parent => true) {}
+		RangesIO.open(f, :ranges => [], :close_parent => true) {}
 		assert_equal true, f.closed?
 	end
 
@@ -81,7 +81,7 @@ class TestRangesIO < Test::Unit::TestCase
 
 	def test_write
 		str = File.read "#{TEST_DIR}/test_ranges_io.rb"
-		@io = RangesIO.new StringIO.new(str), @io.ranges
+		@io = RangesIO.new StringIO.new(str), :ranges => @io.ranges
 		assert_equal "io'\nrequir", str[100, 10]
 		@io.write 'testing testing'
 		assert_equal 'testing te', str[100, 10]

data/test/test_storage.rb

@@ -6,6 +6,7 @@ require 'test/unit'
 require 'ole/storage'
 require 'digest/sha1'
 require 'stringio'
+require 'tempfile'
 
 #
 # = TODO
@@ -88,7 +89,10 @@ class TestStorageWrite < Test::Unit::TestCase
 		io = StringIO.open File.read("#{TEST_DIR}/test_word_6.doc")
 		assert_equal '9974e354def8471225f548f82b8d81c701221af7', sha1(io.string)
 		Ole::Storage.open(io, :update_timestamps => false) { }
-		assert_equal 'efa8cfaf833b30b1d1d9381771ddaafdfc95305c', sha1(io.string)
+		# hash changed. used to be efa8cfaf833b30b1d1d9381771ddaafdfc95305c
+		# thats because i know truncate the io, and am probably removing some trailing allocated
+		# available blocks.
+		assert_equal 'a39e3c4041b8a893c753d50793af8d21ca8f0a86', sha1(io.string)
 		# add a repack test here
 		Ole::Storage.open io, :update_timestamps => false, &:repack
 		assert_equal 'c8bb9ccacf0aaad33677e1b2a661ee6e66a48b5a', sha1(io.string)

data/test/test_support.rb

@@ -25,7 +25,7 @@ class TestSupport < Test::Unit::TestCase
 		io = StringIO.new
 		log = Logger.new_with_callstack io
 		log.warn 'test'
-		expect = %r{^\[\d\d:\d\d:\d\d \./test/test_support\.rb:\d+:test_logger\]\nWARN   test$}
+		expect = %r{^\[\d\d:\d\d:\d\d .*?test_support\.rb:\d+:test_logger\]\nWARN   test$}
 		assert_match expect, io.string.chomp
 	end
 
@@ -46,6 +46,44 @@ class TestSupport < Test::Unit::TestCase
 	end
 end
 
+class TestIOMode < Test::Unit::TestCase
+	def mode s
+		IO::Mode.new s
+	end
+
+	def test_parse
+		assert_equal true,  mode('r+bbbbb').binary?
+		assert_equal false, mode('r+').binary?
+
+		assert_equal false, mode('r+').create?
+		assert_equal false, mode('r').create?
+		assert_equal true,  mode('wb').create?
+
+		assert_equal true,  mode('w').truncate?
+		assert_equal false, mode('r').truncate?
+		assert_equal false, mode('r+').truncate?
+
+		assert_equal true,  mode('r+').readable?
+		assert_equal true,  mode('r+').writeable?
+		assert_equal false, mode('r').writeable?
+		assert_equal false, mode('w').readable?
+
+		assert_equal true,  mode('a').append?
+		assert_equal false, mode('w+').append?
+	end
+
+	def test_invalid
+		assert_raises(ArgumentError) { mode 'rba' }
+		assert_raises(ArgumentError) { mode '+r' }
+	end
+	
+	def test_inspect
+		assert_equal '#<IO::Mode rdonly>', IO::Mode.new('r').inspect
+		assert_equal '#<IO::Mode rdwr|creat|trunc|binary>', IO::Mode.new('wb+').inspect
+		assert_equal '#<IO::Mode wronly|creat|append>', IO::Mode.new('a').inspect
+	end
+end
+
 class TestRecursivelyEnumerable < Test::Unit::TestCase
 	class Container
 		include RecursivelyEnumerable