remarkable_activerecord 3.1.8 → 3.1.9

data/spec/accept_nested_attributes_for_matcher_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-if RAILS_VERSION == '2.3.2'
+if RAILS_VERSION == '2.3.3'
   describe 'accept_nested_attributes_for' do
     include ModelBuilder
 

data/spec/allow_mass_assignment_of_matcher_spec.rb

@@ -1,84 +1,84 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe 'allow_mass_assignment_of' do
-  include ModelBuilder
-
-  def define_and_validate(options={})
-    @model = define_model :product, :title => :string, :category => :string do
-      attr_protected  :title, :category     if options[:protected]
-
-      attr_accessible :title, :category     if options[:accessible] == true
-      attr_accessible *options[:accessible] if options[:accessible].is_a?(Array)
-    end
-
-    allow_mass_assignment_of(:title, :category)
-  end
-
-  describe 'messages' do
-
-    it 'should contain a description' 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)
-      @matcher.failure_message.should == 'Expected Product to allow mass assignment of title (Product is protecting title)'
-    end
-
-    it 'should set is_accessible? message' do
-      @matcher = define_and_validate(:accessible => [:another])
-      @matcher.matches?(@model)
-      @matcher.failure_message.should == 'Expected Product to allow mass assignment of title (Product has not made title accessible)'
-    end
-
-  end
-
-  describe 'matchers' do
-    it { should define_and_validate }
-    it { should define_and_validate(:accessible => true) }
-
-    it { should_not define_and_validate(:protected => true) }
-    it { should_not define_and_validate(:accessible => [:another]) }
-
-    describe 'with no argument' do
-      it 'should allow mass assignment if no attribute is accessible or protected' do
-        define_and_validate
-        should allow_mass_assignment_of
-      end
-
-      it 'should allow mass assignment if attributes are accessible' do
-        define_and_validate(:accessible => true)
-        should allow_mass_assignment_of
-      end
-
-      it 'should not allow mass assignment if attributes are protected' do
-        define_and_validate(:protected => true)
-        should_not allow_mass_assignment_of
-      end
-    end
-  end
-
-  describe 'macros' do
-    before(:each){ define_and_validate(:accessible => true) }
-
-    should_allow_mass_assignment_of :title
-    should_allow_mass_assignment_of :category
-    should_allow_mass_assignment_of :title, :category
-
-    should_not_allow_mass_assignment_of :another
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'allow_mass_assignment_of' do
+  include ModelBuilder
+
+  def define_and_validate(options={})
+    @model = define_model :product, :title => :string, :category => :string do
+      attr_protected  :title, :category     if options[:protected]
+
+      attr_accessible :title, :category     if options[:accessible] == true
+      attr_accessible *options[:accessible] if options[:accessible].is_a?(Array)
+    end
+
+    allow_mass_assignment_of(:title, :category)
+  end
+
+  describe 'messages' do
+
+    it 'should contain a description' 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)
+      @matcher.failure_message.should == 'Expected Product to allow mass assignment of title (Product is protecting title)'
+    end
+
+    it 'should set is_accessible? message' do
+      @matcher = define_and_validate(:accessible => [:another])
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow mass assignment of title (Product has not made title accessible)'
+    end
+
+  end
+
+  describe 'matchers' do
+    it { should define_and_validate }
+    it { should define_and_validate(:accessible => true) }
+
+    it { should_not define_and_validate(:protected => true) }
+    it { should_not define_and_validate(:accessible => [:another]) }
+
+    describe 'with no argument' do
+      it 'should allow mass assignment if no attribute is accessible or protected' do
+        define_and_validate
+        should allow_mass_assignment_of
+      end
+
+      it 'should allow mass assignment if attributes are accessible' do
+        define_and_validate(:accessible => true)
+        should allow_mass_assignment_of
+      end
+
+      it 'should not allow mass assignment if attributes are protected' do
+        define_and_validate(:protected => true)
+        should_not allow_mass_assignment_of
+      end
+    end
+  end
+
+  describe 'macros' do
+    before(:each){ define_and_validate(:accessible => true) }
+
+    should_allow_mass_assignment_of :title
+    should_allow_mass_assignment_of :category
+    should_allow_mass_assignment_of :title, :category
+
+    should_not_allow_mass_assignment_of :another
   end
 
   describe 'failures' do
-    it "should fail if not all attributes are accessible on should not" do
+    it "should fail if some attribute is accessible when it shuold be protected" do
       define_and_validate(:accessible => true)
 
       lambda {
@@ -86,13 +86,21 @@ describe 'allow_mass_assignment_of' do
       }.should raise_error(Spec::Expectations::ExpectationNotMetError, /Product has made title accessible/)
     end
 
-    it "should fail if accessible when protecting" do
+    it "should fail if attributes are accessible when none should" do
       define_and_validate(:accessible => true)
 
       lambda {
         should_not allow_mass_assignment_of
       }.should raise_error(Spec::Expectations::ExpectationNotMetError, /Product made category and title accessible/)
     end
-  end
-end
-
+
+    it "should fail if nothing was declared but expected to be protected" do
+      define_and_validate
+
+      lambda {
+        should_not allow_mass_assignment_of(:title)
+      }.should raise_error(Spec::Expectations::ExpectationNotMetError, /Did not expect Product to allow mass assignment of title/)
+    end
+  end
+end
+

data/spec/allow_values_for_matcher_spec.rb

@@ -1,71 +1,80 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe 'allow_values_for' do
-  include ModelBuilder
-
-  # Defines a model, create a validation and returns a raw matcher
-  def define_and_validate(options={})
-    @model = define_model :product, :title => :string, :category => :string do
-      validates_format_of :title, options
-    end
-
-    allow_values_for(:title)
-  end
-
-  describe 'messages' do
-    before(:each){ @matcher = define_and_validate(:with => /X|Y|Z/) }
-
-    it 'should contain a description' do
-      @matcher = allow_values_for(:title, "X", "Y", "Z")
-      @matcher.description.should == 'allow "X", "Y", and "Z" as values for title'
-    end
-
-    it 'should set is_valid? message' do
-      @matcher.in("A").matches?(@model)
-      @matcher.failure_message.should == 'Expected Product to be valid when title is set to "A"'
-    end
-
-    it 'should set allow_nil? message' do
-      @matcher.allow_nil.matches?(@model)
-      @matcher.failure_message.should == 'Expected Product to allow nil values for title'
-    end
-
-    it 'should set allow_blank? message' do
-      @matcher.allow_blank.matches?(@model)
-      @matcher.failure_message.should == 'Expected Product to allow blank values for title'
-    end
-  end
-
-  describe 'matchers' do
-    it { should define_and_validate(:with => /X|Y|Z/).in('X', 'Y', 'Z') }
-    it { should_not define_and_validate(:with => /X|Y|Z/).in('A') }
-
-    it { should define_and_validate(:with => /X|Y|Z/, :message => 'valid').in('X', 'Y', 'Z').message('valid') }
-
-    create_optional_boolean_specs(:allow_nil, self, :with => /X|Y|Z/)
-    create_optional_boolean_specs(:allow_blank, self, :with => /X|Y|Z/)
-  end
-
-  describe 'macros' do
-    before(:each){ define_and_validate(:with => /X|Y|Z/) }
-
-    should_allow_values_for :title, 'X'
-    should_not_allow_values_for :title, 'A'
-
-    describe 'deprecation' do
-      it { should validate_format_of(:title, 'X') }
-      should_not_validate_format_of :title, 'A'
-    end
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'allow_values_for' do
+  include ModelBuilder
+
+  # Defines a model, create a validation and returns a raw matcher
+  def define_and_validate(options={})
+    @model = define_model :product, :title => :string, :category => :string do
+      validates_format_of :title, options
+    end
+
+    allow_values_for(:title)
+  end
+
+  describe 'messages' do
+    before(:each){ @matcher = define_and_validate(:with => /X|Y|Z/) }
+
+    it 'should contain a description' do
+      @matcher = allow_values_for(:title, "X", "Y", "Z")
+      @matcher.description.should == 'allow "X", "Y", and "Z" as values for title'
+    end
+
+    it 'should set is_valid? message' do
+      @matcher.in("A").matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be valid when title is set to "A"'
+    end
+
+    it 'should set allow_nil? message' do
+      @matcher.allow_nil.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow nil values for title'
+    end
+
+    it 'should set allow_blank? message' do
+      @matcher.allow_blank.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow blank values for title'
+    end
+  end
+
+  describe 'matchers' do
+    it { should define_and_validate(:with => /X|Y|Z/).in('X', 'Y', 'Z') }
+
+    it { should_not define_and_validate(:with => /X|Y|Z/).in('A') }
+    it { should_not define_and_validate(:with => /X|Y|Z/, :message => 'invalid').in('A') }
+
+    create_optional_boolean_specs(:allow_nil, self, :with => /X|Y|Z/)
+    create_optional_boolean_specs(:allow_blank, self, :with => /X|Y|Z/)
+  end
+
+  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'
   end
 
   describe 'failures' do
-    it "should fail if any of the values are valid on invalid cases" do
+    before(:each) do
       define_and_validate(:with => /X|Y|Z/)
+    end
 
+    it "should fail if any of the values are valid on invalid cases" do
       lambda {
         should_not allow_values_for :title, 'A', 'X', 'B'
       }.should raise_error(Spec::Expectations::ExpectationNotMetError, /Did not expect Product to be valid/)
-    end
-  end
-end
-
+    end
+
+    it "should also fail if all values are valid" do
+      lambda {
+        should_not allow_values_for :title, 'X', 'Y', 'Z'
+      }.should raise_error(Spec::Expectations::ExpectationNotMetError, /Did not expect Product to be valid/)
+    end
+
+    it "should not fail if all values are invalid" do
+      lambda {
+        should_not allow_values_for :title, 'A', 'B', 'C'
+      }.should_not raise_error
+    end
+  end
+end
+

data/spec/association_matcher_spec.rb

@@ -1,170 +1,170 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe 'association_matcher' do
-  include ModelBuilder
-
-  describe 'belong_to' do
-
-    # Defines a model, create a validation and returns a raw matcher
-    def define_and_validate(options={})
-      columns = options.delete(:association_columns) || { :projects_count => :integer }
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'association_matcher' do
+  include ModelBuilder
+
+  describe 'belong_to' do
+
+    # Defines a model, create a validation and returns a raw matcher
+    def define_and_validate(options={})
+      columns = options.delete(:association_columns) || { :projects_count => :integer }
       define_model :company, columns
       define_model :super_company, columns
-
-      columns = options.delete(:model_columns) || { :company_id => :integer, :company_type => :string }
-      @model = define_model :project, columns do
+
+      columns = options.delete(:model_columns) || { :company_id => :integer, :company_type => :string }
+      @model = define_model :project, columns do
         belongs_to :company, options
         belongs_to :unknown
-        belongs_to :accountable, :polymorphic => true
-      end
-
-      belong_to :company
-    end
-
-    describe 'messages' do
-      it 'should contain a description' do
-        matcher = define_and_validate
-        matcher.description.should == 'belong to company'
-
-        matcher.class_name('Company')
-        matcher.description.should == 'belong to company with class name "Company"'
-
-        matcher.foreign_key('company_id')
-        matcher.description.should == 'belong to company with class name "Company" and with foreign key "company_id"'
-
-        matcher = belong_to(:company).dependent(:destroy)
-        matcher.description.should == 'belong to company with dependent :destroy'
-
-        matcher.readonly
-        matcher.description.should == 'belong to company with dependent :destroy and with readonly records'
-
-        matcher.as(:interface)
-        matcher.description.should == 'belong to company with dependent :destroy, through the polymorphic interface :interface, and with readonly records'
-
-        matcher.counter_cache('projects_count')
+        belongs_to :accountable, :polymorphic => true
+      end
+
+      belong_to :company
+    end
+
+    describe 'messages' do
+      it 'should contain a description' do
+        matcher = define_and_validate
+        matcher.description.should == 'belong to company'
+
+        matcher.class_name('Company')
+        matcher.description.should == 'belong to company with class name "Company"'
+
+        matcher.foreign_key('company_id')
+        matcher.description.should == 'belong to company with class name "Company" and with foreign key "company_id"'
+
+        matcher = belong_to(:company).dependent(:destroy)
+        matcher.description.should == 'belong to company with dependent :destroy'
+
+        matcher.readonly
+        matcher.description.should == 'belong to company with dependent :destroy and with readonly records'
+
+        matcher.as(:interface)
+        matcher.description.should == 'belong to company with dependent :destroy, through the polymorphic interface :interface, and with readonly records'
+
+        matcher.counter_cache('projects_count')
         matcher.description.should == 'belong to company with dependent :destroy, through the polymorphic interface :interface, ' <<
-                                      'with readonly records, and with counter cache "projects_count"'
-      end
-
-      it 'should set association_exists? message' do
-        define_and_validate
-        matcher = belong_to('whatever')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records belong to whatever, but the association does not exist'
-      end
-
-      it 'should set macro_matches? message' do
-        define_and_validate
-        matcher = have_one('company')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have one company, got Project records belong to company'
+                                      'with readonly records, and with counter cache "projects_count"'
+      end
+
+      it 'should set association_exists? message' do
+        define_and_validate
+        matcher = belong_to('whatever')
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected Project records belong to whatever, but the association does not exist'
+      end
+
+      it 'should set macro_matches? message' do
+        define_and_validate
+        matcher = have_one('company')
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have one company, got Project records belong to company'
       end
 
       it 'should set klass_exists? message' do
-        define_and_validate
-        matcher = belong_to('unknown')
-        matcher.matches?(@model)
+        define_and_validate
+        matcher = belong_to('unknown')
+        matcher.matches?(@model)
         matcher.failure_message.should == 'Expected Project records belong to unknown, but the association class does not exist'
-      end
-
-      it 'should set foreign_key_exists? message' do
-        matcher = define_and_validate(:model_columns => {})
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected foreign key "company_id" to exist on "projects", but does not'
-      end
-
-      it 'should set polymorphic_exists? message' do
-        matcher = define_and_validate(:model_columns => { :company_id => :integer }, :polymorphic => true)
-        matcher.polymorphic.matches?(@model)
-        matcher.failure_message.should == 'Expected "projects" to have "company_type" as column, but does not'
-      end
-
-      it 'should set counter_cache_exists? message' do
-        matcher = define_and_validate(:association_columns => {}, :counter_cache => true)
-        matcher.counter_cache.matches?(@model)
-        matcher.failure_message.should == 'Expected "companies" to have "projects_count" as column, but does not'
-      end
-
-      it 'should set options_matches? message when polymorphic is given' do
-        matcher = define_and_validate(:polymorphic => false)
-        matcher.polymorphic.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records belong to company with options {:polymorphic=>"true"}, got {:polymorphic=>"false"}'
-      end
-
-      it 'should set options_matches? message when counter_cache is given' do
-        matcher = define_and_validate(:counter_cache => true)
-        matcher.counter_cache(false).matches?(@model)
-        matcher.failure_message.should == 'Expected Project records belong to company with options {:counter_cache=>"false"}, got {:counter_cache=>"true"}'
-      end
-    end
-
-    describe 'matchers' do
-      describe 'without options' do
-        before(:each){ define_and_validate }
-
+      end
+
+      it 'should set foreign_key_exists? message' do
+        matcher = define_and_validate(:model_columns => {})
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected foreign key "company_id" to exist on "projects", but does not'
+      end
+
+      it 'should set polymorphic_exists? message' do
+        matcher = define_and_validate(:model_columns => { :company_id => :integer }, :polymorphic => true)
+        matcher.polymorphic.matches?(@model)
+        matcher.failure_message.should == 'Expected "projects" to have "company_type" as column, but does not'
+      end
+
+      it 'should set counter_cache_exists? message' do
+        matcher = define_and_validate(:association_columns => {}, :counter_cache => true)
+        matcher.counter_cache.matches?(@model)
+        matcher.failure_message.should == 'Expected "companies" to have "projects_count" as column, but does not'
+      end
+
+      it 'should set options_matches? message when polymorphic is given' do
+        matcher = define_and_validate(:polymorphic => false)
+        matcher.polymorphic.matches?(@model)
+        matcher.failure_message.should == 'Expected Project records belong to company with options {:polymorphic=>"true"}, got {:polymorphic=>"false"}'
+      end
+
+      it 'should set options_matches? message when counter_cache is given' do
+        matcher = define_and_validate(:counter_cache => true)
+        matcher.counter_cache(false).matches?(@model)
+        matcher.failure_message.should == 'Expected Project records belong to company with options {:counter_cache=>"false"}, got {:counter_cache=>"true"}'
+      end
+    end
+
+    describe 'matchers' do
+      describe 'without options' do
+        before(:each){ define_and_validate }
+
         it { should belong_to(:company) }
-        it { should_not belong_to(:unknown) }
-        it { should_not belong_to(:project) }
-        it { should_not have_one(:company) }
-        it { should_not have_many(:company) }
-      end
-
-      describe 'with class name option' do
-        it { should define_and_validate.class_name('Company') }
-        it { should define_and_validate(:class_name => 'SuperCompany').class_name('SuperCompany') }
-
-        it { should_not define_and_validate.class_name('SuperCompany') }
-        it { should_not define_and_validate(:class_name => 'Company').class_name('SuperCompany') }
-      end
-
-      describe 'with foreign_key option' do
-        it { should define_and_validate.foreign_key(:company_id) }
-        it { should_not define_and_validate.foreign_key(:association_id) }
-
-        # Checks whether fk exists or not
-        it { should define_and_validate(:foreign_key => :association_id,
-                                        :model_columns => { :association_id => :integer }).foreign_key(:association_id) }
-
-        it { should_not define_and_validate(:foreign_key => :association_id).foreign_key(:association_id) }
-        it { should_not define_and_validate(:model_columns => { :association_id => :integer }).foreign_key(:association_id) }
-      end
-
-      describe 'with dependent option' do
-        it { should define_and_validate(:dependent => :delete).dependent(:delete) }
-        it { should define_and_validate(:dependent => :destroy).dependent(:destroy) }
-
-        it { should_not define_and_validate(:dependent => :delete).dependent(:destroy) }
-        it { should_not define_and_validate(:dependent => :destroy).dependent(:delete) }
-      end
-
-      describe 'with counter_cache option' do
-        # Checks whether fk exists or not
-        it { should define_and_validate(:counter_cache => :association_count,
-                                        :association_columns => { :association_count => :integer }).counter_cache(:association_count) }
-
-        it { should_not define_and_validate(:counter_cache => :association_count).counter_cache(:association_count) }
-        it { should_not define_and_validate(:association_columns => { :association_count => :integer }).counter_cache(:association_count) }
-      end
+        it { should_not belong_to(:unknown) }
+        it { should_not belong_to(:project) }
+        it { should_not have_one(:company) }
+        it { should_not have_many(:company) }
+      end
+
+      describe 'with class name option' do
+        it { should define_and_validate.class_name('Company') }
+        it { should define_and_validate(:class_name => 'SuperCompany').class_name('SuperCompany') }
+
+        it { should_not define_and_validate.class_name('SuperCompany') }
+        it { should_not define_and_validate(:class_name => 'Company').class_name('SuperCompany') }
+      end
+
+      describe 'with foreign_key option' do
+        it { should define_and_validate.foreign_key(:company_id) }
+        it { should_not define_and_validate.foreign_key(:association_id) }
+
+        # Checks whether fk exists or not
+        it { should define_and_validate(:foreign_key => :association_id,
+                                        :model_columns => { :association_id => :integer }).foreign_key(:association_id) }
+
+        it { should_not define_and_validate(:foreign_key => :association_id).foreign_key(:association_id) }
+        it { should_not define_and_validate(:model_columns => { :association_id => :integer }).foreign_key(:association_id) }
+      end
+
+      describe 'with dependent option' do
+        it { should define_and_validate(:dependent => :delete).dependent(:delete) }
+        it { should define_and_validate(:dependent => :destroy).dependent(:destroy) }
+
+        it { should_not define_and_validate(:dependent => :delete).dependent(:destroy) }
+        it { should_not define_and_validate(:dependent => :destroy).dependent(:delete) }
+      end
+
+      describe 'with counter_cache option' do
+        # Checks whether fk exists or not
+        it { should define_and_validate(:counter_cache => :association_count,
+                                        :association_columns => { :association_count => :integer }).counter_cache(:association_count) }
+
+        it { should_not define_and_validate(:counter_cache => :association_count).counter_cache(:association_count) }
+        it { should_not define_and_validate(:association_columns => { :association_count => :integer }).counter_cache(:association_count) }
+      end
 
       describe "with polymorphic option" do
         before(:each){ define_and_validate(:model_columns => {:accountable_id => :integer, :accountable_type => :string}) }
         it { should belong_to(:accountable).polymorphic }
       end
-
-      create_optional_boolean_specs(:readonly, self)
-      create_optional_boolean_specs(:validate, self)
-      create_optional_boolean_specs(:autosave, self) if RAILS_VERSION =~ /^2.3/
-      create_optional_boolean_specs(:polymorphic, self)
-      create_optional_boolean_specs(:counter_cache, self)
-    end
-
-    describe 'macros' do
-      before(:each){ define_and_validate(:validate => true, :readonly => true) }
-
-      should_belong_to :company
-      should_belong_to :company, :readonly    => true
-      should_belong_to :company, :validate    => true
-      should_belong_to :company, :class_name  => "Company"
+
+      create_optional_boolean_specs(:readonly, self)
+      create_optional_boolean_specs(:validate, self)
+      create_optional_boolean_specs(:autosave, self) if RAILS_VERSION =~ /^2.3/
+      create_optional_boolean_specs(:polymorphic, self)
+      create_optional_boolean_specs(:counter_cache, self)
+    end
+
+    describe 'macros' do
+      before(:each){ define_and_validate(:validate => true, :readonly => true) }
+
+      should_belong_to :company
+      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 do |m|
@@ -172,153 +172,153 @@ describe 'association_matcher' do
         m.validate
         m.class_name = "Company"
         m.foreign_key = :company_id
-      end
-
-      should_not_belong_to :unknown
-      should_not_belong_to :project
-      should_not_have_one  :company
-      should_not_have_many :companies
-
-      should_not_belong_to :company, :readonly    => false
-      should_not_belong_to :company, :validate    => false
-      should_not_belong_to :company, :class_name  => "Anything"
-      should_not_belong_to :company, :foreign_key => :anything_id
-    end
-  end
-
-  describe 'have_and_belong_to_many' do
-
-    # Defines a model, create a validation and returns a raw matcher
-    def define_and_validate(options={})
+      end
+
+      should_not_belong_to :unknown
+      should_not_belong_to :project
+      should_not_have_one  :company
+      should_not_have_many :companies
+
+      should_not_belong_to :company, :readonly    => false
+      should_not_belong_to :company, :validate    => false
+      should_not_belong_to :company, :class_name  => "Anything"
+      should_not_belong_to :company, :foreign_key => :anything_id
+    end
+  end
+
+  describe 'have_and_belong_to_many' do
+
+    # Defines a model, create a validation and returns a raw matcher
+    def define_and_validate(options={})
       define_model :label
-      define_model :super_label
-
-      columns = options.delete(:association_columns) || [ :label_id, :project_id ]
-      create_table(options.delete(:association_table) || :labels_projects) do |table|
-        columns.each { |name| table.column(name, :integer) }
-      end
-
-      @model = define_model :project, options.delete(:model_columns) || {} do
-        has_and_belongs_to_many :labels, options
-      end
-
-      have_and_belong_to_many :labels
-    end
-
-    describe 'messages' do
-      it 'should contain a description' do
-        matcher = define_and_validate
-        matcher.description.should == 'have and belong to many labels'
-
-        matcher.class_name('Label')
-        matcher.description.should == 'have and belong to many labels with class name "Label"'
-
-        matcher.foreign_key('label_id')
-        matcher.description.should == 'have and belong to many labels with class name "Label" and with foreign key "label_id"'
-
-        matcher = have_and_belong_to_many(:labels).autosave
-        matcher.description.should == 'have and belong to many labels autosaving associated records'
-
-        matcher.uniq
-        matcher.description.should == 'have and belong to many labels with unique records and autosaving associated records'
-      end
-
-      it 'should set association_exists? message' do
-        define_and_validate
-        matcher = have_and_belong_to_many('whatever')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have and belong to many whatever, but the association does not exist'
-      end
-
-      it 'should set macro_matches? message' do
-        define_and_validate
-        matcher = have_many('labels')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have many labels, got Project records have and belong to many labels'
-      end
-
-      it 'should set join_table_exists? message' do
-        matcher = define_and_validate(:association_table => 'another_name')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected join table "labels_projects" to exist, but does not'
-      end
-
-      it 'should set foreign_key_exists? message' do
-        matcher = define_and_validate(:association_columns => [])
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected foreign key "project_id" to exist on "labels_projects", but does not'
-      end
-
-      it 'should set options_matches? message' do
-        matcher = define_and_validate(:uniq => false)
-        matcher.uniq.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have and belong to many labels with options {:uniq=>"true"}, got {:uniq=>"false"}'
-      end
-    end
-
-    describe 'matchers' do
-      describe 'without options' do
-        before(:each){ define_and_validate }
-
-        it { should have_and_belong_to_many(:labels) }
-        it { should_not belong_to(:label) }
-        it { should_not have_one(:label) }
-        it { should_not have_many(:labels) }
-        it { should_not have_and_belong_to_many(:companies) }
-      end
-
-      describe 'with class name option' do
-        it { should define_and_validate.class_name('Label') }
-
-        it { should define_and_validate(:class_name => 'SuperLabel',
-                                        :association_table => 'projects_super_labels').class_name('SuperLabel') }
-
-        it { should_not define_and_validate.class_name('SuperLabel') }
-      end
-
-      describe 'with foreign_key option' do
-        it { should define_and_validate.foreign_key(:project_id) }
-        it { should_not define_and_validate.foreign_key(:association_id) }
-
-        # Checks whether fk exists or not
-        it { should define_and_validate(:foreign_key => :association_id,
-                                        :association_columns => [ :association_id ]).foreign_key(:association_id) }
-
-        it { should_not define_and_validate(:foreign_key => :association_id).foreign_key(:association_id) }
-        it { should_not define_and_validate(:association_columns => [ :association_id ]).foreign_key(:association_id) }
-      end
-
-      describe 'with join table option' do
-        it { should define_and_validate.join_table('labels_projects') }
-        it { should define_and_validate(:join_table => 'my_table',
+      define_model :super_label
+
+      columns = options.delete(:association_columns) || [ :label_id, :project_id ]
+      create_table(options.delete(:association_table) || :labels_projects) do |table|
+        columns.each { |name| table.column(name, :integer) }
+      end
+
+      @model = define_model :project, options.delete(:model_columns) || {} do
+        has_and_belongs_to_many :labels, options
+      end
+
+      have_and_belong_to_many :labels
+    end
+
+    describe 'messages' do
+      it 'should contain a description' do
+        matcher = define_and_validate
+        matcher.description.should == 'have and belong to many labels'
+
+        matcher.class_name('Label')
+        matcher.description.should == 'have and belong to many labels with class name "Label"'
+
+        matcher.foreign_key('label_id')
+        matcher.description.should == 'have and belong to many labels with class name "Label" and with foreign key "label_id"'
+
+        matcher = have_and_belong_to_many(:labels).autosave
+        matcher.description.should == 'have and belong to many labels autosaving associated records'
+
+        matcher.uniq
+        matcher.description.should == 'have and belong to many labels with unique records and autosaving associated records'
+      end
+
+      it 'should set association_exists? message' do
+        define_and_validate
+        matcher = have_and_belong_to_many('whatever')
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have and belong to many whatever, but the association does not exist'
+      end
+
+      it 'should set macro_matches? message' do
+        define_and_validate
+        matcher = have_many('labels')
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have many labels, got Project records have and belong to many labels'
+      end
+
+      it 'should set join_table_exists? message' do
+        matcher = define_and_validate(:association_table => 'another_name')
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected join table "labels_projects" to exist, but does not'
+      end
+
+      it 'should set foreign_key_exists? message' do
+        matcher = define_and_validate(:association_columns => [])
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected foreign key "project_id" to exist on "labels_projects", but does not'
+      end
+
+      it 'should set options_matches? message' do
+        matcher = define_and_validate(:uniq => false)
+        matcher.uniq.matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have and belong to many labels with options {:uniq=>"true"}, got {:uniq=>"false"}'
+      end
+    end
+
+    describe 'matchers' do
+      describe 'without options' do
+        before(:each){ define_and_validate }
+
+        it { should have_and_belong_to_many(:labels) }
+        it { should_not belong_to(:label) }
+        it { should_not have_one(:label) }
+        it { should_not have_many(:labels) }
+        it { should_not have_and_belong_to_many(:companies) }
+      end
+
+      describe 'with class name option' do
+        it { should define_and_validate.class_name('Label') }
+
+        it { should define_and_validate(:class_name => 'SuperLabel',
+                                        :association_table => 'projects_super_labels').class_name('SuperLabel') }
+
+        it { should_not define_and_validate.class_name('SuperLabel') }
+      end
+
+      describe 'with foreign_key option' do
+        it { should define_and_validate.foreign_key(:project_id) }
+        it { should_not define_and_validate.foreign_key(:association_id) }
+
+        # Checks whether fk exists or not
+        it { should define_and_validate(:foreign_key => :association_id,
+                                        :association_columns => [ :association_id ]).foreign_key(:association_id) }
+
+        it { should_not define_and_validate(:foreign_key => :association_id).foreign_key(:association_id) }
+        it { should_not define_and_validate(:association_columns => [ :association_id ]).foreign_key(:association_id) }
+      end
+
+      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') }
 
-        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') }
-
-        it { should_not define_and_validate(:join_table => 'my_table',
-                                            :association_table => 'another_table').join_table('my_table') }
-        it { should_not define_and_validate(:join_table => 'another_table',
-                                            :association_table => 'my_table').join_table('my_table') }
-        it { should_not define_and_validate(:join_table => 'my_table',
-                                            :association_table => 'my_table').join_table('another_table') }
-      end
-
-      create_optional_boolean_specs(:uniq, self)
-      create_optional_boolean_specs(:readonly, self)
-      create_optional_boolean_specs(:validate, self)
-      create_optional_boolean_specs(:autosave, self) if RAILS_VERSION =~ /^2.3/
-    end
-
-    describe 'macros' do
-      before(:each){ define_and_validate(:validate => true, :readonly => true) }
-
-      should_have_and_belong_to_many :labels
-      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"
+        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') }
+
+        it { should_not define_and_validate(:join_table => 'my_table',
+                                            :association_table => 'another_table').join_table('my_table') }
+        it { should_not define_and_validate(:join_table => 'another_table',
+                                            :association_table => 'my_table').join_table('my_table') }
+        it { should_not define_and_validate(:join_table => 'my_table',
+                                            :association_table => 'my_table').join_table('another_table') }
+      end
+
+      create_optional_boolean_specs(:uniq, self)
+      create_optional_boolean_specs(:readonly, self)
+      create_optional_boolean_specs(:validate, self)
+      create_optional_boolean_specs(:autosave, self) if RAILS_VERSION =~ /^2.3/
+    end
+
+    describe 'macros' do
+      before(:each){ define_and_validate(:validate => true, :readonly => true) }
+
+      should_have_and_belong_to_many :labels
+      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 do |m|
@@ -326,346 +326,346 @@ describe 'association_matcher' do
         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
-      should_not_have_many :labels
-
-      should_not_have_and_belong_to_many :labels, :readonly    => false
-      should_not_have_and_belong_to_many :labels, :validate    => false
-      should_not_have_and_belong_to_many :labels, :class_name  => "Anything"
-      should_not_have_and_belong_to_many :labels, :foreign_key => :anything_id
-    end
-  end
-
-  describe 'have_many' do
-
-    # Defines a model, create a validation and returns a raw matcher
-    def define_and_validate(options={})
-      columns = options.delete(:association_columns) || { :task_id => :integer, :project_id => :integer, :todo_id => :integer }
+      end
+
+      should_not_have_and_belong_to_many :companies
+      should_not_have_one  :label
+      should_not_have_many :labels
+
+      should_not_have_and_belong_to_many :labels, :readonly    => false
+      should_not_have_and_belong_to_many :labels, :validate    => false
+      should_not_have_and_belong_to_many :labels, :class_name  => "Anything"
+      should_not_have_and_belong_to_many :labels, :foreign_key => :anything_id
+    end
+  end
+
+  describe 'have_many' do
+
+    # Defines a model, create a validation and returns a raw matcher
+    def define_and_validate(options={})
+      columns = options.delete(:association_columns) || { :task_id => :integer, :project_id => :integer, :todo_id => :integer }
       define_model :task, columns
-      define_model :todo, columns
-
-      define_model :project_task, columns do
-        belongs_to :task
+      define_model :todo, columns
+
+      define_model :project_task, columns do
+        belongs_to :task
         belongs_to :project
-        belongs_to :todo
-      end unless options.delete(:skip_source)
-
+        belongs_to :todo
+      end unless options.delete(:skip_source)
+
       @model = define_model :project, options.delete(:model_columns) || {} do
-        has_many :project_tasks unless options.delete(:skip_through)
-        has_many :tasks, options
-      end
-
-      have_many :tasks
-    end
-
-    describe 'messages' do
-      it 'should contain a description' do
-        matcher = define_and_validate
-        matcher.description.should == 'have many tasks'
-
-        matcher.class_name('Task')
-        matcher.description.should == 'have many tasks with class name "Task"'
-
-        matcher.foreign_key('task_id')
-        matcher.description.should == 'have many tasks with class name "Task" and with foreign key "task_id"'
-
-        matcher = have_many(:tasks).autosave
-        matcher.description.should == 'have many tasks autosaving associated records'
-
-        matcher.uniq
-        matcher.description.should == 'have many tasks with unique records and autosaving associated records'
-      end
-
-      it 'should set association_exists? message' do
-        define_and_validate
-        matcher = have_many('whatever')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have many whatever, but the association does not exist'
-      end
-
-      it 'should set macro_matches? message' do
-        define_and_validate
-        matcher = have_and_belong_to_many('tasks')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have and belong to many tasks, got Project records have many tasks'
-      end
-
-      it 'should set foreign_key_exists? message' do
-        matcher = define_and_validate(:association_columns => {})
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected foreign key "project_id" to exist on "tasks", but does not'
-      end
-
-      it 'should set through_exists? message' do
-        matcher = define_and_validate(:through => :project_tasks, :skip_through => true)
-        matcher.through(:project_tasks).matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have many tasks through :project_tasks, through association does not exist'
-      end
-
-      it 'should set source_exists? message' do
-        matcher = define_and_validate(:through => :project_tasks, :skip_source => true)
-        matcher.through(:project_tasks).matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have many tasks through :project_tasks, source association does not exist'
-      end
-
-      it 'should set options_matches? message when dependent is given' do
-        matcher = define_and_validate(:dependent => :destroy)
-        matcher.dependent(:nullify).matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have many tasks with options {:dependent=>"nullify"}, got {:dependent=>"destroy"}'
-      end
-
-      it 'should set options_matches? message when source is given' do
-        matcher = define_and_validate(:through => :project_tasks, :source => :todo)
-        matcher.through(:project_tasks).source(:task).matches?(@model)
+        has_many :project_tasks unless options.delete(:skip_through)
+        has_many :tasks, options
+      end
+
+      have_many :tasks
+    end
+
+    describe 'messages' do
+      it 'should contain a description' do
+        matcher = define_and_validate
+        matcher.description.should == 'have many tasks'
+
+        matcher.class_name('Task')
+        matcher.description.should == 'have many tasks with class name "Task"'
+
+        matcher.foreign_key('task_id')
+        matcher.description.should == 'have many tasks with class name "Task" and with foreign key "task_id"'
+
+        matcher = have_many(:tasks).autosave
+        matcher.description.should == 'have many tasks autosaving associated records'
+
+        matcher.uniq
+        matcher.description.should == 'have many tasks with unique records and autosaving associated records'
+      end
+
+      it 'should set association_exists? message' do
+        define_and_validate
+        matcher = have_many('whatever')
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have many whatever, but the association does not exist'
+      end
+
+      it 'should set macro_matches? message' do
+        define_and_validate
+        matcher = have_and_belong_to_many('tasks')
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have and belong to many tasks, got Project records have many tasks'
+      end
+
+      it 'should set foreign_key_exists? message' do
+        matcher = define_and_validate(:association_columns => {})
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected foreign key "project_id" to exist on "tasks", but does not'
+      end
+
+      it 'should set through_exists? message' do
+        matcher = define_and_validate(:through => :project_tasks, :skip_through => true)
+        matcher.through(:project_tasks).matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have many tasks through :project_tasks, through association does not exist'
+      end
+
+      it 'should set source_exists? message' do
+        matcher = define_and_validate(:through => :project_tasks, :skip_source => true)
+        matcher.through(:project_tasks).matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have many tasks through :project_tasks, source association does not exist'
+      end
+
+      it 'should set options_matches? message when dependent is given' do
+        matcher = define_and_validate(:dependent => :destroy)
+        matcher.dependent(:nullify).matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have many tasks with options {:dependent=>"nullify"}, got {:dependent=>"destroy"}'
+      end
+
+      it 'should set options_matches? message when source is given' do
+        matcher = define_and_validate(:through => :project_tasks, :source => :todo)
+        matcher.through(:project_tasks).source(:task).matches?(@model)
         matcher.failure_message.should match(/:source=>"task"/)
-        matcher.failure_message.should match(/:source=>"todo"/)
-      end
-    end
-
-    describe 'matchers' do
-      describe 'without options' do
-        before(:each){ define_and_validate }
-
-        it { should have_many(:tasks) }
-        it { should_not belong_to(:task) }
-        it { should_not have_one(:task) }
-        it { should_not have_and_belong_to_many(:tasks) }
-      end
-
-      describe 'with class name option' do
-        before(:each){ define_model :super_task, :project_id => :integer }
-
-        it { should define_and_validate.class_name('Task') }
-        it { should define_and_validate(:class_name => 'SuperTask').class_name('SuperTask') }
-
-        it { should_not define_and_validate.class_name('SuperTask') }
-        it { should_not define_and_validate(:class_name => 'SuperTask').class_name('Task') }
-      end
-
-      describe 'with foreign_key option' do
-        it { should define_and_validate.foreign_key(:project_id) }
-        it { should_not define_and_validate.foreign_key(:association_id) }
-
-        # Checks whether fk exists or not
-        it { should define_and_validate(:foreign_key => :association_id,
-                                        :association_columns => { :association_id => :integer }).foreign_key(:association_id) }
-
-        it { should_not define_and_validate(:foreign_key => :association_id).foreign_key(:association_id) }
-        it { should_not define_and_validate(:association_columns => { :association_id => :integer }).foreign_key(:association_id) }
-      end
-
-      describe 'with dependent option' do
-        it { should define_and_validate(:dependent => :delete_all).dependent(:delete_all) }
-        it { should define_and_validate(:dependent => :destroy).dependent(:destroy) }
-
-        it { should_not define_and_validate(:dependent => :delete_all).dependent(:destroy) }
-        it { should_not define_and_validate(:dependent => :destroy).dependent(:delete_all) }
-      end
-
-      describe 'with through option' do
-        it { should define_and_validate(:through => :project_tasks) }
-        it { should define_and_validate(:through => :project_tasks).through(:project_tasks) }
-
-        it { should_not define_and_validate(:through => :project_tasks).through(:something) }
-        it { should_not define_and_validate(:through => :project_tasks, :skip_through => true).through(:project_tasks) }
-      end
-
-      describe 'with source option' do
+        matcher.failure_message.should match(/:source=>"todo"/)
+      end
+    end
+
+    describe 'matchers' do
+      describe 'without options' do
+        before(:each){ define_and_validate }
+
+        it { should have_many(:tasks) }
+        it { should_not belong_to(:task) }
+        it { should_not have_one(:task) }
+        it { should_not have_and_belong_to_many(:tasks) }
+      end
+
+      describe 'with class name option' do
+        before(:each){ define_model :super_task, :project_id => :integer }
+
+        it { should define_and_validate.class_name('Task') }
+        it { should define_and_validate(:class_name => 'SuperTask').class_name('SuperTask') }
+
+        it { should_not define_and_validate.class_name('SuperTask') }
+        it { should_not define_and_validate(:class_name => 'SuperTask').class_name('Task') }
+      end
+
+      describe 'with foreign_key option' do
+        it { should define_and_validate.foreign_key(:project_id) }
+        it { should_not define_and_validate.foreign_key(:association_id) }
+
+        # Checks whether fk exists or not
+        it { should define_and_validate(:foreign_key => :association_id,
+                                        :association_columns => { :association_id => :integer }).foreign_key(:association_id) }
+
+        it { should_not define_and_validate(:foreign_key => :association_id).foreign_key(:association_id) }
+        it { should_not define_and_validate(:association_columns => { :association_id => :integer }).foreign_key(:association_id) }
+      end
+
+      describe 'with dependent option' do
+        it { should define_and_validate(:dependent => :delete_all).dependent(:delete_all) }
+        it { should define_and_validate(:dependent => :destroy).dependent(:destroy) }
+
+        it { should_not define_and_validate(:dependent => :delete_all).dependent(:destroy) }
+        it { should_not define_and_validate(:dependent => :destroy).dependent(:delete_all) }
+      end
+
+      describe 'with through option' do
+        it { should define_and_validate(:through => :project_tasks) }
+        it { should define_and_validate(:through => :project_tasks).through(:project_tasks) }
+
+        it { should_not define_and_validate(:through => :project_tasks).through(:something) }
+        it { should_not define_and_validate(:through => :project_tasks, :skip_through => true).through(:project_tasks) }
+      end
+
+      describe 'with source option' do
         it { should define_and_validate(:through => :project_tasks, :source => :todo).source(:todo) }
-        it { should_not define_and_validate(:through => :project_tasks, :source => :todo).source(:task) }
-      end
-
-      create_optional_boolean_specs(:uniq, self)
-      create_optional_boolean_specs(:readonly, self)
-      create_optional_boolean_specs(:validate, self)
-      create_optional_boolean_specs(:autosave, self) if RAILS_VERSION =~ /^2.3/
-    end
-
-    describe 'macros' do
-      before(:each){ define_and_validate(:through => :project_tasks, :readonly => true, :validate => true) } 
-
-      should_have_many :tasks
-      should_have_many :tasks, :readonly => true
-      should_have_many :tasks, :validate => true
+        it { should_not define_and_validate(:through => :project_tasks, :source => :todo).source(:task) }
+      end
+
+      create_optional_boolean_specs(:uniq, self)
+      create_optional_boolean_specs(:readonly, self)
+      create_optional_boolean_specs(:validate, self)
+      create_optional_boolean_specs(:autosave, self) if RAILS_VERSION =~ /^2.3/
+    end
+
+    describe 'macros' do
+      before(:each){ define_and_validate(:through => :project_tasks, :readonly => true, :validate => true) } 
+
+      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 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
-      should_not_have_many :tasks, :through => :another_thing
-    end
-  end
-
-  describe 'have_one' do
-
-    # Defines a model, create a validation and returns a raw matcher
-    def define_and_validate(options={})
-      columns = options.delete(:association_columns) || { :manager_id => :integer, :project_id => :integer, :boss_id => :integer }
+      end
+
+      should_not_have_many :tasks, :readonly => false
+      should_not_have_many :tasks, :validate => false
+      should_not_have_many :tasks, :through => :another_thing
+    end
+  end
+
+  describe 'have_one' do
+
+    # Defines a model, create a validation and returns a raw matcher
+    def define_and_validate(options={})
+      columns = options.delete(:association_columns) || { :manager_id => :integer, :project_id => :integer, :boss_id => :integer }
       define_model :manager, columns
-      define_model :boss,    columns
-
-      define_model :project_manager, columns do
-        belongs_to :manager
+      define_model :boss,    columns
+
+      define_model :project_manager, columns do
+        belongs_to :manager
         belongs_to :project
-        belongs_to :boss
-      end unless options.delete(:skip_source)
-
+        belongs_to :boss
+      end unless options.delete(:skip_source)
+
       @model = define_model :project, options.delete(:model_columns) || {} do
-        has_many :project_managers unless options.delete(:skip_through)
+        has_many :project_managers unless options.delete(:skip_through)
         has_one  :manager, options
-        has_one  :unknown
-      end
-
-      have_one :manager
-    end
-
-    describe 'messages' do
-      it 'should contain a description' do
-        matcher = define_and_validate
-        matcher.description.should == 'have one manager'
-
-        matcher.class_name('Manager')
-        matcher.description.should == 'have one manager with class name "Manager"'
-
-        matcher.foreign_key('manager_id')
-        matcher.description.should == 'have one manager with class name "Manager" and with foreign key "manager_id"'
-      end
-
-      it 'should set association_exists? message' do
-        define_and_validate
-        matcher = have_one('whatever')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have one whatever, but the association does not exist'
-      end
+        has_one  :unknown
+      end
+
+      have_one :manager
+    end
+
+    describe 'messages' do
+      it 'should contain a description' do
+        matcher = define_and_validate
+        matcher.description.should == 'have one manager'
+
+        matcher.class_name('Manager')
+        matcher.description.should == 'have one manager with class name "Manager"'
+
+        matcher.foreign_key('manager_id')
+        matcher.description.should == 'have one manager with class name "Manager" and with foreign key "manager_id"'
+      end
+
+      it 'should set association_exists? message' do
+        define_and_validate
+        matcher = have_one('whatever')
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have one whatever, but the association does not exist'
+      end
 
       it 'should set klass_exists? message' do
-        define_and_validate
-        matcher = have_one('unknown')
-        matcher.matches?(@model)
+        define_and_validate
+        matcher = have_one('unknown')
+        matcher.matches?(@model)
         matcher.failure_message.should == 'Expected Project records have one unknown, but the association class does not exist'
       end
-
-      it 'should set macro_matches? message' do
-        define_and_validate
-        matcher = belong_to('manager')
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected Project records belong to manager, got Project records have one manager'
-      end
-
-      it 'should set foreign_key_exists? message' do
-        matcher = define_and_validate(:association_columns => {})
-        matcher.matches?(@model)
-        matcher.failure_message.should == 'Expected foreign key "project_id" to exist on "managers", but does not'
-      end
-
-      it 'should set through_exists? message' do
-        matcher = define_and_validate(:through => :project_managers, :skip_through => true)
-        matcher.through(:project_managers).matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have one manager through :project_managers, through association does not exist'
-      end
-
-      it 'should set source_exists? message' do
-        matcher = define_and_validate(:through => :project_managers, :skip_source => true)
-        matcher.through(:project_managers).matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have one manager through :project_managers, source association does not exist'
-      end
-
-      it 'should set options_matches? message when dependent is given' do
-        matcher = define_and_validate(:dependent => :destroy)
-        matcher.dependent(:nullify).matches?(@model)
-        matcher.failure_message.should == 'Expected Project records have one manager with options {:dependent=>"nullify"}, got {:dependent=>"destroy"}'
-      end
-
-      it 'should set options_matches? message when source is given' do
-        matcher = define_and_validate(:through => :project_managers, :source => :boss)
-        matcher.through(:project_managers).source(:manager).matches?(@model)
+
+      it 'should set macro_matches? message' do
+        define_and_validate
+        matcher = belong_to('manager')
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected Project records belong to manager, got Project records have one manager'
+      end
+
+      it 'should set foreign_key_exists? message' do
+        matcher = define_and_validate(:association_columns => {})
+        matcher.matches?(@model)
+        matcher.failure_message.should == 'Expected foreign key "project_id" to exist on "managers", but does not'
+      end
+
+      it 'should set through_exists? message' do
+        matcher = define_and_validate(:through => :project_managers, :skip_through => true)
+        matcher.through(:project_managers).matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have one manager through :project_managers, through association does not exist'
+      end
+
+      it 'should set source_exists? message' do
+        matcher = define_and_validate(:through => :project_managers, :skip_source => true)
+        matcher.through(:project_managers).matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have one manager through :project_managers, source association does not exist'
+      end
+
+      it 'should set options_matches? message when dependent is given' do
+        matcher = define_and_validate(:dependent => :destroy)
+        matcher.dependent(:nullify).matches?(@model)
+        matcher.failure_message.should == 'Expected Project records have one manager with options {:dependent=>"nullify"}, got {:dependent=>"destroy"}'
+      end
+
+      it 'should set options_matches? message when source is given' do
+        matcher = define_and_validate(:through => :project_managers, :source => :boss)
+        matcher.through(:project_managers).source(:manager).matches?(@model)
         matcher.failure_message.should match(/:source=>"manager"/)
-        matcher.failure_message.should match(/:source=>"boss"/)
-      end
-    end
-
-    describe 'matchers' do
-      describe 'without options' do
-        before(:each){ define_and_validate }
-
+        matcher.failure_message.should match(/:source=>"boss"/)
+      end
+    end
+
+    describe 'matchers' do
+      describe 'without options' do
+        before(:each){ define_and_validate }
+
         it { should have_one(:manager) }
-        it { should_not have_one(:unknown) }
-        it { should_not belong_to(:manager) }
-        it { should_not have_many(:managers) }
-        it { should_not have_and_belong_to_many(:managers) }
-      end
-
-      describe 'with class name option' do
-        before(:each){ define_model :super_manager, :project_id => :integer }
-
-        it { should define_and_validate.class_name('Manager') }
-        it { should define_and_validate(:class_name => 'SuperManager').class_name('SuperManager') }
-
-        it { should_not define_and_validate.class_name('SuperManager') }
-        it { should_not define_and_validate(:class_name => 'SuperManager').class_name('Manager') }
-      end
-
-      describe 'with foreign_key option' do
-        it { should define_and_validate.foreign_key(:project_id) }
-        it { should_not define_and_validate.foreign_key(:association_id) }
-
-        # Checks whether fk exists or not
-        it { should define_and_validate(:foreign_key => :association_id,
-                                        :association_columns => { :association_id => :integer }).foreign_key(:association_id) }
-
-        it { should_not define_and_validate(:foreign_key => :association_id).foreign_key(:association_id) }
-        it { should_not define_and_validate(:association_columns => { :association_id => :integer }).foreign_key(:association_id) }
-      end
-
-      describe 'with dependent option' do
-        it { should define_and_validate(:dependent => :delete).dependent(:delete) }
-        it { should define_and_validate(:dependent => :destroy).dependent(:destroy) }
-
-        it { should_not define_and_validate(:dependent => :delete).dependent(:destroy) }
-        it { should_not define_and_validate(:dependent => :destroy).dependent(:delete) }
-      end
-
-      describe 'with through option' do
-        it { should define_and_validate(:through => :project_managers) }
-        it { should define_and_validate(:through => :project_managers).through(:project_managers) }
-
-        it { should_not define_and_validate(:through => :project_managers).through(:something) }
-        it { should_not define_and_validate(:through => :project_managers, :skip_through => true).through(:project_managers) }
-      end
-
-      describe 'with source option' do
+        it { should_not have_one(:unknown) }
+        it { should_not belong_to(:manager) }
+        it { should_not have_many(:managers) }
+        it { should_not have_and_belong_to_many(:managers) }
+      end
+
+      describe 'with class name option' do
+        before(:each){ define_model :super_manager, :project_id => :integer }
+
+        it { should define_and_validate.class_name('Manager') }
+        it { should define_and_validate(:class_name => 'SuperManager').class_name('SuperManager') }
+
+        it { should_not define_and_validate.class_name('SuperManager') }
+        it { should_not define_and_validate(:class_name => 'SuperManager').class_name('Manager') }
+      end
+
+      describe 'with foreign_key option' do
+        it { should define_and_validate.foreign_key(:project_id) }
+        it { should_not define_and_validate.foreign_key(:association_id) }
+
+        # Checks whether fk exists or not
+        it { should define_and_validate(:foreign_key => :association_id,
+                                        :association_columns => { :association_id => :integer }).foreign_key(:association_id) }
+
+        it { should_not define_and_validate(:foreign_key => :association_id).foreign_key(:association_id) }
+        it { should_not define_and_validate(:association_columns => { :association_id => :integer }).foreign_key(:association_id) }
+      end
+
+      describe 'with dependent option' do
+        it { should define_and_validate(:dependent => :delete).dependent(:delete) }
+        it { should define_and_validate(:dependent => :destroy).dependent(:destroy) }
+
+        it { should_not define_and_validate(:dependent => :delete).dependent(:destroy) }
+        it { should_not define_and_validate(:dependent => :destroy).dependent(:delete) }
+      end
+
+      describe 'with through option' do
+        it { should define_and_validate(:through => :project_managers) }
+        it { should define_and_validate(:through => :project_managers).through(:project_managers) }
+
+        it { should_not define_and_validate(:through => :project_managers).through(:something) }
+        it { should_not define_and_validate(:through => :project_managers, :skip_through => true).through(:project_managers) }
+      end
+
+      describe 'with source option' do
         it { should define_and_validate(:through => :project_managers, :source => :boss).source(:boss) }
-        it { should_not define_and_validate(:through => :project_managers, :source => :boss).source(:manager) }
-      end
-
-      create_optional_boolean_specs(:validate, self)
-      create_optional_boolean_specs(:autosave, self) if RAILS_VERSION =~ /^2.3/
-    end
-
-    describe 'macros' do
-      before(:each){ define_and_validate(:through => :project_managers, :validate => true) } 
-
-      should_have_one :manager
-      should_have_one :manager, :validate => true
+        it { should_not define_and_validate(:through => :project_managers, :source => :boss).source(:manager) }
+      end
+
+      create_optional_boolean_specs(:validate, self)
+      create_optional_boolean_specs(:autosave, self) if RAILS_VERSION =~ /^2.3/
+    end
+
+    describe 'macros' do
+      before(:each){ define_and_validate(:through => :project_managers, :validate => true) } 
+
+      should_have_one :manager
+      should_have_one :manager, :validate => true
       should_have_one :manager, :through => :project_managers
 
       should_have_one :manager do |m|
         m.validate
         m.through = :project_managers
-      end
-
-      should_not_have_one :unknown
-      should_not_have_one :manager, :validate => false
-      should_not_have_one :manager, :through => :another_thing
-    end
-  end
-
-end
+      end
+
+      should_not_have_one :unknown
+      should_not_have_one :manager, :validate => false
+      should_not_have_one :manager, :through => :another_thing
+    end
+  end
+
+end