remarkable_activerecord 3.0.8 → 3.0.9

data/CHANGELOG

@@ -1,10 +1,50 @@
+* 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 :include, :join, :group and :having as quick accessors to have_scope matcher
+* Allow :conditions, :include, :joins, :limit, :offset, :order, :select, :readonly,
+  :group, :having, :from, :lock as quick accessors to have_scope matcher
 
-* Allow all objects to be sent to have_scope (thanks to Szymon Nowak and Nolan Eakins) [#53]
+* 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]
@@ -17,8 +57,8 @@
 
 # v3.0
 
-[ENHANCEMENT] Added more options to associations matcher. Previously it was
-handling just :dependent and :through options. Now it deals with:
+* 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,
   :readonly, :validate, :autosave, :counter_cache, :polymorphic
@@ -55,10 +95,9 @@ subject definitions on rspec. This was also fixed.
 
 # v2.x
 
-[ENHANCEMENT] Added associations, allow_mass_assignment, allow_values_for,
-have_column, have_index, have_scope, have_readonly_attributes,
-validate_acceptance_of, validate_associate, validate_confirmation_of,
-validate_exclusion_of, validate_inclusion_of, validate_length_of,
-validate_numericality_of, validate_presence_of and validate_uniqueness_of
-matchers.
+* 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.rb

@@ -11,7 +11,8 @@ end
 
 # Load Remarkable ActiveRecord files
 dir = File.dirname(__FILE__)
-require File.join(dir, 'remarkable_activerecord', 'base')
+require File.join(dir, 'remarkable_activerecord', 'base')
+require File.join(dir, 'remarkable_activerecord', 'describe')
 require File.join(dir, 'remarkable_activerecord', 'human_names')
 
 # Add locale

data/lib/remarkable_activerecord/describe.rb

@@ -0,0 +1,84 @@
+module Remarkable
+  module ActiveRecord
+
+    def self.after_include(target)
+      target.class_inheritable_reader :default_subject_attributes
+      target.extend 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 "
+      #
+      def describe(*args, &block)
+        if described_class && args.first.is_a?(Hash)
+          attributes = args.shift
+
+          connector = Remarkable.t "remarkable.active_record.describe.connector", :default => " and "
+
+          description = if self.default_subject_attributes.blank?
+            Remarkable.t("remarkable.active_record.describe.prepend", :default => "when ")
+          else
+            connector.lstrip
+          end
+
+          pieces = []
+          attributes.each do |key, value|
+            translated_key = if described_class.respond_to?(:human_attribute_name)
+              described_class.human_attribute_name(key, :locale => Remarkable.locale)
+            else
+              key.to_s.humanize
+            end
+
+            pieces << Remarkable.t("remarkable.active_record.describe.each",
+                                    :default => "{{key}} is {{value}}",
+                                    :key => key, :value => value.inspect)
+          end
+
+          description << pieces.join(connector)
+          args.unshift(description)
+
+          # Creates an example group, send the method 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)
+          end
+        else
+          super(*args, &block)
+        end
+      end
+
+    end
+  end
+end

data/lib/remarkable_activerecord/human_names.rb

@@ -7,7 +7,7 @@ if defined?(Spec)
         #
         def self.build_description_with_i18n(*args)
           args.inject("") do |description, arg|
-            arg = if RAILS_I18N && arg.respond_to?(:human_name)
+            arg = if arg.respond_to?(:human_name)
               arg.human_name(:locale => Remarkable.locale)
             else
               arg.to_s
@@ -26,7 +26,7 @@ if defined?(Spec)
 
         # This is for rspec >= 1.2.0.
         #
-        def build_description_from(*args)
+        def self.build_description_from(*args)
           text = ExampleGroupMethods.build_description_with_i18n(*args)
           text == "" ? nil : text
         end

data/lib/remarkable_activerecord/matchers/accept_nested_attributes_for_matcher.rb

@@ -96,24 +96,33 @@ module Remarkable
       #
       #   class Projects < ActiveRecord::Base
       #     has_many :tasks
-      #     accepts_nested_attributes_for :tasks, :reject_if => proc { |a| a[:name].blank? }
+      #     accepts_nested_attributes_for :tasks, :reject_if => proc { |a| a[:title].blank? }
       #   end
       #
       # You can have the following specs:
       #
-      #   should_accept_nested_attributes_for :tasks, :reject => { :name => '' }        # Passes
-      #   should_accept_nested_attributes_for :tasks, :accept => { :name => 'My task' } # Passes
+      #   should_accept_nested_attributes_for :tasks, :reject => { :title => '' }        # Passes
+      #   should_accept_nested_attributes_for :tasks, :accept => { :title => 'My task' } # Passes
       #
-      #   should_accept_nested_attributes_for :tasks, :accept => { :name => 'My task' },
-      #                                               :reject => { :name => '' }        # Passes
+      #   should_accept_nested_attributes_for :tasks, :accept => { :title => 'My task' },
+      #                                               :reject => { :title => '' }        # Passes
       #
-      #   should_accept_nested_attributes_for :tasks, :accept => { :name => '' }        # Fail
-      #   should_accept_nested_attributes_for :tasks, :reject => { :name => 'My task' } # Fail
+      #   should_accept_nested_attributes_for :tasks, :accept => { :title => '' }        # Fail
+      #   should_accept_nested_attributes_for :tasks, :reject => { :title => 'My task' } # Fail
       #
       # You can also give arrays to :accept and :reject to verify multiple attributes.
+      # In such cases the block syntax is more recommended for readability:
+      #
+      #   should_accept_nested_attributes_for :tasks do
+      #     m.allow_destroy(false)
+      #     m.accept :title => 'My task'
+      #     m.accept :title => 'Another task'
+      #     m.reject :title => nil
+      #     m.reject :title => ''
+      #   end
       #
-      def accept_nested_attributes_for(*args)
-        AcceptNestedAttributesForMatcher.new(*args).spec(self)
+      def accept_nested_attributes_for(*args, &block)
+        AcceptNestedAttributesForMatcher.new(*args, &block).spec(self)
       end
 
     end

data/lib/remarkable_activerecord/matchers/allow_mass_assignment_of_matcher.rb

@@ -26,8 +26,8 @@ module Remarkable
       #   should_allow_mass_assignment_of :email, :name
       #   it { should allow_mass_assignment_of(:email, :name) }
       #
-      def allow_mass_assignment_of(*attributes)
-        AllowMassAssignmentOfMatcher.new(*attributes).spec(self)
+      def allow_mass_assignment_of(*attributes, &block)
+        AllowMassAssignmentOfMatcher.new(*attributes, &block).spec(self)
       end
     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(&:inspect).to_sentence }
+              { :in => @options[:in].map{|i| i.inspect}.to_sentence }
             else
               { :in => @options[:in].inspect }
             end
@@ -83,9 +83,9 @@ module Remarkable
       #   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)
+      def allow_values_for(attribute, *args, &block)
         options = args.extract_options!
-        AllowValuesForMatcher.new(attribute, options.merge!(:in => args)).spec(self)
+        AllowValuesForMatcher.new(attribute, options.merge!(:in => args), &block).spec(self)
       end
       alias :validate_format_of :allow_values_for
 

data/lib/remarkable_activerecord/matchers/association_matcher.rb

@@ -150,8 +150,8 @@ module Remarkable
       #   should_belong_to :parent, :polymorphic => true
       #   it { should belong_to(:parent) }
       #
-      def belong_to(*associations)
-        AssociationMatcher.new(:belongs_to, *associations).spec(self)
+      def belong_to(*associations, &block)
+        AssociationMatcher.new(:belongs_to, *associations, &block).spec(self)
       end
 
       # Ensures that the has_and_belongs_to_many relationship exists, if the join
@@ -175,8 +175,8 @@ module Remarkable
       #  should_have_and_belong_to_many :posts, :cars
       #  it{ should have_and_belong_to_many :posts, :cars }
       #
-      def have_and_belong_to_many(*associations)
-        AssociationMatcher.new(:has_and_belongs_to_many, *associations).spec(self)
+      def have_and_belong_to_many(*associations, &block)
+        AssociationMatcher.new(:has_and_belongs_to_many, *associations, &block).spec(self)
       end
 
       # Ensures that the has_many relationship exists. Will also test that the
@@ -211,8 +211,8 @@ module Remarkable
       #   it{ should have_many(:enemies, :through => :friends) }
       #   it{ should have_many(:enemies, :dependent => :destroy) }
       #
-      def have_many(*associations)
-        AssociationMatcher.new(:has_many, *associations).spec(self)
+      def have_many(*associations, &block)
+        AssociationMatcher.new(:has_many, *associations, &block).spec(self)
       end
 
       # Ensures that the has_many relationship exists. Will also test that the
@@ -240,8 +240,8 @@ module Remarkable
       #  should_have_one :universe
       #  it{ should have_one(:universe) }
       #
-      def have_one(*associations)
-        AssociationMatcher.new(:has_one, *associations).spec(self)
+      def have_one(*associations, &block)
+        AssociationMatcher.new(:has_one, *associations, &block).spec(self)
       end
 
     end

data/lib/remarkable_activerecord/matchers/have_column_matcher.rb

@@ -56,8 +56,8 @@ module Remarkable
       #   it { should have_column(:name, :type => :string) }
       #   it { should have_column(:name).type(:string) }
       # 
-      def have_column(*args)
-        HaveColumnMatcher.new(*args).spec(self)
+      def have_column(*args, &block)
+        HaveColumnMatcher.new(*args, &block).spec(self)
       end
       alias :have_columns    :have_column
       alias :have_db_column  :have_column

data/lib/remarkable_activerecord/matchers/have_default_scope_matcher.rb

@@ -5,7 +5,8 @@ module Remarkable
         arguments
         assertions :options_match?
 
-        optionals :select, :conditions, :join, :include, :group, :having, :order, :limit, :offset
+        optionals :conditions, :include, :joins, :limit, :offset, :order, :select,
+                  :readonly, :group, :having, :from, :lock
 
         protected
 
@@ -32,8 +33,9 @@ module Remarkable
       #
       # == Options
       #
-      # All options that the default scope would pass on to find: select, conditions,
-      # join, include, group, having, order, limit e offset.
+      # All options that the default scope would pass on to find: :conditions,
+      # :include, :joins, :limit, :offset, :order, :select, :readonly, :group,
+      # :having, :from, :lock.
       #
       # == Examples
       #
@@ -58,8 +60,8 @@ module Remarkable
       #   should_have_default_scope :conditions => { :published => true,
       #                                               :visible => true }  # Fails
       #
-      def have_default_scope(*args)
-        HaveDefaultScopeMatcher.new(*args).spec(self)
+      def have_default_scope(*args, &block)
+        HaveDefaultScopeMatcher.new(*args, &block).spec(self)
       end
 
     end

data/lib/remarkable_activerecord/matchers/have_index_matcher.rb

@@ -43,10 +43,18 @@ module Remarkable
       # == Examples
       #
       #   it { should have_index(:ssn).unique(true) }
-      #   it { should have_index([:name, :email]).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
+      #   end
       #
-      def have_index(*args)
-        HaveIndexMatcher.new(*args).spec(self)
+      def have_index(*args, &block)
+        HaveIndexMatcher.new(*args, &block).spec(self)
       end
       alias :have_indices    :have_index
       alias :have_db_index   :have_index

data/lib/remarkable_activerecord/matchers/have_readonly_attributes_matcher.rb

@@ -20,8 +20,8 @@ module Remarkable
       #
       #   it { should have_readonly_attributes(:password, :admin_flag) }
       #
-      def have_readonly_attributes(*attributes)
-        HaveReadonlyAttributesMatcher.new(*attributes).spec(self)
+      def have_readonly_attributes(*attributes, &block)
+        HaveReadonlyAttributesMatcher.new(*attributes, &block).spec(self)
       end
       alias :have_readonly_attribute :have_readonly_attributes
 

data/lib/remarkable_activerecord/matchers/have_scope_matcher.rb

@@ -6,17 +6,15 @@ module Remarkable
         assertions :is_scope?, :options_match?
 
         optionals :with, :splat => true
-        optionals :select, :conditions, :join, :include, :group, :having, :order, :limit, :offset
+        optionals :conditions, :include, :joins, :limit, :offset, :order, :select,
+                  :readonly, :group, :having, :from, :lock
 
         protected
 
           def is_scope?
-            @scope_object = if @options[:with]
-              if @options[:with].is_a?(Array)
-                subject_class.send(@scope_name, *@options[:with])
-              else
-                subject_class.send(@scope_name, @options[:with])
-              end
+            @scope_object = if @options.key?(:with)
+              @options[:with] = [ @options[:with] ] unless Array === @options[:with]
+              subject_class.send(@scope_name, *@options[:with])
             else
               subject_class.send(@scope_name)
             end
@@ -43,7 +41,9 @@ module Remarkable
       #
       # * <tt>with</tt> - Options to be sent to the named scope
       #
-      # And all other options that the named scope would pass on to find.
+      # All options that the named scope would pass on to find: :conditions,
+      # :include, :joins, :limit, :offset, :order, :select, :readonly, :group,
+      # :having, :from, :lock.
       #
       # == Examples
       # 
@@ -75,8 +75,8 @@ module Remarkable
       #     scoped(:limit => c)
       #   end
       #
-      def have_scope(*args)
-        HaveScopeMatcher.new(*args).spec(self)
+      def have_scope(*args, &block)
+        HaveScopeMatcher.new(*args, &block).spec(self)
       end
       alias :have_named_scope :have_scope
 

data/lib/remarkable_activerecord/matchers/validate_acceptance_of_matcher.rb

@@ -41,8 +41,8 @@ module Remarkable
       #   it { should validate_acceptance_of(:eula, :terms) }
       #   it { should validate_acceptance_of(:eula, :terms, :accept => true) }
       #
-      def validate_acceptance_of(*attributes)
-        ValidateAcceptanceOfMatcher.new(*attributes).spec(self)
+      def validate_acceptance_of(*attributes, &block)
+        ValidateAcceptanceOfMatcher.new(*attributes, &block).spec(self)
       end
 
     end

data/lib/remarkable_activerecord/matchers/validate_associated_matcher.rb

@@ -2,8 +2,10 @@ module Remarkable
   module ActiveRecord
     module Matchers
       class ValidateAssociatedMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :collection => :associations, :as => :association, :block => :block
-        optional  :message, :builder
+        arguments :collection => :associations, :as => :association, :block => true
+
+        optional :message
+        optional :builder, :block => true
 
         collection_assertions :find_association?, :is_valid?
         default_options :message => :invalid
@@ -84,11 +86,13 @@ module Remarkable
       # == Examples
       #
       #   should_validate_associated :tasks
-      #   should_validate_associated(:tasks){ |p| p.tasks.build(:captcha => 'i_am_a_bot') }
-      #   should_validate_associated :tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_bot') }
+      #   should_validate_associated :tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_bot') }
+      #
+      #   should_validate_associated :tasks do |m|
+      #     m.builder { |p| p.tasks.build(:captcha => 'i_am_a_bot') }
+      #   end
       #
       #   it { should validate_associated(:tasks) }
-      #   it { should validate_associated(:tasks){ |p| p.tasks.build(:captcha => 'i_am_a_bot') } }
       #   it { should validate_associated(:tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_bot') }) }
       #
       def validate_associated(*args, &block)

data/lib/remarkable_activerecord/matchers/validate_confirmation_of_matcher.rb

@@ -35,8 +35,8 @@ module Remarkable
       #
       #   it { should validate_confirmation_of(:email, :password) }
       #
-      def validate_confirmation_of(*attributes)
-        ValidateConfirmationOfMatcher.new(*attributes).spec(self)
+      def validate_confirmation_of(*attributes, &block)
+        ValidateConfirmationOfMatcher.new(*attributes, &block).spec(self)
       end
 
     end

data/lib/remarkable_activerecord/matchers/validate_exclusion_of_matcher.rb

@@ -47,8 +47,8 @@ module Remarkable
       #   should_validate_exclusion_of :username, :in => ["admin", "user"]
       #   should_validate_exclusion_of :age, :in => 30..60
       #
-      def validate_exclusion_of(*args)
-        ValidateExclusionOfMatcher.new(*args).spec(self)
+      def validate_exclusion_of(*args, &block)
+        ValidateExclusionOfMatcher.new(*args, &block).spec(self)
       end
 
     end

data/lib/remarkable_activerecord/matchers/validate_inclusion_of_matcher.rb

@@ -47,8 +47,8 @@ module Remarkable
       #   it { should validate_inclusion_of(:size, :in => ["S", "M", "L", "XL"]) }
       #   it { should validate_inclusion_of(:age, :in => 18..100) }
       #
-      def validate_inclusion_of(*args)
-        ValidateInclusionOfMatcher.new(*args).spec(self)
+      def validate_inclusion_of(*args, &block)
+        ValidateInclusionOfMatcher.new(*args, &block).spec(self)
       end
 
     end

data/lib/remarkable_activerecord/matchers/validate_length_of_matcher.rb

@@ -105,18 +105,23 @@ module Remarkable
       #
       # == Examples
       #
-      #   should_validate_length_of :password, :within => 6..20
-      #   should_validate_length_of :password, :maximum => 20
-      #   should_validate_length_of :password, :minimum => 6
-      #   should_validate_length_of :age, :is => 18
-      #
       #   it { should validate_length_of(:password).within(6..20) }
       #   it { should validate_length_of(:password).maximum(20) }
       #   it { should validate_length_of(:password).minimum(6) }
       #   it { should validate_length_of(:age).is(18) }
+      #
+      #   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
       #
-      def validate_length_of(*attributes)
-        ValidateLengthOfMatcher.new(*attributes).spec(self)
+      def validate_length_of(*attributes, &block)
+        ValidateLengthOfMatcher.new(*attributes, &block).spec(self)
       end
     end
   end

data/lib/remarkable_activerecord/matchers/validate_numericality_of_matcher.rb

@@ -165,17 +165,22 @@ module Remarkable
       #
       # == Examples
       #
-      #   should_validate_numericality_of :age, :price
-      #   should_validate_numericality_of :price, :only_integer => false, :greater_than => 10
-      #
       #   it { should validate_numericality_of(:age).odd }
       #   it { should validate_numericality_of(:age).even }
       #   it { should validate_numericality_of(:age).only_integer }
       #   it { should validate_numericality_of(:age, :odd => true) }
       #   it { should validate_numericality_of(:age, :even => true) }
+      #
+      #   should_validate_numericality_of :age, :price
+      #   should_validate_numericality_of :price, :only_integer => false, :greater_than => 10
+      #
+      #   should_validate_numericality_of :price do |m|
+      #     m.only_integer = false
+      #     m.greater_than = 10
+      #   end
       #
-      def validate_numericality_of(*attributes)
-        ValidateNumericalityOfMatcher.new(*attributes).spec(self)
+      def validate_numericality_of(*attributes, &block)
+        ValidateNumericalityOfMatcher.new(*attributes, &block).spec(self)
       end
 
     end

data/lib/remarkable_activerecord/matchers/validate_presence_of_matcher.rb

@@ -56,8 +56,8 @@ module Remarkable
       #   should_validate_presence_of :name, :phone_number
       #   it { should validate_presence_of(:name, :phone_number) }
       #
-      def validate_presence_of(*args)
-        ValidatePresenceOfMatcher.new(*args).spec(self)
+      def validate_presence_of(*args, &block)
+        ValidatePresenceOfMatcher.new(*args, &block).spec(self)
       end
     end
   end

data/lib/remarkable_activerecord/matchers/validate_uniqueness_of_matcher.rb

@@ -134,11 +134,36 @@ module Remarkable
 
             super
           end
-
-          # 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.
+
+          # 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
+          # and searching for them in the database.
           #
-          def new_value_for_scope(scope)
+          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
@@ -188,12 +213,20 @@ module Remarkable
       # == Examples
       #
       #   it { should validate_uniqueness_of(:keyword, :username) }
-      #   it { should validate_uniqueness_of(:name, :message => "O NOES! SOMEONE STOELED YER NAME!") }
       #   it { should validate_uniqueness_of(:email, :scope => :name, :case_sensitive => false) }
-      #   it { should validate_uniqueness_of(:address, :scope => [:first_name, :last_name]) }
+      #   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
+      #   end
       #
-      def validate_uniqueness_of(*attributes)
-        ValidateUniquenessOfMatcher.new(*attributes).spec(self)
+      def validate_uniqueness_of(*attributes, &block)
+        ValidateUniquenessOfMatcher.new(*attributes, &block).spec(self)
       end
     end
   end

data/locale/en.yml

@@ -1,6 +1,10 @@
 en:
   remarkable:
     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}}"
@@ -25,6 +29,10 @@ en:
           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}}"
@@ -239,7 +247,7 @@ en:
           valid_with_new_scope: "{{subject_name}} to be valid when {{attribute}} scope ({{method}}) change"
         optionals:
           scope:
-            positive: "scoped to {{inspect}}"
+            positive: "scoped to {{sentence}}"
           case_sensitive:
             positive: "case sensitive"
             negative: "case insensitive"

data/spec/accept_nested_attributes_for_matcher_spec.rb

@@ -26,6 +26,10 @@ if RAILS_VERSION == '2.3.2'
 
         matcher.allow_destroy
         matcher.description.should == 'accept nested attributes for category allowing destroy'
+
+        matcher.accept(:name => 'jose')
+        matcher.accept(:name => 'maria')
+        matcher.description.should == 'accept nested attributes for category allowing destroy and accepting {:name=>"jose"} and {:name=>"maria"}'
       end
 
       it 'should set association_match? message' do
@@ -108,6 +112,13 @@ if RAILS_VERSION == '2.3.2'
       should_accept_nested_attributes_for :category, :accept => [ { :name => 'Jose' }, { :name => 'Maria' } ]
       should_accept_nested_attributes_for :category, :reject => [ { :name => '' } ]
 
+      should_accept_nested_attributes_for :category do |m|
+        m.allow_destroy
+        m.accept :name => "Jose"
+        m.accept :name => "Maria"
+        m.reject :name => ""
+      end
+
       should_not_accept_nested_attributes_for :nothing
       should_not_accept_nested_attributes_for :labels
       should_not_accept_nested_attributes_for :tags

data/spec/association_matcher_spec.rb

@@ -149,7 +149,14 @@ describe 'association_matcher' do
       should_belong_to :company, :readonly    => true
       should_belong_to :company, :validate    => true
       should_belong_to :company, :class_name  => "Company"
-      should_belong_to :company, :foreign_key => :company_id
+      should_belong_to :company, :foreign_key => :company_id
+
+      should_belong_to :company do |m|
+        m.readonly
+        m.validate
+        m.class_name = "Company"
+        m.foreign_key = :company_id
+      end
 
       should_not_belong_to :project
       should_not_have_one  :company
@@ -291,7 +298,14 @@ describe 'association_matcher' do
       should_have_and_belong_to_many :labels, :readonly    => true
       should_have_and_belong_to_many :labels, :validate    => true
       should_have_and_belong_to_many :labels, :class_name  => "Label"
-      should_have_and_belong_to_many :labels, :foreign_key => :project_id
+      should_have_and_belong_to_many :labels, :foreign_key => :project_id
+
+      should_have_and_belong_to_many :labels do |m|
+        m.readonly
+        m.validate
+        m.class_name "Label"
+        m.foreign_key :project_id
+      end
 
       should_not_have_and_belong_to_many :companies
       should_not_have_one  :label
@@ -455,7 +469,13 @@ describe 'association_matcher' do
       should_have_many :tasks
       should_have_many :tasks, :readonly => true
       should_have_many :tasks, :validate => true
-      should_have_many :tasks, :through => :project_tasks
+      should_have_many :tasks, :through => :project_tasks
+
+      should_have_many :tasks do |m|
+        m.readonly
+        m.validate
+        m.through = :project_tasks
+      end
 
       should_not_have_many :tasks, :readonly => false
       should_not_have_many :tasks, :validate => false
@@ -605,7 +625,12 @@ describe 'association_matcher' do
 
       should_have_one :manager
       should_have_one :manager, :validate => true
-      should_have_one :manager, :through => :project_managers
+      should_have_one :manager, :through => :project_managers
+
+      should_have_one :manager do |m|
+        m.validate
+        m.through = :project_managers
+      end
 
       should_not_have_one :manager, :validate => false
       should_not_have_one :manager, :through => :another_thing

data/spec/describe_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+RAILS_I18n = true
+
+class Post
+  attr_accessor :title, :published, :public
+ 
+  def initialize(attributes={})
+    attributes.each do |key, value|
+      send(:"#{key}=", value)
+    end
+  end
+
+  def self.human_name(*args)
+    "MyPost"
+  end
+end unless defined?(Post)
+
+describe Post do
+  it "should use human name on description" do
+    self.class.description.should == "MyPost"
+  end
+
+  describe :published => true do
+    it "should set the subject with published equals to true" do
+      subject.published.should be_true
+    end
+
+    it "should generate a readable description" do
+      self.class.description.should == "MyPost when published is true"
+    end
+
+    describe :public => false do
+      it "should nest subject attributes" do
+        subject.published.should be_true
+        subject.public.should be_false
+      end
+
+      it "should nest descriptions" do
+        self.class.description.should == "MyPost when published is true and public is false"
+      end
+    end
+  end
+
+  describe :published => true, :public => false do
+    it "should set the subject with published equals to true and public equals to false" do
+      subject.published.should be_true
+      subject.public.should be_false
+    end
+
+    it "should include both published and public in descriptions" do
+      self.class.description.should match(/MyPost/)
+      self.class.description.should match(/public is false/)
+      self.class.description.should match(/published is true/)
+    end
+  end
+end

data/spec/have_column_matcher_spec.rb

@@ -61,7 +61,12 @@ describe 'have_column_matcher' do
     should_have_column :email, :limit => 255
     should_have_column :email, :default => 'jose.valim@gmail.com'
     should_have_column :price, :precision => 10
-    should_have_column :price, :precision => 10, :scale => 2
+    should_have_column :price, :precision => 10, :scale => 2
+
+    should_have_column :price do |m|
+      m.scale = 2
+      m.precision = 10
+    end
 
     should_not_have_column :name,  :null => false
     should_not_have_column :email, :limit => 400

data/spec/have_scope_matcher_spec.rb

@@ -49,7 +49,8 @@ describe 'have_scope' do
     it { should have_scope(:recent, :order => 'created_at DESC') }
 
     it { should have_scope(:latest).with(10).limit(10) }
-    it { should have_scope(:beginning).with(10).offset(10) }
+    it { should have_scope(:beginning).with(10).offset(10) }
+    it { should have_scope(:since).with(false).conditions(["created_at > ?", false]) }
     it { should have_scope(:since).with(Time.at(0)).conditions(["created_at > ?", Time.at(0)]) }
     it { should have_scope(:between).with(2, 10).conditions(["created_at > ? and created_at < ?", 2, 10]) }
 
@@ -66,8 +67,14 @@ describe 'have_scope' do
 
     should_have_scope :latest,    :with => 10, :limit => 10
     should_have_scope :beginning, :with => 10, :offset => 10
+    should_have_scope :since,     :with => false, :conditions => ["created_at > ?", false]
     should_have_scope :since,     :with => Time.at(0), :conditions => ["created_at > ?", Time.at(0)]
-    should_have_scope :between,   :with => [ 2, 10 ],  :conditions => [ "created_at > ? and created_at < ?", 2, 10 ]
+    should_have_scope :between,   :with => [ 2, 10 ],  :conditions => [ "created_at > ? and created_at < ?", 2, 10 ]
+
+    should_have_scope :between do |m|
+      m.with(2, 10)
+      m.conditions([ "created_at > ? and created_at < ?", 2, 10 ])
+    end
 
     should_not_have_scope :null
     should_not_have_scope :latest,    :with => 5, :limit => 10

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 require 'rubygems'
 require 'ruby-debug'
 
-RAILS_VERSION = ENV['RAILS_VERSION'] || '=2.2.2'
+RAILS_VERSION = ENV['RAILS_VERSION'] || '2.3.2'
 
 gem 'activesupport', RAILS_VERSION
 require 'active_support'

data/spec/validate_associated_matcher_spec.rb

@@ -110,7 +110,11 @@ describe 'validate_associated' do
 
     describe 'has_many with builder' do
       before(:each){ define_and_validate(:has_many, :tasks, :with_builder => true) }
-      should_validate_associated(:tasks){ |p| p.tasks.build(:name => true) }
+      should_validate_associated :tasks, :builder => proc{ |p| p.tasks.build(:name => true) }
+
+      should_validate_associated :tasks do |m|
+        m.builder { |p| p.tasks.build(:name => true) }
+      end
     end
 
     describe 'has_and_belongs_to_many with skip validation' do

data/spec/validate_length_of_matcher_spec.rb

@@ -155,11 +155,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_not_validate_length_of :category, :in => 3..5
+
+    should_validate_length_of :size do |m|
+      m.in = 3..5
+    end
   end
 end

data/spec/validate_numericality_of_matcher_spec.rb

@@ -172,9 +172,15 @@ describe 'validate_numericality_of' do
     should_validate_numericality_of :price
     should_validate_numericality_of :price, :less_than => 100000
     should_validate_numericality_of :price, :greater_than => 9999
-    should_validate_numericality_of :price, :less_than => 100000, :greater_than => 999
+    should_validate_numericality_of :price, :less_than => 100000, :greater_than => 999
+
     should_not_validate_numericality_of :size
     should_not_validate_numericality_of :price, :less_than => 55555
-    should_not_validate_numericality_of :price, :greater_than => 55555
+    should_not_validate_numericality_of :price, :greater_than => 55555
+
+    should_validate_numericality_of :price do |m|
+      m.less_than 100000
+      m.greater_than 999
+    end
   end
 end

data/spec/validate_uniqueness_of_matcher_spec.rb

@@ -5,12 +5,12 @@ describe 'validate_uniqueness_of' do
 
   # Defines a model, create a validation and returns a raw matcher
   def define_and_validate(options={})
-    @model = define_model :user, :username => :string, :email => :integer, :access_code => :string do
+    @model = define_model :user, :username => :string, :email => :string, :public => :boolean, :deleted_at => :timestamp do
       validates_uniqueness_of :username, options
     end
 
     # Create a model
-    User.create(:username => 'jose')
+    User.create(:username => 'jose', :deleted_at => 1.day.ago, :public => false)
 
     validate_uniqueness_of(:username)
   end
@@ -21,23 +21,25 @@ describe 'validate_uniqueness_of' do
     it 'should contain a description' do
       @matcher.description.should == 'require unique values for username'
 
-      @matcher.scope(:email)
-      @matcher.description.should == 'require unique values for username scoped to [:email]'
-
-      @matcher.scope(:email, :access_code)
-      @matcher.description.should == 'require unique values for username scoped to [:email, :access_code]'
-
       @matcher.case_sensitive
-      @matcher.description.should == 'require unique values for username scoped to [:email, :access_code] and case sensitive'
+      @matcher.description.should == 'require unique values for username case sensitive'
 
       @matcher.case_sensitive(false)
-      @matcher.description.should == 'require unique values for username scoped to [:email, :access_code] and case insensitive'
+      @matcher.description.should == 'require unique values for username case insensitive'
 
       @matcher.allow_nil
-      @matcher.description.should == 'require unique values for username scoped to [:email, :access_code], case insensitive, and allowing nil values'
+      @matcher.description.should == 'require unique values for username case insensitive and allowing nil values'
 
       @matcher.allow_blank(false)
-      @matcher.description.should == 'require unique values for username scoped to [:email, :access_code], case insensitive, allowing nil values, and not allowing blank values'
+      @matcher.description.should == 'require unique values for username case insensitive, allowing nil values, and not allowing blank values'
+
+      @matcher = validate_uniqueness_of(:username, :scope => :email)
+      @matcher.description.should == 'require unique values for username scoped to :email'
+
+      @matcher = validate_uniqueness_of(:username)
+      @matcher.scope(:email)
+      @matcher.scope(:public)
+      @matcher.description.should == 'require unique values for username scoped to :email and :public'
     end
 
     it 'should set responds_to_scope? message' do
@@ -72,10 +74,13 @@ describe 'validate_uniqueness_of' do
     end
 
     describe 'scoped to' do
-      it { should define_and_validate(:scope => :email).scope(:email) }
-      it { should define_and_validate(:scope => [:email, :access_code]).scope(:email, :access_code) }
+      it { should define_and_validate(:scope => :email).scope(:email) }
+      it { should define_and_validate(:scope => :public).scope(:public) }
+      it { should define_and_validate(:scope => :deleted_at).scope(:deleted_at) }
+      it { should define_and_validate(:scope => [:email, :public]).scope(:email, :public) }
+      it { should define_and_validate(:scope => [:email, :public, :deleted_at]).scope(:email, :public, :deleted_at) }
       it { should_not define_and_validate(:scope => :email).scope(:title) }
-      it { should_not define_and_validate(:scope => :email).scope(:access_code) }
+      it { should_not define_and_validate(:scope => :email).scope(:public) }
     end
 
     create_message_specs(self)
@@ -169,6 +174,10 @@ describe 'validate_uniqueness_of' do
     should_validate_uniqueness_of :username
     should_validate_uniqueness_of :username, :scope => :email
     should_not_validate_uniqueness_of :email
-    should_not_validate_uniqueness_of :username, :scope => :access_code
+    should_not_validate_uniqueness_of :username, :scope => :access_code
+
+    should_validate_uniqueness_of :username do |m|
+      m.scope :email
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: remarkable_activerecord
 version: !ruby/object:Gem::Version 
-  version: 3.0.8
+  version: 3.0.9
 platform: ruby
 authors: 
 - Carlos Brando
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-24 00:00:00 +02:00
+date: 2009-04-25 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,7 +22,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 3.0.8
+        version: 3.0.9
     version: 
 description: "Remarkable ActiveRecord: collection of matchers and macros with I18n for ActiveRecord"
 email: 
@@ -43,6 +43,7 @@ files:
 - CHANGELOG
 - lib/remarkable_activerecord/base.rb
 - lib/remarkable_activerecord/human_names.rb
+- lib/remarkable_activerecord/describe.rb
 - lib/remarkable_activerecord/matchers/validate_confirmation_of_matcher.rb
 - lib/remarkable_activerecord/matchers/validate_length_of_matcher.rb
 - lib/remarkable_activerecord/matchers/have_default_scope_matcher.rb
@@ -98,6 +99,7 @@ test_files:
 - spec/spec_helper.rb
 - spec/validate_acceptance_of_matcher_spec.rb
 - spec/accept_nested_attributes_for_matcher_spec.rb
+- spec/describe_spec.rb
 - spec/allow_mass_assignment_of_matcher_spec.rb
 - spec/have_scope_matcher_spec.rb
 - spec/validate_inclusion_of_matcher_spec.rb