reek 1.3.8 → 1.4.0

data/spec/reek/smells/smell_detector_shared.rb

@@ -10,32 +10,32 @@ shared_examples_for 'SmellDetector' do
       allow(@ctx).to receive(:config_for).and_return({})
     end
     it 'when false' do
-      @ctx.should_receive(:matches?).at_least(:once).and_return(false)
-      @detector.exception?(@ctx).should == false
+      expect(@ctx).to receive(:matches?).at_least(:once).and_return(false)
+      expect(@detector.exception?(@ctx)).to eq(false)
     end
 
     it 'when true' do
-      @ctx.should_receive(:matches?).at_least(:once).and_return(true)
-      @detector.exception?(@ctx).should == true
+      expect(@ctx).to receive(:matches?).at_least(:once).and_return(true)
+      expect(@detector.exception?(@ctx)).to eq(true)
     end
   end
 
   context 'configuration' do
     it 'becomes disabled when disabled' do
-      @detector.configure_with({SmellConfiguration::ENABLED_KEY => false})
-      @detector.should_not be_enabled
+      @detector.configure_with(SmellConfiguration::ENABLED_KEY => false)
+      expect(@detector).not_to be_enabled
     end
   end
 end
 
 shared_examples_for 'common fields set correctly' do
   it 'reports the source' do
-    @warning.source.should == @source_name
+    expect(@warning.source).to eq(@source_name)
   end
   it 'reports the class' do
-    @warning.smell_class.should == @detector.class::SMELL_CLASS
+    expect(@warning.smell_class).to eq(@detector.class::SMELL_CLASS)
   end
   it 'reports the subclass' do
-    @warning.subclass.should == @detector.class::SMELL_SUBCLASS
+    expect(@warning.subclass).to eq(@detector.class::SMELL_SUBCLASS)
   end
 end

data/spec/reek/smells/too_many_instance_variables_spec.rb

@@ -17,18 +17,18 @@ describe TooManyInstanceVariables do
 
   context 'counting instance variables' do
     it 'should not report 9 ivars' do
-      '# clean class for testing purposes
-class Empty;def ivars() @aa=@ab=@ac=@ad=@ae=@af=@ag=@ah=@ai=4; end;end'.should_not reek
+      expect('# clean class for testing purposes
+class Empty;def ivars() @aa=@ab=@ac=@ad=@ae=@af=@ag=@ah=@ai=4; end;end').not_to reek
     end
 
     it 'counts each ivar only once' do
-      '# clean class for testing purposes
-class Empty;def ivars() @aa=@ab=@ac=@ad=@ae=@af=@ag=@ah=@ai=4;@aa=3; end;end'.should_not reek
+      expect('# clean class for testing purposes
+class Empty;def ivars() @aa=@ab=@ac=@ad=@ae=@af=@ag=@ah=@ai=4;@aa=3; end;end').not_to reek
     end
 
     it 'should report 10 ivars' do
-      '# smelly class for testing purposes
-class Empty;def ivars() @aa=@ab=@ac=@ad=@ae=@af=@ag=@ah=@ai=@aj=4; end;end'.should reek_only_of(:TooManyInstanceVariables)
+      expect('# smelly class for testing purposes
+class Empty;def ivars() @aa=@ab=@ac=@ad=@ae=@af=@ag=@ah=@ai=@aj=4; end;end').to reek_only_of(:TooManyInstanceVariables)
     end
 
     it 'should not report 10 ivars in 2 extensions' do
@@ -38,7 +38,7 @@ class Full;def ivars_a() @aa=@ab=@ac=@ad=@ae; end;end
 # clean class for testing purposes
 class Full;def ivars_b() @af=@ag=@ah=@ai=@aj; end;end
 EOS
-      src.should_not reek
+      expect(src).not_to reek
     end
   end
 
@@ -53,10 +53,10 @@ end
 EOS
     ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
     @warning = @detector.examine_context(ctx)[0]
-    @warning.source.should == @source_name
-    @warning.smell_class.should == 'LargeClass'
-    @warning.subclass.should == TooManyInstanceVariables::SMELL_SUBCLASS
-    @warning.smell[TooManyInstanceVariables::IVAR_COUNT_KEY].should == 10
-    @warning.lines.should == [2]
+    expect(@warning.source).to eq(@source_name)
+    expect(@warning.smell_class).to eq('LargeClass')
+    expect(@warning.subclass).to eq(TooManyInstanceVariables::SMELL_SUBCLASS)
+    expect(@warning.smell[TooManyInstanceVariables::IVAR_COUNT_KEY]).to eq(10)
+    expect(@warning.lines).to eq([2])
   end
 end

data/spec/reek/smells/too_many_methods_spec.rb

@@ -29,7 +29,7 @@ class Full
 end
 EOS
       ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
-      @detector.examine_context(ctx).should be_empty
+      expect(@detector.examine_context(ctx)).to be_empty
     end
 
     it 'should report 26 methods' do
@@ -45,9 +45,9 @@ end
 EOS
       ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
       smells = @detector.examine_context(ctx)
-      smells.length.should == 1
-      smells[0].subclass.should == TooManyMethods::SMELL_SUBCLASS
-      smells[0].smell[TooManyMethods::METHOD_COUNT_KEY].should == 26
+      expect(smells.length).to eq(1)
+      expect(smells[0].subclass).to eq(TooManyMethods::SMELL_SUBCLASS)
+      expect(smells[0].smell[TooManyMethods::METHOD_COUNT_KEY]).to eq(26)
     end
   end
 
@@ -64,7 +64,7 @@ class Full
 end
 EOS
       ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
-      @detector.examine_context(ctx).should be_empty
+      expect(@detector.examine_context(ctx)).to be_empty
     end
   end
 
@@ -81,10 +81,10 @@ end
 EOS
     ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
     @warning = @detector.examine_context(ctx)[0]
-    @warning.source.should == @source_name
-    @warning.smell_class.should == 'LargeClass'
-    @warning.subclass.should == TooManyMethods::SMELL_SUBCLASS
-    @warning.smell[TooManyMethods::METHOD_COUNT_KEY].should == 26
-    @warning.lines.should == [1]
+    expect(@warning.source).to eq(@source_name)
+    expect(@warning.smell_class).to eq('LargeClass')
+    expect(@warning.subclass).to eq(TooManyMethods::SMELL_SUBCLASS)
+    expect(@warning.smell[TooManyMethods::METHOD_COUNT_KEY]).to eq(26)
+    expect(@warning.lines).to eq([1])
   end
 end

data/spec/reek/smells/too_many_statements_spec.rb

@@ -22,17 +22,17 @@ end
 describe TooManyStatements do
   it 'should not report short methods' do
     src = 'def short(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;end'
-    src.should_not smell_of(TooManyStatements)
+    expect(src).not_to smell_of(TooManyStatements)
   end
 
   it 'should report long methods' do
     src = 'def long() alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;@fry = 6;end'
-    src.should reek_only_of(:TooManyStatements, /6 statements/)
+    expect(src).to reek_only_of(:TooManyStatements, /6 statements/)
   end
 
   it 'should not report initialize' do
     src = 'def initialize(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;@fry = 6;end'
-    src.should_not smell_of(TooManyStatements)
+    expect(src).not_to smell_of(TooManyStatements)
   end
 
   it 'should only report a long method once' do
@@ -54,7 +54,7 @@ def standard_entries(rbconfig)
   end
 end
 EOS
-    src.should reek_only_of(:TooManyStatements)
+    expect(src).to reek_only_of(:TooManyStatements)
   end
 
   it 'should report long inner block' do
@@ -71,166 +71,166 @@ def long()
   end
 end
 EOS
-    src.should reek_only_of(:TooManyStatements)
+    expect(src).to reek_only_of(:TooManyStatements)
   end
 end
 
 describe TooManyStatements do
   it 'counts 1 assignment' do
     method = process_method('def one() val = 4; end')
-    method.num_statements.should == 1
+    expect(method.num_statements).to eq(1)
   end
 
   it 'counts 3 assignments' do
     method = process_method('def one() val = 4; val = 4; val = 4; end')
-    method.num_statements.should == 3
+    expect(method.num_statements).to eq(3)
   end
 
   it 'counts 1 attr assignment' do
     method = process_method('def one() val[0] = 4; end')
-    method.num_statements.should == 1
+    expect(method.num_statements).to eq(1)
   end
 
   it 'counts 1 increment assignment' do
     method = process_method('def one() val += 4; end')
-    method.num_statements.should == 1
+    expect(method.num_statements).to eq(1)
   end
 
   it 'counts 1 increment attr assignment' do
     method = process_method('def one() val[0] += 4; end')
-    method.num_statements.should == 1
+    expect(method.num_statements).to eq(1)
   end
 
   it 'counts 1 nested assignment' do
     method = process_method('def one() val = fred = 4; end')
-    method.num_statements.should == 1
+    expect(method.num_statements).to eq(1)
   end
 
   it 'counts returns' do
     method = process_method('def one() val = 4; true; end')
-    method.num_statements.should == 2
+    expect(method.num_statements).to eq(2)
   end
 
   it 'counts nil returns' do
     method = process_method('def one() val = 4; nil; end')
-    method.num_statements.should == 2
+    expect(method.num_statements).to eq(2)
   end
 end
 
 describe TooManyStatements, 'does not count control statements' do
   it 'counts 1 statement in a conditional expression' do
     method = process_method('def one() if val == 4; callee(); end; end')
-    method.num_statements.should == 1
+    expect(method.num_statements).to eq(1)
   end
 
   it 'counts 3 statements in a conditional expression' do
     method = process_method('def one() if val == 4; callee(); callee(); callee(); end; end')
-    method.num_statements.should == 3
+    expect(method.num_statements).to eq(3)
   end
 
   it 'counts 1 statements in an else' do
     method = process_method('def one() if val == 4; callee(); else; callee(); end; end')
-    method.num_statements.should == 2
+    expect(method.num_statements).to eq(2)
   end
 
   it 'counts 3 statements in an else' do
     method = process_method('def one() if val == 4; callee(); callee(); callee(); else; callee(); callee(); callee(); end; end')
-    method.num_statements.should == 6
+    expect(method.num_statements).to eq(6)
   end
 
   it 'does not count empty conditional expression' do
     method = process_method('def one() if val == 4; ; end; end')
-    method.num_statements.should == 0
+    expect(method.num_statements).to eq(0)
   end
 
   it 'does not count empty else' do
     method = process_method('def one() if val == 4; ; else; ; end; end')
-    method.num_statements.should == 0
+    expect(method.num_statements).to eq(0)
   end
 
   it 'counts 1 statement in a while loop' do
     method = process_method('def one() while val < 4; callee(); end; end')
-    method.num_statements.should == 1
+    expect(method.num_statements).to eq(1)
   end
 
   it 'counts 3 statements in a while loop' do
     method = process_method('def one() while val < 4; callee(); callee(); callee(); end; end')
-    method.num_statements.should == 3
+    expect(method.num_statements).to eq(3)
   end
 
   it 'counts 1 statement in a until loop' do
     method = process_method('def one() until val < 4; callee(); end; end')
-    method.num_statements.should == 1
+    expect(method.num_statements).to eq(1)
   end
 
   it 'counts 3 statements in a until loop' do
     method = process_method('def one() until val < 4; callee(); callee(); callee(); end; end')
-    method.num_statements.should == 3
+    expect(method.num_statements).to eq(3)
   end
 
   it 'counts 1 statement in a for loop' do
     method = process_method('def one() for i in 0..4; callee(); end; end')
-    method.num_statements.should == 1
+    expect(method.num_statements).to eq(1)
   end
 
   it 'counts 3 statements in a for loop' do
     method = process_method('def one() for i in 0..4; callee(); callee(); callee(); end; end')
-    method.num_statements.should == 3
+    expect(method.num_statements).to eq(3)
   end
 
   it 'counts 1 statement in a rescue' do
     method = process_method('def one() begin; callee(); rescue; callee(); end; end')
-    method.num_statements.should == 2
+    expect(method.num_statements).to eq(2)
   end
 
   it 'counts 3 statements in a rescue' do
     method = process_method('def one() begin; callee(); callee(); callee(); rescue; callee(); callee(); callee(); end; end')
-    method.num_statements.should == 6
+    expect(method.num_statements).to eq(6)
   end
 
   it 'counts 1 statement in a when' do
     method = process_method('def one() case fred; when "hi"; callee(); end; end')
-    method.num_statements.should == 1
+    expect(method.num_statements).to eq(1)
   end
 
   it 'counts 3 statements in a when' do
     method = process_method('def one() case fred; when "hi"; callee(); callee(); when "lo"; callee(); end; end')
-    method.num_statements.should == 3
+    expect(method.num_statements).to eq(3)
   end
 
   it 'counts 1 statement in a case else' do
     method = process_method('def one() case fred; when "hi"; callee(); else; callee(); end; end')
-    method.num_statements.should == 2
+    expect(method.num_statements).to eq(2)
   end
 
   it 'counts 3 statements in a case else' do
     method = process_method('def one() case fred; when "hi"; callee(); callee(); callee(); else; callee(); callee(); callee(); end; end')
-    method.num_statements.should == 6
+    expect(method.num_statements).to eq(6)
   end
 
   it 'does not count empty case' do
     method = process_method('def one() case fred; when "hi"; ; when "lo"; ; end; end')
-    method.num_statements.should == 0
+    expect(method.num_statements).to eq(0)
   end
 
   it 'does not count empty case else' do
     method = process_method('def one() case fred; when "hi"; ; else; ; end; end')
-    method.num_statements.should == 0
+    expect(method.num_statements).to eq(0)
   end
 
   it 'counts 2 statement in an iterator' do
     method = process_method('def one() fred.each do; callee(); end; end')
-    method.num_statements.should == 2
+    expect(method.num_statements).to eq(2)
   end
 
   it 'counts 4 statements in an iterator' do
     method = process_method('def one() fred.each do; callee(); callee(); callee(); end; end')
-    method.num_statements.should == 4
+    expect(method.num_statements).to eq(4)
   end
 
   it 'counts 1 statement in a singleton method' do
     method = process_singleton_method('def self.foo; callee(); end')
-    method.num_statements.should == 1
+    expect(method.num_statements).to eq(1)
   end
 end
 
@@ -245,18 +245,18 @@ describe TooManyStatements do
     before :each do
       @num_statements = 30
       ctx = double('method_context').as_null_object
-      ctx.should_receive(:num_statements).and_return(@num_statements)
-      ctx.should_receive(:config_for).with(TooManyStatements).and_return({})
+      expect(ctx).to receive(:num_statements).and_return(@num_statements)
+      expect(ctx).to receive(:config_for).with(TooManyStatements).and_return({})
       @smells = @detector.examine_context(ctx)
     end
     it 'reports only 1 smell' do
-      @smells.length.should == 1
+      expect(@smells.length).to eq(1)
     end
     it 'reports the number of statements' do
-      @smells[0].smell[TooManyStatements::STATEMENT_COUNT_KEY].should == @num_statements
+      expect(@smells[0].smell[TooManyStatements::STATEMENT_COUNT_KEY]).to eq(@num_statements)
     end
     it 'reports the correct subclass' do
-      @smells[0].subclass.should == TooManyStatements::SMELL_SUBCLASS
+      expect(@smells[0].subclass).to eq(TooManyStatements::SMELL_SUBCLASS)
     end
   end
 end

data/spec/reek/smells/uncommunicative_method_name_spec.rb

@@ -17,7 +17,7 @@ describe UncommunicativeMethodName do
 
   ['help', '+', '-', '/', '*'].each do |method_name|
     it "accepts the method name '#{method_name}'" do
-      "def #{method_name}(fred) basics(17) end".should_not smell_of(UncommunicativeMethodName)
+      expect("def #{method_name}(fred) basics(17) end").not_to smell_of(UncommunicativeMethodName)
     end
   end
 
@@ -33,9 +33,9 @@ describe UncommunicativeMethodName do
       it_should_behave_like 'common fields set correctly'
 
       it 'reports the correct values' do
-        @warning.smell[UncommunicativeMethodName::METHOD_NAME_KEY].should == method_name
-        @warning.lines.should == [1]
-        @warning.context.should == method_name
+        expect(@warning.smell[UncommunicativeMethodName::METHOD_NAME_KEY]).to eq(method_name)
+        expect(@warning.lines).to eq([1])
+        expect(@warning.context).to eq(method_name)
       end
     end
   end

data/spec/reek/smells/uncommunicative_module_name_spec.rb

@@ -17,26 +17,26 @@ describe UncommunicativeModuleName do
 
   ['class', 'module'].each do |type|
     it 'does not report one-word name' do
-      "#{type} Helper; end".should_not reek_of(:UncommunicativeModuleName)
+      expect("#{type} Helper; end").not_to reek_of(:UncommunicativeModuleName)
     end
     it 'reports one-letter name' do
-      "#{type} X; end".should reek_of(:UncommunicativeModuleName, /X/)
+      expect("#{type} X; end").to reek_of(:UncommunicativeModuleName, /X/)
     end
     it 'reports name of the form "x2"' do
-      "#{type} X2; end".should reek_of(:UncommunicativeModuleName, /X2/)
+      expect("#{type} X2; end").to reek_of(:UncommunicativeModuleName, /X2/)
     end
     it 'reports long name ending in a number' do
-      "#{type} Printer2; end".should reek_of(:UncommunicativeModuleName, /Printer2/)
+      expect("#{type} Printer2; end").to reek_of(:UncommunicativeModuleName, /Printer2/)
     end
     it 'reports a bad scoped name' do
       src = "#{type} Foo::X; end"
       ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
       smells = @detector.examine_context(ctx)
-      smells.length.should == 1
-      smells[0].smell_class.should == UncommunicativeModuleName::SMELL_CLASS
-      smells[0].subclass.should == UncommunicativeModuleName::SMELL_SUBCLASS
-      smells[0].smell[UncommunicativeModuleName::MODULE_NAME_KEY].should == 'X'
-      smells[0].context.should match(/#{smells[0].smell[UncommunicativeModuleName::MODULE_NAME_KEY]}/)
+      expect(smells.length).to eq(1)
+      expect(smells[0].smell_class).to eq(UncommunicativeModuleName::SMELL_CLASS)
+      expect(smells[0].subclass).to eq(UncommunicativeModuleName::SMELL_SUBCLASS)
+      expect(smells[0].smell[UncommunicativeModuleName::MODULE_NAME_KEY]).to eq('X')
+      expect(smells[0].context).to match(/#{smells[0].smell[UncommunicativeModuleName::MODULE_NAME_KEY]}/)
     end
   end
 
@@ -44,7 +44,7 @@ describe UncommunicativeModuleName do
     it 'accepts Inline::C' do
       src = 'module Inline::C; end'
       ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
-      @detector.examine_context(ctx).should be_empty
+      expect(@detector.examine_context(ctx)).to be_empty
     end
   end
 
@@ -59,8 +59,8 @@ describe UncommunicativeModuleName do
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the correct values' do
-      @warning.smell[UncommunicativeModuleName::MODULE_NAME_KEY].should == 'Printer2'
-      @warning.lines.should == [1]
+      expect(@warning.smell[UncommunicativeModuleName::MODULE_NAME_KEY]).to eq('Printer2')
+      expect(@warning.lines).to eq([1])
     end
   end
 end