ruby-ole 1.2.6 → 1.2.7

data/lib/ole/support.rb

@@ -99,6 +99,8 @@ module RecursivelyEnumerable
 		end
 	end
 
+	# don't think this is actually a proper breadth first recursion. only first
+	# level is breadth first.
 	def each_recursive_breadth_first(&block)
 		children = []
 		each_child do |child|
@@ -131,41 +133,35 @@ module RecursivelyEnumerable
 	# streams a "tree" form of the recursively enumerable structure to +io+, or
 	# return a string form instead if +io+ is not specified.
 	#
-	# mostly a debugging aid. can specify a different +method+ to call if desired,
-	# though it should return a single line string.
-	def to_tree io=nil, method=:inspect
-		unless io
-			to_tree io = StringIO.new
-			return io.string
-		end
-		io << "- #{send method}\n"
-		to_tree_helper io, method, '  '
-	end
-
-	def to_tree_helper io, method, prefix
-		# i need to know when i get to the last child. use delay to know
-		child = nil
-		each_child do |next_child|
-			if child
-				io << "#{prefix}|- #{child.send method}\n"
-				if child.respond_to? :to_tree_helper
-					child.to_tree_helper io, method, prefix + '|  '
+	# mostly a debugging aid. can specify a different block which will be called
+	# to provide the string form for each node.
+	def to_tree io='', &inspect
+		inspect ||= :inspect.to_proc
+		io << "- #{inspect[self]}\n"
+		recurse = proc do |node, prefix|
+			child = nil
+			node.each_child do |next_child|
+				if child
+					io << "#{prefix}|- #{inspect[child]}\n"
+					recurse.call child, prefix + '|  '
 				end
+				child = next_child
+			end if node.respond_to?(:each_child)
+			if child
+				io << "#{prefix}\\- #{inspect[child]}\n"
+				recurse.call child, prefix + '   '
 			end
-			child = next_child
-		end
-		return unless child
-		# child is the last child
-		io << "#{prefix}\\- #{child.send method}\n"
-		if child.respond_to? :to_tree_helper
-			child.to_tree_helper io, method, prefix + '   '
 		end
+		recurse.call self, '  '
+		io
 	end
-	protected :to_tree_helper
 end
 
 # can include File::Constants
 class IO
+	# this is for jruby
+	include File::Constants unless defined?(RDONLY)
+
 	# nabbed from rubinius, and modified
 	def self.parse_mode mode
 		ret = 0

data/lib/ole/types.rb

@@ -1,243 +1,2 @@
-require 'iconv'
-require 'date'
-
-require 'ole/base'
-
-module Ole # :nodoc:
-	#
-	# 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 < String
-			def self.load str
-				# not sure if its always there, but there is often a trailing
-				# null byte.
-				new str.chomp(0.chr)
-			end
-
-			def self.dump str
-				# do i need to append the null byte?
-				str.to_s
-			end
-		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).chomp(0.chr)
-			end
-			
-			def self.dump str
-				# need to append nulls?
-				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 'V2'
-				# 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 'V2'
-			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
-			PACK = 'V v v 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(PACK)
-					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(PACK)
-			end
-			
-			def inspect
-				"#<#{self.class}:{#{format}}>"
-			end
-		end
-
-		#
-		# The OLE variant types, extracted from
-		# http://www.marin.clara.net/COM/variant_type_definitions.htm.
-		#
-		# A subset is also in WIN32OLE::VARIANT, but its not cross platform (obviously).
-		#
-		# Use like:
-		#
-		#   p Ole::Types::Variant::NAMES[0x001f] => 'VT_LPWSTR'
-		#   p Ole::Types::VT_DATE # => 7
-		#
-		# The serialization / deserialization functions should be fixed to make it easier
-		# to work with. like
-		#
-		#   Ole::Types.from_str(VT_DATE, data) # and
-		#   Ole::Types.to_str(VT_DATE, data)
-		#
-		# Or similar, rather than having to do VT_* <=> ad hoc class name etc as it is
-		# currently.
-		#
-		module Variant
-			NAMES = {
-				0x0000 => 'VT_EMPTY',
-				0x0001 => 'VT_NULL',
-				0x0002 => 'VT_I2',
-				0x0003 => 'VT_I4',
-				0x0004 => 'VT_R4',
-				0x0005 => 'VT_R8',
-				0x0006 => 'VT_CY',
-				0x0007 => 'VT_DATE',
-				0x0008 => 'VT_BSTR',
-				0x0009 => 'VT_DISPATCH',
-				0x000a => 'VT_ERROR',
-				0x000b => 'VT_BOOL',
-				0x000c => 'VT_VARIANT',
-				0x000d => 'VT_UNKNOWN',
-				0x000e => 'VT_DECIMAL',
-				0x0010 => 'VT_I1',
-				0x0011 => 'VT_UI1',
-				0x0012 => 'VT_UI2',
-				0x0013 => 'VT_UI4',
-				0x0014 => 'VT_I8',
-				0x0015 => 'VT_UI8',
-				0x0016 => 'VT_INT',
-				0x0017 => 'VT_UINT',
-				0x0018 => 'VT_VOID',
-				0x0019 => 'VT_HRESULT',
-				0x001a => 'VT_PTR',
-				0x001b => 'VT_SAFEARRAY',
-				0x001c => 'VT_CARRAY',
-				0x001d => 'VT_USERDEFINED',
-				0x001e => 'VT_LPSTR',
-				0x001f => 'VT_LPWSTR',
-				0x0040 => 'VT_FILETIME',
-				0x0041 => 'VT_BLOB',
-				0x0042 => 'VT_STREAM',
-				0x0043 => 'VT_STORAGE',
-				0x0044 => 'VT_STREAMED_OBJECT',
-				0x0045 => 'VT_STORED_OBJECT',
-				0x0046 => 'VT_BLOB_OBJECT',
-				0x0047 => 'VT_CF',
-				0x0048 => 'VT_CLSID',
-				0x0fff => 'VT_ILLEGALMASKED',
-				0x0fff => 'VT_TYPEMASK',
-				0x1000 => 'VT_VECTOR',
-				0x2000 => 'VT_ARRAY',
-				0x4000 => 'VT_BYREF',
-				0x8000 => 'VT_RESERVED',
-				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
-		
-		# 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
-
-		def self.load_time str
-			Variant.load VT_FILETIME, str
-		end
-
-		FROM_UTF16 = Lpwstr::FROM_UTF16
-		TO_UTF16 = Lpwstr::TO_UTF16
-	end
-end
-
+require 'ole/types/base'
+require 'ole/types/property_set'

data/lib/ole/types/base.rb

@@ -0,0 +1,247 @@
+require 'iconv'
+require 'date'
+
+require 'ole/base'
+
+module Ole # :nodoc:
+	#
+	# 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 < String
+			def self.load str
+				# not sure if its always there, but there is often a trailing
+				# null byte.
+				new str.chomp(0.chr)
+			end
+
+			def self.dump str
+				# do i need to append the null byte?
+				str.to_s
+			end
+		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).chomp(0.chr)
+			end
+			
+			def self.dump str
+				# need to append nulls?
+				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 'V2'
+				# 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 'V2'
+			end
+			
+			def inspect
+				"#<#{self.class} #{to_s}>"
+			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
+			PACK = 'V v v 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(PACK)
+					return guid if guid.format.delete('{}') == str.downcase.delete('{}')
+				end
+				raise ArgumentError, 'invalid guid - %p' % str
+			end
+
+			def format
+				"%08x-%04x-%04x-%02x%02x-#{'%02x' * 6}" % unpack(PACK)
+			end
+			
+			def inspect
+				"#<#{self.class}:{#{format}}>"
+			end
+		end
+
+		#
+		# The OLE variant types, extracted from
+		# http://www.marin.clara.net/COM/variant_type_definitions.htm.
+		#
+		# A subset is also in WIN32OLE::VARIANT, but its not cross platform (obviously).
+		#
+		# Use like:
+		#
+		#   p Ole::Types::Variant::NAMES[0x001f] => 'VT_LPWSTR'
+		#   p Ole::Types::VT_DATE # => 7
+		#
+		# The serialization / deserialization functions should be fixed to make it easier
+		# to work with. like
+		#
+		#   Ole::Types.from_str(VT_DATE, data) # and
+		#   Ole::Types.to_str(VT_DATE, data)
+		#
+		# Or similar, rather than having to do VT_* <=> ad hoc class name etc as it is
+		# currently.
+		#
+		module Variant
+			NAMES = {
+				0x0000 => 'VT_EMPTY',
+				0x0001 => 'VT_NULL',
+				0x0002 => 'VT_I2',
+				0x0003 => 'VT_I4',
+				0x0004 => 'VT_R4',
+				0x0005 => 'VT_R8',
+				0x0006 => 'VT_CY',
+				0x0007 => 'VT_DATE',
+				0x0008 => 'VT_BSTR',
+				0x0009 => 'VT_DISPATCH',
+				0x000a => 'VT_ERROR',
+				0x000b => 'VT_BOOL',
+				0x000c => 'VT_VARIANT',
+				0x000d => 'VT_UNKNOWN',
+				0x000e => 'VT_DECIMAL',
+				0x0010 => 'VT_I1',
+				0x0011 => 'VT_UI1',
+				0x0012 => 'VT_UI2',
+				0x0013 => 'VT_UI4',
+				0x0014 => 'VT_I8',
+				0x0015 => 'VT_UI8',
+				0x0016 => 'VT_INT',
+				0x0017 => 'VT_UINT',
+				0x0018 => 'VT_VOID',
+				0x0019 => 'VT_HRESULT',
+				0x001a => 'VT_PTR',
+				0x001b => 'VT_SAFEARRAY',
+				0x001c => 'VT_CARRAY',
+				0x001d => 'VT_USERDEFINED',
+				0x001e => 'VT_LPSTR',
+				0x001f => 'VT_LPWSTR',
+				0x0040 => 'VT_FILETIME',
+				0x0041 => 'VT_BLOB',
+				0x0042 => 'VT_STREAM',
+				0x0043 => 'VT_STORAGE',
+				0x0044 => 'VT_STREAMED_OBJECT',
+				0x0045 => 'VT_STORED_OBJECT',
+				0x0046 => 'VT_BLOB_OBJECT',
+				0x0047 => 'VT_CF',
+				0x0048 => 'VT_CLSID',
+				0x0fff => 'VT_ILLEGALMASKED',
+				0x0fff => 'VT_TYPEMASK',
+				0x1000 => 'VT_VECTOR',
+				0x2000 => 'VT_ARRAY',
+				0x4000 => 'VT_BYREF',
+				0x8000 => 'VT_RESERVED',
+				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
+		
+		# 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
+
+		def self.load_time str
+			Variant.load VT_FILETIME, str
+		end
+
+		FROM_UTF16 = Lpwstr::FROM_UTF16
+		TO_UTF16 = Lpwstr::TO_UTF16
+	end
+end
+