remarkable_activerecord 3.0.1 → 3.0.2

data/lib/remarkable_activerecord/matchers/validate_confirmation_of_matcher.rb

@@ -1,44 +1,44 @@
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class ValidateConfirmationOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :collection => :attributes, :as => :attribute
-
-        optional :message
-        collection_assertions :responds_to_confirmation?, :confirms?
-
-        default_options :message => :confirmation
-
-        protected
-
-          def responds_to_confirmation?
-            @subject.respond_to?(:"#{@attribute}_confirmation=")
-          end
-
-          def confirms?
-            @subject.send(:"#{@attribute}_confirmation=", 'something')
-            bad?('different')
-          end
-
-      end
-
-      # Ensures that the model cannot be saved if one of the attributes is not confirmed.
-      #
-      # == Options
-      #
-      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.confirmation')</tt>
-      #
-      # == Examples
-      #
-      #   should_validate_confirmation_of :email, :password
-      #
-      #   it { should validate_confirmation_of(:email, :password) }
-      #
-      def validate_confirmation_of(*attributes)
-        ValidateConfirmationOfMatcher.new(*attributes).spec(self)
-      end
-
-    end
-  end
-end
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class ValidateConfirmationOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        arguments :collection => :attributes, :as => :attribute
+
+        optional :message
+        collection_assertions :responds_to_confirmation?, :confirms?
+
+        default_options :message => :confirmation
+
+        protected
+
+          def responds_to_confirmation?
+            @subject.respond_to?(:"#{@attribute}_confirmation=")
+          end
+
+          def confirms?
+            @subject.send(:"#{@attribute}_confirmation=", 'something')
+            bad?('different')
+          end
+
+      end
+
+      # Ensures that the model cannot be saved if one of the attributes is not confirmed.
+      #
+      # == Options
+      #
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.confirmation')</tt>
+      #
+      # == Examples
+      #
+      #   should_validate_confirmation_of :email, :password
+      #
+      #   it { should validate_confirmation_of(:email, :password) }
+      #
+      def validate_confirmation_of(*attributes)
+        ValidateConfirmationOfMatcher.new(*attributes).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/validate_exclusion_of_matcher.rb

@@ -1,26 +1,26 @@
-require File.join(File.dirname(__FILE__), 'allow_values_for_matcher')
-
+require File.join(File.dirname(__FILE__), 'allow_values_for_matcher')
+
 module Remarkable
   module ActiveRecord
-    module Matchers
-      class ValidateExclusionOfMatcher < AllowValuesForMatcher #:nodoc:
-
-        default_options :message => :exclusion
-
-        protected
-
-          def valid_values
-            @in_range ? [ @options[:in].first - 1, @options[:in].last + 1 ] : []
-          end
-
-          def invalid_values
-            @options[:in]
-          end
+    module Matchers
+      class ValidateExclusionOfMatcher < AllowValuesForMatcher #:nodoc:
+
+        default_options :message => :exclusion
+
+        protected
+
+          def valid_values
+            @in_range ? [ @options[:in].first - 1, @options[:in].last + 1 ] : []
+          end
+
+          def invalid_values
+            @options[:in]
+          end
 
       end
 
       # 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.
+      # is given, ensures that the attribute is not valid in the given range.
       #
       # == Options
       #

data/lib/remarkable_activerecord/matchers/validate_inclusion_of_matcher.rb

@@ -1,27 +1,27 @@
-require File.join(File.dirname(__FILE__), 'allow_values_for_matcher')
-
+require File.join(File.dirname(__FILE__), 'allow_values_for_matcher')
+
 module Remarkable
   module ActiveRecord
-    module Matchers
-      class ValidateInclusionOfMatcher < AllowValuesForMatcher #:nodoc:
-
-        default_options :message => :inclusion
-
-        protected
-
-          def valid_values
-            @options[:in]
-          end
-
-          def invalid_values
-            @in_range ? [ @options[:in].first - 1, @options[:in].last + 1 ] : []
-          end
+    module Matchers
+      class ValidateInclusionOfMatcher < AllowValuesForMatcher #:nodoc:
+
+        default_options :message => :inclusion
+
+        protected
+
+          def valid_values
+            @options[:in]
+          end
+
+          def invalid_values
+            @in_range ? [ @options[:in].first - 1, @options[:in].last + 1 ] : []
+          end
 
       end
 
       # Ensures that given values are valid for the attribute. If a range
-      # is given, ensures that the attribute is valid in the given range.
-      #
+      # is given, ensures that the attribute is valid in the given range.
+      #
       # == Options
       #
       # * <tt>:in</tt> - values to test inclusion.
@@ -31,9 +31,9 @@ module Remarkable
       #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.inclusion')</tt>
       #
       # == Examples
-      #
+      #
       #   should_validate_inclusion_of :size, :in => ["S", "M", "L", "XL"]
-      #   should_validate_inclusion_of :age, :in => 18..100
+      #   should_validate_inclusion_of :age, :in => 18..100
       #
       #   it { should validate_inclusion_of(:size, :in => ["S", "M", "L", "XL"]) }
       #   it { should validate_inclusion_of(:age, :in => 18..100) }

data/lib/remarkable_activerecord/matchers/validate_numericality_of_matcher.rb

@@ -130,20 +130,20 @@ module Remarkable
             (valid_value_for_test / 2) * 2
           end
 
-          # Returns the default message for each key (:odd, :even, :equal_to, ...).
-          # If the user provided a message, we use it, otherwise we should use
-          # the given key as message.
-          #
-          # For example, a default_message_for(:odd), if none is provided, will be
-          # :odd. So we have create :odd_message in the options hash, that when
-          # called later, will return :odd.
-          #
-          def default_message_for(key)
-            if @options[:message]
-              :message
-            else
-              @options[:"#{key}_message"] = key
-              :"#{key}_message"
+          # Returns the default message for each key (:odd, :even, :equal_to, ...).
+          # If the user provided a message, we use it, otherwise we should use
+          # the given key as message.
+          #
+          # For example, a default_message_for(:odd), if none is provided, will be
+          # :odd. So we have create :odd_message in the options hash, that when
+          # called later, will return :odd.
+          #
+          def default_message_for(key)
+            if @options[:message]
+              :message
+            else
+              @options[:"#{key}_message"] = key
+              :"#{key}_message"
             end
           end
       end

data/lib/remarkable_activerecord/matchers/validate_uniqueness_of_matcher.rb

@@ -2,56 +2,56 @@ module Remarkable
   module ActiveRecord
     module Matchers
       class ValidateUniquenessOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :collection => :attributes, :as => :attribute
-
-        optional :message
+        arguments :collection => :attributes, :as => :attribute
+
+        optional :message
         optional :scope, :splat => true
-        optional :case_sensitive, :allow_nil, :allow_blank, :default => true
+        optional :case_sensitive, :allow_nil, :allow_blank, :default => true
 
         collection_assertions :find_first_object?, :responds_to_scope?, :is_unique?, :case_sensitive?,
                               :valid_with_new_scope?, :allow_nil?, :allow_blank?
-
-        default_options :message => :taken
-
-        before_assert do
-          @options[:scope] = [*@options[:scope]].compact if @options[:scope]
-        end
+
+        default_options :message => :taken
+
+        before_assert do
+          @options[:scope] = [*@options[:scope]].compact if @options[:scope]
+        end
 
         private
 
-          # Tries to find an object in the database. If allow_nil and/or allow_blank
+          # Tries to find an object in the database. If allow_nil and/or allow_blank
           # is given, we must find a record which is not nil or not blank.
           #
           # If any of these attempts fail, the validation fail.
           #
           def find_first_object?
             @existing, message = if @options[:allow_nil]
-              [ subject_class.find(:first, :conditions => "#{@attribute} IS NOT NULL"), " with #{@attribute} not nil" ]
+              [ subject_class.find(:first, :conditions => "#{@attribute} IS NOT NULL"), " with #{@attribute} not nil" ]
             elsif @options[:allow_blank]
-              [ subject_class.find(:first, :conditions => "#{@attribute} != ''"), " with #{@attribute} not blank" ]
+              [ subject_class.find(:first, :conditions => "#{@attribute} != ''"), " with #{@attribute} not blank" ]
             else
               [ subject_class.find(:first), "" ]
-            end
-
-            return true if @existing
+            end
+
+            return true if @existing
             raise ScriptError, "could not find a #{subject_class} in the database" + message
-          end
-
+          end
+
           # Set subject scope to be equal to the object found.
-          #
-          def responds_to_scope?
-            (@options[:scope] || []).each do |scope|
-              method = :"#{scope}="
-              return false, :method => method unless @subject.respond_to?(method)
+          #
+          def responds_to_scope?
+            (@options[:scope] || []).each do |scope|
+              method = :"#{scope}="
+              return false, :method => method unless @subject.respond_to?(method)
 
               @subject.send(method, @existing.send(scope))
-            end
-            true
+            end
+            true
           end
-
+
           # Check if the attribute given is valid and if the validation fails for equal values.
           #
-          def is_unique?
+          def is_unique?
             @value = @existing.send(@attribute)
             return bad?(@value)
           end
@@ -71,52 +71,71 @@ module Remarkable
 
           # Now test that the object is valid when changing the scoped attribute.
           #
-          def valid_with_new_scope?
-            (@options[:scope] || []).each do |scope|
-              previous_scope_value = @subject.send(scope)
+          def valid_with_new_scope?
+            (@options[:scope] || []).each do |scope|
+              previous_scope_value = @subject.send(scope)
+
+              @subject.send("#{scope}=", new_value_for_scope(scope))
+              return false, :method => scope unless good?(@value)
 
-              @subject.send("#{scope}=", new_value_for_scope(scope))
-              return false, :method => scope unless good?(@value)
-
               @subject.send("#{scope}=", previous_scope_value)
             end
             true
           end
-
-          # Change the existing object attribute to nil to run allow nil validation.
-          #
+
+          # Change the existing object attribute to nil to run allow nil
+          # validations. If we find any problem while updating the @existing
+          # record, it's because we can't save nil values in the database. So it
+          # passes when :allow_nil is false, but should raise an error when
+          # :allow_nil is true
+          #
           def allow_nil?
-            @existing.update_attribute(@attribute, nil)
+            return true unless @options.key?(:allow_nil)
+
+            @existing.update_attribute(@attribute, nil)
             super
-          end
+          rescue Exception => e
+            raise ScriptError, "You declared that #{@attribute} accepts nil values in validate_uniqueness_of, " <<
+                               "but I cannot save nil values in the database, got: #{e.message}" if @options[:allow_nil]
 
-          # Change the existing object attribute to blank to run allow blank validation.
-          #
+            true
+          end
+
+          # Change the existing object attribute to blank to run allow blank
+          # validation. It uses the same logic as :allow_nil.
+          #
           def allow_blank?
-            @existing.update_attribute(@attribute, '')
+            return true unless @options.key?(:allow_blank)
+
+            @existing.update_attribute(@attribute, '')
             super
-          end
+          rescue Exception => e
+            raise ScriptError, "You declared that #{@attribute} accepts blank values in validate_uniqueness_of, " <<
+                               "but I cannot save blank values in the database, got: #{e.message}" if @options[:allow_blank]
+
+            true
+          end
 
-          # Returns a value to be used as new scope. It does a range query in the
+          # Returns a value to be used as new scope. It does a range query in the
           # database and tries to return a new value which does not belong to it.
           #
-          def new_value_for_scope(scope)
-            new_scope = (@existing.send(scope) || 999).next.to_s
-
-            # Generate a range of values to search in the database
-            values = 100.times.inject([new_scope]) {|v,i| v << v.last.next }
-            conditions = { scope => values, @attribute => @value }
-
-            # Get values from the database, get the scope attribute and map them to string.
-            db_values = subject_class.find(:all, :conditions => conditions, :select => scope)
-            db_values.map!{ |r| r.send(scope).to_s }
-
-            if value_to_return = (values - db_values).first
-              value_to_return
-            else
-              raise ScriptError, "Tried to find an unique scope value for #{scope} but I could not. " << 
-                                 "The conditions hash was #{conditions.inspect} and it returned all records."
-            end
+          def new_value_for_scope(scope)
+            new_scope = (@existing.send(scope) || 999).next.to_s
+
+            # Generate a range of values to search in the database
+            values = 100.times.inject([new_scope]) {|v,i| v << v.last.next }
+            conditions = { scope => values, @attribute => @value }
+
+            # Get values from the database, get the scope attribute and map them to string.
+            db_values = subject_class.find(:all, :conditions => conditions, :select => scope)
+            db_values.map!{ |r| r.send(scope).to_s }
+
+            if value_to_return = (values - db_values).first
+              value_to_return
+            else
+              raise ScriptError, "Tried to find an unique scope value for #{scope} but I could not. " << 
+                                 "The conditions hash was #{conditions.inspect} and it returned all records."
+            end
           end
       end
 
@@ -124,7 +143,7 @@ module Remarkable
       # 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 which is not nil in the
+      # option, you need to have in the database a record which is not nil in the
       # given attributes. The same is required for allow_blank option.
       #
       # == Options

data/locale/en.yml

@@ -1,253 +1,253 @@
-en:
-  remarkable:
-    active_record:
-      allow_nil: "{{subject_name}} to {{not}}allow nil values for {{attribute}}"
-      allow_blank: "{{subject_name}} to {{not}}allow blank values for {{attribute}}"
-
-      allow_values_for:
-        description: "allow {{in}} as values for {{attributes}}"
-        expectations:
-          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
-        optionals:
-          allow_nil:
-            positive: "allowing nil values"
-            negative: "not allowing nil values"
-          allow_blank:
-            positive: "allowing blank values"
-            negative: "not allowing blank values"
-
-      allow_mass_assignment_of:
-        description: "allow mass assignment of {{attributes}}"
-        expectations:
-          is_protected: "{{subject_name}} to allow mass assignment of {{attribute}} ({{subject_name}} is protecting {{attribute}})"
-          is_accessible: "{{subject_name}} to allow mass assignment of {{attribute}} ({{subject_name}} has not made {{attribute}} accessible)"
-
-      association:
-        belongs_to: belong to
-        has_many: have many
-        has_and_belongs_to_many: have and belong to many
-        has_one: have one
-        description: "{{macro}} {{associations}}"
-        expectations:
-          association_exists: "{{subject_name}} records {{macro}} {{association}}, got no association"
-          macro_matches: "{{subject_name}} records {{macro}} {{association}}, got {{subject_name}} records {{actual_macro}} {{association}}"
-          through_exists: "{{subject_name}} records {{macro}} {{association}} through {{through}}, through association does not exist"
-          join_table_exists: "join table {{actual_join_table}} to exist, but does not"
-          foreign_key_exists: "foreign key {{actual_foreign_key}} to exist on {{foreign_key_table}}, but does not"
-          polymorphic_exists: "{{subject_table}} to have {{polymorphic_column}} as column, but does not"
-          counter_cache_exists: "{{reflection_table}} to have {{counter_cache_column}} as column, but does not"
-          through_matches: "{{association}} association through {{through}}, got {{actual_through}}"
-          class_name_matches: "{{association}} association with class name {{class_name}}, got {{actual_class_name}}"
-          foreign_key_matches: "{{association}} association with foreign key {{foreign_key}}, got {{actual_foreign_key}}"
-          dependent_matches: "{{association}} association with dependent {{dependent}}, got {{actual_dependent}}"
-          join_table_matches: "{{association}} association with join table {{join_table}}, got {{actual_join_table}}"
-          uniq_matches: "{{association}} association with uniq equals to {{uniq}}, got {{actual_uniq}}"
-          readonly_matches: "{{association}} association with readonly equals to {{readonly}}, got {{actual_readonly}}"
-          validate_matches: "{{association}} association with validate equals to {{validate}}, got {{actual_validate}}"
-          autosave_matches: "{{association}} association with autosave equals to {{autosave}}, got {{actual_autosave}}"
-          polymorphic_matches: "{{association}} association with polymorphic equals to {{polymorphic}}, got {{actual_polymorphic}}"
-          as_matches: "{{association}} association with polymorphic interface {{as}}, got {{actual_as}}"
-          counter_cache_matches: "{{association}} association with counter cache {{counter_cache}}, got {{actual_counter_cache}}"
-        optionals:
-          through:
-            positive: "through {{value}}"
-          class_name:
-            positive: "with class name {{inspect}}"
-          foreign_key:
-            positive: "with foreign key {{inspect}}"
-          dependent:
-            positive: "with dependent {{inspect}}"
-          join_table:
-            positive: "with join table {{inspect}}"
-          uniq:
-            positive: "with unique records"
-            negative: "without unique records"
-          readonly:
-            positive: "with readonly records"
-            negative: "without readonly records"
-          validate:
-            positive: "validating associated records"
-            negative: "not validating associated records"
-          autosave:
-            positive: "autosaving associated records"
-            negative: "not autosaving associated records"
-          polymorphic:
-            positive: "through a polymorphic interface"
-          as:
-            positive: "through the polymorphic interface {{inspect}}"
-          counter_cache:
-            positive: "with counter cache {{inspect}}"
-            negative: "without counter cache"
-
-      have_column:
-        description: "have column(s) named {{columns}}"
-        expectations:
-          column_exists: "{{subject_name}} to have column named {{column}}"
-          options_match: "{{subject_name}} to have column {{column}} with options {{options}}, got {{actual}}"
-        optionals:
-          type:
-            positive: "with type {{inspect}}"
-          null:
-            positive: "allowing null values"
-            negative: "not allowing null values"
-          default:
-            positive: "with default {{inspect}}"
-            negative: "with default {{inspect}}"
-          limit:
-            positive: "with limit {{inspect}}"
-
-      have_index:
-        description: "have index for column(s) {{columns}}"
-        expectations:
-          index_exists: "index {{column}} to exist on table {{table_name}}"
-          is_unique: "index on {{column}} with unique equals to {{unique}}, got {{actual}}"
-        optionals:
-          unique:
-            positive: "with unique values"
-            negative: "with non unique values"
-
-      have_readonly_attributes:
-        description: "make {{attributes}} read-only"
-        expectations:
-          is_readonly: "{{subject_name}} to make {{attribute}} read-only, got {{actual}}"
-
-      have_scope:
-        description: "have to scope itself to {{options}} when {{scope_name}} is called"
-        expectations:
-          is_scope: "{{scope_name}} when called on {{subject_name}} return a ActiveRecord::NamedScope::Scope object"
-          options_match: "{{scope_name}} when called on {{subject_name}} scope to {{options}}, got {{actual}}"
-        optionals:
-          with:
-            positive: "with {{inspect}} as argument"
-
-      validate_acceptance_of:
-        description: "require {{attributes}} to be accepted"
-        expectations:
-          requires_acceptance: "{{subject_name}} to be invalid if {{attribute}} is not accepted"
-          accept_is_valid: "{{subject_name}} to be valid when {{attribute}} is accepted with value {{accept}}"
-        optionals:
-          accept:
-            positive: "with value {{inspect}}"
-          allow_nil:
-            positive: "allowing nil values"
-            negative: "not allowing nil values"
-
-      validate_associated:
-        description: "require associated {{associations}} to be valid"
-        expectations:
-          is_valid: "{{subject_name}} to be invalid when {{association}} is invalid"
-
-      validate_confirmation_of:
-        description: "require {{attributes}} to be confirmed"
-        expectations:
-          responds_to_confirmation: "{{subject_name}} instance responds to {{attribute}}_confirmation"
-          confirms: "{{subject_name}} to be valid only when {{attribute}} is confirmed"
-
-      validate_exclusion_of:
-        description: "ensure exclusion of {{attributes}} in {{in}}"
-        expectations:
-          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
-          is_invalid: "{{subject_name}} to be invalid when {{attribute}} is set to {{value}}"
-        optionals:
-          allow_nil:
-            positive: "allowing nil values"
-            negative: "not allowing nil values"
-          allow_blank:
-            positive: "allowing blank values"
-            negative: "not allowing blank values"
-
-      validate_inclusion_of:
-        description: "ensure inclusion of {{attributes}} in {{in}}"
-        expectations:
-          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
-          is_invalid: "{{subject_name}} to be invalid when {{attribute}} is set to {{value}}"
-        optionals:
-          allow_nil:
-            positive: "allowing nil values"
-            negative: "not allowing nil values"
-          allow_blank:
-            positive: "allowing blank values"
-            negative: "not allowing blank values"
-
-      validate_length_of:
-        description: "ensure length of {{attributes}}"
-        expectations:
-          less_than_min_length: "{{subject_name}} to be invalid when {{attribute}} length is less than {{minimum}} characters"
-          exactly_min_length: "{{subject_name}} to be valid when {{attribute}} length is {{minimum}} characters"
-          more_than_max_length: "{{subject_name}} to be invalid when {{attribute}} length is more than {{maximum}} characters"
-          exactly_max_length: "{{subject_name}} to be valid when {{attribute}} length is {{maximum}} characters"
-        optionals:
-          within:
-            positive: "is within {{inspect}} characters"
-          maximum:
-            positive: "is maximum {{inspect}} characters"
-          minimum:
-            positive: "is minimum {{inspect}} characters"
-          is:
-            positive: "is equal to {{inspect}} characters"
-          allow_nil:
-            positive: "allowing nil values"
-            negative: "not allowing nil values"
-          allow_blank:
-            positive: "allowing blank values"
-            negative: "not allowing blank values"
-
-      validate_numericality_of:
-        description: "ensure numericality of {{attributes}}"
-        expectations:
-          only_numeric_values: "{{subject_name}} to allow only numeric values for {{attribute}}"
-          only_integer: "{{subject_name}} to {{not}}allow only integer values for {{attribute}}"
-          only_even: "{{subject_name}} to allow only even values for {{attribute}}"
-          only_odd: "{{subject_name}} to allow only odd values for {{attribute}}"
-          equals_to: "{{subject_name}} to be valid only when {{attribute}} is equal to {{count}}"
-          more_than_maximum: "{{subject_name}} to be invalid when {{attribute}} is greater than {{count}}"
-          less_than_minimum: "{{subject_name}} to be invalid when {{attribute}} is less than {{count}}"
-        optionals:
-          only_integer:
-            positive: "allowing only integer values"
-          odd:
-            positive: "allowing only odd values"
-          even:
-            positive: "allowing only even values"
-          equal_to:
-            positive: "is equal to {{inspect}}"
-          less_than:
-            positive: "is less than {{inspect}}"
-          greater_than:
-            positive: "is greater than {{inspect}}"
-          less_than_or_equal_to:
-            positive: "is less than or equal to {{inspect}}"
-          greater_than_or_equal_to:
-            positive: "is greater than or equal to {{inspect}}"
-          allow_nil:
-            positive: "allowing nil values"
-            negative: "not allowing nil values"
-          allow_blank:
-            positive: "allowing blank values"
-            negative: "not allowing blank values"
-
-      validate_presence_of:
-        description: "require {{attributes}} to be set"
-        expectations:
-          allow_nil: "{{subject_name}} to require {{attribute}} to be set"
-
-      validate_uniqueness_of:
-        description: "require unique values for {{attributes}}"
-        expectations:
-          responds_to_scope: "{{subject_name}} instance responds to {{method}}"
-          is_unique: "{{subject_name}} to require unique values for {{attribute}}"
-          case_sensitive: "{{subject_name}} to {{not}}be case sensitive on {{attribute}} validation"
-          valid_with_new_scope: "{{subject_name}} to be valid when {{attribute}} scope ({{method}}) change"
-        optionals:
-          scope:
-            positive: "scoped to {{inspect}}"
-          case_sensitive:
-            positive: "case sensitive"
-            negative: "case insensitive"
-          allow_nil:
-            positive: "allowing nil values"
-            negative: "not allowing nil values"
-          allow_blank:
-            positive: "allowing blank values"
-            negative: "not allowing blank values"
-
+en:
+  remarkable:
+    active_record:
+      allow_nil: "{{subject_name}} to {{not}}allow nil values for {{attribute}}"
+      allow_blank: "{{subject_name}} to {{not}}allow blank values for {{attribute}}"
+
+      allow_values_for:
+        description: "allow {{in}} as values for {{attributes}}"
+        expectations:
+          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
+        optionals:
+          allow_nil:
+            positive: "allowing nil values"
+            negative: "not allowing nil values"
+          allow_blank:
+            positive: "allowing blank values"
+            negative: "not allowing blank values"
+
+      allow_mass_assignment_of:
+        description: "allow mass assignment of {{attributes}}"
+        expectations:
+          is_protected: "{{subject_name}} to allow mass assignment of {{attribute}} ({{subject_name}} is protecting {{attribute}})"
+          is_accessible: "{{subject_name}} to allow mass assignment of {{attribute}} ({{subject_name}} has not made {{attribute}} accessible)"
+
+      association:
+        belongs_to: belong to
+        has_many: have many
+        has_and_belongs_to_many: have and belong to many
+        has_one: have one
+        description: "{{macro}} {{associations}}"
+        expectations:
+          association_exists: "{{subject_name}} records {{macro}} {{association}}, got no association"
+          macro_matches: "{{subject_name}} records {{macro}} {{association}}, got {{subject_name}} records {{actual_macro}} {{association}}"
+          through_exists: "{{subject_name}} records {{macro}} {{association}} through {{through}}, through association does not exist"
+          join_table_exists: "join table {{actual_join_table}} to exist, but does not"
+          foreign_key_exists: "foreign key {{actual_foreign_key}} to exist on {{foreign_key_table}}, but does not"
+          polymorphic_exists: "{{subject_table}} to have {{polymorphic_column}} as column, but does not"
+          counter_cache_exists: "{{reflection_table}} to have {{counter_cache_column}} as column, but does not"
+          through_matches: "{{association}} association through {{through}}, got {{actual_through}}"
+          class_name_matches: "{{association}} association with class name {{class_name}}, got {{actual_class_name}}"
+          foreign_key_matches: "{{association}} association with foreign key {{foreign_key}}, got {{actual_foreign_key}}"
+          dependent_matches: "{{association}} association with dependent {{dependent}}, got {{actual_dependent}}"
+          join_table_matches: "{{association}} association with join table {{join_table}}, got {{actual_join_table}}"
+          uniq_matches: "{{association}} association with uniq equals to {{uniq}}, got {{actual_uniq}}"
+          readonly_matches: "{{association}} association with readonly equals to {{readonly}}, got {{actual_readonly}}"
+          validate_matches: "{{association}} association with validate equals to {{validate}}, got {{actual_validate}}"
+          autosave_matches: "{{association}} association with autosave equals to {{autosave}}, got {{actual_autosave}}"
+          polymorphic_matches: "{{association}} association with polymorphic equals to {{polymorphic}}, got {{actual_polymorphic}}"
+          as_matches: "{{association}} association with polymorphic interface {{as}}, got {{actual_as}}"
+          counter_cache_matches: "{{association}} association with counter cache {{counter_cache}}, got {{actual_counter_cache}}"
+        optionals:
+          through:
+            positive: "through {{value}}"
+          class_name:
+            positive: "with class name {{inspect}}"
+          foreign_key:
+            positive: "with foreign key {{inspect}}"
+          dependent:
+            positive: "with dependent {{inspect}}"
+          join_table:
+            positive: "with join table {{inspect}}"
+          uniq:
+            positive: "with unique records"
+            negative: "without unique records"
+          readonly:
+            positive: "with readonly records"
+            negative: "without readonly records"
+          validate:
+            positive: "validating associated records"
+            negative: "not validating associated records"
+          autosave:
+            positive: "autosaving associated records"
+            negative: "not autosaving associated records"
+          polymorphic:
+            positive: "through a polymorphic interface"
+          as:
+            positive: "through the polymorphic interface {{inspect}}"
+          counter_cache:
+            positive: "with counter cache {{inspect}}"
+            negative: "without counter cache"
+
+      have_column:
+        description: "have column(s) named {{columns}}"
+        expectations:
+          column_exists: "{{subject_name}} to have column named {{column}}"
+          options_match: "{{subject_name}} to have column {{column}} with options {{options}}, got {{actual}}"
+        optionals:
+          type:
+            positive: "with type {{inspect}}"
+          null:
+            positive: "allowing null values"
+            negative: "not allowing null values"
+          default:
+            positive: "with default {{inspect}}"
+            negative: "with default {{inspect}}"
+          limit:
+            positive: "with limit {{inspect}}"
+
+      have_index:
+        description: "have index for column(s) {{columns}}"
+        expectations:
+          index_exists: "index {{column}} to exist on table {{table_name}}"
+          is_unique: "index on {{column}} with unique equals to {{unique}}, got {{actual}}"
+        optionals:
+          unique:
+            positive: "with unique values"
+            negative: "with non unique values"
+
+      have_readonly_attributes:
+        description: "make {{attributes}} read-only"
+        expectations:
+          is_readonly: "{{subject_name}} to make {{attribute}} read-only, got {{actual}}"
+
+      have_scope:
+        description: "have to scope itself to {{options}} when {{scope_name}} is called"
+        expectations:
+          is_scope: "{{scope_name}} when called on {{subject_name}} return a ActiveRecord::NamedScope::Scope object"
+          options_match: "{{scope_name}} when called on {{subject_name}} scope to {{options}}, got {{actual}}"
+        optionals:
+          with:
+            positive: "with {{inspect}} as argument"
+
+      validate_acceptance_of:
+        description: "require {{attributes}} to be accepted"
+        expectations:
+          requires_acceptance: "{{subject_name}} to be invalid if {{attribute}} is not accepted"
+          accept_is_valid: "{{subject_name}} to be valid when {{attribute}} is accepted with value {{accept}}"
+        optionals:
+          accept:
+            positive: "with value {{inspect}}"
+          allow_nil:
+            positive: "allowing nil values"
+            negative: "not allowing nil values"
+
+      validate_associated:
+        description: "require associated {{associations}} to be valid"
+        expectations:
+          is_valid: "{{subject_name}} to be invalid when {{association}} is invalid"
+
+      validate_confirmation_of:
+        description: "require {{attributes}} to be confirmed"
+        expectations:
+          responds_to_confirmation: "{{subject_name}} instance responds to {{attribute}}_confirmation"
+          confirms: "{{subject_name}} to be valid only when {{attribute}} is confirmed"
+
+      validate_exclusion_of:
+        description: "ensure exclusion of {{attributes}} in {{in}}"
+        expectations:
+          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
+          is_invalid: "{{subject_name}} to be invalid when {{attribute}} is set to {{value}}"
+        optionals:
+          allow_nil:
+            positive: "allowing nil values"
+            negative: "not allowing nil values"
+          allow_blank:
+            positive: "allowing blank values"
+            negative: "not allowing blank values"
+
+      validate_inclusion_of:
+        description: "ensure inclusion of {{attributes}} in {{in}}"
+        expectations:
+          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
+          is_invalid: "{{subject_name}} to be invalid when {{attribute}} is set to {{value}}"
+        optionals:
+          allow_nil:
+            positive: "allowing nil values"
+            negative: "not allowing nil values"
+          allow_blank:
+            positive: "allowing blank values"
+            negative: "not allowing blank values"
+
+      validate_length_of:
+        description: "ensure length of {{attributes}}"
+        expectations:
+          less_than_min_length: "{{subject_name}} to be invalid when {{attribute}} length is less than {{minimum}} characters"
+          exactly_min_length: "{{subject_name}} to be valid when {{attribute}} length is {{minimum}} characters"
+          more_than_max_length: "{{subject_name}} to be invalid when {{attribute}} length is more than {{maximum}} characters"
+          exactly_max_length: "{{subject_name}} to be valid when {{attribute}} length is {{maximum}} characters"
+        optionals:
+          within:
+            positive: "is within {{inspect}} characters"
+          maximum:
+            positive: "is maximum {{inspect}} characters"
+          minimum:
+            positive: "is minimum {{inspect}} characters"
+          is:
+            positive: "is equal to {{inspect}} characters"
+          allow_nil:
+            positive: "allowing nil values"
+            negative: "not allowing nil values"
+          allow_blank:
+            positive: "allowing blank values"
+            negative: "not allowing blank values"
+
+      validate_numericality_of:
+        description: "ensure numericality of {{attributes}}"
+        expectations:
+          only_numeric_values: "{{subject_name}} to allow only numeric values for {{attribute}}"
+          only_integer: "{{subject_name}} to {{not}}allow only integer values for {{attribute}}"
+          only_even: "{{subject_name}} to allow only even values for {{attribute}}"
+          only_odd: "{{subject_name}} to allow only odd values for {{attribute}}"
+          equals_to: "{{subject_name}} to be valid only when {{attribute}} is equal to {{count}}"
+          more_than_maximum: "{{subject_name}} to be invalid when {{attribute}} is greater than {{count}}"
+          less_than_minimum: "{{subject_name}} to be invalid when {{attribute}} is less than {{count}}"
+        optionals:
+          only_integer:
+            positive: "allowing only integer values"
+          odd:
+            positive: "allowing only odd values"
+          even:
+            positive: "allowing only even values"
+          equal_to:
+            positive: "is equal to {{inspect}}"
+          less_than:
+            positive: "is less than {{inspect}}"
+          greater_than:
+            positive: "is greater than {{inspect}}"
+          less_than_or_equal_to:
+            positive: "is less than or equal to {{inspect}}"
+          greater_than_or_equal_to:
+            positive: "is greater than or equal to {{inspect}}"
+          allow_nil:
+            positive: "allowing nil values"
+            negative: "not allowing nil values"
+          allow_blank:
+            positive: "allowing blank values"
+            negative: "not allowing blank values"
+
+      validate_presence_of:
+        description: "require {{attributes}} to be set"
+        expectations:
+          allow_nil: "{{subject_name}} to require {{attribute}} to be set"
+
+      validate_uniqueness_of:
+        description: "require unique values for {{attributes}}"
+        expectations:
+          responds_to_scope: "{{subject_name}} instance responds to {{method}}"
+          is_unique: "{{subject_name}} to require unique values for {{attribute}}"
+          case_sensitive: "{{subject_name}} to {{not}}be case sensitive on {{attribute}} validation"
+          valid_with_new_scope: "{{subject_name}} to be valid when {{attribute}} scope ({{method}}) change"
+        optionals:
+          scope:
+            positive: "scoped to {{inspect}}"
+          case_sensitive:
+            positive: "case sensitive"
+            negative: "case insensitive"
+          allow_nil:
+            positive: "allowing nil values"
+            negative: "not allowing nil values"
+          allow_blank:
+            positive: "allowing blank values"
+            negative: "not allowing blank values"
+