reek 3.2.1 → 3.3.0

data/spec/reek/smells/duplicate_method_call_spec.rb

@@ -6,9 +6,10 @@ require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::DuplicateMethodCall do
   context 'when a smell is reported' do
-    before :each do
-      @source_name = 'dummy_source'
-      @detector = build(:smell_detector, smell_type: :DuplicateMethodCall, source: @source_name)
+    let(:detector) { build(:smell_detector, smell_type: :DuplicateMethodCall, source: source_name) }
+    let(:source_name) { 'dummy_source' }
+
+    let(:warning) do
       src = <<-EOS
         def double_thing(other)
           other[@thing]
@@ -17,20 +18,20 @@ RSpec.describe Reek::Smells::DuplicateMethodCall do
         end
       EOS
       ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      smells = @detector.examine_context(ctx)
+      smells = detector.examine_context(ctx)
       expect(smells.length).to eq(1)
-      @warning = smells[0]
+      smells.first
     end
 
     it_should_behave_like 'SmellDetector'
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the call' do
-      expect(@warning.parameters[:name]).to eq('other[@thing]')
+      expect(warning.parameters[:name]).to eq('other[@thing]')
     end
 
     it 'reports the correct lines' do
-      expect(@warning.lines).to eq([2, 4])
+      expect(warning.lines).to eq([2, 4])
     end
   end
 

data/spec/reek/smells/feature_envy_spec.rb

@@ -213,53 +213,52 @@ RSpec.describe Reek::Smells::FeatureEnvy do
 end
 
 RSpec.describe Reek::Smells::FeatureEnvy do
-  before(:each) do
-    @source_name = 'string'
-    @detector = build(:smell_detector, smell_type: :FeatureEnvy, source: @source_name)
-  end
+  let(:detector) { build(:smell_detector, smell_type: :FeatureEnvy, source: source_name) }
+  let(:source_name) { 'string' }
 
   it_should_behave_like 'SmellDetector'
 
   context 'when a smell is reported' do
-    before :each do
-      @receiver = 'other'
+    let(:receiver) { 'other' }
+
+    let(:smells) do
       src = <<-EOS
         def envious(other)
-          #{@receiver}.call
+          #{receiver}.call
           self.do_nothing
-          #{@receiver}.other
-          #{@receiver}.fred
+          #{receiver}.other
+          #{receiver}.fred
         end
       EOS
-      @smells = Reek::Examiner.new(src, ['FeatureEnvy']).smells
+      Reek::Examiner.new(src, ['FeatureEnvy']).smells
     end
 
     it 'reports only that smell' do
-      expect(@smells.length).to eq(1)
+      expect(smells.length).to eq(1)
     end
 
     it 'reports the source' do
-      expect(@smells[0].source).to eq(@source_name)
+      expect(smells[0].source).to eq(source_name)
     end
 
     it 'reports the smell class' do
-      expect(@smells[0].smell_category).to eq(described_class.smell_category)
+      expect(smells[0].smell_category).to eq(described_class.smell_category)
     end
 
     it 'reports the smell sub class' do
-      expect(@smells[0].smell_type).to eq(described_class.smell_type)
+      expect(smells[0].smell_type).to eq(described_class.smell_type)
     end
 
     it 'reports the envious receiver' do
-      expect(@smells[0].parameters[:name]).to eq(@receiver)
+      expect(smells[0].parameters[:name]).to eq(receiver)
     end
 
     it 'reports the number of references' do
-      expect(@smells[0].parameters[:count]).to eq(3)
+      expect(smells[0].parameters[:count]).to eq(3)
     end
 
     it 'reports the referring lines' do
-      expect(@smells[0].lines).to eq([2, 4, 5])
+      expect(smells[0].lines).to eq([2, 4, 5])
     end
   end
 end

data/spec/reek/smells/irresponsible_module_spec.rb

@@ -184,10 +184,8 @@ RSpec.describe Reek::Smells::IrresponsibleModule do
   end
 
   context 'when a smell is reported' do
-    before do
-      @source_name = 'dummy_source'
-      @detector = build(:smell_detector, smell_type: :IrresponsibleModule, source: @source_name)
-    end
+    let(:detector) { build(:smell_detector, smell_type: :IrresponsibleModule, source: source_name) }
+    let(:source_name) { 'dummy_source' }
 
     it_should_behave_like 'SmellDetector'
   end

data/spec/reek/smells/long_parameter_list_spec.rb

@@ -74,15 +74,13 @@ RSpec.describe Reek::Smells::LongParameterList do
 end
 
 RSpec.describe Reek::Smells::LongParameterList do
-  before(:each) do
-    @source_name = 'dummy_source'
-    @detector = build(:smell_detector, smell_type: :LongParameterList, source: @source_name)
-  end
+  let(:detector) { build(:smell_detector, smell_type: :LongParameterList, source: source_name) }
+  let(:source_name) { 'dummy_source' }
 
   it_should_behave_like 'SmellDetector'
 
   context 'when a smell is reported' do
-    before :each do
+    let(:warning) do
       src = <<-EOS
         def badguy(arga, argb, argc, argd)
           f(3)
@@ -90,18 +88,17 @@ RSpec.describe Reek::Smells::LongParameterList do
         end
       EOS
       ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      @smells = @detector.examine_context(ctx)
-      @warning = @smells[0]
+      detector.examine_context(ctx).first
     end
 
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the number of parameters' do
-      expect(@warning.parameters[:count]).to eq(4)
+      expect(warning.parameters[:count]).to eq(4)
     end
 
     it 'reports the line number of the method' do
-      expect(@warning.lines).to eq([1])
+      expect(warning.lines).to eq([1])
     end
   end
 end

data/spec/reek/smells/long_yield_list_spec.rb

@@ -4,10 +4,8 @@ require_relative '../../../lib/reek/smells/long_yield_list'
 require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::LongYieldList do
-  before(:each) do
-    @source_name = 'dummy_source'
-    @detector = build(:smell_detector, smell_type: :LongYieldList, source: @source_name)
-  end
+  let(:detector) { build(:smell_detector, smell_type: :LongYieldList, source: source_name) }
+  let(:source_name) { 'dummy_source' }
 
   it_should_behave_like 'SmellDetector'
 
@@ -31,7 +29,7 @@ RSpec.describe Reek::Smells::LongYieldList do
   end
 
   context 'when a smells is reported' do
-    before :each do
+    let(:warning) do
       src = <<-EOS
         def simple(arga, argb, &blk)
           f(3)
@@ -39,15 +37,14 @@ RSpec.describe Reek::Smells::LongYieldList do
           end
       EOS
       ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      @smells = @detector.examine_context(ctx)
-      @warning = @smells[0]
+      detector.examine_context(ctx).first
     end
 
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the correct values' do
-      expect(@warning.parameters[:count]).to eq(4)
-      expect(@warning.lines).to eq([3])
+      expect(warning.parameters[:count]).to eq(4)
+      expect(warning.lines).to eq([3])
     end
   end
 end

data/spec/reek/smells/nested_iterators_spec.rb

@@ -123,11 +123,11 @@ RSpec.describe Reek::Smells::NestedIterators do
   end
 
   context 'when the allowed nesting depth is 3' do
-    before :each do
-      @config = { Reek::Smells::NestedIterators =>
-                  { Reek::Smells::NestedIterators::MAX_ALLOWED_NESTING_KEY => 3 } }
+    let(:configuration) do
+      config = { Reek::Smells::NestedIterators =>
+                 { Reek::Smells::NestedIterators::MAX_ALLOWED_NESTING_KEY => 3 } }
+      test_configuration_for(config)
     end
-    let(:configuration) { test_configuration_for(@config) }
 
     it 'should not report nested iterators 2 levels deep' do
       src = <<-EOS
@@ -161,11 +161,11 @@ RSpec.describe Reek::Smells::NestedIterators do
   end
 
   context 'when ignoring iterators' do
-    before :each do
-      @config = { Reek::Smells::NestedIterators =>
-                  { Reek::Smells::NestedIterators::IGNORE_ITERATORS_KEY => ['ignore_me'] } }
+    let(:configuration) do
+      config = { Reek::Smells::NestedIterators =>
+                 { Reek::Smells::NestedIterators::IGNORE_ITERATORS_KEY => ['ignore_me'] } }
+      test_configuration_for(config)
     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'
@@ -207,15 +207,13 @@ RSpec.describe Reek::Smells::NestedIterators do
 end
 
 RSpec.describe Reek::Smells::NestedIterators do
-  before(:each) do
-    @source_name = 'dummy_source'
-    @detector = build(:smell_detector, smell_type: :NestedIterators, source: @source_name)
-  end
+  let(:detector) { build(:smell_detector, smell_type: :NestedIterators, source: source_name) }
+  let(:source_name) { 'dummy_source' }
 
   it_should_behave_like 'SmellDetector'
 
   context 'when a smell is reported' do
-    before :each do
+    let(:warning) do
       src = <<-EOS
         def fred()
           nothing.each do |item|
@@ -224,14 +222,14 @@ RSpec.describe Reek::Smells::NestedIterators do
         end
       EOS
       ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      @warning = @detector.examine_context(ctx)[0]
+      detector.examine_context(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.lines).to eq([3])
+      expect(warning.parameters[:count]).to eq(2)
+      expect(warning.lines).to eq([3])
     end
   end
 end

data/spec/reek/smells/repeated_conditional_spec.rb

@@ -5,10 +5,8 @@ require_relative 'smell_detector_shared'
 require_relative '../../../lib/reek/source/source_code'
 
 RSpec.describe Reek::Smells::RepeatedConditional do
-  before(:each) do
-    @source_name = 'dummy_source'
-    @detector = build(:smell_detector, smell_type: :RepeatedConditional, source: @source_name)
-  end
+  let(:detector) { build(:smell_detector, smell_type: :RepeatedConditional, source: source_name) }
+  let(:source_name) { 'dummy_source' }
 
   it_should_behave_like 'SmellDetector'
 
@@ -16,7 +14,7 @@ RSpec.describe Reek::Smells::RepeatedConditional 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)
+      expect(detector.conditional_counts(ctx).length).to eq(0)
     end
   end
 
@@ -24,7 +22,7 @@ RSpec.describe Reek::Smells::RepeatedConditional 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)
+      expect(detector.conditional_counts(ctx).length).to eq(0)
     end
   end
 
@@ -32,53 +30,55 @@ RSpec.describe Reek::Smells::RepeatedConditional 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)
+      expect(detector.conditional_counts(ctx).length).to eq(0)
     end
   end
 
   context 'with three identical conditionals' do
-    before :each do
-      @cond = '@field == :sym'
-      @cond_expr = Reek::Source::SourceCode.from(@cond).syntax_tree
+    let(:cond) { '@field == :sym' }
+    let(:cond_expr) { Reek::Source::SourceCode.from(cond).syntax_tree }
+
+    let(:conds) do
       src = <<-EOS
         class Scrunch
           def first
             puts "hello" if @debug
-            return #{@cond} ? 0 : 3;
+            return #{cond} ? 0 : 3;
           end
           def second
-            if #{@cond}
+            if #{cond}
               @other += " quarts"
             end
           end
           def third
-            raise 'flu!' unless #{@cond}
+            raise 'flu!' unless #{cond}
           end
         end
       EOS
 
       ast = Reek::Source::SourceCode.from(src).syntax_tree
-      @ctx = Reek::Context::CodeContext.new(nil, ast)
-      @conds = @detector.conditional_counts(@ctx)
+      ctx = Reek::Context::CodeContext.new(nil, ast)
+      detector.conditional_counts(ctx)
     end
 
     it 'finds both conditionals' do
-      expect(@conds.length).to eq(2)
+      expect(conds.length).to eq(2)
     end
 
     it 'returns the condition expr' do
-      expect(@conds.keys[1]).to eq(@cond_expr)
+      expect(conds.keys[1]).to eq(cond_expr)
     end
 
     it 'knows there are three copies' do
-      expect(@conds.values[1].length).to eq(3)
+      expect(conds.values[1].length).to eq(3)
     end
   end
 
   context 'with a matching if and case' do
-    before :each do
-      cond = '@field == :sym'
-      @cond_expr = Reek::Source::SourceCode.from(cond).syntax_tree
+    let(:cond) { '@field == :sym' }
+    let(:cond_expr) { Reek::Source::SourceCode.from(cond).syntax_tree }
+
+    let(:conds) do
       src = <<-EOS
         class Scrunch
           def alpha
@@ -95,19 +95,19 @@ RSpec.describe Reek::Smells::RepeatedConditional do
 
       ast = Reek::Source::SourceCode.from(src).syntax_tree
       ctx = Reek::Context::CodeContext.new(nil, ast)
-      @conds = @detector.conditional_counts(ctx)
+      detector.conditional_counts(ctx)
     end
 
     it 'finds exactly one conditional' do
-      expect(@conds.length).to eq(1)
+      expect(conds.length).to eq(1)
     end
 
     it 'returns the condition expr' do
-      expect(@conds.keys[0]).to eq(@cond_expr)
+      expect(conds.keys[0]).to eq(cond_expr)
     end
 
     it 'knows there are two copies' do
-      expect(@conds.values[0].length).to eq(2)
+      expect(conds.values[0].length).to eq(2)
     end
   end
 end

data/spec/reek/smells/smell_configuration_spec.rb

@@ -8,47 +8,52 @@ RSpec.describe Reek::Smells::SmellConfiguration do
   end
 
   context 'when overriding default configs' do
-    before(:each) do
-      @base_config = { 'enabled' => true, 'exclude' => [],
-                       'reject' => [/^.$/, /[0-9]$/, /[A-Z]/],
-                       'accept' => ['_'] }
-      @smell_config = described_class.new(@base_config)
+    let(:base_config) do
+      {
+        'accept'  => ['_'],
+        'enabled' => true,
+        'exclude' => [],
+        'reject'  => [/^.$/, /[0-9]$/, /[A-Z]/]
+      }
     end
 
-    it { expect(@smell_config.merge!({})).to eq(@base_config) }
-    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) }
+    let(:smell_config) { described_class.new(base_config) }
+
+    it { expect(smell_config.merge!({})).to eq(base_config) }
+    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 do
-      @smell_config = @smell_config.merge!('reject' => [/^.$/, /[0-9]$/, /[A-Z]/])
-      expect(@smell_config).to eq(@base_config)
+      updated = smell_config.merge!('reject' => [/^.$/, /[0-9]$/, /[A-Z]/])
+      expect(updated).to eq(base_config)
     end
     it do
-      @smell_config = @smell_config.merge!('enabled' => true, 'accept' => ['_'])
-      expect(@smell_config).to eq(@base_config)
+      updated = smell_config.merge!('accept' => ['_'], 'enabled' => true)
+      expect(updated).to eq(base_config)
     end
 
     it 'should override single values' do
-      @smell_config = @smell_config.merge!('enabled' => false)
-      expect(@smell_config).to eq('enabled' => false, 'exclude' => [],
-                                  'reject' => [/^.$/, /[0-9]$/, /[A-Z]/],
-                                  'accept' => ['_'])
+      updated = smell_config.merge!('enabled' => false)
+      expect(updated).to eq('accept'  => ['_'],
+                            'enabled' => false,
+                            'exclude' => [],
+                            'reject'  => [/^.$/, /[0-9]$/, /[A-Z]/])
     end
 
     it 'should override arrays of values' do
-      @smell_config = @smell_config.merge!('reject' => [/^.$/, /[3-9]$/])
-      expect(@smell_config).to eq('enabled' => true,
-                                  'exclude' => [],
-                                  'reject' => [/^.$/, /[3-9]$/],
-                                  'accept' => ['_'])
+      updated = smell_config.merge!('reject' => [/^.$/, /[3-9]$/])
+      expect(updated).to eq('accept'  => ['_'],
+                            'enabled' => true,
+                            'exclude' => [],
+                            'reject'  => [/^.$/, /[3-9]$/])
     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]$/]
-      )
+      updated = smell_config.merge!('accept' => [/[A-Z]$/], 'enabled' => false)
+      expect(updated).to eq('accept'  => [/[A-Z]$/],
+                            'enabled' => false,
+                            'exclude' => [],
+                            'reject'  => [/^.$/, /[0-9]$/, /[A-Z]/])
     end
   end
 end