jakewendt-simply_authorized 1.3.6

data/lib/simply_authorized/tasks.rb

@@ -0,0 +1 @@
+Dir["#{File.dirname(__FILE__)}/../tasks/**/*.rake"].sort.each { |ext| load ext }

data/lib/simply_authorized/test_tasks.rb

@@ -0,0 +1,47 @@
+module SimplyAuthorized;end
+namespace :test do
+	namespace :units do
+		Rake::TestTask.new(:simply_authorized => "db:test:prepare") do |t|
+			t.pattern = File.expand_path(File.join(
+				File.dirname(__FILE__),'/../../test/unit/authorized/*_test.rb'))
+			t.libs << "test"
+			t.verbose = true
+		end
+	end
+	namespace :functionals do
+		Rake::TestTask.new(:simply_authorized => "db:test:prepare") do |t|
+			t.pattern = File.expand_path(File.join(
+				File.dirname(__FILE__),'/../../test/functional/authorized/*_test.rb'))
+			t.libs << "test"
+			t.verbose = true
+		end
+	end
+end
+Rake::Task['test:functionals'].prerequisites.unshift(
+	"test:functionals:simply_authorized" )
+Rake::Task['test:units'].prerequisites.unshift(
+	"test:units:simply_authorized" )
+
+#	I thought of possibly just including this file
+#	but that would make __FILE__ different.
+#	Hmmm
+
+#
+#	used in simply_helpful's rake test:coverage to run gem's 
+#		tests in the context of the application
+#
+@gem_test_dirs ||= []
+#@gem_test_dirs << File.expand_path(File.join(File.dirname(__FILE__),
+#	'/../../test/unit/authorized/'))
+#@gem_test_dirs << File.expand_path(File.join(File.dirname(__FILE__),
+#	'/../../test/functional/authorized/'))
+
+#
+#	More flexible. Find all test files, pick out their dir, uniq 'em and add.
+#
+Dir.glob( File.expand_path(File.join(File.dirname(__FILE__),
+		'/../../test/*/authorized/*_test.rb'))).collect{|f|
+	File.dirname(f)
+}.uniq.each{ |dir|
+	@gem_test_dirs << dir
+}

data/lib/simply_authorized/user_model.rb

@@ -0,0 +1,161 @@
+module SimplyAuthorized
+module 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 simply_authorized(options={})
+
+			include SimplyAuthorized::UserModel::InstanceMethods
+			extend  SimplyAuthorized::UserModel::ClassMethods
+
+			has_and_belongs_to_many :roles,  :uniq => true, 
+				:before_add => :before_add_role,
+				:after_add  => :after_add_role,
+				:before_remove => :before_remove_role,
+				:after_remove  => :after_remove_role
+
+		end
+		alias_method :authorized, :simply_authorized
+	end
+
+	module ClassMethods
+
+#		def search(options={})
+#			conditions = {}
+#			includes = joins = []
+#			if !options[:role_name].blank?
+#				includes = [:roles]
+#				if Role.all.collect(&:name).include?(options[:role_name])
+#					joins = [:roles]
+#					conditions = ["roles.name = '#{options[:role_name]}'"]
+#		#		else
+#		#			@errors = "No such role '#{options[:role_name]}'"
+#				end 
+#			end 
+#			self.all( 
+#				:joins => joins, 
+#				:include => includes,
+#				:conditions => conditions )
+#		end 
+
+	end
+
+	module InstanceMethods
+
+		def before_add_role(role)
+		end
+
+		def after_add_role(role)
+		end
+
+		def before_remove_role(role)
+		end
+
+		def after_remove_role(role)
+		end
+
+		def role_names
+			roles.collect(&:name).uniq
+		end
+
+		def deputize
+			roles << Role.find_or_create_by_name('administrator')
+		end
+
+		#	The 4 common CCLS roles are ....
+		def is_superuser?(*args)
+			self.role_names.include?('superuser')
+		end
+		alias_method :is_super_user?, :is_superuser?
+
+		def is_administrator?(*args)
+			self.role_names.include?('administrator')
+		end
+
+		def is_editor?(*args)
+			self.role_names.include?('editor')
+		end
+
+		def is_interviewer?(*args)
+			self.role_names.include?('interviewer')
+		end
+
+		def is_reader?(*args)
+			self.role_names.include?('reader')
+		end
+
+		def is_user?(user=nil)
+			!user.nil? && self == user
+		end
+		alias_method :may_be_user?, :is_user?
+
+		def may_administrate?(*args)
+			(self.role_names & ['superuser','administrator']).length > 0
+		end
+		alias_method :may_view_permissions?,        :may_administrate?
+		alias_method :may_create_user_invitations?, :may_administrate?
+		alias_method :may_view_users?,              :may_administrate?
+		alias_method :may_assign_roles?,            :may_administrate?
+
+		def may_edit?(*args)
+			(self.role_names & 
+				['superuser','administrator','editor']
+			).length > 0
+		end
+		alias_method :may_maintain_pages?, :may_edit?
+
+
+#	Add tests for may_interview and may_read
+		def may_interview?(*args)
+			(self.role_names & 
+				['superuser','administrator','editor','interviewer']
+			).length > 0
+		end
+
+#	This is pretty lame as all current roles can read
+		def may_read?(*args)
+			(self.role_names & 
+				['superuser','administrator','editor','interviewer','reader']
+			).length > 0
+		end
+		alias_method :may_view?, :may_read?
+
+
+
+		def may_view_user?(user=nil)
+			self.is_user?(user) || self.may_administrate?
+		end
+
+
+
+
+		def may_share_document?(document=nil)
+			document && ( 
+				self.is_administrator? ||
+				( document.owner && self == document.owner ) 
+			)
+		end
+
+		def may_view_document?(document=nil)
+			document
+
+
+
+
+
+		end
+
+	protected
+
+	end
+
+end
+end
+ActiveRecord::Base.send( :include, SimplyAuthorized::UserModel )

data/lib/tasks/application.rake

@@ -0,0 +1,40 @@
+namespace :app do
+
+#	task :args_as_array do
+#		args = $*.dup.slice(1..-1)
+#		puts args.collect {|arg| "X:" << arg }.join("\n")
+#		exit
+#	end
+
+	desc "Add some expected users."
+	task :add_users => :environment do
+		puts "Adding users"
+		%w( 859908 228181 214766 180918 66458 808 768475 
+			10883 86094 754783 769067 854720 16647 ).each do |uid|
+			puts " - Adding user with uid:#{uid}:"
+			User.find_create_and_update_by_uid(uid)
+		end
+	end
+
+	desc "Deputize user by UID"
+	task :deputize => :environment do
+		puts
+		if ENV['uid'].blank?
+			puts "User's CalNet UID required."
+			puts "Usage: rake #{$*} uid=INTEGER"
+			puts
+			exit
+		end
+		if !User.exists?(:uid => ENV['uid'])
+			puts "No user found with uid=#{ENV['uid']}."
+			puts
+			exit
+		end
+		user = User.find(:first, :conditions => { :uid => ENV['uid'] })
+		puts "Found user #{user.displayname}.  Deputizing..."
+		user.deputize
+		puts "User deputized: #{user.is_administrator?}"
+		puts
+	end
+
+end

data/lib/tasks/database.rake

@@ -0,0 +1,52 @@
+namespace :db do
+
+	desc "Create yml fixtures for given model in database\n" <<
+	     "rake db:extract_fixtures_from pages"
+	task :extract_fixtures_from => :environment do
+		me = $*.shift
+		while( table_name = $*.shift )
+			File.open("#{RAILS_ROOT}/db/#{table_name}.yml", 'w') do |file|
+				data = table_name.singularize.capitalize.constantize.find(
+					:all).collect(&:attributes)
+				file.write data.inject({}) { |hash, record|
+					record.delete('created_at')
+					record.delete('updated_at')
+					hash["#{table_name}_#{record['id']}"] = record
+					hash
+				}.to_yaml
+			end
+		end
+		exit
+	end
+
+	desc "Dump MYSQL table descriptions."
+	task :describe => :environment do
+		puts
+		puts "FYI: This task ONLY works on MYSQL databases."
+		puts
+		config = ActiveRecord::Base.connection.instance_variable_get(:@config)
+#=> {:adapter=>"mysql", :host=>"localhost", :password=>nil, :username=>"root", :database=>"my_development", :encoding=>"utf8"}
+
+		tables = ActiveRecord::Base.connection.execute('show tables;')
+		while( table = tables.fetch_row ) do
+			puts "Table: #{table}"
+
+			#	may have to include host and port
+			system("mysql --table=true " <<
+				"--user=#{config[:username]} " <<
+				"--password='#{config[:password]}' " <<
+				"--execute='describe #{table}' " <<
+				config[:database]);
+
+			#
+			#	mysql formats the table well so doing it by hand is something that
+			#	will have to wait until I feel like wasting my time
+			#
+			#	columns = ActiveRecord::Base.connection.execute("describe #{table};")
+			#	while( column = columns.fetch_hash ) do
+			#		puts column.keys Extra Default Null Type Field Key
+			#	end
+		end
+	end
+
+end

data/lib/tasks/documentation.rake

@@ -0,0 +1,68 @@
+#
+#	This file has been copied from rails 
+#		.../rails-2.3.5/lib/tasks/documentation.rake
+#	so that parts of it could be modified.
+
+namespace :doc do	|doc|
+
+#	Rake::RDocTask.new("app") { |rdoc|
+#
+#		We cannot overwrite or override an RDoc rake task.
+#		Redefining it here actually creates another
+#		of the same name and both are run when
+#		`rake doc:app` is called.	The Rakefile
+#		is modified to handle the modifications.
+#
+#		Actually, that's not entirely true.  This would
+#		add another task, but you can remove and override
+#		a task.  The rdoc_rails plugin was overriding my
+#		override, which caused all the frustration!!!
+#
+#	}
+
+	plugins = FileList['vendor/plugins/**'].collect { |plugin| 
+		File.basename(plugin) }
+
+	namespace :plugins do
+		# Define doc tasks for each plugin
+		plugins.each do |plugin|
+
+			#	clear rails' Rake::Task of the same name
+			Rake::Task[plugin].clear_actions
+			Rake::Task[plugin].clear_prerequisites
+
+			Rake::RDocTask.new(plugin) { |rdoc|
+				plugin_base  = "vendor/plugins/#{plugin}"
+				ENV['format'] ||= 'railsfish'
+				rdoc.rdoc_dir = "doc/plugins/#{plugin}"
+				rdoc.template = ENV['template'] if ENV['template']
+				rdoc.title    = "#{plugin.titlecase} Plugin Documentation"
+				rdoc.options << '--line-numbers' << '--inline-source'
+				rdoc.options << '--charset' << 'utf-8'
+				rdoc.options << '--format'  << ENV['format']
+				rdoc.rdoc_files.include("#{plugin_base}/lib/**/*.rb")
+				rdoc.rdoc_files.include("#{plugin_base}/app/**/*.rb")
+
+				%w( README README.rdoc ).each do |readme|
+					if File.exist?("#{plugin_base}/#{readme}")
+						rdoc.main = "#{plugin_base}/#{readme}"
+						break
+					end
+				end
+				%w( TODO.org MIT-LICENSE LICENSE CHANGELOG README README.rdoc ).each do |possible_file|
+					if File.exist?("#{plugin_base}/#{possible_file}")
+						rdoc.rdoc_files.include("#{plugin_base}/#{possible_file}") 
+					end
+				end
+			}
+
+		end
+	end
+
+	task :parse_readme => :environment do
+		require 'rdoc/markup/to_html'
+		h = RDoc::Markup::ToHtml.new
+		puts h.convert( File.read('README.rdoc') )
+	end
+
+end

data/lib/tasks/rcov.rake

@@ -0,0 +1,44 @@
+#
+#	This is from Advanced Rails Recipes, page 277
+#
+
+#	TODO use the version in simply_helpful and delete this
+
+#namespace :test do
+#	
+#	desc 'Tracks test coverage with rcov'
+#	task :coverage do
+#		rm_f "coverage"
+#		rm_f "coverage.data"
+#		
+#		unless PLATFORM['i386-mswin32']
+#			rcov = "rcov --sort coverage --rails --aggregate coverage.data " <<
+#							"--text-summary -Ilib -T " <<
+#							"-x gems/*,db/migrate/*,jrails/*/*" <<
+#							',\(eval\),\(recognize_optimized\),\(erb\)' <<    # needed in jruby
+#							",yaml,yaml/*,lib/tmail/parser.y,jruby.jar!/*" << # needed in jruby
+#							",html_test/*/*" <<
+#							",html_test_extension/*/*"
+#		else
+#			rcov = "rcov.cmd --sort coverage --rails --aggregate " <<
+#							"coverage.data --text-summary -Ilib -T"
+#		end
+#		
+#		dirs = Dir.glob("test/**/*_test.rb").collect{|f|File.dirname(f)}.uniq
+#		lastdir = dirs.pop
+#		dirs.each do |dir|
+#			system("#{rcov} --no-html #{dir}/*_test.rb")
+#		end
+#		system("#{rcov} --html #{lastdir}/*_test.rb") unless lastdir.nil?
+#		
+#		unless PLATFORM['i386-mswin32']
+##	jruby-1.5.0.RC1 > PLATFORM 
+##	 => "java" 
+##			system("open coverage/index.html") if PLATFORM['darwin']
+#			system("open coverage/index.html")
+#		else
+#			system("\"C:/Program Files/Mozilla Firefox/firefox.exe\" " +
+#						 "coverage/index.html")
+#		end
+#	end
+#end

data/lib/tasks/simply_sessions.rake

@@ -0,0 +1,5 @@
+#	From `script/generate simply_sessions` ...
+unless Gem.source_index.find_name('jakewendt-simply_sessions').empty?
+	gem 'jakewendt-simply_sessions'
+	require 'simply_sessions/test_tasks'
+end

data/rails/init.rb

@@ -0,0 +1,4 @@
+#
+#	THIS is the file that is "require"'d from rails' config.gem
+#
+require 'jakewendt-simply_authorized'

data/test/app/controllers/application_controller.rb

@@ -0,0 +1,16 @@
+class ApplicationController < ActionController::Base
+
+	helper :all # include all helpers, all the time
+
+	# See ActionController::RequestForgeryProtection for details
+	protect_from_forgery
+
+	def redirections
+		@redirections ||= HashWithIndifferentAccess.new({
+			:not_be_user => {
+				:redirect_to => user_path(current_user)
+			}
+		})
+	end
+
+end