Prefer should.predicate? over predicate?.should == true

Author: nobu

command_line/error_message_spec.rb

@@ -3,9 +3,9 @@
 describe "The error message caused by an exception" do
   it "is not printed to stdout" do
     out = ruby_exe("this_does_not_exist", args: "2> #{File::NULL}")
-    out.chomp.empty?.should == true
+    out.chomp.should.empty?
 
     out = ruby_exe("end #syntax error", args: "2> #{File::NULL}")
-    out.chomp.empty?.should == true
+    out.chomp.should.empty?
   end
 end

core/argf/binmode_spec.rb

@@ -34,7 +34,7 @@
   it "sets the file's encoding to BINARY" do
     argf [@bin_file, @file1] do
       @argf.binmode
-      @argf.binmode?.should == true
+      @argf.should.binmode?
       @argf.gets.encoding.should == Encoding::BINARY
       @argf.skip
       @argf.read.encoding.should == Encoding::BINARY

core/array/any_spec.rb

@@ -4,17 +4,17 @@
   describe 'with no block given (a default block of { |x| x } is implicit)' do
     it "is false if the array is empty" do
       empty_array = []
-      empty_array.any?.should == false
+      empty_array.should_not.any?
     end
 
     it "is false if the array is not empty, but all the members of the array are falsy" do
       falsy_array = [false, nil, false]
-      falsy_array.any?.should == false
+      falsy_array.should_not.any?
     end
 
     it "is true if the array has any truthy members" do
       not_empty_array = ['anything', nil]
-      not_empty_array.any?.should == true
+      not_empty_array.should.any?
     end
   end
 

core/array/clear_spec.rb

@@ -16,7 +16,7 @@
   it "leaves the Array empty" do
     a = [1]
     a.clear
-    a.empty?.should == true
+    a.should.empty?
     a.size.should == 0
   end
 

core/array/clone_spec.rb

@@ -12,8 +12,8 @@
     aa = a.clone
     bb = b.clone
 
-    aa.frozen?.should == true
-    bb.frozen?.should == false
+    aa.should.frozen?
+    bb.should_not.frozen?
   end
 
   it "copies singleton methods" do

core/array/empty_spec.rb

@@ -3,8 +3,8 @@
 
 describe "Array#empty?" do
   it "returns true if the array has no elements" do
-    [].empty?.should == true
-    [1].empty?.should == false
-    [1, 2].empty?.should == false
+    [].should.empty?
+    [1].should_not.empty?
+    [1, 2].should_not.empty?
   end
 end

core/array/frozen_spec.rb

@@ -4,13 +4,13 @@
 describe "Array#frozen?" do
   it "returns true if array is frozen" do
     a = [1, 2, 3]
-    a.frozen?.should == false
+    a.should_not.frozen?
     a.freeze
-    a.frozen?.should == true
+    a.should.frozen?
   end
 
   it "returns false for an array being sorted by #sort" do
     a = [1, 2, 3]
-    a.sort { |x,y| a.frozen?.should == false; x <=> y }
+    a.sort { |x,y| a.should_not.frozen?; x <=> y }
   end
 end

core/array/multiply_spec.rb

@@ -92,39 +92,39 @@ def obj.to_str() "2" end
     it "copies the taint status of the original array even if the passed count is 0" do
       ary = [1, 2, 3]
       ary.taint
-      (ary * 0).tainted?.should == true
+      (ary * 0).should.tainted?
     end
 
     it "copies the taint status of the original array even if the array is empty" do
       ary = []
       ary.taint
-      (ary * 3).tainted?.should == true
+      (ary * 3).should.tainted?
     end
 
     it "copies the taint status of the original array if the passed count is not 0" do
       ary = [1, 2, 3]
       ary.taint
-      (ary * 1).tainted?.should == true
-      (ary * 2).tainted?.should == true
+      (ary * 1).should.tainted?
+      (ary * 2).should.tainted?
     end
 
     it "copies the untrusted status of the original array even if the passed count is 0" do
       ary = [1, 2, 3]
       ary.untrust
-      (ary * 0).untrusted?.should == true
+      (ary * 0).should.untrusted?
     end
 
     it "copies the untrusted status of the original array even if the array is empty" do
       ary = []
       ary.untrust
-      (ary * 3).untrusted?.should == true
+      (ary * 3).should.untrusted?
     end
 
     it "copies the untrusted status of the original array if the passed count is not 0" do
       ary = [1, 2, 3]
       ary.untrust
-      (ary * 1).untrusted?.should == true
-      (ary * 2).untrusted?.should == true
+      (ary * 1).should.untrusted?
+      (ary * 2).should.untrusted?
     end
   end
 end

core/array/shared/clone.rb

@@ -26,8 +26,8 @@
       aa = a.send @method
       bb = b.send @method
 
-      aa.tainted?.should == true
-      bb.tainted?.should == false
+      aa.should.tainted?
+      bb.should_not.tainted?
     end
 
     it "copies untrusted status from the original" do
@@ -37,8 +37,8 @@
       aa = a.send @method
       bb = b.send @method
 
-      aa.untrusted?.should == true
-      bb.untrusted?.should == false
+      aa.should.untrusted?
+      bb.should_not.untrusted?
     end
   end
 end

core/array/sort_spec.rb

@@ -58,9 +58,9 @@
     b = ArraySpecs::MockForCompared.new
     c = ArraySpecs::MockForCompared.new
 
-    ArraySpecs::MockForCompared.compared?.should == false
+    ArraySpecs::MockForCompared.should_not.compared?
     [a, b, c].sort.should == [c, b, a]
-    ArraySpecs::MockForCompared.compared?.should == true
+    ArraySpecs::MockForCompared.should.compared?
   end
 
   it "does not deal with exceptions raised by unimplemented or incorrect #<=>" do
@@ -104,7 +104,7 @@
 
   it "does not freezes self during being sorted" do
     a = [1, 2, 3]
-    a.sort { |x,y| a.frozen?.should == false; x <=> y }
+    a.sort { |x,y| a.should_not.frozen?; x <=> y }
   end
 
   it "returns the specified value when it would break in the given block" do
@@ -207,9 +207,9 @@ class Bignum
     b = ArraySpecs::MockForCompared.new
     c = ArraySpecs::MockForCompared.new
 
-    ArraySpecs::MockForCompared.compared?.should == false
+    ArraySpecs::MockForCompared.should_not.compared?
     [a, b, c].sort!.should == [c, b, a]
-    ArraySpecs::MockForCompared.compared?.should == true
+    ArraySpecs::MockForCompared.should.compared?
   end
 
   it "does not call #<=> on contained objects when invoked with a block" do

core/array/uniq_spec.rb

@@ -87,8 +87,8 @@ def obj.eql?(o)
       end
 
       a.uniq.should == a
-      a[0].tainted?.should == true
-      a[1].tainted?.should == true
+      a[0].should.tainted?
+      a[1].should.tainted?
 
       a = Array.new(2) do
         obj = mock('0')
@@ -106,8 +106,8 @@ def obj.eql?(o)
       end
 
       a.uniq.size.should == 1
-      a[0].tainted?.should == true
-      a[1].tainted?.should == true
+      a[0].should.tainted?
+      a[1].should.tainted?
     end
   end
 

core/class/allocate_spec.rb

@@ -30,7 +30,7 @@ def initialized?
       end
     end
 
-    klass.allocate.initialized?.should == false
+    klass.allocate.should_not.initialized?
   end
 
   it "raises TypeError for #superclass" do

core/class/new_spec.rb

@@ -126,7 +126,7 @@ def initialized?
       end
     end
 
-    klass.new.initialized?.should == true
+    klass.new.should.initialized?
     klass.new(1, 2, 3).args.should == [1, 2, 3]
   end
 

core/complex/finite_spec.rb

@@ -2,31 +2,31 @@
 
 describe "Complex#finite?" do
   it "returns true if magnitude is finite" do
-    (1+1i).finite?.should == true
+    (1+1i).should.finite?
   end
 
   it "returns false for positive infinity" do
     value = Complex(Float::INFINITY, 42)
-    value.finite?.should == false
+    value.should_not.finite?
   end
 
   it "returns false for positive complex with infinite imaginary" do
     value = Complex(1, Float::INFINITY)
-    value.finite?.should == false
+    value.should_not.finite?
   end
 
   it "returns false for negative infinity" do
     value = -Complex(Float::INFINITY, 42)
-    value.finite?.should == false
+    value.should_not.finite?
   end
 
   it "returns false for negative complex with infinite imaginary" do
     value = -Complex(1, Float::INFINITY)
-    value.finite?.should == false
+    value.should_not.finite?
   end
 
   it "returns false for NaN" do
     value = Complex(Float::NAN, Float::NAN)
-    value.finite?.should == false
+    value.should_not.finite?
   end
 end

core/dir/glob_spec.rb

@@ -119,7 +119,7 @@
   end
 
   it "handles infinite directory wildcards" do
-    Dir.glob('**/**/**').empty?.should == false
+    Dir.glob('**/**/**').should_not.empty?
   end
 
   it "handles simple filename patterns" do

core/dir/home_spec.rb

@@ -17,7 +17,7 @@
     end
 
     it "returns a non-frozen string" do
-      Dir.home.frozen?.should == false
+      Dir.home.should_not.frozen?
     end
   end
 
@@ -35,7 +35,7 @@
     end
 
     it "returns a non-frozen string" do
-      Dir.home(ENV['USER']).frozen?.should == false
+      Dir.home(ENV['USER']).should_not.frozen?
     end
   end
 

core/dir/shared/open.rb

@@ -66,7 +66,7 @@
       Dir.send(@method, DirSpecs.mock_dir) do |dir|
         io = IO.for_fd(dir.fileno)
         io.autoclose = false
-        io.close_on_exec?.should == true
+        io.should.close_on_exec?
       end
     end
   end

core/enumerable/all_spec.rb

@@ -10,13 +10,13 @@
   end
 
   it "always returns true on empty enumeration" do
-    @empty.all?.should == true
+    @empty.should.all?
     @empty.all? { nil }.should == true
 
-    [].all?.should == true
+    [].should.all?
     [].all? { false }.should == true
 
-    {}.all?.should == true
+    {}.should.all?
     {}.all? { nil }.should == true
   end
 
@@ -38,24 +38,24 @@
 
   describe "with no block" do
     it "returns true if no elements are false or nil" do
-      @enum.all?.should == true
-      @enum1.all?.should == true
-      @enum2.all?.should == false
+      @enum.should.all?
+      @enum1.should.all?
+      @enum2.should_not.all?
 
-      EnumerableSpecs::Numerous.new('a','b','c').all?.should == true
-      EnumerableSpecs::Numerous.new(0, "x", true).all?.should == true
+      EnumerableSpecs::Numerous.new('a','b','c').should.all?
+      EnumerableSpecs::Numerous.new(0, "x", true).should.all?
     end
 
     it "returns false if there are false or nil elements" do
-      EnumerableSpecs::Numerous.new(false).all?.should == false
-      EnumerableSpecs::Numerous.new(false, false).all?.should == false
+      EnumerableSpecs::Numerous.new(false).should_not.all?
+      EnumerableSpecs::Numerous.new(false, false).should_not.all?
 
-      EnumerableSpecs::Numerous.new(nil).all?.should == false
-      EnumerableSpecs::Numerous.new(nil, nil).all?.should == false
+      EnumerableSpecs::Numerous.new(nil).should_not.all?
+      EnumerableSpecs::Numerous.new(nil, nil).should_not.all?
 
-      EnumerableSpecs::Numerous.new(1, nil, 2).all?.should == false
-      EnumerableSpecs::Numerous.new(0, "x", false, true).all?.should == false
-      @enum2.all?.should == false
+      EnumerableSpecs::Numerous.new(1, nil, 2).should_not.all?
+      EnumerableSpecs::Numerous.new(0, "x", false, true).should_not.all?
+      @enum2.should_not.all?
     end
 
     it "gathers whole arrays as elements when each yields multiple" do