keeguon-ruby-ole 1.2.11.7

data/lib/ole/storage/version.rb

@@ -0,0 +1,8 @@
+# encoding: ASCII-8BIT
+
+module Ole # :nodoc:
+	class Storage
+		VERSION = '1.2.11.7'
+	end
+end
+

data/lib/ole/support.rb

@@ -0,0 +1,248 @@
+# encoding: ASCII-8BIT
+
+# 
+# A file with general support functions used by most files in the project.
+# 
+# These are the only methods added to other classes.
+# 
+
+require 'logger'
+require 'stringio'
+require 'enumerator'
+
+class String # :nodoc:
+	def each_chunk size
+		(length / size.to_f).ceil.times { |i| yield self[i * size, size] }
+	end
+end
+
+class File # :nodoc:
+	# for interface consistency with StringIO etc (rather than adding #stat
+	# to them). used by RangesIO.
+	unless File.method_defined?(:size) or (RUBY_PLATFORM =~ /java/).nil?
+		def size
+			stat.size
+		end
+	end
+end
+
+class Symbol # :nodoc:
+	unless Symbol.method_defined?(:to_proc)
+		def to_proc
+			Proc.new { |*args| args.shift.__send__(self, *args) }
+		end
+	end
+end
+
+module Enumerable # :nodoc:
+	unless [].respond_to? :group_by
+		# 1.9 backport
+		def group_by
+			hash = Hash.new { |h, key| h[key] = [] }
+			each { |item| hash[yield(item)] << item }
+			hash
+		end
+	end
+
+	unless [].respond_to? :sum
+		def sum initial=0
+			inject(initial) { |a, b| a + b }
+		end
+	end
+end
+
+# move to support?
+class IO # :nodoc:
+	# Copy data from IO-like object +src+, to +dst+
+	def self.copy src, dst
+		until src.eof?
+			buf = src.read(4096)
+			dst.write buf
+		end
+	end
+end
+
+class Logger # :nodoc:
+	# A helper method for creating a +Logger+ which produce call stack
+	# in their output
+	def self.new_with_callstack logdev=STDERR
+		log = Logger.new logdev
+		log.level = WARN
+		log.formatter = proc do |severity, time, progname, msg|
+			# find where we were called from, in our code
+			callstack = caller.dup
+			callstack.shift while callstack.first =~ /\/logger\.rb:\d+:in/
+			from = callstack.first.sub(/:in `(.*?)'/, ":\\1")
+			"[%s %s]\n%-7s%s\n" % [time.strftime('%H:%M:%S'), from, severity, msg.to_s]
+		end
+		log
+	end
+end
+
+# Include this module into a class that defines #each_child. It should
+# maybe use #each instead, but its easier to be more specific, and use
+# an alias.
+#
+# I don't want to force the class to cache children (eg where children
+# are loaded on request in pst), because that forces the whole tree to
+# be loaded. So, the methods should only call #each_child once, and 
+# breadth first iteration holds its own copy of the children around.
+#
+# Main methods are #recursive, and #to_tree
+module RecursivelyEnumerable # :nodoc:
+	def each_recursive_depth_first(&block)
+		each_child do |child|
+			yield child
+			if child.respond_to? :each_recursive_depth_first
+				child.each_recursive_depth_first(&block)
+			end
+		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|
+			children << child if child.respond_to? :each_recursive_breadth_first
+			yield child
+		end
+		children.each { |child| child.each_recursive_breadth_first(&block) }
+	end
+
+	def each_recursive mode=:depth_first, &block
+		# we always actually yield ourself (the tree root) before recursing
+		yield self
+		send "each_recursive_#{mode}", &block
+	end
+
+	# the idea of this function, is to allow use of regular Enumerable methods
+	# in a recursive fashion. eg:
+	#
+	#   # just looks at top level children
+	#   root.find { |child| child.some_condition? }
+	#   # recurse into all children getting non-folders, breadth first
+	#   root.recursive(:breadth_first).select { |child| !child.folder? }
+	#   # just get everything
+	#   items = root.recursive.to_a
+	#
+	def recursive mode=:depth_first
+		to_enum(:each_recursive, mode)
+	end
+
+	# 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 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
+		end
+		recurse.call self, '  '
+		io
+	end
+end
+
+module Ole
+	class IOMode
+		# ruby 1.9 defines binary as 0, which isn't very helpful.
+		# its 4 in rubinius. no longer using
+		#
+		#   BINARY = 0x4 unless defined?(BINARY)
+		#
+		# for that reason, have my own constants module here
+		module Constants
+			include File::Constants
+			BINARY = 0x4
+		end
+		
+		include Constants
+		NAMES = %w[rdonly wronly rdwr creat trunc append binary]
+
+		# nabbed from rubinius, and modified
+		def self.parse_mode mode
+			ret = 0
+
+			case mode[0, 1]
+			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, 1]
+				when '+'; ret = (ret & ~(RDONLY | WRONLY)) | RDWR
+				when 'b'; ret |= BINARY
+				else raise ArgumentError, "illegal access mode #{mode}"
+				end
+			end
+
+			ret
+		end
+
+		attr_reader :flags
+		def initialize flags
+			flags = self.class.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 & RDONLY) == 0
+			(@flags & 0x3) != RDONLY
+		end
+
+		def readable?
+			(@flags & WRONLY) == 0
+		end
+
+		def truncate?
+			(@flags & TRUNC) != 0
+		end
+
+		def append?
+			(@flags & APPEND) != 0
+		end
+
+		def create?
+			(@flags & CREAT) != 0
+		end
+
+		def binary?
+			(@flags & 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 & IOMode.const_get(name.upcase)) != 0 }
+			names.unshift 'rdonly' if (flags & 0x3) == 0
+			"#<#{self.class} #{names.compact * '|'}>"
+		end
+	end
+end
+

data/lib/ole/types.rb

@@ -0,0 +1,2 @@
+require 'ole/types/base'
+require 'ole/types/property_set'

data/lib/ole/types/base.rb

@@ -0,0 +1,314 @@
+# encoding: ASCII-8BIT
+
+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
+
+		if ''.respond_to? :encode
+			# NOTE: only here in the interim to preserve behaviour of
+			# FROM/TO_UTF16 constants for ruby-msg. 
+			class Iconv # :nodoc:
+				def initialize(to, from)
+					@to, @from = to, from
+				end
+
+				def iconv(str)
+					str.encode(@to, @from)
+				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 str.encode(Encoding::UTF_8, Encoding::UTF_16LE).chomp(0.chr)
+				end
+
+				def self.dump str
+					# need to append nulls?
+					data = str.encode(Encoding::UTF_16LE)
+					# not sure if this is the recommended way to do it, but I want to treat
+					# the resulting utf16 data as regular bytes, not characters.
+					data.force_encoding Encoding::ASCII_8BIT
+					data
+				end
+			end
+		else
+			require 'iconv'
+
+			# 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
+		end
+
+		# for VT_FILETIME
+		class FileTime < DateTime
+			SIZE = 8
+
+			# DateTime.new is slow... faster version for FileTime
+			def self.new year, month, day, hour=0, min=0, sec=0
+				# DateTime will remove leap and leap-leap seconds
+				sec = 59 if sec > 59
+				if month <= 2
+					month += 12
+					year  -= 1
+				end
+				y   = year + 4800
+				m   = month - 3
+				jd  = day + (153 * m + 2).div(5) + 365 * y + y.div(4) - y.div(100) + y.div(400) - 32045
+				fr  = hour / 24.0 + min / 1440.0 + sec / 86400.0
+				# new! was actually new0 in older versions of ruby (<=1.8.4?)
+				# see issue #4.
+				msg = respond_to?(:new!) ? :new! : :new0
+				send msg, jd + fr - 0.5, 0, ITALY
+			end if respond_to?(:new!) || respond_to?(:new0)
+
+			def self.from_time time
+				new(*time.to_a[0, 6].reverse)
+			end
+
+			def self.now
+				from_time Time.now
+			end
+
+			EPOCH = new 1601, 1, 1
+
+			#def initialize year, month, day, hour, min, sec
+
+			# 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
+				# the + 0.00001 here stinks a bit...
+				seconds = (high * (1 << 32) + low) / 1e7 + 0.00001
+				obj = EPOCH + seconds / 86400 rescue return
+				# work around home_run not preserving derived class
+				obj = new! obj.jd + obj.day_fraction - 0.5, 0, ITALY unless FileTime === obj
+				obj
+			end
+
+			# +time+ should be able to be either a Time, Date, or DateTime.
+			def self.dump time
+				return 0.chr * SIZE unless time
+				# convert whatever is given to be a datetime, to handle the large range
+				case time
+				when Date # this includes DateTime & FileTime
+				when Time
+					time = from_time time
+				else
+					raise ArgumentError, 'unknown time argument - %p' % [time]
+				end
+				# round to milliseconds (throwing away nanosecond precision) to
+				# compensate for using Float-based DateTime
+				nanoseconds = ((time - EPOCH).to_f * 864000000).round * 1000
+				high, low = nanoseconds.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
+