reek 1.5.1 → 1.6.0

data/spec/reek/configuration/configuration_file_finder_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'reek/cli/application'
+
+include Reek::Cli
+include Reek::Configuration
+
+describe ConfigurationFileFinder do
+  describe '.find' do
+    let(:sample_config_path) { Pathname.new('spec/samples/simple_configuration.reek') }
+    let(:config_path_same_level) { Pathname.new('spec/samples/simple_configuration.reek') }
+    let(:options) { double(config_file: sample_config_path) }
+    let(:application_with_options) { double(options: options) }
+    let(:application_without_options) { nil }
+
+    it 'should return the config file we passed as cli option if given' do
+      expect(ConfigurationFileFinder.find(application_with_options)).to eq(sample_config_path)
+    end
+
+    it 'should return the first configuration file it can find in the current directory' do
+      allow(ConfigurationFileFinder).to receive(:detect_or_traverse_up).
+        and_return config_path_same_level
+
+      expect(ConfigurationFileFinder.find(application_without_options)).
+        to eq(config_path_same_level)
+    end
+
+    it 'should look in the HOME directory lastly' do
+      allow(ConfigurationFileFinder).to receive(:configuration_by_cli).and_return nil
+      allow(ConfigurationFileFinder).to receive(:configuration_in_file_system).and_return nil
+      expect(ConfigurationFileFinder).to receive(:configuration_in_home_directory).once
+
+      ConfigurationFileFinder.find application_without_options
+    end
+  end
+end

data/spec/reek/core/code_context_spec.rb

@@ -164,7 +164,7 @@ EOS
     let(:sniffer) { double('sniffer') }
 
     before :each do
-      allow(sniffer).to receive(:smell_class_name).and_return('DuplicateMethodCall')
+      allow(sniffer).to receive(:smell_type).and_return('DuplicateMethodCall')
       allow(exp).to receive(:comments).and_return(
         ':reek:DuplicateMethodCall: { allow_calls: [ puts ] }')
     end

data/spec/reek/core/module_context_spec.rb

@@ -6,7 +6,11 @@ include Reek::Core
 
 describe ModuleContext do
   it 'should report module name for smell in method' do
-    expect('module Fred; def simple(x) x + 1; end; end').to reek_of(:UncommunicativeParameterName, /x/, /simple/)
+    expect('
+      module Fred
+        def simple(x) x + 1; end
+      end
+    ').to reek_of(:UncommunicativeParameterName, /x/, /simple/)
   end
 
   it 'should not report module with empty class' do

data/spec/reek/core/smell_configuration_spec.rb

@@ -12,8 +12,8 @@ describe SmellConfiguration do
   context 'when overriding default configs' do
     before(:each) do
       @base_config = { 'enabled' => true, 'exclude' => [],
-                      'reject' => [/^.$/, /[0-9]$/, /[A-Z]/],
-                      'accept' => ['_'] }
+                       'reject' => [/^.$/, /[0-9]$/, /[A-Z]/],
+                       'accept' => ['_'] }
       @smell_config = SmellConfiguration.new(@base_config)
     end
 
@@ -21,27 +21,35 @@ describe SmellConfiguration do
     it { expect(@smell_config.merge!('enabled' => true)).to eq(@base_config) }
     it { expect(@smell_config.merge!('exclude' => [])).to eq(@base_config) }
     it { expect(@smell_config.merge!('accept' => ['_'])).to eq(@base_config) }
-    it { expect(@smell_config.merge!('reject' => [/^.$/, /[0-9]$/, /[A-Z]/])).to eq(@base_config) }
-    it { expect(@smell_config.merge!('enabled' => true, 'accept' => ['_'])).to eq(@base_config) }
+    it do
+      @smell_config = @smell_config.merge!('reject' => [/^.$/, /[0-9]$/, /[A-Z]/])
+      expect(@smell_config).to eq(@base_config)
+    end
+    it do
+      @smell_config = @smell_config.merge!('enabled' => true, 'accept' => ['_'])
+      expect(@smell_config).to eq(@base_config)
+    end
 
     it 'should override single values' do
-      expect(@smell_config.merge!('enabled' => false)).to eq('enabled' => false, 'exclude' => [],
-                                                          'reject' => [/^.$/, /[0-9]$/, /[A-Z]/],
-                                                          'accept' => ['_'])
+      @smell_config = @smell_config.merge!('enabled' => false)
+      expect(@smell_config).to eq('enabled' => false, 'exclude' => [],
+                                  'reject' => [/^.$/, /[0-9]$/, /[A-Z]/],
+                                  'accept' => ['_'])
     end
 
     it 'should override arrays of values' do
-      expect(@smell_config.merge!('reject' => [/^.$/, /[3-9]$/])).to eq('enabled' => true,
-                                                                        'exclude' => [],
-                                                                        'reject' => [/^.$/, /[3-9]$/],
-                                                                        'accept' => ['_'])
+      @smell_config = @smell_config.merge!('reject' => [/^.$/, /[3-9]$/])
+      expect(@smell_config).to eq('enabled' => true,
+                                  'exclude' => [],
+                                  'reject' => [/^.$/, /[3-9]$/],
+                                  'accept' => ['_'])
     end
 
     it 'should override multiple values' do
       expect(@smell_config.merge!('enabled' => false, 'accept' => [/[A-Z]$/])).to eq(
                            'enabled' => false, 'exclude' => [],
-                            'reject' => [/^.$/, /[0-9]$/, /[A-Z]/],
-                            'accept' => [/[A-Z]$/]
+                           'reject' => [/^.$/, /[0-9]$/, /[A-Z]/],
+                           'accept' => [/[A-Z]$/]
       )
     end
   end

data/spec/reek/core/warning_collector_spec.rb

@@ -17,7 +17,10 @@ describe WarningCollector do
 
   context 'with one warning' do
     before :each do
-      @warning = Reek::SmellWarning.new('ControlCouple', 'fred', [1, 2, 3], 'hello')
+      @warning = Reek::SmellWarning.new(Reek::Smells::FeatureEnvy.new(''),
+                                        context: 'fred',
+                                        lines:   [1, 2, 3],
+                                        message: 'hello')
       @collector.found_smell(@warning)
     end
     it 'reports that warning' do

data/spec/reek/examiner_spec.rb

@@ -37,7 +37,7 @@ shared_examples_for 'one smell found' do
     expect(@examiner.smells.length).to eq(1)
   end
   it 'reports the correct smell' do
-    expect(@examiner.smells[0].smell_class).to eq(@expected_first_smell)
+    expect(@examiner.smells[0].smell_category).to eq(@expected_first_smell)
   end
 
   it_should_behave_like 'supports the deprecated api'
@@ -66,6 +66,12 @@ describe Examiner do
   end
 
   context 'with a partially masked smelly Dir' do
+    around(:each) do |example|
+      with_test_config('spec/samples/all_but_one_masked/masked.reek') do
+        example.run
+      end
+    end
+
     before :each do
       smelly_dir = Dir['spec/samples/all_but_one_masked/*.rb']
       @examiner = Examiner.new(smelly_dir)
@@ -84,6 +90,12 @@ describe Examiner do
   end
 
   context 'with a smelly Dir masked by a dotfile' do
+    around(:each) do |example|
+      with_test_config('spec/samples/masked_by_dotfile/.reek') do
+        example.run
+      end
+    end
+
     before :each do
       smelly_dir = Dir['spec/samples/masked_by_dotfile/*.rb']
       @examiner = Examiner.new(smelly_dir)
@@ -93,6 +105,12 @@ describe Examiner do
   end
 
   context 'with a partially masked smelly File' do
+    around(:each) do |example|
+      with_test_config('spec/samples/all_but_one_masked/masked.reek') do
+        example.run
+      end
+    end
+
     before :each do
       smelly_file = File.new(Dir['spec/samples/all_but_one_masked/d*.rb'][0])
       @examiner = Examiner.new(smelly_file)

data/spec/reek/smell_warning_spec.rb

@@ -4,6 +4,10 @@ require 'reek/smell_warning'
 include Reek
 
 describe SmellWarning do
+  let(:duplication_detector)  { build(:smell_detector, smell_type: 'DuplicateMethodCall') }
+  let(:feature_envy_detector) { build(:smell_detector, smell_type: 'FeatureEnvy') }
+  let(:utility_function_detector) { build(:smell_detector, smell_type: 'UtilityFunction') }
+
   context 'sort order' do
     shared_examples_for 'first sorts ahead of second' do
       it 'hash differently' do
@@ -23,8 +27,8 @@ describe SmellWarning do
 
     context 'smells differing only by detector' do
       before :each do
-        @first = SmellWarning.new('Duplication', 'self', 27, 'self', false)
-        @second = SmellWarning.new('FeatureEnvy', 'self', 27, 'self', true)
+        @first  = build(:smell_warning, smell_detector: duplication_detector)
+        @second = build(:smell_warning, smell_detector: feature_envy_detector)
       end
 
       it_should_behave_like 'first sorts ahead of second'
@@ -32,8 +36,10 @@ describe SmellWarning do
 
     context 'smells differing only by context' do
       before :each do
-        @first = SmellWarning.new('FeatureEnvy', 'first', 27, 'self', true)
-        @second = SmellWarning.new('FeatureEnvy', 'second', 27, 'self', false)
+        @first  = build(:smell_warning, smell_detector: duplication_detector,
+                                        context: 'first')
+        @second = build(:smell_warning, smell_detector: duplication_detector,
+                                        context: 'second')
       end
 
       it_should_behave_like 'first sorts ahead of second'
@@ -41,8 +47,12 @@ describe SmellWarning do
 
     context 'smells differing only by message' do
       before :each do
-        @first = SmellWarning.new('FeatureEnvy', 'context', 27, 'first', true)
-        @second = SmellWarning.new('FeatureEnvy', 'context', 27, 'second', false)
+        @first  = build(:smell_warning, smell_detector: duplication_detector,
+                                        context: 'ctx',
+                                        message: 'first message')
+        @second = build(:smell_warning, smell_detector: duplication_detector,
+                                        context: 'ctx',
+                                        message: 'second message')
       end
 
       it_should_behave_like 'first sorts ahead of second'
@@ -50,8 +60,10 @@ describe SmellWarning do
 
     context 'message takes precedence over smell name' do
       before :each do
-        @first = SmellWarning.new('UtilityFunction', 'context', 27, 'first', true)
-        @second = SmellWarning.new('FeatureEnvy', 'context', 27, 'second', false)
+        @first  = build(:smell_warning, smell_detector: utility_function_detector,
+                                        message: 'first message')
+        @second = build(:smell_warning, smell_detector: feature_envy_detector,
+                                        message: 'second message')
       end
 
       it_should_behave_like 'first sorts ahead of second'
@@ -59,8 +71,18 @@ describe SmellWarning do
 
     context 'smells differing everywhere' do
       before :each do
-        @first = SmellWarning.new('UncommunicativeName', 'Dirty', 27, "has the variable name '@s'", true)
-        @second = SmellWarning.new('Duplication', 'Dirty#a', 27, 'calls @s.title twice', false)
+        uncommunicative_name_detector = build(:smell_detector,
+                                              smell_type: 'UncommunicativeVariableName',
+                                              source: true)
+        duplication_detector = build(:smell_detector,
+                                     smell_type: 'DuplicateMethodCall',
+                                     source: false)
+        @first  = build(:smell_warning, smell_detector: uncommunicative_name_detector,
+                                        context: 'Dirty',
+                                        message: "has the variable name '@s'")
+        @second = build(:smell_warning, smell_detector: duplication_detector,
+                                        context: 'Dirty#a',
+                                        message: 'calls @s.title twice')
       end
 
       it_should_behave_like 'first sorts ahead of second'
@@ -77,8 +99,8 @@ describe SmellWarning do
     end
 
     shared_examples_for 'common fields' do
-      it 'includes the smell class' do
-        expect(@yaml).to match(/class:\s*FeatureEnvy/)
+      it 'includes the smell type' do
+        expect(@yaml).to match(/smell_type:\s*FeatureEnvy/)
       end
       it 'includes the context' do
         expect(@yaml).to match(/context:\s*#{@context_name}/)
@@ -96,17 +118,20 @@ describe SmellWarning do
     context 'with all details specified' do
       before :each do
         @source = 'a/ruby/source/file.rb'
-        @subclass = 'TooManyParties'
+        @smell_type = 'FeatureEnvy'
         @parameters = { 'one' => 34, 'two' => 'second' }
-        @warning = SmellWarning.new(@class, @context_name, @lines, @message,
-                                    @source, @subclass, @parameters)
+        @detector = Reek::Smells::FeatureEnvy.new @source
+        @warning = SmellWarning.new(@detector, context: @context_name,
+                                               lines: @lines,
+                                               message: @message,
+                                               parameters: @parameters)
         @yaml = @warning.to_yaml
       end
 
       it_should_behave_like 'common fields'
 
-      it 'includes the subclass' do
-        expect(@yaml).to match(/subclass:\s*#{@subclass}/)
+      it 'includes the smell type' do
+        expect(@yaml).to match(/smell_type:\s*#{@smell_type}/)
       end
       it 'includes the source' do
         expect(@yaml).to match(/source:\s*#{@source}/)
@@ -117,24 +142,5 @@ describe SmellWarning do
         end
       end
     end
-
-    context 'with all defaults used' do
-      before :each do
-        warning = SmellWarning.new(@class, @context_name, @lines, @message)
-        @yaml = warning.to_yaml
-      end
-
-      it_should_behave_like 'common fields'
-
-      it 'includes no subclass' do
-        expect(@yaml).to match(/subclass: ["']{2}/)
-      end
-      it 'includes no source' do
-        expect(@yaml).to match(/source: ["']{2}/)
-      end
-      it 'includes empty parameters' do
-        expect(@yaml).not_to match(/parameter/)
-      end
-    end
   end
 end

data/spec/reek/smells/attribute_spec.rb

@@ -36,15 +36,19 @@ describe Attribute do
       it 'records only that attribute' do
         expect(@smells.length).to eq(1)
       end
+
       it 'reports the attribute name' do
-        expect(@smells[0].smell[Attribute::ATTRIBUTE_KEY]).to eq(@attr_name)
+        expect(@smells[0].parameters[:name]).to eq(@attr_name)
       end
+
       it 'reports the declaration line number' do
         expect(@smells[0].lines).to eq([1])
       end
+
       it 'reports the correct smell class' do
-        expect(@smells[0].smell_class).to eq(Attribute::SMELL_CLASS)
+        expect(@smells[0].smell_category).to eq(Attribute.smell_category)
       end
+
       it 'reports the context fq name' do
         expect(@smells[0].context).to eq('Fred')
       end

data/spec/reek/smells/boolean_parameter_spec.rb

@@ -9,34 +9,34 @@ describe BooleanParameter do
     context 'in a method' do
       it 'reports a parameter defaulted to true' do
         src = 'def cc(arga = true) end'
-        expect(src).to smell_of(BooleanParameter, BooleanParameter::PARAMETER_KEY => 'arga')
+        expect(src).to smell_of(BooleanParameter, name: 'arga')
       end
       it 'reports a parameter defaulted to false' do
         src = 'def cc(arga = false) end'
-        expect(src).to smell_of(BooleanParameter, BooleanParameter::PARAMETER_KEY => 'arga')
+        expect(src).to smell_of(BooleanParameter, name: 'arga')
       end
       it 'reports two parameters defaulted to booleans' do
         src = 'def cc(nowt, arga = true, argb = false, &blk) end'
         expect(src).to smell_of(BooleanParameter,
-                                { BooleanParameter::PARAMETER_KEY => 'arga' },
-                                BooleanParameter::PARAMETER_KEY => 'argb')
+                                { name: 'arga' },
+                                { name: 'argb' })
       end
     end
 
     context 'in a singleton method' do
       it 'reports a parameter defaulted to true' do
         src = 'def self.cc(arga = true) end'
-        expect(src).to smell_of(BooleanParameter, BooleanParameter::PARAMETER_KEY => 'arga')
+        expect(src).to smell_of(BooleanParameter, name: 'arga')
       end
       it 'reports a parameter defaulted to false' do
         src = 'def fred.cc(arga = false) end'
-        expect(src).to smell_of(BooleanParameter, BooleanParameter::PARAMETER_KEY => 'arga')
+        expect(src).to smell_of(BooleanParameter, name: 'arga')
       end
       it 'reports two parameters defaulted to booleans' do
         src = 'def Module.cc(nowt, arga = true, argb = false, &blk) end'
         expect(src).to smell_of(BooleanParameter,
-                                { BooleanParameter::PARAMETER_KEY => 'arga' },
-                                BooleanParameter::PARAMETER_KEY => 'argb')
+                                { name: 'arga' },
+                                { name: 'argb' })
       end
     end
   end
@@ -55,11 +55,10 @@ describe BooleanParameter do
       @detector.examine(ctx)
       smells = @detector.smells_found.to_a
       expect(smells.length).to eq(1)
-      expect(smells[0].smell_class).to eq(BooleanParameter::SMELL_CLASS)
-      expect(smells[0].smell[BooleanParameter::PARAMETER_KEY]).to eq('arga')
+      expect(smells[0].smell_category).to eq(BooleanParameter.smell_category)
+      expect(smells[0].parameters[:name]).to eq('arga')
       expect(smells[0].source).to eq(@source_name)
-      expect(smells[0].smell_class).to eq(BooleanParameter::SMELL_CLASS)
-      expect(smells[0].subclass).to eq(BooleanParameter::SMELL_SUBCLASS)
+      expect(smells[0].smell_type).to eq(BooleanParameter.smell_type)
       expect(smells[0].lines).to eq([1])
     end
   end

data/spec/reek/smells/class_variable_spec.rb

@@ -36,7 +36,7 @@ describe ClassVariable do
         expect(@smells.length).to eq(1)
       end
       it 'records the variable name' do
-        expect(@smells[0].smell[ClassVariable::VARIABLE_KEY]).to eq(@class_variable)
+        expect(@smells[0].parameters[:name]).to eq(@class_variable)
       end
     end
 
@@ -67,7 +67,12 @@ describe ClassVariable do
 
       context "declared and used in a #{scope}" do
         before :each do
-          @src = "#{scope} Fred; #{@class_variable} = {}; def jim() #{@class_variable} = {}; end; end"
+          @src = "
+            #{scope} Fred
+              #{@class_variable} = {}
+              def jim() #{@class_variable} = {}; end
+            end
+          "
         end
 
         it_should_behave_like 'one variable found'
@@ -75,7 +80,12 @@ describe ClassVariable do
 
       context "used twice in a #{scope}" do
         before :each do
-          @src = "#{scope} Fred; def jeff() #{@class_variable} = {}; end; def jim() #{@class_variable} = {}; end; end"
+          @src = "
+            #{scope} Fred
+              def jeff() #{@class_variable} = {}; end
+              def jim()  #{@class_variable} = {}; end
+            end
+          "
         end
 
         it_should_behave_like 'one variable found'
@@ -92,9 +102,9 @@ EOS
     ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
     @warning = @detector.examine_context(ctx)[0]
     expect(@warning.source).to eq(@source_name)
-    expect(@warning.smell_class).to eq(ClassVariable::SMELL_CLASS)
-    expect(@warning.subclass).to eq(ClassVariable::SMELL_SUBCLASS)
-    expect(@warning.smell[ClassVariable::VARIABLE_KEY]).to eq(@class_variable)
+    expect(@warning.smell_category).to eq(ClassVariable.smell_category)
+    expect(@warning.smell_type).to eq(ClassVariable.smell_type)
+    expect(@warning.parameters[:name]).to eq(@class_variable)
     expect(@warning.lines).to eq([2])
   end
 end