ruby_outlook 0.1.0 → 0.2.0

data/README.md

@@ -2,6 +2,8 @@
 
 The RubyOutlook gem is a light-weight implementation of the Office 365 [Mail](https://msdn.microsoft.com/office/office365/APi/mail-rest-operations), [Calendar](https://msdn.microsoft.com/office/office365/APi/calendar-rest-operations), and [Contacts](https://msdn.microsoft.com/office/office365/APi/contacts-rest-operations) REST APIs. It provides basic CRUD functionality for all three APIs, along with the ability to extend functionality by making any arbitrary API call.
 
+For a sample app that uses this gem, see the [Office 365 VCF Import/Export Sample](https://github.com/jasonjoh/o365-vcftool).
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -31,6 +33,45 @@ outlook_client = RubyOutlook::Client.new
 
 In addition, you can set the `enable_fiddler` property on the `Client` to true if you want to capture Fiddler traces. Setting this property to true sets the proxy for all traffic to `http://127.0.0.1:8888` (the default Fiddler proxy value), and turns off SSL verification. Note that if you set this property to true and do not have Fiddler running, all requests will fail.
 
+### Get an OAuth2 token ###
+
+The Outlook APIs require an OAuth2 token for authentication. This gem doesn't handle the OAuth2 flow for you. For a full example that implements the OAuth2 [Authorization Code Grant Flow](https://msdn.microsoft.com/en-us/library/azure/dn645542.aspx), see the [Office 365 VCF Import/Export Sample](https://github.com/jasonjoh/o365-vcftool).
+
+For convenience, here's the relevant steps and code, which uses the [oauth2](https://rubygems.org/gems/oauth2) gem.
+
+- Generate a login URL:
+```ruby
+# Generates the login URL for the app.
+def get_login_url
+  client = OAuth2::Client.new(CLIENT_ID,
+                              CLIENT_SECRET,
+                              :site => "https://login.microsoftonline.com",
+                              :authorize_url => "/common/oauth2/authorize",
+                              :token_url => "/common/oauth2/token")
+
+  login_url = client.auth_code.authorize_url(:redirect_uri => "http://yourapp.com/authorize")
+end
+```
+- User browses to the login URL, authenticates, and provides consent to your app.
+- The user's browser is redirected back to "http://yourapp.com/authorize", a page in your web app that extracts the `code` parameter from the request URL.
+- Exchange the `code` value for an access token:
+```ruby
+# Exchanges an authorization code for a token
+def get_token_from_code(auth_code)
+  client = OAuth2::Client.new(CLIENT_ID,
+                              CLIENT_SECRET,
+                              :site => "https://login.microsoftonline.com",
+                              :authorize_url => "/common/oauth2/authorize",
+                              :token_url => "/common/oauth2/token")
+
+  token = client.auth_code.get_token(auth_code,
+                                     :redirect_uri => "http://yourapp.com/authorize",
+                                     :resource => 'https://outlook.office365.com')
+
+  access_token = token
+end
+```
+
 ### Using a built-in function
 
 All of the built-in functions have a required `token` parameter and an optional `user` parameter. The `token` parameter is the OAuth2 access token required for authentication. The `user` parameter is an email address. If passed, the library will make the call to that user's mailbox using the `/Users/user@domain.com/` URL. If omitted, the library will make the call using the `'/Me'` URL.

data/lib/ruby_outlook.rb

@@ -4,7 +4,6 @@ require "uuidtools"
 require "json"
 
 module RubyOutlook
-  
   class Client
     # User agent
     attr_reader :user_agent
@@ -12,43 +11,49 @@ module RubyOutlook
     # Always "https://outlook.office365.com"
     attr_writer :api_host
     attr_writer :enable_fiddler
-    
-    # method (string): The HTTP method to use for the API call. 
+
+    def initialize
+      @user_agent = "RubyOutlookGem/" << RubyOutlook::VERSION
+      @api_host = "https://outlook.office365.com"
+      @enable_fiddler = false
+    end
+
+    # method (string): The HTTP method to use for the API call.
     #                  Must be 'GET', 'POST', 'PATCH', or 'DELETE'
     # url (string): The URL to use for the API call. Must not contain
-    #               the host. For example: '/api/v1.0/me/messages'
+    #               the host. For example: '/api/v2.0/me/messages'
     # token (string): access token
     # params (hash) a Ruby hash containing any query parameters needed for the API call
     # payload (hash): a JSON hash representing the API call's payload. Only used
     #                 for POST or PATCH.
     def make_api_call(method, url, token, params = nil, payload = nil)
-      
+
       conn_params = {
         :url => 'https://outlook.office365.com'
       }
-      
+
       if @enable_fiddler
         conn_params[:proxy] = 'http://127.0.0.1:8888'
         conn_params[:ssl] = {:verify => false}
       end
-    
+
       conn = Faraday.new(conn_params) do |faraday|
         # Uses the default Net::HTTP adapter
-        faraday.adapter  Faraday.default_adapter  
-        
+        faraday.adapter  Faraday.default_adapter
+
       end
-      
+
       conn.headers = {
         'Authorization' => "Bearer #{token}",
         'Accept' => "application/json",
-        
+
         # Client instrumentation
         # See https://msdn.microsoft.com/EN-US/library/office/dn720380(v=exchg.150).aspx
         'User-Agent' => @user_agent,
         'client-request-id' => UUIDTools::UUID.timestamp_create.to_str,
         'return-client-request-id' => "true"
       }
-      
+
       case method.upcase
         when "GET"
           response = conn.get do |request|
@@ -71,16 +76,16 @@ module RubyOutlook
             request.url url, params
           end
       end
-      
+
       if response.status >= 300
         return JSON.dump({ 'ruby_outlook_error' => response.status})
       end
-      
-      return response.body
+
+      response.body
     end
-    
+
     #----- Begin Contacts API -----#
-    
+
     # token (string): access token
     # view_size (int): maximum number of results
     # page (int): What page to fetch (multiple of view size)
@@ -88,202 +93,227 @@ module RubyOutlook
     # sort (hash): { sort_on => field_to_sort_on, sort_order => 'ASC' | 'DESC' }
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def get_contacts(token, view_size, page, fields = nil, sort = nil, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Contacts"
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Contacts"
       request_params = {
         '$top' => view_size,
         '$skip' => (page - 1) * view_size
       }
-      
-      if not fields.nil?
+
+      unless fields.nil?
         request_params['$select'] = fields.join(',')
-      end 
-      
-      if not sort.nil?
+      end
+
+      unless sort.nil?
         request_params['$orderby'] = sort[:sort_field] + " " + sort[:sort_order]
       end
-      
+
       get_contacts_response = make_api_call "GET", request_url, token, request_params
-      
-      return JSON.parse(get_contacts_response)
+
+      JSON.parse(get_contacts_response)
     end
-    
+
     # token (string): access token
     # id (string): The Id of the contact to retrieve
     # fields (array): An array of field names to include in results
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def get_contact_by_id(token, id, fields = nil, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Contacts/" << id 
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Contacts/" << id
       request_params = nil
-      
-      if not fields.nil?
+
+      unless fields.nil?
         request_params = { '$select' => fields.join(',') }
       end
-      
+
       get_contact_response = make_api_call "GET", request_url, token, request_params
-      
-      return JSON.parse(get_contact_response)
+
+      JSON.parse(get_contact_response)
     end
-    
+
     # token (string): access token
     # payload (hash): a JSON hash representing the contact entity
     # folder_id (string): The Id of the contact folder to create the contact in.
     #                     If nil, contact is created in the default contacts folder.
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def create_contact(token, payload, folder_id = nil, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user))
-      if not folder_id.nil?
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user))
+
+      unless folder_id.nil?
         request_url << "/ContactFolders/" << folder_id
       end
+
       request_url << "/Contacts"
-      
+
       create_contact_response = make_api_call "POST", request_url, token, nil, payload
-      
-      return JSON.parse(create_contact_response)
+
+      JSON.parse(create_contact_response)
     end
-    
+
     # token (string): access token
     # payload (hash): a JSON hash representing the updated contact fields
     # id (string): The Id of the contact to update.
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def update_contact(token, payload, id, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Contacts/" << id 
-      
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Contacts/" << id
+
       update_contact_response = make_api_call "PATCH", request_url, token, nil, payload
-      
-      return JSON.parse(update_contact_response)
+
+      JSON.parse(update_contact_response)
     end
-    
+
     # token (string): access token
     # id (string): The Id of the contact to delete.
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def delete_contact(token, id, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Contacts/" << id 
-      
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Contacts/" << id
+
       delete_response = make_api_call "DELETE", request_url, token
-      
-      if not delete_response.nil? and not delete_response.empty?
-        return JSON.parse(delete_response)
-      else
-        return nil
-      end
+
+      return nil if delete_response.nil? || delete_response.empty?
+
+       JSON.parse(delete_response)
     end
-    
+
     #----- End Contacts API -----#
-    
+
     #----- Begin Mail API -----#
-    
+
     # token (string): access token
     # view_size (int): maximum number of results
     # page (int): What page to fetch (multiple of view size)
     # fields (array): An array of field names to include in results
-    # sort (hash): { sort_on => field_to_sort_on, sort_order => 'ASC' | 'DESC' }
+    # sort (hash): { sort_field: field_to_sort_on, sort_order: 'ASC' | 'DESC' }
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def get_messages(token, view_size, page, fields = nil, sort = nil, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Messages"
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Messages"
+      request_params = {
+        '$top' => view_size,
+        '$skip' => (page - 1) * view_size
+      }
+
+      unless fields.nil?
+        request_params['$select'] = fields.join(',')
+      end
+
+      unless sort.nil?
+        request_params['$orderby'] = sort[:sort_field] + " " + sort[:sort_order]
+      end
+
+      get_messages_response = make_api_call "GET", request_url, token, request_params
+
+      JSON.parse(get_messages_response)
+    end
+
+    # token (string): access token
+    # view_size (int): maximum number of results
+    # page (int): What page to fetch (multiple of view size)
+    # fields (array): An array of field names to include in results
+    # sort (hash): { sort_on => field_to_sort_on, sort_order => 'ASC' | 'DESC' }
+    # user (string): The user to make the call for. If nil, use the 'Me' constant.
+    # folder_id (string): The folder to get mail for. (inbox, drafts, sentitems, deleteditems)
+    def get_messages_for_folder(token, view_size, page, fields = nil, sort = nil, user = nil, folder_id)
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/MailFolders/#{folder_id}/messages"
       request_params = {
         '$top' => view_size,
         '$skip' => (page - 1) * view_size
       }
-      
-      if not fields.nil?
+
+      unless fields.nil?
         request_params['$select'] = fields.join(',')
-      end 
-      
-      if not sort.nil?
+      end
+
+      unless sort.nil?
         request_params['$orderby'] = sort[:sort_field] + " " + sort[:sort_order]
       end
-      
+
       get_messages_response = make_api_call "GET", request_url, token, request_params
-      
-      return JSON.parse(get_messages_response)
+
+      JSON.parse(get_messages_response)
     end
-    
+
     # token (string): access token
     # id (string): The Id of the message to retrieve
     # fields (array): An array of field names to include in results
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def get_message_by_id(token, id, fields = nil, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Messages/" << id 
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Messages/" << id
       request_params = nil
-      
-      if not fields.nil?
+
+      unless fields.nil?
         request_params = { '$select' => fields.join(',') }
       end
-      
+
       get_message_response = make_api_call "GET", request_url, token, request_params
-      
-      return JSON.parse(get_message_response)
+
+      JSON.parse(get_message_response)
     end
-    
+
     # token (string): access token
     # payload (hash): a JSON hash representing the contact entity
     # folder_id (string): The Id of the folder to create the message in.
     #                     If nil, message is created in the default drafts folder.
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def create_message(token, payload, folder_id = nil, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user))
-      if not folder_id.nil?
-        request_url << "/Folders/" << folder_id
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user))
+
+      unless folder_id.nil?
+        request_url << "/MailFolders/" << folder_id
       end
+
       request_url << "/Messages"
-      
+
       create_message_response = make_api_call "POST", request_url, token, nil, payload
-      
-      return JSON.parse(create_message_response)
+
+      JSON.parse(create_message_response)
     end
-    
+
     # token (string): access token
     # payload (hash): a JSON hash representing the updated message fields
     # id (string): The Id of the message to update.
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def update_message(token, payload, id, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Messages/" << id 
-      
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Messages/" << id
+
       update_message_response = make_api_call "PATCH", request_url, token, nil, payload
-      
-      return JSON.parse(update_message_response)
+
+      JSON.parse(update_message_response)
     end
-    
+
     # token (string): access token
     # id (string): The Id of the message to delete.
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def delete_message(token, id, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Messages/" << id 
-      
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Messages/" << id
+
       delete_response = make_api_call "DELETE", request_url, token
-      
-      if not delete_response.nil? and not delete_response.empty?
-        return JSON.parse(delete_response)
-      else
-        return nil
-      end
+
+      return nil if delete_response.nil? || delete_response.empty?
+
+      JSON.parse(delete_response)
     end
-    
+
     # token (string): access token
     # payload (hash): a JSON hash representing the message to send
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def send_message(token, payload, save_to_sentitems = true, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/SendMail"
-      
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/SendMail"
+
       # Wrap message in the sendmail JSON structure
       send_mail_json = {
         'Message' => payload,
         'SaveToSentItems' => save_to_sentitems
       }
-      
+
       send_response = make_api_call "POST", request_url, token, nil, send_mail_json
-      
-      if not send_response.nil? and not send_response.empty?
-        return JSON.parse(send_response)
-      else
-        return nil
-      end
+
+      return nil if send_response.nil? || send_response.empty?
+
+      JSON.parse(send_response)
     end
-    
+
     #----- End Mail API -----#
-    
+
     #----- Begin Calendar API -----#
-    
+
     # token (string): access token
     # view_size (int): maximum number of results
     # page (int): What page to fetch (multiple of view size)
@@ -291,42 +321,42 @@ module RubyOutlook
     # sort (hash): { sort_on => field_to_sort_on, sort_order => 'ASC' | 'DESC' }
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def get_events(token, view_size, page, fields = nil, sort = nil, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Events"
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Events"
       request_params = {
         '$top' => view_size,
         '$skip' => (page - 1) * view_size
       }
-      
-      if not fields.nil?
+
+      unless fields.nil?
         request_params['$select'] = fields.join(',')
-      end 
-      
-      if not sort.nil?
+      end
+
+      unless sort.nil?
         request_params['$orderby'] = sort[:sort_field] + " " + sort[:sort_order]
       end
-      
+
       get_events_response = make_api_call "GET", request_url, token, request_params
-      
-      return JSON.parse(get_events_response)
+
+      JSON.parse(get_events_response)
     end
-    
+
     # token (string): access token
     # id (string): The Id of the event to retrieve
     # fields (array): An array of field names to include in results
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def get_event_by_id(token, id, fields = nil, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Events/" << id 
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Events/" << id
       request_params = nil
-      
-      if not fields.nil?
+
+      unless fields.nil?
         request_params = { '$select' => fields.join(',') }
       end
-      
+
       get_event_response = make_api_call "GET", request_url, token, request_params
-      
-      return JSON.parse(get_event_response)
+
+      JSON.parse(get_event_response)
     end
-    
+
     # token (string): access token
     # window_start (DateTime): The earliest time (UTC) to include in the view
     # window_end (DateTime): The latest time (UTC) to include in the view
@@ -335,80 +365,71 @@ module RubyOutlook
     # fields (array): An array of field names to include in results
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def get_calendar_view(token, window_start, window_end, id = nil, fields = nil, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user))
-      
-      if not id.nil?
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user))
+
+      unless id.nil?
         request_url << "/Calendars/" << id
       end
-      
+
       request_url << "/CalendarView"
-      
+
       request_params = {
         'startDateTime' => window_start.strftime('%Y-%m-%dT00:00:00Z'),
         'endDateTime' => window_end.strftime('%Y-%m-%dT00:00:00Z')
       }
-      
-      if not fields.nil?
+
+      unless fields.nil?
         request_params['$select'] = fields.join(',')
       end
-      
+
       get_view_response =make_api_call "GET", request_url, token, request_params
-      
-      return JSON.parse(get_view_response)
+
+      JSON.parse(get_view_response)
     end
-    
+
     # token (string): access token
     # payload (hash): a JSON hash representing the event entity
     # folder_id (string): The Id of the calendar folder to create the event in.
     #                     If nil, event is created in the default calendar folder.
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def create_event(token, payload, folder_id = nil, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user))
-      if not folder_id.nil?
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user))
+
+      unless folder_id.nil?
         request_url << "/Calendars/" << folder_id
       end
+
       request_url << "/Events"
-      
+
       create_event_response = make_api_call "POST", request_url, token, nil, payload
-      
-      return JSON.parse(create_event_response)
+
+      JSON.parse(create_event_response)
     end
-    
+
     # token (string): access token
     # payload (hash): a JSON hash representing the updated event fields
     # id (string): The Id of the event to update.
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def update_event(token, payload, id, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Events/" << id 
-      
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Events/" << id
+
       update_event_response = make_api_call "PATCH", request_url, token, nil, payload
-      
-      return JSON.parse(update_event_response)
+
+      JSON.parse(update_event_response)
     end
-    
+
     # token (string): access token
     # id (string): The Id of the event to delete.
     # user (string): The user to make the call for. If nil, use the 'Me' constant.
     def delete_event(token, id, user = nil)
-      request_url = "/api/v1.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Events/" << id 
-      
+      request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Events/" << id
+
       delete_response = make_api_call "DELETE", request_url, token
-      
-      if not delete_response.nil? and not delete_response.empty?
-        return JSON.parse(delete_response)
-      else
-        return nil
-      end
+
+      return nil if delete_response.nil? || delete_response.empty?
+
+      JSON.parse(delete_response)
     end
-    
     #----- End Calendar API -----#
-    
-    private
-      def initialize
-        @user_agent = "RubyOutlookGem/" << RubyOutlook::VERSION
-        @api_host = "https://outlook.office365.com"
-        @enable_fiddler = false
-        super
-      end
   end
 end

data/lib/ruby_outlook/version.rb

@@ -1,3 +1,3 @@
 module RubyOutlook
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/ruby_outlook.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Jason Johnston"]
   spec.email         = ["jasonjoh@microsoft.com"]
 
-  spec.summary       = %q{A ruby gem to invoke the Office 365 REST APIs.}
-  spec.description   = %q{This ruby gem provides functions for common operations with the Office 365 Mail, Calendar, and Contacts APIs.}
+  spec.summary       = %q{A ruby gem to invoke the Outlook REST APIs.}
+  spec.description   = %q{This ruby gem provides functions for common operations with the Outlook Mail, Calendar, and Contacts APIs.}
   spec.homepage      = "https://github.com/jasonjoh/ruby_outlook"
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_outlook
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-03-24 00:00:00.000000000 Z
+date: 2016-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -75,8 +75,8 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
-description: This ruby gem provides functions for common operations with the Office
-  365 Mail, Calendar, and Contacts APIs.
+description: This ruby gem provides functions for common operations with the Outlook
+  Mail, Calendar, and Contacts APIs.
 email:
 - jasonjoh@microsoft.com
 executables: []
@@ -119,5 +119,5 @@ rubyforge_project:
 rubygems_version: 1.8.29
 signing_key: 
 specification_version: 3
-summary: A ruby gem to invoke the Office 365 REST APIs.
+summary: A ruby gem to invoke the Outlook REST APIs.
 test_files: []