mspec 1.8.0 → 1.9.0

data/spec/matchers/equal_element_spec.rb

@@ -4,72 +4,72 @@ require 'mspec/matchers'
 
 describe EqualElementMatcher do
   it "matches if it finds an element with the passed name, no matter what attributes/content" do
-    EqualElementMatcher.new("A").matches?('<A></A>').should be_true
-    EqualElementMatcher.new("A").matches?('<A HREF="http://example.com"></A>').should be_true
-    EqualElementMatcher.new("A").matches?('<A HREF="http://example.com"></A>').should be_true
+    EqualElementMatcher.new("A").matches?('<A></A>').should be_truthy
+    EqualElementMatcher.new("A").matches?('<A HREF="http://example.com"></A>').should be_truthy
+    EqualElementMatcher.new("A").matches?('<A HREF="http://example.com"></A>').should be_truthy
 
-    EqualElementMatcher.new("BASE").matches?('<BASE></A>').should be_false
-    EqualElementMatcher.new("BASE").matches?('<A></BASE>').should be_false
-    EqualElementMatcher.new("BASE").matches?('<A></A>').should be_false
-    EqualElementMatcher.new("BASE").matches?('<A HREF="http://example.com"></A>').should be_false
-    EqualElementMatcher.new("BASE").matches?('<A HREF="http://example.com"></A>').should be_false
+    EqualElementMatcher.new("BASE").matches?('<BASE></A>').should be_falsey
+    EqualElementMatcher.new("BASE").matches?('<A></BASE>').should be_falsey
+    EqualElementMatcher.new("BASE").matches?('<A></A>').should be_falsey
+    EqualElementMatcher.new("BASE").matches?('<A HREF="http://example.com"></A>').should be_falsey
+    EqualElementMatcher.new("BASE").matches?('<A HREF="http://example.com"></A>').should be_falsey
   end
 
   it "matches if it finds an element with the passed name and the passed attributes" do
-    EqualElementMatcher.new("A", {}).matches?('<A></A>').should be_true
-    EqualElementMatcher.new("A", nil).matches?('<A HREF="http://example.com"></A>').should be_true
-    EqualElementMatcher.new("A", "HREF" => "http://example.com").matches?('<A HREF="http://example.com"></A>').should be_true
+    EqualElementMatcher.new("A", {}).matches?('<A></A>').should be_truthy
+    EqualElementMatcher.new("A", nil).matches?('<A HREF="http://example.com"></A>').should be_truthy
+    EqualElementMatcher.new("A", "HREF" => "http://example.com").matches?('<A HREF="http://example.com"></A>').should be_truthy
 
-    EqualElementMatcher.new("A", {}).matches?('<A HREF="http://example.com"></A>').should be_false
-    EqualElementMatcher.new("A", "HREF" => "http://example.com").matches?('<A></A>').should be_false
-    EqualElementMatcher.new("A", "HREF" => "http://example.com").matches?('<A HREF="http://test.com"></A>').should be_false
-    EqualElementMatcher.new("A", "HREF" => "http://example.com").matches?('<A HREF="http://example.com" HREF="http://example.com"></A>').should be_false
+    EqualElementMatcher.new("A", {}).matches?('<A HREF="http://example.com"></A>').should be_falsey
+    EqualElementMatcher.new("A", "HREF" => "http://example.com").matches?('<A></A>').should be_falsey
+    EqualElementMatcher.new("A", "HREF" => "http://example.com").matches?('<A HREF="http://test.com"></A>').should be_falsey
+    EqualElementMatcher.new("A", "HREF" => "http://example.com").matches?('<A HREF="http://example.com" HREF="http://example.com"></A>').should be_falsey
   end
 
   it "matches if it finds an element with the passed name, the passed attributes and the passed content" do
-    EqualElementMatcher.new("A", {}, "").matches?('<A></A>').should be_true
-    EqualElementMatcher.new("A", {"HREF" => "http://example.com"}, "Example").matches?('<A HREF="http://example.com">Example</A>').should be_true
+    EqualElementMatcher.new("A", {}, "").matches?('<A></A>').should be_truthy
+    EqualElementMatcher.new("A", {"HREF" => "http://example.com"}, "Example").matches?('<A HREF="http://example.com">Example</A>').should be_truthy
 
-    EqualElementMatcher.new("A", {}, "Test").matches?('<A></A>').should be_false
-    EqualElementMatcher.new("A", {"HREF" => "http://example.com"}, "Example").matches?('<A HREF="http://example.com"></A>').should be_false
-    EqualElementMatcher.new("A", {"HREF" => "http://example.com"}, "Example").matches?('<A HREF="http://example.com">Test</A>').should be_false
+    EqualElementMatcher.new("A", {}, "Test").matches?('<A></A>').should be_falsey
+    EqualElementMatcher.new("A", {"HREF" => "http://example.com"}, "Example").matches?('<A HREF="http://example.com"></A>').should be_falsey
+    EqualElementMatcher.new("A", {"HREF" => "http://example.com"}, "Example").matches?('<A HREF="http://example.com">Test</A>').should be_falsey
   end
   
   it "can match unclosed elements" do
-    EqualElementMatcher.new("BASE", nil, nil, :not_closed => true).matches?('<BASE>').should be_true
-    EqualElementMatcher.new("BASE", {"HREF" => "http://example.com"}, nil, :not_closed => true).matches?('<BASE HREF="http://example.com">').should be_true
-    EqualElementMatcher.new("BASE", {"HREF" => "http://example.com"}, "Example", :not_closed => true).matches?('<BASE HREF="http://example.com">Example').should be_true
+    EqualElementMatcher.new("BASE", nil, nil, :not_closed => true).matches?('<BASE>').should be_truthy
+    EqualElementMatcher.new("BASE", {"HREF" => "http://example.com"}, nil, :not_closed => true).matches?('<BASE HREF="http://example.com">').should be_truthy
+    EqualElementMatcher.new("BASE", {"HREF" => "http://example.com"}, "Example", :not_closed => true).matches?('<BASE HREF="http://example.com">Example').should be_truthy
 
-    EqualElementMatcher.new("BASE", {}, nil, :not_closed => true).matches?('<BASE HREF="http://example.com">').should be_false
-    EqualElementMatcher.new("BASE", {"HREF" => "http://example.com"}, "", :not_closed => true).matches?('<BASE HREF="http://example.com">Example').should be_false
-    EqualElementMatcher.new("BASE", {"HREF" => "http://example.com"}, "Test", :not_closed => true).matches?('<BASE HREF="http://example.com">Example').should be_false
+    EqualElementMatcher.new("BASE", {}, nil, :not_closed => true).matches?('<BASE HREF="http://example.com">').should be_falsey
+    EqualElementMatcher.new("BASE", {"HREF" => "http://example.com"}, "", :not_closed => true).matches?('<BASE HREF="http://example.com">Example').should be_falsey
+    EqualElementMatcher.new("BASE", {"HREF" => "http://example.com"}, "Test", :not_closed => true).matches?('<BASE HREF="http://example.com">Example').should be_falsey
   end
 
   it "provides a useful failure message" do
     equal_element = EqualElementMatcher.new("A", {}, "Test")
-    equal_element.matches?('<A></A>').should be_false
+    equal_element.matches?('<A></A>').should be_falsey
     equal_element.failure_message.should == [%{Expected "<A></A>"\n}, %{to be a 'A' element with no attributes and "Test" as content}]
 
     equal_element = EqualElementMatcher.new("A", {}, "")
-    equal_element.matches?('<A>Test</A>').should be_false
+    equal_element.matches?('<A>Test</A>').should be_falsey
     equal_element.failure_message.should == [%{Expected "<A>Test</A>"\n}, %{to be a 'A' element with no attributes and no content}]
 
     equal_element = EqualElementMatcher.new("A", "HREF" => "http://www.example.com")
-    equal_element.matches?('<A>Test</A>').should be_false
+    equal_element.matches?('<A>Test</A>').should be_falsey
     equal_element.failure_message.should == [%{Expected "<A>Test</A>"\n}, %{to be a 'A' element with HREF="http://www.example.com" and any content}]
   end
 
   it "provides a useful negative failure message" do
     equal_element = EqualElementMatcher.new("A", {}, "Test")
-    equal_element.matches?('<A></A>').should be_false
+    equal_element.matches?('<A></A>').should be_falsey
     equal_element.negative_failure_message.should == [%{Expected "<A></A>"\n}, %{not to be a 'A' element with no attributes and "Test" as content}]
 
     equal_element = EqualElementMatcher.new("A", {}, "")
-    equal_element.matches?('<A>Test</A>').should be_false
+    equal_element.matches?('<A>Test</A>').should be_falsey
     equal_element.negative_failure_message.should == [%{Expected "<A>Test</A>"\n}, %{not to be a 'A' element with no attributes and no content}]
 
     equal_element = EqualElementMatcher.new("A", "HREF" => "http://www.example.com")
-    equal_element.matches?('<A>Test</A>').should be_false
+    equal_element.matches?('<A>Test</A>').should be_falsey
     equal_element.negative_failure_message.should == [%{Expected "<A>Test</A>"\n}, %{not to be a 'A' element with HREF="http://www.example.com" and any content}]
   end
 end

data/spec/matchers/have_class_variable_spec.rb

@@ -11,22 +11,22 @@ shared_examples_for "have_class_variable, on all Ruby versions" do
 
   it "matches when mod has the class variable, given as string" do
     matcher = HaveClassVariableMatcher.new('@foo')
-    matcher.matches?(IVarModMock).should be_true
+    matcher.matches?(IVarModMock).should be_truthy
   end
 
   it "matches when mod has the class variable, given as symbol" do
     matcher = HaveClassVariableMatcher.new(:@foo)
-    matcher.matches?(IVarModMock).should be_true
+    matcher.matches?(IVarModMock).should be_truthy
   end
 
   it "does not match when mod hasn't got the class variable, given as string" do
     matcher = HaveClassVariableMatcher.new('@bar')
-    matcher.matches?(IVarModMock).should be_false
+    matcher.matches?(IVarModMock).should be_falsey
   end
 
   it "does not match when mod hasn't got the class variable, given as symbol" do
     matcher = HaveClassVariableMatcher.new(:@bar)
-    matcher.matches?(IVarModMock).should be_false
+    matcher.matches?(IVarModMock).should be_falsey
   end
 
   it "provides a failure message for #should" do

data/spec/matchers/have_constant_spec.rb

@@ -9,12 +9,12 @@ end
 describe HaveConstantMatcher do
   it "matches when mod has the constant" do
     matcher = HaveConstantMatcher.new :X
-    matcher.matches?(HCMSpecs).should be_true
+    matcher.matches?(HCMSpecs).should be_truthy
   end
 
   it "does not match when mod does not have the constant" do
     matcher = HaveConstantMatcher.new :A
-    matcher.matches?(HCMSpecs).should be_false
+    matcher.matches?(HCMSpecs).should be_falsey
   end
 
   it "provides a failure message for #should" do

data/spec/matchers/have_data_spec.rb

@@ -21,19 +21,19 @@ describe HaveDataMatcher do
   end
 
   it "matches when the named file begins with the same bytes as data" do
-    HaveDataMatcher.new("123a").matches?(@name).should be_true
+    HaveDataMatcher.new("123a").matches?(@name).should be_truthy
   end
 
   it "does not match when the named file begins with fewer bytes than data" do
-    HaveDataMatcher.new("123abcPQR").matches?(@name).should be_false
+    HaveDataMatcher.new("123abcPQR").matches?(@name).should be_falsey
   end
 
   it "does not match when the named file begins with different bytes than data" do
-    HaveDataMatcher.new("abc1").matches?(@name).should be_false
+    HaveDataMatcher.new("abc1").matches?(@name).should be_falsey
   end
 
   it "accepts an optional mode argument to open the data file" do
-    HaveDataMatcher.new("123a", "r").matches?(@name).should be_true
+    HaveDataMatcher.new("123a", "r").matches?(@name).should be_truthy
   end
 
   it "provides a useful failure message" do

data/spec/matchers/have_instance_method_spec.rb

@@ -19,18 +19,18 @@ describe HaveInstanceMethodMatcher do
 
   it "matches when mod has the instance method" do
     matcher = HaveInstanceMethodMatcher.new :instance_method
-    matcher.matches?(HIMMSpecs).should be_true
-    matcher.matches?(HIMMSpecs::Subclass).should be_true
+    matcher.matches?(HIMMSpecs).should be_truthy
+    matcher.matches?(HIMMSpecs::Subclass).should be_truthy
   end
 
   it "does not match when mod does not have the instance method" do
     matcher = HaveInstanceMethodMatcher.new :another_method
-    matcher.matches?(HIMMSpecs).should be_false
+    matcher.matches?(HIMMSpecs).should be_falsey
   end
 
   it "does not match if the method is in a superclass and include_super is false" do
     matcher = HaveInstanceMethodMatcher.new :instance_method, false
-    matcher.matches?(HIMMSpecs::Subclass).should be_false
+    matcher.matches?(HIMMSpecs::Subclass).should be_falsey
   end
 
   it "provides a failure message for #should" do

data/spec/matchers/have_instance_variable_spec.rb

@@ -9,22 +9,22 @@ shared_examples_for "have_instance_variable, on all Ruby versions" do
 
   it "matches when object has the instance variable, given as string" do
     matcher = HaveInstanceVariableMatcher.new('@foo')
-    matcher.matches?(@object).should be_true
+    matcher.matches?(@object).should be_truthy
   end
 
   it "matches when object has the instance variable, given as symbol" do
     matcher = HaveInstanceVariableMatcher.new(:@foo)
-    matcher.matches?(@object).should be_true
+    matcher.matches?(@object).should be_truthy
   end
 
   it "does not match when object hasn't got the instance variable, given as string" do
     matcher = HaveInstanceVariableMatcher.new('@bar')
-    matcher.matches?(@object).should be_false
+    matcher.matches?(@object).should be_falsey
   end
 
   it "does not match when object hasn't got the instance variable, given as symbol" do
     matcher = HaveInstanceVariableMatcher.new(:@bar)
-    matcher.matches?(@object).should be_false
+    matcher.matches?(@object).should be_falsey
   end
 
   it "provides a failure message for #should" do

data/spec/matchers/have_method_spec.rb

@@ -19,20 +19,20 @@ describe HaveMethodMatcher do
 
   it "matches when mod has the method" do
     matcher = HaveMethodMatcher.new :instance_method
-    matcher.matches?(HMMSpecs).should be_true
-    matcher.matches?(HMMSpecs.new).should be_true
-    matcher.matches?(HMMSpecs::Subclass).should be_true
-    matcher.matches?(HMMSpecs::Subclass.new).should be_true
+    matcher.matches?(HMMSpecs).should be_truthy
+    matcher.matches?(HMMSpecs.new).should be_truthy
+    matcher.matches?(HMMSpecs::Subclass).should be_truthy
+    matcher.matches?(HMMSpecs::Subclass.new).should be_truthy
   end
 
   it "does not match when mod does not have the method" do
     matcher = HaveMethodMatcher.new :another_method
-    matcher.matches?(HMMSpecs).should be_false
+    matcher.matches?(HMMSpecs).should be_falsey
   end
 
   it "does not match if the method is in a superclass and include_super is false" do
     matcher = HaveMethodMatcher.new :instance_method, false
-    matcher.matches?(HMMSpecs::Subclass).should be_false
+    matcher.matches?(HMMSpecs::Subclass).should be_falsey
   end
 
   it "provides a failure message for #should" do

data/spec/matchers/have_private_instance_method_spec.rb

@@ -23,18 +23,18 @@ describe HavePrivateInstanceMethodMatcher do
 
   it "matches when mod has the private instance method" do
     matcher = HavePrivateInstanceMethodMatcher.new :private_method
-    matcher.matches?(HPIMMSpecs).should be_true
-    matcher.matches?(HPIMMSpecs::Subclass).should be_true
+    matcher.matches?(HPIMMSpecs).should be_truthy
+    matcher.matches?(HPIMMSpecs::Subclass).should be_truthy
   end
 
   it "does not match when mod does not have the private instance method" do
     matcher = HavePrivateInstanceMethodMatcher.new :another_method
-    matcher.matches?(HPIMMSpecs).should be_false
+    matcher.matches?(HPIMMSpecs).should be_falsey
   end
 
   it "does not match if the method is in a superclass and include_super is false" do
     matcher = HavePrivateInstanceMethodMatcher.new :private_method, false
-    matcher.matches?(HPIMMSpecs::Subclass).should be_false
+    matcher.matches?(HPIMMSpecs::Subclass).should be_falsey
   end
 
   it "provides a failure message for #should" do

data/spec/matchers/have_private_method_spec.rb

@@ -16,12 +16,12 @@ describe HavePrivateMethodMatcher do
 
   it "matches when mod has the private method" do
     matcher = HavePrivateMethodMatcher.new :private_method
-    matcher.matches?(HPMMSpecs).should be_true
+    matcher.matches?(HPMMSpecs).should be_truthy
   end
 
   it "does not match when mod does not have the private method" do
     matcher = HavePrivateMethodMatcher.new :another_method
-    matcher.matches?(HPMMSpecs).should be_false
+    matcher.matches?(HPMMSpecs).should be_falsey
   end
 
   it "provides a failure message for #should" do

data/spec/matchers/have_protected_instance_method_spec.rb

@@ -23,18 +23,18 @@ describe HaveProtectedInstanceMethodMatcher do
 
   it "matches when mod has the protected instance method" do
     matcher = HaveProtectedInstanceMethodMatcher.new :protected_method
-    matcher.matches?(HPIMMSpecs).should be_true
-    matcher.matches?(HPIMMSpecs::Subclass).should be_true
+    matcher.matches?(HPIMMSpecs).should be_truthy
+    matcher.matches?(HPIMMSpecs::Subclass).should be_truthy
   end
 
   it "does not match when mod does not have the protected instance method" do
     matcher = HaveProtectedInstanceMethodMatcher.new :another_method
-    matcher.matches?(HPIMMSpecs).should be_false
+    matcher.matches?(HPIMMSpecs).should be_falsey
   end
 
   it "does not match if the method is in a superclass and include_super is false" do
     matcher = HaveProtectedInstanceMethodMatcher.new :protected_method, false
-    matcher.matches?(HPIMMSpecs::Subclass).should be_false
+    matcher.matches?(HPIMMSpecs::Subclass).should be_falsey
   end
 
   it "provides a failure message for #should" do

data/spec/matchers/have_public_instance_method_spec.rb

@@ -19,18 +19,18 @@ describe HavePublicInstanceMethodMatcher do
 
   it "matches when mod has the public instance method" do
     matcher = HavePublicInstanceMethodMatcher.new :public_method
-    matcher.matches?(HPIMMSpecs).should be_true
-    matcher.matches?(HPIMMSpecs::Subclass).should be_true
+    matcher.matches?(HPIMMSpecs).should be_truthy
+    matcher.matches?(HPIMMSpecs::Subclass).should be_truthy
   end
 
   it "does not match when mod does not have the public instance method" do
     matcher = HavePublicInstanceMethodMatcher.new :another_method
-    matcher.matches?(HPIMMSpecs).should be_false
+    matcher.matches?(HPIMMSpecs).should be_falsey
   end
 
   it "does not match if the method is in a superclass and include_super is false" do
     matcher = HavePublicInstanceMethodMatcher.new :public_method, false
-    matcher.matches?(HPIMMSpecs::Subclass).should be_false
+    matcher.matches?(HPIMMSpecs::Subclass).should be_falsey
   end
 
   it "provides a failure message for #should" do

data/spec/matchers/have_singleton_method_spec.rb

@@ -14,7 +14,7 @@ describe HaveSingletonMethodMatcher do
 
   it "matches when the class has a singleton method" do
     matcher = HaveSingletonMethodMatcher.new :singleton_method
-    matcher.matches?(HSMMSpecs).should be_true
+    matcher.matches?(HSMMSpecs).should be_truthy
   end
 
   it "matches when the object has a singleton method" do
@@ -22,7 +22,7 @@ describe HaveSingletonMethodMatcher do
     def obj.singleton_method; end
 
     matcher = HaveSingletonMethodMatcher.new :singleton_method
-    matcher.matches?(obj).should be_true
+    matcher.matches?(obj).should be_truthy
   end
 
   it "provides a failure message for #should" do

data/spec/mocks/mock_spec.rb

@@ -44,16 +44,16 @@ describe Mock, ".replaced?" do
 
   it "returns true if a method has been stubbed on an object" do
     Mock.install_method @mock, :method_call
-    Mock.replaced?(Mock.replaced_name(@mock, :method_call)).should be_true
+    Mock.replaced?(Mock.replaced_name(@mock, :method_call)).should be_truthy
   end
 
   it "returns true if a method has been mocked on an object" do
     Mock.install_method @mock, :method_call, :stub
-    Mock.replaced?(Mock.replaced_name(@mock, :method_call)).should be_true
+    Mock.replaced?(Mock.replaced_name(@mock, :method_call)).should be_truthy
   end
 
   it "returns false if a method has not been stubbed or mocked" do
-    Mock.replaced?(Mock.replaced_name(@mock, :method_call)).should be_false
+    Mock.replaced?(Mock.replaced_name(@mock, :method_call)).should be_falsey
   end
 end
 
@@ -461,9 +461,9 @@ describe Mock, ".cleanup" do
     Mock.should_receive(:clear_replaced).with(replaced_key)
 
     replaced_name = Mock.replaced_name(@mock, :method_call)
-    Mock.replaced?(replaced_name).should be_true
+    Mock.replaced?(replaced_name).should be_truthy
 
     Mock.cleanup
-    Mock.replaced?(replaced_name).should be_false
+    Mock.replaced?(replaced_name).should be_falsey
   end
 end

data/spec/mocks/proxy_spec.rb

@@ -15,11 +15,11 @@ end
 
 describe MockProxy, ".new" do
   it "creates a mock proxy by default" do
-    MockProxy.new.mock?.should be_true
+    MockProxy.new.mock?.should be_truthy
   end
 
   it "creates a stub proxy by request" do
-    MockProxy.new(:stub).stub?.should be_true
+    MockProxy.new(:stub).stub?.should be_truthy
   end
 
   it "sets the call expectation to 1 call for a mock" do
@@ -294,21 +294,21 @@ end
 
 describe MockProxy, "#stub?" do
   it "returns true if the proxy is created as a stub" do
-    MockProxy.new(:stub).stub?.should be_true
+    MockProxy.new(:stub).stub?.should be_truthy
   end
 
   it "returns false if the proxy is created as a mock" do
-    MockProxy.new(:mock).stub?.should be_false
+    MockProxy.new(:mock).stub?.should be_falsey
   end
 end
 
 describe MockProxy, "#mock?" do
   it "returns true if the proxy is created as a mock" do
-    MockProxy.new(:mock).mock?.should be_true
+    MockProxy.new(:mock).mock?.should be_truthy
   end
 
   it "returns false if the proxy is created as a stub" do
-    MockProxy.new(:stub).mock?.should be_false
+    MockProxy.new(:stub).mock?.should be_falsey
   end
 end
 
@@ -379,11 +379,11 @@ describe MockProxy, "#yielding?" do
   end
 
   it "returns false if the proxy is not yielding" do
-    @proxy.yielding?.should be_false
+    @proxy.yielding?.should be_falsey
   end
 
   it "returns true if the proxy is yielding" do
     @proxy.and_yield(1)
-    @proxy.yielding?.should be_true
+    @proxy.yielding?.should be_truthy
   end
 end

data/spec/runner/actions/tag_spec.rb

@@ -40,12 +40,12 @@ describe TagAction, "#exception?" do
   end
 
   it "returns false if no exception has been raised while evaluating an example" do
-    @action.exception?.should be_false
+    @action.exception?.should be_falsey
   end
 
   it "returns true if an exception was raised while evaluating an example" do
     @action.exception ExceptionState.new nil, nil, Exception.new("failed")
-    @action.exception?.should be_true
+    @action.exception?.should be_truthy
   end
 end
 
@@ -87,20 +87,20 @@ end
 describe TagAction, "#before" do
   it "resets the #exception? flag to false" do
     action = TagAction.new :add, :fail, nil, nil, nil, nil
-    action.exception?.should be_false
+    action.exception?.should be_falsey
     action.exception ExceptionState.new(nil, nil, Exception.new("Fail!"))
-    action.exception?.should be_true
+    action.exception?.should be_truthy
     action.before(ExampleState.new(ContextState.new("describe"), "it"))
-    action.exception?.should be_false
+    action.exception?.should be_falsey
   end
 end
 
 describe TagAction, "#exception" do
   it "sets the #exception? flag" do
     action = TagAction.new :add, :fail, nil, nil, nil, nil
-    action.exception?.should be_false
+    action.exception?.should be_falsey
     action.exception ExceptionState.new(nil, nil, Exception.new("Fail!"))
-    action.exception?.should be_true
+    action.exception?.should be_truthy
   end
 end