diff options
| -rw-r--r-- | activerecord/CHANGELOG | 24 | ||||
| -rwxr-xr-x | activerecord/lib/active_record/validations.rb | 74 | ||||
| -rwxr-xr-x | activerecord/test/validations_test.rb | 133 |
3 files changed, 201 insertions, 30 deletions
diff --git a/activerecord/CHANGELOG b/activerecord/CHANGELOG index a503e27e55..bd6a856285 100644 --- a/activerecord/CHANGELOG +++ b/activerecord/CHANGELOG @@ -60,13 +60,25 @@ validates_format_of :email, :with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/, :on => :create end -* Added Base.validates_boundaries_of that delegates to add_on_boundary_breaking #312 [Tobias Luetke]. Example: - - class Person < ActiveRecord::Base - validates_boundries_of :password, :password_confirmation - validates_boundries_of :user_name, :within => 6..20, :too_long => "pick a shorter name", :too_short => "pick a longer name" - end +* Added Base.validates_length_of that delegates to add_on_boundary_breaking #312 [Tobias Luetke]. Example: + Validates that the specified attribute matches the length restrictions supplied in either: + + - configuration[:minimum] + - configuration[:maximum] + - configuration[:is] + - configuration[:within] (aka. configuration[:in]) + + Only one option can be used at a time. + + class Person < ActiveRecord::Base + validates_length_of :first_name, :maximum=>30 + validates_length_of :last_name, :maximum=>30, :message=>"less than %d if you don't mind" + validates_length_of :user_name, :within => 6..20, :too_long => "pick a shorter name", :too_short => "pick a longer name" + validates_length_of :fav_bra_size, :minimum=>1, :too_short=>"please enter at least %d character" + validates_length_of :smurf_leader, :is=>4, :message=>"papa is spelled with %d characters... don't play me." + end + * Added Base.validate_presence as an alternative to implementing validate and doing errors.add_on_empty yourself. * Added Base.validates_uniqueness_of that alidates whether the value of the specified attributes are unique across the system. diff --git a/activerecord/lib/active_record/validations.rb b/activerecord/lib/active_record/validations.rb index 95e1cc4b1e..0585ddbb90 100755 --- a/activerecord/lib/active_record/validations.rb +++ b/activerecord/lib/active_record/validations.rb @@ -123,25 +123,77 @@ module ActiveRecord end end - # Validates that the specified attributes are within the boundary defined in configuration[:within]. Happens by default on both create and update. + # Validates that the specified attribute matches the length restrictions supplied in either: + # + # - configuration[:minimum] + # - configuration[:maximum] + # - configuration[:is] + # - configuration[:within] (aka. configuration[:in]) + # + # Only one option can be used at a time. # # class Person < ActiveRecord::Base - # validates_boundaries_of :password, :password_confirmation - # validates_boundaries_of :user_name, :within => 6..20, :too_long => "pick a shorter name", :too_short => "pick a longer name" + # validates_length_of :first_name, :maximum=>30 + # validates_length_of :last_name, :maximum=>30, :message=>"less than %d if you don't mind" + # validates_length_of :user_name, :within => 6..20, :too_long => "pick a shorter name", :too_short => "pick a longer name" + # validates_length_of :fav_bra_size, :minimum=>1, :too_short=>"please enter at least %d character" + # validates_length_of :smurf_leader, :is=>4, :message=>"papa is spelled with %d characters... don't play me." # end # # Configuration options: - # ::within: The range that constitutes the boundary (default is: 6..20) - # ::too_long: The error message if the attributes go over the boundary (default is: "is too long (max is %d characters)") - # ::too_short: The error message if the attributes go under the boundary (default is: "is too short (min is %d characters)") + # ::minimum: The minimum size of the attribute + # ::maximum: The maximum size of the attribute + # ::is: The exact size of the attribute + # ::within: A range specifying the minimum and maximum size of the attribute + # ::in: A synonym(or alias) for :within + # + # ::too_long: The error message if the attribute goes over the maximum (default is: "is too long (max is %d characters)") + # ::too_short: The error message if the attribute goes under the minimum (default is: "is too short (min is %d characters)") + # ::wrong_length: The error message if using the :is method and the attribute is the wrong size (default is: "is the wrong length (should be %d characters)") + # ::message: The error message to use for a :minimum, :maximum, or :is violation. An alias of the appropriate too_long/too_short/wrong_length message # ::on: Specifies when this validation is active (default is :save, other options :create, :update) - def validates_boundaries_of(*attr_names) - configuration = { :within => 5..20, :too_long => ActiveRecord::Errors.default_error_messages[:too_long], :too_short => ActiveRecord::Errors.default_error_messages[:too_short], :on => :save } + def validates_length_of(*attr_names) + configuration = { :too_long => ActiveRecord::Errors.default_error_messages[:too_long], :too_short => ActiveRecord::Errors.default_error_messages[:too_short], :wrong_length => ActiveRecord::Errors.default_error_messages[:wrong_length], :on => :save } configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash) + # you must use one of 4 options, :within, :maximum, :minimum, or :is + within = configuration[:within] || configuration[:in] + maximum = configuration[:maximum] + minimum = configuration[:minimum] + is = configuration[:is] + + raise(ArgumentError, "The :within, :maximum, :minimum, or :is options must be passed in the configuration hash") unless within or maximum or minimum or is + # but not more than 1 of them at a time + options_used = 0 + options_used += 1 if within + options_used += 1 if maximum + options_used += 1 if minimum + options_used += 1 if is + raise(ArgumentError, "The :within, :maximum, :minimum, and :is options are mutually exclusive") if options_used > 1 + + option_to_use = within || maximum || minimum || is for attr_name in attr_names - class_eval(%(#{validation_method(configuration[:on])} %{errors.add_on_boundary_breaking('#{attr_name}', #{configuration[:within]}, "#{configuration[:too_long]}", "#{configuration[:too_short]}")})) + if within + raise(ArgumentError, "The :within option must be a Range") unless within.kind_of?(Range) + class_eval(%(#{validation_method(configuration[:on])} %{errors.add_on_boundary_breaking('#{attr_name}', #{within}, "#{configuration[:too_long]}", "#{configuration[:too_short]}")})) + elsif maximum + raise(ArgumentError, "The :maximum option must be a Fixnum") unless maximum.kind_of?(Fixnum) + msg = configuration[:message] || configuration[:too_long] + msg = (msg % maximum) rescue msg + class_eval(%(#{validation_method(configuration[:on])} %{errors.add( '#{attr_name}', '#{msg}') if #{attr_name}.to_s.length > #{maximum} })) + elsif minimum + raise(ArgumentError, "The :minimum option must be a Fixnum") unless minimum.kind_of?(Fixnum) + msg = configuration[:message] || configuration[:too_short] + msg = (msg % minimum) rescue msg + class_eval(%(#{validation_method(configuration[:on])} %{errors.add( '#{attr_name}', '#{msg}') if #{attr_name}.to_s.length < #{minimum} })) + else + raise(ArgumentError, "The :is option must be a Fixnum") unless is.kind_of?(Fixnum) + msg = configuration[:message] || configuration[:wrong_length] + msg = (msg % is) rescue msg + class_eval(%(#{validation_method(configuration[:on])} %{errors.add( '#{attr_name}', '#{msg}') if #{attr_name}.to_s.length != #{is} })) + end end + end # Validates whether the value of the specified attributes are unique across the system. Useful for making sure that only one user @@ -202,7 +254,7 @@ module ActiveRecord def validates_inclusion_of(*attr_names) configuration = { :message => ActiveRecord::Errors.default_error_messages[:inclusion], :on => :save } configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash) - enum = configuration[:in] + enum = configuration[:in] || configuration[:within] raise(ArgumentError, "An object with the method include? is required must be supplied as the :in option of the configuration hash") unless enum.respond_to?("include?") @@ -211,6 +263,7 @@ module ActiveRecord end end + private def validation_method(on) case on @@ -319,6 +372,7 @@ module ActiveRecord :empty => "can't be empty", :too_long => "is too long (max is %d characters)", :too_short => "is too short (min is %d characters)", + :wrong_length => "is the wrong length (should be %d characters)", :taken => "has already been taken", } cattr_accessor :default_error_messages diff --git a/activerecord/test/validations_test.rb b/activerecord/test/validations_test.rb index 92c0a71c35..b6c9cfed7d 100755 --- a/activerecord/test/validations_test.rb +++ b/activerecord/test/validations_test.rb @@ -189,20 +189,6 @@ class ValidationsTest < Test::Unit::TestCase t2.title = "Now Im really also unique" assert t2.save, "Should now save t2 as unique" end - - def test_validate_boundaries - Topic.validates_boundaries_of(:title, :content, :within => 3..5) - - t = Topic.create("title" => "a!", "content" => "I'm ooooooooh so very long") - assert !t.save - assert_equal "is too short (min is 3 characters)", t.errors.on(:title) - assert_equal "is too long (max is 5 characters)", t.errors.on(:content) - - t.title = "abe" - t.content = "mad" - - assert t.save - end def test_validate_format Topic.validates_format_of(:title, :content, :with => /^Validation macros rule!$/, :message => "is bad data") @@ -243,4 +229,123 @@ class ValidationsTest < Test::Unit::TestCase assert_nothing_raised(ArgumentError) { Topic.validates_inclusion_of( :title, :in => {} ) } assert_nothing_raised(ArgumentError) { Topic.validates_inclusion_of( :title, :in => [] ) } end + + def test_validates_length_of_using_minimum + Topic.validates_length_of( :title, :minimum=>5 ) + t = Topic.create("title" => "valid", "content" => "whatever") + assert t.valid? + t.title = "not" + assert !t.valid? + assert t.errors.on(:title) + assert_equal "is too short (min is 5 characters)", t.errors["title"] + t.title = "" + assert !t.valid? + assert t.errors.on(:title) + t.title = nil + assert !t.valid? + assert_equal "is too short (min is 5 characters)", t.errors["title"] + assert t.errors.on(:title) + end + + def test_validates_length_of_using_maximum + Topic.validates_length_of( :title, :maximum=>5 ) + t = Topic.create("title" => "valid", "content" => "whatever") + assert t.valid? + t.title = "notvalid" + assert !t.valid? + assert t.errors.on(:title) + assert_equal "is too long (max is 5 characters)", t.errors["title"] + t.title = "" + assert t.valid? + t.title = nil + assert t.valid? + end + + def test_validates_length_of_using_within + Topic.validates_length_of(:title, :content, :within => 3..5) + + t = Topic.create("title" => "a!", "content" => "I'm ooooooooh so very long") + assert !t.save + assert_equal "is too short (min is 3 characters)", t.errors.on(:title) + assert_equal "is too long (max is 5 characters)", t.errors.on(:content) + + t.title = "abe" + t.content = "mad" + + assert t.save + end + + def test_validates_length_of_using_is + Topic.validates_length_of( :title, :is=>5 ) + t = Topic.create("title" => "valid", "content" => "whatever") + assert t.valid? + t.title = "notvalid" + assert !t.valid? + assert t.errors.on(:title) + assert_equal "is the wrong length (should be 5 characters)", t.errors["title"] + t.title = "" + assert !t.valid? + t.title = nil + assert !t.valid? + end + + def test_validates_length_of_nasty_params + assert_raise(ArgumentError) { Topic.validates_length_of(:title, :minimum=>6, :maximum=>9) } + assert_raise(ArgumentError) { Topic.validates_length_of(:title, :within=>6, :maximum=>9) } + assert_raise(ArgumentError) { Topic.validates_length_of(:title, :within=>6, :minimum=>9) } + assert_raise(ArgumentError) { Topic.validates_length_of(:title, :within=>6, :is=>9) } + assert_raise(ArgumentError) { Topic.validates_length_of(:title, :minimum=>"a") } + assert_raise(ArgumentError) { Topic.validates_length_of(:title, :maximum=>"a") } + assert_raise(ArgumentError) { Topic.validates_length_of(:title, :within=>"a") } + assert_raise(ArgumentError) { Topic.validates_length_of(:title, :is=>"a") } + end + + def test_validates_length_of_custom_errors_for_minimum_with_message + Topic.validates_length_of( :title, :minimum=>5, :message=>"boo %d" ) + t = Topic.create("title" => "uhoh", "content" => "whatever") + assert !t.valid? + assert t.errors.on(:title) + assert_equal "boo 5", t.errors["title"] + end + + def test_validates_length_of_custom_errors_for_minimum_with_too_short + Topic.validates_length_of( :title, :minimum=>5, :too_short=>"hoo %d" ) + t = Topic.create("title" => "uhoh", "content" => "whatever") + assert !t.valid? + assert t.errors.on(:title) + assert_equal "hoo 5", t.errors["title"] + end + + def test_validates_length_of_custom_errors_for_maximum_with_message + Topic.validates_length_of( :title, :maximum=>5, :message=>"boo %d" ) + t = Topic.create("title" => "uhohuhoh", "content" => "whatever") + assert !t.valid? + assert t.errors.on(:title) + assert_equal "boo 5", t.errors["title"] + end + + def test_validates_length_of_custom_errors_for_maximum_with_too_long + Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo %d" ) + t = Topic.create("title" => "uhohuhoh", "content" => "whatever") + assert !t.valid? + assert t.errors.on(:title) + assert_equal "hoo 5", t.errors["title"] + end + + def test_validates_length_of_custom_errors_for_is_with_message + Topic.validates_length_of( :title, :is=>5, :message=>"boo %d" ) + t = Topic.create("title" => "uhohuhoh", "content" => "whatever") + assert !t.valid? + assert t.errors.on(:title) + assert_equal "boo 5", t.errors["title"] + end + + def test_validates_length_of_custom_errors_for_is_with_wrong_length + Topic.validates_length_of( :title, :is=>5, :wrong_length=>"hoo %d" ) + t = Topic.create("title" => "uhohuhoh", "content" => "whatever") + assert !t.valid? + assert t.errors.on(:title) + assert_equal "hoo 5", t.errors["title"] + end + end |