Class: Mapi::PropertySet

Inherits:
Object
  • Object
show all
Includes:
Constants
Defined in:
lib/mapi/property_set.rb

Overview

The Mapi::PropertySet class is used to wrap the lower level Msg or Pst property stores, and provide a consistent and more friendly interface. It allows you to just say:

properties.subject

instead of:

properites.raw[0x0037, PS_MAPI]

The underlying store can be just a hash, or lazily loading directly from the file. A good compromise is to cache all the available keys, and just return the values on demand, rather than load up many possibly unwanted values.

Defined Under Namespace

Modules: Constants Classes: Key

Constant Summary collapse

NAMES = 
{
  oleguid['00020328'] => 'PS_MAPI',
  oleguid['00020329'] => 'PS_PUBLIC_STRINGS',
  oleguid['00020380'] => 'PS_ROUTING_EMAIL_ADDRESSES',
  oleguid['00020381'] => 'PS_ROUTING_ADDRTYPE',
  oleguid['00020382'] => 'PS_ROUTING_DISPLAY_NAME',
  oleguid['00020383'] => 'PS_ROUTING_ENTRYID',
  oleguid['00020384'] => 'PS_ROUTING_SEARCH_KEY',
  # string properties in this namespace automatically get added to the internet headers
  oleguid['00020386'] => 'PS_INTERNET_HEADERS',
  # theres are bunch of outlook ones i think
  # http://blogs.msdn.com/stephen_griffin/archive/2006/05/10/outlook-2007-beta-documentation-notification-based-indexing-support.aspx
  # IPM.Appointment
  oleguid['00062002'] => 'PSETID_Appointment',
  # IPM.Task
  oleguid['00062003'] => 'PSETID_Task',
  # used for IPM.Contact
  oleguid['00062004'] => 'PSETID_Address',
  oleguid['00062008'] => 'PSETID_Common',
  # didn't find a source for this name. it is for IPM.StickyNote
  oleguid['0006200e'] => 'PSETID_Note',
  # for IPM.Activity. also called the journal?
  oleguid['0006200a'] => 'PSETID_Log',
}
SUPPORT_DIR =

duplicated here for now

File.dirname(__FILE__) + '/../..'
TAGS =

data files that provide for the code to symbolic name mapping guids in named_map are really constant references to the above

YAML.load_file "#{SUPPORT_DIR}/data/mapitags.yaml"
NAMED_MAP = 
YAML.load_file("#{SUPPORT_DIR}/data/named_map.yaml").inject({}) do |hash, (key, value)|
  hash.update Key.new(key[0], const_get(key[1])) => value
end

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(raw) ⇒ PropertySet

raw should be an hash-like object that maps Keys to values. Should respond_to? [], keys, values, each, and optionally []=, and delete.



149
150
151
 
# File 'lib/mapi/property_set.rb', line 149

def initialize raw
  @raw = raw
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args) ⇒ Object 



211
212
213
214
215
216
217
218
219
 
# File 'lib/mapi/property_set.rb', line 211

def method_missing name, *args
  if name.to_s !~ /\=$/ and args.empty?
    self[name]
  elsif name.to_s =~ /(.*)\=$/ and args.length == 1
    self[$1] = args[0]
  else
    super
  end
end

Instance Attribute Details

#raw ⇒ Object (readonly)

Returns the value of attribute raw.



145
146
147
 
# File 'lib/mapi/property_set.rb', line 145

def raw
  @raw
end

Instance Method Details

#[](arg, guid = nil) ⇒ Object 



199
200
201
 
# File 'lib/mapi/property_set.rb', line 199

def [] arg, guid=nil
  raw[resolve(arg, guid)]
end

#[]=(arg, *args) ⇒ Object 



203
204
205
206
207
208
209
 
# File 'lib/mapi/property_set.rb', line 203

def []= arg, *args
  args.unshift nil if args.length == 1
  guid, value = args
  # FIXME this won't really work properly. it would need to go
  # to TAGS to resolve, as it often won't be there already...
  raw[resolve(arg, guid)] = value
end

#body ⇒ Object

for providing rtf to plain text conversion. later, html to text too.



237
238
239
240
241
242
243
244
245
246
 
# File 'lib/mapi/property_set.rb', line 237

def body
  return @body if defined?(@body)
  @body = (self[:body] rescue nil)
  # last resort
  if !@body or @body.strip.empty?
    Log.warn 'creating text body from rtf'
    @body = (RTF::Converter.rtf2text body_rtf rescue nil)
  end
  @body
end

#body_html ⇒ Object

for providing rtf to html extraction or conversion



263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
 
# File 'lib/mapi/property_set.rb', line 263

def body_html
  return @body_html if defined?(@body_html)
  @body_html = self[:body_html]
  # sometimes body_html is a stream, and sometimes a string
  @body_html = @body_html.read if @body_html.respond_to?(:read)
  @body_html = nil if @body_html.to_s.strip.empty?
  if body_rtf and !@body_html
    begin
      @body_html = RTF.rtf2html body_rtf
    rescue
      Log.warn 'unable to extract html from rtf'
    end
    if !@body_html
      Log.warn 'creating html body from rtf'
      begin
        @body_html = RTF::Converter.rtf2text body_rtf, :html
      rescue
        Log.warn 'unable to convert rtf to html'
      end
    end
  end
  @body_html
end

#body_rtf ⇒ Object

for providing rtf decompression



249
250
251
252
253
254
255
256
257
258
259
260
 
# File 'lib/mapi/property_set.rb', line 249

def body_rtf
  return @body_rtf if defined?(@body_rtf)
  @body_rtf = nil
  if self[:rtf_compressed]
    begin
      @body_rtf = RTF.rtfdecompr self[:rtf_compressed].read
    rescue
      Log.warn 'unable to decompress rtf'
    end
  end
  @body_rtf
end

#inspect ⇒ Object 



225
226
227
228
229
230
 
# File 'lib/mapi/property_set.rb', line 225

def inspect
  "#<#{self.class} " + to_h.sort_by { |k, v| k.to_s }.map do |k, v|
    v = v.inspect
    "#{k}=#{v.length > 32 ? v[0..29] + '..."' : v}"
  end.join(' ') + '>'
end

#keys ⇒ Object 



191
192
193
 
# File 'lib/mapi/property_set.rb', line 191

def keys
  sym_to_key.keys
end

#resolve(arg, guid = nil) ⇒ Object

resolve arg (could be key, code, string, or symbol), and possible guid to a key. returns nil on failure



155
156
157
158
159
160
161
162
163
164
 
# File 'lib/mapi/property_set.rb', line 155

def resolve arg, guid=nil
  if guid;        Key.new arg, guid
  else
    case arg
    when Key;     arg
    when Integer; Key.new arg
    else          sym_to_key[arg.to_sym]
    end
  end
end

#sym_to_key ⇒ Object

this is the function that creates a symbol to key mapping. currently this works by making a pass through the raw properties, but conceivably you could map symbols to keys using the mapitags directly. problem with that would be that named properties wouldn’t map automatically, but maybe thats not too important.



170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
 
# File 'lib/mapi/property_set.rb', line 170

def sym_to_key
  return @sym_to_key if @sym_to_key
  @sym_to_key = {}
  raw.keys.each do |key|
    sym = key.to_sym
    unless Symbol === sym
      Log.debug "couldn't find symbolic name for key #{key.inspect}" 
      next
    end
    if @sym_to_key[sym]
      Log.warn "duplicate key #{key.inspect}"
      # we give preference to PS_MAPI keys
      @sym_to_key[sym] = key if key.guid == PS_MAPI
    else
      # just assign
      @sym_to_key[sym] = key
    end
  end
  @sym_to_key
end

#to_h ⇒ Object 



221
222
223
 
# File 'lib/mapi/property_set.rb', line 221

def to_h
  sym_to_key.inject({}) { |hash, (sym, key)| hash.update sym => raw[key] }
end

#values ⇒ Object 



195
196
197
 
# File 'lib/mapi/property_set.rb', line 195

def values
  sym_to_key.values.map { |key| raw[key] }
end