inbox 0.2.0 → 0.3.0

data/lib/message.rb

@@ -0,0 +1,37 @@
+require 'restful_model'
+require 'file'
+
+module Inbox
+  class Message < RestfulModel
+
+    attr_accessor :subject
+    attr_accessor :from
+    attr_accessor :to
+    attr_accessor :cc
+    attr_accessor :bcc
+    attr_accessor :date
+    attr_accessor :thread_id
+    attr_accessor :file_ids
+    attr_accessor :body
+
+    def inflate(json)
+      super
+      @thread_id = json[:thread]
+      @file_ids = json[:files] || []
+      @to ||= []
+      @cc ||= []
+      @bcc ||= []
+    end
+
+    def as_json()
+      json = super
+      json[:files] = json[:file_ids]
+      json
+    end
+
+    def files
+      @files ||= RestfulModelCollection.new(File, @_api, @namespace, {:message=>@id})
+    end
+
+  end
+end

data/lib/namespace.rb

@@ -0,0 +1,51 @@
+require 'restful_model'
+require 'tag'
+require 'message'
+require 'draft'
+require 'contact'
+require 'file'
+
+# 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 "thread.rb"
+
+module Inbox
+
+  class Namespace < RestfulModel
+
+    attr_accessor :email_address
+    attr_accessor :provider
+    attr_accessor :account
+
+    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
+
+  end
+end

data/lib/restful_model.rb

@@ -0,0 +1,76 @@
+module Inbox
+  class RestfulModel
+
+    attr_accessor :id
+    attr_accessor :namespace
+    attr_accessor :created_at
+
+    def self.collection_name
+      "#{self.to_s.downcase}s".split('::').last
+    end
+
+    def initialize(api, namespace = nil)
+      raise StandardError.new unless api.class <= Inbox::API
+      @namespace = namespace
+      @_api = api
+    end
+
+    def ==(comparison_object)
+      comparison_object.equal?(self) || (comparison_object.instance_of?(self.class) && comparison_object.id == id)
+    end
+
+    def inflate(json)
+      setters = methods.grep(/^\w+=$/)
+      setters.each do |setter|
+        property_name = setter.to_s.sub('=', '')
+        send(setter, json[property_name]) if json.has_key?(property_name)
+      end
+    end
+
+    def save!
+      if id
+        update('PUT', '', as_json())
+      else
+        update('POST', '', as_json())
+      end
+    end
+
+    def url(action = "")
+      action = "/#{action}" unless action.empty?
+      @_api.url_for_path("/n/#{@namespace}/#{self.class.collection_name}/#{id}#{action}")
+    end
+
+    def as_json(options = {})
+      hash = {}
+      setters = methods.grep(/^\w+=$/)
+      setters.each do |setter|
+        getter = setter.to_s.sub('=', '')
+        unless options[:except] && options[:except].include?(getter)
+          value = send(getter)
+          unless value.is_a?(RestfulModelCollection)
+            value = value.as_json(options) if value.respond_to?(:as_json)
+            hash[getter] = value
+          end
+        end
+      end
+      hash
+    end
+
+    def update(http_method, action, data = {})
+      http_method = http_method.downcase
+
+      ::RestClient.send(http_method, self.url(action), data.to_json, :content_type => :json) do |response, request, result|
+        unless http_method == 'delete'
+          json = Inbox.interpret_response(result, response, :expected_class => Object)
+          inflate(json)
+        end
+      end
+      self
+    end
+
+    def destroy
+      update('DELETE', '')
+    end
+
+  end
+end

data/lib/restful_model_collection.rb

@@ -0,0 +1,131 @@
+require 'restful_model'
+
+module Inbox
+  class RestfulModelCollection
+
+    attr_accessor :filters
+    
+    def initialize(model_class, api, namespace, filters = {})
+      raise StandardError.new unless api.class <= Inbox::API
+      @model_class = model_class
+      @filters = filters
+      @namespace = namespace
+      @_api = api
+    end
+
+    def each
+      offset = 0
+      finished = false
+      while (!finished) do
+        items = get_model_collection(offset)
+        break if items.length == 0
+        items.each { |item|
+          yield item
+        }
+        offset += items.length
+      end
+    end
+
+    def first
+      get_model_collection.first
+    end
+
+    def all
+      range(0, Float::INFINITY)
+    end
+
+    def where(filters)
+      collection = self.clone
+      collection.filters = filters
+      collection
+    end
+
+    def range(offset = 0, limit = 50)
+      accumulated = []
+      finished = false
+      chunk_size = 50
+
+      while (!finished && accumulated.length < limit) do
+        results = get_model_collection(offset + accumulated.length, chunk_size)
+        accumulated = accumulated.concat(results)
+
+        # we're done if we have more than 'limit' items, or if we asked for 50 and got less than 50...
+        finished = accumulated.length >= limit || results.length == 0 || (results.length % chunk_size != 0)
+      end
+
+      accumulated = accumulated[0..limit] if limit < Float::INFINITY
+      accumulated
+    end
+
+    def delete(item_or_id)
+      item_or_id = item_or_id.id if item_or_id.is_a?(RestfulModel)
+      RestClient.delete("#{url}/#{id}")
+    end
+
+    def find(id)
+      return nil unless id
+      get_model(id)
+    end
+
+    def build(args)
+      for key in args.keys
+        args[key.to_s] = args[key] 
+      end
+      model = @model_class.new(@_api, @namespace)
+      model.inflate(args)
+      model
+    end
+
+    def inflate_collection(items = [])
+      models = []
+
+      return unless items.is_a?(Array)
+      items.each do |json|
+        if @model_class < RestfulModel
+          model = @model_class.new(@_api)
+          model.inflate(json)
+        else
+          model = @model_class.new(json)
+        end
+        models.push(model)
+      end
+      models
+    end
+
+    private
+
+    def url
+      prefix = "/n/#{@namespace}" if @namespace
+      @_api.url_for_path("#{prefix}/#{@model_class.collection_name}")
+    end
+
+    def get_model(id)
+      model = nil
+
+      RestClient.get("#{url}/#{id}"){ |response,request,result|
+        json = Inbox.interpret_response(result, response, {:expected_class => Object})
+        if @model_class < RestfulModel
+          model = @model_class.new(@_api)
+          model.inflate(json)
+        else
+          model = @model_class.new(json)
+        end
+      }
+      model
+    end
+
+    def get_model_collection(offset = 0, limit = 50)
+      filters = @filters.clone
+      filters[:offset] = offset
+      filters[:limit] = limit
+      models = []
+
+      RestClient.get("#{url}?#{filters.to_query}"){ |response,request,result|
+        items = Inbox.interpret_response(result, response, {:expected_class => Array})
+        models = inflate_collection(items)
+      }
+      models
+    end
+
+  end
+end

data/lib/tag.rb

@@ -0,0 +1,9 @@
+require 'restful_model'
+
+module Inbox
+  class Tag < RestfulModel
+
+    attr_accessor :name
+
+  end
+end

data/lib/thread.rb

@@ -0,0 +1,60 @@
+require 'restful_model'
+
+module Inbox
+  class Thread < RestfulModel
+
+    attr_accessor :subject
+    attr_accessor :participants
+    attr_accessor :last_message_timestamp
+    attr_accessor :first_message_timestamp
+    attr_accessor :snippet
+    attr_accessor :tags
+    attr_accessor :message_ids
+    attr_accessor :draft_ids
+
+    def inflate(json)
+      super
+      message_ids = json[:messages]
+      draft_ids = json[:drafts]
+    end
+
+    def messages
+      @messages ||= RestfulModelCollection.new(Message, @_api, @namespace, {:thread=>@id})
+    end
+
+    def drafts
+      @drafts ||= RestfulModelCollection.new(Draft, @_api, @namespace, {:thread=>@id})
+    end
+
+    def update_tags!(tags_to_add = [], tags_to_remove = [])
+      update('PUT', '', {
+        :add_tags => tags_to_add,
+        :remove_tags => tags_to_remove
+      })
+    end
+
+    def mark_as_read!
+      update_tags!([], ['unread'])
+    end
+
+    def mark_as_seen!
+      update_tags!([], ['unseen'])
+    end
+
+    def archive!
+      update_tags!(['archive'], ['inbox'])
+    end
+
+    def unarchive!
+      update_tags!(['inbox'], ['archive'])
+    end
+
+    def star!
+      update_tags!(['starred'], [''])
+    end
+
+    def unstar!
+      update_tags!([], ['starred'])
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Inbox
+  VERSION = "0.3.0"
+end

data/spec/inbox_spec.rb

@@ -0,0 +1,79 @@
+::ENV['RACK_ENV'] = 'test'
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'Inbox' do
+  before (:each) do
+    @app_id = 'ABC'
+    @app_secret = '123'
+    @auth_token = 'UXXMOCJW-BKSLPCFI-UQAQFWLO'
+    @inbox = Inbox::API.new(@app_id, @app_secret, @auth_token)
+  end
+
+  describe "#url_for_path" do
+    it "should return the url for a provided path" do
+      expect(@inbox.url_for_path('/wobble')).to eq("https://#{@inbox.auth_token}:@api.inboxapp.com/wobble")
+    end
+
+    it "should return an error if you have not provided an auth token" do
+      @inbox = Inbox::API.new(@app_id, @app_secret)
+      expect {
+        @inbox.url_for_path('/wobble')
+      }.to raise_error(Inbox::NoAuthToken)
+    end
+  end
+
+  describe "#self.interpret_response" do
+    before (:each) do
+      @result = double('result')
+      allow(@result).to receive(:code).and_return(200)
+    end
+
+    context "when an expected_class is provided" do
+      context "when the server responds with a 200 but unknown, invalid body" do
+        it "should raise an UnexpectedResponse" do
+          expect {
+            Inbox.interpret_response(@result, "I AM NOT JSON", {:expected_class => Array})
+          }.to raise_error(Inbox::UnexpectedResponse)
+        end
+      end
+
+      context "when the server responds with JSON that does not represent an array" do
+        it "should raise an UnexpectedResponse" do
+          allow(@result).to receive(:code).and_return(500)
+          expect {
+            Inbox.interpret_response(@result, "{\"_id\":\"5107089add02dcaecc000003\",\"created_at\":\"2013-01-28T23:24:10Z\",\"domain\":\"generic\",\"name\":\"Untitled\",\"password\":null,\"slug\":\"\",\"tracers\":[{\"_id\":\"5109b5e0dd02dc5976000001\",\"created_at\":\"2013-01-31T00:08:00Z\",\"name\":\"Facebook\"},{\"_id\":\"5109b5f5dd02dc4c43000002\",\"created_at\":\"2013-01-31T00:08:21Z\",\"name\":\"Twitter\"}],\"published_pop_url\":\"http://group3.lvh.me\",\"unpopulated_api_tags\":[],\"unpopulated_api_regions\":[],\"label_names\":[]}", {:expected_class => Array})
+          }.to raise_error(Inbox::UnexpectedResponse)
+        end
+      end
+    end
+
+    context "when the server responds with a 403" do
+      it "should raise AccessDenied" do
+        allow(@result).to receive(:code).and_return(403)
+        expect {
+          Inbox.interpret_response(@result, '')
+        }.to raise_error(Inbox::AccessDenied)
+      end
+    end
+
+    context "when the server responds with a 404" do
+      it "should raise ResourceNotFound" do
+        allow(@result).to receive(:code).and_return(404)
+        expect {
+          Inbox.interpret_response(@result, '')
+        }.to raise_error(Inbox::ResourceNotFound)
+      end
+    end
+
+    context "when the server responds with another status code" do
+      it "should raise an UnexpectedResponse" do
+        allow(@result).to receive(:code).and_return(500)
+        expect {
+          Inbox.interpret_response(@result, '')
+        }.to raise_error(Inbox::UnexpectedResponse)
+      end
+    end
+
+  end
+
+end