podio 0.1.0 → 0.2.0

data/lib/podio/areas/user.rb

@@ -0,0 +1,19 @@
+module Podio
+  module User
+    include Podio::ResponseWrapper
+    extend self
+
+    def current
+      member Podio.connection.get("/user/").body
+    end
+
+    def create(token, attributes)
+      response = Podio.connection.post do |req|
+        req.url '/user/'
+        req.body = attributes.merge(:token => token)
+      end
+
+      response.body['user_id']
+    end
+  end
+end

data/lib/podio/areas/user_status.rb

@@ -0,0 +1,11 @@
+module Podio
+  module UserStatus
+    include Podio::ResponseWrapper
+    extend self
+
+    def current
+      member Podio.connection.get("/user/status").body
+    end
+
+  end
+end

data/lib/podio/areas/widget.rb

@@ -0,0 +1,45 @@
+module Podio
+  module Widget
+    include Podio::ResponseWrapper
+    extend self
+
+    def create(ref_type, ref_id, attributes)
+      response = Podio.connection.post do |req|
+        req.url "/widget/#{ref_type}/#{ref_id}/"
+        req.body = attributes
+      end
+
+      response.body['widget_id']
+    end
+
+    def update(id, attributes)
+      response = Podio.connection.put do |req|
+        req.url "/widget/#{id}"
+        req.body = attributes
+      end
+
+      response.status
+    end
+
+    def delete(id)
+      Podio.connection.delete("/widget/#{id}").status
+    end
+
+    def update_order(ref_type, ref_id, widget_list)
+      response = Podio.connection.put do |req|
+        req.url "/widget/#{ref_type}/#{ref_id}/order"
+        req.body = widget_list
+      end
+
+      response.status
+    end
+
+    def find(id)
+      member Podio.connection.get("/widget/#{id}").body
+    end
+
+    def find_all_for_reference(ref_type, ref_id)
+      list Podio.connection.get("/widget/#{ref_type}/#{ref_id}/display/").body
+    end
+  end
+end

data/lib/podio/client.rb

@@ -1,13 +1,7 @@
-require 'podio/middleware/logger'
-require 'podio/middleware/oauth2'
-require 'podio/middleware/mashify'
-require 'podio/middleware/podio_api'
-require 'podio/middleware/yajl_response'
-require 'podio/middleware/error_response'
-
 module Podio
   class Client
-    attr_reader :api_url, :api_key, :api_secret, :debug, :oauth_token, :connection
+    attr_reader :api_url, :api_key, :api_secret, :debug, :connection
+    attr_accessor :oauth_token, :stubs
 
     def initialize(options = {})
       @api_url = options[:api_url] || Podio.api_url || 'https://api.podio.com'
@@ -16,12 +10,23 @@ module Podio
       @debug = options[:debug] || Podio.debug
       @oauth_token = options[:oauth_token]
 
-      @connection = configure_connection
-      @oauth_connection = configure_oauth_connection
+      if options[:enable_stubs]
+        @enable_stubs = true
+        @stubs = Faraday::Adapter::Test::Stubs.new
+      end
+      @test_mode   = options[:test_mode]
+      @record_mode = options[:record_mode]
+
+      setup_connections
+    end
+
+    def reset
+      setup_connections
     end
 
+    # Sign in as a user
     def get_access_token(username, password)
-      response = connection.post do |req|
+      response = @oauth_connection.post do |req|
         req.url '/oauth/token', :grant_type => 'password', :client_id => api_key, :client_secret => api_secret, :username => username, :password => password
       end
 
@@ -29,6 +34,17 @@ module Podio
       configure_oauth
       @oauth_token
     end
+    
+    # Sign in as an app
+    def get_access_token_as_app(app_id, app_token)
+      response = @oauth_connection.post do |req|
+        req.url '/oauth/token', :grant_type => 'app', :client_id => api_key, :client_secret => api_secret, :app_id => app_id, :app_token => app_token
+      end
+
+      @oauth_token = OAuthToken.new(response.body)
+      configure_oauth
+      @oauth_token
+    end
 
     def refresh_access_token
       response = @oauth_connection.post do |req|
@@ -39,37 +55,50 @@ module Podio
       configure_oauth
     end
 
+    def configured_headers
+      headers = {}
+      headers['User-Agent']      = 'Podio Ruby Library'
+      headers['authorization']   = "OAuth2 #{oauth_token.access_token}" if oauth_token
+      headers['X-Podio-Dry-Run'] = '1'                                  if @test_mode
+
+      headers
+    end
+
   private
 
-    def configure_connection
-      params = {}
-      params[:oauth_token] = oauth_token.access_token if oauth_token
+    def setup_connections
+      @connection = configure_connection
+      @oauth_connection = configure_oauth_connection
+    end
 
-      Faraday::Connection.new(:url => api_url, :params => params, :headers => default_headers, :request => {:client => self}) do |builder|
+    def configure_connection
+      Faraday::Connection.new(:url => api_url, :headers => configured_headers, :request => {:client => self}) do |builder|
         builder.use Faraday::Request::Yajl
         builder.use Middleware::PodioApi
         builder.use Middleware::OAuth2
         builder.use Middleware::Logger
-        builder.adapter Faraday.default_adapter
+        builder.adapter(*default_adapter)
+        builder.use Middleware::ResponseRecorder if @record_mode
         builder.use Middleware::YajlResponse
-        builder.use Middleware::Mashify
         builder.use Middleware::ErrorResponse
+        builder.use Middleware::DateConversion
       end
     end
 
+    def default_adapter
+      @enable_stubs ? [:test, @stubs] : Faraday.default_adapter
+    end
+
     def configure_oauth_connection
       conn = @connection.dup
       conn.options[:client] = self
-      conn.params = {}
+      conn.headers.delete('authorization')
+      conn.headers.delete('X-Podio-Dry-Run') if @test_mode # oauth requests don't really work well in test mode
       conn
     end
 
     def configure_oauth
       @connection = configure_connection
     end
-
-    def default_headers
-      { :user_agent => 'Podio Ruby Library' }
-    end
   end
 end

data/lib/podio/error.rb

@@ -0,0 +1,10 @@
+module Podio
+  module Error
+    class TokenExpired < StandardError; end
+    class AuthorizationError < StandardError; end
+    class BadRequestError < StandardError; end
+    class ServerError < StandardError; end
+    class NotFoundError < StandardError; end
+    class GoneError < StandardError; end
+  end
+end

data/lib/podio/middleware/date_conversion.rb

@@ -0,0 +1,40 @@
+module Podio
+  module Middleware
+    class DateConversion < Faraday::Response::Middleware
+      def self.register_on_complete(env)
+        env[:response].on_complete do |finished_env|
+          convert_dates(finished_env[:body])
+        end
+      end
+      
+      # Converts all attributes ending with "_on" to datetime and ending with "date" to date
+      def self.convert_dates(body)
+        [body].flatten.compact.each do |hash|
+          hash.each do |key, value|
+            if value.is_a?(Hash)
+              self.convert_dates(value)
+            elsif value.is_a?(Array)
+              value.each_with_index { |item, index| hash[key][index] = self.convert_field(key, item) }
+            else
+              hash[key] = self.convert_field(key, value)
+            end
+          end
+        end
+      end
+      
+      private
+      
+        def self.convert_field(key, value)
+          if key.present?
+            if key[-3..-1] == "_on"
+              return value.try(:to_s).try(:to_datetime)
+            elsif key[-4..-1] == "date"
+              return value.try(:to_s).try(:to_date)
+            end
+          end
+          value
+        end
+      
+    end
+  end
+end

data/lib/podio/middleware/error_response.rb

@@ -7,21 +7,21 @@ module Podio
         env[:response].on_complete do |finished_env|
           case finished_env[:status]
             when 400
-              raise Error::BadRequestError, finished_env[:body].error
+              raise Error::BadRequestError, finished_env[:body]
             when 401
-              if finished_env[:body]['error'] == 'Unauthorized: expired_token'
-                raise Error::TokenExpired, finished_env[:body].error
+              if finished_env[:body]['error_description'] =~ /expired_token/
+                raise Error::TokenExpired, finished_env[:body].inspect
               else
-                raise Error::AuthorizationError, finished_env[:body].error
+                raise Error::AuthorizationError, finished_env[:body].inspect
               end
             when 403
-              raise Error::AuthorizationError, finished_env[:body].error
+              raise Error::AuthorizationError, finished_env[:body].inspect
             when 404
               raise Error::NotFoundError, "#{finished_env[:method].to_s.upcase} #{finished_env[:url]}"
             when 410
               raise Error::GoneError, "#{finished_env[:method].to_s.upcase} #{finished_env[:url]}"
             when 500
-              raise Error::ServerError, finished_env[:body].error
+              raise Error::ServerError, finished_env[:body].inspect
           end
         end
       end

data/lib/podio/middleware/logger.rb

@@ -8,7 +8,13 @@ module Podio
           puts "\n==> #{env[:method].to_s.upcase} #{env[:url]} \n\n"
         end
 
-        @app.call(env)
+        begin
+          @app.call(env)
+        ensure
+          if env[:request][:client].debug
+            puts "\n== (#{env[:status]}) ==> #{env[:body]}\n\n"
+          end
+        end
       end
 
       def initialize(app)

data/lib/podio/middleware/oauth2.rb

@@ -12,8 +12,8 @@ module Podio
         rescue Error::TokenExpired
           podio_client.refresh_access_token
 
-          params = orig_env[:url].query_values || {}
-          orig_env[:url].query_values = params.merge('oauth_token' => podio_client.oauth_token.access_token)
+          # new access token needs to be put into the header
+          orig_env[:request_headers].merge!(podio_client.configured_headers)
 
           # redo the request with the new access token
           @app.call(orig_env)

data/lib/podio/middleware/response_recorder.rb

@@ -0,0 +1,16 @@
+require 'digest/md5'
+
+module Podio
+  module Middleware
+    class ResponseRecorder < Faraday::Response::Middleware
+      def self.register_on_complete(env)
+        env[:response].on_complete do |finished_env|
+          response = "['#{Faraday::Utils.normalize_path(finished_env[:url])}', :#{finished_env[:method]}, #{finished_env[:status]}, #{finished_env[:response_headers]}, '#{finished_env[:body]}']"
+
+          filename = Digest::MD5.hexdigest(finished_env[:url].request_uri)
+          File.open("#{filename}.rack", 'w') { |f| f.write(response) }
+        end
+      end
+    end
+  end
+end

data/lib/podio/response_wrapper.rb

@@ -0,0 +1,15 @@
+module Podio
+  module ResponseWrapper
+    def member(response)
+      response
+    end
+
+    def list(response)
+      response
+    end
+
+    def collection(response)
+      Struct.new(:all, :count, :total_count).new(response['items'], response['filtered'], response['total'])
+    end
+  end
+end

data/lib/podio/version.rb

@@ -1,3 +1,3 @@
 module Podio
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/podio.gemspec

@@ -16,10 +16,8 @@ Gem::Specification.new do |s|
   s.require_paths     = ['lib']
 
   s.add_runtime_dependency 'faraday', '~> 0.5.1'
-  s.add_runtime_dependency 'hashie', '~> 0.4.0'
-  s.add_runtime_dependency 'yajl-ruby', '~> 0.7.0'
-
-  s.add_development_dependency 'fakeweb', '~> 1.3'
+  s.add_runtime_dependency 'activesupport', '~> 3.0'
+  s.add_runtime_dependency 'yajl-ruby', '~> 0.7'
 
   s.description       = <<desc
 The humble beginnings of the Ruby wrapper for the Podio API.

data/test/app_store_test.rb

@@ -0,0 +1,40 @@
+require_relative 'test_helper'
+
+class AppStoreTest < ActiveSupport::TestCase
+  test 'should find single category' do
+    category = Podio::Category.find(1)
+
+    assert_equal 1, category['category_id']
+  end
+
+  test 'should find all categories' do
+    categories = Podio::Category.find_all
+
+    assert_equal Array, categories.functional.class
+    assert_not_nil categories.functional.first['category_id']
+
+    assert_equal Array, categories.vertical.class
+    assert_not_nil categories.vertical.first['category_id']
+  end
+
+  test 'should create category' do
+    login_as_user(2)
+
+    status = Podio::Category.create(:type => 'vertical', :name => 'New Category')
+    assert_equal 200, status
+  end
+
+  test 'should update category' do
+    login_as_user(2)
+
+    status = Podio::Category.update(1, :name => 'New name')
+    assert_equal 204, status
+  end
+
+  test 'should delete category' do
+    login_as_user(2)
+
+    status = Podio::Category.delete(3)
+    assert_equal 204, status
+  end
+end

data/test/client_test.rb

@@ -1,81 +1,74 @@
 require_relative 'test_helper'
 
-context 'ClientTest' do
-  context 'client configuration' do
-    setup do
-      Podio.configure do |config|
-        config.api_url = 'https://api.podio.com'
-        config.api_key = 'client_id'
-        config.api_secret = 'client_secret'
-      end
+class ClientTest < ActiveSupport::TestCase
+  def setup
+    Podio.configure do |config|
+      config.api_url = 'https://api.podio.com'
+      config.api_key = 'client_id'
+      config.api_secret = 'client_secret'
     end
+  end
 
-    test 'should configure defaults' do
-      podio = Podio::Client.new
+  test 'should configure defaults' do
+    podio = Podio::Client.new
 
-      assert_equal 'https://api.podio.com', podio.api_url
-      assert_equal 'client_id', podio.api_key
-      assert_equal 'client_secret', podio.api_secret
-    end
+    assert_equal 'https://api.podio.com', podio.api_url
+    assert_equal 'client_id', podio.api_key
+    assert_equal 'client_secret', podio.api_secret
+  end
 
-    test 'should overwrite defaults' do
-      podio = Podio::Client.new(:api_url => 'https://new.podio.com', :api_key => 'new_client_id', :api_secret => 'new_client_secret')
+  test 'should overwrite defaults' do
+    podio = Podio::Client.new(:api_url => 'https://new.podio.com', :api_key => 'new_client_id', :api_secret => 'new_client_secret')
 
-      assert_equal 'https://new.podio.com', podio.api_url
-      assert_equal 'new_client_id', podio.api_key
-      assert_equal 'new_client_secret', podio.api_secret
-    end
+    assert_equal 'https://new.podio.com', podio.api_url
+    assert_equal 'new_client_id', podio.api_key
+    assert_equal 'new_client_secret', podio.api_secret
+  end
 
-    test 'should setup connection' do
-      token = Podio::OAuthToken.new('access_token' => 'access', 'refresh_token' => 'refresh')
-      podio = Podio::Client.new(:oauth_token => token)
+  test 'should setup connection' do
+    token = Podio::OAuthToken.new('access_token' => 'access', 'refresh_token' => 'refresh')
+    podio = Podio::Client.new(:oauth_token => token)
 
-      assert_equal token, podio.oauth_token
+    assert_equal token, podio.oauth_token
 
-      assert_equal({'oauth_token' => 'access'}, podio.connection.params)
-    end
+    assert_equal 'OAuth2 access', podio.connection.headers['authorization']
   end
 
-  context 'oauth2 authorization' do
-    test 'should get an access token' do
-      client = Podio::Client.new(:api_url => 'https://api.podio.com', :api_key => 'client_id', :api_secret => 'client_secret')
-      assert_nil client.oauth_token
-
-      stub_post(
-        '/oauth/token?grant_type=password&client_id=client_id&client_secret=client_secret&username=username&password=password',
-        {'access_token' => 'access', 'refresh_token' => 'refresh', 'expires_in' => 3600}
-      )
+  test 'should get an access token' do
+    client = Podio.client
+    client.oauth_token = nil
+    assert_nil client.oauth_token
 
-      client.get_access_token('username', 'password')
+    client.get_access_token('pollas@hoisthq.com', 'secret')
 
-      assert_equal 'access', client.oauth_token.access_token
-      assert_equal 'refresh', client.oauth_token.refresh_token
-    end
-
-    test 'should be able to refresh access token' do
-      client = podio_test_client
+    assert_not_nil client.oauth_token.access_token
+    assert_not_nil client.oauth_token.refresh_token
+  end
 
-      stub_post(
-        '/oauth/token?grant_type=refresh_token&refresh_token=refresh&client_id=client_id&client_secret=client_secret',
-        {'access_token' => 'new_access', 'refresh_token' => 'refresh', 'expires_in' => 3600}
-      )
+  test 'should be able to refresh access token' do
+    client = Podio.client
+    old_token = client.oauth_token.dup
 
-      client.refresh_access_token
+    client.refresh_access_token
 
-      assert_equal 'new_access', client.oauth_token.access_token
-      assert_equal 'refresh', client.oauth_token.refresh_token
-    end
+    assert_not_equal old_token.access_token, client.oauth_token.access_token
+    assert_equal old_token.refresh_token, client.oauth_token.refresh_token
   end
 
-  context 'raw connection' do
-    test 'should be able to make arbitrary requests' do
-      client = podio_test_client
+  test 'should automatically refresh an expired token' do
+    # this token is already expired in the test database
+    Podio.client.oauth_token = Podio::OAuthToken.new('access_token' => '30da4594eef93528c11df7fb5deb989cd629ea7060a1ce1ced628d19398214c942bcfe0334cf953ef70a80ea1afdfd80183d5c75d19c1f5526ca4c6f6f3471ef', 'refresh_token' => '82e7a11ae187f28a25261599aa6229cd89f8faee48cba18a75d70efae88ba665ced11d43143b7f5bebb31a4103662b851dd2db1879a3947b843259479fccfad3', 'expires_in' => -10)
+    Podio.client.reset
 
-      stub_get('/?oauth_token=access', { 'messaging' => true, 'version' => '1.0.1' })
-
-      response = client.connection.get('/')
+    assert_nothing_raised do
+      response = Podio.client.connection.get('/org/')
       assert_equal 200, response.status
-      assert_equal({ 'messaging' => true, 'version' => '1.0.1' }, response.body)
     end
   end
+
+  test 'should be able to make arbitrary requests' do
+    response = Podio.client.connection.get('/org/')
+    assert_equal 200, response.status
+    assert response.body.is_a?(Array)
+  end
 end