reek 4.4.0 → 4.4.1

data/spec/reek/smells/nil_check_spec.rb

@@ -1,88 +1,99 @@
 require_relative '../../spec_helper'
-require_lib 'reek/context/code_context'
 require_lib 'reek/smells/nil_check'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::NilCheck do
-  it 'reports correctly the basic use case' do
+  it 'reports the right values' do
     src = <<-EOS
-      def foo(bar)
-        bar.nil?
+      def alfa(bravo)
+        bravo.nil?
       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)
+    expect(src).to reek_of(:NilCheck,
+                           lines:   [2],
+                           context: 'alfa',
+                           message: 'performs a nil-check',
+                           source:  'string')
   end
 
-  it 'reports when scope uses #nil?' do
+  it 'does count all occurences' do
     src = <<-EOS
-    def foo(bar)
-      bar.nil?
-    end
+      def alfa(bravo, charlie)
+        bravo.nil?
+        charlie.nil?
+      end
     EOS
-    expect(src).to reek_of(:NilCheck)
+
+    expect(src).to reek_of(:NilCheck,
+                           lines:   [2, 3],
+                           context: 'alfa')
+  end
+
+  it 'reports nothing when scope includes no nil checks' do
+    expect('def alfa; end').not_to reek_of(:NilCheck)
   end
 
   it 'reports when scope uses == nil' do
     src = <<-EOS
-    def foo(bar)
-      bar == nil
-    end
+      def alfa(bravo)
+        bravo == nil
+      end
     EOS
+
     expect(src).to reek_of(:NilCheck)
   end
 
   it 'reports when scope uses === nil' do
     src = <<-EOS
-    def foo(bar)
-      bar === nil
-    end
+      def alfa(bravo)
+        bravo === nil
+      end
     EOS
+
     expect(src).to reek_of(:NilCheck)
   end
 
   it 'reports when scope uses nil ==' do
     src = <<-EOS
-    def foo(bar)
-      nil == bar
-    end
+      def alfa(bravo)
+        nil == bravo
+      end
     EOS
+
     expect(src).to reek_of(:NilCheck)
   end
 
   it 'reports when scope uses a case-clause checking nil' do
     src = <<-EOS
-    def case_nil
-      case @foo
-      when nil then puts "Nil"
+      def alfa(bravo)
+        case bravo
+        when nil then puts "Nil"
+        end
       end
-    end
     EOS
+
     expect(src).to reek_of(:NilCheck)
   end
 
   it 'reports when scope uses &.' do
     src = <<-EOS
-    def foo(bar)
-      bar&.baz
-    end
+      def alfa(bravo)
+        bravo&.charlie
+      end
     EOS
+
     expect(src).to reek_of(:NilCheck)
   end
 
   it 'reports all lines when scope uses multiple nilchecks' do
     src = <<-EOS
-    def foo(bar)
-      bar.nil?
-      bar === nil
-      bar&.baz
-    end
+      def alfa(bravo)
+        bravo.nil?
+        @charlie === nil
+        delta&.echo
+      end
     EOS
+
     expect(src).to reek_of(:NilCheck, lines: [2, 3, 4])
   end
 end

data/spec/reek/smells/prima_donna_method_spec.rb

@@ -1,38 +1,53 @@
 require_relative '../../spec_helper'
-require_lib 'reek/context/module_context'
-require_relative 'smell_detector_shared'
+require_lib 'reek/smells/prima_donna_method'
 
 RSpec.describe Reek::Smells::PrimaDonnaMethod do
   it 'reports the right values' do
-    src = 'class C; def m!; end; end'
-    expect(src).to reek_of :PrimaDonnaMethod,
+    src = <<-EOS
+      class Alfa
+        def bravo!
+        end
+      end
+    EOS
+
+    expect(src).to reek_of(:PrimaDonnaMethod,
+                           lines:   [1],
+                           context: 'Alfa',
+                           message: "has prima donna method 'bravo!'",
+                           source:  'string',
+                           name:    :bravo!)
+  end
+
+  it 'does count all occurences' do
+    src = <<-EOS
+      class Alfa
+        def bravo!
+        end
+
+        def charlie!
+        end
+      end
+    EOS
+
+    expect(src).to reek_of(:PrimaDonnaMethod,
+                           lines: [1],
+                           name:  :bravo!)
+    expect(src).to reek_of(:PrimaDonnaMethod,
                            lines: [1],
-                           message: 'has prima donna method `m!`',
-                           name: :m!
+                           name:  :charlie!)
   end
 
   it 'should report nothing when method and bang counterpart exist' do
-    expect('class C; def m; end; def m!; end; end').not_to reek_of(:PrimaDonnaMethod)
-  end
+    src = <<-EOS
+      class Alfa
+        def bravo
+        end
 
-  it 'should report PrimaDonnaMethod when only bang method exists' do
-    expect('class C; def m!; end; end').to reek_of(:PrimaDonnaMethod)
-  end
+        def bravo!
+        end
+      end
+    EOS
 
-  describe 'the right smell' do
-    let(:detector) { build(:smell_detector, smell_type: :PrimaDonnaMethod) }
-    let(:src)      { 'class C; def m!; end; end' }
-    let(:ctx)      do
-      Reek::Context::ModuleContext.new(nil,
-                                       Reek::Source::SourceCode.from(src).syntax_tree)
-    end
-
-    it 'should be reported' do
-      smells = detector.sniff(ctx)
-      warning = smells[0]
-
-      expect(warning.smell_type).to eq('PrimaDonnaMethod')
-      expect(warning.lines).to eq([1])
-    end
+    expect(src).not_to reek_of(:PrimaDonnaMethod)
   end
 end

data/spec/reek/smells/repeated_conditional_spec.rb

@@ -1,112 +1,100 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/repeated_conditional'
-require_lib 'reek/context/code_context'
-require_relative 'smell_detector_shared'
-require_lib 'reek/source/source_code'
 
 RSpec.describe Reek::Smells::RepeatedConditional do
-  let(:detector) { build(:smell_detector, smell_type: :RepeatedConditional) }
+  it 'reports the right values' do
+    src = <<-EOS
+      class Alfa
+        attr_accessor :bravo
 
-  it_should_behave_like 'SmellDetector'
+        def charlie
+          puts "Repeat 1!" if bravo
+        end
 
-  context 'with no conditionals' do
-    it 'gathers an empty hash' do
-      ast = Reek::Source::SourceCode.from('module Stable; end').syntax_tree
-      ctx = Reek::Context::CodeContext.new(nil, ast)
-      expect(detector.conditional_counts(ctx).length).to eq(0)
-    end
-  end
+        def delta
+          puts "Repeat 2!" if bravo
+        end
 
-  context 'with a test of block_given?' do
-    it 'does not record the condition' do
-      ast = Reek::Source::SourceCode.from('def fred() yield(3) if block_given?; end').syntax_tree
-      ctx = Reek::Context::CodeContext.new(nil, ast)
-      expect(detector.conditional_counts(ctx).length).to eq(0)
-    end
+        def echo
+          puts "Repeat 3!" if bravo
+        end
+      end
+    EOS
+
+    expect(src).to reek_of(:RepeatedConditional,
+                           lines:   [5, 9, 13],
+                           context: 'Alfa',
+                           message: "tests 'bravo' at least 3 times",
+                           source:  'string',
+                           name:    'bravo',
+                           count:   3)
   end
 
-  context 'with an empty condition' do
-    it 'does not record the condition' do
-      ast = Reek::Source::SourceCode.from('def fred() case; when 3; end; end').syntax_tree
-      ctx = Reek::Context::CodeContext.new(nil, ast)
-      expect(detector.conditional_counts(ctx).length).to eq(0)
-    end
-  end
+  it 'does count all occurences' do
+    src = <<-EOS
+      class Alfa
+        attr_accessor :bravo
 
-  context 'with three identical conditionals' do
-    let(:cond) { '@field == :sym' }
-    let(:cond_expr) { Reek::Source::SourceCode.from(cond).syntax_tree }
+        def charlie
+          puts "Repeat 1!" if bravo
+          puts "And again!" if bravo
+        end
 
-    let(:conds) do
-      src = <<-EOS
-        class Scrunch
-          def first
-            puts "hello" if @debug
-            return #{cond} ? 0 : 3;
-          end
-          def second
-            if #{cond}
-              @other += " quarts"
-            end
-          end
-          def third
-            raise 'flu!' unless #{cond}
-          end
+        def delta
+          puts "Repeat 2!" if bravo
         end
-      EOS
 
-      ast = Reek::Source::SourceCode.from(src).syntax_tree
-      ctx = Reek::Context::CodeContext.new(nil, ast)
-      detector.conditional_counts(ctx)
-    end
+        def echo
+          puts "Repeat 3!" if bravo
+        end
+      end
+    EOS
 
-    it 'finds both conditionals' do
-      expect(conds.length).to eq(2)
-    end
+    expect(src).to reek_of(:RepeatedConditional,
+                           lines: [5, 6, 10, 14],
+                           count: 4)
+  end
 
-    it 'returns the condition expr' do
-      expect(conds.keys[1]).to eq(cond_expr)
-    end
+  it 'does not report two repeated conditionals' do
+    src = <<-EOS
+      class Alfa
+        attr_accessor :bravo
 
-    it 'knows there are three copies' do
-      expect(conds.values[1].length).to eq(3)
-    end
+        def charlie
+          puts "Repeat 1!" if bravo
+        end
+
+        def delta
+          puts "Repeat 2!" if bravo
+        end
+      end
+    EOS
+
+    expect(src).not_to reek_of(:RepeatedConditional)
   end
 
-  context 'with a matching if and case' do
-    let(:cond) { '@field == :sym' }
-    let(:cond_expr) { Reek::Source::SourceCode.from(cond).syntax_tree }
+  it 'reports repeated conditionals regardless of `if` or `case` statements' do
+    src = <<-EOS
+      class Alfa
+        attr_accessor :bravo
 
-    let(:conds) do
-      src = <<-EOS
-        class Scrunch
-          def alpha
-            return #{cond} ? 0 : 2;
-          end
-          def beta
-            case #{cond}
-            when :symbol
-              @tother += " pints"
-            end
-          end
+        def charlie
+          puts "Repeat 1!" if bravo
         end
-      EOS
-
-      ast = Reek::Source::SourceCode.from(src).syntax_tree
-      ctx = Reek::Context::CodeContext.new(nil, ast)
-      detector.conditional_counts(ctx)
-    end
 
-    it 'finds exactly one conditional' do
-      expect(conds.length).to eq(1)
-    end
+        def delta
+          case bravo
+          when 1 then puts "Repeat 2!"
+          else 'nothing'
+          end
+        end
 
-    it 'returns the condition expr' do
-      expect(conds.keys[0]).to eq(cond_expr)
-    end
+        def echo
+          puts "Repeat 3!" if bravo
+        end
+      end
+    EOS
 
-    it 'knows there are two copies' do
-      expect(conds.values[0].length).to eq(2)
-    end
+    expect(src).to reek_of(:RepeatedConditional)
   end
 end

data/spec/reek/smells/smell_warning_spec.rb

@@ -31,6 +31,13 @@ RSpec.describe Reek::Smells::SmellWarning do
       it_should_behave_like 'first sorts ahead of second'
     end
 
+    context 'smells differing only by lines' do
+      let(:first) { build(:smell_warning, smell_detector: feature_envy_detector, lines: [2]) }
+      let(:second) { build(:smell_warning, smell_detector: feature_envy_detector, lines: [3]) }
+
+      it_should_behave_like 'first sorts ahead of second'
+    end
+
     context 'smells differing only by context' do
       let(:first) { build(:smell_warning, smell_detector: duplication_detector, context: 'first') }
       let(:second) do

data/spec/reek/smells/subclassed_from_core_class_spec.rb

@@ -1,157 +1,82 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/subclassed_from_core_class'
-require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::SubclassedFromCoreClass do
-  let(:detector) { described_class.new }
-
-  it_should_behave_like 'SmellDetector'
-
-  context 'report' do
-    context 'smell line' do
-      context 'single class' do
-        it 'should report the core class in the message' do
-          src = <<-EOS
-            class Dummy < Hash
-            end
-          EOS
-
-          expect(src).to reek_of(:SubclassedFromCoreClass, lines: [1])
-        end
-      end
-
-      context 'class inside a module' do
-        it 'should report the core class in the message' do
-          src = <<-EOS
-            module Namespace
-              class Dummy < Hash
-              end
-            end
-          EOS
-
-          expect(src).to reek_of(:SubclassedFromCoreClass, lines: [2])
-        end
-      end
-    end
-
-    context 'smell message' do
-      context 'Array' do
-        it 'should report the core class in the message' do
-          src = <<-EOS
-            class Dummy < Array
-            end
-          EOS
-
-          expect(src).to reek_of(:SubclassedFromCoreClass, message: 'inherits from a core class (Array)')
-        end
-      end
-
-      context 'Hash' do
-        it 'should report the core class in the message' do
-          src = <<-EOS
-            class Dummy < Hash
-            end
-          EOS
-
-          expect(src).to reek_of(:SubclassedFromCoreClass, message: 'inherits from a core class (Hash)')
-        end
-      end
-    end
-  end
-
-  it 'does not inherit from a core class' do
+  it 'reports the right values' do
     src = <<-EOS
-      class Dummy
+      class Alfa < Hash
       end
     EOS
 
-    expect(src).to_not reek_of(:SubclassedFromCoreClass)
+    expect(src).to reek_of(:SubclassedFromCoreClass,
+                           lines:    [1],
+                           context:  'Alfa',
+                           message:  "inherits from core class 'Hash'",
+                           source:   'string',
+                           ancestor: 'Hash')
   end
 
-  it 'should report if we inherit from a core class' do
+  it 'reports when inheriting from a core class inside a module' do
     src = <<-EOS
-      class Dummy < Array
+      module Alfa
+        class Bravo < Hash
+        end
       end
     EOS
 
-    expect(src).to reek_of(:SubclassedFromCoreClass, ancestor: 'Array', message: 'inherits from a core class (Array)')
+    expect(src).to reek_of(:SubclassedFromCoreClass, context: 'Alfa::Bravo')
   end
 
-  it 'should not report on coincidental core class names in other namespaces' do
+  it 'does not report when not inheriting from a core class' do
     src = <<-EOS
-      class Dummy < My::Array
+      class Alfa
       end
     EOS
+
     expect(src).to_not reek_of(:SubclassedFromCoreClass)
   end
 
-  it 'should report if we inherit from a core class from within a namespaced class' do
+  it 'does not report on coincidental core class names in other namespaces' do
     src = <<-EOS
-      module Namespace
-        class Dummy < Array
-        end
+      class Alfa < Bravo::Array
       end
     EOS
-    expect(src).to reek_of(:SubclassedFromCoreClass, ancestor: 'Array')
+
+    expect(src).to_not reek_of(:SubclassedFromCoreClass)
   end
 
-  it 'should report if we inherit from a core class using Class#new' do
-    src = 'Dummy = Class.new(Array)'
-    expect(src).to reek_of(:SubclassedFromCoreClass, ancestor: 'Array')
+  it 'reports if we inherit from a core class using Class#new' do
+    src = 'Alfa = Class.new(Array)'
+    expect(src).to reek_of(:SubclassedFromCoreClass)
   end
 
-  it 'should report if inner class inherit from a core class' do
+  it 'reports if inner class inherit from a core class' do
     src = <<-EOS
-      module Namespace
-        class Dummy
-          Dummiest = Class.new(Array)
-        end
+      class Alfa
+        Bravo = Class.new(Array)
       end
     EOS
-    expect(src).to reek_of(:SubclassedFromCoreClass, ancestor: 'Array')
+
+    expect(src).to reek_of(:SubclassedFromCoreClass, context: 'Alfa::Bravo')
   end
 
-  it 'should not report on coincidental core class names in other namespaces' do
-    src = <<-EOS
-      module Namespace
-        class Dummy
-          Dummiest = Class.new(My::Array)
-        end
-      end
-    EOS
-    expect(src).to_not reek_of(:SubclassedFromCoreClass)
+  it 'reports class which inherits from core class via Class.new' do
+    src = 'Alfa = Class.new(Array)'
+    expect(src).to reek_of(:SubclassedFromCoreClass)
   end
 
-  it 'should not report if inner class inherits from allowed classes' do
-    src = <<-EOS
-      module Namespace
-        class Dummy
-          Dummiest = Class.new(StandardError)
-        end
-      end
-    EOS
+  it 'does not report class which inherits from allowed class via Class.new' do
+    src = 'Alfa = Class.new(StandardError)'
     expect(src).to_not reek_of(:SubclassedFromCoreClass)
   end
 
-  it 'should not report if class is created with Struct.new' do
-    src = <<-EOS
-      module Namespace
-        class Dummy
-          Dummiest = Struct.new('Array')
-        end
-      end
-    EOS
+  it 'does not report classes created with Struct.new' do
+    src = "Alfa = Struct.new('Array')"
     expect(src).to_not reek_of(:SubclassedFromCoreClass)
   end
 
-  it 'should only report classes created with Class.new' do
-    src = <<-EOS
-      module Namespace
-        class Dummy
-          Dummiest = Foo.new(Array)
-        end
-      end
-    EOS
+  it 'does not report class created by another class constructor taking a core class as argument' do
+    src = 'Charlie = Delta.new(Array)'
     expect(src).to_not reek_of(:SubclassedFromCoreClass)
   end
 end