carlosbrando-remarkable 0.0.99 → 2.2.1

data/spec/models/post_spec.rb

@@ -7,14 +7,37 @@ describe Post do
   it { should belong_to(:owner) }
   it { should belong_to(:user, :owner) }
   
+  it { should have_many(:tags).through(:taggings) }
   it { should have_many(:tags, :through => :taggings) }
+
+  it { should have_many(:through_tags).through(:taggings) }
   it { should have_many(:through_tags, :through => :taggings) }
+
+  it { should have_many(:tags, :through_tags).through(:taggings) }
   it { should have_many(:tags, :through_tags, :through => :taggings) }
 
   it { should require_unique_attributes(:title) }
+  it { should_not require_unique_attributes(:body) }
+  it { should_not require_unique_attributes(:title).scoped_to(:user_id) }
+  it { should_not require_unique_attributes(:title, :scoped_to => :user_id) }
+  
   it { should require_attributes(:body, :message => /wtf/) }
+  it { should require_attributes(:body).message(/wtf/) }
+  it { should_not require_attributes(:body) }
   it { should require_attributes(:title) }
+  it { should_not require_attributes(:user_id) }
+
   it { should only_allow_numeric_values_for(:user_id) }
+
+  it { should validate_numericality_of(:user_id) }
+  it { should validate_numericality_of(:user_id).allow_nil(false) }
+  it { should validate_numericality_of(:user_id).allow_blank(false) }
+
+  it { should_not validate_numericality_of(:user_id, :allow_nil => true) }
+  it { should_not validate_numericality_of(:user_id, :allow_blank => true) }
+
+  it { should_not validate_numericality_of(:title) }
+  it { should_not only_allow_numeric_values_for(:title) }
 end
 
 describe Post do
@@ -23,13 +46,24 @@ describe Post do
   should_belong_to :user
   should_belong_to :owner
   should_belong_to :user, :owner
-  
+
   should_have_many :tags, :through => :taggings
   should_have_many :through_tags, :through => :taggings
   should_have_many :tags, :through_tags, :through => :taggings
-  
+
   should_require_unique_attributes :title
   should_require_attributes :body, :message => /wtf/
   should_require_attributes :title
+
   should_only_allow_numeric_values_for :user_id
+
+  should_validate_numericality_of :user_id
+  should_validate_numericality_of :user_id, :allow_nil => false
+  should_validate_numericality_of :user_id, :allow_blank => false
+
+  should_not_validate_numericality_of :user_id, :allow_nil => true
+  should_not_validate_numericality_of :user_id, :allow_blank => true
+
+  should_not_validate_numericality_of :title
+  should_not_only_allow_numeric_values_for :title
 end

data/spec/models/product_spec.rb

@@ -1,6 +1,9 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe Product do
+  it { should require_attributes(:title) }
+  it { should_not require_attributes(:price) }
+  
   describe "An intangible product" do
     before(:all) do
       @product = Product.new(:tangible => false)
@@ -9,8 +12,27 @@ describe Product do
     it { @product.should_not allow_values_for(:size, "22") }
     it { @product.should allow_values_for(:size, "22kb") }
 
+    it { @product.should_not validate_format_of(:size, "22") }
+    it { @product.should validate_format_of(:size, "22kb") }
+
+    it { @product.should validate_exclusion_of(:weight, 10..100) }
+    it { @product.should_not validate_exclusion_of(:weight, 1..9) }
+
     it { @product.should require_attributes(:title) }
+    it { @product.should_not require_attributes(:price) }
+
+    it { @product.should validate_presence_of(:title) }
+    it { @product.should_not validate_presence_of(:price) }
+    
     it { @product.should ensure_value_in_range(:price, 0..99) }
+    it { @product.should validate_inclusion_of(:price, 0..99) }
+    it { @product.should validate_inclusion_of(:price, 0..99).allow_nil(false) }
+    it { @product.should validate_inclusion_of(:price, 0..99).allow_blank(false) }
+
+    it { @product.should_not ensure_value_in_range(:price, 2..80) }
+    it { @product.should_not validate_inclusion_of(:price, 2..80) }
+    it { @product.should_not validate_inclusion_of(:price, 0..99, :allow_nil => true) }
+    it { @product.should_not validate_inclusion_of(:price, 0..99, :allow_blank => true) }
   end
 
   describe "A tangible product" do
@@ -18,13 +40,32 @@ describe Product do
       @product = Product.new(:tangible => true)
     end
 
-    it { @product.should_not allow_values_for(:size, "22", "10x15") }
-    it { @product.should allow_values_for(:size, "12x12x1") }
+    it { @product.should validate_inclusion_of(:size, "S", "M", "L", "XL") }
+    it { @product.should validate_inclusion_of(:size, "S", "M", "L", "XL").allow_blank }
+    it { @product.should_not validate_inclusion_of(:size, "XXXL", "XXL") }
+    it { @product.should_not validate_inclusion_of(:size, "S", "M", "L", "XL", :allow_blank => false) }
+
+    it { @product.should validate_exclusion_of(:size, "XS", "XM") }
+    it { @product.should_not validate_exclusion_of(:size, "S", "M", "L", "XL") }
+
+    it { @product.should require_attributes(:price, :title) }
+    it { @product.should validate_presence_of(:price, :title) }
 
-    it { @product.should require_attributes(:price) }
     it { @product.should ensure_value_in_range(:price, 1..9999) }
     it { @product.should ensure_value_in_range(:weight, 1..100) }
+
+    it { @product.should validate_inclusion_of(:price, 1..9999) }
+    it { @product.should validate_inclusion_of(:price, 1..9999).allow_nil }
+    it { @product.should_not validate_inclusion_of(:price, 1..9999, :allow_nil => false) }
+
+    it { @product.should validate_inclusion_of(:weight, 1..100) }
+    it { @product.should validate_inclusion_of(:weight, 1..100).allow_blank(true) }
+    it { @product.should_not validate_inclusion_of(:weight, 1..100, :allow_blank => false) }
+
     it { @product.should ensure_length_in_range(:size, 5..20) }
+    it { @product.should validate_length_of(:size, :in => 5..20).allow_blank }
+    it { @product.should_not validate_length_of(:size, :in => 1..10) }
+    it { @product.should_not validate_length_of(:size, :within => 5..20, :allow_blank => false) }
   end
 end
 
@@ -36,9 +77,14 @@ describe Product do
 
     should_not_allow_values_for :size, "22"
     should_allow_values_for :size, "22kb"
-
-    should_require_attributes :title
+    
     should_ensure_value_in_range :price, 0..99
+
+    should_require_attributes(:title)
+    should_not_require_attributes(:price)
+
+    should_validate_presence_of(:title)
+    should_not_validate_presence_of(:price)
   end
 
   describe "A tangible product" do
@@ -46,12 +92,31 @@ describe Product do
       @product = Product.new(:tangible => true)
     end
 
-    should_not_allow_values_for :size, "22", "10x15"
-    should_allow_values_for :size, "12x12x1"
+    should_validate_inclusion_of :size, "S", "M", "L", "XL"
+    should_validate_inclusion_of :size, :allow_blank => true
+    should_not_validate_inclusion_of :size, "XXXL", "XXL"
+    should_not_validate_inclusion_of :size, "S", "M", "L", "XL", :allow_blank => false
+
+    should_validate_exclusion_of :size, "XS", "XM"
+    should_not_validate_exclusion_of :size, "S", "M", "L", "XL"
+
+    should_require_attributes :price, :title
+    should_validate_presence_of :price, :title
 
-    should_require_attributes :price
     should_ensure_value_in_range :price, 1..9999
     should_ensure_value_in_range :weight, 1..100
+
+    should_validate_inclusion_of :price, 1..9999
+    should_validate_inclusion_of :price, 1..9999, :allow_nil => true
+    should_not_validate_inclusion_of :price, 1..9999, :allow_nil => false
+
+    should_validate_inclusion_of :weight, 1..100
+    should_validate_inclusion_of :weight, 1..100, :allow_blank => true
+    should_not_validate_inclusion_of :weight, 1..100, :allow_blank => false
+
     should_ensure_length_in_range :size, 5..20
+    should_validate_length_of :size, :in => 5..20, :allow_blank => true
+    should_not_validate_length_of :size, :in => 1..10
+    should_not_validate_length_of :size, :within =>5..20, :allow_blank => false
   end
 end

data/spec/models/tag_spec.rb

@@ -1,13 +1,13 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe Tag do
+  it { should have_many(:taggings).dependent(:destroy) }
   it { should have_many(:taggings, :dependent => :destroy) }
   it { should have_many(:posts) }
 
   it { should ensure_length_at_least(:name, 2) }
-
+  
   it { should protect_attributes(:secret) }
-
   it { should_not protect_attributes(:name) }
 end
 

data/spec/models/tagging_spec.rb

@@ -4,10 +4,34 @@ describe Tagging do
   it { should belong_to(:post) }
   it { should belong_to(:tag) }
   it { should belong_to(:post, :tag) }
+
+  it { should validate_associated(:post) }
+  it { should validate_associated(:tag) }
+  it { should validate_associated(:tag, :post) }
+
+  it do
+    # Create a Post mock that will return true when saving.
+    # This means that the object Post is always valid, then it can not be validated.
+    @post = mock_model(Post, :save => true, :valid? => true)
+    should_not validate_associated(:post)
+  end
+
+  it do
+    # Create a Tagging mock that will return true when saving.
+    # This means that even the association :post is not valid, :tagging will be valid.
+    # Then the association is not validated.
+    @tagging = Tagging.new
+    @tagging.stub!(:save).and_return(true)
+    should_not validate_associated(:post)
+  end
 end
 
 describe Tagging do
   should_belong_to :post
   should_belong_to :tag
   should_belong_to :post, :tag
+
+  should_validate_associated :tag
+  should_validate_associated :post
+  should_validate_associated :tag, :post
 end

data/spec/models/user_spec.rb

@@ -8,50 +8,180 @@ describe User do
   it { should have_many(:friendships) }
   it { should have_many(:friends) }
   it { should have_many(:posts, :dogs, :friendships, :friends) }
+
+  it { should validate_associated(:posts) }
+  it { should validate_associated(:address) }
+  it { should validate_associated(:posts, :address) }
+  it { should_not validate_associated(:dogs) }
   
   it { should have_one(:address) }
+  it { should have_one(:address).dependent(:destroy) }
   it { should have_one(:address, :dependent => :destroy) }
   
-  it { should have_indices(:email, :name, [:email, :name]) }
+  it { should_not have_index(:foo, :bar) }
+
+  it { should have_indices(:email, :name) }
+  it { should have_index([:email, :name]).unique }
+  it { should have_index([:email, :name]).unique(true) }
+  it { should have_index([:email, :name], :unique => true) }
+  it { should have_index(:age, :unique => false) }
+
+  it { should_not have_index(:phone) }
+  it { should_not have_index(:email, :unique => false) }
+  it { should_not have_index(:age, :unique => true) }
+
   it { should have_index(:age) }
-  
+  it { should_not have_index(:aged) }
+
+  it { should have_named_scope(:old)}
   it { should have_named_scope(:old, :conditions => "age > 50") }
+  it { should_not have_named_scope(:old, :conditions => "age > 49") }
   it { should have_named_scope(:eighteen, :conditions => { :age => 18 }) }
-
+  it { should_not have_named_scope(:eighteen, :conditions => { :age => 17 }) }
+  
+  it { should have_named_scope('recent(5)') }
   it { should have_named_scope('recent(5)', :limit => 5) }
+  it { should_not have_named_scope('recent(5)', :limit => 4) }
   it { should have_named_scope('recent(1)', :limit => 1) }
+  it { should_not have_named_scope('recent(1)', :limit => 2) }
   it { should have_named_scope('recent_via_method(7)', :limit => 7) }
-
+  it { should_not have_named_scope('recent_via_method(7)', :limit => 8) }
+  
   describe "when given an instance variable" do
     before(:each) do
       @count = 2
     end
     it { should have_named_scope("recent(#{@count})", :limit => 2) }
+    it { should_not have_named_scope("recent(#{@count})", :limit => 1) }
   end
   
+  it { should have_after_create_callback(:send_welcome_email) }
+  it { should_not have_after_save_callback(:send_welcome_email) }
+  it { should_not have_after_destroy_callback(:goodbye_jerk) }
+  it { should have_before_validation_on_update_callback(:some_weird_callback) }
+  
   it { should_not allow_values_for(:email, "blah", "b lah") }
   it { should allow_values_for(:email, "a@b.com", "asdf@asdf.com") }
-  it { should ensure_length_in_range(:email, 1..100) }
-  it { should ensure_value_in_range(:age, 1..100) }
+  it { should_not allow_values_for(:email, "a@b.com", "asdf@asdf.com").allow_nil }
+  it { should_not allow_values_for(:email, "a@b.com", "asdf@asdf.com").allow_nil(true) }
+  it { should allow_values_for(:email, "a@b.com", "asdf@asdf.com").allow_nil(false) }
+
+  it { should validate_confirmation_of(:username, :email) }
+  it { should_not validate_confirmation_of(:ssn) }
+  
+  it { should ensure_length_in_range(:email, 2..100) }
+  it { should_not ensure_length_in_range(:email, 1..100) }
+  it { should_not ensure_length_in_range(:email, 2..101) }
+  it { should_not ensure_length_in_range(:email, 3..100) }
+  it { should_not ensure_length_in_range(:email, 2..99) }
+
+  it { should validate_size_of(:email, :minimum => 2) }
+  it { should validate_size_of(:email, :maximum => 100) }
+  it { should validate_length_of(:email, :in => 2..100) }
+  it { should validate_length_of(:email, :within => 2..100).allow_nil(false) }
+  it { should validate_length_of(:email, :within => 2..100).allow_blank(false) }
+
+  it { should_not validate_length_of(:email, :is => 2) }
+  it { should_not validate_length_of(:email, :is => 100) }
+  it { should_not validate_length_of(:email, :within => 0..200) }
+  it { should_not validate_length_of(:email, :in => 2..100, :allow_nil => true) }
+  it { should_not validate_length_of(:email, :in => 2..100, :allow_blank => true) }
+
+  it { should ensure_value_in_range(:age, 2..100) }
+  it { should_not ensure_value_in_range(:age, 1..100) }
+  it { should_not ensure_value_in_range(:age, 2..101) }
+  it { should_not ensure_value_in_range(:age, 3..100) }
+  it { should_not ensure_value_in_range(:age, 2..99) }
+  
   it { should protect_attributes(:password) }
+  it { should_not protect_attributes(:name, :age) }
+
+  it { should allow_mass_assignment_of(:name, :age) }
+  it { should_not allow_mass_assignment_of(:password) }
+
+  it { should have_class_methods(:find) }
+  it { should_not have_class_methods(:foo) }
   it { should have_class_methods(:find, :destroy) }
+  it { should_not have_class_methods(:foo, :bar) }
+  
+  it { should have_instance_methods(:email) }
+  it { should_not have_instance_methods(:foo) }
   it { should have_instance_methods(:email, :age, :email=, :valid?) }
+  it { should_not have_instance_methods(:foo, :bar) }
   
+  it { should_not have_db_column(:foo) }
+  it { should_not have_db_columns(:foo, :bar) }
   it { should have_db_columns(:name, :email, :age) }
-  it { should have_db_column(:name) }
-  it { should have_db_column(:id, :type => "integer", :primary => true) }
-  it { should have_db_column(:email, :type => "string",  :default => nil,    :precision => nil,  :limit => 255,
-                                          :null => true,      :primary => false,  :scale => nil,      :sql_type => 'varchar(255)') }
+  it { should have_db_columns(:name, :email, :type => "string") }
+  it { should_not have_db_columns(:name, :email, :type => "integer") }
+  it { should have_db_columns(:name, :email).type("string") }
+  it { should_not have_db_columns(:foo, :bar).type("string") }
   
+  it { should have_db_column(:name) }
+  it { should have_db_column(:id).type("integer").primary(true) }
+  it { should have_db_column(:id).type("integer").primary }
+  it { should have_db_column(:email).type("string").default(nil).precision(nil).limit(255).null(true).primary(false).scale(nil).sql_type('varchar(255)') }
+  it { should have_db_column(:email).type("string") }
+  it { should_not have_db_column(:email).type("integer") }
+  it { should have_db_column(:email).default(nil) }
+  it { should_not have_db_column(:email).default('foo') }
+  it { should have_db_column(:email).precision(nil) }
+  it { should_not have_db_column(:email).precision(10) }
+  it { should have_db_column(:email).limit(255) }
+  it { should_not have_db_column(:email).limit(254) }
+  it { should have_db_column(:email).null(true) }
+  it { should have_db_column(:email).null }
+  it { should_not have_db_column(:email).null(false) }
+  it { should have_db_column(:email).primary(false) }
+  it { should_not have_db_column(:email).primary }
+  it { should_not have_db_column(:email).primary(true) }
+  it { should have_db_column(:email).scale(nil) }
+  it { should_not have_db_column(:email).scale(2) }
+  it { should have_db_column(:email).sql_type('varchar(255)') }
+  it { should_not have_db_column(:email).sql_type('varchar(254)') }
+  it { should have_db_column(:email, :type => "string").limit(255) }
+  it { should_not have_db_column(:email, :type => "integer").limit(255) }
+  it { should have_db_column(:email,  :type => "string",  :default => nil,    :precision => nil,  :limit => 255,
+                                      :null => true,      :primary => false,  :scale => nil,      :sql_type => 'varchar(255)') }
+
   it { should require_acceptance_of(:eula) }
+  it { should_not require_acceptance_of(:name) }
+  it { should_not validate_acceptance_of(:name) }
+
+  it { should validate_acceptance_of(:eula) }
+  it { should validate_acceptance_of(:eula, :allow_nil => true) }
+  it { should_not validate_acceptance_of(:eula, :allow_nil => false) }
+
+  it { should validate_acceptance_of(:terms).accept(true) }
+  it { should validate_acceptance_of(:terms).allow_nil(false) }
+  it { should_not validate_acceptance_of(:terms).allow_nil }
+  it { should_not validate_acceptance_of(:terms, :accept => false) }
+
+  it "should rails error when calling allow_blank on validate_acceptance_of matcher" do
+   proc{ should validate_acceptance_of(:terms).allow_nil.allow_blank }.should raise_error(NoMethodError)
+  end
+
+  it { should validate_uniqueness_of(:email, :scoped_to => :name) }
   it { should require_unique_attributes(:email, :scoped_to => :name) }
-  
+
   it { should ensure_length_is(:ssn, 9, :message => "Social Security Number is not the right length") }
+  it { should ensure_length_is(:ssn, 9).message("Social Security Number is not the right length") }
+  it { should_not ensure_length_is(:ssn, 9) }
+  it { should_not ensure_length_is(:ssn, 8).message("Social Security Number is not the right length") }
+  it { should_not ensure_length_is(:ssn, 10).message("Social Security Number is not the right length") }
+
+  it { should validate_length_of(:ssn, :is => 9).message("Social Security Number is not the right length") }
+  it { should validate_length_of(:ssn, :is => 9, :message => "Social Security Number is not the right length") }
+
   it { should only_allow_numeric_values_for(:ssn) }
-  
+
+  it { should validate_numericality_of(:ssn) }
+  it { should validate_numericality_of(:ssn).equal_to(123456789) }
+  it { should_not validate_numericality_of(:ssn, :equal_to => 123456780) }
+
   it { should have_readonly_attributes(:name) }
-  
-  it { should_not protect_attributes(:name, :age) }
+  it { should_not have_readonly_attributes(:foo) }
+  it { should_not have_readonly_attributes(:ssn) }
 end
 
 describe User do
@@ -65,9 +195,20 @@ describe User do
   
   should_have_one :address
   should_have_one :address, :dependent => :destroy
+
+  should_validate_associated(:posts)
+  should_validate_associated(:address)
+  should_validate_associated(:posts, :address)
+  should_not_validate_associated(:dogs)
   
-  should_have_indices :email, :name, [:email, :name]
+  should_have_indices :email, :name
   should_have_index :age
+  should_have_index [:email, :name], :unique => true
+  should_have_index :age, :unique => false
+  
+  should_not_have_index :phone
+  should_not_have_index :email, :unique => false
+  should_not_have_index :age, :unique => true
   
   should_have_named_scope :old, :conditions => "age > 50"
   should_have_named_scope :eighteen, :conditions => { :age => 18 }
@@ -80,28 +221,72 @@ describe User do
     before(:each) do
       @count = 2
     end
-    should_have_named_scope "recent(@count)", :limit => 2
+    # should_have_named_scope "recent(@count)", :limit => 2
   end
+
+  should_have_after_create_callback(:send_welcome_email)
+  should_not_have_after_save_callback(:send_welcome_email)
+  should_not_have_after_destroy_callback(:goodbye_jerk)
+  should_have_before_validation_on_update_callback(:some_weird_callback)
   
   should_not_allow_values_for :email, "blah", "b lah"
   should_allow_values_for :email, "a@b.com", "asdf@asdf.com"
-  should_ensure_length_in_range :email, 1..100
-  should_ensure_value_in_range :age, 1..100
+  should_ensure_value_in_range :age, 2..100
   should_protect_attributes :password
   should_have_class_methods :find, :destroy
   should_have_instance_methods :email, :age, :email=, :valid?
+
+  should_allow_mass_assignment_of :email
+  should_not_allow_mass_assignment_of :password
+
+  should_ensure_length_in_range :email, 2..100
+
+  should_validate_size_of :email, :minimum => 2
+  should_validate_size_of :email, :maximum => 100
+  should_validate_length_of :email, :in => 2..100
+  should_validate_length_of :email, :within => 2..100 , :allow_nil => false
+  should_validate_length_of :email, :within => 2..100, :allow_blank => false
+
+  should_not_validate_length_of :email, :is => 2
+  should_not_validate_length_of :email, :is => 100
+  should_not_validate_length_of :email, :within => 0..200
+  should_not_validate_length_of :email, :in => 2..100, :allow_nil => true
+  should_not_validate_length_of :email, :in => 2..100, :allow_blank => true
+
+  should_validate_confirmation_of :username, :email
+  should_not_validate_confirmation_of :ssn
   
   should_have_db_columns :name, :email, :age
+  should_have_db_columns :name, :email, :type => "string"
+  
   should_have_db_column :name
   should_have_db_column :id, :type => "integer", :primary => true
   should_have_db_column :email, :type => "string",  :default => nil,    :precision => nil,  :limit => 255,
                                 :null => true,      :primary => false,  :scale => nil,      :sql_type => 'varchar(255)'
-  
+
   should_require_acceptance_of :eula
+  should_validate_acceptance_of :eula
+  should_validate_acceptance_of :eula, :allow_nil => true
+  should_not_validate_acceptance_of :eula, :allow_nil => false
+
+  should_validate_acceptance_of :terms
+  should_validate_acceptance_of :terms, :accept => true
+  should_validate_acceptance_of :terms, :allow_nil => false
+  should_not_validate_acceptance_of :terms, :allow_nil => true
+  should_not_validate_acceptance_of :terms, :accept => false
+
+  should_not_validate_acceptance_of :name
+  should_not_require_acceptance_of :name
+
+  should_validate_uniqueness_of :email, :scoped_to => :name
   should_require_unique_attributes :email, :scoped_to => :name
-  
+
   should_ensure_length_is :ssn, 9, :message => "Social Security Number is not the right length"
   should_only_allow_numeric_values_for :ssn
-  
+
+  should_validate_numericality_of :ssn
+  should_validate_numericality_of :ssn, :equal_to => 123456789
+  should_not_validate_numericality_of :ssn, :equal_to => 123456780
+
   should_have_readonly_attributes :name
 end

data/spec/other/custom_macros_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Custom Macros" do
+  before(:all) do
+    custom_macro = File.join(RAILS_ROOT, "spec", "remarkable_macros", "run_my_custom_macro.rb")
+    plugin_macro = File.join(RAILS_ROOT, "vendor", "plugins", "my_plugin", "remarkable_macros", "run_my_plugin_macro.rb")
+
+    [custom_macro, plugin_macro].each do |macro_file|
+      File.open(macro_file, "w") do |f|
+        f.puts("it 'should run my macro' do\t  true.should be_true\tend")
+      end
+    end
+
+    load File.expand_path(File.dirname(__FILE__) + '/../../lib/remarkable/rails.rb')
+  end
+
+  it { self.class.should respond_to(:should_run_my_custom_macro) }
+  it { should run_my_custom_macro }
+
+  it { self.class.should respond_to(:should_run_my_plugin_macro) }
+  it { should run_my_plugin_macro }
+
+  after(:all) do
+    FileUtils.rm(File.join(RAILS_ROOT, "spec", "remarkable_macros", "run_my_custom_macro.rb"), :force => true)
+    FileUtils.rm(File.join(RAILS_ROOT, "vendor", "plugins", "my_plugin", "remarkable_macros", "run_my_plugin_macro.rb"), :force => true)
+  end
+end

data/spec/other/my_own_matcher_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "my own matcher" do
+  it { "abc".should first_three_letters_of_alphabet }
+end
+
+def first_three_letters_of_alphabet
+  simple_matcher "be the first three letters of alphabet" do |spec|
+    spec.should == "abc"
+  end
+end

data/spec/other/private_helpers_spec.rb

@@ -0,0 +1,31 @@
+# require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+# 
+# describe "PrivateHelpers" do
+#   describe "get_options!" do
+#     it "remove opts from args" do
+#       args = [:a, :b, {}]
+#       get_options!(args)
+#       args.should == [:a, :b]
+#     end
+# 
+#     it "return wanted opts in order" do
+#       args = [{:one => 1, :two => 2}]
+#       one, two = get_options!(args, :one, :two)
+#       one.should == 1
+#       two.should == 2
+#     end
+# 
+#     it "raise ArgumentError if given unwanted option" do
+#       args = [{:one => 1, :two => 2}]
+#       lambda { get_options!(args, :one) }.should raise_error(ArgumentError)
+#     end
+#   end
+# 
+#   class ::SomeModel; end
+#   describe "subject_class" do
+#     it "sniff the class constant from the test class" do
+#       self.should_receive(:described_type).and_return(SomeModel)
+#       subject_class.should == SomeModel
+#     end
+#   end
+# end

data/spec/rails_root/app/controllers/posts_controller.rb

@@ -4,6 +4,7 @@ class PostsController < ApplicationController
   
   def index
     @posts = @user.posts
+    @some_text = "foo bar"
 
     respond_to do |format|
       format.html # index.rhtml
@@ -19,6 +20,7 @@ class PostsController < ApplicationController
 
   def show
     @post = @user.posts.find(params[:id])
+    @false_flag = false
 
     respond_to do |format|
       format.html { render :layout => 'wide' }

data/spec/rails_root/app/models/address.rb

@@ -2,6 +2,6 @@ class Address < ActiveRecord::Base
   belongs_to :addressable, :polymorphic => true
   validates_uniqueness_of :title, :scope => [:addressable_type, :addressable_id]
   
-  validates_length_of :zip, :minimum => 5
-  validates_numericality_of :zip  
+  validates_length_of :zip, :minimum => 5, :allow_nil => true
+  validates_numericality_of :zip, :less_than => 20, :greater_than => 10
 end

data/spec/rails_root/app/models/flea.rb

@@ -1,3 +1,7 @@
 class Flea < ActiveRecord::Base
   has_and_belongs_to_many :dogs
+  validates_presence_of :name
+  validates_uniqueness_of :name, :case_sensitive => false
+  validates_uniqueness_of :color, :allow_nil => true
+  validates_uniqueness_of :address, :allow_blank => true
 end

data/spec/rails_root/app/models/pets/dog.rb

@@ -0,0 +1,12 @@
+module Pets
+  class Dog < ActiveRecord::Base
+    belongs_to :user, :foreign_key => :owner_id
+    belongs_to :address
+    has_and_belongs_to_many :fleas, :join_table => :fleas
+
+    validates_numericality_of :age, :allow_blank => true, :only_integer => true, :odd => true, :greater_than_or_equal_to => 10
+    validates_numericality_of :owner_id, :allow_nil => true, :even => true, :less_than_or_equal_to => 10
+
+    validates_presence_of :owner_id
+  end
+end