remarkable_activerecord 3.1.6 → 3.1.7

data/CHANGELOG

@@ -1,98 +1,100 @@
-* Added :token and :separator to deal with :tokenizer in validates_length_of [#77]
+* Ensure quick subject bypass protected attributes [#87]
 
-* Deprecated validate_format_of. It does not have the same API as the respective
-  ActiveRecord macro, raising questions frequentely about its usage [#76]
-
-* allow_mass_assignment_of when called without arguments checks if any mass
-  assignment is possible [#80]
-
-* Add :table_name option to have_index (thanks to Lawrence Pit) [#79]
-
-* Allow default subject attributes to be given [#74]
-  You can even mix with a fixture replacement tool and still use quick subjects:
-
-    describe Post
-      # Fixjour example
-      subject_attributes { valid_post_attributes }
-
-      describe :published => true do
-        should_validate_presence_of :published_at
-      end
-    end
-
-* Bug fix when a symbol is given has join table to habtm association [#75]
-
-* Association matchers now searches in the right database for tables [#73]
-
-* validate_length_of accepts :with_kind_of to enable it to work with associations [#69]
-  In your Post specs now you can write:
-
-    should_validate_length_of :comments, :maximum => 10, :with_kind_of => Comment
-
-# v3.1
-
-* Allow validate_presence_of to work with associations [#63]
-
-* Allow validate_uniqueness_of to work when scopes are not stringfiable values.
-  You can now give timestamps, datetime, date and boolean as scopes [#60]
-
-* Allow subjects to be overwriten quickly (quick subjects):
-
-    describe Post
-      should_validate_presente_of :title
- 
-      describe :published => true do
-        should_validate_presence_of :published_at
-      end
+* Added :token and :separator to deal with :tokenizer in validates_length_of [#77]
+
+* Deprecated validate_format_of. It does not have the same API as the respective
+  ActiveRecord macro, raising questions frequentely about its usage [#76]
+
+* allow_mass_assignment_of when called without arguments checks if any mass
+  assignment is possible [#80]
+
+* Add :table_name option to have_index (thanks to Lawrence Pit) [#79]
+
+* Allow default subject attributes to be given [#74]
+  You can even mix with a fixture replacement tool and still use quick subjects:
+
+    describe Post
+      # Fixjour example
+      subject_attributes { valid_post_attributes }
+
+      describe :published => true do
+        should_validate_presence_of :published_at
+      end
     end
- 
-  Is the same as:
-
-    describe Post
-      should_validate_presente_of :title
- 
-      describe "when published is true" do
-        subject { Post.new(:published => true) }
-        should_validate_presence_of :published_at
-      end
-    end
-
-  And the string can be also localized using I18n [#57]
-
-[COMPATIBILITY] validate_associated no longer accepts a block to confgure the
-builder:
-
-    should_validate_associated(:tasks){ |p| p.tasks.build(:captcha => 'i_am_a_robot') }
-
-The right way to do this is by giving an option called builder and a proc:
-
-    should_validate_associated :tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_robot') }
-
-* validate_uniqueness_of and accept_nested_attributes_for now use the new
-  interpolation option {{sentence}} [#58]
-
-* Added accept_nested_attributes_for matcher [#39]
-
-* Added have_default_scope matcher [#38]
-
-* Allow :conditions, :include, :joins, :limit, :offset, :order, :select, :readonly,
-  :group, :having, :from, :lock as quick accessors to have_scope matcher
-
-* Allow all kind of objects to be sent to have_scope (including datetimes, arrays,
-  booleans and nil) (thanks to Szymon Nowak and Nolan Eakins) [#53]
-
-* Added support to sql options in association_matcher: select, conditions, include,
-  group, having, order, limit and offset, plus finder_sql and counter_sql. [#48]
-
-* :source and :source_type are now supported by association matcher [#47]
-
-* validate_inclusion_of became smarter since it now tests invalid values too [#36]
-
-* Fixed three bugs in validate_uniqueness_of matcher [#42] [#40] [#37]
-
+
+* Bug fix when a symbol is given has join table to habtm association [#75]
+
+* Association matchers now searches in the right database for tables [#73]
+
+* validate_length_of accepts :with_kind_of to enable it to work with associations [#69]
+  In your Post specs now you can write:
+
+    should_validate_length_of :comments, :maximum => 10, :with_kind_of => Comment
+
+# v3.1
+
+* Allow validate_presence_of to work with associations [#63]
+
+* Allow validate_uniqueness_of to work when scopes are not stringfiable values.
+  You can now give timestamps, datetime, date and boolean as scopes [#60]
+
+* Allow subjects to be overwriten quickly (quick subjects):
+
+    describe Post
+      should_validate_presente_of :title
+ 
+      describe :published => true do
+        should_validate_presence_of :published_at
+      end
+    end
+ 
+  Is the same as:
+
+    describe Post
+      should_validate_presente_of :title
+ 
+      describe "when published is true" do
+        subject { Post.new(:published => true) }
+        should_validate_presence_of :published_at
+      end
+    end
+
+  And the string can be also localized using I18n [#57]
+
+[COMPATIBILITY] validate_associated no longer accepts a block to confgure the
+builder:
+
+    should_validate_associated(:tasks){ |p| p.tasks.build(:captcha => 'i_am_a_robot') }
+
+The right way to do this is by giving an option called builder and a proc:
+
+    should_validate_associated :tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_robot') }
+
+* validate_uniqueness_of and accept_nested_attributes_for now use the new
+  interpolation option {{sentence}} [#58]
+
+* Added accept_nested_attributes_for matcher [#39]
+
+* Added have_default_scope matcher [#38]
+
+* Allow :conditions, :include, :joins, :limit, :offset, :order, :select, :readonly,
+  :group, :having, :from, :lock as quick accessors to have_scope matcher
+
+* Allow all kind of objects to be sent to have_scope (including datetimes, arrays,
+  booleans and nil) (thanks to Szymon Nowak and Nolan Eakins) [#53]
+
+* Added support to sql options in association_matcher: select, conditions, include,
+  group, having, order, limit and offset, plus finder_sql and counter_sql. [#48]
+
+* :source and :source_type are now supported by association matcher [#47]
+
+* validate_inclusion_of became smarter since it now tests invalid values too [#36]
+
+* Fixed three bugs in validate_uniqueness_of matcher [#42] [#40] [#37]
+
 # v3.0
 
-* Added more options to associations matcher. Previously it was handling just
+* Added more options to associations matcher. Previously it was handling just
 :dependent and :through options. Now it deals with:
 
   :through, :class_name, :foreign_key, :dependent, :join_table, :uniq,
@@ -130,9 +132,9 @@ subject definitions on rspec. This was also fixed.
 
 # v2.x
 
-* Added associations, allow_mass_assignment, allow_values_for, have_column,
-have_index, have_scope, have_readonly_attributes, validate_acceptance_of,
-validate_associated, validate_confirmation_of, validate_exclusion_of,
-validate_inclusion_of, validate_length_of, validate_numericality_of,
+* Added associations, allow_mass_assignment, allow_values_for, have_column,
+have_index, have_scope, have_readonly_attributes, validate_acceptance_of,
+validate_associated, validate_confirmation_of, validate_exclusion_of,
+validate_inclusion_of, validate_length_of, validate_numericality_of,
 validate_presence_of and validate_uniqueness_of matchers.
 

data/lib/remarkable_activerecord/base.rb

@@ -1,6 +1,7 @@
 module Remarkable
   module ActiveRecord
-    class Base < Remarkable::Base
+    class Base < Remarkable::Base
+      I18N_COLLECTION = [ :attributes, :associations ]
 
       # Provides a way to send options to all ActiveRecord matchers.
       #
@@ -206,12 +207,14 @@ module Remarkable
             @spec.send(:described_class)
           end
 
-          if RAILS_I18N && described_class.respond_to?(:human_attribute_name) && self.class.matcher_arguments[:collection]
+          if i18n_collection? && described_class.respond_to?(:human_attribute_name)
             options = {}
 
             collection_name = self.class.matcher_arguments[:collection].to_sym
             if collection = instance_variable_get("@#{collection_name}")
-              collection.map!{|attr| described_class.human_attribute_name(attr.to_s, :locale => Remarkable.locale).downcase }
+              collection = collection.map do |attr|
+                described_class.human_attribute_name(attr.to_s, :locale => Remarkable.locale).downcase
+              end
               options[collection_name] = array_to_sentence(collection)
             end
 
@@ -225,6 +228,12 @@ module Remarkable
           else
             super
           end
+        end
+
+        # Returns true if the given collection should be translated.
+        #
+        def i18n_collection? #:nodoc:
+          RAILS_I18N && I18N_COLLECTION.include?(self.class.matcher_arguments[:collection])
         end
 
     end

data/lib/remarkable_activerecord/describe.rb

@@ -137,7 +137,7 @@ module Remarkable
             #
             example_group = super(*args) do
               write_inheritable_hash(:describe_subject_attributes, attributes)
-              subject { self.class.described_class.new(subject_attributes) }
+              set_described_subject!
               instance_eval(&block)
             end
           else
@@ -160,9 +160,16 @@ module Remarkable
         #
         def subject_attributes(options=nil, &block)
           write_inheritable_attribute(:default_subject_attributes, options || block)
-          subject { self.class.described_class.new(subject_attributes) }
+          set_described_subject!
         end
 
+        def set_described_subject!
+          subject {
+            record = self.class.described_class.new
+            record.send(:attributes=, subject_attributes, false)
+            record
+          }
+        end
       end
 
       # Returns a hash with the subject attributes declared using the
@@ -186,7 +193,7 @@ module Remarkable
 
         default.merge(self.class.describe_subject_attributes || {})
       end
-
+
     end
   end
 end

data/lib/remarkable_activerecord/matchers/allow_mass_assignment_of_matcher.rb

@@ -3,18 +3,18 @@ module Remarkable
     module Matchers
       class AllowMassAssignmentOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
         arguments :collection => :attributes, :as => :attribute
-
+
         assertion :allows?
         collection_assertions :is_protected?, :is_accessible?
 
         protected
-
-          # If no attribute is given, check if no attribute is being protected,
-          # otherwise it fails.
-          #
-          def allows?
-            !@attributes.empty? || protected_attributes.empty?
-          end
+
+          # If no attribute is given, check if no attribute is being protected,
+          # otherwise it fails.
+          #
+          def allows?
+            !@attributes.empty? || protected_attributes.empty?
+          end
 
           def is_protected?
             protected_attributes.empty? || !protected_attributes.include?(@attribute.to_s)
@@ -22,28 +22,41 @@ module Remarkable
 
           def is_accessible?
             accessible_attributes.empty? || accessible_attributes.include?(@attribute.to_s)
-          end
-
-          def interpolation_options
-            if @subject
-              { :protected_attributes => array_to_sentence(protected_attributes.to_a, false, '[]') }
-            else
-              {}
-            end
-          end
-
-        private
-
-          def accessible_attributes
-            @accessible_attributes ||= subject_class.accessible_attributes || []
-          end
-
-          def protected_attributes
-            @protected_attributes ||= subject_class.protected_attributes || []
+          end
+
+          def interpolation_options
+            if @subject
+              { :protected_attributes => array_to_sentence(protected_attributes.to_a, false, '[]') }
+            else
+              {}
+            end
+          end
+
+        private
+
+          def accessible_attributes
+            @accessible_attributes ||= subject_class.accessible_attributes || []
+          end
+
+          def protected_attributes
+            @protected_attributes ||= subject_class.protected_attributes || []
           end
       end
 
-      # Ensures that the attribute can be set on mass update.
+      # Ensures that the attribute can be set on mass update.
+      #
+      # Beware that when used in the negative form, this matcher fails if any of
+      # the values fail. For example, let's assume we have a accessible and a
+      # protected attribute called :accessible and :protected. The following
+      # assertion WILL pass:
+      #
+      #   should_not_allow_mass_assignment_of :protected, :accessible
+      #
+      # If you want to assert that all values fail, you have to do:
+      #
+      #   %w(first_protected second_protected).each do |protected|
+      #     should_not_allow_mass_assignment_of protected
+      #   end
       #
       # == Examples
       #

data/lib/remarkable_activerecord/matchers/allow_values_for_matcher.rb

@@ -63,10 +63,19 @@ module Remarkable
 
       end
 
-      # 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 "validate_format_of".
+      # Ensures that the attribute can be set to the given values.
+      #
+      # Beware that when used in the negative form, this matcher fails if any of
+      # the values fail. For example, let's assume we have a valid and invalid
+      # value called "valid" and "invalid". The following assertion WILL pass:
+      #
+      #   should_not_allow_values_for :attribute, "valid", "invalid"
+      #
+      # If you want to assert that all values fail, you have to do:
+      #
+      #   %w(first_invalid second_invalid).each do |invalid|
+      #     should_not_allow_values_for invalid
+      #   end
       #
       # == Options
       #
@@ -78,25 +87,22 @@ module Remarkable
       # == Examples
       #
       #   should_allow_values_for :isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0"
-      #   should_not_allow_values_for :isbn, "bad 1", "bad 2"
-      #
       #   it { should allow_values_for(:isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0") }
-      #   it { should_not allow_values_for(:isbn, "bad 1", "bad 2") }
       #
       def allow_values_for(attribute, *args, &block)
         options = args.extract_options!
         AllowValuesForMatcher.new(attribute, options.merge!(:in => args), &block).spec(self)
-      end
-
-      # Deprecated. Use allow_values_for instead.
-      #
-      def validate_format_of(*args)
-        if caller[0] =~ /\macros.rb/
-          warn "[DEPRECATION] should_validate_format_of is deprecated, use should_allow_values_for instead."
-        else
-          warn "[DEPRECATION] validate_format_of is deprecated, use allow_values_for instead. Called from #{caller[0]}."
-        end
-        allow_values_for(*args)
+      end
+
+      # Deprecated. Use allow_values_for instead.
+      #
+      def validate_format_of(*args)
+        if caller[0] =~ /\macros.rb/
+          warn "[DEPRECATION] should_validate_format_of is deprecated, use should_allow_values_for instead."
+        else
+          warn "[DEPRECATION] validate_format_of is deprecated, use allow_values_for instead. Called from #{caller[0]}."
+        end
+        allow_values_for(*args)
       end
 
     end

data/lib/remarkable_activerecord/matchers/association_matcher.rb

@@ -4,11 +4,11 @@ module Remarkable
       class AssociationMatcher < Remarkable::ActiveRecord::Base #:nodoc:
         arguments :macro, :collection => :associations, :as => :association
 
-        optionals :through, :source, :source_type, :class_name, :foreign_key, :dependent, :join_table, :as
+        optionals :through, :source, :source_type, :class_name, :foreign_key, :dependent, :join_table, :as
         optionals :select, :conditions, :include, :group, :having, :order, :limit, :offset, :finder_sql, :counter_sql
         optionals :uniq, :readonly, :validate, :autosave, :polymorphic, :counter_cache, :default => true
 
-        collection_assertions :association_exists?, :macro_matches?, :through_exists?, :source_exists?,
+        collection_assertions :association_exists?, :macro_matches?, :through_exists?, :source_exists?,
                               :klass_exists?, :join_table_exists?, :foreign_key_exists?, :polymorphic_exists?,
                               :counter_cache_exists?, :options_match?
 
@@ -16,38 +16,38 @@ module Remarkable
 
           def association_exists?
             reflection
-          end
-
+          end
+
           def macro_matches?
             reflection.macro == @macro
           end
 
           def through_exists?
-            return true unless @options.key?(:through)
+            return true unless @options.key?(:through)
             reflection.through_reflection rescue false
-          end
-
-          def source_exists?
-            return true unless @options.key?(:through)
-            reflection.source_reflection rescue false
-          end
-
-          # Polymorphic associations does not have a klass.
-          #
-          def klass_exists?
-            return true if @options[:polymorphic]
-            reflection.klass rescue nil
           end
-
-          # has_and_belongs_to_many only works if the tables are in the same
-          # database, so we always look for the table in the subject connection.
+
+          def source_exists?
+            return true unless @options.key?(:through)
+            reflection.source_reflection rescue false
+          end
+
+          # Polymorphic associations does not have a klass.
+          #
+          def klass_exists?
+            return true if @options[:polymorphic]
+            reflection.klass rescue nil
+          end
+
+          # has_and_belongs_to_many only works if the tables are in the same
+          # database, so we always look for the table in the subject connection.
           #
           def join_table_exists?
             return true unless reflection.macro == :has_and_belongs_to_many
             subject_class.connection.tables.include?(reflection.options[:join_table].to_s)
           end
 
-          def foreign_key_exists?
+          def foreign_key_exists?
             return true unless foreign_key_table
             table_has_column?(foreign_key_table_class, foreign_key_table, reflection_foreign_key)
           end
@@ -61,18 +61,18 @@ module Remarkable
             return true unless @options[:counter_cache]
             klass_table_has_column?(reflection.klass, reflection.counter_cache_column.to_s)
           end
-
-          def options_match?
-            actual_options = {}
-
-            @options.keys.each do |key|
-              method = :"reflection_#{key}"
-
-              @options[key]       = @options[key].to_s
-              actual_options[key] = (respond_to?(method, true) ? send(method) : reflection.options[key]).to_s
-            end
-
-            return @options == actual_options, :actual => actual_options.inspect
+
+          def options_match?
+            actual_options = {}
+
+            @options.keys.each do |key|
+              method = :"reflection_#{key}"
+
+              @options[key]       = @options[key].to_s
+              actual_options[key] = (respond_to?(method, true) ? send(method) : reflection.options[key]).to_s
+            end
+
+            return @options == actual_options, :actual => actual_options.inspect
           end
 
         private
@@ -80,15 +80,15 @@ module Remarkable
           def reflection
             @reflection ||= subject_class.reflect_on_association(@association.to_sym)
           end
-
+
           def subject_table_name
             subject_class.table_name.to_s
-          end
+          end
 
           def reflection_class_name
             reflection.class_name.to_s rescue nil
-          end
-
+          end
+
           def reflection_table_name
             reflection.klass.table_name.to_s rescue nil
           end
@@ -99,24 +99,24 @@ module Remarkable
 
           def table_has_column?(klass, table_name, column)
             klass.connection.columns(table_name, 'Remarkable column retrieval').any?{|c| c.name == column }
-          end
-
-          def klass_table_has_column?(klass, column)
-            table_has_column?(klass, klass.table_name, column)
           end
 
-          # In through we don't check the foreign_key, because it's spread
-          # accross the through and the source reflection which should be tested
-          # with their own macros.
-          #
+          def klass_table_has_column?(klass, column)
+            table_has_column?(klass, klass.table_name, column)
+          end
+
+          # In through we don't check the foreign_key, because it's spread
+          # accross the through and the source reflection which should be tested
+          # with their own macros.
+          #
           # In cases a join table exists (has_and_belongs_to_many and through
           # associations), we check the foreign key in the join table.
           #
           # On belongs to, the foreign_key is in the subject class table and in
           # other cases it's on the reflection class table.
           #
-          def foreign_key_table
-            if reflection.options.key?(:through)
+          def foreign_key_table
+            if reflection.options.key?(:through)
               nil
             elsif reflection.macro == :has_and_belongs_to_many
               reflection.options[:join_table]
@@ -125,22 +125,22 @@ module Remarkable
             else
               reflection_table_name
             end
-          end
-
-          # Returns the foreign key table class to use the proper connection
-          # when searching for the table and foreign key.
-          #
-          def foreign_key_table_class
+          end
+
+          # Returns the foreign key table class to use the proper connection
+          # when searching for the table and foreign key.
+          #
+          def foreign_key_table_class
             if [:belongs_to, :has_and_belongs_to_many].include?(reflection.macro)
               subject_class
             else
               reflection.klass
-            end
-          end
+            end
+          end
 
           def interpolation_options
-            options = {}
-            options[:macro]   = Remarkable.t(@macro, :scope => matcher_i18n_scope, :default => @macro.to_s.gsub("_", ""))
+            options = {}
+            options[:macro]   = Remarkable.t(@macro, :scope => matcher_i18n_scope, :default => @macro.to_s.gsub("_", ""))
             options[:options] = @options.inspect
 
             if @subject && reflection
@@ -150,8 +150,8 @@ module Remarkable
                 :reflection_table     => reflection_table_name.inspect,
                 :foreign_key_table    => foreign_key_table.inspect,
                 :polymorphic_column   => reflection_foreign_key.sub(/_id$/, '_type').inspect,
-                :counter_cache_column => reflection.counter_cache_column.to_s.inspect,
-                :join_table           => reflection.options[:join_table].inspect,
+                :counter_cache_column => reflection.counter_cache_column.to_s.inspect,
+                :join_table           => reflection.options[:join_table].inspect,
                 :foreign_key          => reflection_foreign_key.inspect
               )
             end
@@ -175,9 +175,9 @@ module Remarkable
       #   It also checks if the column actually exists in the table.
       # * <tt>:polymorphic</tt> - if the association should be polymorphic or not.
       #   When true it also checks for the association_type column in the subject table.
-      #
-      # Plus all supported sql conditions options: :select, :conditions, :order,
-      # :limit, :offset, :include, :group, :having.
+      #
+      # Plus all supported sql conditions options: :select, :conditions, :order,
+      # :limit, :offset, :include, :group, :having.
       #
       # == Examples
       #
@@ -199,9 +199,9 @@ module Remarkable
       # * <tt>:uniq</tt>     - checks wether uniq is true or false.
       # * <tt>:readonly</tt> - checks wether readonly is true or false.
       # * <tt>:validate</tt> - checks wether validate is true or false.
-      # * <tt>:autosave</tt> - checks wether autosave is true or false.
-      #
-      # Plus all supported sql conditions options: :select, :conditions, :order,
+      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      #
+      # Plus all supported sql conditions options: :select, :conditions, :order,
       # :limit, :offset, :include, :group, :having.
       #
       # == Examples
@@ -221,8 +221,8 @@ module Remarkable
       #
       # * <tt>:class_name</tt>  - the expected associted class name.
       # * <tt>:through</tt>     - the expected join model which to perform the query.
-      #   It also checks if the through table exists.
-      # * <tt>:source</tt>      - the source of the through association.
+      #   It also checks if the through table exists.
+      # * <tt>:source</tt>      - the source of the through association.
       # * <tt>:source_type</tt> - the source type of the through association.
       # * <tt>:foreign_key</tt> - the expected foreign key in the associated table.
       #   When used with :through, it will check for the foreign key in the join table.
@@ -230,9 +230,9 @@ module Remarkable
       # * <tt>:uniq</tt>     - checks wether uniq is true or false.
       # * <tt>:readonly</tt> - checks wether readonly is true or false.
       # * <tt>:validate</tt> - checks wether validate is true or false.
-      # * <tt>:autosave</tt> - checks wether autosave is true or false.
-      #
-      # Plus all supported sql conditions options: :select, :conditions, :order,
+      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      #
+      # Plus all supported sql conditions options: :select, :conditions, :order,
       # :limit, :offset, :include, :group, :having.
       #
       # == Examples
@@ -257,16 +257,16 @@ module Remarkable
       #
       # * <tt>:class_name</tt>  - the expected associted class name.
       # * <tt>:through</tt>     - the expected join model which to perform the query.
-      #   It also checks if the through table exists.
-      # * <tt>:source</tt>      - the source of the through association.
+      #   It also checks if the through table exists.
+      # * <tt>:source</tt>      - the source of the through association.
       # * <tt>:source_type</tt> - the source type of the through association.
       # * <tt>:foreign_key</tt> - the expected foreign key in the associated table.
       #   When used with :through, it will check for the foreign key in the join table.
       # * <tt>:dependent</tt>   - the expected dependent value for the association.
       # * <tt>:validate</tt> - checks wether validate is true or false.
-      # * <tt>:autosave</tt> - checks wether autosave is true or false.
-      #
-      # Plus all supported sql conditions options: :select, :conditions, :order,
+      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      #
+      # Plus all supported sql conditions options: :select, :conditions, :order,
       # :limit, :offset, :include, :group, :having.
       #
       # == Examples

data/lib/remarkable_activerecord/matchers/have_scope_matcher.rb

@@ -5,9 +5,9 @@ module Remarkable
         arguments :scope_name
         assertions :is_scope?, :options_match?
 
-        optionals :with, :splat => true
-        optionals :conditions, :include, :joins, :limit, :offset, :order, :select,
-                  :readonly, :group, :having, :from, :lock
+        optionals :with, :splat => true
+        optionals :conditions, :include, :joins, :limit, :offset, :order, :select,
+                  :readonly, :group, :having, :from, :lock
 
         protected
 
@@ -41,8 +41,8 @@ module Remarkable
       #
       # * <tt>with</tt> - Options to be sent to the named scope
       #
-      # All options that the named scope would pass on to find: :conditions,
-      # :include, :joins, :limit, :offset, :order, :select, :readonly, :group,
+      # All options that the named scope would pass on to find: :conditions,
+      # :include, :joins, :limit, :offset, :order, :select, :readonly, :group,
       # :having, :from, :lock.
       #
       # == Examples

data/lib/remarkable_activerecord/matchers/validate_exclusion_of_matcher.rb

@@ -10,12 +10,12 @@ module Remarkable
         protected
 
           def valid_values
-            if @in_range
-              [ @options[:in].first - 1, @options[:in].last + 1 ]
-            elsif @options[:in].empty?
-              []
-            else
-              [ @options[:in].map(&:to_s).max.to_s.next ]
+            if @in_range
+              [ @options[:in].first - 1, @options[:in].last + 1 ]
+            elsif @options[:in].empty?
+              []
+            else
+              [ @options[:in].map(&:to_s).max.to_s.next ]
             end
           end
 
@@ -26,9 +26,9 @@ module Remarkable
       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.
-      #
-      # If you give that :username does not accept ["admin", "user"], it will
+      # is given, ensures that the attribute is not valid in the given range.
+      #
+      # If you give that :username does not accept ["admin", "user"], it will
       # test that "uses" (the next of the array max value) is allowed.
       #
       # == Options

data/lib/remarkable_activerecord/matchers/validate_inclusion_of_matcher.rb

@@ -14,21 +14,21 @@ module Remarkable
           end
 
           def invalid_values
-            if @in_range
-              [ @options[:in].first - 1, @options[:in].last + 1 ]
-            elsif @options[:in].empty?
-              []
-            else
-              [ @options[:in].map(&:to_s).max.to_s.next ]
+            if @in_range
+              [ @options[:in].first - 1, @options[:in].last + 1 ]
+            elsif @options[:in].empty?
+              []
+            else
+              [ @options[:in].map(&:to_s).max.to_s.next ]
             end
           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.
-      #
-      # If you give that :size accepts ["S", "M", "L"], it will test that "T"
+      # is given, ensures that the attribute is valid in the given range.
+      #
+      # If you give that :size accepts ["S", "M", "L"], it will test that "T"
       # (the next of the array max value) is not allowed.
       #
       # == Options

data/lib/remarkable_activerecord/matchers/validate_length_of_matcher.rb

@@ -5,10 +5,10 @@ module Remarkable
         arguments :collection => :attributes, :as => :attribute
 
         optional :within, :alias => :in
-        optional :minimum, :maximum, :is
+        optional :minimum, :maximum, :is
         optional :token, :separator, :with_kind_of
         optional :allow_nil, :allow_blank, :default => true
-        optional :message, :too_short, :too_long, :wrong_length
+        optional :message, :too_short, :too_long, :wrong_length
 
         collection_assertions :less_than_min_length?, :exactly_min_length?,
                               :more_than_max_length?, :exactly_max_length?,
@@ -56,12 +56,12 @@ module Remarkable
             @max_value.nil? || @min_value == @max_value || good?(value_for_length(@max_value), default_message_for(:too_long))
           end
 
-          def value_for_length(value)
-            if @options[:with_kind_of]
-              [@options[:with_kind_of].new] * value
-            else
-              ([@options.fetch(:token, 'x')] * value).join(@options.fetch(:separator, ''))
-            end
+          def value_for_length(value)
+            if @options[:with_kind_of]
+              [@options[:with_kind_of].new] * value
+            else
+              ([@options.fetch(:token, 'x')] * value).join(@options.fetch(:separator, ''))
+            end
           end
 
           def interpolation_options
@@ -101,23 +101,23 @@ module Remarkable
       #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.wrong_length') % range.last</tt>
       # * <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.wrong_length') % value</tt>
-      #
-      # It also accepts an extra option called :with_kind_of. If you are validating
-      # the size of an association array, you have to specify the kind of the array
-      # being validated. For example, if your post accepts maximum 10 comments, you
-      # can do:
-      #
-      #   should_validate_length_of :comments, :maximum => 10, :with_kind_of => Comment
-      #
-      # Finally, it also accepts :token and :separator, to specify how the
-      # tokenizer should work. For example, if you are splitting the attribute
-      # per word:
-      #
-      #   validates_length_of :essay, :minimum => 100, :tokenizer => lambda {|str| str.scan(/\w+/) }
-      #
-      # You could do this:
-      #
-      #   should_validate_length_of :essay, :minimum => 100, :token => "word", :separator => " "
+      #
+      # It also accepts an extra option called :with_kind_of. If you are validating
+      # the size of an association array, you have to specify the kind of the array
+      # being validated. For example, if your post accepts maximum 10 comments, you
+      # can do:
+      #
+      #   should_validate_length_of :comments, :maximum => 10, :with_kind_of => Comment
+      #
+      # Finally, it also accepts :token and :separator, to specify how the
+      # tokenizer should work. For example, if you are splitting the attribute
+      # per word:
+      #
+      #   validates_length_of :essay, :minimum => 100, :tokenizer => lambda {|str| str.scan(/\w+/) }
+      #
+      # You could do this:
+      #
+      #   should_validate_length_of :essay, :minimum => 100, :token => "word", :separator => " "
       #
       # == Gotcha
       #
@@ -131,16 +131,16 @@ module Remarkable
       #   it { should validate_length_of(:password).maximum(20) }
       #   it { should validate_length_of(:password).minimum(6) }
       #   it { should validate_length_of(:age).is(18) }
-      #
+      #
       #   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
-      #
-      #   should_validate_length_of :password do |m|
-      #     m.minimum 6
-      #     m.maximum 20
-      #   end
+      #   should_validate_length_of :age, :is => 18
+      #
+      #   should_validate_length_of :password do |m|
+      #     m.minimum 6
+      #     m.maximum 20
+      #   end
       #
       def validate_length_of(*attributes, &block)
         ValidateLengthOfMatcher.new(*attributes, &block).spec(self)

data/locale/en.yml

@@ -1,13 +1,13 @@
 en:
   remarkable:
-    active_record:
-      describe:
-        each: "{{key}} is {{value}}"
-        prepend: "when "
-        connector: " and "
+    active_record:
+      describe:
+        each: "{{key}} is {{value}}"
+        prepend: "when "
+        connector: " and "
       expectations:
         allow_nil: "{{subject_name}} to {{not}}allow nil values for {{attribute}}"
-        allow_blank: "{{subject_name}} to {{not}}allow blank values for {{attribute}}"
+        allow_blank: "{{subject_name}} to {{not}}allow blank values for {{attribute}}"
       optionals:
         allow_nil:
           positive: "allowing nil values"
@@ -15,24 +15,24 @@ en:
         allow_blank:
           positive: "allowing blank values"
           negative: "not allowing blank values"
-
-      accept_nested_attributes_for:
-        description: "accept nested attributes for {{associations}}"
-        expectations:
-          association_exists: "{{subject_name}} to have association {{association}}, but does not"
-          is_autosave: "{{subject_name}} to have association {{association}} with autosave true, got false"
-          responds_to_attributes: "{{subject_name}} to respond to :{{association}}_attributes=, but does not"
-          allows_destroy: "{{subject_name}} with allow destroy equals to {{allow_destroy}}, got {{actual}}"
-          accepts: "{{subject_name}} to accept attributes {{attributes}} for {{association}}, but does not"
-          rejects: "{{subject_name}} to reject attributes {{attributes}} for {{association}}, but does not"
-        optionals:
-          allow_destroy:
-            positive: "allowing destroy"
-            negative: "not allowing destroy"
-          accept:
-            positive: "accepting {{sentence}}"
-          reject:
-            positive: "rejecting {{sentence}}"
+
+      accept_nested_attributes_for:
+        description: "accept nested attributes for {{associations}}"
+        expectations:
+          association_exists: "{{subject_name}} to have association {{association}}, but does not"
+          is_autosave: "{{subject_name}} to have association {{association}} with autosave true, got false"
+          responds_to_attributes: "{{subject_name}} to respond to :{{association}}_attributes=, but does not"
+          allows_destroy: "{{subject_name}} with allow destroy equals to {{allow_destroy}}, got {{actual}}"
+          accepts: "{{subject_name}} to accept attributes {{attributes}} for {{association}}, but does not"
+          rejects: "{{subject_name}} to reject attributes {{attributes}} for {{association}}, but does not"
+        optionals:
+          allow_destroy:
+            positive: "allowing destroy"
+            negative: "not allowing destroy"
+          accept:
+            positive: "accepting {{sentence}}"
+          reject:
+            positive: "rejecting {{sentence}}"
 
       allow_values_for:
         description: "allow {{in}} as values for {{attributes}}"
@@ -41,7 +41,7 @@ en:
 
       allow_mass_assignment_of:
         description: "allow mass assignment of {{attributes}}"
-        expectations:
+        expectations:
           allows: "{{subject_name}} to allow mass assignment ({{subject_name}} is protecting {{protected_attributes}})"
           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)"
@@ -53,22 +53,22 @@ en:
         has_one: have one
         description: "{{macro}} {{associations}}"
         expectations:
-          association_exists: "{{subject_name}} records {{macro}} {{association}}, but the association does not exist"
+          association_exists: "{{subject_name}} records {{macro}} {{association}}, but the association does not exist"
           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"
-          source_exists: "{{subject_name}} records {{macro}} {{association}} through {{through}}, source association does not exist"
+          through_exists: "{{subject_name}} records {{macro}} {{association}} through {{through}}, through association does not exist"
+          source_exists: "{{subject_name}} records {{macro}} {{association}} through {{through}}, source association does not exist"
           klass_exists: "{{subject_name}} records {{macro}} {{association}}, but the association class does not exist"
           join_table_exists: "join table {{join_table}} to exist, but does not"
           foreign_key_exists: "foreign key {{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"
+          counter_cache_exists: "{{reflection_table}} to have {{counter_cache_column}} as column, but does not"
           options_match: "{{subject_name}} records {{macro}} {{association}} with options {{options}}, got {{actual}}"
         optionals:
           through:
-            positive: "through {{value}}"
-          source:
-            positive: "with source {{inspect}}"
-          source_type:
+            positive: "through {{value}}"
+          source:
+            positive: "with source {{inspect}}"
+          source_type:
             positive: "with source type {{inspect}}"
           class_name:
             positive: "with class name {{inspect}}"
@@ -94,23 +94,23 @@ en:
             positive: "through the polymorphic interface {{inspect}}"
           counter_cache:
             positive: "with counter cache {{inspect}}"
-            negative: "without counter cache"
-          select:
-            positive: "selecting {{inspect}}"
-          conditions:
-            positive: "with conditions {{inspect}}"
-          include:
-            positive: "including {{inspect}}"
-          group:
-            positive: "grouping by {{inspect}}"
-          having:
-            positive: "having {{inspect}}"
-          order:
-            positive: "with order {{inspect}}"
-          limit:
-            positive: "with limit {{inspect}}"
-          offset:
-            positive: "with offset {{inspect}}"
+            negative: "without counter cache"
+          select:
+            positive: "selecting {{inspect}}"
+          conditions:
+            positive: "with conditions {{inspect}}"
+          include:
+            positive: "including {{inspect}}"
+          group:
+            positive: "grouping by {{inspect}}"
+          having:
+            positive: "having {{inspect}}"
+          order:
+            positive: "with order {{inspect}}"
+          limit:
+            positive: "with limit {{inspect}}"
+          offset:
+            positive: "with offset {{inspect}}"
 
       have_column:
         description: "have column(s) named {{columns}}"
@@ -127,8 +127,8 @@ en:
             positive: "with default value {{inspect}}"
             negative: "with default value {{inspect}}"
           limit:
-            positive: "with limit {{inspect}}"
-
+            positive: "with limit {{inspect}}"
+
       have_default_scope:
         description: "have a default scope with {{options}}"
         expectations:
@@ -142,8 +142,8 @@ en:
         optionals:
           unique:
             positive: "with unique values"
-            negative: "with non unique values"
-          table_name:
+            negative: "with non unique values"
+          table_name:
             positive: "on table {{value}}"
 
       have_readonly_attributes:
@@ -207,8 +207,8 @@ en:
           minimum:
             positive: "is minimum {{inspect}} characters"
           is:
-            positive: "is equal to {{inspect}} characters"
-          with_kind_of:
+            positive: "is equal to {{inspect}} characters"
+          with_kind_of:
             positive: "with kind of {{value}}"
 
       validate_numericality_of:
@@ -257,4 +257,4 @@ en:
           case_sensitive:
             positive: "case sensitive"
             negative: "case insensitive"
-
+

data/spec/allow_mass_assignment_of_matcher_spec.rb

@@ -20,14 +20,14 @@ describe 'allow_mass_assignment_of' do
       @matcher = allow_mass_assignment_of(:title, :category)
       @matcher.description.should == 'allow mass assignment of title and category'
     end
-
-    it 'should set allows? message' do
+
+    it 'should set allows? message' do
       define_and_validate(:protected => true)
       @matcher = allow_mass_assignment_of
       @matcher.matches?(@model)
       @matcher.failure_message.should == 'Expected Product to allow mass assignment (Product is protecting category and title)'
-    end
-
+    end
+
     it 'should set is_protected? message' do
       @matcher = define_and_validate(:protected => true)
       @matcher.matches?(@model)
@@ -47,23 +47,23 @@ describe 'allow_mass_assignment_of' do
     it { should define_and_validate(:accessible => true) }
 
     it { should_not define_and_validate(:protected => true) }
-    it { should_not define_and_validate(:accessible => [:another]) }
-
-    describe 'with no argument' do
-      it 'should allow mass assignment if no attribute is accessible or protected' do
-        define_and_validate
-        should allow_mass_assignment_of
-      end
-
-      it 'should allow mass assignment if attributes are accessible' do
-        define_and_validate(:accessible => true)
-        should allow_mass_assignment_of
-      end
-
-      it 'should not allow mass assignment if attributes are protected' do
-        define_and_validate(:protected => true)
-        should_not allow_mass_assignment_of
-      end
+    it { should_not define_and_validate(:accessible => [:another]) }
+
+    describe 'with no argument' do
+      it 'should allow mass assignment if no attribute is accessible or protected' do
+        define_and_validate
+        should allow_mass_assignment_of
+      end
+
+      it 'should allow mass assignment if attributes are accessible' do
+        define_and_validate(:accessible => true)
+        should allow_mass_assignment_of
+      end
+
+      it 'should not allow mass assignment if attributes are protected' do
+        define_and_validate(:protected => true)
+        should_not allow_mass_assignment_of
+      end
     end
   end
 

data/spec/allow_values_for_matcher_spec.rb

@@ -49,13 +49,13 @@ describe 'allow_values_for' do
   describe 'macros' do
     before(:each){ define_and_validate(:with => /X|Y|Z/) }
 
-    should_allow_values_for :title, 'X'
-    should_not_allow_values_for :title, 'A'
-
-    describe 'deprecation' do
-      it { should validate_format_of(:title, 'X') }
-      should_not_validate_format_of :title, 'A'
-    end
+    should_allow_values_for :title, 'X'
+    should_not_allow_values_for :title, 'A'
+
+    describe 'deprecation' do
+      it { should validate_format_of(:title, 'X') }
+      should_not_validate_format_of :title, 'A'
+    end
   end
 end
 

data/spec/describe_spec.rb

@@ -5,9 +5,9 @@ RAILS_I18n = true
 class Post
   attr_accessor :published, :public, :deleted
  
-  def initialize(attributes={})
+  def attributes=(attributes={}, guard=true)
     attributes.each do |key, value|
-      send(:"#{key}=", value)
+      send(:"#{key}=", value) unless guard
     end
   end
 

data/spec/validate_length_of_matcher_spec.rb

@@ -143,31 +143,31 @@ describe 'validate_length_of' do
       it { should define_and_validate(:is => 3).is(3)     }
       it { should_not define_and_validate(:is => 3).is(2) }
       it { should_not define_and_validate(:is => 3).is(4) }
-    end
-
-    describe "with token and separator options" do
-      describe "and words as tokens" do
-        before(:each) do
-          @matcher = define_and_validate(:within => 3..5, :tokenizer => lambda { |str| str.scan(/\w+/) })
-        end
-
-        it { should @matcher.within(3..5).token("word").separator(" ") }
-        it { should_not @matcher.within(2..5).token("word").separator(" ") }
-        it { should_not @matcher.within(4..5).token("word").separator(" ") }
-        it { should_not @matcher.within(3..4).token("word").separator(" ") }
-        it { should_not @matcher.within(3..6).token("word").separator(" ") }
-        it { should_not @matcher.within(3..5).token("word").separator("") }
-        it { should_not @matcher.within(3..5).token("word").separator(" a ") }
-      end
-
-      describe "and digits as tokens" do
-        before(:each) do
-          @matcher = define_and_validate(:within => 3..5, :tokenizer => lambda { |str| str.scan(/\d+/) })
-        end
-
-        it { should @matcher.within(3..5).token("1").separator(" ") }
-        it { should_not @matcher.within(3..5).token("a").separator("") }
-      end
+    end
+
+    describe "with token and separator options" do
+      describe "and words as tokens" do
+        before(:each) do
+          @matcher = define_and_validate(:within => 3..5, :tokenizer => lambda { |str| str.scan(/\w+/) })
+        end
+
+        it { should @matcher.within(3..5).token("word").separator(" ") }
+        it { should_not @matcher.within(2..5).token("word").separator(" ") }
+        it { should_not @matcher.within(4..5).token("word").separator(" ") }
+        it { should_not @matcher.within(3..4).token("word").separator(" ") }
+        it { should_not @matcher.within(3..6).token("word").separator(" ") }
+        it { should_not @matcher.within(3..5).token("word").separator("") }
+        it { should_not @matcher.within(3..5).token("word").separator(" a ") }
+      end
+
+      describe "and digits as tokens" do
+        before(:each) do
+          @matcher = define_and_validate(:within => 3..5, :tokenizer => lambda { |str| str.scan(/\d+/) })
+        end
+
+        it { should @matcher.within(3..5).token("1").separator(" ") }
+        it { should_not @matcher.within(3..5).token("a").separator("") }
+      end
     end
 
     describe "with with kind of" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: remarkable_activerecord
 version: !ruby/object:Gem::Version 
-  version: 3.1.6
+  version: 3.1.7
 platform: ruby
 authors: 
 - Carlos Brando
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-06 00:00:00 +02:00
+date: 2009-07-05 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,7 +32,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 3.1.6
+        version: 3.1.7
     version: 
 description: "Remarkable ActiveRecord: collection of matchers and macros with I18n for ActiveRecord"
 email: