reek 4.2.3 → 4.2.4

data/spec/reek/smells/data_clump_spec.rb

@@ -26,7 +26,7 @@ RSpec.shared_examples_for 'a data clump detector' do
         end
       EOS
       ctx = Reek::Context::ModuleContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      build(:smell_detector, smell_type: :DataClump).inspect(ctx)
+      build(:smell_detector, smell_type: :DataClump).sniff(ctx)
     end
 
     it 'records only the one smell' do
@@ -41,10 +41,6 @@ RSpec.shared_examples_for 'a data clump detector' do
       expect(smells[0].parameters[:count]).to eq(3)
     end
 
-    it 'reports all methods' do
-      expect(smells[0].parameters[:methods]).to eq([:first, :second, :third])
-    end
-
     it 'reports the declaration line numbers' do
       expect(smells[0].lines).to eq([2, 3, 4])
     end
@@ -56,6 +52,10 @@ RSpec.shared_examples_for 'a data clump detector' do
     it 'reports the context fq name' do
       expect(smells[0].context).to eq(module_name)
     end
+
+    it 'has the right message' do
+      expect(smells[0].message).to eq('takes parameters [pa, pb] to 3 methods')
+    end
   end
 
   it 'reports 3 swapped pairs' do

data/spec/reek/smells/duplicate_method_call_spec.rb

@@ -17,7 +17,7 @@ RSpec.describe Reek::Smells::DuplicateMethodCall do
         end
       EOS
       ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      smells = detector.inspect(ctx)
+      smells = detector.sniff(ctx)
       expect(smells.length).to eq(1)
       smells.first
     end

data/spec/reek/smells/feature_envy_spec.rb

@@ -235,10 +235,16 @@ RSpec.describe Reek::Smells::FeatureEnvy do
 
     it_should_behave_like 'common fields set correctly'
 
-    it 'reports the correct values' do
+    it 'reports the name' do
       expect(warning.parameters[:name]).to eq(receiver)
-      expect(warning.parameters[:count]).to eq(3)
+    end
+
+    it 'reports the lines' do
       expect(warning.lines).to eq([2, 4, 5])
     end
+
+    it 'has the right message' do
+      expect(warning.message).to eq('refers to other more than self (maybe move it to another class?)')
+    end
   end
 end

data/spec/reek/smells/irresponsible_module_spec.rb

@@ -6,12 +6,14 @@ require_relative 'smell_detector_shared'
 RSpec.describe Reek::Smells::IrresponsibleModule do
   it 'reports a class without a comment' do
     src = 'class BadClass; end'
-    expect(src).to reek_of :IrresponsibleModule, name: 'BadClass'
+    expect(src).to reek_of :IrresponsibleModule,
+                           lines: [1],
+                           message: 'has no descriptive comment'
   end
 
   it 'reports a module without a comment' do
     src = 'module BadClass; end'
-    expect(src).to reek_of :IrresponsibleModule, name: 'BadClass'
+    expect(src).to reek_of(:IrresponsibleModule, context: 'BadClass')
   end
 
   it 'does not report re-opened modules' do
@@ -39,7 +41,7 @@ RSpec.describe Reek::Smells::IrresponsibleModule do
       #
       class BadClass; end
     EOS
-    expect(src).to reek_of :IrresponsibleModule
+    expect(src).to reek_of(:IrresponsibleModule, context: 'BadClass')
   end
 
   it 'reports a class with a preceding comment with intermittent material' do
@@ -50,7 +52,7 @@ RSpec.describe Reek::Smells::IrresponsibleModule do
 
       class Bar; end
     EOS
-    expect(src).to reek_of(:IrresponsibleModule)
+    expect(src).to reek_of(:IrresponsibleModule, context: 'Bar')
   end
 
   it 'reports a class with a trailing comment' do
@@ -58,12 +60,12 @@ RSpec.describe Reek::Smells::IrresponsibleModule do
       class BadClass
       end # end BadClass
     EOS
-    expect(src).to reek_of(:IrresponsibleModule)
+    expect(src).to reek_of(:IrresponsibleModule, context: 'BadClass')
   end
 
   it 'reports a fully qualified class name correctly' do
     src = 'class Foo::Bar; end'
-    expect(src).to reek_of :IrresponsibleModule, name: 'Foo::Bar'
+    expect(src).to reek_of(:IrresponsibleModule, context: 'Foo::Bar')
   end
 
   it 'does not report modules used only as namespaces' do
@@ -102,7 +104,7 @@ RSpec.describe Reek::Smells::IrresponsibleModule do
         end
       end
     EOS
-    expect(src).to reek_of(:IrresponsibleModule)
+    expect(src).to reek_of(:IrresponsibleModule, context: 'Foo')
   end
 
   it 'reports modules that have both nested modules and singleton methods' do
@@ -115,7 +117,7 @@ RSpec.describe Reek::Smells::IrresponsibleModule do
         end
       end
     EOS
-    expect(src).to reek_of(:IrresponsibleModule)
+    expect(src).to reek_of(:IrresponsibleModule, context: 'Foo')
   end
 
   it 'reports modules that have both nested modules and methods on the singleton class' do
@@ -130,7 +132,7 @@ RSpec.describe Reek::Smells::IrresponsibleModule do
         end
       end
     EOS
-    expect(src).to reek_of(:IrresponsibleModule)
+    expect(src).to reek_of(:IrresponsibleModule, context: 'Foo')
   end
 
   it 'does not report namespace modules that have a nested class through assignment' do
@@ -149,7 +151,7 @@ RSpec.describe Reek::Smells::IrresponsibleModule do
     src = <<-EOS
       class Foo < Bar; end
     EOS
-    expect(src).to reek_of(:IrresponsibleModule)
+    expect(src).to reek_of(:IrresponsibleModule, context: 'Foo')
   end
 
   it 'reports classes defined through assignment' do
@@ -159,14 +161,14 @@ RSpec.describe Reek::Smells::IrresponsibleModule do
         Foo = Class.new Bar
       end
     EOS
-    expect(src).to reek_of(:IrresponsibleModule, name: 'Foo')
+    expect(src).to reek_of(:IrresponsibleModule, context: 'Qux::Foo')
   end
 
   it 'reports top level classes defined through assignment' do
     src = <<-EOS
       Foo = Class.new Bar
     EOS
-    expect(src).to reek_of(:IrresponsibleModule, name: 'Foo')
+    expect(src).to reek_of(:IrresponsibleModule, context: 'Foo')
   end
 
   it 'reports structs defined through assignment' do
@@ -176,14 +178,14 @@ RSpec.describe Reek::Smells::IrresponsibleModule do
         Foo = Struct.new(:x, :y)
       end
     EOS
-    expect(src).to reek_of(:IrresponsibleModule, name: 'Foo')
+    expect(src).to reek_of(:IrresponsibleModule, context: 'Qux::Foo')
   end
 
   it 'reports top level structs defined through assignment' do
     src = <<-EOS
       Foo = Struct.new(:x, :y)
     EOS
-    expect(src).to reek_of(:IrresponsibleModule, name: 'Foo')
+    expect(src).to reek_of(:IrresponsibleModule, context: 'Foo')
   end
 
   it 'does not report constants that are not classes' do

data/spec/reek/smells/long_parameter_list_spec.rb

@@ -87,7 +87,7 @@ RSpec.describe Reek::Smells::LongParameterList do
         end
       EOS
       ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      detector.inspect(ctx).first
+      detector.sniff(ctx).first
     end
 
     it_should_behave_like 'common fields set correctly'
@@ -99,5 +99,9 @@ RSpec.describe Reek::Smells::LongParameterList do
     it 'reports the line number of the method' do
       expect(warning.lines).to eq([1])
     end
+
+    it 'has the right message' do
+      expect(warning.message).to eq('has 4 parameters')
+    end
   end
 end

data/spec/reek/smells/long_yield_list_spec.rb

@@ -13,14 +13,17 @@ RSpec.describe Reek::Smells::LongYieldList do
       src = 'def simple(arga, argb, &blk) f(3);yield; end'
       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 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 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 reek_of(:LongYieldList)
@@ -33,10 +36,10 @@ RSpec.describe Reek::Smells::LongYieldList do
         def simple(arga, argb, &blk)
           f(3)
           yield(arga,argb,arga,argb)
-          end
+        end
       EOS
       ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      detector.inspect(ctx).first
+      detector.sniff(ctx).first
     end
 
     it_should_behave_like 'common fields set correctly'

data/spec/reek/smells/nested_iterators_spec.rb

@@ -69,7 +69,7 @@ RSpec.describe Reek::Smells::NestedIterators do
         ) { |qux| qux.quuz }
       end
     EOS
-    expect(src).to reek_of(:NestedIterators, count: 2)
+    expect(src).to reek_of(:NestedIterators, depth: 2)
   end
 
   it 'reports the deepest level of nesting only' do
@@ -82,8 +82,8 @@ RSpec.describe Reek::Smells::NestedIterators do
         }
       end
     EOS
-    expect(src).not_to reek_of(:NestedIterators, count: 2)
-    expect(src).to reek_of(:NestedIterators, count: 3)
+    expect(src).not_to reek_of(:NestedIterators, depth: 2)
+    expect(src).to reek_of(:NestedIterators, depth: 3)
   end
 
   it 'handles the case where super receives a block' do
@@ -110,7 +110,7 @@ RSpec.describe Reek::Smells::NestedIterators do
     expect(src).to reek_of(:NestedIterators)
   end
 
-  describe 'inspect / warnings' do
+  describe 'sniff / warnings' do
     let(:detector) { build(:smell_detector, smell_type: :NestedIterators) }
 
     it 'reports a sensible warning message' do
@@ -132,7 +132,7 @@ RSpec.describe Reek::Smells::NestedIterators do
           end
         end
       EOS
-      expect(source).to reek_of(:NestedIterators, name: 'foo', lines: [3])
+      expect(source).to reek_of(:NestedIterators, lines: [3])
     end
 
     it 'reports all lines on which nested iterators occur' do
@@ -143,7 +143,7 @@ RSpec.describe Reek::Smells::NestedIterators do
         end
       EOS
 
-      expect(source).to reek_of(:NestedIterators, name: 'bad', lines: [2, 3])
+      expect(source).to reek_of(:NestedIterators, lines: [2, 3])
     end
 
     it 'reports separete cases of nested iterators if levels are different' do
@@ -153,8 +153,8 @@ RSpec.describe Reek::Smells::NestedIterators do
           @jim.each {|ting| ting.each {|piece| piece.each {|atom| atom.foo } } }
         end
       EOS
-      expect(source).to reek_of(:NestedIterators, name: 'bad', lines: [2], count: 2)
-      expect(source).to reek_of(:NestedIterators, name: 'bad', lines: [3], count: 3)
+      expect(source).to reek_of(:NestedIterators, lines: [2], depth: 2)
+      expect(source).to reek_of(:NestedIterators, lines: [3], depth: 3)
     end
   end
 
@@ -193,6 +193,30 @@ RSpec.describe Reek::Smells::NestedIterators do
     end
   end
 
+  it 'reports nested iterators called via safe navigation' do
+    source = <<-EOS
+      def show_bottles(bars)
+        bars&.each do |bar|
+          bar&.each do |bottle|
+            puts bottle
+          end
+        end
+      end
+    EOS
+    expect(source).to reek_of(:NestedIterators)
+  end
+
+  it 'does not report unnested iterators called via safe navigation' do
+    source = <<-EOS
+      def show_bottles(bar)
+        bar&.each do |bottle|
+          puts bottle
+        end
+      end
+    EOS
+    expect(source).not_to reek_of(:NestedIterators)
+  end
+
   context 'when the allowed nesting depth is 3' do
     let(:config) do
       { Reek::Smells::NestedIterators::MAX_ALLOWED_NESTING_KEY => 3 }
@@ -250,7 +274,7 @@ RSpec.describe Reek::Smells::NestedIterators do
           @fred.ignore_me {|item| item.each {|ting| ting.each {|other| other.other} } }
         end
       '
-      expect(src).to reek_of(:NestedIterators, count: 2).with_config(config)
+      expect(src).to reek_of(:NestedIterators, depth: 2).with_config(config)
     end
 
     it 'should report nested iterators outside the ignored iterator' do
@@ -259,7 +283,7 @@ RSpec.describe Reek::Smells::NestedIterators do
           @fred.each {|item| item.each {|ting| ting.ignore_me {|other| other.other} } }
         end
       '
-      expect(src).to reek_of(:NestedIterators, count: 2).with_config(config)
+      expect(src).to reek_of(:NestedIterators, depth: 2).with_config(config)
     end
 
     it 'should report nested iterators with the ignored iterator between them' do
@@ -268,7 +292,7 @@ RSpec.describe Reek::Smells::NestedIterators do
           @fred.each {|item| item.ignore_me {|ting| ting.ting {|other| other.other} } }
         end
       '
-      expect(src).to reek_of(:NestedIterators, count: 2).with_config(config)
+      expect(src).to reek_of(:NestedIterators, depth: 2).with_config(config)
     end
   end
 end
@@ -288,13 +312,13 @@ RSpec.describe Reek::Smells::NestedIterators do
         end
       EOS
       ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      detector.inspect(ctx).first
+      detector.sniff(ctx).first
     end
 
     it_should_behave_like 'common fields set correctly'
 
     it 'reports correct values' do
-      expect(warning.parameters[:count]).to eq(2)
+      expect(warning.parameters[:depth]).to eq(2)
       expect(warning.lines).to eq([3])
     end
   end

data/spec/reek/smells/nil_check_spec.rb

@@ -4,73 +4,70 @@ require_lib 'reek/smells/nil_check'
 require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::NilCheck do
-  context 'for methods' do
-    it 'reports the correct line number' do
-      src = <<-EOS
+  it 'reports correctly the basic use case' do
+    src = <<-EOS
       def nilcheck foo
         foo.nil?
       end
-      EOS
-      ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      detector = build(:smell_detector, smell_type: :NilCheck)
-      smells = detector.inspect(ctx)
-      expect(smells[0].lines).to eq [2]
-    end
+    EOS
+    expect(src).to reek_of :NilCheck,
+                           lines: [2],
+                           message: 'performs a nil-check'
+  end
 
-    it 'reports nothing when scope includes no nil checks' do
-      expect('def no_nils; end').not_to reek_of(:NilCheck)
-    end
+  it 'reports nothing when scope includes no nil checks' do
+    expect('def no_nils; end').not_to reek_of(:NilCheck)
+  end
 
-    it 'reports when scope uses multiple nil? methods' do
-      src = <<-EOS
-      def chk_multi_nil(para)
-        para.nil?
-        puts "Hello"
-        \"\".nil?
-      end
-      EOS
-      expect(src).to reek_of(:NilCheck)
+  it 'reports when scope uses multiple nil? methods' do
+    src = <<-EOS
+    def chk_multi_nil(para)
+      para.nil?
+      puts "Hello"
+      \"\".nil?
     end
+    EOS
+    expect(src).to reek_of(:NilCheck)
+  end
 
-    it 'reports twice when scope uses == nil and === nil' do
-      src = <<-EOS
-      def chk_eq_nil(para)
-        para == nil
-        para === nil
-      end
-      EOS
-      expect(src).to reek_of(:NilCheck)
+  it 'reports twice when scope uses == nil and === nil' do
+    src = <<-EOS
+    def chk_eq_nil(para)
+      para == nil
+      para === nil
     end
+    EOS
+    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 reek_of(:NilCheck)
-    end
+  it 'reports when scope uses nil ==' do
+    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
-      src = <<-EOS
-      def case_nil
-        case @inst_var
-        when nil then puts "Nil"
-        end
-        puts "Hello"
-        case @inst_var2
-        when 1 then puts 1
-        when nil then puts nil.inspect
-        end
+  it 'reports when scope uses multiple case-clauses checking nil' do
+    src = <<-EOS
+    def case_nil
+      case @inst_var
+      when nil then puts "Nil"
+      end
+      puts "Hello"
+      case @inst_var2
+      when 1 then puts 1
+      when nil then puts nil.inspect
       end
-      EOS
-      expect(src).to reek_of(:NilCheck)
     end
+    EOS
+    expect(src).to reek_of(:NilCheck)
+  end
 
-    it 'reports a when clause that checks nil and other values' do
-      src = <<-EOS
-      def case_nil
-        case @inst_var
-        when nil, false then puts "Hello"
-        end
+  it 'reports a when clause that checks nil and other values' do
+    src = <<-EOS
+    def case_nil
+      case @inst_var
+      when nil, false then puts "Hello"
       end
-      EOS
-      expect(src).to reek_of(:NilCheck)
     end
+    EOS
+    expect(src).to reek_of(:NilCheck)
   end
 end