winton-authentication 1.0.0

data/CHANGELOG

@@ -0,0 +1,74 @@
+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)
+	* unauthenticated method stores request_uri in session[:return_to]
+
+2008-06-09 - Sean Huber (shuber@huberry.com)
+	* Removed accidently left over hard coded logic from password_required?
+
+2008-06-09 - Sean Huber (shuber@huberry.com)
+	* Reloading a model sets password_changed? to false
+
+2008-06-05 - Sean Huber (shuber@huberry.com)
+	* Changed email addresses in CHANGELOG
+
+2008-06-05 - Sean Huber (shuber@huberry.com)
+	* Added find_current_user functional tests
+
+2008-06-05 - Sean Huber (shuber@huberry.com)
+	* Renamed test files
+	* find_current_user always returns current_user
+
+2008-06-05 - Sean Huber (shuber@huberry.com)
+	* Renamed login_required to authentication_required
+
+2008-06-05 - Sean Huber (shuber@huberry.com)
+	* Renamed @searched_for_current_user to @queried_for_current_user
+
+2008-06-05 - Sean Huber (shuber@huberry.com)
+	* Added extra uses_authentication field options
+	* Updated README
+
+2008-06-05 - Sean Huber (shuber@huberry.com)
+	* current_user returns nil unless logged_in?
+	* Updated README
+
+2008-06-05 - Sean Huber (shuber@huberry.com)
+	* Updated README
+
+2008-06-05 - Sean Huber (shuber@huberry.com)
+	* Updated README
+
+2008-06-04 - Sean Huber (shuber@huberry.com)
+	* Updated README
+
+2008-06-04 - Sean Huber (shuber@huberry.com)
+	* Updated README
+
+2008-06-04 - Sean Huber (shuber@huberry.com)
+	* Controller no longer has to call uses_authentication - logic included automatically
+	* Updated README
+
+2008-06-04 - Sean Huber (shuber@huberry.com)
+	* Updated README
+
+2008-06-04 - Sean Huber (shuber@huberry.com)
+	* Updated README
+
+2008-06-04 - Sean Huber (shuber@huberry.com)
+	* Updated README
+
+2008-06-04 - Sean Huber (shuber@huberry.com)
+	* Added functional tests
+
+2008-06-04 - Sean Huber (shuber@huberry.com)
+	* Fixed functional test exception
+
+2008-06-04 - Sean Huber (shuber@huberry.com)
+	* Controller and model must call uses_authentication
+
+2008-06-04 - Sean Huber (shuber@huberry.com)
+	* Initial import from access_control_list repository
+	* Login field is configurable

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,82 @@
+Huberry::Authentication
+=======================
+
+A rails plugin that handles authentication
+
+
+Installation
+------------
+
+	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 :login_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
+	login_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 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 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')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1,7 @@
+require 'huberry/authentication/controller_methods'
+require 'huberry/authentication/model_methods'
+
+ActionController::Base.extend Huberry::Authentication::ControllerMethods
+ActiveRecord::Base.extend Huberry::Authentication::ModelMethods
+
+$:.unshift File.dirname(__FILE__) + '/lib'

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,45 @@
+$:.reject! { |path| path.include? 'TextMate' }
+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,63 @@
+--- !ruby/object:Gem::Specification 
+name: winton-authentication
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Sean Huber
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A rails plugin that handles authentication
+email: shuber@huberry.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- CHANGELOG
+- init.rb
+- lib/huberry/authentication/controller_methods.rb
+- lib/huberry/authentication/model_methods.rb
+- MIT-LICENSE
+- Rakefile
+- README.markdown
+has_rdoc: false
+homepage: http://github.com/shuber/authentication
+post_install_message: 
+rdoc_options: []
+
+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 plugin that handles authentication
+test_files: 
+- test/_controller_test.rb
+- test/_model_test.rb
+- test/helpers/table_test_helper.rb
+- test/helpers/user_test_helper.rb
+- test/init.rb