mirror-api 0.0.9 → 0.1.0

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-pro

data/.rspec

@@ -1 +1 @@
---colour
+--colour --format d

data/README.md

@@ -4,7 +4,12 @@
 
 # Mirror::Api
 
-Simple Mirror Api client library
+Simple Mirror Api client library.
+
+## Benefits
+
+- Robust error handling. You can choose whether to bubble errors or not.
+- Snake case(ruby friendly) notation for requests and responses
 
 ## Installation
 
@@ -22,31 +27,143 @@ Or install it yourself as:
 
 ## Usage
 
-``` ruby
-
+##Getting Started
+###Require the mirror-api gem.
+```ruby
 require "mirror-api"
+```
+### Authenticating your client
+```ruby
+token = Mirror::OAuth.new(client_id, client_secret, refresh_token)
 
 api = Mirror::Api::Client.new(token)
+```
+##[Timeline](https://developers.google.com/glass/v1/reference/timeline)
 
-# Getting all the timeline items
+### [Listing Timeline items](https://developers.google.com/glass/v1/reference/timeline/list)
+```ruby
 items = api.timeline.list
+```
+
+### [Inserting a Timeline item](https://developers.google.com/glass/v1/reference/timeline/insert)
+```ruby
+item_1 = api.timeline.insert({text: "What up WORLD?!?!"})
+```
+
+### [Inserting a Timeline item with reply actions](https://developers.google.com/glass/timeline#user_interaction_with_menu_items)
+```ruby
+item_2 = api.timeline.insert({text: "Do you like tacos?", menu_items:[{action: "REPLY"}]})
+```
+
+### [Updating a Timeline item](https://developers.google.com/glass/v1/reference/timeline/update)
+```ruby
+txt = "Seriously, do you like tacos? This is the second time I had to ask you."
+item_2 = api.timeline.update(item_2.id, {text: txt, menu_items:[{action: "REPLY"}]})
+```
+
+### [Patching a Timeline item](https://developers.google.com/glass/v1/reference/timeline/patch)
+```ruby
+item_2 = api.timeline.patch(item_2.id, {text: "You realize you are a bad friend right?", menu_items:[{action: "REPLY"}]})
+```
+
+### [Getting a Timeline item](https://developers.google.com/glass/v1/reference/timeline/get)
+```ruby
+api.timeline.get(item_2.id)
+```
+
+### [Deleting a Timeline item](https://developers.google.com/glass/v1/reference/timeline/delete)
+```ruby
+api.timeline.delete(item_2.id)
+```
+
+##[Timeline Attachments](https://developers.google.com/glass/v1/reference/timeline/attachments)
+
+### [Listing Timeline Attachments](https://developers.google.com/glass/v1/reference/timeline/attachments/list)
+```ruby
+attachments = api.timeline.list(item_1.id, {attachments:{}})
+```
+
+### [Getting a Timeline Attachment](https://developers.google.com/glass/v1/reference/timeline/attachments/get)
+```ruby
+#for the sake of getting an id...
+attachment = attachments.items.first
+api.timeline.get(item_2.id, {attachments:{id: attachment.id}})
+```
 
-# Insert a simple text item - https://developers.google.com/glass/timeline#inserting_a_simple_timeline_item
-item1 = api.timeline.create({text: "Hello Word"})
+### [Deleting a Timeline Attachment](https://developers.google.com/glass/v1/reference/timeline/attachments/delete)
+```ruby
+api.timeline.delete(item_2.id, {attachments:{id: attachment.id}})
+```
+
+##[Subscriptions](https://developers.google.com/glass/v1/reference/subscriptions)
+
+### [Listing Subscriptions](https://developers.google.com/glass/v1/reference/subscriptions/list)
+```ruby
+subscriptions = api.subscriptions.list
+```
+
+### [Inserting a Subscription](https://developers.google.com/glass/v1/reference/subscriptions/insert)
+```ruby
+subscription = api.subscriptions.insert({collection: "timeline", userToken:"user_1", operation: ["UPDATE"], callbackUrl: "https://yourawesomewebsite.com/callback"})
+```
 
-# Inserting an item with reply actions - https://developers.google.com/glass/timeline#user_interaction_with_menu_items
-item2 = api.timeline.create({text: "Hello Word", menu_items:[{action: "REPLY"}]})
+### [Updating a Subscription](https://developers.google.com/glass/v1/reference/subscriptions/update)
+```ruby
+item_2 = api.subscriptions.update(subscription.id, {collection: "timeline", operation: ["UPDATE", "INSERT", "DELETE"], callbackUrl: "https://yourawesomewebsite.com/callback"})
 
-item2 = api.timeline.update(item2.id, {text: "Hello Again Word", menu_items:[{action: "REPLY"}]})
+```
+
+### [Deleting a Subscription](https://developers.google.com/glass/v1/reference/subscriptions/delete)
+```ruby
+api.subscriptions.delete(item_2.id)
+```
+
+##[Locations](https://developers.google.com/glass/v1/reference/locations)
+
+### [Listing Locations](https://developers.google.com/glass/v1/reference/locations/list)
+```ruby
+locations = api.locations.list
+```
 
-api.timeline.delete(item2.id)
+### [Getting a Location](https://developers.google.com/glass/v1/reference/locations/get)
+```ruby
+#for the sake of getting an id...
+location = locations.items.first
+api.locations.get(location.id)
 ```
 
-## See Also
+##[Contacts](https://developers.google.com/glass/v1/reference/contacts)
 
-Generic Google API Ruby Client
+### [Listing Contacts](https://developers.google.com/glass/v1/reference/contacts/list)
+```ruby
+items = api.contacts.list
+```
+
+### [Inserting a Contact](https://developers.google.com/glass/v1/reference/contacts/insert)
+```ruby
+contact = api.contacts.insert({id: '1234', displayName: 'Troll', imageUrls: ["http://pixelr3ap3r.com/wp-content/uploads/2012/08/357c6328ee4b11e1bfbf22000a1c91a7_7.jpg"]})
+```
+
+### [Updating a Contact](https://developers.google.com/glass/v1/reference/contacts/update)
+```ruby
+contact = api.contacts.update(contact.id, {displayName: 'Unicorn'})
+```
+
+### [Patching a Contact](https://developers.google.com/glass/v1/reference/contacts/patch)
+```ruby
+contact = api.contacts.patch(contact.id, {displayName: 'Grumpy Cat', imageUrls: ["http://blog.catmoji.com/wp-content/uploads/2012/09/grumpy-cat.jpeg"]})
+```
+
+### [Getting a Contact](https://developers.google.com/glass/v1/reference/contacts/get)
+```ruby
+api.contacts.get(contact.id)
+```
+
+### [Deleting a Contact](https://developers.google.com/glass/v1/reference/contacts/delete)
+```ruby
+api.contacts.delete(contact.id)
+```
 
-https://github.com/google/google-api-ruby-client
 
 ## Contributing
 

data/lib/mirror-api.rb

@@ -1,4 +1,3 @@
 require "mirror-api/version"
-require "mirror-api/base"
 require "mirror-api/client"
 require "mirror-api/oauth"

data/lib/mirror-api/client.rb

@@ -4,30 +4,36 @@ module Mirror
   module Api
     class Client
 
-      def initialize(credentials)
-        @credentials =  if credentials.is_a?(String)
-                          {:token => credentials}
-                        elsif credentials.is_a?(Hash)
-                          credentials
-                        end
-
-        raise "Invalid credentials #{credentials.inspect}" unless @credentials
+      attr_accessor :credentials, :options
+
+      def initialize(credentials, options={raise_errors: false})
+        self.credentials = credentials
+        self.options = options
+        raise "Invalid credentials. Missing token" unless (self.credentials && self.credentials[:token])
+      end
+
+      def credentials=(value)
+        if value.is_a?(String)
+          @credentials =  {:token => value}
+        elsif value.is_a?(Hash)
+          @credentials = value
+        end
       end
 
       def timeline
-        @timeline ||= Resource.new(@credentials)
+        @timeline ||= Resource.new(credentials, Request::TIMELINE, options)
       end
 
       def subscriptions
-        @subscriptions ||= Resource.new(@credentials, Request::SUBSCRIPTIONS)
+        @subscriptions ||= Resource.new(credentials, Request::SUBSCRIPTIONS, options)
       end
 
       def locations
-        @locations ||= Resource.new(@credentials, Request::LOCATIONS)
+        @locations ||= Resource.new(credentials, Request::LOCATIONS, options)
       end
 
       def contacts
-        @contacts ||= Resource.new(@credentials, Request::CONTACTS)
+        @contacts ||= Resource.new(credentials, Request::CONTACTS, options)
       end
     end
   end

data/lib/mirror-api/errors.rb

@@ -0,0 +1,10 @@
+module Mirror
+  module Api
+    class Errors
+      ERROR_400 = {code: 1, :message => "Mirror API returned a status code 400 for this call"}
+      ERROR_404 = {code: 2, :message => "Mirror API returned a status code 404 for this call"}
+      INTERNAL_ERROR = {:code => 100, :message => "We are experiencing problems requesting your name. Our team has been notified."}
+      TOKEN_REFRESH_ERROR = {:code => 200, :message => "Could not refresh your API access token"}
+    end
+end
+end

data/lib/mirror-api/oauth.rb

@@ -12,12 +12,14 @@ module Mirror
         req = Net::HTTP::Post.new("/o/oauth2/token")
         req.set_form_data(client_id: self.client_id, client_secret: self.client_secret, refresh_token: self.refresh_token, grant_type: "refresh_token")
         res = Net::HTTP.start("accounts.google.com", use_ssl: true, verify_mode: OpenSSL::SSL::VERIFY_NONE) { |http| http.request(req) }
-       
-        begin
-          result = JSON.parse(res.body)
-          result["access_token"]
-        rescue
-          raise JSON.parse(res.body)['error']['message']
+        result = JSON.parse(res.body)
+
+        if result
+          if result["access_token"]
+            result["access_token"]
+          elsif result["error"]
+            raise "Error in get_access_token #{result["error"]}"
+          end
         end
       end
 

data/lib/mirror-api/request.rb

@@ -1,22 +1,163 @@
-require_relative "base"
+require "rest-client"
+require "json"
+require "logger"
+require_relative "request_data"
+require_relative "response_data"
+require_relative "errors"
 
 module Mirror
   module Api
     HOST = "https://www.googleapis.com"
 
-    class Request < Mirror::Api::Base
+    class Request
       TIMELINE = "timeline"
       SUBSCRIPTIONS = "subscriptions"
       LOCATIONS = "locations"
       CONTACTS = "contacts"
 
+      VALID_RESOURCES = [TIMELINE, SUBSCRIPTIONS, LOCATIONS, CONTACTS]
+
+      attr_accessor :last_error, :logger, :host, :last_exception, :throw_on_fail, :response, :data, :creds, :resource, :params
+
+
       def initialize(creds, options={})
-        @resource = options[:resource] || TIMELINE
+        self.resource = options[:resource]
+        self.params = options[:params]
+        self.logger = options[:logger]
         @id = options[:id]
-        @params = options[:params]
+
         @expected_response = options[:expected_response]
-        host = options[:host] || HOST
-        super(creds, options[:raise_errors], host, options[:logger])
+        @creds = creds
+        @last_exception = nil
+        @throw_on_fail = options[:raise_errors] || false
+        @host = options[:host] || HOST
+
+        @last_error = nil
+      end
+
+      def logger=(value)
+        if value
+          if value.is_a?(Logger)
+            @logger = value
+          else
+            raise "Invalid object given as logger #{value.inspect}"
+          end
+        end
+      end
+
+      def resource=(value)
+        if value
+          if VALID_RESOURCES.include?(value)
+            @resource = value
+          else
+            raise "Invalid resource name #{value}"
+          end
+        end
+        @resource = TIMELINE unless @resource
+      end
+
+      def params=(value)
+        if value
+          if value.is_a?(RequestData)
+            @params = value
+          elsif value.is_a?(Hash) && value.keys.count > 0
+            @params = RequestData.new(value)
+          else
+            raise "Parameter #{value.inspect} is not compatible"
+          end
+        else
+          @params = nil
+        end
+      end
+
+      public
+      def post
+        do_verb(:post)
+      end
+
+      def put
+        do_verb(:put)
+      end
+
+      def patch
+        do_verb(:patch)
+      end
+
+      def delete
+        get_verb(:delete)
+      end
+
+      def get
+        get_verb
+      end
+
+      protected
+
+      def handle_http_response(response, request, result, &block)
+        @request = request
+        case response.code
+          when 404
+          when 400
+            if @logger
+              msg = "ERROR - #{response.code} #{request.inspect} to #{self.invoke_url} with params #{self.params}. Response is #{response.body}"
+              @logger.error(msg)
+            end
+            response
+          else
+            response.return!(request, result, &block)
+        end
+      end
+
+      def successful_response?
+        @response and @response.code == expected_response
+      end
+
+      def headers
+        {
+            "Accept" => "application/json",
+            "Content-type" => "application/json",
+            "Authorization" => "Bearer #{@creds[:token]}"
+        }
+      end
+
+      def handle_response
+        if successful_response?
+          ret_val
+        else
+          send_error
+        end
+      end
+
+      def handle_error(error_desc, msg, errors, validation_error=nil, params={})
+        @last_error = error_desc.dup
+        @last_error[:errors] = errors
+        @last_error[:validation_error] = validation_error if validation_error
+        msg += " with params #{params}"
+        @logger.warn(msg) if @logger
+        raise error_desc[:message] if throw_on_fail
+      end
+
+      def set_data
+        if @response and @response.body
+          @data = JSON.parse(@response.body) if @response.body.is_a?(String) && !@response.body.empty?
+        end
+      end
+
+      def do_verb(verb=:post)
+        data = self.params.to_json
+        @response = RestClient.send(verb, self.invoke_url, data, self.headers) do |response, request, result, &block|
+          handle_http_response(response, request, result, &block)
+        end
+        set_data
+        handle_response
+      end
+
+      def get_verb(verb=:get)
+        @response = RestClient.send(verb, self.invoke_url, self.headers) do |response, request, result, &block|
+          handle_http_response(response, request, result, &block)
+        end
+        set_data
+        handle_response
       end
 
       def invoke_url
@@ -31,20 +172,24 @@ module Mirror
       end
 
       def attachments
-        params[:attachments] if params
-      end
-
-      def params
-        @params ||={}
+        params.attachments if params
       end
 
       def ret_val
-        Hashie::Mash.new(@data)
+        ResponseData.new(@data)
       end
 
       def expected_response
         @expected_response
       end
+
+      def send_error
+        return handle_error(
+            Mirror::Api::Errors::ERROR_400,
+            "Error making a request for #{@resource}",
+            @data
+        )
+      end
     end
   end
 end