ruby-msg-nx 0.3.0

data/data/named_map.yaml

@@ -0,0 +1,114 @@
+# this file provides for the mapping of the keys of named properties
+# to symbolic names (as opposed to mapitags.yaml, which is currently
+# in a different format, has a different source, and is only fixed
+# code properties)
+#
+# essentially the symbols are slightly munged versions of the names
+# given to these properties by CDO, or Outlook's object model.
+# it was parsed out of cdo10.htm, and neatened up a bit.
+#
+# interestingly, despite having separate guids, the codes are picked not to
+# clash. further the names themselves have only 3 clashes in all the below.
+{
+[0x8005, PSETID_Address]: file_under,
+[0x8017, PSETID_Address]: last_name_and_first_name,
+[0x8018, PSETID_Address]: company_and_full_name,
+[0x8019, PSETID_Address]: full_name_and_company,
+[0x801a, PSETID_Address]: home_address,
+[0x801b, PSETID_Address]: business_address,
+[0x801c, PSETID_Address]: other_address,
+[0x8022, PSETID_Address]: selected_address,
+[0x802b, PSETID_Address]: web_page,
+[0x802c, PSETID_Address]: yomi_first_name,
+[0x802d, PSETID_Address]: yomi_last_name,
+[0x802e, PSETID_Address]: yomi_company_name,
+[0x8030, PSETID_Address]: last_first_no_space,
+[0x8031, PSETID_Address]: last_first_space_only,
+[0x8032, PSETID_Address]: company_last_first_no_space,
+[0x8033, PSETID_Address]: company_last_first_space_only,
+[0x8034, PSETID_Address]: last_first_no_space_company,
+[0x8035, PSETID_Address]: last_first_space_only_company,
+[0x8036, PSETID_Address]: last_first_and_suffix,
+[0x8045, PSETID_Address]: business_address_street,
+[0x8046, PSETID_Address]: business_address_city,
+[0x8047, PSETID_Address]: business_address_state,
+[0x8048, PSETID_Address]: business_address_postal_code,
+[0x8049, PSETID_Address]: business_address_country,
+[0x804a, PSETID_Address]: business_address_post_office_box,
+[0x804f, PSETID_Address]: user_field1,
+[0x8050, PSETID_Address]: user_field2,
+[0x8051, PSETID_Address]: user_field3,
+[0x8052, PSETID_Address]: user_field4,
+[0x8062, PSETID_Address]: imaddress,
+[0x8082, PSETID_Address]: email_addr_type,
+[0x8083, PSETID_Address]: email_email_address,
+[0x8084, PSETID_Address]: email_original_display_name,
+[0x8085, PSETID_Address]: email_original_entry_id,
+[0x8092, PSETID_Address]: email2_addr_type,
+[0x8093, PSETID_Address]: email2_email_address,
+[0x8094, PSETID_Address]: email2_original_display_name,
+[0x8095, PSETID_Address]: email2_original_entry_id,
+[0x80a2, PSETID_Address]: email3_addr_type,
+[0x80a3, PSETID_Address]: email3_email_address,
+[0x80a4, PSETID_Address]: email3_original_display_name,
+[0x80a5, PSETID_Address]: email3_original_entry_id,
+[0x80d8, PSETID_Address]: internet_free_busy_address,
+[0x8101, PSETID_Task]: status,
+[0x8102, PSETID_Task]: percent_complete,
+[0x8103, PSETID_Task]: team_task,
+[0x8104, PSETID_Task]: start_date,
+[0x8105, PSETID_Task]: due_date,
+[0x8106, PSETID_Task]: duration,
+[0x810f, PSETID_Task]: date_completed,
+[0x8110, PSETID_Task]: actual_work,
+[0x8111, PSETID_Task]: total_work,
+[0x811c, PSETID_Task]: complete,
+[0x811f, PSETID_Task]: owner,
+[0x8126, PSETID_Task]: is_recurring,
+[0x8205, PSETID_Appointment]: busy_status,
+[0x8208, PSETID_Appointment]: location,
+[0x820d, PSETID_Appointment]: start_date,
+[0x820e, PSETID_Appointment]: end_date,
+[0x8213, PSETID_Appointment]: duration,
+[0x8214, PSETID_Appointment]: colors,
+[0x8216, PSETID_Appointment]: recurrence_state,
+[0x8218, PSETID_Appointment]: response_status,
+[0x8222, PSETID_Appointment]: reply_time,
+[0x8223, PSETID_Appointment]: is_recurring,
+[0x822e, PSETID_Appointment]: organizer,
+[0x8231, PSETID_Appointment]: recurrence_type,
+[0x8232, PSETID_Appointment]: recurrence_pattern,
+# also had CdoPR_FLAG_DUE_BY, when applied to messages. i don't currently
+# use message class specific names
+[0x8502, PSETID_Common]: reminder_time,
+[0x8503, PSETID_Common]: reminder_set,
+[0x8516, PSETID_Common]: common_start,
+[0x8517, PSETID_Common]: common_end,
+[0x851c, PSETID_Common]: reminder_override,
+[0x851e, PSETID_Common]: reminder_sound,
+[0x851f, PSETID_Common]: reminder_file,
+# this one only listed as CdoPR_FLAG_TEXT. maybe should be
+# reminder_text
+[0x8530, PSETID_Common]: flag_text,
+[0x8534, PSETID_Common]: mileage,
+[0x8535, PSETID_Common]: billing_information,
+[0x8539, PSETID_Common]: companies,
+[0x853a, PSETID_Common]: contact_names,
+# had CdoPR_FLAG_DUE_BY_NEXT for this one also
+[0x8560, PSETID_Common]: reminder_next_time,
+[0x8700, PSETID_Log]: entry,
+[0x8704, PSETID_Log]: start_date,
+[0x8705, PSETID_Log]: start_time,
+[0x8706, PSETID_Log]: start,
+[0x8707, PSETID_Log]: duration,
+[0x8708, PSETID_Log]: end,
+[0x870e, PSETID_Log]: doc_printed,
+[0x870f, PSETID_Log]: doc_saved,
+[0x8710, PSETID_Log]: doc_routed,
+[0x8711, PSETID_Log]: doc_posted,
+[0x8712, PSETID_Log]: entry_type,
+[0x8b00, PSETID_Note]: color,
+[0x8b02, PSETID_Note]: width,
+[0x8b03, PSETID_Note]: height,
+["Keywords", PS_PUBLIC_STRINGS]: categories
+}

data/data/types.yaml

@@ -0,0 +1,15 @@
+---
+# grep ' PT_' mapitags.yaml | sort -u > types.yaml
+- PT_BINARY
+- PT_BOOLEAN
+- PT_CLSID
+- PT_I8
+- PT_LONG
+- PT_MV_BINARY
+- PT_MV_LONG
+- PT_MV_TSTRING
+- PT_OBJECT
+- PT_SHORT
+- PT_STRING8
+- PT_SYSTIME
+- PT_TSTRING

data/lib/mapi/base.rb

@@ -0,0 +1,104 @@
+module Mapi
+	#
+	# Mapi::Item is the base class used for all mapi objects, and is purely a
+	# property set container
+	#
+	class Item
+		attr_reader :properties
+		alias props properties
+
+		# +properties+ should be a PropertySet instance.
+		def initialize properties
+			@properties = properties
+		end
+	end
+
+	# a general attachment class. is subclassed by Msg and Pst attachment classes
+	class Attachment < Item
+		def filename
+			props.attach_long_filename || props.attach_filename
+		end
+
+		def data
+			@embedded_msg || @embedded_ole || props.attach_data
+		end
+
+		# with new stream work, its possible to not have the whole thing in memory at one time,
+		# just to save an attachment
+		#
+		# a = msg.attachments.first
+		# a.save open(File.basename(a.filename || 'attachment'), 'wb') 
+		def save io
+			raise "can only save binary data blobs, not ole dirs" if @embedded_ole
+			data.rewind
+			io << data.read(8192) until data.eof?
+		end
+
+		def inspect
+			"#<#{self.class.to_s[/\w+$/]}" +
+				(filename ? " filename=#{filename.inspect}" : '') +
+				(@embedded_ole ? " embedded_type=#{@embedded_ole.embedded_type.inspect}" : '') + ">"
+		end
+	end
+	
+	class Recipient < Item
+		# some kind of best effort guess for converting to standard mime style format.
+		# there are some rules for encoding non 7bit stuff in mail headers. should obey
+		# that here, as these strings could be unicode
+		# email_address will be an EX:/ address (X.400?), unless external recipient. the
+		# other two we try first.
+		# consider using entry id for this too.
+		def name
+			name = props.transmittable_display_name || props.display_name
+			# dequote
+			name[/^'(.*)'/, 1] or name rescue nil
+		end
+
+		def email
+			props.smtp_address || props.org_email_addr || props.email_address
+		end
+
+		RECIPIENT_TYPES = { 0 => :orig, 1 => :to, 2 => :cc, 3 => :bcc }
+		def type
+			RECIPIENT_TYPES[props.recipient_type]
+		end
+
+		def to_s
+			if name = self.name and !name.empty? and email && name != email
+				%{"#{Mime::to_encoded_word(name)}" <#{email}>}
+			else
+				email || name
+			end
+		end
+
+		def inspect
+			"#<#{self.class.to_s[/\w+$/]}:#{self.to_s.inspect}>"
+		end
+	end
+
+	# i refer to it as a message (as does mapi), although perhaps Item is better, as its a more general
+	# concept than a message, as used in Pst files. though maybe i'll switch to using
+	# Mapi::Object as the base class there.
+	#
+	# IMessage essentially, but there's also stuff like IMAPIFolder etc. so, for this to form
+	# basis for PST Item, it'd need to be more general.
+	class Message < Item
+		# these 2 collections should be provided by our subclasses
+		def attachments
+			raise NotImplementedError
+		end
+
+		def recipients
+			raise NotImplementedError
+		end
+		
+		def inspect
+			str = %w[message_class from to subject].map do |key|
+				" #{key}=#{props.send(key).inspect}"
+			end.compact.join
+			str << " recipients=#{recipients.inspect}"
+			str << " attachments=#{attachments.inspect}"
+			"#<#{self.class.to_s[/\w+$/]}#{str}>"
+		end
+	end
+end

data/lib/mapi/convert/contact.rb

@@ -0,0 +1,142 @@
+require 'rubygems'
+require 'vpim/vcard'
+
+# patch Vpim. TODO - fix upstream, or verify old behaviour was ok
+def Vpim.encode_text v
+	# think the regexp was wrong
+	v.to_str.gsub(/(.)/m) do
+		case $1
+		when "\n"
+			"\\n"
+		when "\\", ",", ";"
+			"\\#{$1}"
+		else
+			$1
+		end
+	end
+end
+
+module Mapi
+	class Message
+		class VcardConverter
+			include Vpim
+
+			# a very incomplete mapping, but its a start...
+			# can't find where to set a lot of stuff, like zipcode, jobtitle etc
+			VCARD_MAP = {
+				# these are all standard mapi properties
+				:name => [
+					{
+						:given		=> :given_name,
+						:family		=> :surname,
+						:fullname	=> :subject
+					}
+				],
+				# outlook seems to eschew the mapi properties this time,
+				# like postal_address, street_address, home_address_city
+				# so we use the named properties
+				:addr => [
+					{
+						:location	=> 'work',
+						:street		=> :business_address_street,
+						:locality	=> proc do |props|
+							[props.business_address_city, props.business_address_state].compact * ', '
+						end
+					}
+				],
+
+				# right type? maybe date
+				:birthday	=> :birthday,
+				:nickname	=> :nickname
+
+				# photo available?
+				# FIXME finish, emails, telephones etc
+			}
+
+			attr_reader :msg
+			def initialize msg
+				@msg = msg
+			end
+
+			def field name, *args
+				DirectoryInfo::Field.create name, Vpim.encode_text_list(args)
+			end
+
+			def get_property key
+				if String === key
+					return key
+				elsif key.respond_to? :call
+					value = key.call msg.props
+				else
+					value = msg.props[key]
+				end
+				if String === value and value.empty?
+					nil
+				else
+					value
+				end
+			end
+
+			def get_properties hash
+				constants = {}
+				others = {}
+				hash.each do |to, from|
+					if String === from
+						constants[to] = from
+					else
+						value = get_property from
+						others[to] = value if value
+					end
+				end
+				return nil if others.empty?
+				others.merge constants
+			end
+
+			def convert
+				Vpim::Vcard::Maker.make2 do |m|
+					# handle name
+					[:name, :addr].each do |type|
+						VCARD_MAP[type].each do |hash|
+							next unless props = get_properties(hash)
+							m.send "add_#{type}" do |n|
+								props.each { |key, value| n.send "#{key}=", value }
+							end
+						end
+					end
+
+					(VCARD_MAP.keys - [:name, :addr]).each do |key|
+						value = get_property VCARD_MAP[key]
+						m.send "#{key}=", value if value
+					end
+
+					# the rest of the stuff is custom
+
+					url = get_property(:webpage) || get_property(:business_home_page)
+					m.add_field field('URL', url) if url
+					m.add_field field('X-EVOLUTION-FILE-AS', get_property(:file_under)) if get_property(:file_under)
+
+					addr = get_property(:email_email_address) || get_property(:email_original_display_name)
+					if addr
+						m.add_email addr do |e|
+							e.format ='x400' unless msg.props.email_addr_type == 'SMTP'
+						end
+					end
+
+					if org = get_property(:company_name)
+						m.add_field field('ORG', get_property(:company_name))
+					end
+
+					# TODO: imaddress
+				end
+			end
+		end
+
+		def to_vcard
+			#p props.raw.reject { |key, value| key.guid.inspect !~ /00062004-0000-0000-c000-000000000046/ }.
+			#	map { |key, value| [key.to_sym, value] }.reject { |a, b| b.respond_to? :read }
+			#y props.to_h.reject { |a, b| b.respond_to? :read }
+			VcardConverter.new(self).convert
+		end
+	end
+end
+

data/lib/mapi/convert/note-mime.rb

@@ -0,0 +1,282 @@
+require 'base64'
+require 'mapi/mime'
+require 'time'
+
+# there is still some Msg specific stuff in here.
+
+module Mapi
+	class Message
+		def mime
+			return @mime if @mime
+			# if these headers exist at all, they can be helpful. we may however get a
+			# application/ms-tnef mime root, which means there will be little other than
+			# headers. we may get nothing.
+			# and other times, when received from external, we get the full cigar, boundaries
+			# etc and all.
+			# sometimes its multipart, with no boundaries. that throws an error. so we'll be more
+			# forgiving here
+			@mime = Mime.new props.transport_message_headers.to_s, true
+			populate_headers
+			@mime
+		end
+
+		def headers
+			mime.headers
+		end
+
+		# copy data from msg properties storage to standard mime. headers
+		# i've now seen it where the existing headers had heaps on stuff, and the msg#props had
+		# practically nothing. think it was because it was a tnef - msg conversion done by exchange.
+		def populate_headers
+			# construct a From value
+			# should this kind of thing only be done when headers don't exist already? maybe not. if its
+			# sent, then modified and saved, the headers could be wrong?
+			# hmmm. i just had an example where a mail is sent, from an internal user, but it has transport
+			# headers, i think because one recipient was external. the only place the senders email address
+			# exists is in the transport headers. so its maybe not good to overwrite from.
+			# recipients however usually have smtp address available.
+			# maybe we'll do it for all addresses that are smtp? (is that equivalent to 
+			# sender_email_address !~ /^\//
+			name, email = props.sender_name, props.sender_email_address
+			if props.sender_addrtype == 'SMTP'
+				headers['From'] = if name and email and name != email
+					[%{"#{Mime::to_encoded_word(name)}" <#{email}>}]
+				else
+					[email || Mime::to_encoded_word(name)]
+				end
+			elsif !headers.has_key?('From')
+				# some messages were never sent, so that sender stuff isn't filled out. need to find another
+				# way to get something
+				# what about marking whether we thing the email was sent or not? or draft?
+				# for partition into an eventual Inbox, Sent, Draft mbox set?
+				# i've now seen cases where this stuff is missing, but exists in transport message headers,
+				# so maybe i should inhibit this in that case.
+				if email
+					# disabling this warning for now
+					#Log.warn "* no smtp sender email address available (only X.400). creating fake one"
+					# this is crap. though i've specially picked the logic so that it generates the correct
+					# email addresses in my case (for my organisation).
+					# this user stuff will give valid email i think, based on alias.
+					user = name ? name.sub(/(.*), (.*)/, "\\2.\\1") : email[/\w+$/].downcase
+					domain = (email[%r{^/O=([^/]+)}i, 1].downcase + '.com' rescue email)
+					headers['From'] = [name ? %{"#{Mime::to_encoded_word(name)}" <#{user}@#{domain}>} : "<#{user}@#{domain}>" ]
+				elsif name
+					# we only have a name? thats screwed up.
+					# disabling this warning for now
+					#Log.warn "* no smtp sender email address available (only name). creating fake one"
+					headers['From'] = [%{"#{Mime::to_encoded_word(name)}"}]
+				else
+					# disabling this warning for now
+					#Log.warn "* no sender email address available at all. FIXME"
+				end
+			# else we leave the transport message header version
+			end
+
+			# for all of this stuff, i'm assigning in utf8 strings.
+			# thats ok i suppose, maybe i can say its the job of the mime class to handle that.
+			# but a lot of the headers are overloaded in different ways. plain string, many strings
+			# other stuff. what happens to a person who has a " in their name etc etc. encoded words
+			# i suppose. but that then happens before assignment. and can't be automatically undone
+			# until the header is decomposed into recipients.
+			recips_by_type = recipients.group_by { |r| r.type }
+			# i want to the the types in a specific order.
+			[:to, :cc, :bcc].each do |type|
+				# for maximal (probably pointless) fidelity, we try to sort recipients by the
+				# numerical part of the ole name
+				recips = recips_by_type[type] || []
+				recips = (recips.sort_by { |r| r.obj.name[/\d{8}$/].hex } rescue recips)
+				# switched to using , for separation, not ;. see issue #4
+				# recips.empty? is strange. i wouldn't have thought it possible, but it was right?
+				headers[type.to_s.sub(/^(.)/) { $1.upcase }] = [recips.join(', ')] unless recips.empty?
+			end
+			headers['Subject'] = [Mime::to_encoded_word(props.subject)] if props.subject
+
+			# fill in a date value. by default, we won't mess with existing value hear
+			if !headers.has_key?('Date')
+				# we want to get a received date, as i understand it.
+				# use this preference order, or pull the most recent?
+				keys = %w[message_delivery_time client_submit_time last_modification_time creation_time]
+				time = keys.each { |key| break time if time = props.send(key) }
+				time = nil unless Date === time
+
+				# now convert and store
+				# this is a little funky. not sure about time zone stuff either?
+				# actually seems ok. maybe its always UTC and interpreted anyway. or can be timezoneless.
+				# i have no timezone info anyway.
+				# in gmail, i see stuff like 15 Jan 2007 00:48:19 -0000, and it displays as 11:48.
+				# can also add .localtime here if desired. but that feels wrong.
+				headers['Date'] = [Time.iso8601(time.to_s).rfc2822] if time
+			end
+
+			# some very simplistic mapping between internet message headers and the
+			# mapi properties
+			# any of these could be causing duplicates due to case issues. the hack in #to_mime
+			# just stops re-duplication at that point. need to move some smarts into the mime
+			# code to handle it.
+			mapi_header_map = [
+				[:internet_message_id, 'Message-ID'],
+				[:in_reply_to_id, 'In-Reply-To'],
+				# don't set these values if they're equal to the defaults anyway
+				[:importance, 'Importance', proc { |val| val.to_s == '1' ? nil : val }],
+				[:priority, 'Priority', proc { |val| val.to_s == '1' ? nil : val }],
+				[:sensitivity, 'Sensitivity', proc { |val| val.to_s == '0' ? nil : val }],
+				# yeah?
+				[:conversation_topic, 'Thread-Topic', proc { |val| val ? Mime::to_encoded_word(val) : nil }],
+				# not sure of the distinction here
+				# :originator_delivery_report_requested ??
+				[:read_receipt_requested, 'Disposition-Notification-To', proc { |val| from }]
+			]
+			mapi_header_map.each do |mapi, mime, *f|
+				next unless q = val = props.send(mapi) or headers.has_key?(mime)
+				next if f[0] and !(val = f[0].call(val))
+				headers[mime] = [val.to_s]
+			end
+		end
+
+		# redundant?
+		def type
+			props.message_class[/IPM\.(.*)/, 1].downcase rescue nil
+		end
+
+		# shortcuts to some things from the headers
+		%w[From To Cc Bcc Subject].each do |key|
+			define_method(key.downcase) { 
+				headers[key].join(' ') if headers.has_key?(key) 
+			}
+		end
+
+		# @return [Mime]
+		def body_to_mime
+			# to create the body
+			# should have some options about serializing rtf. and possibly options to check the rtf
+			# for rtf2html conversion, stripping those html tags or other similar stuff. maybe want to
+			# ignore it in the cases where it is generated from incoming html. but keep it if it was the
+			# source for html and plaintext.
+			if props.body_rtf or props.body_html
+				# should plain come first?
+				mime = Mime.new "Content-Type: multipart/alternative\r\n\r\n"
+				# its actually possible for plain body to be empty, but the others not.
+				# if i can get an html version, then maybe a callout to lynx can be made...
+				mime.parts << Mime.new("Content-Type: text/plain\r\n\r\n" + props.body) if props.body
+				# this may be automatically unwrapped from the rtf if the rtf includes the html
+				mime.parts << Mime.new("Content-Type: text/html\r\n\r\n"  + props.body_html) if props.body_html
+				# temporarily disabled the rtf. its just showing up as an attachment anyway.
+				#mime.parts << Mime.new("Content-Type: text/rtf\r\n\r\n"   + props.body_rtf)  if props.body_rtf
+				# its thus currently possible to get no body at all if the only body is rtf. that is not
+				# really acceptable FIXME
+				mime
+			else
+				# check no header case. content type? etc?. not sure if my Mime class will accept
+				Log.debug "taking that other path"
+				# body can be nil, hence the to_s
+				Mime.new "Content-Type: text/plain\r\n\r\n" + props.body.to_s
+			end
+		end
+
+		def to_mime
+			# intended to be used for IPM.note, which is the email type. can use it for others if desired,
+			# YMMV
+			Log.warn "to_mime used on a #{props.message_class}" unless props.message_class == 'IPM.Note'
+			# we always have a body
+			mime = body = body_to_mime
+
+			# If we have attachments, we take the current mime root (body), and make it the first child
+			# of a new tree that will contain body and attachments.
+			unless attachments.empty?
+				mime = Mime.new "Content-Type: multipart/mixed\r\n\r\n"
+				mime.parts << body
+				# i don't know any better way to do this. need multipart/related for inline images
+				# referenced by cid: urls to work, but don't want to use it otherwise...
+				related = false
+				attachments.each do |attach|
+					part = attach.to_mime
+					related = true if part.headers.has_key?('Content-ID') or part.headers.has_key?('Content-Location')
+					mime.parts << part
+				end
+				mime.headers['Content-Type'] = ['multipart/related'] if related
+			end
+
+			# at this point, mime is either
+			# - a single text/plain, consisting of the body ('taking that other path' above. rare)
+			# - a multipart/alternative, consiting of a few bodies (plain and html body. common)
+			# - a multipart/mixed, consisting of 1 of the above 2 types of bodies, and attachments.
+			# we add this standard preamble if its multipart
+			# FIXME preamble.replace, and body.replace both suck.
+			# preamble= is doable. body= wasn't being done because body will get rewritten from parts
+			# if multipart, and is only there readonly. can do that, or do a reparse...
+			# The way i do this means that only the first preamble will say it, not preambles of nested
+			# multipart chunks.
+			mime.preamble.replace "This is a multi-part message in MIME format.\r\n" if mime.multipart?
+
+			# now that we have a root, we can mix in all our headers
+			headers.each do |key, vals|
+				# don't overwrite the content-type, encoding style stuff
+				next if mime.headers.has_key? key
+				# some new temporary hacks
+				next if key =~ /content-type/i and vals[0] =~ /base64/
+				next if mime.headers.keys.map(&:downcase).include? key.downcase
+				mime.headers[key] += vals
+			end
+			# just a stupid hack to make the content-type header last
+			mime.headers['Content-Type'] = mime.headers.delete 'Content-Type'
+
+			mime
+		end
+	end
+
+	class Attachment
+		def to_mime
+			# TODO: smarter mime typing.
+			mimetype = props.attach_mime_tag || 'application/octet-stream'
+			mime = Mime.new "Content-Type: #{mimetype}\r\n\r\n"
+			mime.headers['Content-Disposition'] = [
+				%{attachment; filename="#{Mime::to_encoded_word(filename)}"}
+			]
+			mime.headers['Content-Transfer-Encoding'] = ['base64']
+			mime.headers['Content-Location'] = [props.attach_content_location] if props.attach_content_location
+			mime.headers['Content-ID'] = [props.attach_content_id] if props.attach_content_id
+			# data.to_s for now. data was nil for some reason.
+			# perhaps it was a data object not correctly handled?
+			# hmmm, have to use read here. that assumes that the data isa stream.
+			# but if the attachment data is a string, then it won't work. possible?
+			data_str = if @embedded_msg
+				mime.headers['Content-Type'] = 'message/rfc822'
+				# lets try making it not base64 for now
+				mime.headers.delete 'Content-Transfer-Encoding'
+				# not filename. rather name, or something else right?
+				# maybe it should be inline?? i forget attach_method / access meaning
+				mime.headers['Content-Disposition'] = [
+					%{attachment; filename="#{Mime::to_encoded_word(@embedded_msg.subject)}"}
+				]
+				@embedded_msg.to_mime.to_s
+			elsif @embedded_ole
+				# kind of hacky
+				io = StringIO.new
+				Ole::Storage.new io do |ole|
+					ole.root.type = :dir
+					Ole::Storage::Dirent.copy @embedded_ole, ole.root
+				end
+				io.string
+			else
+				# FIXME: shouldn't be required
+				data.read.to_s rescue ''
+			end
+			mime.body.replace @embedded_msg ? data_str : Base64.encode64(data_str).gsub(/\n/, "\r\n")
+			mime
+		end
+	end
+
+	class Msg < Message
+		# @private
+		def populate_headers
+			super
+			if !headers.has_key?('Date')
+				# can employ other methods for getting a time. heres one in a similar vein to msgconvert.pl,
+				# ie taking the time from an ole object
+				time = @root.ole.dirents.map { |dirent| dirent.modify_time || dirent.create_time }.compact.sort.last
+				headers['Date'] = [Time.iso8601(time.to_s).rfc2822] if time
+			end
+		end
+	end
+end
+