remarkable_activerecord 3.1.2 → 3.1.3

data/CHANGELOG

@@ -1,3 +1,27 @@
+* 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:
 

data/README

@@ -3,8 +3,9 @@
 Remarkable ActiveRecord is a collection of matchers to ActiveRecord. Why use
 Remarkable?
 
-* The only one with matchers for all ActiveRecord validations, with support to
-  all options (except :on and the option :with in validates_format_of);
+* Matchers for all ActiveRecord validations, with support to all options. The only
+  exceptions are validate_format_of (which should be invoked as allow_values_for)
+  and the :on option;
 
 * Matchers for all ActiveRecord associations. The only one which supports all
   these options:

data/lib/remarkable_activerecord/describe.rb

@@ -1,82 +1,190 @@
 module Remarkable
   module ActiveRecord
 
-    def self.after_include(target)
-      target.class_inheritable_reader :default_subject_attributes
-      target.extend Describe
+    def self.after_include(target) #:nodoc:
+      target.class_inheritable_reader :describe_subject_attributes, :default_subject_attributes
+      target.send :include, Describe
     end
 
-    module Describe
+    # Overwrites describe to provide quick way to configure your subject:
+    #
+    #   describe Post
+    #     should_validate_presente_of :title
+    #
+    #     describe :published => true do
+    #       should_validate_presence_of :published_at
+    #     end
+    #   end
+    #
+    # This 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
+    #
+    # The string can be localized using I18n. An example yml file is:
+    #
+    #   locale:
+    #     remarkable:
+    #       active_record:
+    #         describe:
+    #           each: "{{key}} is {{value}}"
+    #           prepend: "when "
+    #           connector: " and "
+    #
+    # You can also call subject attributes to set the default attributes for a
+    # subject. You can even mix with a fixture replacement tool:
+    #
+    #   describe Post
+    #     # Fixjour example
+    #     subject_attributes { valid_post_attributes }
+    #
+    #     describe :published => true do
+    #       should_validate_presence_of :published_at
+    #     end
+    #   end
+    #
+    # You can retrieve the merged result of all attributes given using the
+    # subject_attributes instance method:
+    #
+    #   describe Post
+    #     # Fixjour example
+    #     subject_attributes { valid_post_attributes }
+    #
+    #     describe :published => true do
+    #       it "should have default subject attributes" do
+    #         subject_attributes.should == { :title => 'My title', :published => true }
+    #       end
+    #     end
+    #   end
+    #
+    module Describe
 
-      # Overwrites describe to provide quick way to configure your subject:
-      #
-      #   describe Post
-      #     should_validate_presente_of :title
-      #
-      #     describe :published => true do
-      #       should_validate_presence_of :published_at
-      #     end
-      #   end
-      #
-      # This 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
-      #
-      # The string can be localized using I18n. An example yml file is:
-      #
-      #   locale:
-      #     remarkable:
-      #       active_record:
-      #         describe:
-      #           each: "{{key}} is {{value}}"
-      #           prepend: "when "
-      #           connector: " and "
-      #
-      def describe(*args, &block)
-        if described_class && args.first.is_a?(Hash)
-          attributes = args.shift
+      def self.included(base) #:nodoc:
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
 
-          connector = Remarkable.t "remarkable.active_record.describe.connector", :default => " and "
+        # Overwrites describe to provide quick way to configure your subject:
+        #
+        #   describe Post
+        #     should_validate_presente_of :title
+        #
+        #     describe :published => true do
+        #       should_validate_presence_of :published_at
+        #     end
+        #   end
+        #
+        # This 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
+        #
+        # The string can be localized using I18n. An example yml file is:
+        #
+        #   locale:
+        #     remarkable:
+        #       active_record:
+        #         describe:
+        #           each: "{{key}} is {{value}}"
+        #           prepend: "when "
+        #           connector: " and "
+        #
+        # See also subject_attributes instance and class methods for more
+        # information.
+        #
+        def describe(*args, &block)
+          if described_class && args.first.is_a?(Hash)
+            attributes = args.shift
 
-          description = if self.default_subject_attributes.blank?
-            Remarkable.t("remarkable.active_record.describe.prepend", :default => "when ")
-          else
-            connector.lstrip
-          end
+            connector = Remarkable.t "remarkable.active_record.describe.connector", :default => " and "
 
-          pieces = []
-          attributes.each do |key, value|
-            translated_key = if described_class.respond_to?(:human_attribute_name)
-              described_class.human_attribute_name(key.to_s, :locale => Remarkable.locale)
+            description = if self.describe_subject_attributes.blank?
+              Remarkable.t("remarkable.active_record.describe.prepend", :default => "when ")
             else
-              key.to_s.humanize
+              connector.lstrip
             end
 
-            pieces << Remarkable.t("remarkable.active_record.describe.each",
-                                    :default => "{{key}} is {{value}}",
-                                    :key => translated_key.downcase, :value => value.inspect)
-          end
+            pieces = []
+            attributes.each do |key, value|
+              translated_key = if described_class.respond_to?(:human_attribute_name)
+                described_class.human_attribute_name(key.to_s, :locale => Remarkable.locale)
+              else
+                key.to_s.humanize
+              end
 
-          description << pieces.join(connector)
-          args.unshift(description)
+              pieces << Remarkable.t("remarkable.active_record.describe.each",
+                                      :default => "{{key}} is {{value}}",
+                                      :key => translated_key.downcase, :value => value.inspect)
+            end
 
-          # Creates an example group, set the subject and eval the given block.
-          #
-          example_group = super(*args) do
-            write_inheritable_hash(:default_subject_attributes, attributes)
-            subject { self.class.described_class.new(self.class.default_subject_attributes) }
-            instance_eval(&block)
+            description << pieces.join(connector)
+            args.unshift(description)
+
+            # Creates an example group, set the subject and eval the given block.
+            #
+            example_group = super(*args) do
+              write_inheritable_hash(:describe_subject_attributes, attributes)
+              subject { self.class.described_class.new(subject_attributes) }
+              instance_eval(&block)
+            end
+          else
+            super(*args, &block)
           end
-        else
-          super(*args, &block)
-        end
+        end
+
+        # Sets default attributes for the subject. You can use this to set up
+        # your subject with valid attributes. 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
+        #
+        def subject_attributes(options=nil, &block)
+          write_inheritable_attribute(:default_subject_attributes, options || block)
+          subject { self.class.described_class.new(subject_attributes) }
+        end
+
+      end
+
+      # Returns a hash with the subject attributes declared using the
+      # subject_attributes class method and the attributes given using the
+      # describe method.
+      #
+      #   describe Post
+      #     subject_attributes { valid_post_attributes }
+      #
+      #     describe :published => true do
+      #       it "should have default subject attributes" do
+      #         subject_attributes.should == { :title => 'My title', :published => true }
+      #       end
+      #     end
+      #   end
+      #
+      def subject_attributes
+        default = self.class.default_subject_attributes
+        default = self.instance_eval(&default) if default.is_a?(Proc)
+        default ||= {}
+
+        default.merge(self.class.describe_subject_attributes || {})
       end
 
     end

data/lib/remarkable_activerecord/matchers/allow_mass_assignment_of_matcher.rb

@@ -3,19 +3,44 @@ 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
 
           def is_protected?
-            protected = subject_class.protected_attributes || []
-            protected.empty? || !protected.include?(@attribute.to_s)
+            protected_attributes.empty? || !protected_attributes.include?(@attribute.to_s)
           end
 
           def is_accessible?
-            accessible = subject_class.accessible_attributes || []
-            accessible.empty? || accessible.include?(@attribute.to_s)
+            accessible_attributes.empty? || accessible_attributes.include?(@attribute.to_s)
+          end
+
+          def interpolation_options
+            if @subject
+              array = protected_attributes.to_a
+              { :protected_attributes => array.empty? ? "[]" : array_to_sentence(array) }
+            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
 

data/lib/remarkable_activerecord/matchers/allow_values_for_matcher.rb

@@ -53,7 +53,7 @@ module Remarkable
             options = if @in_range
               { :in => (@options[:in].first..@options[:in].last).inspect }
             elsif @options[:in].is_a?(Array)
-              { :in => @options[:in].map{|i| i.inspect}.to_sentence }
+              { :in => array_to_sentence(@options[:in].map{|i| i.inspect}) }
             else
               { :in => @options[:in].inspect }
             end
@@ -86,8 +86,18 @@ module Remarkable
       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
-      alias :validate_format_of :allow_values_for
 
     end
   end

data/lib/remarkable_activerecord/matchers/association_matcher.rb

@@ -31,25 +31,28 @@ module Remarkable
             return true unless @options.key?(:through)
             reflection.source_reflection rescue false
           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
-            ::ActiveRecord::Base.connection.tables.include?(reflection.options[:join_table])
+            subject_class.connection.tables.include?(reflection.options[:join_table].to_s)
           end
 
           def foreign_key_exists?
             return true unless foreign_key_table
-            table_has_column?(foreign_key_table, reflection_foreign_key)
+            table_has_column?(foreign_key_table_class, foreign_key_table, reflection_foreign_key)
           end
 
           def polymorphic_exists?
             return true unless @options[:polymorphic]
-            table_has_column?(subject_class.table_name, reflection_foreign_key.sub(/_id$/, '_type'))
+            klass_table_has_column?(subject_class, reflection_foreign_key.sub(/_id$/, '_type'))
           end
 
           def counter_cache_exists?
             return true unless @options[:counter_cache]
-            table_has_column?(reflection.klass.table_name, reflection.counter_cache_column.to_s)
+            klass_table_has_column?(reflection.klass, reflection.counter_cache_column.to_s)
           end
 
           def options_match?
@@ -80,8 +83,12 @@ module Remarkable
             reflection.primary_key_name.to_s
           end
 
-          def table_has_column?(table_name, column)
-            ::ActiveRecord::Base.connection.columns(table_name, 'Remarkable column retrieval').any?{|c| c.name == column }
+          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
@@ -104,7 +111,18 @@ module Remarkable
             else
               reflection.klass.table_name
             end
-          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
+            if [:belongs_to, :has_and_belongs_to_many].include?(reflection.macro)
+              subject_class
+            else
+              reflection.klass
+            end
+          end
 
           def interpolation_options
             options = { :macro => Remarkable.t(@macro, :scope => matcher_i18n_scope, :default => @macro.to_s), :options => @options.inspect }

data/lib/remarkable_activerecord/matchers/have_index_matcher.rb

@@ -4,6 +4,7 @@ module Remarkable
       class HaveIndexMatcher < Remarkable::ActiveRecord::Base #:nodoc:
         arguments :collection => :columns, :as => :column
 
+        optional :table_name
         optional :unique, :default => true
 
         collection_assertions :index_exists?, :is_unique?
@@ -25,11 +26,17 @@ module Remarkable
           end
 
           def indexes
-            @indexes ||= ::ActiveRecord::Base.connection.indexes(subject_class.table_name)
+            @indexes ||= ::ActiveRecord::Base.connection.indexes(current_table_name)
           end
 
           def interpolation_options
-            @subject ? { :table_name => subject_class.table_name } : {}
+            @subject ? { :table_name => current_table_name } : {}
+          end
+
+        private
+
+          def current_table_name
+            @options[:table_name] || subject_class.table_name
           end
 
       end
@@ -39,18 +46,19 @@ module Remarkable
       # == Options
       #
       # * <tt>unique</tt> - when supplied, tests if the index is unique or not
+      # * <tt>table_name</tt> - when supplied, tests if the index is defined for the given table
       #
       # == Examples
       #
       #   it { should have_index(:ssn).unique(true) }
-      #   it { should have_index([:name, :email]).unique(true) }
-      #
-      #   should_have_index :ssn, :unique => true, :limit => 9, :null => false
-      #
-      #   should_have_index :ssn do |m|
-      #     m.unique
-      #     m.limit = 9
-      #     m.null = false
+      #   it { should have_index([:name, :email]).unique(true) }
+      #
+      #   should_have_index :ssn, :unique => true, :limit => 9, :null => false
+      #
+      #   should_have_index :ssn do |m|
+      #     m.unique
+      #     m.limit = 9
+      #     m.null = false
       #   end
       #
       def have_index(*args, &block)

data/lib/remarkable_activerecord/matchers/validate_uniqueness_of_matcher.rb

@@ -21,28 +21,28 @@ module Remarkable
 
           # 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.
-          #
-          # We should also ensure that the object retrieved from the database
-          # is not the @subject.
+          #
+          # We should also ensure that the object retrieved from the database
+          # is not the @subject.
           #
           # If any of these attempts fail, an error is raised.
           #
-          def find_first_object?
+          def find_first_object?
             conditions, message = if @options[:allow_nil]
               [ ["#{@attribute} IS NOT NULL"], " with #{@attribute} not nil" ]
             elsif @options[:allow_blank]
               [ ["#{@attribute} != ''"], " with #{@attribute} not blank" ]
             else
               [ [], "" ]
-            end
-
-            unless @subject.new_record?
-              primary_key = subject_class.primary_key
-
-              message    << " which is different from the subject record (the object being validated is the same as the one in the database)"
-              conditions << "#{subject_class.primary_key} != '#{@subject.send(primary_key)}'"
-            end
-
+            end
+
+            unless @subject.new_record?
+              primary_key = subject_class.primary_key
+
+              message    << " which is different from the subject record (the object being validated is the same as the one in the database)"
+              conditions << "#{subject_class.primary_key} != '#{@subject.send(primary_key)}'"
+            end
+
             options = conditions.empty? ? {} : { :conditions => conditions.join(' AND ') }
 
             return true if @existing = subject_class.find(:first, options)
@@ -53,9 +53,9 @@ module Remarkable
           #
           def responds_to_scope?
             (@options[:scope] || []).each do |scope|
-              setter = :"#{scope}="
-
-              return false, :method => setter unless @subject.respond_to?(setter)
+              setter = :"#{scope}="
+
+              return false, :method => setter unless @subject.respond_to?(setter)
               return false, :method => scope  unless @existing.respond_to?(scope)
 
               @subject.send(setter, @existing.send(scope))
@@ -86,11 +86,11 @@ module Remarkable
           # Now test that the object is valid when changing the scoped attribute.
           #
           def valid_with_new_scope?
-            (@options[:scope] || []).each do |scope|
-              setter = :"#{scope}="
+            (@options[:scope] || []).each do |scope|
+              setter = :"#{scope}="
 
-              previous_scope_value = @subject.send(scope)
-              @subject.send(setter, new_value_for_scope(scope))
+              previous_scope_value = @subject.send(scope)
+              @subject.send(setter, new_value_for_scope(scope))
               return false, :method => scope unless good?(@value)
 
               @subject.send(setter, previous_scope_value)
@@ -106,13 +106,13 @@ module Remarkable
           #
           def allow_nil?
             return true unless @options.key?(:allow_nil)
-
+
             begin
               @existing.update_attribute(@attribute, nil)
             rescue ::ActiveRecord::StatementInvalid => 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]
-              return true
+                                 "but I cannot save nil values in the database, got: #{e.message}" if @options[:allow_nil]
+              return true
             end
 
             super
@@ -123,53 +123,53 @@ module Remarkable
           #
           def allow_blank?
             return true unless @options.key?(:allow_blank)
-
+
             begin
               @existing.update_attribute(@attribute, '')
             rescue ::ActiveRecord::StatementInvalid => 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]
-              return true
+                                 "but I cannot save blank values in the database, got: #{e.message}" if @options[:allow_blank]
+              return true
             end
 
             super
           end
-
-          # Returns a value to be used as new scope. It deals with four different
-          # cases: date, time, boolean and stringfiable (everything that can be
+
+          # Returns a value to be used as new scope. It deals with four different
+          # cases: date, time, boolean and stringfiable (everything that can be
           # converted to a string and the next value makes sense)
-          #
-          def new_value_for_scope(scope)
-            column_type = if @existing.respond_to?(:column_for_attribute)
-              @existing.column_for_attribute(scope)
-            else
-              nil
-            end
-
-            case column_type.type
-              when :int, :integer, :float, :decimal
-                new_value_for_stringfiable_scope(scope)
-              when :datetime, :timestamp, :time
-                Time.now + 10000
-              when :date
-                Date.today + 100
-              when :boolean
-                !@existing.send(scope)
-              else
-                new_value_for_stringfiable_scope(scope)
-            end
-          end
-
-          # Returns a value to be used as scope by generating a range of values
+          #
+          def new_value_for_scope(scope)
+            column_type = if @existing.respond_to?(:column_for_attribute)
+              @existing.column_for_attribute(scope)
+            else
+              nil
+            end
+
+            case column_type.type
+              when :int, :integer, :float, :decimal
+                new_value_for_stringfiable_scope(scope)
+              when :datetime, :timestamp, :time
+                Time.now + 10000
+              when :date
+                Date.today + 100
+              when :boolean
+                !@existing.send(scope)
+              else
+                new_value_for_stringfiable_scope(scope)
+            end
+          end
+
+          # Returns a value to be used as scope by generating a range of values
           # and searching for them in the database.
           #
           def new_value_for_stringfiable_scope(scope)
             values = [(@existing.send(scope) || 999).next.to_s]
 
             # Generate a range of values to search in the database
-            100.times do
-              values << values.last.next
-            end
+            100.times do
+              values << values.last.next
+            end
             conditions = { scope => values, @attribute => @value }
 
             # Get values from the database, get the scope attribute and map them to string.
@@ -190,15 +190,15 @@ module Remarkable
       #
       # 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
-      # given attributes. The same is required for allow_blank option.
-      #
-      # Notice that the record being validate should not be the same as in the
-      # database. In other words, you can't do this:
-      #
-      #   subject { Post.create!(@valid_attributes) }
-      #   should_validate_uniquness_of :title
-      #
-      # But don't worry, if you eventually do that, a helpful error message
+      # given attributes. The same is required for allow_blank option.
+      #
+      # Notice that the record being validate should not be the same as in the
+      # database. In other words, you can't do this:
+      #
+      #   subject { Post.create!(@valid_attributes) }
+      #   should_validate_uniqueness_of :title
+      #
+      # But don't worry, if you eventually do that, a helpful error message
       # will be raised.
       #
       # == Options
@@ -214,15 +214,15 @@ module Remarkable
       #
       #   it { should validate_uniqueness_of(:keyword, :username) }
       #   it { should validate_uniqueness_of(:email, :scope => :name, :case_sensitive => false) }
-      #   it { should validate_uniqueness_of(:address, :scope => [:first_name, :last_name]) }
-      #
+      #   it { should validate_uniqueness_of(:address, :scope => [:first_name, :last_name]) }
+      #
       #   should_validate_uniqueness_of :keyword, :username
       #   should_validate_uniqueness_of :email, :scope => :name, :case_sensitive => false
-      #   should_validate_uniqueness_of :address, :scope => [:first_name, :last_name]
-      #
-      #   should_validate_uniqueness_of :email do |m|
-      #     m.scope = name
-      #     m.case_sensitive = false
+      #   should_validate_uniqueness_of :address, :scope => [:first_name, :last_name]
+      #
+      #   should_validate_uniqueness_of :email do |m|
+      #     m.scope = name
+      #     m.case_sensitive = false
       #   end
       #
       def validate_uniqueness_of(*attributes, &block)

data/locale/en.yml

@@ -41,7 +41,8 @@ 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)"
 
@@ -140,7 +141,9 @@ en:
         optionals:
           unique:
             positive: "with unique values"
-            negative: "with non unique values"
+            negative: "with non unique values"
+          table_name:
+            positive: "on table {{value}}"
 
       have_readonly_attributes:
         description: "make {{attributes}} read-only"

data/spec/allow_mass_assignment_of_matcher_spec.rb

@@ -20,7 +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
+      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
+
     it 'should set is_protected? message' do
       @matcher = define_and_validate(:protected => true)
       @matcher.matches?(@model)
@@ -40,7 +47,24 @@ 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]) }
+    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
 
   describe 'macros' do

data/spec/allow_values_for_matcher_spec.rb

@@ -49,8 +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'
+    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/association_matcher_spec.rb

@@ -273,7 +273,10 @@ describe 'association_matcher' do
       describe 'with join table option' do
         it { should define_and_validate.join_table('labels_projects') }
         it { should define_and_validate(:join_table => 'my_table',
-                                        :association_table => 'my_table').join_table('my_table') }
+                                        :association_table => 'my_table').join_table('my_table') }
+
+        it { should define_and_validate(:join_table => :my_table,
+                                        :association_table => :my_table).join_table(:my_table) }
 
         it { should_not define_and_validate.join_table('projects_labels') }
 

data/spec/describe_spec.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 RAILS_I18n = true
 
 class Post
-  attr_accessor :title, :published, :public
+  attr_accessor :published, :public, :deleted
  
   def initialize(attributes={})
     attributes.each do |key, value|
@@ -14,13 +14,41 @@ class Post
   def self.human_name(*args)
     "MyPost"
   end
-end unless defined?(Post)
+end
 
 describe Post do
   it "should use human name on description" do
     self.class.description.should == "MyPost"
   end
 
+  describe "default attributes as a hash" do
+    subject_attributes :deleted => true
+
+    it "should set the subject with deleted equals to true" do
+      subject.deleted.should be_true
+    end
+
+    it "should not change the description" do
+      self.class.description.should == "MyPost default attributes as a hash"
+    end
+  end
+
+  describe "default attributes as a proc" do
+    subject_attributes { my_attributes }
+
+    it "should set the subject with deleted equals to true" do
+      subject.deleted.should be_true
+    end
+
+    it "should not change the description" do
+      self.class.description.should == "MyPost default attributes as a proc"
+    end
+
+    def my_attributes
+      { :deleted => true }
+    end
+  end
+
   describe :published => true do
     it "should set the subject with published equals to true" do
       subject.published.should be_true
@@ -46,6 +74,16 @@ describe Post do
       it "should nest descriptions" do
         self.class.description.should == "MyPost when published is true and public is false"
       end
+
+      describe "default attributes as a hash" do
+        subject_attributes :deleted => true
+
+        it "should merge describe attributes with subject attributes" do
+          subject.published.should be_true
+          subject.public.should be_false
+          subject.deleted.should be_true
+        end
+      end
     end
   end
 

data/spec/have_index_matcher_spec.rb

@@ -9,25 +9,33 @@ describe 'have_index_matcher' do
       table.string  :email, :limit => '255', :default => 'jose.valim@gmail.com'
     }
 
+    create_table "users_watchers" do |t|
+      t.integer :user_id
+      t.integer :watcher_id
+    end
+
     ActiveRecord::Base.connection.add_index :users, :name
     ActiveRecord::Base.connection.add_index :users, :email, :unique => true
     ActiveRecord::Base.connection.add_index :users, [:email, :name], :unique => true
+    ActiveRecord::Base.connection.add_index :users_watchers, :user_id
   end
 
   describe 'messages' do
-
     it 'should contain a description' do
       @matcher = have_index(:name)
       @matcher.description.should == 'have index for column(s) name'
 
       @matcher.unique
       @matcher.description.should == 'have index for column(s) name with unique values'
+
+      @matcher.table_name("another")
+      @matcher.description.should == 'have index for column(s) name on table another and with unique values'
     end
 
     it 'should set index_exists? message' do
-      @matcher = have_index(:password)
+      @matcher = have_index(:password).table_name("special_users")
       @matcher.matches?(@model)
-      @matcher.failure_message.should == 'Expected index password to exist on table users'
+      @matcher.failure_message.should == 'Expected index password to exist on table special_users'
     end
 
     it 'should set is_unique? message' do
@@ -41,28 +49,39 @@ describe 'have_index_matcher' do
     it { should have_index(:name) }
     it { should have_index(:email) }
     it { should have_index([:email, :name]) }
-    it { should have_indices(:name, :email) }
+    it { should have_index(:name, :email) }
 
     it { should have_index(:name).unique(false) }
     it { should have_index(:email).unique }
+    it { should have_index(:user_id).table_name(:users_watchers) }
 
     it { should_not have_index(:password) }
     it { should_not have_index(:name).unique(true) }
     it { should_not have_index(:email).unique(false) }
+    it { should_not have_index(:watcher_id).table_name(:users_watchers) }
   end
 
   describe 'macros' do
     should_have_index :name
     should_have_index :email
     should_have_index [:email, :name]
-    should_have_indices :name, :email
+    should_have_index :name, :email
 
     should_have_index :name, :unique => false
     should_have_index :email, :unique => true
+    should_have_index :user_id, :table_name => :users_watchers
 
     should_not_have_index :password
     should_not_have_index :name, :unique => true
     should_not_have_index :email, :unique => false
+    should_not_have_index :watcher_id, :table_name => :users_watchers
   end
+
+  describe "aliases" do
+    should_have_indices :name
+    should_have_db_index :name
+    should_have_db_indices :name
+  end
+
 end
 

data/spec/spec_helper.rb

@@ -1,5 +1,5 @@
+# encoding: utf-8
 require 'rubygems'
-require 'ruby-debug'
 
 RAILS_VERSION = ENV['RAILS_VERSION'] || '2.3.2'
 

data/spec/validate_length_of_matcher_spec.rb

@@ -143,29 +143,29 @@ 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 with kind of" do
-      def define_and_validate(options)
-        define_model :variant, :product_id => :integer
+    end
+
+    describe "with with kind of" do
+      def define_and_validate(options)
+        define_model :variant, :product_id => :integer
 
-        @model = define_model :product do
+        @model = define_model :product do
           has_many :variants
-          validates_length_of :variants, options
+          validates_length_of :variants, options
         end
 
-        validate_length_of(:variants)
-      end
-
-      it { should define_and_validate(:within => 3..6).within(3..6).with_kind_of(Variant) }
-      it { should_not define_and_validate(:within => 2..6).within(3..6).with_kind_of(Variant) }
-      it { should_not define_and_validate(:within => 3..7).within(3..6).with_kind_of(Variant) }
-
-      it "should raise association type mismatch if with_kind_of is not supplied" do
-        lambda {
-          should_not define_and_validate(:within => 3..6).within(3..6)
-        }.should raise_error(ActiveRecord::AssociationTypeMismatch)
-      end
+        validate_length_of(:variants)
+      end
+
+      it { should define_and_validate(:within => 3..6).within(3..6).with_kind_of(Variant) }
+      it { should_not define_and_validate(:within => 2..6).within(3..6).with_kind_of(Variant) }
+      it { should_not define_and_validate(:within => 3..7).within(3..6).with_kind_of(Variant) }
+
+      it "should raise association type mismatch if with_kind_of does not match" do
+        lambda {
+          should_not define_and_validate(:within => 3..6).within(3..6).with_kind_of(Product)
+        }.should raise_error(ActiveRecord::AssociationTypeMismatch)
+      end
     end
 
     # Those are macros to test optionals which accept only boolean values
@@ -178,16 +178,16 @@ describe 'validate_length_of' do
     before(:each) { define_and_validate }
 
     should_validate_length_of :size, :in => 3..5
-    should_validate_length_of :size, :within => 3..5
+    should_validate_length_of :size, :within => 3..5
 
     should_not_validate_length_of :size, :within => 2..5
     should_not_validate_length_of :size, :within => 4..5
     should_not_validate_length_of :size, :within => 3..4
     should_not_validate_length_of :size, :within => 3..6
-    should_not_validate_length_of :category, :in => 3..5
-
-    should_validate_length_of :size do |m|
-      m.in = 3..5
+    should_not_validate_length_of :category, :in => 3..5
+
+    should_validate_length_of :size do |m|
+      m.in = 3..5
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: remarkable_activerecord
 version: !ruby/object:Gem::Version 
-  version: 3.1.2
+  version: 3.1.3
 platform: ruby
 authors: 
 - Carlos Brando
@@ -11,9 +11,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-15 00:00:00 +02:00
+date: 2009-05-28 00:00:00 +02:00
 default_executable: 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: 
 - !ruby/object:Gem::Dependency 
   name: remarkable
   type: :runtime
@@ -22,7 +32,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 3.1.2
+        version: 3.1.3
     version: 
 description: "Remarkable ActiveRecord: collection of matchers and macros with I18n for ActiveRecord"
 email: