reek 1.6.6 → 2.0.0

data/spec/reek/smells/irresponsible_module_spec.rb

@@ -48,7 +48,7 @@ describe IrresponsibleModule do
       #
       class #{@bad_module_name}; end
     EOS
-    expect(src).to smell_of IrresponsibleModule
+    expect(src).to reek_of IrresponsibleModule
   end
 
   it 'reports a class with a preceding comment with intermittent material' do

data/spec/reek/smells/long_parameter_list_spec.rb

@@ -8,17 +8,17 @@ include Reek::Smells
 describe LongParameterList do
   context 'for methods with few parameters' do
     it 'should report nothing for no parameters' do
-      expect('def simple; f(3);true; end').not_to smell_of(LongParameterList)
+      expect('def simple; f(3);true; end').not_to reek_of(LongParameterList)
     end
     it 'should report nothing for 1 parameter' do
-      expect('def simple(yep) f(3);true end').not_to smell_of(LongParameterList)
+      expect('def simple(yep) f(3);true end').not_to reek_of(LongParameterList)
     end
     it 'should report nothing for 2 parameters' do
-      expect('def simple(yep,zero) f(3);true end').not_to smell_of(LongParameterList)
+      expect('def simple(yep,zero) f(3);true end').not_to reek_of(LongParameterList)
     end
     it 'should not count an optional block' do
       src = 'def simple(alpha, yep, zero, &opt) f(3); true end'
-      expect(src).not_to smell_of(LongParameterList)
+      expect(src).not_to reek_of(LongParameterList)
     end
     it 'should not report inner block with too many parameters' do
       src = '
@@ -26,20 +26,20 @@ describe LongParameterList do
           m[3]; rand(34); f.each { |arga, argb, argc, argd| true}
         end
       '
-      expect(src).not_to smell_of(LongParameterList)
+      expect(src).not_to reek_of(LongParameterList)
     end
 
     describe 'and default values' do
       it 'should report nothing for 1 parameter' do
-        expect('def simple(zero=nil) f(3);false end').not_to smell_of(LongParameterList)
+        expect('def simple(zero=nil) f(3);false end').not_to reek_of(LongParameterList)
       end
       it 'should report nothing for 2 parameters with 1 default' do
         source = 'def simple(yep, zero=nil) f(3); false end'
-        expect(source).not_to smell_of(LongParameterList)
+        expect(source).not_to reek_of(LongParameterList)
       end
       it 'should report nothing for 2 defaulted parameters' do
         source = 'def simple(yep=4, zero=nil) f(3); false end'
-        expect(source).not_to smell_of(LongParameterList)
+        expect(source).not_to reek_of(LongParameterList)
       end
     end
   end
@@ -47,21 +47,21 @@ describe LongParameterList do
   describe 'for methods with too many parameters' do
     it 'should report 4 parameters' do
       src = 'def simple(arga, argb, argc, argd) f(3);true end'
-      expect(src).to smell_of(LongParameterList, count: 4)
+      expect(src).to reek_of(LongParameterList, count: 4)
     end
     it 'should report 8 parameters' do
       src = 'def simple(arga, argb, argc, argd,arge, argf, argg, argh) f(3);true end'
-      expect(src).to smell_of(LongParameterList, count: 8)
+      expect(src).to reek_of(LongParameterList, count: 8)
     end
 
     describe 'and default values' do
       it 'should report 3 with 1 defaulted' do
         src = 'def simple(polly, queue, yep, zero=nil) f(3);false end'
-        expect(src).to smell_of(LongParameterList, count: 4)
+        expect(src).to reek_of(LongParameterList, count: 4)
       end
       it 'should report with 3 defaulted' do
         src = 'def simple(aarg, polly=2, yep=:truth, zero=nil) f(3);false end'
-        expect(src).to smell_of(LongParameterList, count: 4)
+        expect(src).to reek_of(LongParameterList, count: 4)
       end
     end
   end

data/spec/reek/smells/long_yield_list_spec.rb

@@ -18,19 +18,19 @@ describe LongYieldList do
   context 'yield' do
     it 'should not report yield with no parameters' do
       src = 'def simple(arga, argb, &blk) f(3);yield; end'
-      expect(src).not_to smell_of(LongYieldList)
+      expect(src).not_to reek_of(LongYieldList)
     end
     it 'should not report yield with few parameters' do
       src = 'def simple(arga, argb, &blk) f(3);yield a,b; end'
-      expect(src).not_to smell_of(LongYieldList)
+      expect(src).not_to reek_of(LongYieldList)
     end
     it 'should report yield with many parameters' do
       src = 'def simple(arga, argb, &blk) f(3);yield arga,argb,arga,argb; end'
-      expect(src).to smell_of(LongYieldList, count: 4)
+      expect(src).to reek_of(LongYieldList, count: 4)
     end
     it 'should not report yield of a long expression' do
       src = 'def simple(arga, argb, &blk) f(3);yield(if @dec then argb else 5+3 end); end'
-      expect(src).not_to smell_of(LongYieldList)
+      expect(src).not_to reek_of(LongYieldList)
     end
   end
 

data/spec/reek/smells/module_initialize_spec.rb

@@ -13,7 +13,7 @@ describe ModuleInitialize do
             def initialize; end
           end
         EOF
-        expect(src).to smell_of(ModuleInitialize)
+        expect(src).to reek_of(ModuleInitialize)
       end
     end
 
@@ -26,7 +26,7 @@ describe ModuleInitialize do
             end
           end
         EOF
-        expect(src).not_to smell_of(ModuleInitialize)
+        expect(src).not_to reek_of(ModuleInitialize)
       end
     end
 
@@ -39,7 +39,7 @@ describe ModuleInitialize do
             end
           end
         EOF
-        expect(src).not_to smell_of(ModuleInitialize)
+        expect(src).not_to reek_of(ModuleInitialize)
       end
     end
   end

data/spec/reek/smells/nested_iterators_spec.rb

@@ -8,39 +8,39 @@ describe NestedIterators do
   context 'with no iterators' do
     it 'reports no smells' do
       src = 'def fred() nothing = true; end'
-      expect(src).not_to smell_of(NestedIterators)
+      expect(src).not_to reek_of(NestedIterators)
     end
   end
 
   context 'with one iterator' do
     it 'reports no smells' do
       src = 'def fred() nothing.each {|item| item}; end'
-      expect(src).not_to smell_of(NestedIterators)
+      expect(src).not_to reek_of(NestedIterators)
     end
   end
 
   it 'should report nested iterators in a method' do
     src = 'def bad(fred) @fred.each {|item| item.each {|ting| ting.ting} } end'
-    expect(src).to smell_of(NestedIterators)
+    expect(src).to reek_of(NestedIterators)
   end
 
   it 'should not report method with successive iterators' do
-    src = <<EOS
-def bad(fred)
-  @fred.each {|item| item.each }
-  @jim.each {|ting| ting.each }
-end
-EOS
-    expect(src).not_to smell_of(NestedIterators)
+    src = <<-EOS
+      def bad(fred)
+        @fred.each {|item| item.each }
+        @jim.each {|ting| ting.each }
+      end
+    EOS
+    expect(src).not_to reek_of(NestedIterators)
   end
 
   it 'should not report method with chained iterators' do
-    src = <<EOS
-def chained
-  @sig.keys.sort_by { |xray| xray.to_s }.each { |min| md5 << min.to_s }
-end
-EOS
-    expect(src).not_to smell_of(NestedIterators)
+    src = <<-EOS
+      def chained
+        @sig.keys.sort_by { |xray| xray.to_s }.each { |min| md5 << min.to_s }
+      end
+    EOS
+    expect(src).not_to reek_of(NestedIterators)
   end
 
   it 'detects an iterator with an empty block' do
@@ -49,17 +49,17 @@ EOS
         bar { baz { } }
       end
     EOS
-    expect(src).to smell_of(NestedIterators, {})
+    expect(src).to reek_of(NestedIterators)
   end
 
   it 'should report nested iterators only once per method' do
-    src = <<EOS
-def bad(fred)
-  @fred.each {|item| item.each {|part| @joe.send} }
-  @jim.each {|ting| ting.each {|piece| @hal.send} }
-end
-EOS
-    expect(src).to smell_of(NestedIterators, {})
+    src = <<-EOS
+      def bad(fred)
+        @fred.each {|item| item.each {|part| @joe.send} }
+        @jim.each {|ting| ting.each {|piece| @hal.send} }
+      end
+    EOS
+    expect(src).to reek_of(NestedIterators)
   end
 
   it 'reports nested iterators only once per method even if levels are different' do
@@ -69,7 +69,7 @@ EOS
         @jim.each {|ting| ting.each {|piece| piece.each {|atom| atom.foo } } }
       end
     EOS
-    expect(src).to smell_of(NestedIterators, {})
+    expect(src).to reek_of(NestedIterators)
   end
 
   it 'reports nesting inside iterator arguments' do
@@ -84,7 +84,7 @@ EOS
         ) { |qux| qux.quuz }
       end
     EOS
-    expect(src).to smell_of(NestedIterators, count: 2)
+    expect(src).to reek_of(NestedIterators, count: 2)
   end
 
   it 'reports the deepest level of nesting only' do
@@ -97,55 +97,68 @@ EOS
         }
       end
     EOS
-    expect(src).to smell_of(NestedIterators, count: 3)
+    expect(src).to reek_of(NestedIterators, count: 3)
   end
 
   context 'when the allowed nesting depth is 3' do
     before :each do
-      @config = { NestedIterators::MAX_ALLOWED_NESTING_KEY => 3 }
+      @config = { NestedIterators: { NestedIterators::MAX_ALLOWED_NESTING_KEY => 3 } }
     end
 
     it 'should not report nested iterators 2 levels deep' do
-      src = <<EOS
-def bad(fred)
-  @fred.each {|one| one.each {|two| two.two} }
-end
-EOS
-      expect(src).not_to smell_of(NestedIterators).with_config(@config)
+      src = <<-EOS
+        def bad(fred)
+          @fred.each {|one| one.each {|two| two.two} }
+        end
+      EOS
+
+      with_test_config(@config) do
+        expect(src).not_to reek_of(NestedIterators)
+      end
     end
 
     it 'should not report nested iterators 3 levels deep' do
-      src = <<EOS
-def bad(fred)
-  @fred.each {|one| one.each {|two| two.each {|three| three.three} } }
-end
-EOS
-      expect(src).not_to smell_of(NestedIterators).with_config(@config)
+      src = <<-EOS
+        def bad(fred)
+          @fred.each {|one| one.each {|two| two.each {|three| three.three} } }
+        end
+      EOS
+
+      with_test_config(@config) do
+        expect(src).not_to reek_of(NestedIterators)
+      end
     end
 
     it 'should report nested iterators 4 levels deep' do
-      src = <<EOS
-def bad(fred)
-  @fred.each {|one| one.each {|two| two.each {|three| three.each {|four| four.four} } } }
-end
-EOS
-      expect(src).to smell_of(NestedIterators).with_config(@config)
+      src = <<-EOS
+        def bad(fred)
+          @fred.each {|one| one.each {|two| two.each {|three| three.each {|four| four.four} } } }
+        end
+      EOS
+
+      with_test_config(@config) do
+        expect(src).to reek_of(NestedIterators)
+      end
     end
   end
 
   context 'when ignoring iterators' do
     before :each do
-      @config = { NestedIterators::IGNORE_ITERATORS_KEY => ['ignore_me'] }
+      @config = { NestedIterators: { NestedIterators::IGNORE_ITERATORS_KEY => ['ignore_me'] } }
     end
 
     it 'should not report nesting the ignored iterator inside another' do
       src = 'def bad(fred) @fred.each {|item| item.ignore_me {|ting| ting.ting} } end'
-      expect(src).not_to smell_of(NestedIterators).with_config(@config)
+      with_test_config(@config) do
+        expect(src).not_to reek_of(NestedIterators)
+      end
     end
 
     it 'should not report nesting inside the ignored iterator' do
       src = 'def bad(fred) @fred.ignore_me {|item| item.each {|ting| ting.ting} } end'
-      expect(src).not_to smell_of(NestedIterators).with_config(@config)
+      with_test_config(@config) do
+        expect(src).not_to reek_of(NestedIterators)
+      end
     end
 
     it 'should report nested iterators inside the ignored iterator' do
@@ -154,7 +167,9 @@ EOS
           @fred.ignore_me {|item| item.each {|ting| ting.each {|other| other.other} } }
         end
       '
-      expect(src).to smell_of(NestedIterators, count: 2).with_config(@config)
+      with_test_config(@config) do
+        expect(src).to reek_of(NestedIterators, count: 2)
+      end
     end
 
     it 'should report nested iterators outside the ignored iterator' do
@@ -163,7 +178,9 @@ EOS
           @fred.each {|item| item.each {|ting| ting.ignore_me {|other| other.other} } }
         end
       '
-      expect(src).to smell_of(NestedIterators, count: 2).with_config(@config)
+      with_test_config(@config) do
+        expect(src).to reek_of(NestedIterators, count: 2)
+      end
     end
 
     it 'should report nested iterators with the ignored iterator between them' do
@@ -172,7 +189,9 @@ EOS
           @fred.each {|item| item.ignore_me {|ting| ting.ting {|other| other.other} } }
         end
       '
-      expect(src).to smell_of(NestedIterators, count: 2).with_config(@config)
+      with_test_config(@config) do
+        expect(src).to reek_of(NestedIterators, count: 2)
+      end
     end
   end
 end

data/spec/reek/smells/nil_check_spec.rb

@@ -20,7 +20,7 @@ describe NilCheck do
     end
 
     it 'reports nothing when scope includes no nil checks' do
-      expect('def no_nils; end').not_to smell_of(NilCheck)
+      expect('def no_nils; end').not_to reek_of(NilCheck)
     end
 
     it 'reports when scope uses multiple nil? methods' do
@@ -31,7 +31,7 @@ describe NilCheck do
         \"\".nil?
       end
       eos
-      expect(src).to smell_of(NilCheck, {}, {})
+      expect(src).to reek_of(NilCheck)
     end
 
     it 'reports twice when scope uses == nil and === nil' do
@@ -41,11 +41,11 @@ describe NilCheck do
         para === nil
       end
       eos
-      expect(src).to smell_of(NilCheck, {}, {})
+      expect(src).to reek_of(NilCheck)
     end
 
     it 'reports when scope uses nil ==' do
-      expect('def chk_eq_nil_rev(para); nil == para; end').to smell_of(NilCheck)
+      expect('def chk_eq_nil_rev(para); nil == para; end').to reek_of(NilCheck)
     end
 
     it 'reports when scope uses multiple case-clauses checking nil' do
@@ -61,7 +61,7 @@ describe NilCheck do
         end
       end
       eos
-      expect(src).to smell_of(NilCheck, {}, {})
+      expect(src).to reek_of(NilCheck)
     end
 
     it 'reports a when clause that checks nil and other values' do
@@ -72,7 +72,7 @@ describe NilCheck do
         end
       end
       eos
-      expect(src).to smell_of(NilCheck)
+      expect(src).to reek_of(NilCheck)
     end
   end
 end

data/spec/reek/smells/prima_donna_method_spec.rb

@@ -7,11 +7,11 @@ include Reek::Smells
 
 describe PrimaDonnaMethod do
   it 'should report nothing when method and bang counterpart exist' do
-    expect('class C; def m; end; def m!; end; end').not_to smell_of(PrimaDonnaMethod)
+    expect('class C; def m; end; def m!; end; end').not_to reek_of(PrimaDonnaMethod)
   end
 
   it 'should report PrimaDonnaMethod when only bang method exists' do
-    expect('class C; def m!; end; end').to smell_of(PrimaDonnaMethod)
+    expect('class C; def m!; end; end').to reek_of(PrimaDonnaMethod)
   end
 
   describe 'the right smell' do

data/spec/reek/smells/too_many_statements_spec.rb

@@ -22,12 +22,12 @@ 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'
-    expect(src).not_to smell_of(TooManyStatements)
+    expect(src).not_to reek_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'
-    expect(src).to reek_only_of(:TooManyStatements, /6 statements/)
+    expect(src).to reek_only_of(:TooManyStatements)
   end
 
   it 'should not report initialize' do
@@ -36,45 +36,45 @@ describe TooManyStatements do
         alf = f(1); @bet = 2; @cut = 3; @dit = 4; @emp = 5; @fry = 6
       end
     '
-    expect(src).not_to smell_of(TooManyStatements)
+    expect(src).not_to reek_of(TooManyStatements)
   end
 
   it 'should only report a long method once' do
-    src = <<EOS
-def standard_entries(rbconfig)
-  @abc = rbconfig
-  rubypath = File.join(@abc['bindir'], @abcf['ruby_install_name'] + cff['EXEEXT'])
-  major = yyy['MAJOR'].to_i
-  minor = zzz['MINOR'].to_i
-  teeny = ccc['TEENY'].to_i
-  version = ""
-  if c['rubylibdir']
-    @libruby         = "/lib/ruby"
-    @librubyver      = "/lib/ruby/"
-    @librubyverarch  = "/lib/ruby/"
-    @siteruby        = "lib/ruby/version/site_ruby"
-    @siterubyver     = siteruby
-    @siterubyverarch = "$siterubyver/['arch']}"
-  end
-end
-EOS
+    src = <<-EOS
+      def standard_entries(rbconfig)
+        @abc = rbconfig
+        rubypath = File.join(@abc['bindir'], @abcf['ruby_install_name'] + cff['EXEEXT'])
+        major = yyy['MAJOR'].to_i
+        minor = zzz['MINOR'].to_i
+        teeny = ccc['TEENY'].to_i
+        version = ""
+        if c['rubylibdir']
+          @libruby         = "/lib/ruby"
+          @librubyver      = "/lib/ruby/"
+          @librubyverarch  = "/lib/ruby/"
+          @siteruby        = "lib/ruby/version/site_ruby"
+          @siterubyver     = siteruby
+          @siterubyverarch = "$siterubyver/['arch']}"
+        end
+      end
+    EOS
     expect(src).to reek_only_of(:TooManyStatements)
   end
 
   it 'should report long inner block' do
-    src = <<EOS
-def long()
-  f(3)
-  self.each do |xyzero|
-    xyzero = 1
-    xyzero = 2
-    xyzero = 3
-    xyzero = 4
-    xyzero = 5
-    xyzero = 6
-  end
-end
-EOS
+    src = <<-EOS
+      def long()
+        f(3)
+        self.each do |xyzero|
+          xyzero = 1
+          xyzero = 2
+          xyzero = 3
+          xyzero = 4
+          xyzero = 5
+          xyzero = 6
+        end
+      end
+    EOS
     expect(src).to reek_only_of(:TooManyStatements)
   end
 end