ruby-msg 1.2.17

data/lib/ole/types.rb

@@ -0,0 +1,36 @@
+require 'iconv'
+require 'date'
+
+require 'ole/base'
+
+module Ole # :nodoc:
+	# FIXME
+	module Types
+		FROM_UTF16 = Iconv.new 'utf-8', 'utf-16le'
+		TO_UTF16   = Iconv.new 'utf-16le', 'utf-8'
+		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) * 1e-7 / 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
+
+		# 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
+	end
+end
+

data/lib/orderedhash.rb

@@ -0,0 +1,218 @@
+# = OrderedHash
+#
+# == Version
+#  1.2006.07.13 (change of the first number means Big Change)
+#
+# == Description
+#  Hash which preserves order of added items (like PHP array).
+#
+# == Usage
+#
+# (see examples directory under the ruby gems root directory)
+#
+#  require 'rubygems'
+#  require 'ordered_hash'
+#
+#  hsh = OrderedHash.new
+#  hsh['z'] = 1
+#  hsh['a'] = 2
+#  hsh['c'] = 3
+#  p hsh.keys     # ['z','a','c']
+#
+# == Source
+# http://simplypowerful.1984.cz/goodlibs/1.2006.07.13
+#
+# == Author
+#  jan molic (/mig/at_sign/1984/dot/cz/)
+#
+# == Thanks to
+#  Andrew Johnson for his suggestions and fixes of Hash[], merge, to_a, inspect and shift
+#  Desmond Dsouza for == fixes
+#
+# == Licence
+#  You can redistribute it and/or modify it under the same terms of Ruby's license;
+#  either the dual license version in 2003, or any later version.
+#
+
+class OrderedHash < Hash
+
+	attr_accessor :order
+
+	class << self
+
+		def [] *args
+			hsh = OrderedHash.new
+			if Hash === args[0]
+				hsh.replace args[0]
+			elsif (args.size % 2) != 0
+				raise ArgumentError, "odd number of elements for Hash"
+			else
+				hsh[args.shift] = args.shift while args.size > 0
+			end
+			hsh
+		end
+
+	end
+
+	def initialize(*a, &b)
+		super
+		@order = []
+	end
+
+	def store_only a,b
+		store a,b
+	end
+
+	alias orig_store store
+
+	def store a,b
+		@order.push a unless has_key? a
+		super a,b
+	end
+
+	alias []= store
+
+	def == hsh2
+		return hsh2==self if !hsh2.is_a?(OrderedHash)
+		return false if @order != hsh2.order
+		super hsh2
+	end
+
+	def clear
+		@order = []
+		super
+	end
+
+	def delete key
+		@order.delete key
+		super
+	end
+
+	def each_key
+		@order.each { |k| yield k }
+		self
+	end
+
+	def each_value
+		@order.each { |k| yield self[k] }
+		self
+	end
+
+	def each
+		@order.each { |k| yield k,self[k] }
+		self
+	end
+
+	alias each_pair each
+
+	def delete_if
+		@order.clone.each { |k|
+			delete k if yield
+		}
+		self
+	end
+
+	def values
+		ary = []
+		@order.each { |k| ary.push self[k] }
+		ary
+	end
+
+	def keys
+		@order
+	end
+
+	def invert
+		hsh2 = Hash.new
+		@order.each { |k| hsh2[self[k]] = k }
+		hsh2
+	end
+
+	def reject &block
+		self.dup.delete_if( &block )
+	end
+
+	def reject! &block
+		hsh2 = reject( &block )
+		self == hsh2 ? nil : hsh2
+	end
+
+	def replace hsh2
+		@order = hsh2.keys
+		super hsh2
+	end
+
+	def shift
+		key = @order.first
+		key ? [key,delete(key)] : super
+	end
+
+	def unshift k,v
+		unless self.include? k
+			@order.unshift k
+			orig_store(k,v)
+			true
+		else
+			false
+		end
+	end
+
+	def push k,v
+		unless self.include? k
+			@order.push k
+			orig_store(k,v)
+			true
+		else
+			false
+		end
+	end
+
+	def pop
+		key = @order.last
+		key ? [key,delete(key)] : nil
+	end
+
+	def first
+		self[@order.first]
+	end
+
+	def last
+		self[@order.last]
+	end
+
+	def to_a
+		ary = []
+		each { |k,v| ary << [k,v] }
+		ary
+	end
+
+	def to_s
+		self.to_a.to_s
+	end
+
+	def inspect
+		ary = []
+		each {|k,v| ary << k.inspect + "=>" + v.inspect}
+		'{' + ary.join(", ") + '}'
+	end
+
+	def update hsh2
+		hsh2.each { |k,v| self[k] = v }
+		self
+	end
+
+	alias :merge! update
+
+	def merge hsh2
+		self.dup update(hsh2)
+	end
+
+	def select
+		ary = []
+		each { |k,v| ary << [k,v] if yield k,v }
+		ary
+	end
+
+end
+
+#=end

data/lib/rtf.rb

@@ -0,0 +1,118 @@
+#! /usr/bin/ruby -w
+
+require 'stringio'
+
+# this file is pretty crap, its just to ensure there is always something readable if
+# there is an rtf only body, with no html encapsulation.
+
+module RTF
+	class Tokenizer
+		def self.process io
+			while true do
+				case c = io.getc
+				when ?{; yield :open_group
+				when ?}; yield :close_group
+				when ?\\
+					case c = io.getc
+					when ?{, ?}, ?\\; yield :text, c.chr
+					when ?'; yield :text, [io.read(2)].pack('H*')
+					when ?a..?z, ?A..?Z
+						# read control word
+						str = c.chr
+						str << c while c = io.read(1) and c =~ /[a-zA-Z]/
+						neg = 1
+						neg = -1 and c = io.read(1) if c == '-'
+						num = if c =~ /[0-9]/
+							num = c
+							num << c while c = io.read(1) and c =~ /[0-9]/
+							num.to_i * neg
+						end
+						raise "invalid rtf stream" if neg == -1 and !num # ???? \blahblah- some text
+						io.seek(-1, IO::SEEK_CUR) if c != ' '
+						yield :control_word, str, num
+					when nil
+						raise "invalid rtf stream" # \EOF
+					else
+						# other kind of control symbol
+						yield :control_symbol, c.chr
+					end
+				when nil
+					return
+				when ?\r, ?\n
+					# ignore
+				else yield :text, c.chr
+				end
+			end
+		end
+	end
+
+	class Converter
+		# crappy
+		def self.rtf2text str, format=:text
+			group = 0
+			text = ''
+			text << "<html>\n<body>" if format == :html
+			group_type = []
+			group_tags = []
+			RTF::Tokenizer.process(StringIO.new(str)) do |a, b, c|
+				add_text = ''
+				case a
+				when :open_group; group += 1; group_type[group] = nil; group_tags[group] = []
+				when :close_group; group_tags[group].reverse.each { |t| text << "</#{t}>" }; group -= 1;
+				when :control_word; # ignore
+					group_type[group] ||= b
+					# maybe change this to use utf8 where possible
+					add_text = if b == 'par' || b == 'line' || b == 'page'; "\n"
+					elsif b == 'tab' || b == 'cell'; "\t"
+					elsif b == 'endash' || b == 'emdash'; "-"
+					elsif b == 'emspace' || b == 'enspace' || b == 'qmspace'; " "
+					elsif b == 'ldblquote'; '"'
+					else ''
+					end
+					if b == 'b' || b == 'i' and format == :html
+						close = c == 0 ? '/' : ''
+						text << "<#{close}#{b}>"
+						if c == 0
+							group_tags[group].delete b
+						else
+							group_tags[group] << b
+						end
+					end
+					# lot of other ones belong in here.\
+=begin
+\bullet 	Bullet character.
+\lquote 	Left single quotation mark.
+\rquote 	Right single quotation mark.
+\ldblquote 	Left double quotation mark.
+\rdblquote
+=end
+				when :control_symbol; # ignore
+					 group_type[group] ||= b
+					add_text = ' ' if b == '~' # non-breakable space
+					add_text = '-' if b == '_' # non-breakable hypen
+				when :text
+					add_text = b if group <= 1 or group_type[group] == 'rtlch' && !group_type[0...group].include?('*')
+				end
+				if format == :html
+					text << add_text.gsub(/([<>&"'])/) do
+						ent = { '<' => 'lt', '>' => 'gt', '&' => 'amp', '"' => 'quot', "'" => 'apos' }[$1]
+						"&#{ent};"
+					end
+					text << '<br>' if add_text == "\n"
+				else
+					text << add_text
+				end
+			end
+			text << "</body>\n</html>\n" if format == :html
+			text
+		end
+	end
+end
+
+if $0 == __FILE__
+	#str = File.read('test.rtf')
+	str = YAML.load(open('rtfs.yaml'))[2]
+	#puts str
+	puts text
+end
+

data/lib/support.rb

@@ -0,0 +1,51 @@
+
+# 
+# A file with general support functions used by most files in the project.
+# 
+
+require 'logger'
+
+class File # :nodoc:
+	# for consistency with StringIO and others. makes more sense than forcing
+	# them to provide a #stat
+	def size
+		stat.size
+	end
+end
+
+class Symbol # :nodoc:
+	def to_proc
+		proc { |a| a.send self }
+	end
+end
+
+module Enumerable # :nodoc:
+	# 1.9 backport
+	def group_by
+		hash = Hash.new { |hash, key| hash[key] = [] }
+		each { |item| hash[yield(item)] << item }
+		hash
+	end
+
+	def sum initial=0
+		inject(initial) { |a, b| a + b }
+	end
+end
+
+class Logger # :nodoc:
+	# A helper method for creating <tt>Logger</tt>s 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
+

data/test/test_mime.rb

@@ -0,0 +1,22 @@
+#! /usr/bin/ruby -w
+
+TEST_DIR = File.dirname __FILE__
+$: << "#{TEST_DIR}/../lib"
+
+require 'test/unit'
+require 'mime'
+
+class TestMime < Test::Unit::TestCase
+	# test out the way it partitions a message into parts
+	def test_parsing_no_multipart
+		mime = Mime.new "Header1: Value1\r\nHeader2: Value2\r\n\r\nBody text."
+		assert_equal ['Value1'], mime.headers['Header1']
+		assert_equal 'Body text.', mime.body
+		assert_equal false, mime.multipart?
+		assert_equal nil, mime.parts
+		# we get round trip conversion. this is mostly fluke, as orderedhash hasn't been
+		# added yet
+		assert_equal "Header1: Value1\r\nHeader2: Value2\r\n\r\nBody text.", mime.to_s
+	end
+end
+

data/test/test_storage.rb

@@ -0,0 +1,139 @@
+#! /usr/bin/ruby -w
+
+TEST_DIR = File.dirname __FILE__
+$: << "#{TEST_DIR}/../lib"
+
+require 'test/unit'
+require 'ole/storage'
+require 'digest/sha1'
+require 'stringio'
+
+#
+# = TODO
+#
+# These tests could be a lot more complete.
+#
+
+class TestRangesIO < Test::Unit::TestCase
+	def setup
+		# why not :) ?
+		# repeats too
+		ranges = [100..200, 0..10, 100..150]
+		@io = RangesIO.new open("#{TEST_DIR}/test_storage.rb"), ranges, :close_parent => true
+	end
+
+	def teardown
+		@io.close
+	end
+
+	def test_basic
+		assert_equal 160, @io.size
+		# this will map to the start of the file:
+		@io.pos = 100
+		assert_equal '#! /usr/bi', @io.read(10)
+	end
+
+	# should test range_and_offset specifically
+
+	def test_reading
+		# test selection of initial range, offset within that range
+		pos = 100
+		@io.seek pos
+		# test advancing of pos properly, by...
+		chunked = (0...10).map { @io.read 10 }.join
+		# given the file is 160 long:
+		assert_equal 60, chunked.length
+		@io.seek pos
+		# comparing with a flat read
+		assert_equal chunked, @io.read(60)
+	end
+end
+
+# should test resizeable and migrateable IO.
+
+class TestStorageRead < Test::Unit::TestCase
+	def setup
+		@ole = Ole::Storage.open "#{TEST_DIR}/test_word_6.doc", 'rb'
+	end
+
+	def teardown
+		@ole.close
+	end
+
+	def test_header
+		# should have further header tests, testing the validation etc.
+		assert_equal 17,  @ole.header.to_a.length
+		assert_equal 117, @ole.header.dirent_start
+		assert_equal 1,   @ole.header.num_bat
+		assert_equal 1,   @ole.header.num_sbat
+		assert_equal 0,   @ole.header.num_mbat
+	end
+
+	def test_fat
+		# the fat block has all the numbers from 5..118 bar 117
+		bbat_table = [112] + ((5..118).to_a - [112, 117])
+		assert_equal bbat_table, @ole.bbat.table.reject { |i| i >= (1 << 32) - 3 }, 'bbat'
+		sbat_table = (1..43).to_a - [2, 3]
+		assert_equal sbat_table, @ole.sbat.table.reject { |i| i >= (1 << 32) - 3 }, 'sbat'
+	end
+
+	def test_directories
+		assert_equal 5, @ole.dirents.length, 'have all directories'
+		# a more complicated one would be good for this
+		assert_equal 4, @ole.root.children.length, 'properly nested directories'
+	end
+
+	def test_utf16_conversion
+		assert_equal 'Root Entry', @ole.root.name
+		assert_equal 'WordDocument', @ole.root.children[2].name
+	end
+
+	def test_data
+		# test the ole storage type
+		type = 'Microsoft Word 6.0-Dokument'
+		assert_equal type, @ole.root["\001CompObj"].read[/^.{32}([^\x00]+)/m, 1]
+		# i was actually not loading data correctly before, so carefully check everything here
+		hashes = [-482597081, 285782478, 134862598, -863988921]
+		assert_equal hashes, @ole.root.children.map { |child| child.read.hash }
+	end
+end
+
+class TestStorageWrite < Test::Unit::TestCase
+	def sha1 str
+		Digest::SHA1.hexdigest str
+	end
+	
+	# FIXME
+	# don't really want to lock down the actual internal api's yet. this will just
+	# ensure for the time being that #flush continues to work properly. need a host
+	# of checks involving writes that resize their file bigger/smaller, that resize
+	# the bats to more blocks, that resizes the sb_blocks, that has migration etc.
+	def test_write_hash
+		io = StringIO.open File.read("#{TEST_DIR}/test_word_6.doc")
+		assert_equal '9974e354def8471225f548f82b8d81c701221af7', sha1(io.string)
+		Ole::Storage.open(io) { }
+		assert_equal 'efa8cfaf833b30b1d1d9381771ddaafdfc95305c', sha1(io.string)
+		# add a repack test here
+		Ole::Storage.open io, &:repack
+		assert_equal 'c8bb9ccacf0aaad33677e1b2a661ee6e66a48b5a', sha1(io.string)
+	end
+
+	def test_plain_repack
+		io = StringIO.open File.read("#{TEST_DIR}/test_word_6.doc")
+		assert_equal '9974e354def8471225f548f82b8d81c701221af7', sha1(io.string)
+		Ole::Storage.open io, &:repack
+		# note equivalence to the above flush, repack, flush
+		assert_equal 'c8bb9ccacf0aaad33677e1b2a661ee6e66a48b5a', sha1(io.string)
+	end
+
+	def test_create_from_scratch_hash
+		io = StringIO.new
+		Ole::Storage.new(io) { }
+		assert_equal '6bb9d6c1cdf1656375e30991948d70c5fff63d57', sha1(io.string)
+		# more repack test, note invariance
+		Ole::Storage.open io, &:repack
+		assert_equal '6bb9d6c1cdf1656375e30991948d70c5fff63d57', sha1(io.string)
+	end
+end
+
+

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: ruby-msg
+version: !ruby/object:Gem::Version 
+  version: 1.2.17
+date: 2007-05-13 00:00:00 +10:00
+summary: Ruby Msg library.
+require_paths: 
+- lib
+email: aquasync@gmail.com
+homepage: http://code.google.com/p/ruby-msg
+rubyforge_project: 
+description: A library for reading Outlook msg files, and for converting them to RFC2822 emails.
+autorequire: msg
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Charles Lowe
+files: 
+- data/named_map.yaml
+- data/types.yaml
+- data/mapitags.yaml
+- Rakefile
+- README
+- FIXES
+- bin/msgtool
+- bin/oletool
+- lib/orderedhash.rb
+- lib/blah.rb
+- lib/mime-new.rb
+- lib/rtf.rb
+- lib/support.rb
+- lib/mime.rb
+- lib/msg.rb
+- lib/ole/types.rb
+- lib/ole/file_system.rb
+- lib/ole/storage.rb
+- lib/ole/io_helpers.rb
+- lib/ole/base.rb
+- lib/msg/rtf.rb
+- lib/msg/properties.rb
+- test/test_mime.rb
+- test/test_storage.rb
+- test/test_word_6.doc
+- test/test_word_95.doc
+- test/test_word_97.doc
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: 
+- msgtool
+- oletool
+extensions: []
+
+requirements: []
+
+dependencies: []
+