ruby-ole 1.2.6 → 1.2.7

data/lib/ole/types/property_set.rb

@@ -0,0 +1,165 @@
+require 'ole/types'
+require 'yaml'
+
+module Ole
+	module Types
+		#
+		# The PropertySet class currently supports readonly access to the properties
+		# serialized in "property set" streams, such as the file "\005SummaryInformation",
+		# in OLE files.
+		#
+		# Think it has its roots in MFC property set serialization.
+		#
+		# See http://poi.apache.org/hpsf/internals.html for details
+		#
+		class PropertySet
+			HEADER_SIZE = 28
+			HEADER_PACK = "vvVa#{Clsid::SIZE}V"
+			OS_MAP = {
+				0 => :win16,
+				1 => :mac,
+				2 => :win32,
+				0x20001 => :ooffice, # open office on linux...
+			}
+
+			# define a smattering of the property set guids. 
+			DATA = YAML.load_file(File.dirname(__FILE__) + '/../../../data/propids.yaml').
+				inject({}) { |hash, (key, value)| hash.update Clsid.parse(key) => value }
+
+			# create an inverted map of names to guid/key pairs
+			PROPERTY_MAP = DATA.inject({}) do |h1, (guid, data)|
+				data[1].inject(h1) { |h2, (id, name)| h2.update name => [guid, id] }
+			end
+
+			module Constants
+				DATA.each { |guid, (name, map)| const_set name, guid }
+			end
+
+			include Constants
+			include Enumerable
+
+			class Section
+				include Variant::Constants
+				include Enumerable
+
+				SIZE = Clsid::SIZE + 4
+				PACK = "a#{Clsid::SIZE}v"
+
+				attr_accessor :guid, :offset
+				attr_reader :length
+
+				def initialize str, property_set
+					@property_set = property_set
+					@guid, @offset = str.unpack PACK
+					self.guid = Clsid.load guid
+					load_header
+				end
+
+				def io
+					@property_set.io
+				end
+
+				def load_header
+					io.seek offset
+					@byte_size, @length = io.read(8).unpack 'V2'
+				end
+				
+				def [] key
+					each_raw do |id, property_offset|
+						return read_property(property_offset).last if key == id
+					end
+					nil
+				end
+				
+				def []= key, value
+					raise NotImplementedError, 'section writes not yet implemented'
+				end
+				
+				def each
+					each_raw do |id, property_offset|
+						yield id, read_property(property_offset).last
+					end
+				end
+
+			private
+
+				def each_raw
+					io.seek offset + 8
+					io.read(length * 8).scan(/.{8}/m).each { |str| yield(*str.unpack('V2')) }
+				end
+				
+				def read_property property_offset
+					io.seek offset + property_offset
+					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
+					[type, value]
+				end
+			end
+						
+			attr_reader :io, :signature, :unknown, :os, :guid, :sections
+			
+			def initialize io
+				@io = io
+				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
+			end
+
+			def load_header str
+				@signature, @unknown, @os_id, @guid, @num_sections = str.unpack HEADER_PACK
+				# should i check that unknown == 0? it usually is. so is the guid actually
+				@guid = Clsid.load @guid
+				@os = OS_MAP[@os_id] || Log.warn("unknown operating system id #{@os_id}")
+			end
+
+			def load_section_list str
+				@sections = str.scan(/.{#{Section::SIZE}}/m).map { |s| Section.new s, self }
+			end
+			
+			def [] key
+				pair = PROPERTY_MAP[key.to_s] or return nil
+				section = @sections.find { |s| s.guid == pair.first } or return nil
+				section[pair.last]
+			end
+			
+			def []= key, value
+				pair = PROPERTY_MAP[key.to_s] or return nil
+				section = @sections.find { |s| s.guid == pair.first } or return nil
+				section[pair.last] = value
+			end
+			
+			def method_missing name, *args, &block
+				if name.to_s =~ /(.*)=$/
+					return super unless args.length == 1
+					return super unless PROPERTY_MAP[$1]
+					self[$1] = args.first
+				else
+					return super unless args.length == 0
+					return super unless PROPERTY_MAP[name.to_s]
+					self[name]
+				end
+			end
+			
+			def each
+				@sections.each do |section|
+					next unless pair = DATA[section.guid]
+					map = pair.last
+					section.each do |id, value|
+						name = map[id] or next
+						yield name, value
+					end
+				end
+			end
+			
+			def to_h
+				inject({}) { |hash, (name, value)| hash.update name.to_sym => value }
+			end
+		end
+	end
+end

data/test/test_filesystem.rb

@@ -23,7 +23,7 @@
 TEST_DIR = File.dirname __FILE__
 $:.unshift "#{TEST_DIR}/../lib"
 
-require 'ole/file_system'
+require 'ole/storage/file_system'
 require 'test/unit'
 
 module ExtraAssertions
@@ -146,7 +146,6 @@ class OleFsNonmutatingTest < Test::Unit::TestCase
 		assert_equal(0, @ole.file.stat("dir2/dir21").size)
 	end
 
-=begin
 	def test_size?
 		assert_equal(nil, @ole.file.size?("notAFile"))
 		assert_equal(72, @ole.file.size?("file1"))
@@ -155,7 +154,6 @@ class OleFsNonmutatingTest < Test::Unit::TestCase
 		assert_equal(72, @ole.file.stat("file1").size?)
 		assert_equal(nil, @ole.file.stat("dir2/dir21").size?)
 	end
-=end
 
 	def test_file?
 		assert(@ole.file.file?("file1"))
@@ -563,6 +561,14 @@ class OleFsFileStatTest < Test::Unit::TestCase
 		assert_equal(64, @ole.file.stat("file1").blksize)
 	end
 
+	# an additional test i added for coverage. i've tried to make the inspect
+	# string on the ole stat match that of the regular one.
+	def test_inspect
+		expect = '#<Ole::Storage::FileClass::Stat ino=0, uid=0, size=72, rdev=0, nlink=1, dev=0, blocks=2, gid=0, ftype=file, blksize=64>'
+		# normalize them, as instance_variables order is undefined
+		normalize = proc { |s| s[/ (.*)>$/, 1].split(', ').sort.join(', ') }
+		assert_equal normalize[expect], normalize[@ole.file.stat('file1').inspect]
+	end
 end
 
 class OleFsFileMutatingTest < Test::Unit::TestCase
@@ -659,7 +665,7 @@ class OleFsFileMutatingTest < Test::Unit::TestCase
 
 end
 
-class ZipFsDirectoryTest < Test::Unit::TestCase
+class OleFsDirectoryTest < Test::Unit::TestCase
 	def setup
 		# we use an in memory copy of the file instead of the original
 		# file based.
@@ -807,13 +813,12 @@ class ZipFsDirectoryTest < Test::Unit::TestCase
 
 end
 
-=begin
-class ZipFsDirIteratorTest < Test::Unit::TestCase
+class OleFsDirIteratorTest < Test::Unit::TestCase
 	
 	FILENAME_ARRAY = [ "f1", "f2", "f3", "f4", "f5", "f6"  ]
 
 	def setup
-		@dirIt = ZipFileSystem::ZipFsDirIterator.new(FILENAME_ARRAY)
+		@dirIt = Ole::Storage::DirClass::Dir.new('/', FILENAME_ARRAY)
 	end
 
 	def test_close
@@ -872,4 +877,3 @@ end
 # Copyright (C) 2002, 2003 Thomas Sondergaard
 # rubyzip is free software; you can redistribute it and/or
 # modify it under the terms of the ruby license.
-=end

data/test/test_mbat.rb

@@ -3,8 +3,8 @@
 $: << File.dirname(__FILE__) + '/../lib'
 
 require 'test/unit'
-require 'ole/storage'
-require 'ole/file_system'
+require 'ole/storage/base'
+require 'ole/storage/file_system'
 require 'tempfile'
 
 class TestWriteMbat < Test::Unit::TestCase

data/test/test_meta_data.rb

@@ -0,0 +1,45 @@
+#! /usr/bin/ruby
+
+$: << File.dirname(__FILE__) + '/../lib'
+
+require 'test/unit'
+require 'ole/storage/base'
+require 'ole/storage/meta_data'
+require 'ole/storage/file_system'
+
+class TestMetaData < Test::Unit::TestCase
+	def test_meta_data
+		Ole::Storage.open File.dirname(__FILE__) + '/test.doc', 'rb' do |ole|
+			assert_equal 'Charles Lowe', ole.meta_data[:doc_author]
+			assert_equal 'Charles Lowe', ole.meta_data['doc_author']
+			assert_equal 'Charles Lowe', ole.meta_data.to_h[:doc_author]
+			assert_equal 'Title', ole.meta_data.doc_title
+			assert_equal 'MSWordDoc', ole.meta_data.file_format
+			assert_equal 'application/msword', ole.meta_data.mime_type
+			assert_raises NotImplementedError do
+				ole.meta_data[:doc_author] = 'New Author'
+			end
+		end
+	end
+	
+	# this tests the other ways of getting the mime_type, than using "\001CompObj",
+	# ie, relying on root clsid, and on the heuristics
+	def test_mime_type
+		ole = Ole::Storage.new StringIO.new
+		ole.root.clsid = Ole::Storage::MetaData::CLSID_EXCEL97.to_s
+		assert_equal nil, ole.meta_data.file_format
+		assert_equal 'application/vnd.ms-excel', ole.meta_data.mime_type
+		
+		ole.root.clsid = 0.chr * Ole::Types::Clsid::SIZE
+		assert_equal nil, ole.meta_data.file_format
+		assert_equal nil, ole.meta_data.mime_type
+		
+		ole.file.open('Book', 'w') { |f| }
+		assert_equal 'application/vnd.ms-excel', ole.meta_data.mime_type
+		ole.file.open('WordDocument', 'w') { |f| }
+		assert_equal 'application/msword', ole.meta_data.mime_type
+		ole.file.open('__properties_version1.0', 'w') { |f| }
+		assert_equal 'application/vnd.ms-outlook', ole.meta_data.mime_type
+	end
+end
+

data/test/test_property_set.rb

@@ -3,10 +3,9 @@
 $: << File.dirname(__FILE__) + '/../lib'
 
 require 'test/unit'
-require 'ole/storage'
-require 'ole/property_set'
+require 'ole/types/property_set'
 
-class TestTypes < Test::Unit::TestCase
+class TestPropertySet < Test::Unit::TestCase
 	include Ole::Types
 
 	def setup
@@ -25,16 +24,17 @@ class TestTypes < Test::Unit::TestCase
 		assert_equal 14, section.length
 		assert_equal 'f29f85e0-4ff9-1068-ab91-08002b27b3d9', section.guid.format
 		assert_equal PropertySet::FMTID_SummaryInformation, section.guid
-		assert_equal 'Charles Lowe', section.properties.assoc(4).last
-		# new named support
-		assert_equal 'Charles Lowe', section.doc_author
-	end
-	
-	def test_ole_storage_integration
-		Ole::Storage.open File.dirname(__FILE__) + '/test.doc', 'rb' do |ole|
-			assert_equal 'Charles Lowe', ole.summary_info.doc_author
-			assert_equal 'Title', ole.summary_info.doc_title
-		end
+		assert_equal 'Charles Lowe', section.to_a.assoc(4).last
+		assert_equal 'Charles Lowe', propset.doc_author
+		assert_equal 'Charles Lowe', propset.to_h[:doc_author]
+
+		# knows the difference between existent and non-existent properties
+		assert_raise(NoMethodError) { propset.non_existent_key }
+		assert_raise(NotImplementedError) { propset.doc_author = 'New Author'}
+		assert_raise(NoMethodError) { propset.non_existent_key = 'Value'}
+		
+		# a valid property that has no value in this property set
+		assert_equal nil, propset.security
 	end
 end
 

data/test/test_ranges_io.rb

@@ -96,5 +96,15 @@ class TestRangesIO < Test::Unit::TestCase
 		# write enough to overflow the file
 		assert_raises(IOError) { @io.write 'x' * 60 }
 	end
+	
+	def test_non_resizeable
+		# will try to truncate, which will fail
+		assert_raises NotImplementedError do
+			@io = RangesIO.new(StringIO.new, 'w', :ranges => [])
+		end
+		# will be fine
+		@io = RangesIONonResizeable.new(StringIO.new, 'w', :ranges => [])
+		assert_equal '#<IO::Mode wronly|creat>', @io.instance_variable_get(:@mode).inspect
+	end
 end
 

data/test/test_storage.rb

@@ -41,10 +41,6 @@ class TestStorageRead < Test::Unit::TestCase
 		@ole.close
 	end
 
-	def test_invalid
-		assert_raises(Ole::Storage::FormatError) { Ole::Storage.open StringIO.new(0.chr * 1024) }
-	end
-
 	def test_header
 		# should have further header tests, testing the validation etc.
 		assert_equal 17,  @ole.header.to_a.length
@@ -53,6 +49,60 @@ class TestStorageRead < Test::Unit::TestCase
 		assert_equal 1,   @ole.header.num_sbat
 		assert_equal 0,   @ole.header.num_mbat
 	end
+	
+	def test_new_without_explicit_mode
+		open "#{TEST_DIR}/test_word_6.doc", 'rb' do |f|
+			assert_equal false, Ole::Storage.new(f).writeable
+		end
+	end
+
+	def capture_warnings
+		@warn = []
+		outer_warn = @warn
+		old_log = Ole::Log
+		begin
+			old_verbose = $VERBOSE
+			begin
+				$VERBOSE = nil
+				Ole.const_set :Log, Object.new
+			ensure
+				$VERBOSE = old_verbose
+			end
+			(class << Ole::Log; self; end).send :define_method, :warn do |message|
+				outer_warn << message
+			end
+			yield
+		ensure
+			old_verbose = $VERBOSE
+			begin
+				$VERBOSE = nil
+				Ole.const_set :Log, Object.new
+			ensure
+				$VERBOSE = old_verbose
+			end
+		end
+	end
+
+	def test_invalid
+		assert_raises Ole::Storage::FormatError do
+			Ole::Storage.open StringIO.new(0.chr * 1024)
+		end
+		assert_raises Ole::Storage::FormatError do
+			Ole::Storage.open StringIO.new(Ole::Storage::Header::MAGIC + 0.chr * 1024)
+		end
+		capture_warnings do
+			head = Ole::Storage::Header.new
+			head.threshold = 1024
+			assert_raises NoMethodError do
+				Ole::Storage.open StringIO.new(head.to_s + 0.chr * 1024)
+			end
+		end
+		assert_equal ['may not be a valid OLE2 structured storage file'], @warn
+	end
+	
+	def test_inspect
+		assert_match(/#<Ole::Storage io=#<File:.*?test_word_6.doc> root=#<Dirent:"Root Entry">>/, @ole.inspect)
+	end
 
 	def test_fat
 		# the fat block has all the numbers from 5..118 bar 117
@@ -120,6 +170,36 @@ class TestStorageRead < Test::Unit::TestCase
 		# i was actually not loading data correctly before, so carefully check everything here
 		assert_equal expect, @ole.root.children.map { |child| child.read }
 	end
+
+	def test_dirent
+		dirent = @ole.root.children.first
+		assert_equal '#<Dirent:"\001Ole" size=20 data="\001\000\000\002\000...">', dirent.inspect
+		assert_equal '#<Dirent:"Root Entry">', @ole.root.inspect
+		
+		# exercise Dirent#[]. note that if you use a number, you get the Struct
+		# fields.
+		assert_equal dirent, @ole.root["\001Ole"]
+		assert_equal dirent.name_utf16, dirent[0]
+		assert_equal nil, @ole.root.time
+		
+		assert_equal @ole.root.children, @ole.root.to_enum(:each_child).to_a
+
+		dirent.open('r') { |f| assert_equal 2, f.first_block }
+		dirent.open('w') { |f| }
+		assert_raises Errno::EINVAL do
+			dirent.open('a') { |f| }
+		end
+	end
+
+	def test_delete
+		dirent = @ole.root.children.first
+		assert_raises(ArgumentError) { @ole.root.delete nil }
+		assert_equal [dirent], @ole.root.children & [dirent]
+		assert_equal 20, dirent.size
+		@ole.root.delete dirent
+		assert_equal [], @ole.root.children & [dirent]
+		assert_equal 0, dirent.size
+	end
 end
 
 class TestStorageWrite < Test::Unit::TestCase
@@ -157,6 +237,13 @@ class TestStorageWrite < Test::Unit::TestCase
 		Ole::Storage.open io, :update_timestamps => false, &:repack
 		# note equivalence to the above flush, repack, flush
 		assert_equal 'c8bb9ccacf0aaad33677e1b2a661ee6e66a48b5a', sha1(io.string)
+		# lets do it again using memory backing
+		Ole::Storage.open(io, :update_timestamps => false) { |ole| ole.repack :mem }
+		# note equivalence to the above flush, repack, flush
+		assert_equal 'c8bb9ccacf0aaad33677e1b2a661ee6e66a48b5a', sha1(io.string)
+		assert_raises ArgumentError do
+			Ole::Storage.open(io, :update_timestamps => false) { |ole| ole.repack :typo }
+		end
 	end
 
 	def test_create_from_scratch_hash