omniauth 0.2.6 → 0.3.0

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

@@ -1,54 +0,0 @@
-require 'omniauth/oauth'
-require 'multi_json'
-require 'evernote'
-
-module OmniAuth
-  module Strategies
-    #
-    # Authenticate to Evernote via OAuth and retrieve an access token for API usage
-    #
-    # Usage:
-    #
-    #    use OmniAuth::Strategies::Evernote, 'consumerkey', 'consumersecret'
-    #
-    class Evernote < OmniAuth::Strategies::OAuth
-      # Initialize the Evernote strategy.
-      #
-      # @option options [Hash, {}] :client_options Options to be passed directly to the OAuth Consumer
-      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
-        client_options = {
-          :site => 'https://www.evernote.com',
-          :request_token_path => '/oauth',
-          :access_token_path => '/oauth',
-          :authorize_path => '/OAuth.action',
-          :oauth_signature_method => 'PLAINTEXT'
-        }
-
-        super(app, :evernote, consumer_key, consumer_secret, client_options, options, &block)
-      end
-
-      def auth_hash
-        OmniAuth::Utils.deep_merge(super, {
-          'uid' => user_data.id,
-          'user_info' => user_info,
-          'extra' => user_data
-        })
-      end
-
-      def user_info
-        {
-          'name' => user_data.name,
-          'nickname' => user_data.username,
-        }
-      end
-
-      def user_data
-        @user_data ||= begin
-          user_store_url = consumer.site + '/edam/user'
-          client = ::Evernote::Client.new(::Evernote::EDAM::UserStore::UserStore::Client, user_store_url, {})
-          client.getUser(@access_token.token)
-        end
-      end
-    end
-  end
-end

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

@@ -1,70 +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::Facebook, 'client_id', 'client_secret'
-    class Facebook < OAuth2
-      # @param [Rack Application] app standard middleware application parameter
-      # @param [String] client_id the application id as [registered on Facebook](http://www.facebook.com/developers/)
-      # @param [String] client_secret the application secret as registered on Facebook
-      # @option options [String] :scope ('email,offline_access') comma-separated extended permissions such as `email` and `manage_pages`
-      def initialize(app, client_id = nil, client_secret = nil, options = {}, &block)
-        super(app, :facebook, client_id, client_secret, {:site => 'https://graph.facebook.com/'}, options, &block)
-      end
-
-      def user_data
-        @data ||= MultiJson.decode(@access_token.get('/me', {}, { "Accept-Language" => "en-us,en;"}))
-      end
-
-      def request_phase
-        options[:scope] ||= "email,offline_access"
-        super
-      end
-
-      def build_access_token
-        if facebook_session.nil? || facebook_session.empty?
-          super
-        else
-          @access_token = ::OAuth2::AccessToken.new(client, facebook_session['access_token'])
-        end
-      end
-
-      def facebook_session
-        session_cookie = request.cookies["fbs_#{client.id}"]
-        if session_cookie
-          @facebook_session ||= Rack::Utils.parse_query(request.cookies["fbs_#{client.id}"].gsub('"', ''))
-        else
-          nil
-        end
-      end
-
-      def user_info
-        {
-          'nickname' => user_data["username"],
-          'email' => (user_data["email"] if user_data["email"]),
-          'first_name' => user_data["first_name"],
-          'last_name' => user_data["last_name"],
-          'name' => "#{user_data['first_name']} #{user_data['last_name']}",
-          'image' => "http://graph.facebook.com/#{user_data['id']}/picture?type=square",
-          'urls' => {
-            'Facebook' => user_data["link"],
-            'Website' => user_data["website"],
-          }
-        }
-      end
-
-      def auth_hash
-        OmniAuth::Utils.deep_merge(super, {
-          'uid' => user_data['id'],
-          'user_info' => user_info,
-          'extra' => {'user_hash' => user_data}
-        })
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-require 'omniauth/oauth'
-require 'multi_json'
-
-module OmniAuth
-  module Strategies
-    class Foursquare < OAuth2
-      # Initialize the middleware
-      #
-      # @option options [Boolean, true] :sign_in When true, use a sign-in flow instead of the authorization flow.
-      # @option options [Boolean, false] :mobile When true, use the mobile sign-in interface.
-      def initialize(app, client_id = nil, client_secret = nil, options = {}, &block)
-        options[:sign_in] ||= true
-        super(app, :foursquare, client_id, client_secret, {
-          :site => "https://api.foursquare.com/v2",
-          :authorize_url      => authorize_url(options),
-          :access_token_url   => "https://foursquare.com/oauth2/access_token"
-        }, options, &block)
-      end
-
-      def authorize_url(options)
-        "https://foursquare.com/#{'mobile/' if options[:mobile]}oauth2/#{options[:sign_in] ? 'authenticate' : 'authorize'}"
-      end
-
-      def user_data
-        @data ||= MultiJson.decode(@access_token.get(client.site+'/users/self', {'oauth_token' => @access_token.token}))
-      end
-
-      def request_phase
-        options[:response_type] ||= 'code'
-        super
-      end
-
-      def callback_phase
-        options[:grant_type] ||= 'authorization_code'
-        super
-      end
-
-      def user_info
-        {
-          'nickname' => user_data['response']['user']['contact']['twitter'],
-          'first_name' => user_data['response']['user']['firstName'],
-          'last_name' => user_data['response']['user']['lastName'],
-          'email' => user_data['response']['user']['contact']['email'],
-          'name' => "#{user_data['response']['user']['firstName']} #{user_data['response']['user']['lastName']}".strip,
-        # 'location' => user_data['response']['user']['location'],
-          'image' => user_data['response']['user']['photo'],
-        # 'description' => user_data['response']['user']['description'],
-          'phone' => user_data['response']['user']['contact']['phone'],
-          'urls' => {}
-        }
-      end
-
-      def auth_hash
-        OmniAuth::Utils.deep_merge(super, {
-          'uid' => user_data['response']['user']['id'],
-          'user_info' => user_info,
-          'extra' => {'user_hash' => user_data['response']['user']}
-        })
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-require 'omniauth/oauth'
-require 'multi_json'
-
-module OmniAuth
-  module Strategies
-    # OAuth 2.0 based authentication with GitHub. In order to
-    # sign up for an application, you need to [register an application](http://github.com/account/applications/new)
-    # and provide the proper credentials to this middleware.
-    class GitHub < OAuth2
-      # @param [Rack Application] app standard middleware application argument
-      # @param [String] client_id the application ID for your client
-      # @param [String] client_secret the application secret
-      def initialize(app, client_id = nil, client_secret = nil, options = {}, &block)
-        client_options = {
-          :site => 'https://github.com/',
-          :authorize_path => '/login/oauth/authorize',
-          :access_token_path => '/login/oauth/access_token'
-        }
-
-        super(app, :github, client_id, client_secret, client_options, options, &block)
-      end
-
-      protected
-
-      def user_data
-        @data ||= MultiJson.decode(@access_token.get('/api/v2/json/user/show'))['user']
-      end
-
-      def user_info
-        {
-          'nickname' => user_data["login"],
-          'email' => user_data['email'],
-          'name' => user_data['name'],
-          'urls' => {
-            'GitHub' => "http://github.com/#{user_data['login']}",
-            'Blog' => user_data["blog"],
-          }
-        }
-      end
-
-      def auth_hash
-        OmniAuth::Utils.deep_merge(super, {
-          'uid' => user_data['id'],
-          'user_info' => user_info,
-          'extra' => {'user_hash' => user_data}
-        })
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-require 'multi_xml'
-require 'omniauth/oauth'
-
-module OmniAuth
-  module Strategies
-    class Goodreads < OmniAuth::Strategies::OAuth
-
-      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
-        client_options = {
-          :site => 'http://www.goodreads.com',
-        }
-        @consumer_key = consumer_key
-        super(app, :goodreads, consumer_key, consumer_secret, client_options, options, &block)
-      end
-
-      def auth_hash
-        hash = user_hash(@access_token)
-
-        OmniAuth::Utils.deep_merge(super, {
-          'uid' => hash.delete('id'),
-          'user_info' => hash
-        })
-      end
-
-      def user_hash(access_token)
-        authenticated_user = MultiXml.parse(@access_token.get('/api/auth_user').body)
-        id = authenticated_user.xpath('GoodreadsResponse/user').attribute('id').value.to_i
-        response_doc = MultiXml.parse(open("http://www.goodreads.com/user/show/#{id}.xml?key=#{@consumer_key}").read)
-        user = response_doc.xpath('GoodreadsResponse/user')
-
-        hash = {
-          'id' => id,
-          'name' => user.xpath('name').text,
-          'user_name' => user.xpath('user_name').text,
-          'image_url' => user.xpath('image_url').text,
-          'about' => user.xpath('about').text,
-          'location' => user.xpath('location').text,
-          'website' => user.xpath('website').text,
-        }
-      end
-    end
-  end
-end
-

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

@@ -1,80 +0,0 @@
-require 'omniauth/oauth'
-require 'multi_json'
-
-module OmniAuth
-  module Strategies
-    #
-    # Authenticate to Google via OAuth and retrieve basic
-    # user information.
-    #
-    # Usage:
-    #
-    #    use OmniAuth::Strategies::Google, 'consumerkey', 'consumersecret'
-    #
-    class Google < OmniAuth::Strategies::OAuth
-      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
-        client_options = {
-          :site => 'https://www.google.com',
-          :request_token_path => '/accounts/OAuthGetRequestToken',
-          :access_token_path => '/accounts/OAuthGetAccessToken',
-          :authorize_path => '/accounts/OAuthAuthorizeToken'
-        }
-
-        google_contacts_auth = "www.google.com/m8/feeds"
-        options[:scope] ||= google_contacts_auth
-        options[:scope] << " http://#{google_contacts_auth}" unless options[:scope] =~ %r[http[s]?:\/\/#{google_contacts_auth}]
-
-        super(app, :google, 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
-        email = user_hash['feed']['id']['$t']
-
-        name = user_hash['feed']['author'].first['name']['$t']
-        name = email if name.strip == '(unknown)'
-
-        {
-          'email' => email,
-          'uid' => email,
-          'name' => name
-        }
-      end
-
-      def user_hash
-        # Google is very strict about keeping authorization and
-        # authentication separated.
-        # They give no endpoint to get a user's profile directly that I can
-        # find. We *can* get their name and email out of the contacts feed,
-        # however. It will fail in the extremely rare case of a user who has
-        # a Google Account but has never even signed up for Gmail. This has
-        # not been seen in the field.
-        @user_hash ||= MultiJson.decode(@access_token.get("http://www.google.com/m8/feeds/contacts/default/full?max-results=1&alt=json").body)
-      end
-
-      # Monkeypatch OmniAuth to pass the scope in the consumer.get_request_token call
-      def request_phase
-        request_token = consumer.get_request_token({:oauth_callback => callback_url}, {:scope => options[:scope]})
-        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)
-        else
-          r.redirect(request_token.authorize_url(:oauth_callback => callback_url))
-        end
-
-        r.finish
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-require 'omniauth/oauth'
-require 'multi_json'
-
-module OmniAuth
-  module Strategies
-    #
-    # Authenticate to Gowalla utilizing OAuth 2.0 and retrieve
-    # basic user information.
-    #
-    # @example Basic Usage
-    #     use OmniAuth::Strategies::Gowalla, 'API Key', 'Secret Key'
-    class Gowalla < OAuth2
-      # @param [Rack Application] app standard middleware application parameter
-      # @param [String] api_key the application id as [registered on Gowalla](http://gowalla.com/api/keys)
-      # @param [String] secret_key the application secret as [registered on Gowalla](http://gowalla.com/api/keys)
-      # @option options ['read','read-write'] :scope ('read') the scope of your authorization request; must be `read` or `read-write`
-      def initialize(app, api_key = nil, secret_key = nil, options = {}, &block)
-        client_options = {
-          :site => 'https://api.gowalla.com/api/oauth',
-          :authorize_url => 'https://gowalla.com/api/oauth/new',
-          :access_token_url => 'https://api.gowalla.com/api/oauth/token'
-        }
-
-        super(app, :gowalla, api_key, secret_key, client_options, options, &block)
-      end
-
-      protected
-
-      def user_data
-        @data ||= MultiJson.decode(@access_token.get("/users/me.json"))
-      end
-
-      def refresh_token
-        @refresh_token ||= @access_token.refresh_token
-      end
-
-      def token_expires_at
-        @expires_at ||= @access_token.expires_at
-      end
-
-      def request_phase
-        options[:scope] ||= "read"
-        super
-      end
-
-      def user_info
-        {
-          'name' => "#{user_data['first_name']} #{user_data['last_name']}",
-          'nickname' => user_data["username"],
-          'first_name' => user_data["first_name"],
-          'last_name' => user_data["last_name"],
-          'location' => user_data["hometown"],
-          'description' => user_data["bio"],
-          'image' => user_data["image_url"],
-          'phone' => nil,
-          'urls' => {
-            'Gowalla' => "http://www.gowalla.com#{user_data['url']}",
-            'Website' => user_data["website"]
-          }
-        }
-      end
-
-      def auth_hash
-        OmniAuth::Utils.deep_merge(super, {
-          'uid' => user_data["url"].split('/').last,
-          'user_info' => user_info,
-          'extra' => {'user_hash' => user_data, 'refresh_token' => refresh_token, 'token_expires_at' => token_expires_at}
-        })
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-require 'omniauth/oauth'
-require 'multi_json'
-
-
-module OmniAuth
-  module Strategies
-    class Hyves < OmniAuth::Strategies::OAuth
-      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
-        client_options = {
-          :request_token_path => request_token_path,
-          :authorize_path => "http://www.hyves.nl/api/authorize",
-          :access_token_path => access_token_path,
-          :http_method => :get,
-          :scheme => :header
-        }
-        super(app, :hyves, consumer_key, consumer_secret, client_options, options, &block)
-      end
-
-      def auth_hash
-        hash = user_hash(@access_token)
-
-        {
-          "provider" => "hyves",
-          "uid" => hash["userid"],
-          "user_info" => {
-            "name" => hash["firstname"] + " " + hash["lastname"],
-            "first_name" => hash["firstname"],
-            "last_name" => hash["lastname"]
-          },
-          "credentials" => {
-            "token" => @access_token.token,
-            "secret" => @access_token.secret
-          }
-        }
-      end
-
-      def user_hash(access_token)
-        rsp = MultiJson.decode( access_token.get("http://data.hyves-api.nl/?userid=#{access_token.params[:userid]}&ha_method=users.get&#{default_options}").body )
-        rsp["user"].first
-      end
-
-      def request_token_path
-        "http://data.hyves-api.nl/?#{request_token_options}&#{default_options}"
-      end
-
-      def access_token_path
-        "http://data.hyves-api.nl/?#{access_token_options}&#{default_options}"
-      end
-
-      def default_options
-        to_params( { :ha_version => "2.0", :ha_format => "json", :ha_fancylayout => false } )
-      end
-
-      def request_token_options
-        to_params( { :methods => "users.get,friends.get,wwws.create", :ha_method => "auth.requesttoken", :strict_oauth_spec_response => true } )
-      end
-
-      def access_token_options
-        to_params( { :ha_method => "auth.accesstoken", :strict_oauth_spec_response => true } )
-      end
-
-      def to_params(options)
-        options.collect { |key, value| "#{key}=#{value}"}.join('&')
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-require 'omniauth/oauth'
-require 'multi_json'
-
-module OmniAuth
-  module Strategies
-    #
-    # Authenticate to Identica via OAuth and retrieve basic
-    # user information.
-    #
-    # Usage:
-    #
-    #    use OmniAuth::Strategies::Identica, 'consumerkey', 'consumersecret'
-    #
-    class Identica < OmniAuth::Strategies::OAuth
-      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
-        super(app, :identica, consumer_key, consumer_secret,
-                {:site => 'http://identi.ca',
-                :request_token_path => "/api/oauth/request_token",
-                :access_token_path  => "/api/oauth/access_token",
-                :authorize_path     => "/api/oauth/authorize"}, 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
-
-        {
-          'nickname' => user_hash['screen_name'],
-          'name' => user_hash['name'],
-          'location' => user_hash['location'],
-          'image' => user_hash['profile_image_url'],
-          'description' => user_hash['description'],
-          'urls' => {'Website' => user_hash['url']}
-        }
-      end
-
-      def user_hash
-        @user_hash ||= MultiJson.decode(@access_token.get('/api/account/verify_credentials.json').body)
-      end
-    end
-  end
-end

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

@@ -1,56 +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::Instagram, 'client_id', 'client_secret'
-    class Instagram < 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://api.instagram.com/",
-          :authorize_url      => "/oauth/authorize",
-          :access_token_url   => "/oauth/access_token"
-        }
-
-        super(app, :instagram, client_id, client_secret, client_options, options, &block)
-      end
-
-      def request_phase
-        options[:scope] ||= "basic"
-        options[:response_type] ||= 'code'
-        super
-      end
-
-      def callback_phase
-        options[:grant_type] ||= 'authorization_code'
-        super
-      end
-
-      def user_data
-        @data ||= MultiJson.decode(@access_token.get("/v1/users/self"))
-      end
-
-      def user_info
-        {
-          'nickname' => user_data['data']['username'],
-          'name' => user_data['data']['full_name'],
-          'image' => user_data['data']['profile_picture'],
-          'urls' => {}
-        }
-      end
-
-      def auth_hash
-        OmniAuth::Utils.deep_merge(super, {
-          'uid' => user_data['data']['id'],
-          'user_info' => user_info,
-          'extra' => {'user_hash' => user_data['data']}
-        })
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-require 'omniauth/oauth'
-require 'multi_json'
-
-module OmniAuth
-  module Strategies
-    class Instapaper < OmniAuth::Strategies::XAuth
-
-      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
-        client_options = {
-          :title => 'Instapaper',
-          :site => 'https://www.instapaper.com',
-          :access_token_path => '/api/1/oauth/access_token'
-        }
-        super(app, :instapaper, consumer_key, consumer_secret, client_options, options, &block)
-      end
-
-      protected
-
-      def user_data
-        @data ||= MultiJson.decode(@access_token.get('/api/1/account/verify_credentials').body)[0]
-      end
-
-      def user_info
-        {
-          'nickname' => user_data['username'],
-          'name' => user_data['username']
-        }
-      end
-
-      def auth_hash
-        OmniAuth::Utils.deep_merge(super, {
-          'uid' => user_data['user_id'],
-          'user_info' => user_info
-        })
-      end
-
-    end
-  end
-end
-