shuber-authentication 1.0.0

data/CHANGELOG

@@ -0,0 +1,35 @@
+2009-01-08 - Sean Huber (shuber@huberry.com)
+  * Clean up CHANGELOG
+  * Convert to soft tabs
+  * Remove .gitignore
+  * Gemify
+  * Remove logic that rejected TextMate paths to fix the old builder.rb conflict
+
+2008-06-23 - Sean Huber (shuber@huberry.com)
+  * Renamed authentication_message/redirect_path to unauthenticated_message/redirect_path
+  * logged_in? now accepts a block that will yield when true
+
+2008-06-09 - Sean Huber (shuber@huberry.com)
+  * Reloading a model sets password_changed? to false
+  * Removed accidently left over hard coded logic from password_required?
+  * unauthenticated method stores request_uri in session[:return_to]
+
+2008-06-05 - Sean Huber (shuber@huberry.com)
+  * Updated README
+  * current_user returns nil unless logged_in?
+  * Added extra uses_authentication field options
+  * Renamed @searched_for_current_user to @queried_for_current_user
+  * Renamed login_required to authentication_required
+  * find_current_user always returns current_user
+  * Renamed test files
+  * Added find_current_user functional tests
+  * Changed email addresses in CHANGELOG
+
+2008-06-04 - Sean Huber (shuber@huberry.com)
+  * Initial import from access_control_list repository
+  * Login field is configurable
+  * Controller and model must call uses_authentication
+  * Fixed functional test exception
+  * Added functional tests
+  * Updated README
+  * Controller no longer has to call uses_authentication - logic included automatically

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Sean Huber (shuber@huberry.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,84 @@
+authentication
+==============
+
+A rails gem/plugin that handles authentication
+
+
+Installation
+------------
+
+	gem install shuber-authentication --source http://gems.github.com
+	OR
+	script/plugin install git://github.com/shuber/authentication.git
+
+
+Example
+-------
+
+	class User < ActiveRecord::Base
+	  # Accepts an optional hash of options
+	  #   :login_field - The field to use for logins (e.g. username or email) (defaults to :email)
+	  #   :password_field - (defaults to :password)
+	  #   :hashed_password_field - (defaults to :hashed_password)
+	  #   :salt_field - (defaults to :salt)
+	  uses_authentication :login_field => :username
+	end
+	
+	class ApplicationController < ActionController::Base
+	  # Set optional authentication options here
+	  #   self.authentication_model = The model that uses authentication (defaults to 'User')
+	  #   self.unauthenticated_message = The error flash message to set when unauthenticated (defaults to 'Login to continue')
+	  #   self.unauthenticated_redirect_path = The path to redirect to when unauthenticated (can be a symbol of a method) (defaults to '/')
+	end
+	
+	class UsersController < ApplicationController
+	  before_filter :authentication_required, :only => [:index]
+	
+	  def index
+	    render :text => 'test'
+	  end
+	end	
+
+
+Controller Methods
+------------------
+
+	# Returns the current user or nil if a user is not logged in
+	current_user
+	
+	# Checks if the current user is authenticated (optionaly accepts a block that is yielded when true)
+	logged_in?
+	
+	# Login a user
+	login(user)
+	
+	# A before filter to require authentication - redirects to the controller class's authentication_redirect_path if unauthenticated
+	authentication_required
+	
+	# Logout the current user
+	logout
+
+
+Model Methods
+-------------
+
+	# Class method that authenticates a user based on a login and password - returns a user instance or false
+	User.authenticate(login, password)
+	
+	# Checks if the password passed to it matches the current user instance's password
+	authenticated?(password)
+	
+	# Checks if the current user instance's password has just been changed
+	password_changed?
+	
+	# Resets the password - will generate a new random password if one is not specified
+	reset_password(new_password = nil)
+	
+	# Resets the password and saves - will generate a new random password if one is not specified
+	reset_password!(new_password = nil)
+
+
+Contact
+-------
+
+Problems, comments, and suggestions all welcome: [shuber@huberry.com](mailto:shuber@huberry.com)

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run the authentication tests'
+task :default => :test
+
+desc 'Test the authentication gem/plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the authentication gem/plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'authentication'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.markdown')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1 @@
+require 'authentication'

data/lib/authentication.rb

@@ -0,0 +1,5 @@
+require 'huberry/authentication/controller_methods'
+require 'huberry/authentication/model_methods'
+
+ActionController::Base.extend Huberry::Authentication::ControllerMethods
+ActiveRecord::Base.extend Huberry::Authentication::ModelMethods

data/lib/huberry/authentication/controller_methods.rb

@@ -0,0 +1,61 @@
+module Huberry
+  module Authentication
+    module ControllerMethods      
+      def self.extended(base)
+        base.class_eval do
+          include InstanceMethods
+          
+          cattr_accessor :authentication_model, :unauthenticated_message, :unauthenticated_redirect_path
+          self.authentication_model = 'User'
+          self.unauthenticated_message = 'Login to continue'
+          self.unauthenticated_redirect_path = '/'
+          
+          attr_accessor :current_user
+          helper_method :current_user, :logged_in?
+        end
+      end
+      
+      module InstanceMethods
+        protected
+          
+          def authentication_required
+            unauthenticated unless logged_in?
+          end
+          
+          def find_current_user(force_query = false)
+            if @queried_for_current_user.nil? || force_query
+              @queried_for_current_user = true
+              self.current_user = self.class.authentication_model.to_s.constantize.find(session[:user_id]) rescue nil
+            end
+            self.current_user
+          end
+          
+          def logged_in?
+            find_current_user if self.current_user.nil?
+            if self.current_user.nil?
+              block_given? ? nil : false
+            else
+              block_given? ? yield : true
+            end
+          end
+          
+          def login(user)
+            self.current_user = user
+            session[:user_id] = user.id
+          end
+          
+          def logout
+            self.current_user = nil
+            session[:user_id] = nil
+          end
+          
+          def unauthenticated
+            session[:return_to] = request.request_uri
+            flash[:error] = self.class.unauthenticated_message.to_s
+            redirect_to respond_to?(self.class.unauthenticated_redirect_path) ? send(self.class.unauthenticated_redirect_path) : self.class.unauthenticated_redirect_path.to_s
+            false
+          end
+      end
+    end
+  end
+end

data/lib/huberry/authentication/model_methods.rb

@@ -0,0 +1,84 @@
+require 'digest/sha2'
+
+module Huberry
+  module Authentication
+    module ModelMethods
+      def uses_authentication(options = {})
+        extend ClassMethods
+        include InstanceMethods
+        
+        cattr_accessor :hashed_password_field, :login_field, :password_field, :salt_field
+        self.hashed_password_field = options[:hashed_password_field] || :hashed_password
+        self.login_field = options[:login_field] || :email
+        self.password_field = options[:password_field] || :password
+        self.salt_field = options[:salt_field] || :salt
+        
+        attr_accessor self.password_field, "#{self.password_field}_confirmation".to_sym
+        
+        validates_presence_of self.login_field
+        validates_presence_of self.password_field, :if => :password_required?
+        validates_confirmation_of self.password_field, :if => :password_required?
+        
+        before_save :hash_password
+        
+        alias_method_chain :reload, :authentication
+      end
+    end
+    
+    module ClassMethods
+      def authenticate(login, password)
+        user = send("find_by_#{self.login_field}", login)
+        user && user.authenticated?(password) ? user : false
+      end
+      
+      def digest(str)
+        Digest::SHA256.hexdigest(str.to_s)
+      end
+    end
+    
+    module InstanceMethods
+      def authenticated?(password)
+        send(self.class.hashed_password_field) == self.class.digest(password.to_s + send(self.class.salt_field).to_s)
+      end
+      
+      def password_changed?
+        !!@password_changed
+      end
+      
+      def reload_with_authentication(*args)
+        reload_without_authentication(*args)
+        @password_changed = false
+      end
+      
+      def reset_password(new_password = nil)
+        new_password = generate_salt[0..7] if new_password.blank?
+        send("#{self.class.salt_field}=", nil)
+        send("#{self.class.password_field}=", new_password)
+        send("#{self.class.password_field}_confirmation=", new_password)
+        @password_changed = true
+      end
+      
+      def reset_password!(new_password = nil)
+        reset_password(new_password)
+        save
+      end
+      
+      protected
+        
+        def generate_salt
+          self.class.digest("--#{Time.now}--#{rand}--")
+        end
+        
+        def hash_password
+          if password_changed? || password_required?
+            send("#{self.class.salt_field}=", generate_salt) if send("#{self.class.salt_field}").blank?
+            send("#{self.class.hashed_password_field}=", self.class.digest(send(self.class.password_field).to_s + send(self.class.salt_field).to_s))
+          end
+        end
+        
+        def password_required?
+          send(self.class.hashed_password_field).blank? || !send(self.class.password_field).blank?
+        end
+    end
+  end
+end

data/test/_controller_test.rb

@@ -0,0 +1,114 @@
+require File.dirname(__FILE__) + '/init'
+
+class TestController < ActionController::Base
+  before_filter :authentication_required, :only => :login_required
+  
+  def login_required
+    render :text => 'test'
+  end
+  
+  def login_not_required
+    render :text => 'test'
+  end
+  
+  def rescue_action(e)
+    raise e
+  end
+end
+
+ActionController::Routing::Routes.append do |map|
+  map.connect 'login_required', :controller => 'test', :action => 'login_required'
+  map.connect 'login_not_required', :controller => 'test', :action => 'login_not_required'
+end
+
+class ControllerTest < Test::Unit::TestCase
+  
+  def setup
+    create_users_table
+    @user = create_user
+
+    @controller = TestController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+
+    @controller.instance_variable_set('@_session', @request.session)
+  end
+  
+  def teardown
+    drop_all_tables
+  end
+
+  def test_logged_in?
+    assert !@controller.send(:logged_in?)
+    
+    @controller.send :login, @user
+    assert @controller.send(:logged_in?)
+    
+    @controller.send :logout
+    assert !@controller.send(:logged_in?)
+  end
+  
+  def test_logged_in_yields_block_on_true
+    assert_equal nil, @controller.send(:logged_in?) { 'some_value' }
+    
+    @controller.send :login, @user
+    assert_equal 'some_value', @controller.send(:logged_in?) { 'some_value' }
+  end
+  
+  def test_current_user
+    assert_nil @controller.send(:current_user)
+    
+    @controller.send :login, @user
+    assert_equal @user, @controller.send(:current_user)
+    
+    @controller.send :logout
+    assert_nil @controller.send(:current_user)
+  end
+
+  def test_should_require_login
+    get :login_required
+    assert_response :redirect
+    assert flash.has_key?(:error)
+    assert_equal @controller.unauthenticated_message, flash[:error]
+    assert_redirected_to '/'
+  end
+  
+  def test_should_not_require_login
+    get :login_not_required
+    assert_response :success
+  end
+  
+  def test_should_login_and_get_authentication_required
+    @controller.send :login, @user
+    get :login_required
+    assert_response :success
+  end
+  
+  def test_find_current_user_with_valid_user
+    @request.session[:user_id] = @user.id
+    assert_equal @user, @controller.send(:find_current_user)
+  end
+  
+  def test_find_current_user_with_nil_user
+    assert_nil @controller.send(:find_current_user)
+  end
+  
+  def test_find_current_user_with_invalid_user
+    @request.session[:user_id] = 2
+    assert_nil @controller.send(:find_current_user)
+  end
+  
+  def test_find_current_user_force_query
+    assert_nil @controller.send(:find_current_user)
+    
+    @request.session[:user_id] = @user.id
+    assert_nil @controller.send(:find_current_user)
+    assert_equal @user, @controller.send(:find_current_user, true)
+  end
+  
+  def test_unauthenticated_sets_return_to_session_variable
+    get :login_required
+    assert_equal @controller.session[:return_to], '/login_required'
+  end
+  
+end

data/test/_model_test.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/init'
+
+class ModelTest < Test::Unit::TestCase
+  
+  def setup
+    create_users_table
+  end
+  
+  def teardown
+    drop_all_tables
+  end
+
+  def test_should_create_user
+    assert_difference 'User.count' do
+      create_user
+    end
+  end
+
+  def test_should_not_create_without_email
+    assert_no_difference 'User.count' do
+      @user = create_user :email => ''
+    end
+    assert @user.errors.on(:email)
+  end
+  
+  def test_should_not_create_without_password
+    assert_no_difference 'User.count' do
+      @user = create_user :password => ''
+    end
+    assert @user.errors.on(:password)
+  end
+
+  def test_should_not_create_without_password_confirmation
+    assert_no_difference 'User.count' do
+      @user = create_user :password_confirmation => ''
+    end
+    assert @user.errors.on(:password)
+  end
+  
+  def test_should_generate_salt_on_create
+    @user = create_user
+    assert !@user.salt.blank?
+  end
+
+  def test_should_hash_password_on_create
+    @user = create_user
+    assert !@user.hashed_password.blank?
+  end
+
+  def test_should_destroy
+    @user = create_user
+    assert_difference 'User.count', -1 do
+      @user.destroy
+    end
+  end
+  
+  def test_should_authenticate
+    @user = create_user
+    assert_equal @user, User.authenticate(@user.email, @user.password)
+  end
+  
+  def test_should_not_authenticate_with_invalid_email
+    @user = create_user
+    assert !User.authenticate('invalid', @user.password)
+  end
+  
+  def test_should_not_authenticate_with_invalid_password
+    @user = create_user
+    assert !User.authenticate(@user.email, 'invalid')
+  end
+
+  def test_should_reset_password
+    @user = create_user
+    assert !@user.password_changed?
+    old_password = @user.password
+    
+    @user.reset_password('new_password')
+    assert_not_equal 'new_password', old_password
+    assert_equal 'new_password', @user.password
+    assert @user.password_changed?
+  end
+  
+  def test_should_reset_password!
+    @user = create_user
+    assert @user.reset_password!('new_password')
+  end
+  
+  def test_reload_should_set_password_changed_to_false
+    @user = create_user
+    assert !@user.password_changed?
+    
+    @user.reset_password!('new_password')
+    assert @user.password_changed?
+    
+    @user.reload
+    assert !@user.password_changed?
+  end
+
+end

data/test/helpers/table_test_helper.rb

@@ -0,0 +1,25 @@
+module TableTestHelper
+  
+  def create_users_table
+    silence_stream(STDOUT) do
+      ActiveRecord::Schema.define(:version => 1) do
+        create_table :users do |t|
+          t.string   :email
+          t.string   :hashed_password
+          t.string   :salt
+        end
+      end
+    end
+  end
+  
+  def drop_all_tables
+    ActiveRecord::Base.connection.tables.each do |table|
+      drop_table(table)
+    end
+  end
+  
+  def drop_table(table)
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+  
+end

data/test/helpers/user_test_helper.rb

@@ -0,0 +1,11 @@
+module UserTestHelper
+  
+  def create_user(options = {})
+    User.create(valid_user_hash(options))
+  end
+  
+  def valid_user_hash(options = {})
+    { :email => 'test@test.com', :password => 'test', :password_confirmation => 'test' }.merge(options)
+  end
+  
+end

data/test/init.rb

@@ -0,0 +1,44 @@
+require 'test/unit'
+
+# Require and include test helpers
+#
+Dir[File.join(File.dirname(__FILE__), 'helpers', '*_test_helper.rb')].each do |helper|
+  require helper
+  /(.*?)_test_helper\.rb/.match File.basename(helper)
+  class_name = $1.split('_').collect{ |name| name.downcase.capitalize }.join('') + 'TestHelper'
+  Test::Unit::TestCase.send :include, Object.const_get(class_name) if Object.const_defined?(class_name)
+end
+
+# Load ActiveRecord
+#
+require 'rubygems'
+gem 'activerecord'
+require 'active_record'
+ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :dbfile => ':memory:'
+
+# Load ActionPack
+#
+gem 'actionpack'
+require 'action_pack'
+require 'action_controller'
+require 'action_controller/routing'
+require 'action_controller/assertions'
+require 'action_controller/test_process'
+
+# Routing
+#
+class ActionController::Routing::RouteSet
+  def append
+    yield Mapper.new(self)
+    install_helpers
+  end
+end
+
+# Require the main init.rb for the plugin
+#
+require File.join(File.dirname(File.dirname(__FILE__)), 'init')
+
+# Basic user class
+class User < ActiveRecord::Base
+  uses_authentication
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: shuber-authentication
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Sean Huber
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-08 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: A rails gem/plugin that handles authentication
+email: shuber@huberry.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- CHANGELOG
+- init.rb
+- lib/authentication.rb
+- lib/huberry/authentication/controller_methods.rb
+- lib/huberry/authentication/model_methods.rb
+- MIT-LICENSE
+- Rakefile
+- README.markdown
+- test/helpers/table_test_helper.rb
+- test/helpers/user_test_helper.rb
+- test/init.rb
+has_rdoc: false
+homepage: http://github.com/shuber/authentication
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README.markdown
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A rails gem/plugin that handles authentication
+test_files: 
+- test/_controller_test.rb
+- test/_model_test.rb