configurability 1.0.0

data/rake/testing.rb

@@ -0,0 +1,187 @@
+# 
+# Rake tasklib for testing tasks
+
+# 
+# Authors:
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+
+unless defined?( COVERAGE_MINIMUM )
+	if ENV['COVVERAGE_MINIMUM']
+		COVERAGE_MINIMUM = Float( ENV['COVERAGE_MINIMUM'] )
+	else
+		COVERAGE_MINIMUM = 85.0 
+	end
+end
+SPEC_FILES       = [] unless defined?( SPEC_FILES )
+TEST_FILES       = [] unless defined?( TEST_FILES )
+
+COMMON_SPEC_OPTS = ['-Du'] unless defined?( COMMON_SPEC_OPTS )
+
+COVERAGE_TARGETDIR = BASEDIR + 'coverage' unless defined?( COVERAGE_TARGETDIR )
+RCOV_EXCLUDES      = 'spec,tests,/Library/Ruby,/var/lib,/usr/local/lib' unless
+	defined?( RCOV_EXCLUDES )
+
+
+desc "Run all defined tests"
+task :test do
+	unless SPEC_FILES.empty?
+		log "Running specs"
+		Rake::Task['spec:quiet'].invoke
+	end
+
+	unless TEST_FILES.empty?
+		log "Running unit tests"
+		Rake::Task[:unittests].invoke 
+	end
+end
+
+
+### RSpec specifications
+begin
+	gem 'rspec', '>= 1.1.3'
+
+	require 'spec'
+	require 'spec/rake/spectask'
+
+	### Task: spec
+	desc "Run specs"
+	task :spec => 'spec:doc'
+
+	namespace :spec do
+		desc "Run rspec every time there's a change to one of the files"
+		task :autotest do
+			require 'autotest/rspec'
+
+			autotester = Autotest::Rspec.new
+			autotester.run
+		end
+
+		desc "Generate regular color 'doc' spec output"
+		Spec::Rake::SpecTask.new( :doc ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = COMMON_SPEC_OPTS + ['-f', 's', '-c']
+		end
+
+		desc "Generate spec output with profiling"
+		Spec::Rake::SpecTask.new( :profile ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = COMMON_SPEC_OPTS + ['-f', 'o']
+		end
+
+		desc "Generate quiet non-colored plain-text output"
+		Spec::Rake::SpecTask.new( :quiet ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = COMMON_SPEC_OPTS + ['-f', 'p']
+		end
+
+		desc "Generate HTML output"
+		Spec::Rake::SpecTask.new( :html ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = COMMON_SPEC_OPTS + ['-f', 'h']
+		end
+
+	end
+rescue LoadError => err
+	task :no_rspec do
+		$stderr.puts "Specification tasks not defined: %s" % [ err.message ]
+	end
+
+	task :spec => :no_rspec
+	namespace :spec do
+		task :autotest => :no_rspec
+		task :doc => :no_rspec
+		task :profile => :no_rspec
+		task :quiet => :no_rspec
+		task :html => :no_rspec
+	end
+end
+
+
+### Test::Unit tests
+begin
+	require 'rake/testtask'
+
+	Rake::TestTask.new( :unittests ) do |task|
+		task.libs += [LIBDIR]
+		task.test_files = TEST_FILES
+		task.verbose = true
+	end
+
+rescue LoadError => err
+	task :no_test do
+		$stderr.puts "Test tasks not defined: %s" % [ err.message ]
+	end
+
+	task :unittests => :no_rspec
+end
+
+
+### RCov (via RSpec) tasks
+begin
+	gem 'rcov'
+	gem 'rspec', '>= 1.1.3'
+
+	require 'spec'
+	require 'rcov'
+
+	### Task: coverage (via RCov)
+	desc "Build test coverage reports"
+	unless SPEC_FILES.empty?
+		Spec::Rake::SpecTask.new( :coverage ) do |task|
+			task.spec_files = SPEC_FILES
+			task.libs += [LIBDIR]
+			task.spec_opts = ['-f', 'p', '-b']
+			task.rcov_opts = RCOV_OPTS
+			task.rcov = true
+		end
+	end
+
+
+	### Task: rcov
+	task :rcov => :coverage
+
+	### Other coverage tasks
+	namespace :coverage do
+		desc "Generate a detailed text coverage report"
+		Spec::Rake::SpecTask.new( :text ) do |task|
+			task.spec_files = SPEC_FILES
+			task.rcov_opts = RCOV_OPTS + ['--text-report']
+			task.rcov = true
+		end
+
+		desc "Show differences in coverage from last run"
+		Spec::Rake::SpecTask.new( :diff ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = ['-f', 'p', '-b']
+			task.rcov_opts = RCOV_OPTS - ['--save'] + ['--text-coverage-diff']
+			task.rcov = true
+		end
+
+		desc "Run RCov in 'spec-only' mode to check coverage from specs"
+		Spec::Rake::SpecTask.new( :speconly ) do |task|
+			task.spec_files = SPEC_FILES
+			task.rcov_opts = ['--exclude', RCOV_EXCLUDES, '--text-report', '--save']
+			task.rcov = true
+		end
+	end
+
+	CLOBBER.include( COVERAGE_TARGETDIR )
+
+rescue LoadError => err
+	task :no_rcov do
+		$stderr.puts "Coverage tasks not defined: RSpec+RCov tasklib not available: %s" %
+		[ err.message ]
+	end
+
+	task :coverage => :no_rcov
+	task :clobber_coverage
+	task :rcov => :no_rcov
+	namespace :coverage do
+		task :text => :no_rcov
+		task :diff => :no_rcov
+	end
+	task :verify => :no_rcov
+end
+
+

data/rake/verifytask.rb

@@ -0,0 +1,64 @@
+#####################################################################
+###	S U B V E R S I O N   T A S K S   A N D   H E L P E R S
+#####################################################################
+
+require 'rake/tasklib'
+
+#
+# Work around the inexplicable behaviour of the original RDoc::VerifyTask, which 
+# errors if your coverage isn't *exactly* the threshold.
+# 
+
+# A task that can verify that the RCov coverage doesn't
+# drop below a certain threshold. It should be run after
+# running Spec::Rake::SpecTask.
+class VerifyTask < Rake::TaskLib
+	
+	COVERAGE_PERCENTAGE_PATTERN = 
+		%r{<tt class='coverage_code'>(\d+\.\d+)%</tt>}
+	
+	# Name of the task. Defaults to :verify_rcov
+	attr_accessor :name
+
+	# Path to the index.html file generated by RCov, which
+	# is the file containing the total coverage.
+	# Defaults to 'coverage/index.html'
+	attr_accessor :index_html
+
+	# Whether or not to output details. Defaults to true.
+	attr_accessor :verbose
+
+	# The threshold value (in percent) for coverage. If the 
+	# actual coverage is not equal to this value, the task will raise an 
+	# exception. 
+	attr_accessor :threshold
+
+	def initialize( name=:verify )
+		@name = name
+		@index_html = 'coverage/index.html'
+		@verbose = true
+		yield self if block_given?
+		raise "Threshold must be set" if @threshold.nil?
+		define
+	end
+
+	def define
+		desc "Verify that rcov coverage is at least #{threshold}%"
+
+		task @name do
+			total_coverage = nil
+			if match = File.read( index_html ).match( COVERAGE_PERCENTAGE_PATTERN )
+				total_coverage = Float( match[1] )
+			else
+				raise "Couldn't find the coverage percentage in #{index_html}"
+			end
+
+			puts "Coverage: #{total_coverage}% (threshold: #{threshold}%)" if verbose
+			if total_coverage < threshold
+				raise "Coverage must be at least #{threshold}% but was #{total_coverage}%"
+			end
+		end
+	end
+end
+
+# vim: set nosta noet ts=4 sw=4:

data/spec/configurability_spec.rb

@@ -0,0 +1,211 @@
+#!/usr/bin/env ruby
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent
+
+	libdir = basedir + "lib"
+
+	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
+}
+
+require 'spec'
+require 'spec/lib/helpers'
+
+require 'configurability'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Configurability do
+	include Configurability::SpecHelpers
+
+	before( :all ) do
+		setup_logging( :fatal )
+	end
+
+	after( :each ) do
+		Configurability.configurable_objects.clear
+	end
+
+
+	it "adds a method for registering an including module's config key" do
+		klass = Class.new do
+			extend Configurability
+			config_key :testconfig
+		end
+
+		klass.config_key.should == :testconfig
+	end
+
+	it "fetches config sections via a method with the config key name if the config " +
+	   "responds_to? it" do
+		klass = Class.new do
+			extend Configurability
+			config_key :testconfig
+		end
+
+		config = stub( "configuration object" )
+		config.should_receive( :respond_to? ).with( :testconfig ).and_return( true )
+		config.should_receive( :testconfig ).and_return( :a_config_section )
+
+		klass.should_receive( :configure ).with( :a_config_section )
+		Configurability.configure_objects( config )
+	end
+
+	it "extends including classes instead of appending features to them" do
+		klass = Class.new do
+			include Configurability
+			config_key :testconfig
+		end
+
+		config = stub( "configuration object" )
+		config.should_receive( :respond_to? ).with( :testconfig ).and_return( true )
+		config.should_receive( :testconfig ).and_return( :a_config_section )
+
+		klass.should_receive( :configure ).with( :a_config_section )
+		Configurability.configure_objects( config )
+	end
+
+	it "fetches config sections via the index operator if the config doesn't respond " +
+	   "directly to the section name, but does to the index operator" do
+		klass = Class.new do
+			extend Configurability
+			config_key :testconfig
+		end
+
+		config = stub( "configuration object" )
+		config.should_receive( :respond_to? ).with( :testconfig ).and_return( false )
+		config.should_receive( :respond_to? ).with( :[] ).and_return( true )
+		config.should_receive( :[] ).with( :testconfig ).and_return( :a_config_section )
+
+		klass.should_receive( :configure ).with( :a_config_section )
+		Configurability.configure_objects( config )
+	end
+
+	it "passes nil to the configure method if the config doesn't respond to the section " +
+	   "name or the index operator" do
+		klass = Class.new do
+			extend Configurability
+			config_key :testconfig
+		end
+
+		config = stub( "configuration object" )
+		config.should_receive( :respond_to? ).with( :testconfig ).and_return( false )
+		config.should_receive( :respond_to? ).with( :[] ).and_return( false )
+
+		klass.should_receive( :configure ).with( nil )
+
+		Configurability.configure_objects( config )
+	end
+
+	it "tries the config key as a String if calling it with the Symbol returns nil" do
+		klass = Class.new do
+			extend Configurability
+			config_key :testconfig
+		end
+
+		config = stub( "configuration object" )
+		config.should_receive( :respond_to? ).with( :testconfig ).and_return( false )
+		config.should_receive( :respond_to? ).with( :[] ).and_return( true )
+		config.should_receive( :[] ).with( :testconfig ).and_return( nil )
+		config.should_receive( :[] ).with( 'testconfig' ).and_return( :a_config_section )
+
+		klass.should_receive( :configure ).with( :a_config_section )
+
+		Configurability.configure_objects( config )
+	end
+
+	it "can be used to configure plain objects, too" do
+		object = Object.new
+		object.extend( Configurability )
+		object.config_key = :testobjconfig
+
+		config = stub( "configuration object" )
+		config.should_receive( :respond_to? ).with( :testobjconfig ).and_return( true )
+		config.should_receive( :testobjconfig ).and_return( :a_config_section )
+
+		object.should_receive( :configure ).with( :a_config_section )
+
+		Configurability.configure_objects( config )
+	end
+
+	it "uses the object's name for its config key if it has one and hasn't specified a key " +
+	   "directly" do
+		object = Object.new
+		def object.name; "testobjconfig"; end
+		object.extend( Configurability )
+
+		config = stub( "configuration object" )
+		config.should_receive( :respond_to? ).with( :testobjconfig ).and_return( true )
+		config.should_receive( :testobjconfig ).and_return( :a_config_section )
+
+		object.should_receive( :configure ).with( :a_config_section )
+
+		Configurability.configure_objects( config )
+	end
+
+	it "normalizes the object's name before using it" do
+		object = Object.new
+		def object.name; "Test Obj-Config"; end
+		object.extend( Configurability )
+
+		config = stub( "configuration object" )
+		config.should_receive( :respond_to? ).with( :test_obj_config ).and_return( true )
+		config.should_receive( :test_obj_config ).and_return( :a_config_section )
+
+		object.should_receive( :configure ).with( :a_config_section )
+
+		Configurability.configure_objects( config )
+	end
+
+	it "uses the object's class's name for its config key if it doesn't have a name and " +
+	   "hasn't specified a key directly" do
+		object = Object.new
+		object.extend( Configurability )
+
+		config = stub( "configuration object" )
+		config.should_receive( :respond_to? ).with( :object ).and_return( true )
+		config.should_receive( :object ).and_return( :a_config_section )
+
+		object.should_receive( :configure ).with( :a_config_section )
+
+		Configurability.configure_objects( config )
+	end
+
+	it "uses only the last part of a class's name if it is namespaced" do
+		module My
+			class DbObject
+				extend Configurability
+			end
+		end
+
+		config = stub( "configuration object" )
+		config.should_receive( :respond_to? ).with( :dbobject ).and_return( true )
+		config.should_receive( :dbobject ).and_return( :a_config_section )
+
+		My::DbObject.should_receive( :configure ).with( :a_config_section )
+
+		Configurability.configure_objects( config )
+	end
+
+	it "uses the 'anonymous' key if the object doesn't have a name, and its class is " +
+	   "anonymous, and it hasn't specified a key directly" do
+		objectclass = Class.new
+		object = objectclass.new
+		object.extend( Configurability )
+
+		config = stub( "configuration object" )
+		config.should_receive( :respond_to? ).with( :anonymous ).and_return( true )
+		config.should_receive( :anonymous ).and_return( :a_config_section )
+
+		object.should_receive( :configure ).with( :a_config_section )
+
+		Configurability.configure_objects( config )
+	end
+
+end
+
+# vim: set nosta noet ts=4 sw=4: