omniauth 0.2.4 → 0.2.5

data/oa-oauth/lib/omniauth/strategies/tsohu.rb

@@ -0,0 +1,57 @@
+require 'omniauth/oauth'
+require 'multi_json'
+
+module OmniAuth
+  module Strategies
+    #
+    # Authenticate to Tsohu via OAuth and retrieve basic
+    # user information.
+    #
+    # Usage:
+    #
+    #    use OmniAuth::Strategies::Tsohu, 'APIKey', 'APIKeySecret'
+    #
+    class Tsohu < OmniAuth::Strategies::OAuth
+
+      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
+        @api_key = consumer_key
+
+        client_options = {
+          :site               => 'http://api.t.sohu.com',
+          :request_token_path => '/oauth/request_token',
+          :access_token_path  => '/oauth/access_token',
+          :authorize_path     => '/oauth/authorize',
+          :scheme             => :header,
+        }
+
+        super(app, :tsohu, consumer_key, consumer_secret, client_options, options, &block)
+      end
+
+      def auth_hash
+        OmniAuth::Utils.deep_merge(super, {
+          'uid' => user_hash['id'],
+          'user_info' => user_info,
+          'extra' => {'user_hash' => user_hash}
+        })
+      end
+
+      def user_info
+        user_hash = self.user_hash
+        {
+          'username' => user_hash['screen_name'],
+          'name' => user_hash['name'],
+          'location' => user_hash['location'],
+          'image' => user_hash['profile_image_url'],
+          'description' => user_hash['description'],
+          'urls' => {
+            'Tsohu' => user_hash['url']
+          }
+        }
+      end
+
+      def user_hash
+        @user_hash ||= MultiJson.decode(@access_token.get("http://api.t.sohu.com/account/verify_credentials.json").body)
+      end
+    end
+  end
+end

data/oa-oauth/lib/omniauth/strategies/tumblr.rb

@@ -0,0 +1,60 @@
+require 'omniauth/oauth'
+
+module OmniAuth
+  module Strategies
+    #
+    # Authenticate to Tumblr via OAuth and retrieve basic
+    # user information.
+    #
+    # Usage:
+    #
+    #    use OmniAuth::Strategies::Tumblr, 'consumerkey', 'consumersecret'
+    #
+    class Tumblr < OmniAuth::Strategies::OAuth
+      # Initialize the middleware
+      #
+      # @option options [Boolean, true] :sign_in When true, use the "Sign in with Tumblr" flow instead of the authorization flow.
+      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
+        client_options = {
+          :site => 'http://www.tumblr.com'
+        }
+
+        client_options[:authorize_path] = '/oauth/authorize' unless options[:sign_in] == false
+        super(app, :tumblr, consumer_key, consumer_secret, client_options, options)
+      end
+
+      def auth_hash
+        OmniAuth::Utils.deep_merge(super, {
+          'uid' => user['name'],
+          'user_info' => user_info,
+          'extra' => { 'user_hash' => user }
+        })
+      end
+
+      def user_info
+        {
+          'nickname' => user['name'],
+          'name' => user['title'],
+          'image' => user['avatar_url'],
+          'urls' => {
+            'website' => user['url'],
+          }
+        }
+      end
+
+      def user
+        tumblelogs = user_hash['tumblr']['tumblelog']
+        if tumblelogs.kind_of?(Array)
+          @user ||= tumblelogs[0]
+        else
+          @user ||= tumblelogs
+        end
+      end
+
+      def user_hash
+        url = "http://www.tumblr.com/api/authenticate"
+        @user_hash ||= Hash.from_xml(@access_token.get(url).body)
+      end
+    end
+  end
+end

data/oa-oauth/lib/omniauth/strategies/twitter.rb

@@ -0,0 +1,57 @@
+require 'omniauth/oauth'
+require 'multi_json'
+
+module OmniAuth
+  module Strategies
+    #
+    # Authenticate to Twitter via OAuth and retrieve basic
+    # user information.
+    #
+    # Usage:
+    #
+    #    use OmniAuth::Strategies::Twitter, 'consumerkey', 'consumersecret'
+    #
+    class Twitter < OmniAuth::Strategies::OAuth
+      # Initialize the middleware
+      #
+      # @option options [Boolean, true] :sign_in When true, use the "Sign in with Twitter" flow instead of the authorization flow.
+      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
+        client_options = {
+          :site => 'https://api.twitter.com'
+        }
+
+        options[:authorize_params] = {:force_login => 'true'} if options.delete(:force_login) == true
+        client_options[:authorize_path] = '/oauth/authenticate' unless options[:sign_in] == false
+        super(app, :twitter, consumer_key, consumer_secret, client_options, options)
+      end
+
+      def auth_hash
+        OmniAuth::Utils.deep_merge(super, {
+          'uid' => @access_token.params[:user_id],
+          'user_info' => user_info,
+          'extra' => {'user_hash' => user_hash}
+        })
+      end
+
+      def user_info
+        user_hash = self.user_hash
+
+        {
+          'nickname' => user_hash['screen_name'],
+          'name' => user_hash['name'] || user_hash['screen_name'],
+          'location' => user_hash['location'],
+          'image' => user_hash['profile_image_url'],
+          'description' => user_hash['description'],
+          'urls' => {
+            'Website' => user_hash['url'],
+            'Twitter' => 'http://twitter.com/' + user_hash['screen_name']
+          }
+        }
+      end
+
+      def user_hash
+        @user_hash ||= MultiJson.decode(@access_token.get('/1/account/verify_credentials.json').body)
+      end
+    end
+  end
+end

data/oa-oauth/lib/omniauth/strategies/type_pad.rb

@@ -0,0 +1,76 @@
+require 'omniauth/oauth'
+require 'multi_json'
+
+module OmniAuth
+  module Strategies
+    #
+    # Authenticate to Typepad via OAuth and retrieve basic
+    # user information.
+    #
+    # Usage:
+    #
+    #    use OmniAuth::Strategies::Typepad, 'consumerkey', 'consumersecret', :application_id => 'my_type_pad_application_id'
+    #
+    #    application_id is required.
+    #
+    class TypePad < OmniAuth::Strategies::OAuth
+      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
+
+        # TypePad uses the application ID for one of the OAuth paths.
+        app_id = options[:application_id]
+
+        client_options = {
+          :site => 'https://www.typepad.com',
+          :request_token_path => '/secure/services/oauth/request_token',
+          :access_token_path => '/secure/services/oauth/access_token',
+          :authorize_path => "/secure/services/api/#{app_id}/oauth-approve",
+          :http_method => :get,
+          # You *must* use query_string for the token dance.
+          :scheme => :query_string
+        }
+
+        options.merge! :scheme => :query_string, :http_method => :get
+
+        super(app, :type_pad, consumer_key, consumer_secret, client_options, options)
+      end
+
+      def auth_hash
+        ui = user_info
+        OmniAuth::Utils.deep_merge(super, {
+          'uid' => ui['uid'],
+          'user_info' => ui,
+          'extra' => {'user_hash' => user_hash}
+        })
+      end
+
+      def user_info
+        user_hash = self.user_hash
+
+        {
+          'uid' => user_hash['urlId'],
+          'nickname' => user_hash['preferredUsername'],
+          'name' => user_hash['displayName'],
+          'image' => user_hash['avatarLink']['url'],
+          'description' => user_hash['aboutMe'],
+          'urls' => {'Profile' => user_hash['profilePageUrl']}
+        }
+      end
+
+      def user_hash
+        # For authenticated requests, you have to use header as your scheme.
+        # Failure to do so gives a unique response body - 'Auth is required'.
+        # 'Unauthorized' is the response body of a truly unauthorized request.
+
+        # Also note that API requests hit a different site than the OAuth dance.
+        r = self.consumer.request(
+              :get,
+              "https://api.typepad.com/users/@self.json",
+              @access_token,
+              :scheme => 'header'
+            )
+
+        @user_hash ||= MultiJson.decode(r.body)
+      end
+    end
+  end
+end

data/oa-oauth/lib/omniauth/strategies/vimeo.rb

@@ -0,0 +1,54 @@
+require 'omniauth/oauth'
+require 'multi_json'
+
+module OmniAuth
+  module Strategies
+    #
+    # Authenticate to Vimeo via OAuth and retrieve basic user information.
+    #
+    # Usage:
+    #
+    #    use OmniAuth::Strategies::Vimeo, 'consumerkey', 'consumersecret'
+    #
+    class Vimeo < OmniAuth::Strategies::OAuth
+      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
+        opts = {
+          :site               => 'http://vimeo.com',
+          :request_token_path => '/oauth/request_token',
+          :access_token_path  => '/oauth/access_token',
+          :authorize_path     => '/oauth/authorize'
+        }
+        super(app, :vimeo, consumer_key, consumer_secret, opts, options, &block)
+      end
+
+      def auth_hash
+        user = user_hash['person']
+        OmniAuth::Utils.deep_merge(super, {
+          'uid' => user['id'],
+          'user_info' => user_info,
+          'extra' => { 'user_hash' => user }
+        })
+      end
+
+      def user_info
+        user = user_hash['person']
+        {
+          'nickname' => user['username'],
+          'name' => user['display_name'],
+          'location' => user['location'],
+          'description' => user['bio'],
+          'image' => user['portraits']['portrait'].select{|h| h['height'] == '300'}.first['_content'],
+          'urls' => {
+            'website' => user['url'],
+            'vimeo' => user['profileurl']
+          }
+        }
+      end
+
+      def user_hash
+        url = "http://vimeo.com/api/rest/v2?method=vimeo.people.getInfo&format=json"
+        @user_hash ||= MultiJson.decode(@access_token.get(url).body)
+      end
+    end
+  end
+end

data/oa-oauth/lib/omniauth/strategies/vkontakte.rb

@@ -0,0 +1,84 @@
+require 'omniauth/oauth'
+require 'multi_json'
+
+module OmniAuth
+  module Strategies
+    #
+    # Authenticate to Vkontakte utilizing OAuth 2.0 and retrieve
+    # basic user information.
+    # documentation available here:
+    # http://vkontakte.ru/developers.php?o=-17680044&p=Authorization&s=0
+    #
+    # @example Basic Usage
+    #     use OmniAuth::Strategies::Vkontakte, 'API Key', 'Secret Key'
+    class Vkontakte < OAuth2
+      # @param [Rack Application] app standard middleware application parameter
+      # @param [String] api_key the application id as [registered in Vkontakte]
+      # @param [String] secret_key the application secret as [registered in Vkontakte]
+      def initialize(app, api_key = nil, secret_key = nil, options = {}, &block)
+        client_options = {
+          :site => 'https://vkontakte.ru',
+          :authorize_url => 'http://api.vkontakte.ru/oauth/authorize',
+          :access_token_url => 'https://api.vkontakte.ru/oauth/token'
+        }
+
+        super(app, :vkontakte, api_key, secret_key, client_options, options, &block)
+      end
+
+      protected
+
+      def user_data
+        # http://vkontakte.ru/developers.php?o=-17680044&p=Description+of+Fields+of+the+fields+Parameter
+        @fields ||= ['uid', 'first_name', 'last_name', 'nickname', 'domain', 'sex', 'city', 'country', 'timezone', 'photo', 'photo_big']
+
+        # http://vkontakte.ru/developers.php?o=-1&p=getProfiles
+        @data ||= MultiJson.decode(@access_token.get("https://api.vkontakte.ru/method/getProfiles?uid=#{@access_token['user_id']}&fields=#{@fields.join(',')}&access_token=#{@access_token.token}"))['response'][0]
+
+        # we need these 2 additional requests since vkontakte returns only ids of the City and Country
+        # http://vkontakte.ru/developers.php?o=-17680044&p=getCities
+        @city ||= MultiJson.decode(@access_token.get("https://api.vkontakte.ru/method/getCities?cids=#{@data['city']}&access_token=#{@access_token.token}"))['response'][0]['name']
+
+        # http://vkontakte.ru/developers.php?o=-17680044&p=getCountries
+        @country ||= MultiJson.decode(@access_token.get("https://api.vkontakte.ru/method/getCountries?cids=#{@data['country']}&access_token=#{@access_token}"))['response'][0]['name']
+      end
+
+    def request_phase
+      options[:response_type] ||= 'code'
+      super
+    end
+
+    def user_info
+      {
+        'firstname' => @data['first_name'],
+        'last_name' => @data['last_name'],
+        'name' => "#{@data['first_name']} #{@data['last_name']}",
+        'nickname' => @data['nickname'],
+        'image' => @data['photo'],
+        'location' => "#{@country}, #{@city}",
+        'urls' => {
+          'Vkontakte' => "http://vkontakte.ru/#{@data['domain']}"
+        }
+      }
+    end
+
+    def user_hash
+      {
+        "user_hash" => {
+          "gender" => @data["sex"],
+          "timezone" => @data["timezone"],
+          "photo_big" => @data["photo_big"] # 200px maximum resolution of the avatar (http://vkontakte.ru/developers.php?o=-17680044&p=Description+of+Fields+of+the+fields+Parameter)
+        }
+      }
+    end
+
+    def auth_hash
+      user_data # process user's info
+      OmniAuth::Utils.deep_merge(super, {
+        'uid' => @data['uid'],
+        'user_info' => user_info,
+        'extra' => user_hash
+      })
+    end
+  end
+end
+end

data/oa-oauth/lib/omniauth/strategies/xauth.rb

@@ -0,0 +1,67 @@
+require 'omniauth/oauth'
+require 'multi_json'
+
+module OmniAuth
+  module Strategies
+    class XAuth
+      include OmniAuth::Strategy
+
+      attr_reader :name
+      attr_accessor :consumer_key, :consumer_secret, :consumer_options
+
+      def initialize(app, name, consumer_key = nil, consumer_secret = nil, consumer_options = {}, options = {}, &block)
+        self.consumer_key = consumer_key
+        self.consumer_secret = consumer_secret
+        self.consumer_options = consumer_options
+        super
+      end
+
+      def request_phase
+        session['oauth'] ||= {}
+        if env['REQUEST_METHOD'] == 'GET'
+          get_credentials
+        else
+          session['omniauth.xauth'] = { 'x_auth_mode' => 'client_auth', 'x_auth_username' => request['username'], 'x_auth_password' => request['password'] }
+          redirect callback_path
+        end
+      end
+
+      def get_credentials
+        OmniAuth::Form.build(consumer_options[:title] || "xAuth Credentials") do
+          text_field 'Username', 'username'
+          password_field 'Password', 'password'
+        end.to_response
+      end
+
+      def consumer
+        ::OAuth::Consumer.new(consumer_key, consumer_secret, consumer_options.merge(options[:client_options] || options[:consumer_options] || {}))
+      end
+
+      def callback_phase
+        @access_token = consumer.get_access_token(nil, {}, session['omniauth.xauth'])
+        super
+        rescue ::Net::HTTPFatalError => e
+          fail!(:service_unavailable, e)
+        rescue ::OAuth::Unauthorized => e
+          fail!(:invalid_credentials, e)
+        rescue ::MultiJson::DecodeError => e
+          fail!(:invalid_response, e)
+      ensure
+        session['omniauth.xauth'] = nil
+      end
+
+      def auth_hash
+        OmniAuth::Utils.deep_merge(super, {
+          'credentials' => {
+            'token' => @access_token.token,
+            'secret' => @access_token.secret
+          }, 'extra' => {
+            'access_token' => @access_token
+          }
+        })
+      end
+
+    end
+  end
+end
+