socialite 0.1.0.pre → 0.1.0.pre.2

data/app/controllers/socialite/sessions_controller.rb

@@ -0,0 +1,69 @@
+module Socialite
+  class SessionsController < ApplicationController
+    unloadable
+
+    def new
+      # Login Page
+    end
+
+    def create
+      auth = request.env['omniauth.auth']
+      # Find an identity here
+      @identity = Socialite.identity_class.find_or_create_from_omniauth(auth)
+
+      if user_signed_in? # Check if user is already signed in.
+        if @identity.user == current_user
+          # User is signed in so they are trying to link an identity with their
+          # account. But we found the identity and the user associated with it
+          # is the current user. So the identity is already associated with
+          # this user. So let's display an error message.
+          redirect_to main_app.root_url, :notice => "You have already linked this account"
+        else
+          # The identity is not associated with the current_user so lets
+          # associate the identity.
+          @identity.user = current_user
+          @identity.save
+          redirect_to main_app.root_url, :notice => "Account successfully authenticated"
+        end
+      else # User is not logged in, this is a new signin
+        if @identity.user.present?
+          # The identity we found had a user associated with it so let's
+          # just log them in here
+          self.current_user = @identity.user
+          redirect_to main_app.root_url, :notice => "Signed in!"
+        else
+          # The authentication has no user assigned and there is no user signed in
+          # Our decision here is to create a new account for the user
+          # But your app may do something different (eg. ask the user
+          # if he already signed up with some other service)
+          user = if @identity.provider == 'identity'
+                   Socialite.user_class.find(@identity.uid)
+                   # If the provider is identity, then it means we already created a user
+                   # So we just load it up
+                 else
+                   # otherwise we have to create a user with the auth hash
+                   Socialite.user_class.create_from_omniauth(auth)
+                   # NOTE: we will handle the different types of data we get back
+                   # from providers at the model level in create_from_omniauth
+                 end
+          # We can now link the authentication with the user and log him in
+          user.identities << @identity
+          self.current_user = user
+          redirect_to main_app.root_path, notice: "Welcome to The app!"
+
+          # No user associated with the identity so we need to create a new one
+          # redirect_to new_user_url, :notice => "Please finish registering"
+        end
+      end
+    end
+
+    def destroy
+      self.current_user = nil
+      redirect_to main_app.root_url, :notice => 'Signed out!'
+    end
+
+    def failure
+      redirect_to main_app.root_url, :alert => "Authentication failed, please try again."
+    end
+  end
+end

data/app/controllers/socialite/users_controller.rb

@@ -2,37 +2,8 @@ module Socialite
   class UsersController < ApplicationController
     unloadable
 
-    before_filter :ensure_user
-    respond_to :html, :json
-
-    def show
-      respond_with(user)
-    end
-
-    def edit
-      respond_with(user)
-    end
-
-    def update
-      flash_message :notice, 'Your account has been removed along with any associated identities.'
-      respond_with(user) do |format|
-        format.html { redirect_back_or_default(user_path) }
-      end
-    end
-
-    def destroy
-      user.destroy
-      logout!
-      flash_message :notice, 'Your account has been removed along with any associated identities.'
-      respond_with(user) do |format|
-        format.html { redirect_back_or_default(user_path) }
-      end
-    end
-
-  private
-
-    def user
-      @user = current_user
+    def new
+      @user = env['omniauth.identity'] ||= Socialite.user_class.new
     end
   end
 end

data/app/views/layouts/socialite/application.html.haml

@@ -2,7 +2,7 @@
 %html
 %head
   %title Socialite
-  = stylesheet_link_tag    "socialite/application", :media => "all"
+  = stylesheet_link_tag "socialite/application", :media => "all"
   = javascript_include_tag "socialite/application"
   = csrf_meta_tags
 %body

data/app/views/socialite/identities/new.html.haml

@@ -1,27 +1,14 @@
 %h1 New Account
 
-= form_tag "/auth/identity/register" do
+= simple_form_for @identity, :url => '/auth/identity/register' do |f|
   - if @identity && @identity.errors.any?
     .error_messages
       %h2 #{pluralize(@identity.errors.count, "error")} prohibited this account from being saved:
       %ul
       - @identity.errors.full_messages.each do |msg|
         %li= msg
-  .field
-    = label_tag :name
-    %br
-    = text_field_tag :name, @identity.try(:name)
-  .field
-    = label_tag :email
-    %br
-    = text_field_tag :email, @identity.try(:email)
-  .field
-    = label_tag :password
-    %br
-    = password_field_tag :password
-  .field
-    = label_tag :password_confirmation
-    %br
-    = password_field_tag :password_confirmation
-  .actions
-    = submit_tag "Register"
+
+  = f.input :email, :input_html => {:name => 'email'}
+  = f.input :password, :as => 'password', :input_html => {:name => 'password'}
+  = f.input :password_confirmation, :label => "Confirm Password", :as => 'password', :input_html => {:name => 'password_confirmation'}
+  = f.button :submit, 'Register'

data/app/views/socialite/sessions/new.html.haml

@@ -0,0 +1,30 @@
+%h1 Sign In
+
+%p
+  %strong Sign in through one of these services:
+
+.auth_providers
+  - if defined?(OmniAuth::Strategies::Twitter)
+    %a.auth_provider{:href => "/auth/twitter"}
+      = image_tag "twitter_64.png", :size => "64x64", :alt => "Twitter"
+      Twitter
+  - if defined?(OmniAuth::Strategies::Facebook)
+    %a.auth_provider{:href => "/auth/facebook"}
+      = image_tag "facebook_64.png", :size => "64x64", :alt => "Facebook"
+      Facebook
+
+%p
+  %strong Don't use these services?
+  #{link_to "Create an account", signup_path} or login below.
+
+= form_tag "/auth/identity/callback" do
+  .field
+    = label_tag :auth_key, "Email"
+    %br
+    = text_field_tag :auth_key
+  .field
+    = label_tag :password
+    %br
+    = password_field_tag :password
+  .actions
+    = submit_tag "Sign in"

data/app/views/socialite/users/new.html.haml

@@ -0,0 +1,10 @@
+-# UsersController#new registration form is ONLY used with omniauth-identity
+
+= simple_form_for @user, :url => '/auth/identity/register' do |f|
+  %h1 Create an Account
+  -# specify :input_html to avoid params nesting
+  -# = f.input :name, :input_html => {:name => 'name'}
+  = f.input :email, :input_html => {:name => 'email'}
+  = f.input :password, :as => 'password', :input_html => {:name => 'password'}
+  = f.input :password_confirmation, :label => "Confirm Password", :as => 'password', :input_html => {:name => 'password_confirmation'}
+  = f.button :submit, 'Sign Up'

data/config/routes.rb

@@ -1,10 +1,9 @@
 Socialite::Engine.routes.draw do
-  # match '/login'                  => 'session#new',      :as => :login
-  # match '/auth/:service/callback' => 'identities#create', :as => :callback
-  # match '/auth/failure'           => 'identities#failure'
-  # match '/logout'                 => 'session#destroy',  :as => :logout
+  match '/signup', :to => 'users#new'
+  match '/auth/:provider/callback', :to => 'sessions#create'
 
-  # resource :user, :except => [:new, :create] do
-    # resources :identities
-  # end
+  match '/logout', :to => 'sessions#destroy', :as => 'logout'
+  match '/login', :to => 'sessions#new', :as => 'login'
+
+  resources :users # needed by omniauth-identity
 end

data/lib/generators/socialite/install_generator.rb

@@ -2,7 +2,7 @@ require 'rails/generators'
 
 module Socialite
   module Generators
-    class InstallGenerator < ::Rails::Generators::Base
+    class InstallGenerator < ::Rails::Generators::Base #:nodoc:
       source_root File.expand_path("../templates", __FILE__)
 
       desc 'Creates a socialite initializer'
@@ -10,10 +10,29 @@ module Socialite
         template 'socialite.rb', 'config/initializers/socialite.rb'
       end
 
-      # def add_opro_routes
-        # socialite_routes = "mount_socialite_oauth"
-        # route socialite_routes
-      # end
+      def mount_engine
+        puts "Mounting Socialite::Engine at \"/socialite\" in config/routes.rb..."
+        insert_into_file("config/routes.rb", :after => /routes.draw.do\n/) do
+          %Q{
+  # This line mounts Socialite's routes at /socialite by default.
+  # This means, any requests to the /socialite URL of your application will go
+  # to Socialite::SessionsController#new. If you would like to change where
+  # this extension is mounted, simply change the :at option to something
+  # different.
+  #
+  # We ask that you don't use the :as option here, as Socialite relies on it
+  # being the default of "socialite"
+  mount Socialite::Engine, :at => '/socialite'
+  match '/login' => 'socialite::sessions#new'
+  match '/logout', :to => 'socialite::sessions#destroy'
+  match '/signup', :to => 'socialite::users#new'
+  match '/auth/:provider/callback', :to => 'socialite::sessions#create'
+  match '/auth/failure', :to => 'socialite::sessions#failure'
+
+}
+        end
+
+      end
     end
   end
 end

data/lib/generators/socialite/migrations_generator.rb

@@ -2,7 +2,7 @@ require 'rails/generators/migration'
 
 module Socialite
   module Generators
-    class MigrationsGenerator < ::Rails::Generators::Base
+    class MigrationsGenerator < ::Rails::Generators::Base #:nodoc:
       include Rails::Generators::Migration
       source_root File.expand_path('../templates', __FILE__)
 

data/lib/generators/socialite/templates/socialite.rb

@@ -20,6 +20,15 @@ Socialite.setup do |config|
   # }
   # config.provider :twitter, ENV['TWITTER_APP_KEY'], ENV['TWITTER_SECRET']
 
+  # We highly recommended adding the omniauth-identity gem to your Gemfile.
+  # This does not enforce a password on signup, but establishes a common
+  # 'password recovery' entry point for all users.
+  #
+  # config.provider :identity,
+  #   :model => Socialite.user_class,
+  #   :fields => [:email],
+  #   :on_failed_registration => Socialite::UsersController.action(:new)
+
   if Rails.env.production?
     # Any production specific information
   elsif Rails.env.development?

data/lib/generators/socialite/templates/users.rb.erb

@@ -1,9 +1,13 @@
 class CreateSocialiteUsers < ActiveRecord::Migration
   def up
     create_table :<%= options[:users_table] %> do |t|
-      t.string :name
+      t.string :name, :email
+      t.string :password_digest # set :null => false to enforce identity, requires 'bcrypt-ruby' in your Gemfile.
       t.timestamps
     end
+
+    # Enforce only every email must be unique
+    add_index :<%= options[:users_table] %>, :email, :unique => true
   end
 
   def down

data/lib/generators/socialite/views_generator.rb

@@ -0,0 +1,22 @@
+require 'rails/generators'
+
+module Socialite
+  module Generators
+    class ViewsGenerator < ::Rails::Generators::Base #:nodoc:
+      source_root File.expand_path("../../../../app/views/socialite", __FILE__)
+      desc "Used to copy socialite's views to your application's views."
+
+      def copy_views
+        view_directory :identities
+        view_directory :sessions
+        view_directory :users
+      end
+
+    protected
+
+      def view_directory(name)
+        directory name.to_s, "app/views/socialite/#{name}"
+      end
+    end
+  end
+end

data/lib/socialite.rb

@@ -10,10 +10,6 @@ module Socialite
     autoload :Helpers, 'socialite/controllers/helpers'
   end
 
-  module Helpers
-    autoload :Authentication, 'socialite/helpers/authentication.rb'
-  end
-
   module Models
     autoload :IdentityConcern, 'socialite/models/identity_concern'
     autoload :UserConcern, 'socialite/models/user_concern'
@@ -35,18 +31,18 @@ module Socialite
   end
 
   def self.identity_class
-    identity_class_name.constantize
+    identity_class_name.try(:constantize)
   end
 
   def self.identity_class_name
-    @@identity_class.camelize
+    @@identity_class.try(:camelize) || 'Identity'
   end
 
   def self.user_class
-    user_class_name.constantize
+    user_class_name.try(:constantize)
   end
 
   def self.user_class_name
-    @@user_class.camelize
+    @@user_class.try(:camelize) || 'User'
   end
 end

data/lib/socialite/controllers/helpers.rb

@@ -4,130 +4,20 @@ module Socialite
       extend ActiveSupport::Concern
 
       included do
-        helper_method :current_user, :user_signed_in?, :current_user?, :default_route
+        helper_method :current_user, :user_signed_in?
       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 ||= 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
-
-    protected
-
-      # 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 there is no current user
-      #
-      # @return [Boolean]
-      # (see #current_user?)
-      def ensure_no_user
-        !current_user? || redirect_back_or_default
-      end
-
-      ## 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
-
-      # 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
-
-      # 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
+        @current_user ||= User.find_by_id(session[:user_id])
       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] = session[:return_to] = nil
-        @current_user = nil
-        cookies.delete(:remember_token)
+      def current_user=(user)
+        @current_user = user
+        session[:user_id] = user.nil? ? user : user.id
       end
     end
   end