omniauth 0.2.6 → 0.3.0.rc3

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

@@ -1,56 +0,0 @@
-require 'omniauth/oauth'
-require 'multi_json'
-
-module OmniAuth
-  module Strategies
-    #
-    # Authenticate with Meetup via OAuth and retrieve an access token for API usage
-    #
-    # Usage:
-    #
-    #    use OmniAuth::Strategies::Meetup, 'consumerkey', 'consumersecret'
-    #
-    class Meetup < OmniAuth::Strategies::OAuth
-      # Initialize meetup middleware
-      # @param [Rack Application] app standard middleware application parameter
-      # @param [String] consumer_key the application consumer id
-      # @param [String] consumer_secret the application consumer secret
-      # @option options [Boolean, true] :sign_in When true, use a sign-in flow instead of the authorization flow.
-      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
-        auth_path = (options[:sign_in] == false) ? 'http://www.meetup.com/authorize' : 'http://www.meetup.com/authenticate'
-
-        super(app, :meetup, consumer_key, consumer_secret,
-                { :request_token_path  => "https://api.meetup.com/oauth/request",
-                  :access_token_path   => "https://api.meetup.com/oauth/access",
-                  :authorize_path      => auth_path }, options)
-      end
-
-      def auth_hash
-        OmniAuth::Utils.deep_merge(super, {
-          'uid' => member['id'],
-          'user_info' => user_info,
-          'extra' => { 'user_hash' => member }
-        })
-      end
-
-      def user_info
-        {
-          'name' => member['name'],
-          'image' => member['photo_url'],
-          'location' => member['city'],
-          'urls' => {
-            'profile' => member['link']
-          }
-        }
-      end
-
-      def member
-        @member ||= parse(@access_token.get('https://api.meetup.com/members.json?relation=self').body)['results'][0]
-      end
-
-      def parse(response)
-        MultiJson.decode(response)
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-require 'omniauth/oauth'
-require 'multi_json'
-
-module OmniAuth
-  module Strategies
-    #
-    # Authenticate to Miso via OAuth and retrieve basic
-    # user information.
-    #
-    # Usage:
-    #
-    #    use OmniAuth::Strategies::Miso, 'consumerkey', 'consumersecret'
-    #
-    class Miso < OmniAuth::Strategies::OAuth
-      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
-        super(app, :miso, consumer_key, consumer_secret, {:site => 'https://gomiso.com'}, options)
-      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
-        {
-          'nickname' => user_hash['username'],
-          'name' => user_hash['full_name'],
-          'image' => user_hash['profile_image_url'],
-          'description' => user_hash['tagline'],
-        }
-      end
-
-      def user_hash
-        @user_hash ||= MultiJson.decode(@access_token.get('/api/oauth/v1/users/show.json').body)['user']
-      end
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-require 'omniauth/oauth'
-require 'multi_json'
-
-module OmniAuth
-  module Strategies
-    # Authenticate to Facebook utilizing OAuth 2.0 and retrieve
-    # basic user information.
-    #
-    # @example Basic Usage
-    #   use OmniAuth::Strategies::Mixi, 'client_id', 'client_secret'
-    class Mixi < OAuth2
-      # @option options [String] :scope separate the scopes by a space
-      def initialize(app, client_id = nil, client_secret = nil, options = {}, &block)
-        client_options = {
-          :site => "https://mixi.jp/",
-          :authorize_url      => "/connect_authorize.pl",
-          :access_token_url   => "https://secure.mixi-platform.com/2/token"
-        }
-
-        super(app, :mixi, client_id, client_secret, client_options, options, &block)
-      end
-
-      def user_data
-        @data ||= MultiJson.decode(@access_token.get(
-          "http://api.mixi-platform.com/2/people/@me/@self",
-          {'oauth_token' => @access_token.token}
-        ))
-      end
-
-      def request_phase
-        options[:scope] ||= "r_profile"
-        options[:display] ||= "pc"
-        options[:response_type] ||= 'code'
-        super
-      end
-
-      def callback_phase
-        options[:grant_type] ||= 'authorization_code'
-        super
-      end
-
-      def user_info
-        {
-          'nickname' => user_data['entry']['displayName'],
-          'image' => user_data['entry']['thumbnailUrl'],
-          'urls' => {:profile => user_data['entry']['profileUrl']}
-        }
-      end
-
-      def auth_hash
-        OmniAuth::Utils.deep_merge(super, {
-          'uid' => user_data['entry']['id'],
-          'user_info' => user_info,
-          'extra' => {'user_hash' => user_data['entry']}
-        })
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-require 'omniauth/oauth'
-require 'multi_json'
-
-module OmniAuth
-  module Strategies
-    #
-    # Authenticate to Netflix via OAuth and retrieve basic user information.
-    # Usage:
-    #    use OmniAuth::Strategies::Netflix, 'consumerkey', 'consumersecret'
-    #
-    class Netflix < OmniAuth::Strategies::OAuth
-      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
-        opts = {
-          :site               => 'http://api.netflix.com',
-          :request_token_path => "/oauth/request_token",
-          :access_token_path  => "/oauth/access_token",
-          :authorize_url      => "https://api-user.netflix.com/oauth/login"
-        }
-        super(app, :netflix, consumer_key, consumer_secret, opts, options, &block)
-      end
-
-      def request_phase
-        request_token = consumer.get_request_token(:oauth_callback => callback_url)
-        session['oauth'] ||= {}
-        session['oauth'][name.to_s] = {'callback_confirmed' => request_token.callback_confirmed?, 'request_token' => request_token.token, 'request_secret' => request_token.secret}
-        r = Rack::Response.new
-
-        if request_token.callback_confirmed?
-          r.redirect(request_token.authorize_url(
-            :oauth_consumer_key => consumer.key
-          ))
-        else
-          r.redirect(request_token.authorize_url(
-            :oauth_callback => callback_url,
-            :oauth_consumer_key => consumer.key
-          ))
-        end
-
-        r.finish
-      end
-
-      def auth_hash
-        OmniAuth::Utils.deep_merge(super, {
-          'uid' => user_hash['user']['user_id'],
-          'user_info' => user_info,
-          'extra' => { 'user_hash' => user_hash['user'] }
-        })
-      end
-
-      def user_info
-        user = user_hash['user']
-        {
-          'nickname' => user['nickname'],
-          'first_name' => user['first_name'],
-          'last_name' => user['last_name'],
-          'name' => "#{user['first_name']} #{user['last_name']}"
-        }
-      end
-
-      def user_hash
-        @user_hash ||= MultiJson.decode(@access_token.get("http://api.netflix.com/users/#{@access_token.params[:user_id]}?output=json").body)
-      end
-    end
-  end
-end

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

@@ -1,83 +0,0 @@
-require 'multi_json'
-require 'oauth'
-require 'omniauth/oauth'
-
-module OmniAuth
-  module Strategies
-    class OAuth
-      include OmniAuth::Strategy
-
-      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
-        self.options[:open_timeout] ||= 30
-        self.options[:read_timeout] ||= 30
-        self.options[:authorize_params] = options[:authorize_params] || {}
-      end
-
-      def consumer
-        consumer = ::OAuth::Consumer.new(consumer_key, consumer_secret, consumer_options.merge(options[:client_options] || options[:consumer_options] || {}))
-        consumer.http.open_timeout = options[:open_timeout] if options[:open_timeout]
-        consumer.http.read_timeout = options[:read_timeout] if options[:read_timeout]
-        consumer
-      end
-
-      attr_reader :name
-      attr_accessor :consumer_key, :consumer_secret, :consumer_options
-
-      def request_phase
-        request_token = consumer.get_request_token(:oauth_callback => callback_url)
-        session['oauth'] ||= {}
-        session['oauth'][name.to_s] = {'callback_confirmed' => request_token.callback_confirmed?, 'request_token' => request_token.token, 'request_secret' => request_token.secret}
-
-        if request_token.callback_confirmed?
-          redirect request_token.authorize_url(options[:authorize_params])
-        else
-          redirect request_token.authorize_url(options[:authorize_params].merge(:oauth_callback => callback_url))
-        end
-
-      rescue ::Timeout::Error => e
-        fail!(:timeout, e)
-      end
-
-      def callback_phase
-        request_token = ::OAuth::RequestToken.new(consumer, session['oauth'][name.to_s].delete('request_token'), session['oauth'][name.to_s].delete('request_secret'))
-
-        opts = {}
-        if session['oauth'][name.to_s]['callback_confirmed']
-          opts[:oauth_verifier] = request['oauth_verifier']
-        else
-          opts[:oauth_callback] = callback_url
-        end
-
-        @access_token = request_token.get_access_token(opts)
-        super
-      rescue ::Timeout::Error => e
-        fail!(:timeout, e)
-      rescue ::Net::HTTPFatalError => e
-        fail!(:service_unavailable, e)
-      rescue ::OAuth::Unauthorized => e
-        fail!(:invalid_credentials, e)
-      rescue ::NoMethodError, ::MultiJson::DecodeError => e
-        fail!(:invalid_response, e)
-      end
-
-      def auth_hash
-        OmniAuth::Utils.deep_merge(super, {
-          'credentials' => {
-            'token' => @access_token.token,
-            'secret' => @access_token.secret
-          }, 'extra' => {
-            'access_token' => @access_token
-          }
-        })
-      end
-
-      def unique_id
-        nil
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-require 'cgi'
-require 'uri'
-require 'oauth2'
-require 'omniauth/oauth'
-
-module OmniAuth
-  module Strategies
-    # Authentication strategy for connecting with APIs constructed using
-    # the [OAuth 2.0 Specification](http://tools.ietf.org/html/draft-ietf-oauth-v2-10).
-    # You must generally register your application with the provider and
-    # utilize an application id and secret in order to authenticate using
-    # OAuth 2.0.
-    class OAuth2
-      include OmniAuth::Strategy
-
-      # The options passed in to the strategy.
-      attr_accessor :options
-      # The `OAuth2::Client` for this strategy.
-      attr_accessor :client_id, :client_secret, :client_options
-
-      # An error that is indicated in the OAuth 2.0 callback.
-      # This could be a `redirect_uri_mismatch` or other
-      class CallbackError < StandardError
-        attr_accessor :error, :error_reason, :error_uri
-
-        def initialize(error, error_reason=nil, error_uri=nil)
-          self.error = error
-          self.error_reason = error_reason
-          self.error_uri = error_uri
-        end
-      end
-
-      # Initialize a new OAuth 2.0 authentication provider.
-
-      # @param [Rack Application] app standard middleware application argument
-      # @param [String] name the name for this provider to be used in its URL, e.g. `/auth/name`
-      # @param [String] client_id the client/application ID of this provider
-      # @param [String] client_secret the client/application secret of this provider
-      # @param [Hash] options that will be passed through to the OAuth2::Client (see [oauth2 docs](http://rubydoc.info/gems/oauth2))
-      def initialize(app, name, client_id = nil, client_secret = nil, client_options = {}, options = {}, &block)
-        self.client_id = client_id
-        self.client_secret = client_secret
-        self.client_options = client_options
-        super
-      end
-
-      def client
-        ::OAuth2::Client.new(client_id, client_secret, client_options.merge(options[:client_options] || {}))
-      end
-
-      def callback_url
-        full_host + script_name + callback_path
-      end
-
-      protected
-
-      def request_phase
-        redirect client.web_server.authorize_url({:redirect_uri => callback_url}.merge(options))
-      end
-
-      def callback_phase
-        if request.params['error'] || request.params['error_reason']
-          raise CallbackError.new(request.params['error'], request.params['error_description'] || request.params['error_reason'], request.params['error_uri'])
-        end
-
-        @access_token = build_access_token
-        @access_token = client.web_server.refresh_access_token(@access_token.refresh_token) if @access_token.expired?
-
-        super
-      rescue ::OAuth2::HTTPError, ::OAuth2::AccessDenied, CallbackError => e
-        fail!(:invalid_credentials, e)
-      rescue ::MultiJson::DecodeError => e
-        fail!(:invalid_response, e)
-      rescue ::Timeout::Error, ::Errno::ETIMEDOUT => e
-        fail!(:timeout, e)
-      end
-
-      def build_access_token
-        verifier = request.params['code']
-        client.web_server.get_access_token(verifier, {:redirect_uri => callback_url}.merge(options))
-      end
-
-      def auth_hash
-        credentials = {'token' => @access_token.token}
-        credentials.merge!('refresh_token' => @access_token.refresh_token) if @access_token.expires?
-
-        OmniAuth::Utils.deep_merge(super, {'credentials' => credentials})
-      end
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-require 'omniauth/oauth'
-require 'multi_json'
-
-module OmniAuth
-  module Strategies
-    #
-    # Authenticate to Plurk via OAuth and retrieve basic user info.
-    #
-    # Please note that this strategy relies on Plurk API 2.0,
-    # which is still in Beta.
-    #
-    # Usage:
-    #   use OmniAuth::Strategies::Plurk
-    class Plurk < OmniAuth::Strategies::OAuth
-
-      # @param [Rack Application] app standard middleware application parameter
-      # @param [String] client_key App key [registered on plurk] (http://www.plurk.com/PlurkApp/register)
-      # @param [String] client_secret App secret registered on plurk
-      def initialize(app, client_key = nil, client_secret = nil, options = {}, &block)
-        client_options = { :site => 'http://www.plurk.com',
-                           :request_token_path => '/OAuth/request_token',
-                           :access_token_path => '/OAuth/access_token',
-                           :authorize_path => '/OAuth/authorize' }
-
-        super(app, :plurk, client_key, client_secret, client_options, options)
-      end
-
-      def auth_hash
-        user = self.user_hash
-        OmniAuth::Utils.deep_merge(super, {
-          'uid' => user['id'],
-          'user_info' => user_info,
-          'extra' => {'user_hash' => user_hash}
-        })
-      end
-
-      def user_info
-        user = self.user_hash
-        {
-          'name' => user['full_name'],
-          'nickname' => user['display_name'] || user['nick_name'],
-          'location' => user['location'],
-          'image' => if user['has_profile_image'] == 1
-                        "http://avatars.plurk.com/#{user['id']}-medium#{user['avatar']}.gif"
-                      else
-                        "http://www.plurk.com/static/default_medium.gif"
-                      end,
-          'urls' => { 'Plurk' => 'http://plurk.com/' + user['nick_name']}
-        }
-      end
-
-      def user_hash
-        @user_hash  ||= MultiJson.decode(@access_token.get('/APP/Profile/getOwnProfile').body)['user_info']
-      end
-
-    end
-  end
-end