reek 4.0.1 → 4.0.2

data/spec/reek/cli/command/todo_list_command_spec.rb

@@ -1,13 +1,17 @@
 require_relative '../../../spec_helper'
 require_lib 'reek/cli/command/todo_list_command'
 require_lib 'reek/cli/options'
-require_lib 'reek/cli/option_interpreter'
 
 RSpec.describe Reek::CLI::Command::TodoListCommand do
   describe '#execute' do
-    let(:option_interpreter) { FactoryGirl.build(:options_interpreter_with_empty_sources) }
-    let(:app) { double 'app' }
-    let(:command) { described_class.new(option_interpreter, sources: []) }
+    let(:options) { Reek::CLI::Options.new [] }
+    let(:configuration) { double 'configuration' }
+
+    let(:command) do
+      described_class.new(options: options,
+                          sources: [],
+                          configuration: configuration)
+    end
 
     before do
       $stdout = StringIO.new
@@ -26,11 +30,11 @@ RSpec.describe Reek::CLI::Command::TodoListCommand do
 
       it 'shows a proper message' do
         expected = "\n'.todo.reek' generated! You can now use this as a starting point for your configuration.\n"
-        expect { command.execute app }.to output(expected).to_stdout
+        expect { command.execute }.to output(expected).to_stdout
       end
 
       it 'returns a success code' do
-        result = command.execute app
+        result = command.execute
         expect(result).to eq(Reek::CLI::Options::DEFAULT_SUCCESS_EXIT_CODE)
       end
     end
@@ -42,18 +46,16 @@ RSpec.describe Reek::CLI::Command::TodoListCommand do
 
       it 'shows a proper message' do
         expected = "\n'.todo.reek' not generated because there were no smells found!\n"
-        expect { command.execute app }.to output(expected).to_stdout
+        expect { command.execute }.to output(expected).to_stdout
       end
 
       it 'returns a success code' do
-        result = command.execute app
+        result = command.execute
         expect(result).to eq Reek::CLI::Options::DEFAULT_SUCCESS_EXIT_CODE
       end
     end
 
     describe 'groups_for' do
-      let(:command) { described_class.new({}, sources: []) }
-
       it 'returns a proper hash representation of the smells found' do
         smells = [FactoryGirl.build(:smell_warning)]
         expected = { 'FeatureEnvy' => { 'exclude' => ['self'] } }

data/spec/reek/smells/duplicate_method_call_spec.rb

@@ -152,19 +152,17 @@ RSpec.describe Reek::Smells::DuplicateMethodCall do
 
   context 'allowing up to 3 calls' do
     let(:config) do
-      { Reek::Smells::DuplicateMethodCall =>
-        { Reek::Smells::DuplicateMethodCall::MAX_ALLOWED_CALLS_KEY => 3 } }
+      { 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'
-      expect(src).not_to reek_of(:DuplicateMethodCall, {}, configuration)
+      expect(src).not_to reek_of(:DuplicateMethodCall).with_config(config)
     end
 
     it 'does not report triple calls' do
       src = 'def double_thing() @other.thing + @other.thing + @other.thing end'
-      expect(src).not_to reek_of(:DuplicateMethodCall, {}, configuration)
+      expect(src).not_to reek_of(:DuplicateMethodCall).with_config(config)
     end
 
     it 'reports quadruple calls' do
@@ -174,35 +172,31 @@ RSpec.describe Reek::Smells::DuplicateMethodCall do
         end
       '
       expect(src).to reek_of(:DuplicateMethodCall,
-                             { name: '@other.thing', count: 4 },
-                             configuration)
+                             name: '@other.thing', count: 4).with_config(config)
     end
   end
 
   context 'allowing calls to some methods' do
     let(:config) do
-      { Reek::Smells::DuplicateMethodCall =>
-        { Reek::Smells::DuplicateMethodCall::ALLOW_CALLS_KEY =>
-          ['@some.thing', /puts/] } }
+      { 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'
 
-      expect(src).not_to reek_of(:DuplicateMethodCall, {}, configuration)
+      expect(src).not_to reek_of(:DuplicateMethodCall).with_config(config)
     end
 
     it 'reports calls to other methods' do
       src = 'def double_other_thing() @other.thing + @other.thing end'
 
-      expect(src).to reek_of(:DuplicateMethodCall, { name: '@other.thing' }, configuration)
+      expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing').with_config(config)
     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'
 
-      expect(src).to reek_of(:DuplicateMethodCall, { name: '@other.thing' }, configuration)
+      expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing').with_config(config)
     end
   end
 end

data/spec/reek/smells/nested_iterators_spec.rb

@@ -174,10 +174,8 @@ RSpec.describe Reek::Smells::NestedIterators do
   end
 
   context 'when the allowed nesting depth is 3' do
-    let(:configuration) do
-      config = { Reek::Smells::NestedIterators =>
-                 { Reek::Smells::NestedIterators::MAX_ALLOWED_NESTING_KEY => 3 } }
-      test_configuration_for(config)
+    let(:config) do
+      { Reek::Smells::NestedIterators::MAX_ALLOWED_NESTING_KEY => 3 }
     end
 
     it 'should not report nested iterators 2 levels deep' do
@@ -187,7 +185,7 @@ RSpec.describe Reek::Smells::NestedIterators do
         end
       EOS
 
-      expect(src).not_to reek_of(:NestedIterators, {}, configuration)
+      expect(src).not_to reek_of(:NestedIterators).with_config(config)
     end
 
     it 'should not report nested iterators 3 levels deep' do
@@ -197,7 +195,7 @@ RSpec.describe Reek::Smells::NestedIterators do
         end
       EOS
 
-      expect(src).not_to reek_of(:NestedIterators, {}, configuration)
+      expect(src).not_to reek_of(:NestedIterators).with_config(config)
     end
 
     it 'should report nested iterators 4 levels deep' do
@@ -207,25 +205,23 @@ RSpec.describe Reek::Smells::NestedIterators do
         end
       EOS
 
-      expect(src).to reek_of(:NestedIterators, {}, configuration)
+      expect(src).to reek_of(:NestedIterators).with_config(config)
     end
   end
 
   context 'when ignoring iterators' do
-    let(:configuration) do
-      config = { Reek::Smells::NestedIterators =>
-                 { Reek::Smells::NestedIterators::IGNORE_ITERATORS_KEY => ['ignore_me'] } }
-      test_configuration_for(config)
+    let(:config) do
+      { Reek::Smells::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 reek_of(:NestedIterators, {}, configuration)
+      expect(src).not_to reek_of(:NestedIterators).with_config(config)
     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 reek_of(:NestedIterators, {}, configuration)
+      expect(src).not_to reek_of(:NestedIterators).with_config(config)
     end
 
     it 'should report nested iterators inside the ignored iterator' do
@@ -234,7 +230,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 }, configuration)
+      expect(src).to reek_of(:NestedIterators, count: 2).with_config(config)
     end
 
     it 'should report nested iterators outside the ignored iterator' do
@@ -243,7 +239,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 }, configuration)
+      expect(src).to reek_of(:NestedIterators, count: 2).with_config(config)
     end
 
     it 'should report nested iterators with the ignored iterator between them' do
@@ -252,7 +248,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 }, configuration)
+      expect(src).to reek_of(:NestedIterators, count: 2).with_config(config)
     end
   end
 end

data/spec/reek/smells/uncommunicative_method_name_spec.rb

@@ -53,8 +53,7 @@ RSpec.describe Reek::Smells::UncommunicativeMethodName do
 
     it 'make smelly names pass via regex / strings given by list / literal' do
       [[/x/], /x/, ['x'], 'x'].each do |pattern|
-        configuration = accept_configuration_for(described_class, pattern: pattern)
-        expect(source).to_not reek_of(described_class, {}, configuration)
+        expect(source).to_not reek_of(described_class).with_config('accept' => pattern)
       end
     end
   end
@@ -64,8 +63,7 @@ RSpec.describe Reek::Smells::UncommunicativeMethodName do
 
     it 'reject smelly names via regex / strings given by list / literal' do
       [[/helper/], /helper/, ['helper'], 'helper'].each do |pattern|
-        configuration = reject_configuration_for(described_class, pattern: pattern)
-        expect(source).to reek_of(described_class, {}, configuration)
+        expect(source).to reek_of(described_class).with_config('reject' => pattern)
       end
     end
   end

data/spec/reek/smells/uncommunicative_module_name_spec.rb

@@ -54,8 +54,7 @@ RSpec.describe Reek::Smells::UncommunicativeModuleName do
 
     it 'make smelly names pass via regex / strings given by list / literal' do
       [[/lassy/], /lassy/, ['lassy'], 'lassy'].each do |pattern|
-        configuration = accept_configuration_for(described_class, pattern: pattern)
-        expect(source).to_not reek_of(described_class, {}, configuration)
+        expect(source).to_not reek_of(described_class).with_config('accept' => pattern)
       end
     end
   end
@@ -65,8 +64,7 @@ RSpec.describe Reek::Smells::UncommunicativeModuleName do
 
     it 'reject smelly names via regex / strings given by list / literal' do
       [[/Helper/], /Helper/, ['Helper'], 'Helper'].each do |pattern|
-        configuration = reject_configuration_for(described_class, pattern: pattern)
-        expect(source).to reek_of(described_class, {}, configuration)
+        expect(source).to reek_of(described_class).with_config('reject' => pattern)
       end
     end
   end

data/spec/reek/smells/uncommunicative_parameter_name_spec.rb

@@ -99,8 +99,7 @@ RSpec.describe Reek::Smells::UncommunicativeParameterName do
 
     it 'make smelly names pass via regex / strings given by list / literal' do
       [[/bar2/], /bar2/, ['bar2'], 'bar2'].each do |pattern|
-        configuration = accept_configuration_for(described_class, pattern: pattern)
-        expect(source).to_not reek_of(described_class, {}, configuration)
+        expect(source).to_not reek_of(described_class).with_config('accept' => pattern)
       end
     end
   end
@@ -110,8 +109,7 @@ RSpec.describe Reek::Smells::UncommunicativeParameterName do
 
     it 'reject smelly names via regex / strings given by list / literal' do
       [[/bar/], /bar/, ['bar'], 'bar'].each do |pattern|
-        configuration = reject_configuration_for(described_class, pattern: pattern)
-        expect(source).to reek_of(described_class, {}, configuration)
+        expect(source).to reek_of(described_class).with_config('reject' => pattern)
       end
     end
   end

data/spec/reek/smells/unused_private_method_spec.rb

@@ -4,12 +4,6 @@ require_lib 'reek/examiner'
 require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::UnusedPrivateMethod do
-  let(:configuration) do
-    test_configuration_for(
-      described_class =>
-        { Reek::Smells::SmellConfiguration::ENABLED_KEY => true }
-    )
-  end
   let(:detector) { build(:smell_detector, smell_type: :UnusedPrivateMethod) }
 
   it_should_behave_like 'SmellDetector'
@@ -24,32 +18,54 @@ RSpec.describe Reek::Smells::UnusedPrivateMethod do
         end
       EOF
 
-      expect(source).to reek_of(:UnusedPrivateMethod, { name: :start }, configuration)
-      expect(source).to reek_of(:UnusedPrivateMethod, { name: :drive }, configuration)
+      expect(source).to reek_of(:UnusedPrivateMethod, name: :start)
+      expect(source).to reek_of(:UnusedPrivateMethod, name: :drive)
     end
 
-    it 'creates warnings correctly' do
+    it 'reports instance methods in the correct class' do
+      source = <<-EOF
+        class Car
+          class Engine
+            private
+            def start; end
+          end
+        end
+      EOF
+
+      expect(source).to reek_of(:UnusedPrivateMethod, context: 'Car::Engine', name: :start)
+      expect(source).not_to reek_of(:UnusedPrivateMethod, context: 'Car', name: :start)
+    end
+
+    it 'discounts calls to identically named methods in nested classes' do
       source = <<-EOF
         class Car
+          class Engine
+            def vroom
+              start
+            end
+            private
+            def start; end
+          end
           private
           def start; end
-          def drive; end
         end
       EOF
 
-      examiner = Reek::Examiner.new(source,
-                                    filter_by_smells: 'UnusedPrivateMethod',
-                                    configuration: configuration)
+      expect(source).not_to reek_of(:UnusedPrivateMethod, context: 'Car::Engine', name: :start)
+      expect(source).to reek_of(:UnusedPrivateMethod, context: 'Car', name: :start)
+    end
 
-      first_warning = examiner.smells.first
-      expect(first_warning.smell_type).to eq(Reek::Smells::UnusedPrivateMethod.smell_type)
-      expect(first_warning.parameters[:name]).to eq(:drive)
-      expect(first_warning.lines).to eq([4])
+    it 'creates warnings correctly' do
+      source = <<-EOF
+        class Car
+          private
+          def start; end
+          def drive; end
+        end
+      EOF
 
-      second_warning = examiner.smells.last
-      expect(second_warning.smell_type).to eq(Reek::Smells::UnusedPrivateMethod.smell_type)
-      expect(second_warning.parameters[:name]).to eq(:start)
-      expect(second_warning.lines).to eq([3])
+      expect(source).to reek_of(:UnusedPrivateMethod, name: :drive, lines: [4])
+      expect(source).to reek_of(:UnusedPrivateMethod, name: :start, lines: [3])
     end
   end
 
@@ -64,13 +80,8 @@ RSpec.describe Reek::Smells::UnusedPrivateMethod do
         end
       EOF
 
-      examiner = Reek::Examiner.new(source,
-                                    filter_by_smells: 'UnusedPrivateMethod',
-                                    configuration: configuration)
-
-      expect(examiner.smells.size).to eq(1)
-      warning_for_drive = examiner.smells.first
-      expect(warning_for_drive.parameters[:name]).to eq(:drive)
+      expect(source).to reek_of(:UnusedPrivateMethod, name: :drive)
+      expect(source).not_to reek_of(:UnusedPrivateMethod, name: :start)
     end
   end
 
@@ -128,29 +139,17 @@ RSpec.describe Reek::Smells::UnusedPrivateMethod do
     end
 
     it 'excludes them via direct match in the app configuration' do
-      configuration = test_configuration_for(
-        described_class =>
-          {
-            Reek::Smells::SmellConfiguration::ENABLED_KEY => true,
-            Reek::Smells::SmellDetector::EXCLUDE_KEY => ['Car#drive']
-          }
-      )
-
-      expect(source).to reek_of(:UnusedPrivateMethod, { name: :start }, configuration)
-      expect(source).not_to reek_of(:UnusedPrivateMethod, { name: :drive }, configuration)
+      config = { Reek::Smells::SmellDetector::EXCLUDE_KEY => ['Car#drive'] }
+
+      expect(source).to reek_of(:UnusedPrivateMethod, name: :start).with_config(config)
+      expect(source).not_to reek_of(:UnusedPrivateMethod, name: :drive).with_config(config)
     end
 
     it 'excludes them via regex in the app configuration' do
-      configuration = test_configuration_for(
-        described_class =>
-          {
-            Reek::Smells::SmellConfiguration::ENABLED_KEY => true,
-            Reek::Smells::SmellDetector::EXCLUDE_KEY => [/drive/]
-          }
-      )
-
-      expect(source).to reek_of(:UnusedPrivateMethod, { name: :start }, configuration)
-      expect(source).not_to reek_of(:UnusedPrivateMethod, { name: :drive }, configuration)
+      config = { Reek::Smells::SmellDetector::EXCLUDE_KEY => [/drive/] }
+
+      expect(source).to reek_of(:UnusedPrivateMethod, name: :start).with_config(config)
+      expect(source).not_to reek_of(:UnusedPrivateMethod, name: :drive).with_config(config)
     end
   end
 end

data/spec/reek/smells/utility_function_spec.rb

@@ -218,13 +218,8 @@ RSpec.describe Reek::Smells::UtilityFunction do
   end
 
   describe 'disabling UtilityFunction via configuration for non-public methods' do
-    let(:configuration) do
-      default_directive = {
-        Reek::Smells::UtilityFunction => {
-          Reek::Smells::UtilityFunction::PUBLIC_METHODS_ONLY_KEY => true
-        }
-      }
-      Reek::Configuration::AppConfiguration.from_hash(default_directive)
+    let(:config) do
+      { Reek::Smells::UtilityFunction::PUBLIC_METHODS_ONLY_KEY => true }
     end
 
     context 'public methods' do
@@ -234,7 +229,7 @@ RSpec.describe Reek::Smells::UtilityFunction do
             def m1(a) a.to_s; end
           end
         EOS
-        expect(src).to reek_of(:UtilityFunction, { name: 'C#m1' }, configuration)
+        expect(src).to reek_of(:UtilityFunction, name: 'C#m1').with_config(config)
       end
     end
 
@@ -246,7 +241,7 @@ RSpec.describe Reek::Smells::UtilityFunction do
             def m1(a) a.to_s; end
           end
         EOS
-        expect(src).not_to reek_of(:UtilityFunction, {}, configuration)
+        expect(src).not_to reek_of(:UtilityFunction).with_config(config)
       end
     end
 
@@ -258,7 +253,7 @@ RSpec.describe Reek::Smells::UtilityFunction do
             def m1(a) a.to_s; end
           end
         EOS
-        expect(src).not_to reek_of(:UtilityFunction, {}, configuration)
+        expect(src).not_to reek_of(:UtilityFunction).with_config(config)
       end
     end
   end

data/spec/reek/spec/should_reek_of_spec.rb

@@ -32,6 +32,11 @@ RSpec.describe Reek::Spec::ShouldReekOf do
       it 'doesnt match a fragrant String' do
         expect(matcher.matches?(clean_code)).to be_falsey
       end
+
+      it 're-calculates matches every time' do
+        matcher.matches? smelly_code
+        expect(matcher.matches?(clean_code)).to be_falsey
+      end
     end
 
     context 'checking code in a File' do
@@ -117,4 +122,26 @@ RSpec.describe Reek::Spec::ShouldReekOf do
       end
     end
   end
+
+  it 'enables the smell detector to match automatically' do
+    default_config = Reek::Smells::UnusedPrivateMethod.default_config
+    expect(default_config[Reek::Smells::SmellConfiguration::ENABLED_KEY]).to be_falsy
+
+    expect('class C; private; def foo; end; end').to reek_of(:UnusedPrivateMethod)
+  end
+
+  describe '#with_config' do
+    let(:matcher) { Reek::Spec::ShouldReekOf.new(:UncommunicativeVariableName) }
+    let(:configured_matcher) { matcher.with_config('accept' => 'x') }
+
+    it 'uses the passed-in configuration for matching' do
+      expect(configured_matcher.matches?('def foo; q = 2; end')).to be_truthy
+      expect(configured_matcher.matches?('def foo; x = 2; end')).to be_falsey
+    end
+
+    it 'leaves the original matcher intact' do
+      expect(configured_matcher.matches?('def foo; x = 2; end')).to be_falsey
+      expect(matcher.matches?('def foo; x = 2; end')).to be_truthy
+    end
+  end
 end