remarkable_activerecord 3.0.7 → 3.0.8

data/CHANGELOG

@@ -1,9 +1,15 @@
-* Allow all objects to be sent to have_scope (thanks to Szymon Nowak) [#53]
+* 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 all objects to be sent to have_scope (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. [#48]
+  group, having, order, limit and offset, plus finder_sql and counter_sql. [#48]
 
-* :source and :source_type are not supported by association matcher [#47]
+* :source and :source_type are now supported by association matcher [#47]
 
 * validate_inclusion_of became smarter since it now tests invalid values too [#36]
 

data/lib/remarkable_activerecord/matchers/accept_nested_attributes_for_matcher.rb

@@ -0,0 +1,121 @@
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class AcceptNestedAttributesForMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        arguments :collection => :associations, :as => :association
+
+        collection_assertions :association_exists?, :is_autosave?, :responds_to_attributes?,
+                              :allows_destroy?, :accepts?, :rejects?
+
+        optionals :allow_destroy, :default => true
+        optionals :accept, :reject, :splat => true
+
+        protected
+
+          def association_exists?
+            reflection
+          end
+
+          def is_autosave?
+            reflection.options[:autosave] == true
+          end
+
+          def responds_to_attributes?
+            @subject.respond_to?(:"#{@association}_attributes=", true)
+          end
+
+          def allows_destroy?
+            return true unless @options.key?(:allow_destroy)
+
+            @subject.instance_eval <<-ALLOW_DESTROY
+              def assign_nested_attributes_for_#{reflection_type}_association(association, attrs, allow)
+                return allow
+              end
+            ALLOW_DESTROY
+
+            actual = @subject.send(:"#{@association}_attributes=", {})
+            return actual == @options[:allow_destroy], :actual => actual
+          end
+
+          def accepts?
+            return true unless @options.key?(:accept)
+
+            [@options[:accept]].flatten.each do |attributes|
+              return false, :attributes => attributes.inspect if reject_if_proc.call(attributes)
+            end
+
+            true
+          end
+
+          def rejects?
+            return true unless @options.key?(:reject)
+
+            [@options[:reject]].flatten.each do |attributes|
+              return false, :attributes => attributes.inspect unless reject_if_proc.call(attributes)
+            end
+
+            true
+          end
+
+        private
+
+          def reflection
+            @reflection ||= subject_class.reflect_on_association(@association.to_sym)
+          end
+
+          def reflection_type
+            case reflection.macro
+              when :has_one, :belongs_to
+                :one_to_one
+              when :has_many, :has_and_belongs_to_many
+                :collection
+            end
+          end
+
+          def reject_if_proc
+            subject_class.reject_new_nested_attributes_procs[@association.to_sym]
+          end
+
+      end
+
+      # Ensures that the model accepts nested attributes for the given associations.
+      #
+      # == Options
+      #
+      # * <tt>allow_destroy</tt> - When true allows the association to be destroyed
+      # * <tt>accept</tt> - attributes that should be accepted by the :reject_if proc
+      # * <tt>reject</tt> - attributes that should be rejected by the :reject_if proc
+      #
+      # == Examples
+      #
+      #   should_accept_nested_attributes_for :tasks
+      #   should_accept_nested_attributes_for :tasks, :allow_destroy => true
+      #
+      # :accept and :reject takes objects that are verified against the proc. So
+      # having a model:
+      #
+      #   class Projects < ActiveRecord::Base
+      #     has_many :tasks
+      #     accepts_nested_attributes_for :tasks, :reject_if => proc { |a| a[:name].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, :accept => { :name => 'My task' },
+      #                                               :reject => { :name => '' }        # Passes
+      #
+      #   should_accept_nested_attributes_for :tasks, :accept => { :name => '' }        # Fail
+      #   should_accept_nested_attributes_for :tasks, :reject => { :name => 'My task' } # Fail
+      #
+      # You can also give arrays to :accept and :reject to verify multiple attributes.
+      #
+      def accept_nested_attributes_for(*args)
+        AcceptNestedAttributesForMatcher.new(*args).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/have_default_scope_matcher.rb

@@ -0,0 +1,67 @@
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class HaveDefaultScopeMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        arguments
+        assertions :options_match?
+
+        optionals :select, :conditions, :join, :include, :group, :having, :order, :limit, :offset
+
+        protected
+
+          def options_match?
+            default_scope.include?(@options)
+          end
+
+          def default_scope
+            @default_scope ||= if @subject
+              scopes = subject_class.default_scoping || []
+              scopes.map!{ |s| s[:find] }
+            else
+              []
+            end
+          end
+
+          def interpolation_options
+            { :options => @options.inspect, :actual => default_scope.inspect }
+          end
+
+      end
+
+      # Ensures that the model has a default scope with the given options.
+      #
+      # == Options
+      #
+      # All options that the default scope would pass on to find: select, conditions,
+      # join, include, group, having, order, limit e offset.
+      #
+      # == Examples
+      #
+      #   it { should have_default_scope(:conditions => {:visible => true}) }
+      #   it { should have_default_scope.conditions(:visible => true) }
+      #
+      # Passes for:
+      #
+      #   default_scope :conditions => { :visible => true }
+      #
+      # If you set two different default scopes, you have to spec them
+      # separatedly. Given the scopes:
+      #
+      #   default_scope :conditions => { :visible => true }
+      #   default_scope :conditions => { :published => true }
+      #
+      # Then we have the matchers:
+      #
+      #   should_have_default_scope :conditions => { :visible => true }   # Passes
+      #   should_have_default_scope :conditions => { :published => true } # Passes
+      #
+      #   should_have_default_scope :conditions => { :published => true,
+      #                                               :visible => true }  # Fails
+      #
+      def have_default_scope(*args)
+        HaveDefaultScopeMatcher.new(*args).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/have_scope_matcher.rb

@@ -5,13 +5,18 @@ module Remarkable
         arguments :scope_name
         assertions :is_scope?, :options_match?
 
-        optionals :with, :select, :conditions, :order, :limit, :offset
+        optionals :with, :splat => true
+        optionals :select, :conditions, :join, :include, :group, :having, :order, :limit, :offset
 
         protected
 
           def is_scope?
             @scope_object = if @options[:with]
-              subject_class.send(@scope_name, @options[:with])
+              if @options[:with].is_a?(Array)
+                subject_class.send(@scope_name, *@options[:with])
+              else
+                subject_class.send(@scope_name, @options[:with])
+              end
             else
               subject_class.send(@scope_name)
             end

data/lib/remarkable_activerecord/matchers/validate_presence_of_matcher.rb

@@ -1,5 +1,40 @@
 module Remarkable
-  module ActiveRecord
+  module ActiveRecord
+    # Holds ActiveRecord matchers.
+    #
+    # == Validations matchers
+    #
+    # Remarkable supports all ActiveRecord validations, and the only options
+    # not supported in those matchers is the :on options. So whenever you have
+    # to test that a validation runs on update, you have to do reproduce the
+    # state in your tests:
+    #
+    #   describe Project do
+    #     describe 'validations on create' do
+    #       should_validate_presence_of :title
+    #     end
+    #
+    #     describe 'validations on update' do
+    #       subject { Post.create!(@valid_attributes) }
+    #       should_validate_presence_of :updated_at
+    #     end
+    #   end
+    #
+    # Another behavior in validations is the :message option. Whenever you change
+    # the message in your model, it must be given in your tests too:
+    #
+    #   class Post < ActiveRecord::Base
+    #     validates_presence_of :title, :message => 'must be filled'
+    #   end
+    #
+    #   describe Post do
+    #     should_validate_presence_of :title #=> fails
+    #     should_validate_presence_of :title, :message => 'must be filled'
+    #   end
+    #
+    # However, if you change the title using the I18n API, you don't need to
+    # specify the message in your tests, because it's retrieved properly.
+    #
     module Matchers
       class ValidatePresenceOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
         arguments :collection => :attributes, :as => :attribute

data/lib/remarkable_activerecord/matchers/validate_uniqueness_of_matcher.rb

@@ -165,7 +165,16 @@ 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.
+      # 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
+      # will be raised.
       #
       # == Options
       #

data/locale/en.yml

@@ -11,6 +11,20 @@ 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"
 
       allow_values_for:
         description: "allow {{in}} as values for {{attributes}}"
@@ -103,7 +117,12 @@ 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:
+          options_match: "default scope with {{options}}, got {{actual}}"
 
       have_index:
         description: "have index for column(s) {{columns}}"

data/spec/accept_nested_attributes_for_matcher_spec.rb

@@ -0,0 +1,119 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+if RAILS_VERSION == '2.3.2'
+  describe 'accept_nested_attributes_for' do
+    include ModelBuilder
+
+    def define_and_validate(default=:category, options={})
+      @model = define_model :product do
+        has_one :category
+        has_many :orders
+        has_many :labels
+        has_many :tags, :autosave => true
+
+        accepts_nested_attributes_for :category, options
+        accepts_nested_attributes_for :orders, options
+      end
+
+      accept_nested_attributes_for *default
+    end
+
+    describe 'messages' do
+
+      it 'should contain a description' do
+        matcher = define_and_validate
+        matcher.description.should == 'accept nested attributes for category'
+
+        matcher.allow_destroy
+        matcher.description.should == 'accept nested attributes for category allowing destroy'
+      end
+
+      it 'should set association_match? message' do
+        matcher = define_and_validate(:nothing)
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected Product to have association nothing, but does not'
+      end
+
+      it 'should set is_autosave? message' do
+        matcher = define_and_validate(:labels)
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected Product to have association labels with autosave true, got false'
+      end
+
+      it 'should set responds_to_attributes? message' do
+        matcher = define_and_validate(:tags)
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected Product to respond to :tags_attributes=, but does not'
+      end
+
+      it 'should set allows_destroy? message' do
+        matcher = define_and_validate(:category, :allow_destroy => false)
+        matcher.allow_destroy.matches?(@model)
+        matcher.failure_message.should == 'Expected Product with allow destroy equals to true, got false'
+      end
+
+      it 'should set accepts? message' do
+        matcher = define_and_validate(:category, :reject_if => proc{|a| true })
+        matcher.accept({}).matches?(@model)
+        matcher.failure_message.should == 'Expected Product to accept attributes {} for category, but does not'
+      end
+
+      it 'should set rejects? message' do
+        matcher = define_and_validate(:category, :reject_if => proc{|a| false })
+        matcher.reject({}).matches?(@model)
+        matcher.failure_message.should == 'Expected Product to reject attributes {} for category, but does not'
+      end
+
+    end
+
+    describe 'matchers' do
+      it { should define_and_validate(:category) }
+      it { should define_and_validate(:orders) }
+
+      it { should_not define_and_validate(:nothing) }
+      it { should_not define_and_validate(:labels) }
+      it { should_not define_and_validate(:tags) }
+
+      describe 'with allow destroy as option' do
+        it { should define_and_validate(:category, :allow_destroy => true).allow_destroy }
+        it { should define_and_validate(:category, :allow_destroy => false).allow_destroy(false) }
+        it { should_not define_and_validate(:category, :allow_destroy => false).allow_destroy }
+        it { should_not define_and_validate(:category, :allow_destroy => true).allow_destroy(false) }
+
+        it { should define_and_validate(:orders, :allow_destroy => true).allow_destroy }
+        it { should define_and_validate(:orders, :allow_destroy => false).allow_destroy(false) }
+        it { should_not define_and_validate(:orders, :allow_destroy => false).allow_destroy }
+        it { should_not define_and_validate(:orders, :allow_destroy => true).allow_destroy(false) }
+      end
+
+      describe 'with accept as option' do
+        it { should define_and_validate(:category, :reject_if => proc{ |a| a[:name].blank? }).accept({ :name => 'Jose' }) }
+        it { should define_and_validate(:category, :reject_if => proc{ |a| a[:name].blank? }).accept({ :name => 'Jose' }, { :name => 'Maria' }) }
+        it { should_not define_and_validate(:category, :reject_if => proc{ |a| a[:name].blank? }).accept({ :name => '' }) }
+      end
+
+      describe 'with reject as option' do
+        it { should define_and_validate(:category, :reject_if => proc{ |a| !a[:name].blank? }).reject({ :name => 'Jose' }) }
+        it { should define_and_validate(:category, :reject_if => proc{ |a| !a[:name].blank? }).reject({ :name => 'Jose' }, { :name => 'Maria' }) }
+        it { should_not define_and_validate(:category, :reject_if => proc{ |a| !a[:name].blank? }).reject({ :name => '' }) }
+      end
+    end
+
+    describe 'macros' do
+      before(:each){ define_and_validate(:category, :allow_destroy => true, :reject_if => proc{ |a| a[:name].blank? }) }
+
+      should_accept_nested_attributes_for :category
+      should_accept_nested_attributes_for :category, :allow_destroy => true
+      should_accept_nested_attributes_for :category, :accept => { :name => 'Jose' }
+      should_accept_nested_attributes_for :category, :accept => [ { :name => 'Jose' }, { :name => 'Maria' } ]
+      should_accept_nested_attributes_for :category, :reject => [ { :name => '' } ]
+
+      should_not_accept_nested_attributes_for :nothing
+      should_not_accept_nested_attributes_for :labels
+      should_not_accept_nested_attributes_for :tags
+      should_not_accept_nested_attributes_for :category, :allow_destroy => false
+      should_not_accept_nested_attributes_for :category, :accept => [ { :name => '' } ]
+      should_not_accept_nested_attributes_for :category, :reject => [ { :name => 'Jose' }, { :name => 'Maria' } ]
+    end
+  end
+end

data/spec/have_default_scope_matcher_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+if RAILS_VERSION == '2.3.2'
+  describe 'have_default_scope' do
+    include ModelBuilder
+
+    before(:each) do
+      @model = define_model :product, :published => :boolean do
+        default_scope :order => 'created_at DESC'
+        default_scope :conditions => { :published => true }
+      end
+    end
+
+    describe 'messages' do
+
+      it 'should contain a description' do
+        matcher = have_default_scope(:conditions => {:special => true})
+        matcher.description.should == 'have a default scope with {:conditions=>{:special=>true}}'
+      end
+
+      it 'should set options_match? message' do
+        matcher = have_default_scope(:conditions => {:special => true})
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected default scope with {:conditions=>{:special=>true}}, got [{:order=>"created_at DESC"}, {:conditions=>{:published=>true}}]'
+      end
+
+    end
+
+    describe 'matchers' do
+      it { should have_default_scope(:order => 'created_at DESC') }
+      it { should have_default_scope(:conditions => { :published => true }) }
+
+      it { should_not have_default_scope(:order => 'created_at ASC') }
+      it { should_not have_default_scope(:conditions => { :published => false }) }
+      it { should_not have_default_scope(:conditions => { :published => true }, :order => 'created_at DESC') }
+
+      describe 'when the model has no default scope' do
+        before(:each){ @model = define_model(:task) }
+        it { @model.should_not have_default_scope }
+      end
+    end
+
+    describe 'macros' do
+      should_have_default_scope :order => 'created_at DESC'
+      should_have_default_scope :conditions => { :published => true }
+
+      should_not_have_default_scope :order => 'created_at ASC'
+      should_not_have_default_scope :conditions => { :published => false }
+      should_not_have_default_scope :conditions => { :published => true }, :order => 'created_at DESC'
+    end
+  end
+end

data/spec/have_scope_matcher_spec.rb

@@ -8,6 +8,7 @@ describe 'have_scope' do
       named_scope :recent, :order => 'created_at DESC'
       named_scope :latest, lambda {|c| {:limit => c}}
       named_scope :since, lambda {|t| {:conditions => ['created_at > ?', t]}}
+      named_scope :between, lambda { |a, b| { :conditions => [ 'created_at > ? and created_at < ?', a, b ] } }
 
       def self.beginning(c)
         scoped(:offset => c)
@@ -22,23 +23,23 @@ describe 'have_scope' do
   describe 'messages' do
 
     it 'should contain a description' do
-      @matcher = have_scope(:title)
-      @matcher.description.should == 'have to scope itself to {} when :title is called'
+      matcher = have_scope(:title)
+      matcher.description.should == 'have to scope itself to {} when :title is called'
 
-      @matcher.with(1)
-      @matcher.description.should == 'have to scope itself to {} when :title is called with 1 as argument'
+      matcher.with(1)
+      matcher.description.should == 'have to scope itself to {} when :title is called with [1] as argument'
     end
 
     it 'should set is_scope? message' do
-      @matcher = have_scope(:null)
-      @matcher.matches?(@model)
-      @matcher.failure_message.should == 'Expected :null when called on Product return an instance of ActiveRecord::NamedScope::Scope'
+      matcher = have_scope(:null)
+      matcher.matches?(@model)
+      matcher.failure_message.should == 'Expected :null when called on Product return an instance of ActiveRecord::NamedScope::Scope'
     end
 
     it 'should set options_match? message' do
-      @matcher = have_scope(:recent, :conditions => {:special => true})
-      @matcher.matches?(@model)
-      @matcher.failure_message.should == 'Expected :recent when called on Product scope to {:conditions=>{:special=>true}}, got {:order=>"created_at DESC"}'
+      matcher = have_scope(:recent, :conditions => {:special => true})
+      matcher.matches?(@model)
+      matcher.failure_message.should == 'Expected :recent when called on Product scope to {:conditions=>{:special=>true}}, got {:order=>"created_at DESC"}'
     end
 
   end
@@ -47,14 +48,16 @@ describe 'have_scope' do
     it { should have_scope(:recent) }
     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(:since,     :with => Time.at(0), :conditions => ["created_at > ?", Time.at(0)]) }
+    it { should have_scope(:latest).with(10).limit(10) }
+    it { should have_scope(:beginning).with(10).offset(10) }
+    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]) }
 
-    it { should_not have_scope(:null) }
-    it { should_not have_scope(:latest,    :with => 5, :limit => 10) }
-    it { should_not have_scope(:beginning, :with => 5, :offset => 10) }
-    it { should_not have_scope(:since,     :with => Time.at(0), :conditions => ["created_at > ?", Time.at(1)]) }
+    it { should_not have_scope(:null) }
+    it { should_not have_scope(:latest).with(5).limit(10) }
+    it { should_not have_scope(:beginning).with(5).offset(10) }
+    it { should_not have_scope(:since).with(Time.at(0)).conditions(["created_at > ?", Time.at(1)]) }
+    it { should_not have_scope(:between).with(2, 10).conditions(["updated_at > ? and updated_at < ?", 2, 10]) }
   end
 
   describe 'macros' do
@@ -64,10 +67,12 @@ 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 => 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_not_have_scope :null
     should_not_have_scope :latest,    :with => 5, :limit => 10
     should_not_have_scope :beginning, :with => 5, :offset => 10
     should_not_have_scope :since,     :with => Time.at(0), :conditions => ["created_at > ?", Time.at(1)]
+    should_not_have_scope :between,   :with => [ 2, 10 ],  :conditions => [ "updated_at > ? and updated_at < ?", 2, 10 ]
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: remarkable_activerecord
 version: !ruby/object:Gem::Version 
-  version: 3.0.7
+  version: 3.0.8
 platform: ruby
 authors: 
 - Carlos Brando
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-22 00:00:00 +02:00
+date: 2009-04-24 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.7
+        version: 3.0.8
     version: 
 description: "Remarkable ActiveRecord: collection of matchers and macros with I18n for ActiveRecord"
 email: 
@@ -41,13 +41,13 @@ files:
 - README
 - LICENSE
 - CHANGELOG
-- lib/remarkable_activerecord
 - lib/remarkable_activerecord/base.rb
 - lib/remarkable_activerecord/human_names.rb
-- lib/remarkable_activerecord/matchers
 - 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
 - lib/remarkable_activerecord/matchers/have_readonly_attributes_matcher.rb
+- lib/remarkable_activerecord/matchers/accept_nested_attributes_for_matcher.rb
 - lib/remarkable_activerecord/matchers/validate_exclusion_of_matcher.rb
 - lib/remarkable_activerecord/matchers/validate_associated_matcher.rb
 - lib/remarkable_activerecord/matchers/have_column_matcher.rb
@@ -65,6 +65,8 @@ files:
 - locale/en.yml
 has_rdoc: true
 homepage: http://github.com/carlosbrando/remarkable
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -85,9 +87,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: remarkable
-rubygems_version: 1.3.1
+rubygems_version: 1.3.2
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: "Remarkable ActiveRecord: collection of matchers and macros with I18n for ActiveRecord"
 test_files: 
 - spec/validate_associated_matcher_spec.rb
@@ -95,6 +97,7 @@ test_files:
 - spec/rcov.opts
 - spec/spec_helper.rb
 - spec/validate_acceptance_of_matcher_spec.rb
+- spec/accept_nested_attributes_for_matcher_spec.rb
 - spec/allow_mass_assignment_of_matcher_spec.rb
 - spec/have_scope_matcher_spec.rb
 - spec/validate_inclusion_of_matcher_spec.rb
@@ -104,6 +107,7 @@ test_files:
 - spec/allow_values_for_matcher_spec.rb
 - spec/validate_uniqueness_of_matcher_spec.rb
 - spec/have_column_matcher_spec.rb
+- spec/have_default_scope_matcher_spec.rb
 - spec/have_index_matcher_spec.rb
 - spec/association_matcher_spec.rb
 - spec/validate_exclusion_of_matcher_spec.rb