carlosbrando-remarkable 0.0.99 → 2.2.1

data/lib/remarkable/active_record/README.markdown

@@ -0,0 +1,378 @@
+h1. ActiveRecord Macros
+
+For each example below, we will show you the Rspec way and in the Macro (Shoulda) way. Choose the one that pleases you the most. :)
+
+h2. Associations
+
+h3. belong_to
+
+Ensure that the belongs_to relationship exists.
+
+<pre><code>  should_belong_to :parent
+  it { should belong_to(:parent) }</code></pre>
+
+h3. have_and_belong_to_many
+
+Ensures that the has_and_belongs_to_many relationship exists, and that the join table is in place.
+
+<pre><code>  should_have_and_belong_to_many :posts, :cars
+  it{ should have_and_belong_to_many :posts, :cars }</code></pre>
+
+h3. have_many
+
+Ensures that the has_many relationship exists. Will also test that the associated table has the required columns. Works with polymorphic associations.
+
+Options:
+* :through - association name for has_many :through
+* :dependent - tests that the association makes use of the dependent option.
+
+<pre><code>  should_have_many :friends
+  should_have_many :enemies, :through => :friends
+  should_have_many :enemies, :dependent => :destroy
+
+  it{ should have_many(:friends) }
+  it{ should have_many(:enemies, :through => :friends) }
+  it{ should have_many(:enemies, :dependent => :destroy) }</code></pre>
+
+h3. have_one
+
+Ensure that the has_one relationship exists. Will also test that the associated table has the required columns. Works with polymorphic associations.
+
+Options:
+* :dependent - tests that the association makes use of the dependent option.
+
+<pre><code>  should_have_one :god
+  it { should have_one(:god) }</code></pre>
+
+h2. Database
+
+h3. have_db_column
+
+Ensure that the given column is defined on the models backing SQL table. The options are the same as the instance variables defined on the column definition: :precision, :limit, :default, :null, :primary, :type, :scale, and :sql_type.
+
+<pre><code>  should_have_db_column :email, :type => "string", :default  => nil, :precision => nil, :limit => 255,
+                        :null => true, :primary => false, :scale => nil, :sql_type => 'varchar(255)'
+
+  it { should have_db_column(:email, :type => "string", :default  => nil, :precision => nil, :limit => 255,
+                             :null => true, :primary => false, :scale => nil, :sql_type => 'varchar(255)') }</code></pre>
+
+h3. have_db_columns
+
+Ensure that the given columns are defined on the models backing SQL table.
+
+<pre><code>  should_have_db_columns :id, :email, :name, :created_at
+  it { should have_db_columns :id, :email, :name, :created_at }</code></pre>
+
+h3. have_indices
+
+Ensures that there are DB indices on the given columns or tuples of columns. Also aliased to @should_have_index@ for readability.
+
+<pre><code>  should_have_indices :email, :name, [:commentable_type, :commentable_id]
+  should_have_index :age
+
+  it { should have_indices(:email, :name, [:commentable_type, :commentable_id]) }
+  it { should have_index(:age) }</code></pre>
+
+h3. have_index
+
+Alias for @should_have_indices@.
+
+h2. Validations
+
+A word about validations: we currently cover *ALL* Active Record validations with *ALL* options. This is great, but you have to know a few things about it.
+
+The first thing is that we only validate what you explicitly give. In other words, if you do:
+
+  should_validate_numericality_of :age
+
+It will only test if it allows only numbers for age. On Active Record, such validation implicitly states that :only_integer is false and :allow_nil is false, but those options are not tested by default. On Remarkable you have to explicitly give them in order to be tested:
+
+  should_validate_numericality_of :age, :only_integer => false, :allow_nil => false
+
+Why? Because tests are part of your software specification, it should not have defaults. You must declare it in order to understand what it does or not. The only default value that is adopted is the :message and we will explain why next.
+
+The second thing is understand how @validate@ macros work:
+
+  should_validate_inclusion_of :gender, %w(m f)
+
+In this case, it will set a non valid value in age and search for the :inclusion message ("not included in list") in the error messages. If the message exists, your validation is working, otherwise, it's not. The thing is, if you change your error message, it will not be able to found the message and the test will always pass.
+
+This is valid for all rspec matchers and not only Remarkable. Actually, we are the only one that fully supports I18n error messages. In other words, if you change the error message in through the I18n YAML files, everything will work properly. But when you set the message in your model like this:
+
+  validates_inclusion_of :gender, %w(m f), :message => "woah?! what are you then?"
+
+You have also to change the message in your tests.
+
+  should_validate_inclusion_of :gender, %w(m f), :message => "woah?! what are you then?"
+
+The third is, in any macro, if an instance variable has been created named after the model being tested, then the macro will use it to test. Otherwise, it will create a new instance to test against.
+
+Deal? Now we are good to go!
+
+h3. allow_mass_assignment_of
+
+Ensures that the attribute can be set on mass update.
+
+  should_allow_mass_assignment_of :email, :name
+  it { should allow_mass_assignment_of(:email, :name) }
+
+h3. have_named_scope
+
+Ensures that the model has a method named scope_name that returns a NamedScope object with the proxy options set to the options you supply. scope_name can be either a symbol, or a method call which will be evaled against the model. The eval‘d method call has access to all the same instance variables that a should statement would.
+
+Options: Any of the options that the named scope would pass on to find.
+
+Example:
+
+  should_have_named_scope :visible, :conditions => {:visible => true}
+
+Passes for:
+
+  named_scope :visible, :conditions => {:visible => true}
+
+Or for:
+
+  def self.visible
+    scoped(:conditions => {:visible => true})
+  end
+
+You can test lambdas or methods that return ActiveRecord#scoped calls:
+
+  should_have_named_scope 'recent(5)', :limit => 5
+  should_have_named_scope 'recent(1)', :limit => 1
+
+Passes for:
+
+  named_scope :recent, lambda {|c| {:limit => c}}
+
+Or for:
+
+  def self.recent(c)
+    scoped(:limit => c)
+  end
+
+h3. have_readonly_attributes
+
+Ensures that the attribute cannot be changed once the record has been created.
+
+  should_have_readonly_attributes :password, :admin_flag
+
+h3. validate_acceptance_of
+
+Ensures that the model cannot be saved if one of the attributes listed is not accepted.
+
+Options:
+* :accept - the expected value to be accepted.
+* :allow_nil - when supplied, validates if it allows nil or not.
+* :message - value the test expects to find in errors.on(:attribute).
+  Regexp or symbol or string.  Default = I18n.translate('activerecord.errors.messages.accepted')
+
+<pre><code>  should_validate_acceptance_of :eula, :terms
+  should_validate_acceptance_of :eula, :terms, :accept => true
+
+  it { should validate_acceptance_of(:eula, :terms) }
+  it { should validate_acceptance_of(:eula, :terms, :accept => true) }</code></pre>
+
+h3. validate_associated
+
+Ensures that the model is invalid if one of the associations given is invalid.
+
+It tries to build an instance of the association by two ways. Let's suppose a user that has many projects and you want to validate it:
+
+  it { should validate_associated(:projects) }
+
+The first attempt to build the association would be:
+
+ @user.projects.build
+
+If not possible, then we try:
+
+ @user.build_project
+
+Then it tries to save the associated object. If the object can be saved if success (in this case, it allows all attributes as blank), we won't be able to verify the validation and then an error will be raised. In such cases, you should instantiate the association before calling the matcher:
+
+ it do
+   @user = User.new
+   @project = @user.projects.build
+   should validate_associated(:projects)
+ end
+
+Or give :builder as option:
+
+  should_validate_associated(:projects, :builder => proc { |user| user.projects.build }) }
+
+Options:
+* :builder - a proc to build the association.
+* :message - value the test expects to find in errors.on(:attribute). Regexp or string.  Default = I18n.translate('activerecord.errors.messages.invalid')
+
+<pre><code>  should_validate_associated :projects, :account
+  should_validate_associated :projects, :builder => proc { |user| user.projects.build }
+
+  it { should validate_associated(:projects, :account) }
+  it { should validate_associated(:projects, :builder => proc { |user| user.projects.build }) }</code></pre>
+
+h3. validate_confirmation_of
+
+Ensures that the model cannot be saved if one of the attributes is not confirmed.
+
+Options:
+* :message - value the test expects to find in errors.on(:attribute).
+  Regexp, string or symbol. Default = I18n.translate('activerecord.errors.messages.confirmation')
+
+  should_validate_confirmation_of :email, :password
+  it { should validate_confirmation_of(:email, :password) }
+
+h3. validate_exclusion_of
+
+Ensures that given values are not valid for the attribute. If a range is given, ensures that the attribute is not valid in the given range.
+
+Note: this matcher accepts at once just one attribute to test.
+
+Options:
+* :allow_nil - when supplied, validates if it allows nil or not.
+* :allow_blank - when supplied, validates if it allows blank or not.
+* :message - value the test expects to find in errors.on(:attribute).
+  Regexp, string or symbol. Default = I18n.translate('activerecord.errors.messages.exclusion')
+
+<pre><code>  should_validate_exclusion_of :age, 30..60
+  should_validate_exclusion_of :username, "admin", "user"
+  should_not validate_exclusion_of :username, "clark_kent", "peter_park"
+
+  it { should validate_exclusion_of(:age, 30..60) }
+  it { should validate_exclusion_of(:username, "admin", "user") }
+  it { should_not validate_exclusion_of(:username, "clark_kent", "peter_park") }</code></pre>
+
+h3. validate_format_of
+
+Ensures that the attribute can be set to the given values.
+
+Note: this matcher accepts at once just one attribute to test.
+Note: this matcher is also aliased as "allow_values_for"
+
+Options:
+* :allow_nil - when supplied, validates if it allows nil or not.
+* :allow_blank - when supplied, validates if it allows blank or not.
+* :message - value the test expects to find in errors.on(:attribute).
+  Regexp, string or symbol. Default = I18n.translate('activerecord.errors.messages.invalid')
+
+<pre><code>  should validate_format_of :isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0"
+  should_not validate_format_of :isbn, "bad 1", "bad 2"
+
+  it { should validate_format_of(:isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0") }
+  it { should_not validate_format_of(:isbn, "bad 1", "bad 2") }
+</code></pre>
+
+h3. validate_inclusion_of
+
+Ensures that given values are valid for the attribute. If a range is given, ensures that the attribute is valid in the given range.
+
+Note: this matcher accepts at once just one attribute to test.
+
+Options:
+* :allow_nil - when supplied, validates if it allows nil or not.
+* :allow_blank - when supplied, validates if it allows blank or not.
+* :message - value the test expects to find in errors.on(:attribute).
+  Regexp, string or symbol. Default = I18n.translate('activerecord.errors.messages.inclusion')
+
+<pre><code>
+  it { should validate_inclusion_of(:age, 18..100) }
+  it { should validate_inclusion_of(:isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0") }
+
+  it { should_not validate_inclusion_of(:isbn, "bad 1", "bad 2") }
+</code></pre>
+
+h3. validate_length_of
+
+Validates the length of the given attributes. You have also to supply one of the following options: minimum, maximum, is or within.
+
+Note: this method is also aliased as @validate_size_of@.
+
+Options:
+* :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.
+* :allow_nil - when supplied, validates if it allows nil or not.
+* :allow_blank - when supplied, validates if it allows blank or not.
+* :short_message - value the test expects to find in errors.on(:attribute).
+  Regexp, string or symbol. Default = I18n.translate('activerecord.errors.messages.too_short') % range.first
+* :long_message - value the test expects to find in errors.on(:attribute).
+  Regexp, string or symbol. Default = I18n.translate('activerecord.errors.messages.too_long') % range.last
+* :message - value the test expects to find in errors.on(:attribute) only when :minimum, :maximum or :is is given.
+  Regexp, string or symbol. Default = I18n.translate('activerecord.errors.messages.wrong_length') % value
+
+<pre><code>  should_validate_length_of :password, :within => 6..20
+  should_validate_length_of(:password, :maximum => 20
+  should_validate_length_of(:password, :minimum => 6
+  should_validate_length_of(:age, :is => 18
+
+  it { should validate_length_of(:password, :within => 6..20) }
+  it { should validate_length_of(:password, :maximum => 20) }
+  it { should validate_length_of(:password).minimum(6) }
+  it { should validate_length_of(:age).is(18) }</code></pre>
+
+h3. validate_numericality_of
+
+Ensures that the given attributes accepts only numbers.
+
+Options:
+
+* :only_integer - when supplied, checks if it accepts only integers or not
+* :odd - when supplied, checks if it accepts only odd values or not
+* :even - when supplied, checks if it accepts only even values or not
+* :equal_to - when supplied, checks if attributes are only valid when equal to given value
+* :less_than - when supplied, checks if attributes are only valid when less than given value
+* :greater_than - when supplied, checks if attributes are only valid when greater than given value
+* :less_than_or_equal_to - when supplied, checks if attributes are only valid when less than or equal to given value
+* :greater_than_or_equal_to - when supplied, checks if attributes are only valid when greater than or equal to given value
+* :message - value the test expects to find in errors.on(:attribute).
+  Regexp, string or symbol. Default = I18n.translate('activerecord.errors.messages.not_a_number')
+
+<pre><code>  should_validate_numericality_of :age, :price
+  should_validate_numericality_of :age, :odd => true
+  should_validate_numericality_of :age, :even => true
+  should_validate_numericality_of :age, :only_integer => true
+
+  it { should validate_numericality_of(:age, :price) }
+  it { should validate_numericality_of(:age).odd }
+  it { should validate_numericality_of(:age, :even => true) }
+  it { should validate_numericality_of(:age).only_integer }</code></pre>
+
+h3. validate_presence_of
+
+Ensures that the model cannot be saved if one of the attributes listed is not present.
+
+Options:
+* :message - value the test expects to find in errors.on(:attribute).
+  Regexp, string or symbol. Default = I18n.translate('activerecord.errors.messages.blank')
+
+ should_validate_presence_of(:name, :phone_number)
+ it { should validate_presence_of(:name, :phone_number) }
+
+h3. validate_uniqueness_of
+
+Ensures that the model cannot be saved if one of the attributes listed is not unique.
+
+Requires an existing record in the database. If you supply :allow_nil as option, you need to have in the database a record with the given attribute nil and another with the given attribute not nil. The same is required for allow_blank option.
+
+Options:
+* :scope - field(s) to scope the uniqueness to.
+* :case_sensitive - the matcher look for an exact match.
+* :allow_nil - when supplied, validates if it allows nil or not.
+* :allow_blank - when supplied, validates if it allows blank or not.
+* :message - value the test expects to find in errors.on(:attribute).
+ Regexp, string or symbol.  Default = I18n.translate('activerecord.errors.messages.taken')
+
+<pre><code>
+  should_validate_uniqueness_of :keyword, :username
+  should_validate_uniqueness_of :name, :message => "O NOES! SOMEONE STOELED YER NAME!"
+  should_validate_uniqueness_of :email, :scope => :name, :case_sensitive => false
+  should_validate_uniqueness_of :address, :scope => [:first_name, :last_name]
+
+  it { should validate_uniqueness_of(:keyword, :username) }
+  it { should validate_uniqueness_of(:name, :message => "O NOES! SOMEONE STOELED YER NAME!") }
+  it { should validate_uniqueness_of(:email, :scope => :name, :case_sensitive => false) }
+  it { should validate_uniqueness_of(:address, :scope => [:first_name, :last_name]) }
+</pre></code>
+

data/lib/remarkable/active_record/active_record.rb

@@ -1,21 +1,22 @@
 require 'remarkable/active_record/helpers'
-%w( database associations validations ).each do |folder|
-  Dir[File.join(File.dirname(__FILE__), "macros", folder, '*')].each do |file|
+%w( database associations validations callbacks ).each do |folder|
+  Dir[File.join(File.dirname(__FILE__), "macros", folder, '*.rb')].each do |file|
     require file
   end
 end
+require 'remarkable/active_record/macros'
 
 module Spec
   module Rails
-    module Matchers
-      include Remarkable::Private
-      include Remarkable::ActiveRecord::Helpers
+    module Example
+      class ModelExampleGroup
+        include Remarkable::Assertions
+        include Remarkable::ActiveRecord::Matchers
+        extend Remarkable::ActiveRecord::Macros
+
+        private
+        include Remarkable::Private
+      end
     end
   end
 end
-
-Spec::Rails::Matchers.send(:include, Remarkable::Syntax::RSpec)
-
-Spec::Example::ExampleGroupMethods.send(:include, Remarkable::Private)
-Spec::Example::ExampleGroupMethods.send(:include, Remarkable::ActiveRecord::Helpers)
-Spec::Example::ExampleGroupMethods.send(:include, Remarkable::Syntax::Shoulda)

data/lib/remarkable/active_record/helpers.rb

@@ -1,14 +1,224 @@
 module Remarkable # :nodoc:
   module ActiveRecord # :nodoc:
     module Helpers # :nodoc:
-      private # :enddoc:
+      include Remarkable::Default::Helpers
 
-      def model_class
-        self.described_type
+      def message(value)
+        @options[:message] = value
+        self
+      end
+
+      def allow_nil(value = true)
+        @options[:allow_nil] = value
+        self
+      end
+
+      def allow_blank(value = true)
+        @options[:allow_blank] = value
+        self
+      end
+
+      protected
+
+      def pretty_error_messages(obj) # :nodoc:
+        obj.errors.map do |a, m| 
+          msg = "#{a} #{m}" 
+          msg << " (#{obj.send(a).inspect})" unless a.to_sym == :base
+        end
+      end
+
+      # Get a instance of the given objecy or class.
+      #
+      # If a class is given, it will check if a instance variable of this class
+      # is already set.
+      #
+      def get_instance_of(object_or_klass) # :nodoc:
+        if object_or_klass.is_a?(Class)
+          klass = object_or_klass
+          object = @spec ? @spec.instance_variable_get("@#{instance_variable_name_for(klass)}") : nil
+          object ||= klass.new
+        else
+          object_or_klass
+        end
+      end
+
+      # Guess instance variable name
+      #
+      def instance_variable_name_for(klass)
+        klass.to_s.split('::').last.underscore
+      end
+
+      # Common structure of tests that has been refactored.
+      # It checks for the key, if it exists and it's true, tests that the value
+      # given is bad, otherwise tests that the value is good.
+      #
+      def assert_bad_or_good_if_key(key, value, missing, message_key = :message, count_for_interpolation = 0)
+        return true unless @options.key? key
+
+        if @options[key]
+          return true if bad?(value, message_key)
+        else
+          return true if good?(value, message_key)
+          missing = 'not ' + missing
+        end
+
+        @missing = missing
+        false
+      end
+
+      # Common structure of tests that has been refactored.
+      # It checks for the key, if it exists and it's true, tests that the value
+      # given is good, otherwise tests that the value is bad.
+      #
+      def assert_good_or_bad_if_key(key, value, missing, message_key = :message, count_for_interpolation = 0)
+        return true unless @options.key? key
+
+        if @options[key]
+          return true if good?(value, message_key, count_for_interpolation)
+          missing = 'not ' + missing
+        else
+          return true if bad?(value, message_key, count_for_interpolation)
+        end
+
+        @missing = missing
+        false
+      end
+
+      # Default allow_nil? validation.
+      #
+      # Notice that it checks for @options[:message], so be sure that this option
+      # is properly set.
+      #
+      def allow_nil?(message_key = :message, count_for_interpolation = 0)
+        message = "allow #{@attribute} be set to nil"
+        assert_good_or_bad_if_key(:allow_nil, nil, message, message_key, count_for_interpolation)
+      end
+
+      # Default allow_blank? validation.
+      #
+      # Notice that it checks for @options[:message], so be sure that this option
+      # is properly set.
+      #
+      def allow_blank?(message_key = :message, count_for_interpolation = 0)
+        message = "allow #{@attribute} be set to blank"
+        assert_good_or_bad_if_key(:allow_blank, '', message, message_key, count_for_interpolation)
+      end
+
+      # Shortcut for assert_good_value.
+      # Please notice that it has instance variables hard coded. So do not use
+      # it if you are trying to assert another instance besides @subject.
+      #
+      def good?(value, message_sym = :message, count_for_interpolation = 0)
+        assert_good_value(@subject, @attribute, value, @options[message_sym], count_for_interpolation)
+      end
+
+      # Shortcut for assert_bad_value.
+      # Please notice that it has instance variables hard coded. So do not use
+      # it if you are trying to assert another instance besides @subject.
+      #
+      def bad?(value, message_sym = :message, count_for_interpolation = 0)
+        assert_bad_value(@subject, @attribute, value, @options[message_sym], count_for_interpolation)
+      end
+
+      # Asserts that an Active Record model validates with the passed
+      # <tt>value</tt> by making sure the <tt>error_message_to_avoid</tt> is not
+      # contained within the list of errors for that attribute.
+      #
+      #   assert_good_value(User.new, :email, "user@example.com")
+      #   assert_good_value(User.new, :ssn, "123456789", /length/)
+      #
+      # If a class is passed as the first argument, a new object will be
+      # instantiated before the assertion.  If an instance variable exists with
+      # the same name as the class (underscored), that object will be used
+      # instead.
+      #
+      #   assert_good_value(User, :email, "user@example.com")
+      #
+      #   @product = Product.new(:tangible => false)
+      #   assert_good_value(Product, :price, "0")
+      #
+      def assert_good_value(object_or_klass, attribute, value, error_message_to_avoid = //, count_for_interpolation = 0) # :nodoc:
+        object = get_instance_of(object_or_klass)
+        object.send("#{attribute}=", value)
+
+        return true if object.valid?
+
+        error_message_to_avoid = error_message_from_model(object, attribute, error_message_to_avoid, count_for_interpolation)
+
+        assert_does_not_contain(object.errors.on(attribute), error_message_to_avoid)
       end
       
-      def fail_with(message)
-        Spec::Expectations.fail_with(message)
+      # Asserts that an Active Record model invalidates the passed
+      # <tt>value</tt> by making sure the <tt>error_message_to_expect</tt> is
+      # contained within the list of errors for that attribute.
+      #
+      #   assert_bad_value(User.new, :email, "invalid")
+      #   assert_bad_value(User.new, :ssn, "123", /length/)
+      #
+      # If a class is passed as the first argument, a new object will be
+      # instantiated before the assertion.  If an instance variable exists with
+      # the same name as the class (underscored), that object will be used
+      # instead.
+      #
+      #   assert_bad_value(User, :email, "invalid")
+      #
+      #   @product = Product.new(:tangible => true)
+      #   assert_bad_value(Product, :price, "0")
+      #
+      def assert_bad_value(object_or_klass, attribute, value, error_message_to_expect = :invalid, count_for_interpolation = 0) # :nodoc:
+        object = get_instance_of(object_or_klass)
+        object.send("#{attribute}=", value)
+        
+        return false if object.valid?
+        return false unless object.errors.on(attribute)
+
+        error_message_to_expect = error_message_from_model(object, attribute, error_message_to_expect, count_for_interpolation)
+
+        assert_contains(object.errors.on(attribute), error_message_to_expect)
+      end
+
+      # Return the error message to be checked. If the message is not a Symbol
+      # neither a Hash, it returns the own message.
+      #
+      # But the nice thing is that when the message is a Symbol we get the error
+      # messsage from within the model, using already existent structure inside
+      # ActiveRecord.
+      #
+      # This allows a couple things from the user side:
+      #
+      #   1. Specify symbols in their tests:
+      #
+      #     should_allow_values_for(:shirt_size, 'S', 'M', 'L', :message => :inclusion)
+      #
+      #   As we know, allow_values_for searches for a :invalid message. So if we
+      #   were testing a validates_inclusion_of with allow_values_for, previously
+      #   we had to do something like this:
+      #
+      #     should_allow_values_for(:shirt_size, 'S', 'M', 'L', :message => 'not included in list')
+      #
+      #   Now everything gets resumed to a Symbol.
+      #
+      #   2. Do not worry with specs if their are using I18n API properly.
+      #
+      #   As we know, I18n API provides several interpolation options besides
+      #   fallback when creating error messages. If the user changed the message,
+      #   macros would start to pass when they shouldn't.
+      #
+      #   Using the underlying mechanism inside ActiveRecord makes us free from
+      #   all thos errors.
+      #
+      # The count value is used to do interpolation.
+      #
+      def error_message_from_model(model, attribute, message, count_value = 0)
+        if message.is_a? Symbol
+          if Object.const_defined?(:I18n) # Rails >= 2.2
+            model.errors.generate_message(attribute, message, :count => count_value)
+          else # Rails <= 2.1
+            ::ActiveRecord::Errors.default_error_messages[message] % count_value
+          end
+        else
+          message
+        end
       end
 
     end