hashrocket-clearance 0.4.0

data/lib/clearance/app/controllers/application_controller.rb

@@ -0,0 +1,88 @@
+module Clearance
+  module App
+    module Controllers
+      module ApplicationController
+    
+        def self.included(base)
+          base.class_eval do
+            helper_method :current_user
+            helper_method :logged_in?
+        
+            include InstanceMethods
+
+         protected
+            include ProtectedInstanceMethods
+          end
+        end
+    
+        module InstanceMethods
+          def current_user
+            @current_user ||= (user_from_session || user_from_cookie)
+          end
+      
+          def logged_in?
+            ! current_user.nil?
+          end
+        end
+
+        module ProtectedInstanceMethods
+          def login_required
+            logged_in? || deny_access('Permission denied', :redirect => new_session_path)
+          end
+          
+          def authenticate
+            deny_access unless logged_in?
+          end
+
+          def user_from_session
+            user_model.find_by_id session[:user_id]
+          end
+
+          def user_from_cookie
+            user = user_model.find_by_remember_token(cookies[:auth_token]) if cookies[:auth_token]
+            user && user.remember_token? ? user : nil
+          end
+
+          # Level of indirection so you can easily override this method
+          # but also call #login .
+          def log_user_in(user)
+            login(user)
+          end
+
+          def login(user)
+            session[:user_id] = user.id if user
+            @current_user = user
+          end
+
+          def redirect_back_or(default)
+            session[:return_to] ? redirect_to(session[:return_to]) : redirect_to(default)
+            session[:return_to] = nil
+          end
+      
+          def redirect_to_root
+            redirect_to root_url
+          end
+
+          def store_location
+            session[:return_to] = request.request_uri
+          end
+
+          def deny_access(flash_message = nil, opts = {})
+            opts[:redirect] ||= new_session_path
+            store_location
+            flash[:error] = flash_message if flash_message
+            redirect_to opts[:redirect]
+          end
+      
+          def user_model
+            User
+          end
+
+          def mailer_model
+            ClearanceMailer
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clearance/app/controllers/confirmations_controller.rb

@@ -0,0 +1,36 @@
+module Clearance
+  module App
+    module Controllers
+      module ConfirmationsController
+    
+        def self.included(base)
+          base.class_eval do
+            include InstanceMethods
+        
+          private
+            include PrivateInstanceMethods
+          end
+        end
+    
+        module InstanceMethods
+          def confirm
+            user = User.find_by_confirmation_code(params[:confirmation_code])
+            if user.nil?
+              render(:nothing => true, :status => :not_found) and return
+            end
+            user.confirm!
+            login(user)
+            redirect_to url_after_confirm
+          end
+        end
+    
+        module PrivateInstanceMethods
+          def url_after_confirm
+            root_url
+          end
+        end
+    
+      end
+    end
+  end
+end

data/lib/clearance/app/controllers/facebook_sessions_controller.rb

@@ -0,0 +1,59 @@
+module Clearance
+  module App
+    module Controllers
+      module FacebookSessionsController
+        def self.included(base)
+          base.class_eval do
+            include Facebooker::Rails::Controller
+            before_filter :ensure_authenticated_to_facebook, :only => %w(facebook_new facebook_create)
+            
+            include InstanceMethods
+            extend ClassMethods
+            
+            class_inheritable_hash :_facebook_to_user_field_mappings
+          end
+        end
+        
+        module InstanceMethods
+          def facebook_new
+            # handle the case where ensure_authenticated_to_facebook filter passes through,
+            # like when the user has already authenticated and we have the facebook cookies
+            redirect_to facebook_create_session_url
+          end
+
+          def facebook_create
+            facebook_user = facebook_session.user
+            facebook_id = facebook_user.facebook_id
+
+            user = User.find_by_facebook_id(facebook_id)
+
+            unless user
+              user = User.create! do |u|
+                u.facebook_id = facebook_id
+                u.confirmed = true
+                
+                if _facebook_to_user_field_mappings
+                  _facebook_to_user_field_mappings.each do |facebook_field, user_field|
+                    u.send("#{user_field}=", facebook_user.send(facebook_field))
+                  end
+                end
+              end
+
+              mail = ClearanceMailer.create_facebook_welcome(user)
+              facebook_user.send_email(mail.subject, mail.body)   
+            end
+
+            login user
+            redirect_back_or root_url
+          end
+        end # InstanceMethods
+        
+        module ClassMethods
+          def facebook_to_user_field_mappings(mappings = {})
+            self._facebook_to_user_field_mappings = mappings
+          end
+        end #ClassMethods        
+      end # FacebookSessionsController
+    end
+  end
+end

data/lib/clearance/app/controllers/passwords_controller.rb

@@ -0,0 +1,58 @@
+module Clearance
+  module App
+    module Controllers
+      module PasswordsController
+
+        def self.included(base)
+          base.class_eval do
+            before_filter :find_user_with_reset_password_code_or_deny, :only => [:edit, :update]
+            filter_parameter_logging :password, :password_confirmation
+            
+            include InstanceMethods
+            
+          private
+            include PrivateInstanceMethods
+          end
+        end
+
+        module InstanceMethods
+          def create
+            user = User.find_by_email params[:email]
+            if user.nil?
+              flash.now[:error] = 'Unknown email'
+              render :action => :new
+            else
+              user.generate_reset_password_code
+              ClearanceMailer.deliver_forgot_password user
+              redirect_to url_after_create
+            end
+          end
+
+          def update
+            if @user.reset_password(params)
+              session[:user_id] = @user.id
+              redirect_to @user
+            else
+              flash.now[:error] = 'Password not changed.'
+              render :action => :edit
+            end
+          end
+        end
+
+        module PrivateInstanceMethods
+          def find_user_with_reset_password_code_or_deny
+            @user = User.find_by_reset_password_code(params[:id])
+            if @user.nil?
+              render :nothing => true, :status => :not_found
+            end
+          end
+          
+          def url_after_create
+            new_session_url
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/clearance/app/controllers/sessions_controller.rb

@@ -0,0 +1,83 @@
+module Clearance
+  module App
+    module Controllers
+      module SessionsController
+
+        def self.included(base)
+          base.class_eval do
+            skip_before_filter :authenticate
+            protect_from_forgery :except => :create
+            filter_parameter_logging :password
+        
+            include InstanceMethods
+        
+          private
+            include PrivateInstanceMethods
+          end
+        end
+    
+        module InstanceMethods
+          def create
+            @user = user_model.authenticate(params[:session][:email], params[:session][:password])
+            if @user.nil?
+              login_failure
+            else
+              if @user.confirmed?
+                remember_me = params[:session][:remember_me] if params[:session]
+                remember(@user) if remember_me == '1'
+                log_user_in(@user)
+                login_successful
+              else
+                unconfirmed_login_attempt
+              end
+            end
+          end
+
+          def destroy
+            forget(current_user)
+            reset_session
+            flash[:notice] = 'You have been logged out.'
+            redirect_to url_after_destroy
+          end
+        end
+
+        module PrivateInstanceMethods
+          def login_successful
+            flash[:notice] = 'Logged in successfully'
+            redirect_back_or url_after_create
+          end
+
+          def login_failure(message = "Bad email or password.")
+            flash.now[:notice] = message
+            render :action => :new
+          end
+          
+          def unconfirmed_login_attempt
+            mailer_model.deliver_confirmation(@user)
+            deny_access('Account not confirmed. Confirmation email sent.')
+          end
+      
+          def remember(user)
+            user.remember_me!
+            cookies[:auth_token] = { :value   => user.remember_token, 
+                                     :expires => user.remember_token_expires_at }
+          end
+
+          def forget(user)
+            user.forget_me! if user
+            cookies.delete :auth_token
+          end
+
+          def url_after_create
+            root_url
+          end
+
+          def url_after_destroy
+            new_session_url
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/clearance/app/controllers/users_controller.rb

@@ -0,0 +1,74 @@
+module Clearance
+  module App
+    module Controllers
+      module UsersController
+
+        def self.included(base)
+          base.class_eval do
+            filter_parameter_logging :password, :password_confirmation, :old_password
+            
+            before_filter :login_required, :only => [:change_password, :edit_password]
+            
+            include InstanceMethods
+        
+          private
+            include PrivateInstanceMethods
+          end
+        end
+
+        module InstanceMethods
+          def new
+            @user = user_model.new(params[:user])
+          end
+      
+          def create
+            @user = user_model.create params[:user]
+            @user.save ? create_successful : create_failed
+          end
+          
+          def edit_password
+            @user = current_user
+          end
+          
+          def change_password
+            @user = current_user
+            
+            if @user.change_password(params[:user])
+              flash[:notice] = "Password changed successfully."
+              after_successful_change_password
+            else
+              render :action => "edit_password"
+            end
+          end
+          
+        end
+
+        module PrivateInstanceMethods
+          
+          def create_successful
+            ClearanceMailer.deliver_confirmation @user
+            flash[:notice] = "You will receive an email within the next few minutes. It contains instructions for you to confirm your account."
+            redirect_to url_after_create
+          end
+          
+          def create_failed
+            render :action => "new"
+          end
+
+          def after_successful_change_password
+            redirect_to user_path(current_user)
+          end
+          
+          def url_after_create
+            new_session_url
+          end
+        
+          def url_after_change_password
+            user_path(current_user)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/clearance/app/models/clearance_facebook_mailer.rb

@@ -0,0 +1,20 @@
+module Clearance
+  module App
+    module Models
+      module ClearanceFacebookMailer
+        def self.included(base)
+          base.class_eval do
+            include InstanceMethods
+          end
+        end
+    
+        module InstanceMethods
+          def facebook_welcome(user)
+            subject "[#{PROJECT_NAME.humanize}]  Welcome!"
+            body :user => user
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clearance/app/models/clearance_mailer.rb

@@ -0,0 +1,33 @@
+module Clearance
+  module App
+    module Models
+      module ClearanceMailer
+    
+        def self.included(base)
+          base.class_eval do
+        
+            include InstanceMethods
+        
+          end
+        end
+    
+        module InstanceMethods
+          def forgot_password(user)
+            from       DO_NOT_REPLY
+            recipients user.email
+            subject    "[#{PROJECT_NAME.humanize}] Forgot your password"
+            body       :user => user
+          end
+        
+          def confirmation(user)
+            recipients user.email
+            from       DO_NOT_REPLY
+            subject   "[#{PROJECT_NAME.humanize}] Account confirmation"
+            body      :user => user
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/clearance/app/models/user.rb

@@ -0,0 +1,125 @@
+module Clearance
+  module App
+    module Models
+      module User
+        def self.included(base)
+          base.class_eval do
+            attr_accessor \
+              :password,
+              :password_confirmation,
+              :old_password
+
+            attr_accessible \
+              :email,
+              :password,
+              :password_confirmation
+
+            validates_presence_of   :email, :unless => :facebook_user?
+            validates_uniqueness_of :email, :unless => :facebook_user?
+
+            validates_presence_of     :password, :if => :password_required?
+            validates_confirmation_of :password, :if => :password_required?
+
+            before_save  :initialize_salt,            :unless => :facebook_user?
+            before_save  :encrypt_password,           :unless => :facebook_user?
+            after_create :generate_confirmation_code, :unless => :facebook_user?
+        
+            extend ClassMethods
+            include InstanceMethods
+        
+          protected
+
+            include ProtectedInstanceMethods
+        
+          end
+        end
+    
+        module ClassMethods
+          def authenticate(email, password)
+            user = find_by_email email
+            user && user.authenticated?(password) ? user : nil
+          end
+        end
+    
+        module InstanceMethods
+          def authenticated?(password)
+            crypted_password == encrypt(password)
+          end
+
+          def encrypt(password)
+            Digest::SHA1.hexdigest "--#{salt}--#{password}--"
+          end
+
+          def remember_token?
+            remember_token_expires_at && Time.now.utc < remember_token_expires_at
+          end
+
+          def remember_me!
+            remember_me_until 2.weeks.from_now.utc
+          end
+
+          def remember_me_until(time)
+            self.update_attribute :remember_token_expires_at, time
+            self.update_attribute :remember_token, encrypt("#{email}--#{remember_token_expires_at}")
+          end
+
+          def forget_me!
+            self.update_attribute :remember_token_expires_at, nil
+            self.update_attribute :remember_token, nil
+          end
+        
+          def confirm!
+            self.update_attribute :confirmed, true
+            update_attribute(:confirmation_code, nil)
+          end
+          
+          def generate_confirmation_code
+            update_attribute(:confirmation_code, Digest::SHA1.hexdigest(Time.now.to_s.split(//).sort_by {rand}.join))
+          end
+          
+          def generate_reset_password_code
+            update_attribute(:reset_password_code, Digest::SHA1.hexdigest(Time.now.to_s.split(//).sort_by {rand}.join))
+          end
+          
+          def reset_password(password_hash)
+            if update_attributes(password_hash.slice(:password, :password_confirmation))
+              update_attribute(:reset_password_code, nil)
+            end
+          end
+          
+          def change_password(password_hash)
+            if authenticated?(password_hash[:old_password])
+              update_attributes(password_hash.slice(:password, :password_confirmation))
+            else
+              errors.add(:old_password, "does not match")
+              return false
+            end
+          end
+          
+          def facebook_user?
+            not normal_user?
+          end
+
+          def normal_user?
+            self.respond_to?(:facebook_id) ? facebook_id.nil? : true
+          end
+        end
+    
+        module ProtectedInstanceMethods
+          def initialize_salt
+            self.salt = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{email}--") if new_record?
+          end
+
+          def encrypt_password
+            return if password.blank?
+            self.crypted_password = encrypt(password)
+          end
+
+          def password_required?
+            normal_user? && (crypted_password.blank? || !password.blank? || !password_confirmation.blank?)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clearance/spec/controllers/sessions_controller_spec.rb

@@ -0,0 +1,105 @@
+module Clearance
+  module Spec
+    module Controllers
+      module SessionsController
+        def self.included(base)
+          base.class_eval do
+            include ActionController::UrlWriter
+            
+            describe "#facebook_new" do
+              it "should redirect to facebook login url" do
+                get :facebook_new
+                response.should redirect_to(Facebooker.login_url_base)
+              end
+  
+              it "should redirect to facebook create if the user is already authenticated with facebook" do
+                controller.stubs(:ensure_authenticated_to_facebook).returns(true)
+                get :facebook_new
+                response.should redirect_to(facebook_create_session_url)
+              end
+            end
+
+            describe "#facebook_create" do
+              before(:each) do
+                controller.stubs(:ensure_authenticated_to_facebook).returns(true)
+                @facebook_user = stub('facebook_user', :facebook_id => 1, :first_name => 'Johnny', :last_name => 'McLovin', :birthday => 'today', :id => 1)
+                User.stubs(:find_by_facebook_id).returns(@facebook_user)
+                @facebook_session = stub_everything('facebook_session', :user => @facebook_user)
+                controller.stubs(:facebook_session).returns(@facebook_session)
+              end
+  
+              it "should get the facebook id from the session" do
+                controller.stubs(:redirect_back_or_default)
+                # @facebook_session.stubs(:user).returns(@facebook_user)
+                @facebook_user.expects(:facebook_id).returns(1)
+                get :facebook_create
+              end
+  
+              it "should try to find a user by their facebook id" do
+                controller.stubs(:redirect_back_or_default)
+                session[:facebook_session] = stub_everything('facebook_session', :facebook_id => 1)
+                User.expects(:find_by_facebook_id).with(1).returns(@facebook_user)
+                get :facebook_create
+              end
+  
+              it "should set the current user" do
+                controller.stubs(:redirect_back_or_default)
+                controller.expects(:login).with(@facebook_user)
+                get :facebook_create
+              end
+  
+              it "should call redirect_back_or_default" do
+                get :facebook_create
+                response.should be_redirect
+              end
+
+              describe "when user doesn't exist on our system" do
+                before :each do
+                  controller.stubs(:redirect_back_or_default)
+                  @facebook_user.stubs(:send_email)
+                  @facebook_session.stubs(:user).returns(@facebook_user)
+                  User.stubs(:find_by_facebook_id).returns(nil)
+                  @user = stub_everything("User")
+                end
+    
+                it "creates a user if one cannot be found" do
+                  User.expects(:new).returns(@user)
+                  get :facebook_create
+                end
+  
+                it "sets the first name, last name, facebook id on the new user" do
+                  User.stubs(:create!).yields(@user).returns(@user)
+                  @user.expects(:first_name=).with('Johnny')
+                  @user.expects(:last_name=).with('McLovin')
+                  @user.expects(:facebook_id=).with(1)
+                  get :facebook_create
+                end
+
+                it "activates the new user" do
+                  get :facebook_create
+                  saved_user = User.last
+                  saved_user.should be_confirmed
+                end
+
+                describe "Facebook user welcome email" do
+                  it "contains a link to the home page URL" do
+                    @user = stub("User", :email => "lark@example.com")
+                    mail = ClearanceMailer.create_facebook_welcome(@user)
+                    mail.body.should =~ /#{root_url}/
+                  end
+      
+                  it "sets the subject, body and sends email" do
+                    mail = stub("Mail", :subject => "some subject", :body => "some text")
+                    ClearanceMailer.stubs(:create_facebook_welcome).returns(mail)
+                    @facebook_user.expects(:send_email).with("some subject", "some text")
+                    get :facebook_create
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end