rexchange 0.2.0 → 0.3.0

data/CHANGELOG

@@ -1,8 +1,19 @@
+-- 0.3.0:
+* Added support for Appointments
+* Options hash for Session creation is gone. The new form is: "RExchange::Session.new(url, username, password)"
+* Removed GenericItem#[], GenericItem#method_missing (attributes are explicit now)
+* Removed Folder#get_messages, #get_contacts and #messages_in. Folders are now Enumerables using Enumerable#entries, #each, etc
+  to retrieve entries according to the folder's content-class. So a 'mailfolder' will retrieve Message instances,
+  a 'calendarfolder' will retrieve Appointment instances, and so on.
+
 -- 0.2.0:
 * Fixed a bug in Message#move_to when passing folders
 * Added support for Contact browsing
 * Added GenericItem to abstract Contacts and Messages
 * Renamed Folder#messages to Folder#get_messages to avoid naming collisions
+* Modified attributes in GenericItem that end with "date" to be Time::parse'd
+* Added "r_exchange.rb" for Rails auto-require compatibility
+* Now calling String#normalize on attribute names instead of just String#tr('-', '_')
 
 -- 0.1.4:
 * Moved Folder::normalize_folder_name to String#normalize, and added support for MixedCase sources.

data/RAKEFILE

@@ -2,12 +2,13 @@
 
 require 'rubygems'
 require 'rake'
+require 'rake/testtask'
 require 'rake/rdoctask'
 require 'rake/gempackagetask'
 require 'rake/contrib/rubyforgepublisher'
 require 'pscp'
 
-PACKAGE_VERSION = '0.2.0'
+PACKAGE_VERSION = '0.3.0'
 
 PACKAGE_FILES = FileList[
   'README',
@@ -64,4 +65,10 @@ end
 desc "Publish RDOC to RubyForge"
 task :rubyforge => [:rdoc, :gem] do
   Rake::SshDirPublisher.new(ENV['RUBYFORGE_USER'], ENV['RUBYFORGE_PROJECT'], 'doc').upload
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*.rb']
+  t.verbose = true
 end

data/README

@@ -4,7 +4,7 @@ RExchange is a pure ruby wrapper for the Microsoft Exchange Server WebDAV API
 
 == Things you should know
 
-* Requires Ruby 1.8.4 (for the extended WebDAV support in the net/http library)
+* Requires Ruby 1.8.4 (or later, for the extended WebDAV support in the net/http library)
 * RExchange is cross-platform compatible, being written in pure Ruby
 * Kiwi fruits are packed with vitamins
 
@@ -36,7 +36,7 @@ RExchange is a pure ruby wrapper for the Microsoft Exchange Server WebDAV API
 	
 			# The RExchange::Message#move_to method moves the message to another folder, in this
 			# case, an "archive" folder off of the inbox.
-			message.move_to '/inbox/archive'
+			message.move_to mailbox.inbox.archive # or you could pass the string: '/inbox/archive'
 		end
 		
 		# You can also call the RExchange::Folder#messages method if you find calling "each"

data/lib/rexchange.rb

@@ -19,8 +19,8 @@ module RExchange
   DEBUG_STREAM = $log
   
   # A shortcut to RExchange::Session#new's block syntax
-  def self.open(uri, options = {})
-    session = RExchange::Session.new(uri, options)
+  def self.open(uri, username = nil, password = nil)
+    session = RExchange::Session.new(uri, username, password)
     
     yield session if block_given?
     return session

data/lib/rexchange/appointment.rb

@@ -0,0 +1,38 @@
+require 'rexchange/generic_item'
+
+module RExchange
+  class Appointment < GenericItem
+    
+    set_folder_type 'calendar'
+    
+    attribute_mappings :all_day_event => 'urn:schemas:calendar:alldayevent',
+      :busy_status => 'urn:schemas:calendar:busystatus',
+      :contact => 'urn:schemas:calendar:contact',
+      :contact_url => 'urn:schemas:calendar:contacturl',
+      :created_on => 'urn:schemas:calendar:created',
+      :description_url => 'urn:schemas:calendar:descriptionurl',
+      :end_at => 'urn:schemas:calendar:dtend',
+      :created_at => 'urn:schemas:calendar:dtstamp',
+      :start_at => 'urn:schemas:calendar:dtstart',
+      :duration => 'urn:schemas:calendar:duration',
+      :expires_on => 'urn:schemas:calendar:exdate',
+      :expiry_rule => 'urn:schemas:calendar:exrule',          
+      :has_attachment? => 'urn:schemas:httpmail:hasattachment', 
+      :html => 'urn:schemas:httpmail:htmldescription', 
+      :modified_on => 'urn:schemas:calendar:lastmodified', 
+      :location => 'urn:schemas:calendar:location', 
+      :location_url => 'urn:schemas:calendar:locationurl', 
+      :meeting_status => 'urn:schemas:calendar:meetingstatus', 
+      :normalized_subject => 'urn:schemas:httpmail:normalizedsubject', 
+      :priority => 'urn:schemas:httpmail:priority', 
+      :recurres_on => 'urn:schemas:calendar:rdate', 
+      :reminder_offset => 'urn:schemas:calendar:reminderoffset', 
+      :reply_time => 'urn:schemas:calendar:replytime', 
+      :sequence => 'urn:schemas:calendar:sequence', 
+      :subject => 'urn:schemas:httpmail:subject', 
+      :body => 'urn:schemas:httpmail:textdescription', 
+      :timezone => 'urn:schemas:calendar:timezone', 
+      :uid => 'urn:schemas:calendar:uid'
+
+  end
+end  

data/lib/rexchange/contact.rb

@@ -3,43 +3,26 @@ require 'rexchange/generic_item'
 module RExchange
   class Contact < GenericItem
     
-    attribute_mappings :first_name => 'given_name',
-      :middle_name => 'middlename',
-      :last_name => 'sn',
-      :created_at => 'creationdate',
-      :address => 'mailingstreet',
-      :city => 'mailingcity',
-      :state => 'st',
-      :zip_code => 'mailingpostalcode',
-      :country => 'co',
-      :phone => 'home_phone',
-      :business_phone => 'telephone_number',
-      :fax => 'facsimiletelephonenumber',      
-      :email => 'email1',
-      :website => 'businesshomepage',
-      :company => 'o'
-    
-    def self.query(path)
-      <<-QBODY
-				<?xml version="1.0"?>
-				<D:searchrequest xmlns:D = "DAV:">
-					 <D:sql>
-					 SELECT "urn:schemas:contacts:givenName", "urn:schemas:contacts:middlename",
-					  "urn:schemas:contacts:sn", "urn:schemas:contacts:title",
-					  "urn:schemas:contacts:mailingstreet", "urn:schemas:contacts:mailingcity",
-					  "urn:schemas:contacts:st", "urn:schemas:contacts:mailingpostalcode",
-					  "urn:schemas:contacts:co", "urn:schemas:contacts:homePhone",
-					  "urn:schemas:contacts:telephoneNumber", "urn:schemas:contacts:facsimiletelephonenumber",
-					  "urn:schemas:contacts:mobile", "urn:schemas:contacts:email1",
-					  "urn:schemas:contacts:businesshomepage", "urn:schemas:contacts:o", "DAV:creationdate"
-					 FROM SCOPE('shallow traversal of "#{path}"')
-					 WHERE "DAV:ishidden" = false
-						 AND "DAV:isfolder" = false
-						 AND "DAV:contentclass" = 'urn:content-classes:person'
-                    </D:sql>
-				</D:searchrequest>
-      QBODY
-    end
+    set_folder_type 'contact'
+    set_content_class 'person'
+
+    attribute_mappings :first_name => 'urn:schemas:contacts:givenName',
+      :middle_name => 'urn:schemas:contacts:middlename',
+      :last_name => 'urn:schemas:contacts:sn',
+      :title => 'urn:schemas:contacts:title',
+      :created_at => 'DAV:creationdate',
+      :address => 'urn:schemas:contacts:mailingstreet',
+      :city => 'urn:schemas:contacts:mailingcity',
+      :state => 'urn:schemas:contacts:st',
+      :zip_code => 'urn:schemas:contacts:mailingpostalcode',
+      :country => 'urn:schemas:contacts:co',
+      :phone => 'urn:schemas:contacts:homePhone',
+      :business_phone => 'urn:schemas:contacts:telephoneNumber',
+      :fax => 'urn:schemas:contacts:facsimiletelephonenumber',
+      :mobile => 'urn:schemas:contacts:mobile',    
+      :email => 'urn:schemas:contacts:email1',
+      :website => 'urn:schemas:contacts:businesshomepage',
+      :company => 'urn:schemas:contacts:o'
 
-  end
+  end  
 end

data/lib/rexchange/credentials.rb

@@ -8,11 +8,11 @@ module RExchange
     attr_reader :user, :password, :uri
 
     # You must pass a uri, and an options hash containing :user and :password
-    def initialize(uri, options = {})
+    def initialize(uri, username = nil, password = nil)
       @uri = URI.parse(uri)
       @use_ssl = (@uri.scheme.downcase == 'https')
-      @user = @uri.userinfo ? @user.userinfo.split(':')[0] : options.values_at(:user)
-      @password = @uri.userinfo ? @user.userinfo.split(':')[1] : options.values_at(:password)
+      @user = @uri.userinfo ? @user.userinfo.split(':')[0] : username
+      @password = @uri.userinfo ? @user.userinfo.split(':')[1] : password
       @port = @uri.port || @uri.default_port
             
       if block_given?

data/lib/rexchange/folder.rb

@@ -3,62 +3,43 @@ require 'net/https'
 require 'rexchange/dav_search_request'
 require 'rexchange/message'
 require 'rexchange/contact'
+require 'rexchange/appointment'
 
 module RExchange
 
+  class FolderNotFoundError < StandardError
+  end
+  
   class Folder
     include REXML
     
-    include Enumerable
-    
-    attr_reader :credentails
+    attr_reader :credentails, :name
     
-    def initialize(credentials, parent, folder)
-      @credentials, @parent, @folder = credentials, parent, folder
+    def initialize(credentials, parent, name, content_type)
+      @credentials, @parent, @name = credentials, parent, name
+      @content_type = CONTENT_TYPES[content_type]
     end
     
-    alias :old_method_missing :method_missing
-    
-    # Used to access subfolders. If the subfolder does not
-    # exist, then old_method_missing is called.
+    # Used to access subfolders.
     def method_missing(sym, *args)
       if folders.has_key?(sym.to_s)
-        Folder.new(@credentials, self, folders[sym.to_s] )
+        folders[sym.to_s]
       else
-        old_method_missing(sym, args)
+        raise FolderNotFoundError.new("#{sym} is not a subfolder of #{name}")
       end
     end
     
-    # Iterate through each RExchange::Message in this folder
+    include Enumerable
+    
+    # Iterate through each entry in this folder
     def each
-      if @folder =~ /^contacts$/i || @parent =~ /\/contacts\//i
-        get_contacts
-      else
-        get_messages
-      end.each do |item|
+      @content_type::find(@credentials, to_s).each do |item|
         yield item
-      end  
-    end
-    
-    # Retrieve an Array of messages from a specific folder
-    # === Example
-    #   RExchange::open(uri, :user => 'bob', :password => 'random') do |mailbox|
-    #     mailbox.messages_in('inbox/archive').each do |message|
-    #       p message.from
-    #     end
-    #   end
-    def messages_in(folder)
-      folder.split('/').inject(@credentials.uri.path) do |final_path, current_path|
-        Folder.new(@credentials, final_path, current_path)
-      end.get_messages
-    end
-    
-    def get_messages
-      RExchange::Message::find(@credentials, to_s)
+      end
     end
     
-    def get_contacts
-      RExchange::Contact::find(@credentials, to_s)
+    def search(conditions = {})
+      @content_type::find(@credentials, to_s, conditions)
     end
     
     # Join the strings passed in with '/'s between them
@@ -68,40 +49,39 @@ module RExchange
     
     # Return an Array of subfolders for this folder
     def folders
-      @folders ||= get_folders
+      @folders ||= begin
+        request_body = <<-eos
+      		<?xml version="1.0"?>
+  				<D:searchrequest xmlns:D = "DAV:">
+  					 <D:sql>
+  					 SELECT "DAV:displayname", "DAV:contentclass"
+  					 FROM SCOPE('shallow traversal of "#{to_s}"')
+  					 WHERE "DAV:ishidden" = false
+                         AND "DAV:isfolder" = true
+  					 </D:sql>
+  				</D:searchrequest>
+        eos
+
+        response = DavSearchRequest.execute(@credentials, :body => request_body)
+
+        folders = {}
+
+        # iterate through folders query and add a new Folder
+        # object for each, under a normalized name.
+        xpath_query = "//a:propstat[a:status/text() = 'HTTP/1.1 200 OK']/a:prop"
+        Document.new(response.body).elements.each(xpath_query) do |m|
+          displayname = m.elements['a:displayname'].text
+          contentclass = m.elements['a:contentclass'].text
+          folders[displayname.normalize] = Folder.new(@credentials, self, displayname, contentclass.split(':').last.sub(/folder$/, ''))
+        end
+
+        folders
+      end
     end
     
     # Return the absolute path to this folder (but not the full URI)
     def to_s
-      Folder.join(@parent, @folder)
-    end
-    
-    private
-    
-    def get_folders
-      request_body = <<DA_QUERY
-    				<?xml version="1.0"?>
-    				<D:searchrequest xmlns:D = "DAV:">
-    					 <D:sql>
-    					 SELECT "DAV:displayname"
-    					 FROM SCOPE('shallow traversal of "#{to_s}"')
-    					 WHERE "DAV:ishidden" = false
-                           AND "DAV:isfolder" = true
-    					 </D:sql>
-    				</D:searchrequest>
-DA_QUERY
-      
-      response = DavSearchRequest.execute(@credentials, :body => request_body)
-      
-      folders = {}
-      
-      # iterate through folders query and add each normalized name to the folders array.
-      xpath_query = "//a:propstat[a:status/text() = 'HTTP/1.1 200 OK']/a:prop"
-      Document.new(response.body).elements.each(xpath_query) do |m| 
-        folders[m.elements['a:displayname'].text.normalize] = m.elements['a:displayname'].text
-      end
-      
-      return folders
+      Folder.join(@parent, @name)
     end
   end
 end

data/lib/rexchange/generic_item.rb

@@ -4,61 +4,120 @@ require 'rexchange/dav_move_request'
 require 'time'
 
 module RExchange
+  
+  class Folder
+    CONTENT_TYPES = {}
+  end
+  
   class GenericItem
     include REXML
     include Enumerable
-    
-    attr_accessor :attributes  
-    
-    # Used to access the attributes of the item as a hash.
-    def [](key)
-      return @attributes[key]
-    end
-    
-    # Used to access the attributes of the item.
-    def method_missing(sym, *args)
-      return @attributes[sym.to_s] if @attributes.include?(sym.to_s)
-    end
-    
+
+    attr_accessor :attributes
+
     def initialize(session, dav_property_node)
       @attributes = {}
       @session = session
-      
+
       dav_property_node.elements.each do |element|
-        if element.name.normalize =~ /date$/i
-          @attributes[element.name.normalize] = Time::parse(element.text)
+        namespaced_name = element.namespace + element.name
+        
+        if element.name =~ /date$/i || self.class::ATTRIBUTE_MAPPINGS.find { |k,v| v == namespaced_name && k.to_s =~ /\_(at|on)$/ }
+          @attributes[namespaced_name] = Time::parse(element.text)
         else
-          @attributes[element.name.normalize] = element.text
+          @attributes[namespaced_name] = element.text
         end
       end
+    end
+
+    # Set the default CONTENT_CLASS to the class name, and define a
+    # dynamic query method for the derived class.
+    def self.inherited(base)
+      base.const_set('CONTENT_CLASS', base.to_s.split('::').last.downcase)
       
-      return self    
+      def base.query(path)
+        <<-QBODY
+          SELECT
+            #{self::ATTRIBUTE_MAPPINGS.values.map { |f| '"' + f + '"' }.join(',')}
+          FROM SCOPE('shallow traversal of "#{path}"')
+          WHERE "DAV:ishidden" = false
+            AND "DAV:isfolder" = false
+            AND "DAV:contentclass" = 'urn:content-classes:#{self::CONTENT_CLASS}'
+        QBODY
+      end
     end
     
+    # This handy method is meant to be called from any inheriting
+    # classes. It is used to bind types of folders to particular
+    # Entity classes so that the folder knows what type it's
+    # enumerating. So for a "calendarfolder" you'd call:
+    #   set_folder_type 'calendarfolder' # or just 'calendar'
+    def self.set_folder_type(dav_name)
+      Folder::CONTENT_TYPES[dav_name.sub(/folder$/, '')] = self
+    end
+    
+    # --Normally Not Used--
+    # By default the CONTENT_CLASS is determined by the name
+    # of your class. So for the Appointment class the
+    # CONTENT_CLASS would be 'appointment'.
+    # If for some reason this convention doesn't suit you,
+    # you can use this method to set the appropriate value
+    # (which is used in queries).
+    # For example, the DAV:content-class for contacts is:
+    #   'urn:content-classes:person'
+    # Person doesn't strike me as the best name for our class though.
+    # Most people would refer to an entry in a Contacts folder as
+    # a Contact. So that's what we call our class, and we use this method
+    # to make sure everything still works as it should.
+    def self.set_content_class(dav_name)
+      const_set('CONTENT_CLASS', dav_name)
+    end
+    
+    # Defines what attributes are used in queries, and
+    # what methods they map to in instances. You should
+    # pass a Hash of method_name and namespaced-attribute-name pairs.
     def self.attribute_mappings(mappings)
+      
+      mappings.merge! :uid => 'DAV:uid',
+        :modified_at => 'DAV:getlastmodified',
+        :href => 'DAV:href'
+      
+      const_set('ATTRIBUTE_MAPPINGS', mappings)
+
       mappings.each_pair do |k,v|
-        define_method k do
+        
+        define_method(k) do
           @attributes[v]
         end
+        
+        define_method("#{k.to_s.sub(/\?$/, '')}=") do |value|
+          @attributes[v] = value
+        end
+        
       end
     end
     
-    def self.query(path)
-      raise 'YOU MUST DEFINE THIS'
-    end
-
     # Retrieve an Array of items (such as Contact, Message, etc)
-    def self.find(credentials, path)      
-      response = DavSearchRequest.execute(credentials, :body => query(path))
+    def self.find(credentials, path, conditions = nil)
+      qbody = <<-QBODY
+        <?xml version="1.0"?>
+  			<D:searchrequest xmlns:D = "DAV:">
+  				 <D:sql>
+           #{conditions.nil? ? query(path) : search(path, conditions)}
+           </D:sql>
+        </D:searchrequest>
+      QBODY
       
+      response = DavSearchRequest.execute(credentials, :body => qbody)
+
       items = []
       xpath_query = "//a:propstat[a:status/text() = 'HTTP/1.1 200 OK']/a:prop"
-      
+
       Document.new(response.body).elements.each(xpath_query) do |m|
         items << self.new(credentials, m)
       end
-      
-      return items
+
+      items
     end
   end
 end

data/lib/rexchange/message.rb

@@ -3,17 +3,17 @@ require 'rexchange/generic_item'
 module RExchange
   class Message < GenericItem
     
-    def to_s
-      "To: #{to}, From: #{from}, Subject: #{subject}"
-    end
+    set_folder_type 'mail'
     
-    attribute_mappings 'has_attachments?' => 'hasattachment'
-    
-    # Returns the body of the message. This is either a httpmail:textdescription,
-    # or a httpmail:htmldescription
-    def body
-      @attributes['textdescription'] || @attributes['htmldescription']
-    end
+    attribute_mappings :from => 'urn:schemas:httpmail:from',
+      :to => 'urn:schemas:httpmail:to',
+      :message_id => 'urn:schemas:mailheader:message-id',
+      :subject => 'urn:schemas:httpmail:subject',
+      :recieved_on => 'urn:schemas:httpmail:date',
+      :importance => 'urn:schemas:httpmail:importance',
+      :has_attachments? => 'urn:schemas:httpmail:hasattachment',
+      :body => 'urn:schemas:httpmail:textdescription',
+      :html => 'urn:schemas:httpmail:htmldescription'
     
     # Move this message to the specified folder.
     # The folder can be a string such as 'inbox/archive' or a RExchange::Folder.
@@ -28,28 +28,15 @@ module RExchange
       else
         @session.uri.path.ensure_ends_with('/') + folder.to_s.ensure_ends_with('/') + source.split('/').last
       end
-      
+
       $log.debug "move_to: source => \"#{source}\", destination => \"#{destination}\""
       DavMoveRequest.execute(@session, source, destination)
     end
     
-    def self.query(path)
-      <<-QBODY
-				<?xml version="1.0"?>
-				<D:searchrequest xmlns:D = "DAV:">
-					 <D:sql>
-					 SELECT "DAV:href", "urn:schemas:httpmail:from", "urn:schemas:httpmail:to",
-					   "urn:schemas:mailheader:message-id", "urn:schemas:httpmail:subject",
-					   "urn:schemas:httpmail:date", "urn:schemas:httpmail:importance",
-					   "urn:schemas:httpmail:hasattachment", "urn:schemas:httpmail:textdescription",
-					   "urn:schemas:httpmail:htmldescription"
-					 FROM SCOPE('shallow traversal of "#{path}"')
-					 WHERE "DAV:ishidden" = false
-						 AND "DAV:isfolder" = false
-						 AND "DAV:contentclass" = 'urn:content-classes:message'
-                    </D:sql>
-				</D:searchrequest>
-      QBODY
+    
+    def to_s
+      "To: #{to}, From: #{from}, Subject: #{subject}"
     end
+    
   end
 end

data/lib/rexchange/session.rb

@@ -11,14 +11,14 @@ module RExchange
     #   uri = 'https://mydomain.com/exchange/demo'
     #   options = { :user => 'test', :password => 'random' }
     # 
-    #   RExchange::Session.new(uri, options) do |mailbox|
+    #   RExchange::Session.new(uri, 'bob', 'secret') do |mailbox|
     #     mailbox.test.each do |message|
     #       puts message.subject
     #     end
     #   end
-    def initialize(uri, options = {})
+    def initialize(uri, username = nil, password = nil)
     
-      @credentials = Credentials.new(uri, options)
+      @credentials = Credentials.new(uri, username, password)
       @parent = @credentials.uri.path
       @folder = ''
       

data/test/functional.rb

@@ -4,24 +4,19 @@ require 'rexchange'
 class FunctionalTests < Test::Unit::TestCase
   
   def setup
+    @mailbox = RExchange::Session.new 'url', 'username', 'password'
   end
   
   def teardown
+    @mailbox = nil
   end
   
   # Ok, so it's not a real test, but I needed to get started,
   # and get rid of console scripts.
   def test_no_exceptions
-    
-    uri = "https://#{ENV['rexchange_test_server']}/exchange/#{ENV['rexchange_test_mailbox']}/"
-    options = { :user => ENV['rexchange_test_user'], :password => ENV['rexchange_test_password'] }
 
-    RExchange::open(uri, options) do |mailbox|
-      mailbox.inbox.each do |message|
-        puts message.body
-      end
-      
-      mailbox.folders.each { |folder| puts folder }
+    @mailbox.inbox.search(:from => 'scott').each do |m|
+      puts m.subject
     end
     
   end

metadata

@@ -1,60 +1,67 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.10
+rubygems_version: 0.9.0
 specification_version: 1
 name: rexchange
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
-date: 2006-02-23
-summary: "A simple wrapper around Microsoft Exchange Server's WebDAV API"
+  version: 0.3.0
+date: 2007-01-05 00:00:00 -06:00
+summary: A simple wrapper around Microsoft Exchange Server's WebDAV API
 require_paths: 
-  - lib
+- lib
 email: ssmoot@gmail.com; bauer.mail@gmail.com
 homepage: http://substantiality.net
 rubyforge_project: rexchange
-description: "Connect, browse, and iterate through folders and messages on an Exchange Server"
+description: Connect, browse, and iterate through folders and messages on an Exchange Server
 autorequire: rexchange
 default_executable: 
 bindir: bin
 has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-    - 
-      - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
   version: 
 platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
 authors: 
-  - Sam Smoot
-  - Scott Bauer
+- Sam Smoot
+- Scott Bauer
 files: 
-  - README
-  - CHANGELOG
-  - RAKEFILE
-  - lib/r_exchange.rb
-  - lib/rexchange.rb
-  - lib/rexchange/contact.rb
-  - lib/rexchange/credentials.rb
-  - lib/rexchange/dav_move_request.rb
-  - lib/rexchange/dav_search_request.rb
-  - lib/rexchange/exchange_request.rb
-  - lib/rexchange/folder.rb
-  - lib/rexchange/generic_item.rb
-  - lib/rexchange/message.rb
-  - lib/rexchange/session.rb
-  - test/functional.rb
+- README
+- CHANGELOG
+- RAKEFILE
+- lib/rexchange.rb
+- lib/r_exchange.rb
+- lib/rexchange/appointment.rb
+- lib/rexchange/contact.rb
+- lib/rexchange/credentials.rb
+- lib/rexchange/dav_move_request.rb
+- lib/rexchange/dav_search_request.rb
+- lib/rexchange/exchange_request.rb
+- lib/rexchange/folder.rb
+- lib/rexchange/generic_item.rb
+- lib/rexchange/message.rb
+- lib/rexchange/session.rb
+- test/functional.rb
 test_files: []
+
 rdoc_options: 
-  - "--line-numbers"
-  - "--inline-source"
-  - "--main"
-  - README
+- --line-numbers
+- --inline-source
+- --main
+- README
 extra_rdoc_files: 
-  - README
-  - CHANGELOG
-  - RAKEFILE
+- README
+- CHANGELOG
+- RAKEFILE
 executables: []
+
 extensions: []
+
 requirements: 
-  - none
-dependencies: []
+- none
+dependencies: []
+