socialite 0.0.1.beta4 → 0.1.0.pre

data/lib/socialite/controllers/helpers.rb

@@ -7,131 +7,127 @@ module Socialite
         helper_method :current_user, :user_signed_in?, :current_user?, :default_route
       end
 
-      module InstanceMethods
-
-        # Set default route for redirect
-        #
-        # @param [String] the path for default redirects
-        # @return [String] the default path for redirect
-        # (see #default_route)
-        def default_route=(route)
-          @default_route = route
-        end
+      # Set default route for redirect
+      #
+      # @param [String] the path for default redirects
+      # @return [String] the default path for redirect
+      # (see #default_route)
+      def default_route=(route)
+        @default_route = route
+      end
 
-        # Get default route for redirect
-        #
-        # @return [String] the default path for redirect
-        # (see #default_route=)
-        def default_route
-          @default_route ||= '/'
-        end
+      # Get default route for redirect
+      #
+      # @return [String] the default path for redirect
+      # (see #default_route=)
+      def default_route
+        @default_route ||= main_app.root_url
+      end
 
-        # Helper for supporting multiple flash messages per type
-        #
-        # @param [Symbol] the type of flash message. Common types are
-        # :success, :notice, :error
-        # @param [String] the message to attach to the flash type
-        # @return [Hash] all associated flash messages for this request
-        def flash_message(type, text)
-          flash[type.to_sym] ||= []
-          flash[type.to_sym] << text
-        end
+      # Helper for supporting multiple flash messages per type
+      #
+      # @param [Symbol] the type of flash message. Common types are
+      # :success, :notice, :error
+      # @param [String] the message to attach to the flash type
+      # @return [Hash] all associated flash messages for this request
+      def flash_message(type, text)
+        flash[type.to_sym] ||= []
+        flash[type.to_sym] << text
+      end
 
-      protected
+    protected
 
-        # Filters
+      # Filters
 
-        # Conditional check to see ensure a current user exists
-        #
-        # @return [Boolean]
-        # (see #current_user?)
-        def ensure_user
-           current_user? || deny_access('You must be logged in to perform this action.')
-        end
+      # Conditional check to see ensure a current user exists
+      #
+      # @return [Boolean]
+      # (see #current_user?)
+      def ensure_user
+        current_user? || deny_access('You must be logged in to perform this action.')
+      end
 
-        # Conditional check to see ensure there is no current user
-        #
-        # @return [Boolean]
-        # (see #current_user?)
-        def ensure_no_user
-           !current_user? || redirect_back_or_default
-        end
+      # Conditional check to see ensure there is no current user
+      #
+      # @return [Boolean]
+      # (see #current_user?)
+      def ensure_no_user
+        !current_user? || redirect_back_or_default
+      end
 
-        # Utils
+      ## Utilities
 
-        # Store the location URL in the session for later use.
-        #
-        # @return [Hash] the modified session object
-        def store_location
-          session[:return_to] = request.fullpath
-        end
+      # Store the location URL in the session for later use.
+      #
+      # @return [Hash] the modified session object
+      def store_location
+        session[:return_to] = request.fullpath
+      end
 
-        # Stores the URL for the current requested action, then redirects to
-        # the login page.
-        #
-        # @param [String] optional flash message to pass to the user
-        # @note This method sets the redirect path, but does not return false.
-        # Meaning you can perform actions after this method is invoked.
-        def deny_access(message=nil)
-          store_location
-          flash_message :notice, message if message.present?
-          redirect_to login_path
-        end
+      # Stores the URL for the current requested action, then redirects to
+      # the login page.
+      #
+      # @param [String] optional flash message to pass to the user
+      # @note This method sets the redirect path, but does not return false.
+      # Meaning you can perform actions after this method is invoked.
+      def deny_access(message=nil)
+        store_location
+        flash_message :notice, message if message.present?
+        redirect_to login_path
+      end
 
-        # Conditional redirect to handle an empty return_to path. If return_to
-        # is empty, the request is redirected to the default path
-        #
-        # @param [String] path to use as the default redirect location
-        # @return [Hash] the modified session hash
-        def redirect_back_or_default(default=nil)
-          default = self.default_route
-          redirect_to(session[:return_to] || default)
-          session[:return_to] = nil
-        end
+      # Conditional redirect to handle an empty return_to path. If return_to
+      # is empty, the request is redirected to the default path
+      #
+      # @param [String] path to use as the default redirect location
+      # @return [Hash] the modified session hash
+      def redirect_back_or_default(default=nil)
+        default = self.default_route
+        redirect_to(session[:return_to] || default)
+        session[:return_to] = nil
+      end
 
-        # Fetch the User model associated with the current session.
-        #
-        # @return [User]
-        # (see #current_user=)
-        def current_user
-          @current_user ||= if session[:user_id]
-                              User.find(session[:user_id])
-                            elsif cookies[:remember_token]
-                              User.find_by_remember_token(cookies[:remember_token])
-                            end
-        end
+      # Fetch the User model associated with the current session.
+      #
+      # @return [User]
+      # (see #current_user=)
+      def current_user
+        @current_user ||= if session[:socialite_user_id]
+                            Socialite.user_class.find(session[:socialite_user_id])
+                          elsif cookies[:remember_token]
+                            Socialite.user_class.find_by_remember_token(cookies[:remember_token])
+                          end
+      end
 
-        # Assign the User model associated with the current session.
-        #
-        # @return [User]
-        # (see #current_user)
-        def current_user=(user)
-          user.tap do |user|
-            user.remember_me!
-            session[:user_id]         = user.id
-            cookies[:remember_token]  = user.remember_token
-          end
+      # Assign the User model associated with the current session.
+      #
+      # @return [User]
+      # (see #current_user)
+      def current_user=(user)
+        user.tap do |user|
+          user.remember_me!
+          session[:user_id]         = user.id
+          cookies[:remember_token]  = user.remember_token
         end
+      end
 
-        # Accessor method for checking if a user is currently signed in
-        #
-        # @return [Boolean]
-        # (see #current_user)
-        def user_signed_in?
-          !!current_user
-        end
-        alias_method :current_user?, :user_signed_in?
-
-        # Destroy the current user session, effectively logging them out upon
-        # the next request.
-        #
-        # @return [Hash] the modified session object
-        def logout!
-          session[:user_id] = nil
-          session[:return_to] = nil
-          @current_user = nil
-          cookies.delete(:remember_token)
-        end
+      # Accessor method for checking if a user is currently signed in
+      #
+      # @return [Boolean]
+      # (see #current_user)
+      def user_signed_in?
+        !!current_user
+      end
+      alias_method :current_user?, :user_signed_in?
+
+      # Destroy the current user session, effectively logging them out upon
+      # the next request.
+      #
+      # @return [Hash] the modified session object
+      def logout!
+        session[:user_id] = session[:return_to] = nil
+        @current_user = nil
+        cookies.delete(:remember_token)
       end
     end
   end

data/lib/socialite/engine.rb

@@ -1,45 +1,32 @@
 require 'haml'
-require 'omniauth/core'
-require 'omniauth/oauth'
+require 'omniauth'
 
 module Socialite
-  class Engine < Rails::Engine
+  class Engine < ::Rails::Engine
     isolate_namespace Socialite
 
-    initializer 'socialite.load_middleware', :after => :load_config_initializers do
-      if Socialite.service_configs[:twitter]
-        if Socialite.mounted_engine?
-          middleware.use OmniAuth::Strategies::Twitter,
-            Socialite.service_configs[:twitter].app_key,
-            Socialite.service_configs[:twitter].app_secret
-        else
-          config.app_middleware.use OmniAuth::Strategies::Twitter,
-            Socialite.service_configs[:twitter].app_key,
-            Socialite.service_configs[:twitter].app_secret
-        end
-      end
+    config.generators do |g|
+      g.test_framework :rspec, :fixture => false
+      g.integration_tool :rspec
+      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+      g.assets false
+      g.helper false
+    end
 
-      if Socialite.service_configs[:facebook]
-        if Socialite.mounted_engine?
-          middleware.use OmniAuth::Strategies::Facebook,
-            Socialite.service_configs[:facebook].app_key,
-            Socialite.service_configs[:facebook].app_secret,
-            Socialite.service_configs[:facebook].options
-        else
-          config.app_middleware.use OmniAuth::Strategies::Facebook,
-            Socialite.service_configs[:facebook].app_key,
-            Socialite.service_configs[:facebook].app_secret,
-            Socialite.service_configs[:facebook].options
+    initializer 'socialite.load_middleware', :after => :load_config_initializers do
+      Socialite.providers.each do |provider_info|
+        OmniAuth.configure do |config|
+          config.provider(*provider_info)
         end
       end
     end
 
-    ActiveSupport.on_load(:action_controller) do
-      include Socialite::Controllers::Helpers
-    end
+    # ActiveSupport.on_load(:action_controller) do
+      # include Socialite::Controllers::Helpers
+    # end
 
-    ActiveSupport.on_load(:action_view) do
-      include Socialite::Helpers::Authentication
-    end
+    # ActiveSupport.on_load(:action_view) do
+      # include Socialite::Helpers::Authentication
+    # end
   end
 end

data/lib/socialite/helpers/authentication.rb

@@ -2,7 +2,7 @@ module Socialite
   module Helpers
     module Authentication
       def identity_request_path(options={})
-        [Socialite.mount_prefix, 'auth', options[:service]].join('/')
+        ['/auth', options[:service]].join('/')
       end
 
       def twitter_login_button

data/lib/socialite/models/identity_concern.rb

@@ -0,0 +1,91 @@
+module Socialite
+  module Models
+    module IdentityConcern
+      extend ActiveSupport::Concern
+
+      included do
+        belongs_to :user,
+          :class_name => Socialite.user_class_name,
+          :foreign_key => "#{Socialite.user_class.table_name.singularize}_id"
+        serialize :auth_hash
+
+        # Ensure that before validation happens that the provider
+        # database column matches what is inside of the auth_hash
+        # dataset.
+        before_validation do |identity|
+          if identity.auth_hash.present?
+            identity.provider = identity.auth_hash.delete('provider') if identity.provider.blank?
+            identity.uid = identity.auth_hash.delete('uid') if identity.uid.blank?
+          end
+        end
+
+        # Ensure each user has only a single identity per provider type
+        validates :provider,
+          :uniqueness => {:scope => "#{Socialite.user_class.table_name.singularize}_id", :case_sensitive => false},
+          :presence => true
+
+        # Ensure an identity is never reused by another account
+        validates :uid,
+          :uniqueness => {:scope => :provider},
+          :presence => true
+
+        # Ensure an associated user exists before creating the identity
+        # validates_associated :user
+      end
+
+      module ClassMethods
+        # Finder method that finds the matching Provider and Unique ID or
+        # initializes a new, unsaved, object.
+        #
+        # @params [Hash] the OAuth authentication hash
+        # @returns [Identity]
+        def find_or_initialize_by_omniauth(auth)
+          identity = where(:provider => auth['provider'], :uid => auth['uid']).first || new
+          identity.auth_hash = auth
+          identity
+        end
+      end
+
+      # Convenience method for accessing the OAuth access token
+      #
+      # @returns [String] OAuth access token
+      # (see #credentials)
+      def access_token
+        credentials['token']
+      end
+
+      # Convenience method for accessing the OAuth access token secret
+      #
+      # @returns [String] OAuth access token secret
+      # (see #credentials)
+      def access_token_secret
+        credentials['secret']
+      end
+
+      # Convenience method for accessing the OAuth credentials sub-hash
+      #
+      # @returns [Hash] OAuth credentials sub-hash
+      # (see #access_token)
+      # (see #access_token_secret)
+      def credentials
+        auth_hash['credentials']
+      end
+
+      # Convenience method for accessing the nickname, which is typically
+      # set to the login name used for that provider.
+      #
+      # @returns [String] user nickname for the provider identity
+      def nickname
+        info['nickname']
+      end
+
+      # Convenience method for accessing the user information from the
+      # OAuth provider.
+      #
+      # @returns [Hash] the user information sub-hash
+      def info
+        auth_hash['info']
+      end
+    end
+  end
+end

data/lib/socialite/models/user_concern.rb

@@ -0,0 +1,54 @@
+module Socialite
+  module Models
+    module UserConcern
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :identities,
+          :dependent => :destroy,
+          :class_name => Socialite.identity_class_name,
+          :foreign_key => "#{Socialite.user_class.table_name.singularize}_id"
+      end
+
+      def method_missing(id, *args, &block)
+        if id =~ /(\w+)_identity$/ && @identity = self.identities.where(:provider => $1).first
+          @identity
+        else
+          super
+        end
+      end
+
+      # Returns the first linked facebook identity
+      #
+      # @return [Identity] the first facebook identity
+      def facebook
+        self.facebook_identity
+      end
+
+      # Returns the first linked twitter account
+      #
+      # @return [Identity] the first twitter identity
+      def twitter
+        self.twitter_identity
+      end
+
+      # Set the user's remember token
+      #
+      # @return [User] the current user
+      # def remember_me!
+        # self.remember_token = Socialite.generate_token
+        # save(:validate => false)
+      # end
+
+      # Clear the user's remember token
+      #
+      # @return [User] the current user
+      # def forget_me!
+        # if persisted?
+          # self.remember_token = nil
+          # save(:validate => false)
+        # end
+      # end
+    end
+  end
+end