simple_user_auth 0.0.2 → 0.0.3

data/README.rdoc

@@ -6,6 +6,12 @@ In your model
     include SimpleUserAuth::Model
     authenticate_by :email # Authenticate the user by email attribute
 
+This gem assumes that you have a field called encrypted_password and a field called salt in your user model.
+It also creates accessors for password and current_password (for password changes).
+
 In ApplicationController
     include SimpleUserAuth::Controller
+    can_sign_in :user # uses the User model.
 
+In your Gemfile
+    gem 'simple_user_auth', '>= 0.0.2'

data/lib/simple_user_auth/version.rb

@@ -1,3 +1,3 @@
 module SimpleUserAuth
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/simple_user_auth.rb

@@ -2,7 +2,7 @@ module SimpleUserAuth
   
   module Model
     
-    def self.included(klass)
+    def self.included(klass) # :nodoc:
       klass.extend(ClassMethods)
       klass.class_eval do
         include ClassInstanceMethods
@@ -11,16 +11,22 @@ module SimpleUserAuth
           :presence     => { :if => :new_record_or_change_password? },
           :confirmation => { :if => :new_record_or_change_password? },
           :length       => { :within => 6..40, :if => :new_record_or_change_password? }
-        before_save :encrypt_password     
+        attr_accessor :password
+        attr_accessor :current_password
+        before_save :encrypt_password   
       end
     end
     
     module ClassMethods
       
+      # Select the database field you want to find the user by with when you use the authenticate method
+      # e.g. authenticate_by(:email)
       def authenticate_by(authenticator)
         write_inheritable_attribute(:authenticator, authenticator)
       end
       
+      # Finds the user in the database by the authenticator and verifys them against the submitted password
+      # e.g. User.authenticate(params[:session][:email], params[:session][:password])
       def authenticate(search, submitted_password)
         authenticator = read_inheritable_attribute(:authenticator)
         user = find(:first, :conditions => ["#{authenticator} = ?", search])
@@ -28,33 +34,37 @@ module SimpleUserAuth
         return user if user.has_password?(submitted_password)
       end
 
-      def authenticate_with_salt(id, cookie_salt)
+      # Finds a user by a given id and authenticates them based on the salt stored in a cookie.
+      def authenticate_with_salt(id, salt)
         user = find_by_id(id)
-        (user && user.salt == cookie_salt) ? user : nil
+        (user && user.salt == salt) ? user : nil
       end
 
     end
     
     module ClassInstanceMethods
-       def change_password_validator
-          if change_password?
-            errors.add(:old_password, "doesn't match.") unless has_password?(current_password)
-          end
-        end
-
-        def change_password?
+      
+        def change_password? #:nodoc:
           @change_password ||= false
         end
 
+        # Set this to true to enable replacing encrypted_password with the password accessor. Also enables validations for passwords.
         def change_password=(bool)
           @change_password = bool
         end
-
+        
+        # Checks to see if a user has a particular password
         def has_password?(submitted_password)
           encrypted_password == encrypt(submitted_password)
         end
         
         private
+        
+        def change_password_validator
+           if change_password?
+             errors.add(:old_password, "doesn't match.") unless has_password?(current_password)
+           end
+         end
 
         def encrypt_password
           self.salt = make_salt if new_record?
@@ -81,28 +91,36 @@ module SimpleUserAuth
   
   module Controller
     
-    def self.included(klass)
-      klass.class_eval do
-        include ClassMethods
+    def self.included(klass) # :nodoc:
+      klass.extend(ClassMethods)
+      klass.class_eval do 
+        include ClassInstanceMethods
+        helper_method :current_user, :signed_in?, :not_signed_in?, :current_user?
       end
-      ActionView::Base.send(:include, ClassMethods)
     end
     
     module ClassMethods
+      # The user model you'll be using. This could be useful if there were different user models for different namespaces.
+      # e.g. can_sign_in :user
+      def can_sign_in(model)
+        klass = Kernel.const_get(model.to_s.camelize)
+        write_inheritable_attribute(:user_model_for_sign_in, klass)
+      end
+    end
+    
+    module ClassInstanceMethods
       
+      # Signs in a user, if the second parameter is false (default) the cookie will last only the session.
       def sign_in(user, remember_me = false)
         if remember_me
-          cookies.permanent.signed[:remember_token] = [user.id, user.salt]
+          cookies.permanent.signed[remember_token_name] = [user.id, user.salt]
         else
-          cookies.signed[:remember_token] = [user.id, user.salt]
+          cookies.signed[remember_token_name] = [user.id, user.salt]
         end
         self.current_user = user
       end
 
-      def current_user=(user)
-        @current_user = user
-      end
-
+      # Returns the user object of the currently signed in user.
       def current_user
         @current_user ||= user_from_remember_token
       end
@@ -116,7 +134,7 @@ module SimpleUserAuth
       end
 
       def sign_out
-        cookies.delete(:remember_token)
+        cookies.delete(remember_token_name)
         self.current_user = nil
       end
 
@@ -124,28 +142,43 @@ module SimpleUserAuth
         user == current_user
       end
 
+      # Stores the location of the resource trying to be accessed and redirects to signin_path
       def deny_access
         store_location
         redirect_to signin_path, :notice => "Please sign in to access this page."
       end
 
+      # Redirects back to the stored location, or to the value passed.
       def redirect_back_or(default)
         redirect_to(session[:return_to] || default)
         clear_return_to
       end
-
+      
+      # This is useful as a before filter, it will deny access unless signed in.
       def authenticate
         deny_access unless signed_in?
       end
 
       private
+      
+      def user_model
+        self.class.read_inheritable_attribute(:user_model_for_sign_in)
+      end
+      
+      def remember_token_name
+        "#{user_model.name.downcase}_remember_token".to_sym
+      end
+      
+      def current_user=(user)
+        @current_user = user
+      end
 
       def user_from_remember_token
-        User.authenticate_with_salt(*remember_token)
+        user_model.authenticate_with_salt(*remember_token)
       end
 
       def remember_token
-        cookies.signed[:remember_token] || [nil, nil]
+        cookies.signed[remember_token_name] || [nil, nil]
       end
       
       def store_location

metadata

@@ -2,7 +2,7 @@
 name: simple_user_auth
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Erich Menge