jakewendt-calnet_authenticated 0.5.2

data/README.rdoc

@@ -0,0 +1,63 @@
+= CalNet Authenticated
+
+In Heavy Development ...
+
+
+
+
+This is a "rails" gem, so much of the code will
+be for testing in a rails app, but will not be
+included in the actual gem.
+
+== ToDo
+
+
+* Include migrations with an rsync or a generator
+* preferably a generator, but they are diff in rails 3
+  * rake task require mods to the Rakefile
+  * append requirement to Rakefile ?
+  * perhaps add initializer (don't know how rails 3 does it)
+* import some tests
+* include any test helpers for users
+* Cleanup code.  Isolate requirements
+
+== Installation / Usage
+
+ config.gem 'jakewendt-calnet_authenticated',
+   :lib    => 'calnet_authenticated',
+   :source => 'http://rubygems.org'
+
+ class User
+   calnet_authenticated
+ end
+
+ # Generates a db migration
+ script/generate calnet_authenticated User
+
+As some methods, like current_user, are flexible
+and dependent upon the developer's choice of user
+model, eager loading isn't good enough.
+The developer will need to ensure that the model
+is always around.  I chose to simply add ...
+
+ require 'user' <- or whatever your user model is
+
+to the bottom of my config/environment.rb outside
+of the initializer block.
+
+
+== Gemified with Jeweler
+
+ vi Rakefile
+ rake version:write
+
+ rake version:bump:patch
+ rake version:bump:minor
+ rake version:bump:major
+
+ rake gemspec
+
+ rake install
+ rake release
+
+Copyright (c) 2010 [George 'Jake' Wendt], released under the MIT license

data/app/controllers/sessions_controller.rb

@@ -0,0 +1,41 @@
+class SessionsController < ApplicationController
+
+#	skip_before_filter :login_required, :only => :create
+#
+#	def create
+#		CASClient::Frameworks::Rails::Filter.config[
+#			:service_url] = request.env["HTTP_REFERER"]
+#		CASClient::Frameworks::Rails::Filter.filter(self)
+#		unless performed?
+#		CASClient::Frameworks::Rails::Filter.config[:service_url] = nil
+#		redirect_to( session[:refer_to] || root_path ) 
+#		session[:refer_to] = nil
+#		end
+#	end
+
+	def destroy
+		calnetuid = session[:calnetuid]
+#	done in CASClient ... logout
+#		reset_session
+#	if done above, will cause
+#		NoMethodError (undefined method `destroy' for {}:Hash):
+#		rubycas-client-2.2.1/lib/casclient/frameworks/rails/filter.rb:
+#				183:in `send'
+#		rubycas-client-2.2.1/lib/casclient/frameworks/rails/filter.rb:
+#				183:in `logout'
+#
+# 179  def logout(controller, service = nil)
+# 180    referer = service || controller.request.referer
+# 181    st = controller.session[:cas_last_valid_ticket]
+# 182    delete_service_session_lookup(st) if st
+# 183    controller.send(:reset_session)
+# 184    controller.send(:redirect_to, client.logout_url(referer))
+# 185  end
+#
+#		This seems odd as you should be able to reset the
+#		session anytime and as often as you'd like.
+#
+		CASClient::Frameworks::Rails::Filter.logout(self)
+	end
+
+end

data/config/routes.rb

@@ -0,0 +1,8 @@
+ActionController::Routing::Routes.draw do |map|
+
+	map.logout 'logout', :controller => 'sessions', :action => 'destroy'
+
+#	map.resources :sessions, :only => [ :destroy ]
+	map.resource :session, :only => [ :destroy ]
+
+end

data/generators/calnet_authenticated/USAGE

@@ -0,0 +1,14 @@
+script/generate calnet_authenticated CalnetAuthenticatedName [options]
+
+
+Description:
+    Explain the generator
+
+Example:
+    ./script/generate calnet_authenticated User
+
+    This will create:
+        a migration file for 
+
+
+blah blah blah

data/generators/calnet_authenticated/calnet_authenticated_generator.rb

@@ -0,0 +1,88 @@
+class CalnetAuthenticatedGenerator < Rails::Generator::NamedBase
+
+#		def initialize(runtime_args, runtime_options = {})
+#	puts "In initialize"
+#	#		#	Rails::Generator::NamedBase apparently requires
+#	#		#	at least 1 argumnet.  The first will be used
+#	#		#	for things like migration class name
+#	#		runtime_args.unshift 'CreateTracksTable'
+#			super
+#		end
+
+	def manifest
+		record do |m|
+			m.directory('config/autotest')
+			m.file('autotest_calnet_authenticated.rb', 'config/autotest/calnet_authenticated.rb')
+			m.directory('lib/tasks')
+			m.file('calnet_authenticated.rake', 'lib/tasks/calnet_authenticated.rake')
+
+#			File.open('Rakefile','a'){|f| 
+#				f.puts <<-EOF
+##       From `script/generate calnet_authenticated` ...
+#require 'calnet_authenticated/test_tasks'
+#				EOF
+#			}
+#
+#			File.open('.autotest','a'){|f| 
+#				f.puts <<-EOF
+##       From `script/generate calnet_authenticated` ...
+#require 'calnet_authenticated/autotest'
+#				EOF
+#			}
+
+			m.migration_template 'migration.rb', 'db/migrate', 
+				:migration_file_name => "add_calnet_authenticated_columns_to_#{file_path.gsub(/\//, '_').pluralize}"
+
+			m.directory('public/javascripts')
+			Dir["#{File.dirname(__FILE__)}/templates/javascripts/*js"].each{|file| 
+				f = file.split('/').slice(-2,2).join('/')
+				m.file(f, "public/javascripts/#{File.basename(file)}")
+			}
+			m.directory('public/stylesheets')
+			Dir["#{File.dirname(__FILE__)}/templates/stylesheets/*css"].each{|file| 
+				f = file.split('/').slice(-2,2).join('/')
+				m.file(f, "public/stylesheets/#{File.basename(file)}")
+			}
+#			m.directory('test/functional/calnet_authenticated')
+#			Dir["#{File.dirname(__FILE__)}/templates/functional/*rb"].each{|file| 
+#				f = file.split('/').slice(-2,2).join('/')
+#				m.file(f, "test/functional/calnet_authenticated/#{File.basename(file)}")
+#			}
+#			m.directory('test/unit/calnet_authenticated')
+#			Dir["#{File.dirname(__FILE__)}/templates/unit/*rb"].each{|file| 
+#				f = file.split('/').slice(-2,2).join('/')
+#				m.file(f, "test/unit/calnet_authenticated/#{File.basename(file)}")
+#			}
+		end
+	end
+
+end
+module Rails::Generator::Commands
+	class Create
+		def migration_template(relative_source, 
+				relative_destination, template_options = {})
+			migration_directory relative_destination
+			migration_file_name = template_options[
+				:migration_file_name] || file_name
+			if migration_exists?(migration_file_name)
+				puts "Another migration is already named #{migration_file_name}: #{existing_migrations(migration_file_name).first}: Skipping" 
+			else
+				template(relative_source, "#{relative_destination}/#{next_migration_string}_#{migration_file_name}.rb", template_options)
+			end
+		end
+	end #	Create
+	class Base
+	protected
+		#	the loop through migrations happens so fast
+		#	that they all have the same timestamp which
+		#	won't work when you actually try to migrate.
+		#	All the timestamps MUST be unique.
+		def next_migration_string(padding = 3)
+			@s = (!@s.nil?)? @s.to_i + 1 : if ActiveRecord::Base.timestamped_migrations
+				Time.now.utc.strftime("%Y%m%d%H%M%S")
+			else
+				"%.#{padding}d" % next_migration_number
+			end
+		end
+	end	#	Base
+end

data/generators/calnet_authenticated/templates/autotest_calnet_authenticated.rb

@@ -0,0 +1,2 @@
+#	From `script/generate calnet_authenticated` ...
+require 'calnet_authenticated/autotest'

data/generators/calnet_authenticated/templates/calnet_authenticated.rake

@@ -0,0 +1,4 @@
+#	From `script/generate calnet_authenticated` ...
+if Gem.searcher.find('calnet_authenticated')
+require 'calnet_authenticated/test_tasks'
+end

data/generators/calnet_authenticated/templates/functional/sessions_controller_test.rb

@@ -0,0 +1,72 @@
+#require File.dirname(__FILE__) + '/../test_helper'
+require 'test_helper'
+
+#SessionsController.class_eval do
+#	def show; redirect_to '/'; end
+#end
+class CalnetAuthenticated::SessionsControllerTest < ActionController::TestCase
+	tests SessionsController
+
+	test "should logout if authenticated" do
+		login_as Factory(:user)
+		assert_logged_in
+		delete :destroy
+		assert_redirected_to_logout
+	end
+
+	test "should NOT logout if NOT authenticated" do
+		assert_not_logged_in
+		delete :destroy
+		assert_redirected_to_login
+	end
+
+#
+#	A temp testing route :show was created specifically to 
+#	test the current_user and logged_in? methods.  Without
+#	actually making a request, these methods fail as the
+#	session is nil.  When making a :destroy request, it is
+#	destroyed and can't be checked.
+#
+#	I suppose that I could create a new controller that
+#	doesn't meddle with the session, but ...
+#
+
+#	test "should not be logged_in? without login" do
+#		assert_not_logged_in
+#		get :show
+#		assert_not_logged_in
+#		assert_equal false, @controller.logged_in?
+#		assert_redirected_to_login
+#	end
+#
+#	test "should be logged_in? with login" do
+#		assert_not_logged_in
+#		login_as Factory(:user)
+#		assert_logged_in
+#		get :show
+#		assert_logged_in
+#		assert_equal true, @controller.logged_in?
+#		assert_redirected_to '/'
+#	end
+#
+#	test "should not have current_user without login" do
+#		assert_not_logged_in
+#		get :show
+#		assert_not_logged_in
+#		assert_nil @controller.current_user
+#		assert_redirected_to_login
+#	end
+#
+#	test "should have a current_user with login" do
+#		assert_not_logged_in
+#		login_as Factory(:user)
+#		assert_logged_in
+#		get :show
+#		assert_logged_in
+#		assert_not_nil @controller.current_user
+#		assert @controller.current_user.is_a?(User)
+#		assert @controller.current_user.is_a?(CalnetAuthenticatedUser())
+#		assert_redirected_to '/'
+#	end
+
+end

data/generators/calnet_authenticated/templates/migration.rb

@@ -0,0 +1,37 @@
+class AddCalnetAuthenticatedColumnsTo<%= class_name.pluralize.gsub(/::/, '') -%> < ActiveRecord::Migration
+	def self.up
+		table_name = '<%= file_path.gsub(/\//, '_').pluralize %>'
+		create_table table_name do |t|
+			t.timestamps
+		end unless table_exists?(table_name)
+		cols = columns(table_name).map(&:name)
+		add_column( table_name, :uid, :string 
+			) unless cols.include?('uid')
+		add_column( table_name, :sn, :string 
+			) unless cols.include?('sn')
+		add_column( table_name, :displayname, :string 
+			) unless cols.include?('displayname')
+		add_column( table_name, :mail, :string, { 
+				:default => '', :null => false } 
+			) unless cols.include?('mail')
+		add_column( table_name, :telephonenumber, :string 
+			) unless cols.include?('telephonenumber')
+
+		idxs = indexes(table_name).map(&:name)
+		add_index( table_name, :uid, :unique => true 
+			) unless idxs.include?("index_#{table_name}_on_uid")
+		add_index( table_name, :sn 
+			) unless idxs.include?("index_#{table_name}_on_sn")
+	end
+
+	def self.down
+		table_name = '<%= file_path.gsub(/\//, '_').pluralize %>'
+		remove_index  table_name, :uid
+		remove_index  table_name, :sn 
+		remove_column table_name, :uid
+		remove_column table_name, :sn
+		remove_column table_name, :displayname
+		remove_column table_name, :mail
+		remove_column table_name, :telephonenumber
+	end
+end

data/lib/calnet_authenticated.rb

@@ -0,0 +1,34 @@
+require 'casclient'
+require 'casclient/frameworks/rails/filter'
+require 'ucb_ldap'
+
+module CalnetAuthenticated
+#	predefine namespace
+end
+require 'calnet_authenticated/user_model'
+require 'calnet_authenticated/controller'
+require 'calnet_authenticated/test_helper'
+
+#	I don't think that this is needed
+#	Apparently it is.  I don't quite understand
+#	why my ccls_engine doesn't.
+%w{models controllers}.each do |dir|
+	path = File.expand_path(File.join(File.dirname(__FILE__), '../app', dir))
+	ActiveSupport::Dependencies.autoload_paths << path
+	ActiveSupport::Dependencies.autoload_once_paths << path
+end
+
+#	I don't think this is needed
+#
+#	Why do I need this for calnet_authenticated,
+#	but not for authorized or photos or ...
+#
+#	I think that it depends on whether the gem is
+#	explictly added to the configuration with config.gem
+#	or just a dependency with a require.
+#	Since buffler and clic and engine only have config.gem ccls_engine,
+#	we need to be explicit, which is probably better anyway.
+ActionController::Routing::Routes.add_configuration_file(
+	File.expand_path(
+		File.join(
+			File.dirname(__FILE__), '../config/routes.rb')))

data/lib/calnet_authenticated/autotest.rb

@@ -0,0 +1,26 @@
+class Autotest::Rails
+
+#
+#	Need both the mapping and the extra files
+#
+	def run_with_calnet_authenticated
+		add_exception %r%config/%
+		add_exception %r%versions/%
+		add_exception %r%\.git/%
+		self.extra_files << File.expand_path(File.join(
+				File.dirname(__FILE__),'/../../test/unit/calnet_authenticated/'))
+
+		self.extra_files << File.expand_path(File.join(
+				File.dirname(__FILE__),'/../../test/functional/calnet_authenticated/'))
+
+		add_mapping( 
+			%r{^#{File.expand_path(File.join(File.dirname(__FILE__),'/../../test/'))}/(unit|functional)/calnet_authenticated/.*_test\.rb$}
+			) do |filename, _|
+			filename
+		end
+		run_without_calnet_authenticated
+	end
+	alias_method_chain :run, :calnet_authenticated
+
+
+end

data/lib/calnet_authenticated/controller.rb

@@ -0,0 +1,91 @@
+require 'action_controller'
+
+#	Further info regarding UCB's CAS setup can be found at 
+#	https://calnet.berkeley.edu/developers/developerResources/cas/CASAppSetup.html#firstLevelServers
+
+module CalnetAuthenticated::Controller
+
+	#	Setup the CASClient and add the cas_filter before_filter
+	#	to all application_controller requests.  This can be
+	#	overridden or "skipped" in any controller, particularly
+	#	those that are passive and will use the cas_gateway_filter
+	#	instead.
+	def self.included(base)
+		base_server_url = ( RAILS_ENV == "production" ) ? 
+			"https://auth.berkeley.edu" : 
+			"https://auth-test.berkeley.edu"
+
+		CASClient::Frameworks::Rails::Filter.configure(
+			:username_session_key => :calnetuid,
+			:cas_base_url => "#{base_server_url}/cas/"
+		)
+
+		base.helper_method :current_user, :logged_in?
+
+		base.extend(ClassMethods)
+		base.send(:include, InstanceMethods)
+
+		base.class_eval do
+			class << self
+				alias_method_chain :inherited, :calnet_before_filter
+			end
+		end
+	end
+
+module ClassMethods
+
+private
+
+	def inherited_with_calnet_before_filter(base)
+		identifier = 'inherited_calnet_authenticated_login_required'
+		unless filter_chain.select(&:before?).map(&:identifier
+			).include?(identifier)
+			before_filter :login_required,
+				:identifier => identifier
+		end
+		inherited_without_calnet_before_filter(base)
+	end
+
+end
+
+module InstanceMethods
+
+	def logged_in?
+		!current_user.nil?
+	end
+
+	#	Force the user to be have an SSO session open.
+	def current_user_required
+		# Have to add ".filter(self)" when not in before_filter line.
+		CASClient::Frameworks::Rails::Filter.filter(self)
+	end
+	alias_method :login_required, :current_user_required
+
+	def current_user
+		@current_user ||= if( session && session[:calnetuid] )
+				#	if the user model hasn't been loaded yet
+				#	this will return nil and fail.
+				$CalnetAuthenticatedUser.find_create_and_update_by_uid(session[:calnetuid])
+			else
+				nil
+			end
+	end
+
+	# This will allow the user to view the page without authentication
+	# but will process CAS authentication data if the user already
+	# has an SSO session open.  This is potentially useful if you
+	#	don't store a copy of the user info locally.  Otherwise,
+	#	not so much.
+#
+#	Not using, so commented out so not to affect code coverage output.
+#
+#	def cas_gateway_filter
+#		# Have to add ".filter(self)" when not in before_filter line.
+#		CASClient::Frameworks::Rails::GatewayFilter.filter(self)
+#		@login_url = CASClient::Frameworks::Rails::Filter.login_url(self)
+#	end
+
+end	#	InstanceMethods
+
+end	#	CalnetAuthenticated::Controller
+ActionController::Base.send(:include,CalnetAuthenticated::Controller)

data/lib/calnet_authenticated/test_helper.rb

@@ -0,0 +1,64 @@
+module CalnetAuthenticated::TestHelper
+
+	def login_as( user=nil )
+		uid = ( user.is_a?($CalnetAuthenticatedUser) ) ? user.uid : user
+		if !uid.blank?
+			@request.session[:calnetuid] = uid
+			stub_ucb_ldap_person()
+			$CalnetAuthenticatedUser.find_create_and_update_by_uid(uid)
+
+			CASClient::Frameworks::Rails::Filter.stubs(
+				:filter).returns(true)
+			# No longer using the GatewayFilter stuff.
+			# CASClient::Frameworks::Rails::GatewayFilter.stubs(
+			# :filter).returns(true)
+		end
+	end
+	alias :login :login_as
+	alias :log_in :login_as
+
+
+	def stub_ucb_ldap_person(options={})
+		UCB::LDAP::Person.stubs(:find_by_uid).returns(
+			UCB::LDAP::Person.new({
+				:sn => ["Wendt"],
+				:displayname => ["Mr. Jake Wendt, BA"],
+				:telephonenumber => ["+1 510 642-9749"],
+				:mail => []
+			})
+		)
+		# Load schema locally for offline testing.
+		# This will generate this warning...
+		# Warning: schema loading from file
+		# from ucb_ldap-1.3.2/lib/ucb_ldap_schema.rb
+		# Comment this out to get the schema from Cal.
+		# This will generate this warning...
+		# warning: peer certificate won't be verified in this SSL session
+		UCB::LDAP::Schema.stubs(
+			:load_attributes_from_url).raises(StandardError)
+	end
+
+	def assert_redirected_to_login
+		assert_response :redirect
+		assert_match "https://auth-test.berkeley.edu/cas/login",
+			@response.redirected_to
+	end
+
+	def assert_redirected_to_logout
+		assert_response :redirect
+		assert_match "https://auth-test.berkeley.edu/cas/logout",
+			@response.redirected_to
+	end
+
+	def assert_logged_in
+		assert_not_nil session[:calnetuid]
+	end
+
+	def assert_not_logged_in
+		assert_nil session[:calnetuid]
+	end
+
+end
+require 'active_support'
+require 'active_support/test_case'
+ActiveSupport::TestCase.send(:include,CalnetAuthenticated::TestHelper)

data/lib/calnet_authenticated/test_tasks.rb

@@ -0,0 +1,29 @@
+module CalnetAuthenticated;end
+namespace :test do
+	namespace :units do
+		Rake::TestTask.new(:calnet_authenticated => "db:test:prepare") do |t|
+			t.pattern = File.expand_path(File.join(
+				File.dirname(__FILE__),'/../../test/unit/calnet_authenticated/*_test.rb'))
+			t.libs << "test"
+			t.verbose = true
+		end
+	end
+	namespace :functionals do
+		Rake::TestTask.new(:calnet_authenticated => "db:test:prepare") do |t|
+			t.pattern = File.expand_path(File.join(
+				File.dirname(__FILE__),'/../../test/functional/calnet_authenticated/*_test.rb'))
+			t.libs << "test"
+			t.verbose = true
+		end
+	end
+end
+Rake::Task['test:functionals'].prerequisites.unshift(
+	"test:functionals:calnet_authenticated" )
+Rake::Task['test:units'].prerequisites.unshift(
+	"test:units:calnet_authenticated" )
+
+#	I thought of possibly just including this file
+#	but that would make __FILE__ different.
+#	Hmmm
+
+

data/lib/calnet_authenticated/user_model.rb

@@ -0,0 +1,90 @@
+#class CalnetAuthenticated::User
+#	cattr_accessor :model
+#end
+#Object.class_eval do
+#	#	MUST BE ACCESSED WITH TRAILING ()
+#	define_method 'CalnetAuthenticatedUser' do
+#		CalnetAuthenticated::User.model
+#	end
+#end
+module CalnetAuthenticated::UserModel
+
+	def self.included(base)
+		base.extend(PrepMethod)
+#		base.send(:include, InstanceMethods)
+#		base.class_eval do
+#			alias_method_chain :reset_persistence_token, :uniqueness
+#		end
+	end
+
+	module PrepMethod
+		def calnet_authenticated(options={})
+			validates_presence_of   :uid
+			validates_uniqueness_of :uid
+
+			include CalnetAuthenticated::UserModel::InstanceMethods
+			extend  CalnetAuthenticated::UserModel::ClassMethods
+
+			#	All I want is a reference to the
+			#	calling model.
+
+			#	This seems to work and I am surprised.
+			#	>> User.object_id
+			#	=> 2162702020
+			#	>> CalnetAuthenticated::User.object_id
+			#	=> 2162702020
+			#	The purpose is to allow the user to specify
+			#	the model name.  
+#			class CalnetAuthenticated::User < self; end
+#	=> class definition in method body
+#			CalnetAuthenticated::User = Class.new( self )
+#	=> dynamic constant assignment
+#			eval "CalnetAuthenticated::User = self"
+#			CalnetAuthenticated::User.model = self
+
+#			CalnetAuthenticatedUser = self
+#		didn't work due to something regarding the Role assocation
+#		I should try with has_many :through rather than habtm
+
+			$CalnetAuthenticatedUser = self
+
+#			Object.class_eval do
+##				class << self
+#				attr_accessor :calnet_authenticated_user
+#				calnet_authenticated_user=self
+##				end
+#			end
+#			$calnet_authenticated_user=self
+#			Object.class_eval do
+#			define_method 'CalnetAuthenticated::User' do
+#				self
+#			end
+#			end
+#	=> just doesn't work
+		end
+	end	#	PrepMethod
+
+	module ClassMethods
+		#	Find or Create a user from a given uid, and then 
+		#	proceed to update the user's information from the 
+		#	UCB::LDAP::Person.find_by_uid(uid) response.
+		#	
+		#	Returns: user
+		def find_create_and_update_by_uid(uid)
+			user = self.find_or_create_by_uid(uid)
+			person = UCB::LDAP::Person.find_by_uid(uid) 
+			user.update_attributes!({
+				:displayname     => person.displayname,
+				:sn              => person.sn.first,
+				:mail            => person.mail.first || '',
+				:telephonenumber => person.telephonenumber.first
+			})
+			user
+		end
+	end	#	ClassMethods
+
+	module InstanceMethods
+	end	#	InstanceMethods
+end	#	CalnetAuthenticated::UserModel
+require 'active_record'
+ActiveRecord::Base.send(:include,CalnetAuthenticated::UserModel)

data/lib/jakewendt-calnet_authenticated.rb

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

data/test/app/controllers/application_controller.rb

@@ -0,0 +1,8 @@
+class ApplicationController < ActionController::Base
+
+	helper :all # include all helpers, all the time
+
+	# See ActionController::RequestForgeryProtection for details
+	protect_from_forgery
+
+end

data/test/app/controllers/home_controller.rb

@@ -0,0 +1,10 @@
+class HomeController < ApplicationController
+
+	skip_before_filter :login_required
+
+	def show
+		render :text => "You are home.",
+			:layout => true
+	end
+
+end

data/test/app/controllers/users_controller.rb

@@ -0,0 +1,43 @@
+class UsersController < ApplicationController
+
+#	skip_before_filter :login_required, :only => :menu
+
+	before_filter :id_required, 
+		:only => [:edit, :show, :update, :destroy]
+#	before_filter :may_view_user_required, 
+#		:except => [:index,:menu]
+#	before_filter :may_view_users_required, 
+#		:only => :index
+
+#	ssl_allowed :menu
+
+#	def menu
+#		respond_to do |format|
+#			format.js {}
+#		end
+#	end
+
+	def show
+#		@roles = Role.all
+	end
+
+	def index
+		@users = User.find(:all)
+	end
+
+	def destroy
+		@user.destroy
+		redirect_to users_path
+	end
+
+protected
+
+	def id_required
+		if !params[:id].blank? and User.exists?(params[:id])
+			@user = User.find(params[:id])
+		else
+			access_denied("user id required!", users_path)
+		end
+	end
+
+end

data/test/app/models/user.rb

@@ -0,0 +1,3 @@
+class User < ActiveRecord::Base
+	calnet_authenticated
+end

data/test/config/routes.rb

@@ -0,0 +1,13 @@
+ActionController::Routing::Routes.draw do |map|
+
+	map.logout 'logout', :controller => 'sessions', :action => 'destroy'
+
+	#	This routes is just for testing the session 'hash'
+	map.resource :session, :only => [ :show ]
+
+	map.resources :users, :only => [:destroy,:show,:index] 
+
+	map.resource :home, :only => :show
+	map.root :controller => :home, :action => :show
+
+end

data/test/factories.rb

@@ -0,0 +1,6 @@
+Factory.define :user do |f|
+	f.sequence(:uid) { |n| "UID#{n}" }
+end
+Factory.define :admin_user, :parent => :user do |f|
+	f.administrator true
+end	#	parent must be defined first

data/test/functional/calnet_authenticated/sessions_controller_test.rb

@@ -0,0 +1,72 @@
+#require File.dirname(__FILE__) + '/../test_helper'
+require 'test_helper'
+
+#SessionsController.class_eval do
+#	def show; redirect_to '/'; end
+#end
+class CalnetAuthenticated::SessionsControllerTest < ActionController::TestCase
+	tests SessionsController
+
+	test "should logout if authenticated" do
+		login_as Factory(:user)
+		assert_logged_in
+		delete :destroy
+		assert_redirected_to_logout
+	end
+
+	test "should NOT logout if NOT authenticated" do
+		assert_not_logged_in
+		delete :destroy
+		assert_redirected_to_login
+	end
+
+#
+#	A temp testing route :show was created specifically to 
+#	test the current_user and logged_in? methods.  Without
+#	actually making a request, these methods fail as the
+#	session is nil.  When making a :destroy request, it is
+#	destroyed and can't be checked.
+#
+#	I suppose that I could create a new controller that
+#	doesn't meddle with the session, but ...
+#
+
+#	test "should not be logged_in? without login" do
+#		assert_not_logged_in
+#		get :show
+#		assert_not_logged_in
+#		assert_equal false, @controller.logged_in?
+#		assert_redirected_to_login
+#	end
+#
+#	test "should be logged_in? with login" do
+#		assert_not_logged_in
+#		login_as Factory(:user)
+#		assert_logged_in
+#		get :show
+#		assert_logged_in
+#		assert_equal true, @controller.logged_in?
+#		assert_redirected_to '/'
+#	end
+#
+#	test "should not have current_user without login" do
+#		assert_not_logged_in
+#		get :show
+#		assert_not_logged_in
+#		assert_nil @controller.current_user
+#		assert_redirected_to_login
+#	end
+#
+#	test "should have a current_user with login" do
+#		assert_not_logged_in
+#		login_as Factory(:user)
+#		assert_logged_in
+#		get :show
+#		assert_logged_in
+#		assert_not_nil @controller.current_user
+#		assert @controller.current_user.is_a?(User)
+#		assert @controller.current_user.is_a?(CalnetAuthenticatedUser())
+#		assert_redirected_to '/'
+#	end
+
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification 
+name: jakewendt-calnet_authenticated
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: 
+  segments: 
+  - 0
+  - 5
+  - 2
+  version: 0.5.2
+platform: ruby
+authors: 
+- George 'Jake' Wendt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-08 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        version: "2"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ucb_ldap
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 4
+        - 2
+        version: 1.4.2
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rubycas-client
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 2
+        - 2
+        - 1
+        version: 2.2.1
+  type: :runtime
+  version_requirements: *id003
+description: longer description of your gem
+email: github@jake.otherinbox.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- app/controllers/sessions_controller.rb
+- config/routes.rb
+- generators/calnet_authenticated/USAGE
+- generators/calnet_authenticated/calnet_authenticated_generator.rb
+- generators/calnet_authenticated/templates/autotest_calnet_authenticated.rb
+- generators/calnet_authenticated/templates/calnet_authenticated.rake
+- generators/calnet_authenticated/templates/functional/sessions_controller_test.rb
+- generators/calnet_authenticated/templates/migration.rb
+- lib/calnet_authenticated.rb
+- lib/calnet_authenticated/autotest.rb
+- lib/calnet_authenticated/controller.rb
+- lib/calnet_authenticated/test_helper.rb
+- lib/calnet_authenticated/test_tasks.rb
+- lib/calnet_authenticated/user_model.rb
+- lib/jakewendt-calnet_authenticated.rb
+- README.rdoc
+- test/app/controllers/application_controller.rb
+- test/app/controllers/home_controller.rb
+- test/app/controllers/users_controller.rb
+- test/app/models/user.rb
+- test/config/routes.rb
+- test/factories.rb
+- test/functional/calnet_authenticated/sessions_controller_test.rb
+has_rdoc: true
+homepage: http://github.com/jakewendt/calnet_authenticated
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: one-line summary of your gem
+test_files: 
+- test/app/controllers/application_controller.rb
+- test/app/controllers/home_controller.rb
+- test/app/controllers/users_controller.rb
+- test/app/models/user.rb
+- test/config/routes.rb
+- test/factories.rb
+- test/functional/calnet_authenticated/sessions_controller_test.rb