inbox 0.18.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 52b398c61d8967ca093f406987ee2ac503e0f6d9
-  data.tar.gz: b011b0f946a01c69da854719ecf2802925c05c70
+  metadata.gz: 4572727f15af142648617ef23c2d02cfbaeb829a
+  data.tar.gz: 11dc0cb420be765146e33679ca143f4ccd798a16
 SHA512:
-  metadata.gz: f15355d979d26a67d9bcb06ef646cc0bb7c8009a071372edb68e6c096c652c35b8894f9d6ff70748f3ef3080743c5876633aad7021e0b12da1c3a2a9766c0966
-  data.tar.gz: 2cf44541f69383d2db41d55441c0fca1dadabee471b5017fc1ad44d7741af26a2fa4382e1b02a9e28b7f725bd54e0ea072cdf72824acb407a9974ffec79a3f8e
+  metadata.gz: 37b247c67eeff634a5f215810ea8b60e54a59c49282e0bbab16302b28fd1ac1d808e760891e208f4fd6e35a23228db5a26bf1addbb9c0d0a5c208eaf77dd386c
+  data.tar.gz: 573a0525f28d8c219be3df6863846f29b8ee4148b87c7ef9c4f47be79768abb65928c8e9d986b9234c234ec29ece20b608b8a9cf0fc6ec0451bb54544f2222fe

data/README.md

@@ -55,7 +55,7 @@ Generally, you should store your App ID and Secret into environment variables to
 
 ### Authentication
 
-The Nylas REST API uses server-side (three-legged) OAuth, and the Ruby gem provides convenience methods that simplify the OAuth process. For more information about authenticating with Nylas, visit the [Developer Documentation](https://www.nylas.com/docs/knowledgebase#authentication).
+The Nylas REST API uses server-side (three-legged) OAuth, and the Ruby gem provides convenience methods that simplify the OAuth process. For more information about authenticating with Nylas, visit the [Developer Documentation](https://nylas.com/docs/platform#authentication).
 
 **Step 1: Redirect the user to Nylas:**
 
@@ -113,12 +113,9 @@ If you're using the open-source version of the Nylas Sync Engine or have fewer t
 ```ruby
 nylas = Nylas::API.new(config.nylas_app_id, config.nylas_app_secret, nylas_token)
 
-# Get the first namespace
-namespace = nylas.namespaces.first
-
 # Print out the email address and provider (Gmail, Exchange)
-puts namespace.email_address
-puts namespace.provider
+puts nylas.account.email_address
+puts nylas.account.provider
 ```
 
 
@@ -126,36 +123,36 @@ puts namespace.provider
 
 ```ruby
 # Fetch the first thread
-thread = namespace.threads.first
+thread = nylas.threads.first
 
 # Fetch a specific thread
-thread = namespace.threads.find('ac123acd123ef123')
+thread = nylas.threads.find('ac123acd123ef123')
 
 # List all threads tagged `inbox`
 # (paginating 50 at a time until no more are returned.)
-namespace.threads.where(:tag => 'inbox').each do |thread|
+nylas.threads.where(:tag => 'inbox').each do |thread|
   puts thread.subject
 end
 
 # List the 5 most recent unread threads
-namespace.threads.where(:tag => 'unread').range(0,4).each do |thread|
+nylas.threads.where(:tag => 'unread').range(0,4).each do |thread|
   puts thread.subject
 end
 
 # List all threads with 'ben@nylas.com'
-namespace.threads.where(:any_email => 'ben@nylas.com').each do |thread|
+nylas.threads.where(:any_email => 'ben@nylas.com').each do |thread|
   puts thread.subject
 end
 
 # Get number of all threads
-count = namespace.threads.count
+count = nylas.threads.count
 
 # Get number of threads with 'ben@inboxapp.com'
-count = namespace.threads.where(:any_email => 'ben@inboxapp.com').count
+count = nylas.threads.where(:any_email => 'ben@inboxapp.com').count
 
 # Collect all threads with 'ben@nylas.com' into an array.
 # Note: for large numbers of threads, this is not advised.
-threads = namespace.threads.where(:any_email => 'ben@nylas.com').all
+threads = nylas.threads.where(:any_email => 'ben@nylas.com').all
 ```
 
 
@@ -181,13 +178,13 @@ thread.update_tags!(tagsToAdd, tagsToRemove)
 # Add a new label to a message
 
 important = nil
-ns.labels.each do |label|
+nylas.labels.each do |label|
   if label.display_name == 'Important'
     important = label
   end
 end
 
-thread = ns.threads.where(:from => "helena@nylas.com").first
+thread = nylas.threads.where(:from => "helena@nylas.com").first
 thread.labels.push(important)
 thread.save!
 
@@ -202,41 +199,41 @@ end
 
 ```ruby
 # List files
-namespace.files.each do |file|
+nylas.files.each do |file|
   puts file.filename
 end
 
 # Create a new file
-file = namespace.files.build(:file => File.new("./public/favicon.ico", 'rb'))
+file = nylas.files.build(:file => File.new("./public/favicon.ico", 'rb'))
 file.save!
 ```
 
-### Working with Labels/Folder
+### Working with Labels/Folders
 
 The new folders and labels API replaces the now deprecated Tags API. It allows you to apply Gmail labels to whole threads or individual messages and, for providers other than Gmail, to move threads and messages between folders.
 
 ```ruby
 
 # List labels
-namespace.labels.each do |label|
+nylas.labels.each do |label|
   puts label.display_name, label.id
 end
 
 # Create a label
-label = ns.folders.build(:display_name => 'Test label', :name => 'test name')
+label = nylas.folders.build(:display_name => 'Test label', :name => 'test name')
 label.save!
 
 # Create a folder
 #
 # Note that Folders and Labels are absolutely identical from the standpoint of the SDK.
 # The only difference is that a message can have many labels but only a single folder.
-fld = ns.folders.build(:display_name => 'Test folder', :name => 'test name')
+fld = nylas.folders.build(:display_name => 'Test folder', :name => 'test name')
 fld.save!
 
 # Rename a folder
 #
 # Note that you can not rename folders like INBOX, Trash, etc.
-fld = ns.folders.first
+fld = nylas.folders.first
 fld.display_name = 'Renamed folder'
 fld.save!
 
@@ -247,10 +244,10 @@ fld.save!
 Each of the primary collections (contacts, messages, etc.) behave the same way as `threads`. For example, finding messages with a filter is similar to finding threads:
 
 ```ruby
-messages = namespace.messages.where(:to => 'ben@nylas.com`).all
+messages = nylas.messages.where(:to => 'ben@nylas.com`).all
 ```
 
-The `where` method accepts a hash of filters, as documented in the [Filters Documentation](https://www.nylas.com/docs/api#filters).
+The `where` method accepts a hash of filters, as documented in the [Filters Documentation](https://nylas.com/docs/platform#filters).
 
 ### Getting the raw contents of a message
 
@@ -265,7 +262,7 @@ raw_contents = message.raw
 
 ```ruby
 # Create a new draft
-draft = namespace.drafts.build(
+draft = nylas.drafts.build(
   :to => [{:name => 'Ben Gotow', :email => 'ben@nylas.com'}],
   :subject => "Sent by Ruby",
   :body => "Hi there!<strong>This is HTML</strong>"
@@ -288,8 +285,8 @@ draft.send!
 
 ````ruby
 # Every event is attached to a calendar -- get the id of the first calendar
-calendar_id = inbox.namespaces.first.calendars.first.id
-new_event = inbox.namespaces.first.events.build(:calendar_id => calendar_id, :title => 'Coffee?')
+calendar_id = nylas.calendars.first.id
+new_event = nylas.events.build(:calendar_id => calendar_id, :title => 'Coffee?')
 
 # Modify attributes as necessary
 new_event.location = "L'excelsior"
@@ -310,17 +307,16 @@ emailed_invite.rsvp!(status='yes', comment='I will come')
 
 ## Using the Delta sync API
 
-The delta sync API allows fetching all the changes that occured since a specified time. [Read this](https://nylas.com/docs/api#sync-protocol) for more details about the API.
+The delta sync API allows fetching all the changes that occured after a specific time. [Read this](https://nylas.com/docs/platform/#deltas) for more details about the API.
 
 ````ruby
-# Get all the messages starting from timestamp
-#
-# we first need to get a cursor object a cursor is simply the id of
-# an individual change.
-cursor = nylas.namespaces.first.get_cursor(1407543195)
+# Get an API cursor. Cursors are API objects identifying an individual change.
+# The latest cursor is the id of the latest change which was applied
+# to an API object (e.g: a message got read, an event got created, etc.)
+cursor = nylas.latest_cursor
 
 last_cursor = nil
-nylas.namespaces.first.deltas(cursor) do |event, object|
+nylas.deltas(cursor) do |event, object|
     if event == "create" or event == "modify"
         if object.is_a?(Nylas::Contact)
             puts "#{object.name} - #{object.email}"
@@ -346,14 +342,10 @@ save_to_db(last_cursor)
 The streaming API will receive deltas in real time, without needing to repeatedly poll. It uses EventMachine for async IO.
 
 ````ruby
-# Get all the messages starting from timestamp
-#
-# we first need to get a cursor object a cursor is simply the id of
-# an individual change.
-cursor = inbox.namespaces.first.get_cursor(1407543195)
+cursor = nylas.latest_cursor
 
 last_cursor = nil
-inbox.namespaces.first.delta_stream(cursor) do |event, object|
+nylas.delta_stream(cursor) do |event, object|
     if event == "create" or event == "modify"
         if object.is_a?(Inbox::Contact)
             puts "#{object.name} - #{object.email}"
@@ -376,11 +368,11 @@ end
 
 ### Exclude changes from a specific type --- get only messages
 ````ruby
-nylas.namespaces.first.deltas(cursor, exclude=[Nylas::Contact,
-                                               Nylas::Event,
-                                               Nylas::File,
-                                               Nylas::Tag,
-                                               Nylas::Thread]) do |event, object|
+nylas.deltas(cursor, exclude=[Nylas::Contact,
+                              Nylas::Event,
+                              Nylas::File,
+                              Nylas::Tag,
+                              Nylas::Thread]) do |event, object|
 if event == 'create' or event == 'modify'
         puts object.subject
     end
@@ -410,11 +402,19 @@ Code | Error Type | Description
 
 ## Open-Source Sync Engine
 
-The [Nylas Sync Engine](http://github.com/nylas/sync-engine) is open source, and you can also use the Ruby gem with the open source API. Since the open source API provides no authentication or security, connecting to it is simple. When you instantiate the Nylas object, provide `nil` for the App ID, App Secret, and API Token, and pass the fully-qualified address to your copy of the sync engine:
+The [Nylas Sync Engine](http://github.com/nylas/sync-engine) is open source, and you can also use the Ruby gem with the open source API. Since the open source API provides no authentication or security, connecting to it is simple. When you instantiate the Nylas object, provide `nil` for the App ID and App Secret, and set the API Token to the id of the account you're going to access. Finally, don't forget to pass the fully-qualified address to your copy of the sync engine:
 
 ```ruby
-require 'inbox'
-inbox = Nylas::API.new(nil, nil, nil, 'http://localhost:5555/')
+require 'nylas'
+nylas = Nylas::API.new(nil, nil, nil, 'http://localhost:5555/')
+
+# Get the id of the first account -- this is the access token we're
+# going to use.
+account_id = nylas.accounts.first.id
+
+# Display the contents of the first message for the first account
+nylas = Nylas::API.new(nil, nil, account_id, 'http://localhost:5555/')
+puts nylas.messages.first.contents
 ```
 
 
@@ -443,10 +443,10 @@ Test your new version (found in `pkg/`) locally, and then release with:
 
 If it's your first time updating the ruby gems, you may be prompted for the username/password for rubygems.org. Members of the Nylas team can find that by doing `fetch-password rubygems`.
 
-## OAuth self-test
-
-Because it's very important that we don't break OAuth, we require releasers to run the OAuth self-test before releasing a version of the gem. The self-test is a small sinatra program which will ask you to click on a couple URLs. You need to make sure that following the URLs returns a working token.
+## API self-tests
 
-To set up the program, you need to copy `tests/credentials.rb.templates` as `test/credentials.rb` and edit the `APP_ID` and `APP_SECRET` with a working Nylas API app id and secret. You also need to set up a `/callback` URL in the Nylas admin panel.
+Because it's critical that we don't break the SDK for our customers, we require releasers to run some tests before releasing a new version of the gem. The test programs are located in the test/ directory. To set up them up, you'll need to copy `tests/credentials.rb.templates` as `test/credentials.rb` and edit the `APP_ID` and `APP_SECRET` with a working Nylas API app id and secret. You also need to set up a `/callback` URL in the Nylas admin panel.
 
-You can then run the program using `cd tests && ruby -I../lib auth.rb`
+You can run the programs like this:
+`cd tests && ruby -I../lib auth.rb`
+`cd tests && ruby -I../lib system.rb`

data/lib/account.rb

@@ -12,7 +12,7 @@ module Inbox
     def _perform_account_action!(action)
       raise UnexpectedAccountAction.new unless action == "upgrade" || action == "downgrade"
 
-      collection = ManagementModelCollection.new(Account, @_api, @namespace_id, {:account_id=>@account_id})
+      collection = ManagementModelCollection.new(Account, @_api, {:account_id=>@account_id})
       ::RestClient.post("#{collection.url}/#{@account_id}/#{action}",{}) do |response, request, result|
           # Throw any exceptions
         json = Inbox.interpret_response(result, response, :expected_class => Object)

data/lib/api_account.rb

@@ -0,0 +1,21 @@
+# api_account.rb --- functions related to the /account endpoint.
+# not to be confused with account.rb which is used by the hosted API
+# account management endpoint.
+require 'restful_model'
+
+module Inbox
+  class APIAccount < RestfulModel
+
+    parameter :account_id
+    parameter :email_address
+    parameter :id
+    parameter :name
+    parameter :object
+    parameter :organization_unit
+    parameter :provider
+
+    def self.collection_name
+      "accounts"
+    end
+  end
+end

data/lib/draft.rb

@@ -22,7 +22,7 @@ module Inbox
     end
 
     def send!
-      url = @_api.url_for_path("/n/#{@namespace_id}/send")
+      url = @_api.url_for_path("/send")
       if @id
         data = {:draft_id => @id, :version => @version}
       else

data/lib/event.rb

@@ -31,7 +31,7 @@ module Inbox
     end
 
     def rsvp!(status, comment)
-      url = @_api.url_for_path("/n/#{@namespace_id}/send-rsvp")
+      url = @_api.url_for_path("/send-rsvp")
       data = {:event_id => @id, :status => status, :comment => comment}
 
       ::RestClient.post(url, data.to_json, :content_type => :json) do |response, request, result|

data/lib/inbox.rb

@@ -1,9 +1,26 @@
-require 'version'
-require 'rest-client'
-require 'restful_model_collection'
 require 'json'
-require 'namespace'
+require 'rest-client'
+require 'yajl'
+require 'em-http'
+require 'ostruct'
+
+require 'account'
+require 'api_account'
+require 'api_thread'
+require 'calendar'
 require 'account'
+require 'tag'
+require 'message'
+require 'draft'
+require 'contact'
+require 'file'
+require 'calendar'
+require 'event'
+require 'folder'
+require 'restful_model'
+require 'restful_model_collection'
+require 'version'
+
 
 module Inbox
 
@@ -122,18 +139,218 @@ module Inbox
       end
     end
 
-    # Convenience Methods
+    # API Methods
+    def threads
+      @threads ||= RestfulModelCollection.new(Thread, self)
+    end
 
-    def namespaces
-      @namespaces ||= RestfulModelCollection.new(Namespace, self, nil)
-      @namespaces
+    def tags
+      @tags ||= RestfulModelCollection.new(Tag, self)
     end
 
-    # Billing Methods
+    def messages
+      @messages ||= RestfulModelCollection.new(Message, self)
+    end
+
+    def files
+      @files ||= RestfulModelCollection.new(File, self)
+    end
+
+    def drafts
+      @drafts ||= RestfulModelCollection.new(Draft, self)
+    end
+
+    def contacts
+      @contacts ||= RestfulModelCollection.new(Contact, self)
+    end
+
+    def calendars
+      @calendars ||= RestfulModelCollection.new(Calendar, self)
+    end
+
+    def events
+      @events ||= RestfulModelCollection.new(Event, self)
+    end
+
+    def folders
+      @folders ||= RestfulModelCollection.new(Folder, self)
+    end
+
+    def labels
+      @labels ||= RestfulModelCollection.new(Label, self)
+    end
+
+    def account
+      path = self.url_for_path("/account")
+
+      RestClient.get(path, {}) do |response,request,result|
+        json = Inbox.interpret_response(result, response, {:expected_class => Object})
+        model = APIAccount.new(self)
+        model.inflate(json)
+        model
+      end
+    end
+
+    def using_hosted_api?
+       return !@app_id.nil?
+    end
 
     def accounts
-      @accounts ||= ManagementModelCollection.new(Account, self, nil)
-      @accounts
+          if self.using_hosted_api?
+               @accounts ||= ManagementModelCollection.new(Account, self)
+          else
+               @accounts ||= RestfulModelCollection.new(APIAccount, self)
+          end
+    end
+
+    def get_cursor(timestamp)
+      # Get the cursor corresponding to a specific timestamp.
+      warn "Nylas#get_cursor is deprecated. Use Nylas#latest_cursor instead."
+
+      path = self.url_for_path("/delta/generate_cursor")
+      data = { :start => timestamp }
+
+      cursor = nil
+
+      RestClient.post(path, data.to_json, :content_type => :json) do |response,request,result|
+        json = Inbox.interpret_response(result, response, {:expected_class => Object})
+        cursor = json["cursor"]
+      end
+
+      cursor
+    end
+
+    def latest_cursor
+      # Get the cursor corresponding to a specific timestamp.
+      path = self.url_for_path("/delta/latest_cursor")
+
+      cursor = nil
+
+      RestClient.post(path, :content_type => :json) do |response,request,result|
+        json = Inbox.interpret_response(result, response, {:expected_class => Object})
+        cursor = json["cursor"]
+      end
+
+      cursor
+    end
+
+    OBJECTS_TABLE = {
+      "account" => Inbox::Account,
+      "calendar" => Inbox::Calendar,
+      "draft" => Inbox::Draft,
+      "thread" => Inbox::Thread,
+      "contact" => Inbox::Contact,
+      "event" => Inbox::Event,
+      "file" => Inbox::File,
+      "message" => Inbox::Message,
+      "tag" => Inbox::Tag,
+      "folder" => Inbox::Folder,
+      "label" => Inbox::Label,
+    }
+
+    def _build_exclude_types(exclude_types)
+      exclude_string = "&exclude_types="
+
+      exclude_types.each do |value|
+        count = 0
+        if OBJECTS_TABLE.has_value?(value)
+          param_name = OBJECTS_TABLE.key(value)
+          exclude_string += "#{param_name},"
+        end
+      end
+
+      exclude_string = exclude_string[0..-2]
+    end
+
+    def deltas(cursor, exclude_types=[])
+      raise 'Please provide a block for receiving the delta objects' if !block_given?
+      exclude_string = ""
+
+      if exclude_types.any?
+        exclude_string = _build_exclude_types(exclude_types)
+      end
+
+      # loop and yield deltas until we've come to the end.
+      loop do
+        path = self.url_for_path("/delta?cursor=#{cursor}#{exclude_string}")
+        json = nil
+
+        RestClient.get(path) do |response,request,result|
+          json = Inbox.interpret_response(result, response, {:expected_class => Object})
+        end
+
+        start_cursor = json["cursor_start"]
+        end_cursor = json["cursor_end"]
+
+        json["deltas"].each do |delta|
+          if not OBJECTS_TABLE.has_key?(delta['object'])
+            next
+          end
+
+          cls = OBJECTS_TABLE[delta['object']]
+          obj = cls.new(self)
+
+          case delta["event"]
+          when 'create', 'modify'
+              obj.inflate(delta['attributes'])
+              obj.cursor = delta["cursor"]
+              yield delta["event"], obj
+          when 'delete'
+              obj.id = delta["id"]
+              obj.cursor = delta["cursor"]
+              yield delta["event"], obj
+          end
+        end
+
+        break if start_cursor == end_cursor
+        cursor = end_cursor
+      end
+    end
+
+    def delta_stream(cursor, exclude_types=[], timeout=0)
+      raise 'Please provide a block for receiving the delta objects' if !block_given?
+
+      exclude_string = ""
+
+      if exclude_types.any?
+        exclude_string = _build_exclude_types(exclude_types)
+      end
+
+      # loop and yield deltas indefinitely.
+      path = self.url_for_path("/delta/streaming?cursor=#{cursor}#{exclude_string}")
+
+      parser = Yajl::Parser.new(:symbolize_keys => false)
+      parser.on_parse_complete = proc do |data|
+        delta = Inbox.interpret_response(OpenStruct.new(:code => '200'), data, {:expected_class => Object, :result_parsed => true})
+
+        if not OBJECTS_TABLE.has_key?(delta['object'])
+          next
+        end
+
+        cls = OBJECTS_TABLE[delta['object']]
+        obj = cls.new(self)
+
+        case delta["event"]
+          when 'create', 'modify'
+            obj.inflate(delta['attributes'])
+            obj.cursor = delta["cursor"]
+            yield delta["event"], obj
+          when 'delete'
+            obj.id = delta["id"]
+            obj.cursor = delta["cursor"]
+            yield delta["event"], obj
+        end
+      end
+
+      EventMachine.run do
+        http = EventMachine::HttpRequest.new(path, :connect_timeout => 0, :inactivity_timeout => timeout).get(:keepalive => true)
+        http.stream do |chunk|
+          parser << chunk
+        end
+        http.errback do
+          raise UnexpectedResponse.new http.error
+        end
+      end
     end
   end
 end

data/lib/message.rb

@@ -68,12 +68,12 @@ module Inbox
     end
 
     def files
-      @files ||= RestfulModelCollection.new(File, @_api, @namespace_id, {:message_id=>@id})
+      @files ||= RestfulModelCollection.new(File, @_api, {:message_id=>@id})
     end
 
     def raw
       model = nil
-      collection = RestfulModelCollection.new(Message, @_api, @namespace_id, {:message_id=>@id})
+      collection = RestfulModelCollection.new(Message, @_api, {:message_id=>@id})
       RestClient.get("#{collection.url}/#{id}/", :accept => 'message/rfc822'){ |response,request,result|
         response
       }

data/lib/nylas.rb

@@ -1,9 +1,26 @@
-require 'version'
-require 'rest-client'
-require 'restful_model_collection'
 require 'json'
-require 'namespace'
+require 'rest-client'
+require 'yajl'
+require 'em-http'
+require 'ostruct'
+
+require 'account'
+require 'api_account'
+require 'api_thread'
+require 'calendar'
 require 'account'
+require 'tag'
+require 'message'
+require 'draft'
+require 'contact'
+require 'file'
+require 'calendar'
+require 'event'
+require 'folder'
+require 'restful_model'
+require 'restful_model_collection'
+require 'version'
+
 
 module Inbox
 
@@ -122,18 +139,218 @@ module Inbox
       end
     end
 
-    # Convenience Methods
+    # API Methods
+    def threads
+      @threads ||= RestfulModelCollection.new(Thread, self)
+    end
 
-    def namespaces
-      @namespaces ||= RestfulModelCollection.new(Namespace, self, nil)
-      @namespaces
+    def tags
+      @tags ||= RestfulModelCollection.new(Tag, self)
     end
 
-    # Billing Methods
+    def messages
+      @messages ||= RestfulModelCollection.new(Message, self)
+    end
+
+    def files
+      @files ||= RestfulModelCollection.new(File, self)
+    end
+
+    def drafts
+      @drafts ||= RestfulModelCollection.new(Draft, self)
+    end
+
+    def contacts
+      @contacts ||= RestfulModelCollection.new(Contact, self)
+    end
+
+    def calendars
+      @calendars ||= RestfulModelCollection.new(Calendar, self)
+    end
+
+    def events
+      @events ||= RestfulModelCollection.new(Event, self)
+    end
+
+    def folders
+      @folders ||= RestfulModelCollection.new(Folder, self)
+    end
+
+    def labels
+      @labels ||= RestfulModelCollection.new(Label, self)
+    end
+
+    def account
+      path = self.url_for_path("/account")
+
+      RestClient.get(path, {}) do |response,request,result|
+        json = Inbox.interpret_response(result, response, {:expected_class => Object})
+        model = APIAccount.new(self)
+        model.inflate(json)
+        model
+      end
+    end
+
+    def using_hosted_api?
+       return !@app_id.nil?
+    end
 
     def accounts
-      @accounts ||= ManagementModelCollection.new(Account, self, nil)
-      @accounts
+          if self.using_hosted_api?
+               @accounts ||= ManagementModelCollection.new(Account, self)
+          else
+               @accounts ||= RestfulModelCollection.new(APIAccount, self)
+          end
+    end
+
+    def get_cursor(timestamp)
+      # Get the cursor corresponding to a specific timestamp.
+      warn "Nylas#get_cursor is deprecated. Use Nylas#latest_cursor instead."
+
+      path = self.url_for_path("/delta/generate_cursor")
+      data = { :start => timestamp }
+
+      cursor = nil
+
+      RestClient.post(path, data.to_json, :content_type => :json) do |response,request,result|
+        json = Inbox.interpret_response(result, response, {:expected_class => Object})
+        cursor = json["cursor"]
+      end
+
+      cursor
+    end
+
+    def latest_cursor
+      # Get the cursor corresponding to a specific timestamp.
+      path = self.url_for_path("/delta/latest_cursor")
+
+      cursor = nil
+
+      RestClient.post(path, :content_type => :json) do |response,request,result|
+        json = Inbox.interpret_response(result, response, {:expected_class => Object})
+        cursor = json["cursor"]
+      end
+
+      cursor
+    end
+
+    OBJECTS_TABLE = {
+      "account" => Inbox::Account,
+      "calendar" => Inbox::Calendar,
+      "draft" => Inbox::Draft,
+      "thread" => Inbox::Thread,
+      "contact" => Inbox::Contact,
+      "event" => Inbox::Event,
+      "file" => Inbox::File,
+      "message" => Inbox::Message,
+      "tag" => Inbox::Tag,
+      "folder" => Inbox::Folder,
+      "label" => Inbox::Label,
+    }
+
+    def _build_exclude_types(exclude_types)
+      exclude_string = "&exclude_types="
+
+      exclude_types.each do |value|
+        count = 0
+        if OBJECTS_TABLE.has_value?(value)
+          param_name = OBJECTS_TABLE.key(value)
+          exclude_string += "#{param_name},"
+        end
+      end
+
+      exclude_string = exclude_string[0..-2]
+    end
+
+    def deltas(cursor, exclude_types=[])
+      raise 'Please provide a block for receiving the delta objects' if !block_given?
+      exclude_string = ""
+
+      if exclude_types.any?
+        exclude_string = _build_exclude_types(exclude_types)
+      end
+
+      # loop and yield deltas until we've come to the end.
+      loop do
+        path = self.url_for_path("/delta?cursor=#{cursor}#{exclude_string}")
+        json = nil
+
+        RestClient.get(path) do |response,request,result|
+          json = Inbox.interpret_response(result, response, {:expected_class => Object})
+        end
+
+        start_cursor = json["cursor_start"]
+        end_cursor = json["cursor_end"]
+
+        json["deltas"].each do |delta|
+          if not OBJECTS_TABLE.has_key?(delta['object'])
+            next
+          end
+
+          cls = OBJECTS_TABLE[delta['object']]
+          obj = cls.new(self)
+
+          case delta["event"]
+          when 'create', 'modify'
+              obj.inflate(delta['attributes'])
+              obj.cursor = delta["cursor"]
+              yield delta["event"], obj
+          when 'delete'
+              obj.id = delta["id"]
+              obj.cursor = delta["cursor"]
+              yield delta["event"], obj
+          end
+        end
+
+        break if start_cursor == end_cursor
+        cursor = end_cursor
+      end
+    end
+
+    def delta_stream(cursor, exclude_types=[], timeout=0)
+      raise 'Please provide a block for receiving the delta objects' if !block_given?
+
+      exclude_string = ""
+
+      if exclude_types.any?
+        exclude_string = _build_exclude_types(exclude_types)
+      end
+
+      # loop and yield deltas indefinitely.
+      path = self.url_for_path("/delta/streaming?cursor=#{cursor}#{exclude_string}")
+
+      parser = Yajl::Parser.new(:symbolize_keys => false)
+      parser.on_parse_complete = proc do |data|
+        delta = Inbox.interpret_response(OpenStruct.new(:code => '200'), data, {:expected_class => Object, :result_parsed => true})
+
+        if not OBJECTS_TABLE.has_key?(delta['object'])
+          next
+        end
+
+        cls = OBJECTS_TABLE[delta['object']]
+        obj = cls.new(self)
+
+        case delta["event"]
+          when 'create', 'modify'
+            obj.inflate(delta['attributes'])
+            obj.cursor = delta["cursor"]
+            yield delta["event"], obj
+          when 'delete'
+            obj.id = delta["id"]
+            obj.cursor = delta["cursor"]
+            yield delta["event"], obj
+        end
+      end
+
+      EventMachine.run do
+        http = EventMachine::HttpRequest.new(path, :connect_timeout => 0, :inactivity_timeout => timeout).get(:keepalive => true)
+        http.stream do |chunk|
+          parser << chunk
+        end
+        http.errback do
+          raise UnexpectedResponse.new http.error
+        end
+      end
     end
   end
 end

data/lib/restful_model.rb

@@ -7,7 +7,7 @@ module Inbox
     include Inbox::Parameters
 
     parameter :id
-    parameter :namespace_id
+    parameter :account_id
     parameter :cursor  # Only used by the delta sync API
     time_attr_accessor :created_at
 
@@ -15,9 +15,9 @@ module Inbox
       "#{self.to_s.downcase}s".split('::').last
     end
 
-    def initialize(api, namespace_id = nil)
+    def initialize(api, account_id = nil)
       raise StandardError.new unless api.class <= Inbox::API
-      @namespace_id = namespace_id
+      @account_id = account_id
       @_api = api
     end
 
@@ -41,7 +41,7 @@ module Inbox
 
     def url(action = "")
       action = "/#{action}" unless action.empty?
-      @_api.url_for_path("/n/#{@namespace_id}/#{self.class.collection_name}/#{id}#{action}")
+      @_api.url_for_path("/#{self.class.collection_name}/#{id}#{action}")
     end
 
     def as_json(options = {})

data/lib/restful_model_collection.rb

@@ -5,11 +5,10 @@ module Inbox
 
     attr_accessor :filters
 
-    def initialize(model_class, api, namespace_id, filters = {})
+    def initialize(model_class, api, filters = {})
       raise StandardError.new unless api.class <= Inbox::API
       @model_class = model_class
       @filters = filters
-      @namespace_id = namespace_id
       @_api = api
     end
 
@@ -93,7 +92,7 @@ module Inbox
       for key in args.keys
         args[key.to_s] = args[key]
       end
-      model = @model_class.new(@_api, @namespace_id)
+      model = @model_class.new(@_api)
       model.inflate(args)
       model
     end
@@ -115,8 +114,7 @@ module Inbox
     end
 
     def url
-      prefix = "/n/#{@namespace_id}" if @namespace_id
-      @_api.url_for_path("#{prefix}/#{@model_class.collection_name}")
+      @_api.url_for_path("/#{@model_class.collection_name}")
     end
 
     private

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Inbox
-  VERSION = "0.18.2"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inbox
 version: !ruby/object:Gem::Version
-  version: 0.18.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Ben Gotow
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-05 00:00:00.000000000 Z
+date: 2015-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -203,6 +203,7 @@ extra_rdoc_files:
 - README.md
 files:
 - lib/account.rb
+- lib/api_account.rb
 - lib/api_thread.rb
 - lib/calendar.rb
 - lib/contact.rb
@@ -213,7 +214,6 @@ files:
 - lib/inbox.rb
 - lib/label.rb
 - lib/message.rb
-- lib/namespace.rb
 - lib/nylas.rb
 - lib/parameters.rb
 - lib/restful_model.rb

data/lib/namespace.rb

@@ -1,210 +0,0 @@
-require 'restful_model'
-require 'account'
-require 'tag'
-require 'message'
-require 'draft'
-require 'contact'
-require 'file'
-require 'calendar'
-require 'event'
-require 'folder'
-require 'yajl'
-require 'em-http'
-require 'ostruct'
-
-# Rather than saying require 'thread', we need to explicitly force
-# the thread model to load. Otherwise, we can't reference it below.
-# Thread still refers to the built-in Thread type, and Inbox::Thread
-# is undefined.
-load "api_thread.rb"
-
-module Inbox
-
-  class Namespace < RestfulModel
-
-    parameter :account_id
-    parameter :name
-    parameter :email_address
-    parameter :provider
-
-    def self.collection_name
-      "n"
-    end
-
-    def threads
-      @threads ||= RestfulModelCollection.new(Thread, @_api, @id)
-    end
-
-    def tags
-      @tags ||= RestfulModelCollection.new(Tag, @_api, @id)
-    end
-
-    def messages
-      @messages ||= RestfulModelCollection.new(Message, @_api, @id)
-    end
-
-    def files
-      @files ||= RestfulModelCollection.new(File, @_api, @id)
-    end
-
-    def drafts
-      @drafts ||= RestfulModelCollection.new(Draft, @_api, @id)
-    end
-
-    def contacts
-      @contacts ||= RestfulModelCollection.new(Contact, @_api, @id)
-    end
-
-    def calendars
-      @calendars ||= RestfulModelCollection.new(Calendar, @_api, @id)
-    end
-
-    def events
-      @events ||= RestfulModelCollection.new(Event, @_api, @id)
-    end
-
-    def folders
-      @folders ||= RestfulModelCollection.new(Folder, @_api, @id)
-    end
-
-    def labels
-      @labels ||= RestfulModelCollection.new(Label, @_api, @id)
-    end
-
-    def get_cursor(timestamp)
-      # Get the cursor corresponding to a specific timestamp.
-      path = @_api.url_for_path("/n/#{@namespace_id}/delta/generate_cursor")
-      data = { :start => timestamp }
-
-      cursor = nil
-
-      RestClient.post(path, data.to_json, :content_type => :json) do |response,request,result|
-        json = Inbox.interpret_response(result, response, {:expected_class => Object})
-        cursor = json["cursor"]
-      end
-
-      cursor
-    end
-
-    OBJECTS_TABLE = {
-      "account" => Inbox::Account,
-      "calendar" => Inbox::Calendar,
-      "draft" => Inbox::Draft,
-      "thread" => Inbox::Thread,
-      "contact" => Inbox::Contact,
-      "event" => Inbox::Event,
-      "file" => Inbox::File,
-      "message" => Inbox::Message,
-      "namespace" => Inbox::Namespace,
-      "tag" => Inbox::Tag,
-      "folder" => Inbox::Folder,
-      "label" => Inbox::Label,
-    }
-
-    def _build_exclude_types(exclude_types)
-      exclude_string = "&exclude_types="
-
-      exclude_types.each do |value|
-        count = 0
-        if OBJECTS_TABLE.has_value?(value)
-          param_name = OBJECTS_TABLE.key(value)
-          exclude_string += "#{param_name},"
-        end
-      end
-
-      exclude_string = exclude_string[0..-2]
-    end
-
-    def deltas(cursor, exclude_types=[])
-      raise 'Please provide a block for receiving the delta objects' if !block_given?
-      exclude_string = ""
-
-      if exclude_types.any?
-        exclude_string = _build_exclude_types(exclude_types)
-      end
-
-      # loop and yield deltas until we've come to the end.
-      loop do
-        path = @_api.url_for_path("/n/#{@namespace_id}/delta?cursor=#{cursor}#{exclude_string}")
-        json = nil
-
-        RestClient.get(path) do |response,request,result|
-          json = Inbox.interpret_response(result, response, {:expected_class => Object})
-        end
-
-        start_cursor = json["cursor_start"]
-        end_cursor = json["cursor_end"]
-
-        json["deltas"].each do |delta|
-          if not OBJECTS_TABLE.has_key?(delta['object'])
-            next
-          end
-
-          cls = OBJECTS_TABLE[delta['object']]
-          obj = cls.new(@_api, @namespace_id)
-
-          case delta["event"]
-          when 'create', 'modify'
-              obj.inflate(delta['attributes'])
-              obj.cursor = delta["cursor"]
-              yield delta["event"], obj
-          when 'delete'
-              obj.id = delta["id"]
-              obj.cursor = delta["cursor"]
-              yield delta["event"], obj
-          end
-        end
-
-        break if start_cursor == end_cursor
-        cursor = end_cursor
-      end
-    end
-
-    def delta_stream(cursor, exclude_types=[], timeout=0)
-      raise 'Please provide a block for receiving the delta objects' if !block_given?
-
-      exclude_string = ""
-
-      if exclude_types.any?
-        exclude_string = _build_exclude_types(exclude_types)
-      end
-
-      # loop and yield deltas indefinitely.
-      path = @_api.url_for_path("/n/#{@namespace_id}/delta/streaming?cursor=#{cursor}#{exclude_string}")
-
-      parser = Yajl::Parser.new(:symbolize_keys => false)
-      parser.on_parse_complete = proc do |data|
-        delta = Inbox.interpret_response(OpenStruct.new(:code => '200'), data, {:expected_class => Object, :result_parsed => true})
-
-        if not OBJECTS_TABLE.has_key?(delta['object'])
-          next
-        end
-
-        cls = OBJECTS_TABLE[delta['object']]
-        obj = cls.new(@_api, @namespace_id)
-
-        case delta["event"]
-          when 'create', 'modify'
-            obj.inflate(delta['attributes'])
-            obj.cursor = delta["cursor"]
-            yield delta["event"], obj
-          when 'delete'
-            obj.id = delta["id"]
-            obj.cursor = delta["cursor"]
-            yield delta["event"], obj
-        end
-      end
-
-      EventMachine.run do
-        http = EventMachine::HttpRequest.new(path, :connect_timeout => 0, :inactivity_timeout => timeout).get(:keepalive => true)
-        http.stream do |chunk|
-          parser << chunk
-        end
-        http.errback do
-          raise UnexpectedResponse.new http.error
-        end
-      end
-    end
-
-  end
-end