reek 3.0.4 → 3.1

data/spec/reek/smells/duplicate_method_call_spec.rb

@@ -151,23 +151,20 @@ RSpec.describe Reek::Smells::DuplicateMethodCall do
   end
 
   context 'allowing up to 3 calls' do
-    before :each do
-      @config = { DuplicateMethodCall:
-                  { Reek::Smells::DuplicateMethodCall::MAX_ALLOWED_CALLS_KEY => 3 } }
+    let(:config) do
+      { Reek::Smells::DuplicateMethodCall =>
+        { Reek::Smells::DuplicateMethodCall::MAX_ALLOWED_CALLS_KEY => 3 } }
     end
+    let(:configuration) { test_configuration_for(config) }
 
     it 'does not report double calls' do
       src = 'def double_thing() @other.thing + @other.thing end'
-      with_test_config(@config) do
-        expect(src).not_to reek_of(:DuplicateMethodCall)
-      end
+      expect(src).not_to reek_of(:DuplicateMethodCall, {}, configuration)
     end
 
     it 'does not report triple calls' do
       src = 'def double_thing() @other.thing + @other.thing + @other.thing end'
-      with_test_config(@config) do
-        expect(src).not_to reek_of(:DuplicateMethodCall)
-      end
+      expect(src).not_to reek_of(:DuplicateMethodCall, {}, configuration)
     end
 
     it 'reports quadruple calls' do
@@ -176,41 +173,36 @@ RSpec.describe Reek::Smells::DuplicateMethodCall do
           @other.thing + @other.thing + @other.thing + @other.thing
         end
       '
-      with_test_config(@config) do
-        expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing', count: 4)
-      end
+      expect(src).to reek_of(:DuplicateMethodCall,
+                             { name: '@other.thing', count: 4 },
+                             configuration)
     end
   end
 
   context 'allowing calls to some methods' do
-    before :each do
-      @config = { DuplicateMethodCall:
-                  { Reek::Smells::DuplicateMethodCall::ALLOW_CALLS_KEY =>
-                    ['@some.thing', /puts/] } }
+    let(:config) do
+      { Reek::Smells::DuplicateMethodCall =>
+        { Reek::Smells::DuplicateMethodCall::ALLOW_CALLS_KEY =>
+          ['@some.thing', /puts/] } }
     end
+    let(:configuration) { test_configuration_for(config) }
 
     it 'does not report calls to some methods' do
       src = 'def double_some_thing() @some.thing + @some.thing end'
 
-      with_test_config(@config) do
-        expect(src).not_to reek_of(:DuplicateMethodCall)
-      end
+      expect(src).not_to reek_of(:DuplicateMethodCall, {}, configuration)
     end
 
     it 'reports calls to other methods' do
       src = 'def double_other_thing() @other.thing + @other.thing end'
 
-      with_test_config(@config) do
-        expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing')
-      end
+      expect(src).to reek_of(:DuplicateMethodCall, { name: '@other.thing' }, configuration)
     end
 
     it 'does not report calls to methods specifed with a regular expression' do
       src = 'def double_puts() puts @other.thing; puts @other.thing end'
 
-      with_test_config(@config) do
-        expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing')
-      end
+      expect(src).to reek_of(:DuplicateMethodCall, { name: '@other.thing' }, configuration)
     end
   end
 end

data/spec/reek/smells/feature_envy_spec.rb

@@ -1,5 +1,6 @@
 require_relative '../../spec_helper'
 require_relative '../../../lib/reek/smells/feature_envy'
+require_relative '../../../lib/reek/examiner'
 require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::FeatureEnvy do
@@ -213,13 +214,13 @@ end
 
 RSpec.describe Reek::Smells::FeatureEnvy do
   before(:each) do
-    @source_name = 'dummy_source'
+    @source_name = 'string'
     @detector = build(:smell_detector, smell_type: :FeatureEnvy, source: @source_name)
   end
 
   it_should_behave_like 'SmellDetector'
 
-  context 'when reporting yaml' do
+  context 'when a smell is reported' do
     before :each do
       @receiver = 'other'
       src = <<-EOS
@@ -230,9 +231,7 @@ RSpec.describe Reek::Smells::FeatureEnvy do
           #{@receiver}.fred
         end
       EOS
-      source = Reek::Source::SourceCode.from(src)
-      @mctx = Reek::TreeWalker.new.process_def(source.syntax_tree)
-      @smells = @detector.examine_context(@mctx)
+      @smells = Reek::Examiner.new(src, ['FeatureEnvy']).smells
     end
 
     it 'reports only that smell' do

data/spec/reek/smells/irresponsible_module_spec.rb

@@ -133,6 +133,18 @@ RSpec.describe Reek::Smells::IrresponsibleModule do
     expect(src).to reek_of(:IrresponsibleModule)
   end
 
+  it 'does not report namespace modules that have a nested class through assignment' do
+    src = <<-EOS
+      module Qux
+        # Foo is responsible
+        Foo = Class.new Bar do
+          def quux; end
+        end
+      end
+    EOS
+    expect(src).not_to reek_of(:IrresponsibleModule)
+  end
+
   it 'reports classes that have a defined superclass' do
     src = <<-EOS
       class Foo < Bar; end
@@ -140,6 +152,37 @@ RSpec.describe Reek::Smells::IrresponsibleModule do
     expect(src).to reek_of(:IrresponsibleModule)
   end
 
+  it 'reports classes defined through assignment' do
+    src = <<-EOS
+      # Qux is responsible, but Foo is not
+      module Qux
+        Foo = Class.new Bar
+      end
+    EOS
+    expect(src).to reek_of(:IrresponsibleModule, name: 'Foo')
+  end
+
+  it 'reports structs defined through assignment' do
+    src = <<-EOS
+      # Qux is responsible, but Foo is not
+      module Qux
+        Foo = Struct.new(:x, :y)
+      end
+    EOS
+    expect(src).to reek_of(:IrresponsibleModule, name: 'Foo')
+  end
+
+  it 'does not report constants that are not classes' do
+    src = <<-EOS
+      module Qux
+        Foo = 23
+        Bar = Hash.new
+        Quuz = 'foo'.freeze
+      end
+    EOS
+    expect(src).not_to reek_of(:IrresponsibleModule)
+  end
+
   context 'when a smell is reported' do
     before do
       @source_name = 'dummy_source'

data/spec/reek/smells/nested_iterators_spec.rb

@@ -124,9 +124,10 @@ RSpec.describe Reek::Smells::NestedIterators do
 
   context 'when the allowed nesting depth is 3' do
     before :each do
-      @config = { NestedIterators:
+      @config = { Reek::Smells::NestedIterators =>
                   { Reek::Smells::NestedIterators::MAX_ALLOWED_NESTING_KEY => 3 } }
     end
+    let(:configuration) { test_configuration_for(@config) }
 
     it 'should not report nested iterators 2 levels deep' do
       src = <<-EOS
@@ -135,9 +136,7 @@ RSpec.describe Reek::Smells::NestedIterators do
         end
       EOS
 
-      with_test_config(@config) do
-        expect(src).not_to reek_of(:NestedIterators)
-      end
+      expect(src).not_to reek_of(:NestedIterators, {}, configuration)
     end
 
     it 'should not report nested iterators 3 levels deep' do
@@ -147,9 +146,7 @@ RSpec.describe Reek::Smells::NestedIterators do
         end
       EOS
 
-      with_test_config(@config) do
-        expect(src).not_to reek_of(:NestedIterators)
-      end
+      expect(src).not_to reek_of(:NestedIterators, {}, configuration)
     end
 
     it 'should report nested iterators 4 levels deep' do
@@ -159,30 +156,25 @@ RSpec.describe Reek::Smells::NestedIterators do
         end
       EOS
 
-      with_test_config(@config) do
-        expect(src).to reek_of(:NestedIterators)
-      end
+      expect(src).to reek_of(:NestedIterators, {}, configuration)
     end
   end
 
   context 'when ignoring iterators' do
     before :each do
-      @config = { NestedIterators:
+      @config = { Reek::Smells::NestedIterators =>
                   { Reek::Smells::NestedIterators::IGNORE_ITERATORS_KEY => ['ignore_me'] } }
     end
+    let(:configuration) { test_configuration_for(@config) }
 
     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'
-      with_test_config(@config) do
-        expect(src).not_to reek_of(:NestedIterators)
-      end
+      expect(src).not_to reek_of(:NestedIterators, {}, configuration)
     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'
-      with_test_config(@config) do
-        expect(src).not_to reek_of(:NestedIterators)
-      end
+      expect(src).not_to reek_of(:NestedIterators, {}, configuration)
     end
 
     it 'should report nested iterators inside the ignored iterator' do
@@ -191,9 +183,7 @@ RSpec.describe Reek::Smells::NestedIterators do
           @fred.ignore_me {|item| item.each {|ting| ting.each {|other| other.other} } }
         end
       '
-      with_test_config(@config) do
-        expect(src).to reek_of(:NestedIterators, count: 2)
-      end
+      expect(src).to reek_of(:NestedIterators, { count: 2 }, configuration)
     end
 
     it 'should report nested iterators outside the ignored iterator' do
@@ -202,9 +192,7 @@ RSpec.describe Reek::Smells::NestedIterators do
           @fred.each {|item| item.each {|ting| ting.ignore_me {|other| other.other} } }
         end
       '
-      with_test_config(@config) do
-        expect(src).to reek_of(:NestedIterators, count: 2)
-      end
+      expect(src).to reek_of(:NestedIterators, { count: 2 }, configuration)
     end
 
     it 'should report nested iterators with the ignored iterator between them' do
@@ -213,9 +201,7 @@ RSpec.describe Reek::Smells::NestedIterators do
           @fred.each {|item| item.ignore_me {|ting| ting.ting {|other| other.other} } }
         end
       '
-      with_test_config(@config) do
-        expect(src).to reek_of(:NestedIterators, count: 2)
-      end
+      expect(src).to reek_of(:NestedIterators, { count: 2 }, configuration)
     end
   end
 end

data/spec/reek/smells/too_many_statements_spec.rb

@@ -1,15 +1,6 @@
 require_relative '../../spec_helper'
 require_relative '../../../lib/reek/smells/too_many_statements'
 require_relative 'smell_detector_shared'
-require_relative '../../../lib/reek/source/source_code'
-
-def process_method(source)
-  Reek::TreeWalker.new.process_def(Reek::Source::SourceCode.from(source).syntax_tree)
-end
-
-def process_singleton_method(source)
-  Reek::TreeWalker.new.process_defs(Reek::Source::SourceCode.from(source).syntax_tree)
-end
 
 RSpec.describe Reek::Smells::TooManyStatements do
   it 'should not report short methods' do
@@ -19,7 +10,7 @@ RSpec.describe Reek::Smells::TooManyStatements do
 
   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)
+    expect(src).to reek_of(:TooManyStatements)
   end
 
   it 'should not report initialize' do
@@ -45,206 +36,7 @@ RSpec.describe Reek::Smells::TooManyStatements do
         end
       end
     EOS
-    expect(src).to reek_only_of(:TooManyStatements)
-  end
-end
-
-RSpec.describe Reek::Smells::TooManyStatements do
-  it 'counts 1 assignment' do
-    method = process_method('def one() val = 4; end')
-    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')
-    expect(method.num_statements).to eq(3)
-  end
-
-  it 'counts 1 attr assignment' do
-    method = process_method('def one() val[0] = 4; end')
-    expect(method.num_statements).to eq(1)
-  end
-
-  it 'counts 1 increment assignment' do
-    method = process_method('def one() val += 4; end')
-    expect(method.num_statements).to eq(1)
-  end
-
-  it 'counts 1 increment attr assignment' do
-    method = process_method('def one() val[0] += 4; end')
-    expect(method.num_statements).to eq(1)
-  end
-
-  it 'counts 1 nested assignment' do
-    method = process_method('def one() val = fred = 4; end')
-    expect(method.num_statements).to eq(1)
-  end
-
-  it 'counts returns' do
-    method = process_method('def one() val = 4; true; end')
-    expect(method.num_statements).to eq(2)
-  end
-
-  it 'counts nil returns' do
-    method = process_method('def one() val = 4; nil; end')
-    expect(method.num_statements).to eq(2)
-  end
-end
-
-RSpec.describe Reek::Smells::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')
-    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')
-    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')
-    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
-    ')
-    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')
-    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')
-    expect(method.num_statements).to eq(0)
-  end
-
-  it 'counts extra statements in an if condition' do
-    method = process_method('def one() if begin val = callee(); val < 4 end; end; end')
-    expect(method.num_statements).to eq(1)
-  end
-
-  it 'counts 1 statement in a while loop' do
-    method = process_method('def one() while val < 4; callee(); end; end')
-    expect(method.num_statements).to eq(1)
-  end
-
-  it 'counts 3 statements in a while loop' do
-    source = 'def one() while val < 4; callee(); callee(); callee(); end; end'
-    expect(process_method(source).num_statements).to eq(3)
-  end
-
-  it 'counts extra statements in a while condition' do
-    method = process_method('def one() while begin val = callee(); val < 4 end; end; end')
-    expect(method.num_statements).to eq(1)
-  end
-
-  it 'counts 1 statement in a until loop' do
-    method = process_method('def one() until val < 4; callee(); end; end')
-    expect(method.num_statements).to eq(1)
-  end
-
-  it 'counts 3 statements in a until loop' do
-    source = 'def one() until val < 4; callee(); callee(); callee(); end; end'
-    expect(process_method(source).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')
-    expect(method.num_statements).to eq(1)
-  end
-
-  it 'counts 3 statements in a for loop' do
-    source = 'def one() for i in 0..4; callee(); callee(); callee(); end; end'
-    expect(process_method(source).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')
-    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
-    ')
-    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')
-    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" then callee(); callee()
-        when "lo" then callee()
-        end
-      end
-    ')
-    expect(method.num_statements).to eq(3)
-  end
-
-  it 'counts 1 statement in a case else' do
-    source = 'def one() case fred; when "hi"; callee(); else; callee(); end; end'
-    expect(process_method(source).num_statements).to eq(2)
-  end
-
-  it 'counts 3 statements in a case else' do
-    method = process_method('
-      def one()
-        case fred
-        when "hi" then callee(); callee(); callee()
-        else           callee(); callee(); callee()
-        end
-      end
-    ')
-    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')
-    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')
-    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')
-    expect(method.num_statements).to eq(2)
-  end
-
-  it 'counts 4 statements in an iterator' do
-    source = 'def one() fred.each do; callee(); callee(); callee(); end; end'
-    expect(process_method(source).num_statements).to eq(4)
-  end
-
-  it 'counts 1 statement in a singleton method' do
-    method = process_singleton_method('def self.foo; callee(); end')
-    expect(method.num_statements).to eq(1)
+    expect(src).to reek_of(:TooManyStatements)
   end
 end