podio 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Florian Munz
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,13 @@
+Podio
+=====
+
+Ruby wrapper for the Podio API.
+
+Meta
+----
+
+* Code: `git clone git://github.com/podio/podio-rb.git`
+* Home: <https://github.com/podio/podio-rb>
+* Bugs: <https://github.com/podio/podio-rb/issues>
+
+This project uses [Semantic Versioning](http://semver.org/).

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake/testtask'
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
+
+desc 'Run tests'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/lib/podio.rb

@@ -0,0 +1,34 @@
+require 'faraday'
+
+module Podio
+  class << self
+    attr_accessor :api_key
+    attr_accessor :api_secret
+    attr_accessor :api_url
+    attr_accessor :debug
+
+    def configure
+      yield self
+      true
+    end
+  end
+
+  class OAuthToken < Struct.new(:access_token, :refresh_token, :expires_at)
+    def initialize(params = {})
+      self.access_token = params['access_token']
+      self.refresh_token = params['refresh_token']
+      self.expires_at = Time.now + params['expires_in'] if params['expires_in']
+    end
+  end
+
+  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
+
+require 'podio/client'

data/lib/podio/client.rb

@@ -0,0 +1,75 @@
+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
+
+    def initialize(options = {})
+      @api_url = options[:api_url] || Podio.api_url || 'https://api.podio.com'
+      @api_key = options[:api_key] || Podio.api_key
+      @api_secret = options[:api_secret] || Podio.api_secret
+      @debug = options[:debug] || Podio.debug
+      @oauth_token = options[:oauth_token]
+
+      @connection = configure_connection
+      @oauth_connection = configure_oauth_connection
+    end
+
+    def get_access_token(username, password)
+      response = connection.post do |req|
+        req.url '/oauth/token', :grant_type => 'password', :client_id => api_key, :client_secret => api_secret, :username => username, :password => password
+      end
+
+      @oauth_token = OAuthToken.new(response.body)
+      configure_oauth
+      @oauth_token
+    end
+
+    def refresh_access_token
+      response = @oauth_connection.post do |req|
+        req.url '/oauth/token', :grant_type => 'refresh_token', :refresh_token => oauth_token.refresh_token, :client_id => api_key, :client_secret => api_secret
+      end
+
+      @oauth_token.access_token = response.body['access_token']
+      configure_oauth
+    end
+
+  private
+
+    def configure_connection
+      params = {}
+      params[:oauth_token] = oauth_token.access_token if oauth_token
+
+      Faraday::Connection.new(:url => api_url, :params => params, :headers => default_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.use Middleware::YajlResponse
+        builder.use Middleware::Mashify
+        builder.use Middleware::ErrorResponse
+      end
+    end
+
+    def configure_oauth_connection
+      conn = @connection.dup
+      conn.options[:client] = self
+      conn.params = {}
+      conn
+    end
+
+    def configure_oauth
+      @connection = configure_connection
+    end
+
+    def default_headers
+      { :user_agent => 'Podio Ruby Library' }
+    end
+  end
+end

data/lib/podio/middleware/error_response.rb

@@ -0,0 +1,34 @@
+# Handle HTTP response status codes
+#
+module Podio
+  module Middleware
+    class ErrorResponse < Faraday::Response::Middleware
+      def self.register_on_complete(env)
+        env[:response].on_complete do |finished_env|
+          case finished_env[:status]
+            when 400
+              raise Error::BadRequestError, finished_env[:body].error
+            when 401
+              if finished_env[:body]['error'] == 'Unauthorized: expired_token'
+                raise Error::TokenExpired, finished_env[:body].error
+              else
+                raise Error::AuthorizationError, finished_env[:body].error
+              end
+            when 403
+              raise Error::AuthorizationError, finished_env[:body].error
+            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
+          end
+        end
+      end
+
+      def initialize(app)
+        super
+      end
+    end
+  end
+end

data/lib/podio/middleware/logger.rb

@@ -0,0 +1,19 @@
+# Do some debug logging
+#
+module Podio
+  module Middleware
+    class Logger < Faraday::Middleware
+      def call(env)
+        if env[:request][:client].debug
+          puts "\n==> #{env[:method].to_s.upcase} #{env[:url]} \n\n"
+        end
+
+        @app.call(env)
+      end
+
+      def initialize(app)
+        super
+      end
+    end
+  end
+end

data/lib/podio/middleware/mashify.rb

@@ -0,0 +1,27 @@
+module Podio
+  module Middleware
+    class Mashify < Faraday::Response::Middleware
+      begin
+        require 'hashie'
+      rescue LoadError, NameError => error
+        self.load_error = error
+      end
+
+      def self.register_on_complete(env)
+        env[:response].on_complete do |response|
+          response_body = response[:body]
+          if response_body.is_a?(Hash)
+            response[:body] = ::Hashie::Mash.new(response_body)
+          elsif response_body.is_a?(Array) and response_body.first.is_a?(Hash)
+            response[:body] = response_body.map{|item| ::Hashie::Mash.new(item)}
+          end
+        end
+      end
+
+      def initialize(app)
+        super
+        @parser = nil
+      end
+    end
+  end
+end

data/lib/podio/middleware/oauth2.rb

@@ -0,0 +1,28 @@
+# Retry requests with expired access tokens
+#
+module Podio
+  module Middleware
+    class OAuth2 < Faraday::Middleware
+      def call(env)
+        podio_client = env[:request][:client]
+        orig_env = env.dup
+
+        begin
+          @app.call(env)
+        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)
+
+          # redo the request with the new access token
+          @app.call(orig_env)
+        end
+      end
+
+      def initialize(app)
+        super
+      end
+    end
+  end
+end

data/lib/podio/middleware/podio_api.rb

@@ -0,0 +1,19 @@
+# Fix for Podio API specific weirdnesses
+#
+module Podio
+  module Middleware
+    class PodioApi < Faraday::Middleware
+      def call(env)
+        if env[:method] == :post && env[:body].nil?
+          env[:body] = ''
+        end
+
+        @app.call(env)
+      end
+
+      def initialize(app)
+        super
+      end
+    end
+  end
+end

data/lib/podio/middleware/yajl_response.rb

@@ -0,0 +1,31 @@
+# Custom Yajl until I find a way to only parse the body once in
+# the OAuth2 retry case
+#
+module Podio
+  module Middleware
+    class YajlResponse < Faraday::Response::Middleware
+      begin
+        require 'yajl'
+
+        def self.register_on_complete(env)
+          env[:response].on_complete do |finished_env|
+            finished_env[:body] = parse(finished_env[:body]) if finished_env[:body].is_a?(String)
+          end
+        end
+      rescue LoadError, NameError => e
+        self.load_error = e
+      end
+
+      def initialize(app)
+        super
+        @parser = nil
+      end
+
+      def self.parse(body)
+        Yajl::Parser.parse(body)
+      rescue Object => err
+        raise Faraday::Error::ParsingError.new(err)
+      end
+    end
+  end
+end

data/lib/podio/version.rb

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

data/podio.gemspec

@@ -0,0 +1,27 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'podio/version'
+
+Gem::Specification.new do |s|
+  s.name              = 'podio'
+  s.version           = Podio::VERSION
+  s.platform          = Gem::Platform::RUBY
+  s.summary           = 'Ruby wrapper for the Podio API'
+  s.homepage          = 'https://github.com/podio/podio-rb'
+  s.email             = 'florian@podio.com'
+  s.authors           = ['Florian Munz']
+  s.has_rdoc          = false
+
+  s.files             = `git ls-files`.split("\n")
+  s.test_files        = `git ls-files -- {test,spec,features}/*`.split("\n")
+  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.description       = <<desc
+The humble beginnings of the Ruby wrapper for the Podio API.
+desc
+end

data/test/client_test.rb

@@ -0,0 +1,81 @@
+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
+    end
+
+    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
+
+    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
+
+    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({'oauth_token' => 'access'}, podio.connection.params)
+    end
+  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}
+      )
+
+      client.get_access_token('username', 'password')
+
+      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
+
+      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}
+      )
+
+      client.refresh_access_token
+
+      assert_equal 'new_access', client.oauth_token.access_token
+      assert_equal 'refresh', client.oauth_token.refresh_token
+    end
+  end
+
+  context 'raw connection' do
+    test 'should be able to make arbitrary requests' do
+      client = podio_test_client
+
+      stub_get('/?oauth_token=access', { 'messaging' => true, 'version' => '1.0.1' })
+
+      response = client.connection.get('/')
+      assert_equal 200, response.status
+      assert_equal({ 'messaging' => true, 'version' => '1.0.1' }, response.body)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,61 @@
+require 'test/unit'
+require 'yajl'
+require 'fakeweb'
+
+require 'podio'
+
+
+FakeWeb.allow_net_connect = false
+
+def podio_test_client
+  token = Podio::OAuthToken.new('access_token' => 'access', 'refresh_token' => 'refresh', 'expires_in' => 3600)
+  Podio::Client.new(:api_url => 'https://api.podio.com', :api_key => 'client_id', :api_secret => 'client_secret', :oauth_token => token)
+end
+
+def fixture_file(filename)
+  return '' if filename == ''
+  file_path = File.expand_path(File.dirname(__FILE__) + '/fixtures/' + filename)
+  File.read(file_path)
+end
+
+def stub_get(url, body, options = {})
+  opts = {
+    :body => body.is_a?(String) ? body : Yajl::Encoder.encode(body),
+    :content_type => 'application/json; charset=utf-8'
+  }.merge(options)
+  FakeWeb.register_uri(:get, "https://api.podio.com#{url}", opts)
+end
+
+def stub_post(url, body, options = {})
+  opts = {
+    :body => body.is_a?(String) ? body : Yajl::Encoder.encode(body),
+    :content_type => 'application/json; charset=utf-8'
+  }.merge(options)
+  FakeWeb.register_uri(:post, "https://api.podio.com#{url}", opts)
+end
+
+
+##
+# test/spec/mini 5
+# http://gist.github.com/307649
+# chris@ozmm.org
+#
+def context(*args, &block)
+  return super unless (name = args.first) && block
+  require 'test/unit'
+  klass = Class.new(defined?(ActiveSupport::TestCase) ? ActiveSupport::TestCase : Test::Unit::TestCase) do
+    def self.test(name, &block)
+      define_method("test_#{name.to_s.gsub(/\W/,'_')}", &block) if block
+    end
+    def self.xtest(*args) end
+    def self.context(*args, &block) instance_eval(&block) end
+    def self.setup(&block)
+      define_method(:setup) { self.class.setups.each { |s| instance_eval(&s) } }
+      setups << block
+    end
+    def self.setups; @setups ||= [] end
+    def self.teardown(&block) define_method(:teardown, &block) end
+  end
+  (class << klass; self end).send(:define_method, :name) { name.gsub(/\W/,'_') }
+  klass.class_eval(&block)
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification 
+name: podio
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Florian Munz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-07 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: faraday
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 0
+        - 5
+        - 1
+        version: 0.5.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hashie
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 4
+        - 0
+        version: 0.4.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        - 7
+        - 0
+        version: 0.7.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :development
+  version_requirements: *id004
+description: |
+  The humble beginnings of the Ruby wrapper for the Podio API.
+
+email: florian@podio.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/podio.rb
+- lib/podio/client.rb
+- lib/podio/middleware/error_response.rb
+- lib/podio/middleware/logger.rb
+- lib/podio/middleware/mashify.rb
+- lib/podio/middleware/oauth2.rb
+- lib/podio/middleware/podio_api.rb
+- lib/podio/middleware/yajl_response.rb
+- lib/podio/version.rb
+- podio.gemspec
+- test/client_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: https://github.com/podio/podio-rb
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby wrapper for the Podio API
+test_files: 
+- test/client_test.rb
+- test/test_helper.rb