strelka 0.0.1.pre.203 → 0.0.1.pre.214

data/lib/strelka/logging.rb

@@ -186,7 +186,7 @@ module Strelka::Logging
 			:info  => colorize( :normal ) {"[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"},
 			:warn  => colorize( :bold, :yellow ) {"[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"},
 			:error => colorize( :red ) {"[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"},
-			:fatal => colorize( :bold, :red, :on_white ) {"[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"},
+			:fatal => colorize( :bold, :red ) {"[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"},
 		}
 
 

data/lib/strelka/mixins.rb

@@ -305,9 +305,11 @@ module Strelka
 	#       include Strelka::MethodUtilities
 	#
 	#       singleton_attr_accessor :types
+	#       singleton_method_alias :kinds, :types
 	#   end
 	#
 	#   MyClass.types = [ :pheno, :proto, :stereo ]
+	#   MyClass.kinds # => [:pheno, :proto, :stereo]
 	#
 	module MethodUtilities
 
@@ -338,6 +340,12 @@ module Strelka
 			end
 		end
 
+		### Creates an alias for the +original+ method named +newname+.
+		def singleton_method_alias( newname, original )
+			singleton_class.__send__( :alias_method, newname, original )
+		end
+
+
 	end # module MethodUtilities
 
 
@@ -354,6 +362,7 @@ module Strelka
 			status_info = nil
 
 			if http_status.is_a?( Hash ) && http_status.key?(:status)
+				self.log.debug "Re-finishing with a status_info struct: %p." % [ http_status ]
 				status_info = http_status
 			else
 				message ||= HTTP::STATUS_NAME[ http_status ]

data/lib/strelka/paramvalidator.rb

@@ -371,7 +371,8 @@ class Strelka::ParamValidator < ::FormValidator
 		args.unshift( block ) if block
 
 		# Custom validator -- either a callback or a regex
-		if args.first.is_a?( Regexp ) || args.first.respond_to?( :call )
+		if args.first.is_a?( Regexp ) ||
+			args.first.respond_to?( :call )
 			self.profile[:constraints][ name ] = args.shift
 
 		# Builtin match validator, either explicit or implied by the name

data/lib/strelka/plugins.rb

@@ -209,6 +209,7 @@ module Strelka
 
 				extend( cm_mod )
 				cm_mod.instance_variables.each do |ivar|
+					next if instance_variable_defined?( ivar )
 					Strelka.log.debug "  copying class instance variable %s" % [ ivar ]
 					ival = cm_mod.instance_variable_get( ivar )
 
@@ -258,17 +259,18 @@ module Strelka
 		end
 
 
+		### Return the list of plugin modules that are in effect for the current
+		### app.
+		def application_stack
+			Strelka.log.debug "Ancestors are: %p" % [ self.class.ancestors ]
+			return self.ancestors.select {|mod| mod.respond_to?(:plugin_name) }
+		end
+
 
 		### Output the application stack into the logfile.
 		def dump_application_stack
-			stack = self.class.ancestors.
-				reverse.
-				drop_while {|mod| mod != Strelka::PluginLoader }.
-				select {|mod| mod.respond_to?(:plugin_name) }.
-				collect {|mod| mod.plugin_name }.
-				reverse
-
-			self.log.info "Application stack: request -> %s" % [ stack.join(" -> ") ]
+			stack = self.application_stack.map( &:plugin_name )
+			Strelka.log.info "Application stack: request -> %s" % [ stack.join(" -> ") ]
 		end
 
 	end # module PluginLoader

data/spec/strelka/app/errors_spec.rb

@@ -177,6 +177,29 @@ describe Strelka::App::Errors do
 			res.notes[:status_info][:message].should == "Your sandwich is missing something."
 		end
 
+		it "provides its own exception handler for the request phase" do
+			@app.class_eval do
+				on_status do |res, info|
+					res.body = info[:exception].class.name
+					return res
+				end
+
+				get do |req|
+					raise "An uncaught exception"
+				end
+			end
+
+			req = @request_factory.get( '/foom' )
+			res = @app.new.handle( req )
+
+			res.notes[:status_info].should include( :status, :message, :headers, :exception )
+			res.notes[:status_info][:status].should == HTTP::SERVER_ERROR
+			res.notes[:status_info][:message].should == "An uncaught exception"
+			res.notes[:status_info][:exception].should be_a( RuntimeError )
+			res.body.should == "RuntimeError"
+		end
+
+
 		context "template-style handlers" do
 
 			before( :all ) do

data/spec/strelka/app/templating_spec.rb

@@ -172,6 +172,25 @@ describe Strelka::App::Templating do
 				res.status.should == 200
 			end
 
+			it "doesn't wrap the layout around non-template responses" do
+				@app.class_eval do
+					layout 'layout.tmpl'
+
+					def handle_request( req )
+						# Super through the plugins and then load the template into the response
+						super do
+							res = req.response
+							res.body = self.template( :main ).render
+							res
+						end
+					end
+				end
+
+				res = @app.new.handle( @req )
+
+				res.body.should == "A template for testing the Templating plugin.\n"
+			end
+
 		end
 
 	end

data/spec/strelka/app_spec.rb

@@ -350,6 +350,27 @@ describe Strelka::App do
 		res.body.should =~ /internal server error/i
 	end
 
+	it "isn't in 'developer mode' by default" do
+		@app.should_not be_in_devmode()
+	end
+
+	it "can be configured to be in 'developer mode' using the Configurability API" do
+		@app.configure( devmode: true )
+		@app.should be_in_devmode()
+	end
+
+	it "configures itself to be in 'developer mode' if debugging is enabled" do
+		debugsetting = $DEBUG
+
+		begin
+			$DEBUG = true
+			@app.configure
+			@app.should be_in_devmode()
+		ensure
+			$DEBUG = debugsetting
+		end
+	end
+
 
 	describe "process name" do
 

data/spec/strelka/httpresponse/negotiation_spec.rb

@@ -38,6 +38,7 @@ describe Strelka::HTTPResponse::Negotiation do
 
 	before( :each ) do
 		@app = Class.new( Strelka::App ) { plugins :negotiation }
+		@app.install_plugins
 		@req = @request_factory.get( '/service/user/estark' )
 		@res = @req.response
 	end

data/spec/strelka/paramvalidator_spec.rb

@@ -49,932 +49,1005 @@ describe Strelka::ParamValidator do
 		@validator.should have_args()
 	end
 
-	it "allows constraints to be added" do
-		@validator.add( :a_field, :string )
-		@validator.param_names.should include( 'a_field' )
-	end
 
-	it "doesn't allow a parameter to be added twice" do
-		@validator.add( :a_field, :string )
-		expect {
+	describe "profile" do
+
+		it "allows constraints to be added" do
 			@validator.add( :a_field, :string )
-		}.to raise_error( /parameter "a_field" is already defined/i )
-		@validator.param_names.should include( 'a_field' )
-	end
+			@validator.param_names.should include( 'a_field' )
+		end
 
-	it "re-validates if profile is modified" do
-		@validator.add( :a_field, :string )
-		@validator.validate( 'a_field' => 'a string!' )
-		@validator.should_not have_errors()
-		@validator.should be_okay()
+		it "doesn't allow a constraint to be added twice" do
+			@validator.add( :a_field, :string )
+			expect {
+				@validator.add( :a_field, :string )
+			}.to raise_error( /parameter "a_field" is already defined/i )
+			@validator.param_names.should include( 'a_field' )
+		end
 
-		@validator.override( :a_field, :integer )
-		@validator.should have_errors()
-		@validator.should_not be_okay()
-		@validator.error_messages.should include( "Invalid value for 'A Field'" )
-	end
+		it "allows an existing constraint to be overridden" do
+			@validator.add( :a_field, :string )
+			@validator.override( :a_field, :integer )
+			@validator.param_names.should include( 'a_field' )
+			@validator.validate( 'a_field' => 'a string!' )
+			@validator.should have_errors()
+			@validator.should_not be_okay()
+			@validator.error_messages.should include( "Invalid value for 'A Field'" )
+		end
 
-	it "allows an existing constraint to be overridden" do
-		@validator.add( :a_field, :string )
-		@validator.override( :a_field, :integer )
-		@validator.param_names.should include( 'a_field' )
-		@validator.validate( 'a_field' => 'a string!' )
-		@validator.should have_errors()
-		@validator.should_not be_okay()
-		@validator.error_messages.should include( "Invalid value for 'A Field'" )
-	end
+		it "doesn't allow a non-existant constraint to be overridden" do
+			expect {
+				@validator.override( :a_field, :string )
+			}.to raise_error( /no parameter "a_field" defined/i )
+			@validator.param_names.should_not include( 'a_field' )
+		end
 
-	it "doesn't allow a non-existant parameter to be overridden" do
-		expect {
-			@validator.override( :a_field, :string )
-		}.to raise_error( /no parameter "a_field" defined/i )
-		@validator.param_names.should_not include( 'a_field' )
-	end
+		it "raises an exception on an unknown constraint type" do
+			expect {
+				@validator.add( :foo, $stderr )
+			}.to raise_error( /no builtin "foo" validator/ )
+		end
 
-	it "raises an exception on an unknown constraint type" do
-		expect {
-			@validator.add( :foo, $stderr )
-		}.to raise_error( /no builtin "foo" validator/ )
-	end
+		it "retains its profile through a copy" do
+			@validator.add( :foo, :string, :required )
+			dup = @validator.dup
+			@validator.validate( {} )
+			@validator.should_not be_okay()
+			@validator.should have_errors()
+			@validator.error_messages.should == ["Missing value for 'Foo'"]
+		end
 
-	it "retains its parameters through a copy" do
-		@validator.add( :foo, :string, :required )
-		dup = @validator.dup
-		@validator.validate( {} )
-		@validator.should_not be_okay()
-		@validator.should have_errors()
-		@validator.error_messages.should == ["Missing value for 'Foo'"]
-	end
+	end # describe "profile"
 
-	it "provides read and write access to valid args via the index operator" do
-		@validator.add( :foo, /^\d+$/ )
+	describe "validation" do
 
-		@validator.validate( {'foo' => "1"} )
-		@validator[:foo].should == "1"
+		it "provides read and write access to valid args via the index operator" do
+			@validator.add( :foo, /^\d+$/ )
 
-		@validator[:foo] = "bar"
-		@validator["foo"].should == "bar"
-	end
+			@validator.validate( {'foo' => "1"} )
+			@validator[:foo].should == "1"
 
+			@validator[:foo] = "bar"
+			@validator["foo"].should == "bar"
+		end
 
-	it "untaints valid args if told to do so" do
-		tainted_one = "1"
-		tainted_one.taint
+		it "untaints valid args if told to do so" do
+			tainted_one = "1"
+			tainted_one.taint
 
-		@validator.add( :number, /^\d+$/, :untaint )
-		@validator.validate( 'number' => tainted_one )
+			@validator.add( :number, /^\d+$/, :untaint )
+			@validator.validate( 'number' => tainted_one )
 
-		@validator[:number].should == "1"
-		@validator[:number].tainted?.should be_false()
-	end
+			@validator[:number].should == "1"
+			@validator[:number].tainted?.should be_false()
+		end
 
+		it "knows the names of fields that were required but missing from the parameters" do
+			@validator.add( :id, :integer, :required )
+			@validator.validate( {} )
 
-	it "returns the capture from a regexp constraint if it has only one" do
-		@validator.add( :treename, /(\w+)/ )
-		@validator.validate( 'treename' => "   ygdrassil   " )
-		@validator[:treename].should == 'ygdrassil'
-	end
+			@validator.should have_errors()
+			@validator.should_not be_okay()
 
-	it "returns the captures from a regexp constraint as an array if it has more than one" do
-		@validator.add( :stuff, /(\w+)(\S+)?/ )
-		@validator.validate( 'stuff' => "   the1tree(!)   " )
-		@validator[:stuff].should == ['the1tree', '(!)']
-	end
+			@validator.missing.should have(1).members
+			@validator.missing.should == ['id']
+		end
 
-	it "returns the captures from a regexp constraint with named captures as a Hash" do
-		@validator.add( :order_number, /(?<category>[[:upper:]]{3})-(?<sku>\d{12})/, :untaint )
-		@validator.validate( 'order_number' => "   JVV-886451300133   ".taint )
+		it "knows the names of fields that did not meet their constraints" do
+			@validator.add( :number, :integer, :required )
+			@validator.validate( 'number' => 'rhinoceros' )
 
-		@validator[:order_number].should == {:category => 'JVV', :sku => '886451300133'}
-		@validator[:order_number][:category].should_not be_tainted()
-		@validator[:order_number][:sku].should_not be_tainted()
-	end
+			@validator.should have_errors()
+			@validator.should_not be_okay()
 
-	it "returns the captures from a regexp constraint as an array " +
-		"even if an optional capture doesn't match anything" do
-		@validator.add( :amount, /^([\-+])?(\d+(?:\.\d+)?)/ )
-		@validator.validate( 'amount' => '2.28' )
+			@validator.invalid.should have(1).keys
+			@validator.invalid.keys.should == ['number']
+		end
 
-		@validator[:amount].should == [ nil, '2.28' ]
-	end
+		it "can return a combined list of missing and invalid fields" do
+			@validator.add( :number, :integer )
+			@validator.add( :id, /^(\w{20})$/, :required )
 
-	it "knows the names of fields that were required but missing from the parameters" do
-		@validator.add( :id, :integer, :required )
-		@validator.validate( {} )
+			@validator.validate( 'number' => 'rhinoceros' )
 
-		@validator.should have_errors()
-		@validator.should_not be_okay()
+			@validator.should have_errors()
+			@validator.should_not be_okay()
 
-		@validator.missing.should have(1).members
-		@validator.missing.should == ['id']
-	end
+			@validator.error_fields.should have(2).members
+			@validator.error_fields.should include('number')
+			@validator.error_fields.should include('id')
+		end
 
-	it "knows the names of fields that did not meet their constraints" do
-		@validator.add( :number, :integer, :required )
-		@validator.validate( 'number' => 'rhinoceros' )
+		it "allows valid parameters to be fetched en masse" do
+			@validator.add( :foom, /^\d+$/ )
+			@validator.add( :bewm, /^\d+$/ )
+			@validator.validate( 'foom' => "1", "bewm" => "2" )
+			@validator.values_at( :foom, :bewm ).should == [ '1', '2' ]
+		end
 
-		@validator.should have_errors()
-		@validator.should_not be_okay()
+		it "re-validates if profile is modified" do
+			@validator.add( :a_field, :string )
+			@validator.validate( 'a_field' => 'a string!' )
+			@validator.should_not have_errors()
+			@validator.should be_okay()
 
-		@validator.invalid.should have(1).keys
-		@validator.invalid.keys.should == ['number']
-	end
+			@validator.override( :a_field, :integer )
+			@validator.should have_errors()
+			@validator.should_not be_okay()
+			@validator.error_messages.should include( "Invalid value for 'A Field'" )
+		end
 
-	it "can return a combined list of all problem parameters, which includes " +
-		" both missing and invalid fields" do
-		@validator.add( :number, :integer )
-		@validator.add( :id, /^(\w{20})$/, :required )
+	end # describe "validation"
 
-		@validator.validate( 'number' => 'rhinoceros' )
+	describe "validation error descriptions" do
 
-		@validator.should have_errors()
-		@validator.should_not be_okay()
+		it "can return human descriptions of validation errors" do
+			@validator.add( :number, :integer )
+			@validator.add( :id, /^(\w{20})$/, :required )
+			@validator.validate( 'number' => 'rhinoceros', 'unknown' => "1" )
 
-		@validator.error_fields.should have(2).members
-		@validator.error_fields.should include('number')
-		@validator.error_fields.should include('id')
-	end
+			@validator.error_messages.should have(2).members
+			@validator.error_messages.should include("Missing value for 'Id'")
+			@validator.error_messages.should include("Invalid value for 'Number'")
+		end
 
-	it "can return human descriptions of validation errors" do
-		@validator.add( :number, :integer )
-		@validator.add( :id, /^(\w{20})$/, :required )
-		@validator.validate( 'number' => 'rhinoceros', 'unknown' => "1" )
+		it "can include unknown fields in its human descriptions of validation errors" do
+			@validator.add( :number, :integer )
+			@validator.add( :id, /^(\w{20})$/, :required )
+			@validator.validate( 'number' => 'rhinoceros', 'unknown' => "1" )
 
-		@validator.error_messages.should have(2).members
-		@validator.error_messages.should include("Missing value for 'Id'")
-		@validator.error_messages.should include("Invalid value for 'Number'")
-	end
+			@validator.error_messages(true).should have(3).members
+			@validator.error_messages(true).should include("Missing value for 'Id'")
+			@validator.error_messages(true).should include("Invalid value for 'Number'")
+			@validator.error_messages(true).should include("Unknown parameter 'Unknown'")
+		end
 
-	it "can include unknown fields in its human descriptions of validation errors" do
-		@validator.add( :number, :integer )
-		@validator.add( :id, /^(\w{20})$/, :required )
-		@validator.validate( 'number' => 'rhinoceros', 'unknown' => "1" )
+		it "can use descriptions of parameters when constructing human validation error messages" do
+			@validator.add( :number, :integer, "Numeral" )
+			@validator.add( :id, /^(\w{20})$/, "Test Name", :required )
+			@validator.validate( 'number' => 'rhinoceros', 'unknown' => "1" )
 
-		@validator.error_messages(true).should have(3).members
-		@validator.error_messages(true).should include("Missing value for 'Id'")
-		@validator.error_messages(true).should include("Invalid value for 'Number'")
-		@validator.error_messages(true).should include("Unknown parameter 'Unknown'")
-	end
+			@validator.error_messages.should have(2).members
+			@validator.error_messages.should include("Missing value for 'Test Name'")
+			@validator.error_messages.should include("Invalid value for 'Numeral'")
+		end
 
-	it "can use provided descriptions of parameters when constructing human " +
-		"validation error messages" do
-		@validator.add( :number, :integer, "Numeral" )
-		@validator.add( :id, /^(\w{20})$/, "Test Name", :required )
-		@validator.validate( 'number' => 'rhinoceros', 'unknown' => "1" )
+		it "can get and set the profile's descriptions directly" do
+			@validator.add( :number, :integer )
+			@validator.add( :id, /^(\w{20})$/, :required )
 
-		@validator.error_messages.should have(2).members
-		@validator.error_messages.should include("Missing value for 'Test Name'")
-		@validator.error_messages.should include("Invalid value for 'Numeral'")
-	end
+			@validator.descriptions = {
+				number: 'Numeral',
+				id:     'Test Name'
+			}
+			@validator.validate( 'number' => 'rhinoceros', 'unknown' => "1" )
 
-	it "can get and set the profile's descriptions directly" do
-		@validator.add( :number, :integer )
-		@validator.add( :id, /^(\w{20})$/, :required )
+			@validator.descriptions.should have( 2 ).members
+			@validator.error_messages.should have( 2 ).members
+			@validator.error_messages.should include("Missing value for 'Test Name'")
+			@validator.error_messages.should include("Invalid value for 'Numeral'")
+		end
 
-		@validator.descriptions = {
-			number: 'Numeral',
-			id:     'Test Name'
-		}
-		@validator.validate( 'number' => 'rhinoceros', 'unknown' => "1" )
+		it "capitalizes the names of simple fields for descriptions" do
+			@validator.get_description( "required" ).should == 'Required'
+		end
 
-		@validator.descriptions.should have( 2 ).members
-		@validator.error_messages.should have( 2 ).members
-		@validator.error_messages.should include("Missing value for 'Test Name'")
-		@validator.error_messages.should include("Invalid value for 'Numeral'")
-	end
+		it "splits apart underbarred field names into capitalized words for descriptions" do
+			@validator.get_description( "rodent_size" ).should == 'Rodent Size'
+		end
 
-	it "capitalizes the names of simple fields for descriptions" do
-		@validator.get_description( "required" ).should == 'Required'
-	end
+		it "uses the key for descriptions of hash fields" do
+			@validator.get_description( "rodent[size]" ).should == 'Size'
+		end
 
-	it "splits apart underbarred field names into capitalized words for descriptions" do
-		@validator.get_description( "rodent_size" ).should == 'Rodent Size'
-	end
+		it "uses separate capitalized words for descriptions of hash fields with underbarred keys " do
+			@validator.get_description( "castle[baron_id]" ).should == 'Baron Id'
+		end
 
-	it "uses the key for descriptions of hash fields" do
-		@validator.get_description( "rodent[size]" ).should == 'Size'
-	end
+	end # describe "validation error descriptions"
 
-	it "uses separate capitalized words for descriptions of hash fields with underbarred keys " do
-		@validator.get_description( "castle[baron_id]" ).should == 'Baron Id'
-	end
+	describe "hash parameters" do
 
-	it "coalesces simple hash fields into a hash of validated values" do
-		@validator.add( 'rodent[size]', :string )
-		@validator.validate( 'rodent[size]' => 'unusual' )
+		it "coalesces simple hash fields into a hash of validated values" do
+			@validator.add( 'rodent[size]', :string )
+			@validator.validate( 'rodent[size]' => 'unusual' )
 
-		@validator.valid.should == {'rodent' => {'size' => 'unusual'}}
-	end
+			@validator.valid.should == {'rodent' => {'size' => 'unusual'}}
+		end
+
+		it "coalesces complex hash fields into a nested hash of validated values" do
+			@validator.add( 'recipe[ingredient][name]', :string )
+			@validator.add( 'recipe[ingredient][cost]', :string )
+			@validator.add( 'recipe[yield]', :string )
 
-	it "coalesces complex hash fields into a nested hash of validated values" do
-		@validator.add( 'recipe[ingredient][name]', :string )
-		@validator.add( 'recipe[ingredient][cost]', :string )
-		@validator.add( 'recipe[yield]', :string )
-
-		args = {
-			'recipe[ingredient][name]' => 'nutmeg',
-			'recipe[ingredient][cost]' => '$0.18',
-			'recipe[yield]' => '2 loaves',
-		}
-		@validator.validate( args )
-
-		@validator.valid.should == {
-			'recipe' => {
-				'ingredient' => { 'name' => 'nutmeg', 'cost' => '$0.18' },
-				'yield' => '2 loaves'
+			args = {
+				'recipe[ingredient][name]' => 'nutmeg',
+				'recipe[ingredient][cost]' => '$0.18',
+				'recipe[yield]' => '2 loaves',
 			}
-		}
-	end
+			@validator.validate( args )
 
-	it "untaints both keys and values in complex hash fields if untainting is turned on" do
-		@validator.add( 'recipe[ingredient][rarity]', /^([\w\-]+)$/, :required )
-		@validator.add( 'recipe[ingredient][name]', :string )
-		@validator.add( 'recipe[ingredient][cost]', :string )
-		@validator.add( 'recipe[yield]', :string )
-		@validator.untaint_all_constraints
-
-		args = {
-			'recipe[ingredient][rarity]'.taint => 'super-rare'.taint,
-			'recipe[ingredient][name]'.taint => 'nutmeg'.taint,
-			'recipe[ingredient][cost]'.taint => '$0.18'.taint,
-			'recipe[yield]'.taint => '2 loaves'.taint,
-		}
-		@validator.validate( args )
-
-		@validator.valid.should == {
-			'recipe' => {
-				'ingredient' => { 'name' => 'nutmeg', 'cost' => '$0.18', 'rarity' => 'super-rare' },
-				'yield' => '2 loaves'
+			@validator.valid.should == {
+				'recipe' => {
+					'ingredient' => { 'name' => 'nutmeg', 'cost' => '$0.18' },
+					'yield' => '2 loaves'
+				}
 			}
-		}
-
-		@validator.valid.keys.all? {|key| key.should_not be_tainted() }
-		@validator.valid.values.all? {|key| key.should_not be_tainted() }
-		@validator.valid['recipe'].keys.all? {|key| key.should_not be_tainted() }
-		@validator.valid['recipe']['ingredient'].keys.all? {|key| key.should_not be_tainted() }
-		@validator.valid['recipe']['yield'].should_not be_tainted()
-		@validator.valid['recipe']['ingredient']['rarity'].should_not be_tainted()
-		@validator.valid['recipe']['ingredient']['name'].should_not be_tainted()
-		@validator.valid['recipe']['ingredient']['cost'].should_not be_tainted()
-	end
+		end
 
-	it "accepts the value 'true' for fields with boolean constraints" do
-		@validator.add( :enabled, :boolean )
-		@validator.validate( 'enabled' => 'true' )
+		it "untaints both keys and values in complex hash fields if untainting is turned on" do
+			@validator.add( 'recipe[ingredient][rarity]', /^([\w\-]+)$/, :required )
+			@validator.add( 'recipe[ingredient][name]', :string )
+			@validator.add( 'recipe[ingredient][cost]', :string )
+			@validator.add( 'recipe[yield]', :string )
+			@validator.untaint_all_constraints
+
+			args = {
+				'recipe[ingredient][rarity]'.taint => 'super-rare'.taint,
+				'recipe[ingredient][name]'.taint => 'nutmeg'.taint,
+				'recipe[ingredient][cost]'.taint => '$0.18'.taint,
+				'recipe[yield]'.taint => '2 loaves'.taint,
+			}
+			@validator.validate( args )
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+			@validator.valid.should == {
+				'recipe' => {
+					'ingredient' => { 'name' => 'nutmeg', 'cost' => '$0.18', 'rarity' => 'super-rare' },
+					'yield' => '2 loaves'
+				}
+			}
 
-		@validator[:enabled].should be_true()
-	end
+			@validator.valid.keys.all? {|key| key.should_not be_tainted() }
+			@validator.valid.values.all? {|key| key.should_not be_tainted() }
+			@validator.valid['recipe'].keys.all? {|key| key.should_not be_tainted() }
+			@validator.valid['recipe']['ingredient'].keys.all? {|key| key.should_not be_tainted() }
+			@validator.valid['recipe']['yield'].should_not be_tainted()
+			@validator.valid['recipe']['ingredient']['rarity'].should_not be_tainted()
+			@validator.valid['recipe']['ingredient']['name'].should_not be_tainted()
+			@validator.valid['recipe']['ingredient']['cost'].should_not be_tainted()
+		end
 
-	it "accepts the value 't' for fields with boolean constraints" do
-		@validator.add( :enabled, :boolean )
-		@validator.validate( 'enabled' => 't' )
+	end # describe "hash parameters"
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+	describe "constraints" do
 
-		@validator[:enabled].should be_true()
-	end
+		it "treats ArgumentErrors in builtin constraints as validation failures" do
+			@validator.add( :integer )
+			@validator.validate( 'integer' => 'jalopy' )
+			@validator.should_not be_okay()
+			@validator.should have_errors()
+			@validator[:integer].should be_nil()
+		end
 
-	it "accepts the value 'yes' for fields with boolean constraints" do
-		@validator.add( :enabled, :boolean )
-		@validator.validate( 'enabled' => 'yes' )
+		describe "Regexp constraints" do
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+			it "returns the capture from a regexp constraint if it has only one" do
+				@validator.add( :treename, /(\w+)/ )
+				@validator.validate( 'treename' => "   ygdrassil   " )
+				@validator[:treename].should == 'ygdrassil'
+			end
 
-		@validator[:enabled].should be_true()
-	end
+			it "returns the captures from a regexp constraint as an array if it has more than one" do
+				@validator.add( :stuff, /(\w+)(\S+)?/ )
+				@validator.validate( 'stuff' => "   the1tree(!)   " )
+				@validator[:stuff].should == ['the1tree', '(!)']
+			end
 
-	it "accepts the value 'y' for fields with boolean constraints" do
-		@validator.add( :enabled, :boolean )
-		@validator.validate( 'enabled' => 'y' )
+			it "returns the captures from a regexp constraint with named captures as a Hash" do
+				@validator.add( :order_number, /(?<category>[[:upper:]]{3})-(?<sku>\d{12})/, :untaint )
+				@validator.validate( 'order_number' => "   JVV-886451300133   ".taint )
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+				@validator[:order_number].should == {:category => 'JVV', :sku => '886451300133'}
+				@validator[:order_number][:category].should_not be_tainted()
+				@validator[:order_number][:sku].should_not be_tainted()
+			end
 
-		@validator[:enabled].should be_true()
-	end
+			it "returns the captures from a regexp constraint as an array " +
+				"even if an optional capture doesn't match anything" do
+				@validator.add( :amount, /^([\-+])?(\d+(?:\.\d+)?)/ )
+				@validator.validate( 'amount' => '2.28' )
 
-	it "accepts the value '1' for fields with boolean constraints" do
-		@validator.add( :enabled, :boolean )
-		@validator.validate( 'enabled' => '1' )
+				@validator[:amount].should == [ nil, '2.28' ]
+			end
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+		end
 
-		@validator[:enabled].should be_true()
-	end
+		describe ":boolean constraints" do
 
-	it "accepts the value 'false' for fields with boolean constraints" do
-		@validator.add( :enabled, :boolean )
-		@validator.validate( 'enabled' => 'false' )
+			before( :each ) do
+				@validator.add( :enabled, :boolean )
+			end
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+			it "accepts the value 'true' for fields with boolean constraints" do
+				@validator.validate( 'enabled' => 'true' )
 
-		@validator[:enabled].should be_false()
-	end
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-	it "accepts the value 'f' for fields with boolean constraints" do
-		@validator.add( :enabled, :boolean )
-		@validator.validate( 'enabled' => 'f' )
+				@validator[:enabled].should be_true()
+			end
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+			it "accepts the value 't' for fields with boolean constraints" do
+				@validator.validate( 'enabled' => 't' )
 
-		@validator[:enabled].should be_false()
-	end
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-	it "accepts the value 'no' for fields with boolean constraints" do
-		@validator.add( :enabled, :boolean )
-		@validator.validate( 'enabled' => 'no' )
+				@validator[:enabled].should be_true()
+			end
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+			it "accepts the value 'yes' for fields with boolean constraints" do
+				@validator.validate( 'enabled' => 'yes' )
 
-		@validator[:enabled].should be_false()
-	end
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-	it "accepts the value 'n' for fields with boolean constraints" do
-		@validator.add( :enabled, :boolean )
-		@validator.validate( 'enabled' => 'n' )
+				@validator[:enabled].should be_true()
+			end
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+			it "accepts the value 'y' for fields with boolean constraints" do
+				@validator.validate( 'enabled' => 'y' )
 
-		@validator[:enabled].should be_false()
-	end
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-	it "accepts the value '0' for fields with boolean constraints" do
-		@validator.add( :enabled, :boolean )
-		@validator.validate( 'enabled' => '0' )
+				@validator[:enabled].should be_true()
+			end
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+			it "accepts the value '1' for fields with boolean constraints" do
+				@validator.validate( 'enabled' => '1' )
 
-		@validator[:enabled].should be_false()
-	end
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-	it "rejects non-boolean parameters for fields with boolean constraints" do
-		@validator.add( :enabled, :boolean )
-		@validator.validate( 'enabled' => 'peanut' )
+				@validator[:enabled].should be_true()
+			end
 
-		@validator.should_not be_okay()
-		@validator.should have_errors()
+			it "accepts the value 'false' for fields with boolean constraints" do
+				@validator.validate( 'enabled' => 'false' )
 
-		@validator[:enabled].should be_nil()
-	end
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-	it "accepts simple integers for fields with integer constraints" do
-		@validator.add( :count, :integer )
-		@validator.validate( 'count' => '11' )
+				@validator[:enabled].should be_false()
+			end
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+			it "accepts the value 'f' for fields with boolean constraints" do
+				@validator.validate( 'enabled' => 'f' )
 
-		@validator[:count].should == 11
-	end
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-	it "accepts '0' for fields with integer constraints" do
-		@validator.add( :count, :integer )
-		@validator.validate( 'count' => '0' )
+				@validator[:enabled].should be_false()
+			end
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+			it "accepts the value 'no' for fields with boolean constraints" do
+				@validator.validate( 'enabled' => 'no' )
 
-		@validator[:count].should == 0
-	end
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-	it "accepts negative integers for fields with integer constraints" do
-		@validator.add( :count, :integer )
-		@validator.validate( 'count' => '-407' )
+				@validator[:enabled].should be_false()
+			end
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+			it "accepts the value 'n' for fields with boolean constraints" do
+				@validator.validate( 'enabled' => 'n' )
 
-		@validator[:count].should == -407
-	end
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-	it "rejects non-integers for fields with integer constraints" do
-		@validator.add( :count, :integer )
-		@validator.validate( 'count' => '11.1' )
+				@validator[:enabled].should be_false()
+			end
 
-		@validator.should_not be_okay()
-		@validator.should have_errors()
+			it "accepts the value '0' for fields with boolean constraints" do
+				@validator.validate( 'enabled' => '0' )
 
-		@validator[:count].should be_nil()
-	end
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-	it "rejects integer values with other cruft in them for fields with integer constraints" do
-		@validator.add( :count, :integer )
-		@validator.validate( 'count' => '88licks' )
+				@validator[:enabled].should be_false()
+			end
 
-		@validator.should_not be_okay()
-		@validator.should have_errors()
+			it "rejects non-boolean parameters for fields with boolean constraints" do
+				@validator.validate( 'enabled' => 'peanut' )
 
-		@validator[:count].should be_nil()
-	end
+				@validator.should_not be_okay()
+				@validator.should have_errors()
 
-	it "accepts simple floats for fields with float constraints" do
-		@validator.add( :amount, :float )
-		@validator.validate( 'amount' => '3.14' )
+				@validator[:enabled].should be_nil()
+			end
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+		end
 
-		@validator[:amount].should == 3.14
-	end
+		describe ":integer constraints" do
 
-	it "accepts negative floats for fields with float constraints" do
-		@validator.add( :amount, :float )
-		@validator.validate( 'amount' => '-3.14' )
+			it "accepts simple integers for fields with integer constraints" do
+				@validator.add( :count, :integer )
+				@validator.validate( 'count' => '11' )
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-		@validator[:amount].should == -3.14
-	end
+				@validator[:count].should == 11
+			end
 
-	it "accepts positive floats for fields with float constraints" do
-		@validator.add( :amount, :float )
-		@validator.validate( 'amount' => '+3.14' )
+			it "accepts '0' for fields with integer constraints" do
+				@validator.add( :count, :integer )
+				@validator.validate( 'count' => '0' )
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-		@validator[:amount].should == 3.14
-	end
+				@validator[:count].should == 0
+			end
 
-	it "accepts floats that begin with '.' for fields with float constraints" do
-		@validator.add( :amount, :float )
-		@validator.validate( 'amount' => '.1418' )
+			it "accepts negative integers for fields with integer constraints" do
+				@validator.add( :count, :integer )
+				@validator.validate( 'count' => '-407' )
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-		@validator[:amount].should == 0.1418
-	end
+				@validator[:count].should == -407
+			end
 
-	it "accepts negative floats that begin with '.' for fields with float constraints" do
-		@validator.add( :amount, :float )
-		@validator.validate( 'amount' => '-.171' )
+			it "rejects non-integers for fields with integer constraints" do
+				@validator.add( :count, :integer )
+				@validator.validate( 'count' => '11.1' )
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+				@validator.should_not be_okay()
+				@validator.should have_errors()
 
-		@validator[:amount].should == -0.171
-	end
+				@validator[:count].should be_nil()
+			end
 
-	it "accepts positive floats that begin with '.' for fields with float constraints" do
-		@validator.add( :amount, :float )
-		@validator.validate( 'amount' => '+.86668001' )
+			it "rejects integer values with other cruft in them for fields with integer constraints" do
+				@validator.add( :count, :integer )
+				@validator.validate( 'count' => '88licks' )
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+				@validator.should_not be_okay()
+				@validator.should have_errors()
 
-		@validator[:amount].should == 0.86668001
-	end
+				@validator[:count].should be_nil()
+			end
 
-	it "accepts floats in exponential notation for fields with float constraints" do
-		@validator.add( :amount, :float )
-		@validator.validate( 'amount' => '1756e-5' )
+		end
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+		describe ":float constraints" do
 
-		@validator[:amount].should == 1756e-5
-	end
+			before( :each ) do
+				@validator.add( :amount, :float )
+			end
 
-	it "accepts negative floats in exponential notation for fields with float constraints" do
-		@validator.add( :amount, :float )
-		@validator.validate( 'amount' => '-28e8' )
+			it "accepts simple floats for fields with float constraints" do
+				@validator.validate( 'amount' => '3.14' )
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-		@validator[:amount].should == -28e8
-	end
+				@validator[:amount].should == 3.14
+			end
 
-	it "accepts floats that start with '.' in exponential notation for fields with float " +
-	   "constraints" do
-		@validator.add( :amount, :float )
-		@validator.validate( 'amount' => '.5552e-10' )
+			it "accepts negative floats for fields with float constraints" do
+				@validator.validate( 'amount' => '-3.14' )
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-		@validator[:amount].should == 0.5552e-10
-	end
+				@validator[:amount].should == -3.14
+			end
 
-	it "accepts negative floats that start with '.' in exponential notation for fields with " +
-	   "float constraints" do
-	   @validator.add( :amount, :float )
-	   @validator.validate( 'amount' => '-.288088e18' )
+			it "accepts positive floats for fields with float constraints" do
+				@validator.validate( 'amount' => '+3.14' )
 
-	   @validator.should be_okay()
-	   @validator.should_not have_errors()
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-	   @validator[:amount].should == -0.288088e18
-	end
+				@validator[:amount].should == 3.14
+			end
 
-	it "accepts integers for fields with float constraints" do
-		@validator.add( :amount, :float )
-		@validator.validate( 'amount' => '288' )
+			it "accepts floats that begin with '.' for fields with float constraints" do
+				@validator.validate( 'amount' => '.1418' )
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-		@validator[:amount].should == 288.0
-	end
+				@validator[:amount].should == 0.1418
+			end
 
-	it "accepts negative integers for fields with float constraints" do
-		@validator.add( :amount, :float )
-		@validator.validate( 'amount' => '-1606' )
+			it "accepts negative floats that begin with '.' for fields with float constraints" do
+				@validator.validate( 'amount' => '-.171' )
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-		@validator[:amount].should == -1606.0
-	end
+				@validator[:amount].should == -0.171
+			end
 
-	it "accepts positive integers for fields with float constraints" do
-		@validator.add( :amount, :float )
-		@validator.validate( 'amount' => '2600' )
+			it "accepts positive floats that begin with '.' for fields with float constraints" do
+				@validator.validate( 'amount' => '+.86668001' )
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-		@validator[:amount].should == 2600.0
-	end
+				@validator[:amount].should == 0.86668001
+			end
 
+			it "accepts floats in exponential notation for fields with float constraints" do
+				@validator.validate( 'amount' => '1756e-5' )
 
-	it "accepts dates for fields with date constraints" do
-		@validator.add( :expires, :date )
-		@validator.validate( 'expires' => '2008-11-18' )
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+				@validator[:amount].should == 1756e-5
+			end
 
-		@validator[:expires].should == Date.parse( '2008-11-18' )
-	end
+			it "accepts negative floats in exponential notation for fields with float constraints" do
+				@validator.validate( 'amount' => '-28e8' )
 
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-	VALID_URIS = %w{
-		http://127.0.0.1
-		http://127.0.0.1/
-		http://[127.0.0.1]/
-		http://ruby-lang.org/
-		http://www.rocketboom.com/vlog/rb_08_feb_01
-		http://del.icio.us/search/?fr=del_icio_us&p=ruby+arrow&type=all
-		http://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]:8080/index.html
-		http://[1080:0:0:0:8:800:200C:417A]/index.html
-		http://[3ffe:2a00:100:7031::1]
-		http://[1080::8:800:200C:417A]/foo
-		http://[::192.9.5.5]/ipng
-		http://[::FFFF:129.144.52.38]:3474/index.html
-		http://[2010:836B:4179::836B:4179]
-
-		https://mail.google.com/
-		https://127.0.0.1/
-		https://r4.com:8080/
-
-		ftp://ftp.ruby-lang.org/pub/ruby/1.0/ruby-0.49.tar.gz
-		ftp://crashoverride:god@gibson.ellingsonmineral.com/root/.workspace/.garbage.
-
-		ldap:/o=University%20of%20Michigan,c=US
-		ldap://ldap.itd.umich.edu/o=University%20of%20Michigan,c=US
-		ldap://ldap.itd.umich.edu/o=University%20of%20Michigan,c=US?postalAddress
-		ldap://host.com:6666/o=University%20of%20Michigan,c=US??sub?(cn=Babs%20Jensen)
-		ldap://ldap.itd.umich.edu/c=GB?objectClass?one
-		ldap://ldap.question.com/o=Question%3f,c=US?mail
-		ldap://ldap.netscape.com/o=Babsco,c=US??(int=%5c00%5c00%5c00%5c04)
-		ldap:/??sub??bindname=cn=Manager%2co=Foo
-		ldap:/??sub??!bindname=cn=Manager%2co=Foo
-	  }
-
-	VALID_URIS.each do |uri_string|
-		it "accepts #{uri_string} for fields with URI constraints" do
-			@validator.add( :homepage, :uri )
-			@validator.validate( 'homepage' => uri_string )
+				@validator[:amount].should == -28e8
+			end
 
-			@validator.should be_okay()
-			@validator.should_not have_errors()
+			it "accepts floats that start with '.' in exponential notation for fields with float " +
+			   "constraints" do
+				@validator.validate( 'amount' => '.5552e-10' )
+
+				@validator.should be_okay()
+				@validator.should_not have_errors()
+
+				@validator[:amount].should == 0.5552e-10
+			end
+
+			it "accepts negative floats that start with '.' in exponential notation for fields with " +
+			   "float constraints" do
+			   @validator.validate( 'amount' => '-.288088e18' )
+
+			   @validator.should be_okay()
+			   @validator.should_not have_errors()
+
+			   @validator[:amount].should == -0.288088e18
+			end
+
+			it "accepts integers for fields with float constraints" do
+				@validator.validate( 'amount' => '288' )
+
+				@validator.should be_okay()
+				@validator.should_not have_errors()
+
+				@validator[:amount].should == 288.0
+			end
+
+			it "accepts negative integers for fields with float constraints" do
+				@validator.validate( 'amount' => '-1606' )
+
+				@validator.should be_okay()
+				@validator.should_not have_errors()
+
+				@validator[:amount].should == -1606.0
+			end
+
+			it "accepts positive integers for fields with float constraints" do
+				@validator.validate( 'amount' => '2600' )
+
+				@validator.should be_okay()
+				@validator.should_not have_errors()
+
+				@validator[:amount].should == 2600.0
+			end
 
-			@validator[:homepage].should be_a_kind_of( URI::Generic )
-			@validator[:homepage].to_s.should == uri_string
 		end
-	end
 
-	# :FIXME: I don't know LDAP uris very well, so I'm not sure how they're likely to
-	# be invalidly-occurring in the wild
-	INVALID_URIS = %W{
-		glark:
-
-		http:
-		http://
-		http://_com/vlog/rb_08_feb_01
-		http://del.icio.us/search/\x20\x14\x18
-		http://FEDC:BA98:7654:3210:FEDC:BA98:7654:3210/index.html
-		http://1080:0:0:0:8:800:200C:417A/index.html
-		http://3ffe:2a00:100:7031::1
-		http://1080::8:800:200C:417A/foo
-		http://::192.9.5.5/ipng
-		http://::FFFF:129.144.52.38:80/index.html
-		http://2010:836B:4179::836B:4179
-
-		https:
-		https://user:pass@/
-		https://r4.com:nonnumericport/
-
-		ftp:
-		ftp:ruby-0.49.tar.gz
-		ftp://crashoverride:god@/root/.workspace/.garbage.
-
-		ldap:
-		ldap:/o=University\x20of\x20Michigan,c=US
-		ldap://ldap.itd.umich.edu/o=University+\x00of+Michigan
-	  }
-
-	INVALID_URIS.each do |uri_string|
-		it "rejects #{uri_string} for fields with URI constraints" do
-			@validator.add( :homepage, :uri )
-			@validator.validate( 'homepage' => uri_string )
+		describe ":date constaints" do
 
-			@validator.should_not be_okay()
-			@validator.should have_errors()
+			before( :each ) do
+				@validator.add( :expires, :date )
+			end
+
+			it "accepts dates for fields with date constraints" do
+				@validator.validate( 'expires' => '2008-11-18' )
+
+				@validator.should be_okay()
+				@validator.should_not have_errors()
+
+				@validator[:expires].should == Date.parse( '2008-11-18' )
+			end
+
+			it "rejects non-dates for fields with date constraints" do
+				@validator.validate( 'expires' => 'Mexico' )
+
+				@validator.should_not be_okay()
+				@validator.should have_errors()
+
+				@validator[:expires].should be_nil()
+			end
 
-			@validator[:homepage].should be_nil()
 		end
-	end
 
-	it "accepts simple RFC822 addresses for fields with email constraints" do
-		@validator.add( :email )
-		@validator.validate( 'email' => 'jrandom@hacker.ie' )
+		describe ":uri constraints" do
+			VALID_URIS = %w{
+				http://127.0.0.1
+				http://127.0.0.1/
+				http://[127.0.0.1]/
+				http://ruby-lang.org/
+				http://www.rocketboom.com/vlog/rb_08_feb_01
+				http://del.icio.us/search/?fr=del_icio_us&p=ruby+arrow&type=all
+				http://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]:8080/index.html
+				http://[1080:0:0:0:8:800:200C:417A]/index.html
+				http://[3ffe:2a00:100:7031::1]
+				http://[1080::8:800:200C:417A]/foo
+				http://[::192.9.5.5]/ipng
+				http://[::FFFF:129.144.52.38]:3474/index.html
+				http://[2010:836B:4179::836B:4179]
+
+				https://mail.google.com/
+				https://127.0.0.1/
+				https://r4.com:8080/
+
+				ftp://ftp.ruby-lang.org/pub/ruby/1.0/ruby-0.49.tar.gz
+				ftp://crashoverride:god@gibson.ellingsonmineral.com/root/.workspace/.garbage.
+
+				ldap:/o=University%20of%20Michigan,c=US
+				ldap://ldap.itd.umich.edu/o=University%20of%20Michigan,c=US
+				ldap://ldap.itd.umich.edu/o=University%20of%20Michigan,c=US?postalAddress
+				ldap://host.com:6666/o=University%20of%20Michigan,c=US??sub?(cn=Babs%20Jensen)
+				ldap://ldap.itd.umich.edu/c=GB?objectClass?one
+				ldap://ldap.question.com/o=Question%3f,c=US?mail
+				ldap://ldap.netscape.com/o=Babsco,c=US??(int=%5c00%5c00%5c00%5c04)
+				ldap:/??sub??bindname=cn=Manager%2co=Foo
+				ldap:/??sub??!bindname=cn=Manager%2co=Foo
+			}
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+			INVALID_URIS = %W{
+				glark:
+
+				http:
+				http://
+				http://_com/vlog/rb_08_feb_01
+				http://del.icio.us/search/\x20\x14\x18
+				http://FEDC:BA98:7654:3210:FEDC:BA98:7654:3210/index.html
+				http://1080:0:0:0:8:800:200C:417A/index.html
+				http://3ffe:2a00:100:7031::1
+				http://1080::8:800:200C:417A/foo
+				http://::192.9.5.5/ipng
+				http://::FFFF:129.144.52.38:80/index.html
+				http://2010:836B:4179::836B:4179
+
+				https:
+				https://user:pass@/
+				https://r4.com:nonnumericport/
+
+				ftp:
+				ftp:ruby-0.49.tar.gz
+				ftp://crashoverride:god@/root/.workspace/.garbage.
+
+				ldap:
+				ldap:/o=University\x20of\x20Michigan,c=US
+				ldap://ldap.itd.umich.edu/o=University+\x00of+Michigan
+			}
 
-		@validator[:email].should == 'jrandom@hacker.ie'
-	end
+			before( :each ) do
+				@validator.add( :homepage, :uri )
+			end
 
-	it "accepts hyphenated domains in RFC822 addresses for fields with email constraints" do
-		@validator.add( :email )
-		@validator.validate( 'email' => 'jrandom@just-another-hacquer.fr' )
+			VALID_URIS.each do |uri_string|
+				it "accepts #{uri_string} for fields with URI constraints" do
+					@validator.validate( 'homepage' => uri_string )
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+					@validator.should be_okay()
+					@validator.should_not have_errors()
 
-		@validator[:email].should == 'jrandom@just-another-hacquer.fr'
-	end
+					@validator[:homepage].should be_a_kind_of( URI::Generic )
+					@validator[:homepage].to_s.should == uri_string
+				end
+			end
 
-	COMPLEX_ADDRESSES = [
-		'ruby+hacker@random-example.org',
-		'"ruby hacker"@ph8675309.org',
-		'jrandom@[ruby hacquer].com',
-		'abcdefghijklmnopqrstuvwxyz@abcdefghijklmnopqrstuvwxyz',
-	]
-	COMPLEX_ADDRESSES.each do |addy|
-		it "accepts #{addy} for fields with email constraints" do
-			@validator.add( :mail, :email )
-			@validator.validate( 'mail' => addy )
+			INVALID_URIS.each do |uri_string|
+				it "rejects #{uri_string} for fields with URI constraints" do
+					@validator.validate( 'homepage' => uri_string )
 
-			@validator.should be_okay()
-			@validator.should_not have_errors()
+					@validator.should_not be_okay()
+					@validator.should have_errors()
+
+					@validator[:homepage].should be_nil()
+				end
+			end
 
-			@validator[:mail].should == addy
 		end
-	end
 
+		describe ":email constraints" do
 
-	BOGUS_ADDRESSES = [
-		'jrandom@hacquer com',
-		'jrandom@ruby hacquer.com',
-		'j random@rubyhacquer.com',
-		'j random@ruby|hacquer.com',
-		'j:random@rubyhacquer.com',
-	]
-	BOGUS_ADDRESSES.each do |addy|
-		it "rejects #{addy} for fields with email constraints" do
-			@validator.add( :mail, :email )
-			@validator.validate( 'mail' => addy )
+			COMPLEX_ADDRESSES = [
+				'ruby+hacker@random-example.org',
+				'"ruby hacker"@ph8675309.org',
+				'jrandom@[ruby hacquer].com',
+				'abcdefghijklmnopqrstuvwxyz@abcdefghijklmnopqrstuvwxyz',
+			]
+			BOGUS_ADDRESSES = [
+				'jrandom@hacquer com',
+				'jrandom@ruby hacquer.com',
+				'j random@rubyhacquer.com',
+				'j random@ruby|hacquer.com',
+				'j:random@rubyhacquer.com',
+			]
 
-			@validator.should_not be_okay()
-			@validator.should have_errors()
+			it "accepts simple RFC822 addresses for fields with email constraints" do
+				@validator.add( :email )
+				@validator.validate( 'email' => 'jrandom@hacker.ie' )
+
+				@validator.should be_okay()
+				@validator.should_not have_errors()
+
+				@validator[:email].should == 'jrandom@hacker.ie'
+			end
+
+			it "accepts hyphenated domains in RFC822 addresses for fields with email constraints" do
+				@validator.add( :email )
+				@validator.validate( 'email' => 'jrandom@just-another-hacquer.fr' )
+
+				@validator.should be_okay()
+				@validator.should_not have_errors()
+
+				@validator[:email].should == 'jrandom@just-another-hacquer.fr'
+			end
+
+			COMPLEX_ADDRESSES.each do |addy|
+				it "accepts #{addy} for fields with email constraints" do
+					@validator.add( :mail, :email )
+					@validator.validate( 'mail' => addy )
+
+					@validator.should be_okay()
+					@validator.should_not have_errors()
+
+					@validator[:mail].should == addy
+				end
+			end
+
+			BOGUS_ADDRESSES.each do |addy|
+				it "rejects #{addy} for fields with email constraints" do
+					@validator.add( :mail, :email )
+					@validator.validate( 'mail' => addy )
+
+					@validator.should_not be_okay()
+					@validator.should have_errors()
+
+					@validator[:mail].should be_nil()
+				end
+			end
 
-			@validator[:mail].should be_nil()
 		end
-	end
 
-	it "accepts simple hosts for fields with host constraints" do
-		@validator.add( :host, :hostname )
-		@validator.validate( 'host' => 'deveiate.org' )
+		describe ":hostname constraints" do
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+			BOGUS_HOSTS = [
+				'.',
+				'glah ',
+				'glah[lock]',
+				'glah.be$',
+				'indus«tree».com',
+			]
 
-		@validator[:host].should == 'deveiate.org'
-	end
+			it "accepts simple hostnames for fields with hostname constraints" do
+				@validator.add( :host, :hostname )
+				@validator.validate( 'host' => 'deveiate.org' )
 
-	it "accepts hyphenated hosts for fields with host constraints" do
-		@validator.add( :hostname )
-		@validator.validate( 'hostname' => 'your-characters-can-fly.kr' )
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+				@validator[:host].should == 'deveiate.org'
+			end
 
-		@validator[:hostname].should == 'your-characters-can-fly.kr'
-	end
+			it "accepts hyphenated hostnames for fields with hostname constraints" do
+				@validator.add( :hostname )
+				@validator.validate( 'hostname' => 'your-characters-can-fly.kr' )
 
-	BOGUS_HOSTS = [
-		'.',
-		'glah ',
-		'glah[lock]',
-		'glah.be$',
-		'indus«tree».com',
-	]
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-	BOGUS_HOSTS.each do |hostname|
-		it "rejects #{hostname} for fields with host constraints" do
-			@validator.add( :hostname )
-			@validator.validate( 'hostname' => hostname )
+				@validator[:hostname].should == 'your-characters-can-fly.kr'
+			end
 
-			@validator.should_not be_okay()
-			@validator.should have_errors()
+			BOGUS_HOSTS.each do |hostname|
+				it "rejects #{hostname} for fields with :hostname constraints" do
+					@validator.add( :hostname )
+					@validator.validate( 'hostname' => hostname )
+
+					@validator.should_not be_okay()
+					@validator.should have_errors()
+
+					@validator[:hostname].should be_nil()
+				end
+			end
 
-			@validator[:hostname].should be_nil()
 		end
-	end
 
-	it "accepts alpha characters for fields with alpha constraints" do
-		@validator.add( :alpha )
-		@validator.validate( 'alpha' => 'abelincoln' )
+		describe ":alpha constraints" do
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+			it "accepts alpha characters for fields with alpha constraints" do
+				@validator.add( :alpha )
+				@validator.validate( 'alpha' => 'abelincoln' )
 
-		@validator[:alpha].should == 'abelincoln'
-	end
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-	it "rejects non-alpha characters for fields with alpha constraints" do
-		@validator.add( :alpha )
-		@validator.validate( 'alpha' => 'duck45' )
+				@validator[:alpha].should == 'abelincoln'
+			end
 
-		@validator.should_not be_okay()
-		@validator.should have_errors()
+			it "rejects non-alpha characters for fields with alpha constraints" do
+				@validator.add( :alpha )
+				@validator.validate( 'alpha' => 'duck45' )
 
-		@validator[:alpha].should be_nil()
-	end
+				@validator.should_not be_okay()
+				@validator.should have_errors()
 
-	### 'alphanumeric'
-	it "accepts alphanumeric characters for fields with alphanumeric constraints" do
-		@validator.add( :username, :alphanumeric )
-		@validator.validate( 'username' => 'zombieabe11' )
+				@validator[:alpha].should be_nil()
+			end
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+		end
 
-		@validator[:username].should == 'zombieabe11'
-	end
+		describe ":alphanumeric constraints" do
 
-	it "rejects non-alphanumeric characters for fields with alphanumeric constraints" do
-		@validator.add( :username, :alphanumeric )
-		@validator.validate( 'username' => 'duck!ling' )
+			it "accepts alphanumeric characters for fields with alphanumeric constraints" do
+				@validator.add( :username, :alphanumeric )
+				@validator.validate( 'username' => 'zombieabe11' )
 
-		@validator.should_not be_okay()
-		@validator.should have_errors()
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-		@validator[:username].should be_nil()
-	end
+				@validator[:username].should == 'zombieabe11'
+			end
 
-	### 'printable'
-	it "accepts printable characters for fields with 'printable' constraints" do
-		test_content = <<-EOF
-		I saw you with some kind of medical apparatus strapped to your
-        spine. It was all glass and metal, a great crystaline hypodermic
-        spider, carrying you into the aether with a humming, crackling sound.
-		EOF
+			it "rejects non-alphanumeric characters for fields with alphanumeric constraints" do
+				@validator.add( :username, :alphanumeric )
+				@validator.validate( 'username' => 'duck!ling' )
 
-		@validator.add( :prologue, :printable )
-		@validator.validate( 'prologue' => test_content )
+				@validator.should_not be_okay()
+				@validator.should have_errors()
 
-		@validator.should be_okay()
-		@validator[:prologue].should == test_content
-	end
+				@validator[:username].should be_nil()
+			end
 
-	it "rejects non-printable characters for fields with 'printable' constraints" do
-		@validator.add( :prologue, :printable )
-		@validator.validate( 'prologue' => %{\0Something cold\0} )
+		end
 
-		@validator.should_not be_okay()
-		@validator.should have_errors()
+		describe ":printable constraints" do
 
-		@validator[:prologue].should be_nil()
-	end
+			it "accepts printable characters for fields with 'printable' constraints" do
+				test_content = <<-EOF
+				I saw you with some kind of medical apparatus strapped to your
+		        spine. It was all glass and metal, a great crystaline hypodermic
+		        spider, carrying you into the aether with a humming, crackling sound.
+				EOF
 
+				@validator.add( :prologue, :printable )
+				@validator.validate( 'prologue' => test_content )
 
-	it "accepts any word characters for fields with 'word' constraints" do
-		@validator.add( :vocab_word, :word )
-		@validator.validate( 'vocab_word' => "Собака" )
+				@validator.should be_okay()
+				@validator[:prologue].should == test_content
+			end
 
-		@validator.should_not have_errors()
-		@validator.should be_okay()
+			it "rejects non-printable characters for fields with 'printable' constraints" do
+				@validator.add( :prologue, :printable )
+				@validator.validate( 'prologue' => %{\0Something cold\0} )
 
-		@validator[:vocab_word].should == "Собака"
-	end
+				@validator.should_not be_okay()
+				@validator.should have_errors()
 
-	it "accepts parameters for fields with Proc constraints if the Proc returns a true value" do
-		test_date = '2007-07-17'
+				@validator[:prologue].should be_nil()
+			end
 
-		@validator.add( :creation_date ) do |input|
-			Date.parse( input )
 		end
-		@validator.validate( 'creation_date' => test_date )
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+		describe ":word constraints" do
 
-		@validator[:creation_date].should == Date.parse( test_date )
-	end
+			it "accepts any word characters for fields with 'word' constraints" do
+				@validator.add( :vocab_word, :word )
+				@validator.validate( 'vocab_word' => "Собака" )
+
+				@validator.should_not have_errors()
+				@validator.should be_okay()
+
+				@validator[:vocab_word].should == "Собака"
+			end
+
+			it "rejects non-word characters for fields with 'word' constraints" do
+				@validator.add( :vocab_word, :word )
+				@validator.validate( 'vocab_word' => "Собака!" )
+
+				@validator.should have_errors()
+				@validator.should_not be_okay()
+
+				@validator[:vocab_word].should be_nil()
+			end
 
-	it "rejects parameters for fields with Proc constraints if the Proc returns a false value" do
-		@validator.add( :creation_date ) do |input|
-			Date.parse( input )
 		end
-		@validator.validate( 'creation_date' => '::::' )
 
-		@validator.should_not be_okay()
-		@validator.should have_errors()
+		describe "Proc constraints" do
 
-		@validator[:creation_date].should be_nil()
-	end
+			it "accepts parameters for fields with Proc constraints if the Proc returns a true value" do
+				test_date = '2007-07-17'
 
-	it "can be merged with another set of parameters" do
-		@validator.add( :foo, :integer, :required )
-		@validator.validate( {} )
-		newval = @validator.merge( 'foo' => '1' )
+				@validator.add( :creation_date ) do |input|
+					Date.parse( input )
+				end
+				@validator.validate( 'creation_date' => test_date )
 
-		newval.should_not equal( @validator )
+				@validator.should be_okay()
+				@validator.should_not have_errors()
 
-		@validator.should_not be_okay()
-		@validator.should have_errors()
-		newval.should be_okay()
-		newval.should_not have_errors()
+				@validator[:creation_date].should == Date.parse( test_date )
+			end
 
-		@validator[:foo].should == nil
-		newval[:foo].should == 1
-	end
+			it "rejects parameters for fields with Proc constraints if the Proc returns a false value" do
+				@validator.add( :creation_date ) do |input|
+					Date.parse( input )
+				end
+				@validator.validate( 'creation_date' => '::::' )
 
-	it "can have required parameters merged into it after the initial validation" do
-		@validator.add( :foo, :integer, :required )
-		@validator.validate( {} )
-		@validator.merge!( 'foo' => '1' )
+				@validator.should_not be_okay()
+				@validator.should have_errors()
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+				@validator[:creation_date].should be_nil()
+			end
 
-		@validator[:foo].should == 1
-	end
+		end
 
-	it "can have optional parameters merged into it after the initial validation" do
-		@validator.add( :foom, /^\d+$/ )
-		@validator.validate( {} )
-		@validator.merge!( 'foom' => '5' )
+		describe "merging new parameters" do
 
-		@validator.should be_okay()
-		@validator.should_not have_errors()
+			it "can be merged with another set of parameters" do
+				@validator.add( :foo, :integer, :required )
+				@validator.validate( {} )
+				newval = @validator.merge( 'foo' => '1' )
 
-		@validator[:foom].should == '5'
-	end
+				newval.should_not equal( @validator )
+
+				@validator.should_not be_okay()
+				@validator.should have_errors()
+				newval.should be_okay()
+				newval.should_not have_errors()
+
+				@validator[:foo].should == nil
+				newval[:foo].should == 1
+			end
+
+			it "can have required parameters merged into it after the initial validation" do
+				@validator.add( :foo, :integer, :required )
+				@validator.validate( {} )
+				@validator.merge!( 'foo' => '1' )
+
+				@validator.should be_okay()
+				@validator.should_not have_errors()
+
+				@validator[:foo].should == 1
+			end
+
+			it "can have optional parameters merged into it after the initial validation" do
+				@validator.add( :foom, /^\d+$/ )
+				@validator.validate( {} )
+				@validator.merge!( 'foom' => '5' )
+
+				@validator.should be_okay()
+				@validator.should_not have_errors()
+
+				@validator[:foom].should == '5'
+			end
+
+		    it "rejects invalid parameters when they're merged after initial validation" do
+		            @validator.add( :foom, /^\d+$/ )
+		            @validator.add( :bewm, /^\d+$/ )
+		            @validator.validate( 'foom' => "1" )
+
+		            @validator.merge!( 'bewm' => 'buckwheat noodles' )
+
+		            @validator.should_not be_okay()
+		            @validator.should have_errors()
+		            @validator[:bewm].should == nil
+		    end
+
+		end
 
-    it "rejects invalid parameters when they're merged after initial validation" do
-            @validator.add( :foom, /^\d+$/ )
-            @validator.add( :bewm, /^\d+$/ )
-            @validator.validate( 'foom' => "1" )
-
-            @validator.merge!( 'bewm' => 'buckwheat noodles' )
-
-            @validator.should_not be_okay()
-            @validator.should have_errors()
-            @validator[:bewm].should == nil
-    end
-
-    it "allows valid parameters to be fetched en masse" do
-            @validator.add( :foom, /^\d+$/ )
-            @validator.add( :bewm, /^\d+$/ )
-            @validator.validate( 'foom' => "1", "bewm" => "2" )
-            @validator.values_at( :foom, :bewm ).should == [ '1', '2' ]
-    end
-
-    it "treats ArgumentErrors in builtin constraints as validation failures" do
-            @validator.add( :integer )
-            @validator.validate( 'integer' => 'jalopy' )
-            @validator.should_not be_okay()
-            @validator.should have_errors()
-            @validator[:integer].should be_nil()
-    end
+	end # describe "constraints"
 
 end