omniauth 0.2.4 → 0.2.5

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

@@ -0,0 +1,64 @@
+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 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}
+        })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,40 @@
+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
+

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

@@ -0,0 +1,55 @@
+require 'multi_xml'
+require 'omniauth/oauth'
+
+module OmniAuth
+  module Strategies
+    class LinkedIn < OmniAuth::Strategies::OAuth
+      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
+        client_options = {
+          :site => 'https://api.linkedin.com',
+          :request_token_path => '/uas/oauth/requestToken',
+          :access_token_path => '/uas/oauth/accessToken',
+          :authorize_path => '/uas/oauth/authorize',
+          :scheme => :header
+        }
+
+        client_options[:authorize_path] = '/uas/oauth/authenticate' unless options[:sign_in] == false
+
+        super(app, :linked_in, 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)
+        person = MulitXml.parse(@access_token.get('/v1/people/~:(id,first-name,last-name,headline,member-url-resources,picture-url,location,public-profile-url)').body).xpath('person')
+
+        hash = {
+          'id' => person.xpath('id').text,
+          'first_name' => person.xpath('first-name').text,
+          'last_name' => person.xpath('last-name').text,
+          'nickname' => person.xpath('public-profile-url').text.split('/').last,
+          'location' => person.xpath('location/name').text,
+          'image' => person.xpath('picture-url').text,
+          'description' => person.xpath('headline').text,
+          'public_profile_url' => person.xpath('public-profile-url').text,
+          'urls' => person.css('member-url-resources member-url').inject({}) do |h,element|
+            h[element.xpath('name').text] = element.xpath('url').text
+            h
+          end
+        }
+
+        hash['urls']['LinkedIn'] = person.xpath('public-profile-url').text
+        hash['name'] = "#{hash['first_name']} #{hash['last_name']}"
+
+        hash
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,59 @@
+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