reek 3.2.1 → 3.3.0

data/spec/reek/context/method_context_spec.rb

@@ -63,33 +63,29 @@ RSpec.describe Reek::Context::MethodContext do
     end
 
     context 'with 1 default' do
-      before :each do
-        src = 'def meth(arga, argb=456, &blk) end'
-        @defaults = assignments_from(src)
-      end
+      let(:defaults) { assignments_from('def meth(arga, argb=456, &blk) end') }
 
       it 'returns the param-value pair' do
-        expect(@defaults[0]).to eq [:argb, s(:int, 456)]
+        expect(defaults[0]).to eq [:argb, s(:int, 456)]
       end
 
       it 'returns the nothing else' do
-        expect(@defaults.length).to eq(1)
+        expect(defaults.length).to eq(1)
       end
     end
 
     context 'with 2 defaults' do
-      before :each do
-        src = 'def meth(arga=123, argb=456, &blk) end'
-        @defaults = assignments_from(src)
+      let(:defaults) do
+        assignments_from('def meth(arga=123, argb=456, &blk) end')
       end
 
       it 'returns both param-value pairs' do
-        expect(@defaults[0]).to eq [:arga, s(:int, 123)]
-        expect(@defaults[1]).to eq [:argb, s(:int, 456)]
+        expect(defaults[0]).to eq [:arga, s(:int, 123)]
+        expect(defaults[1]).to eq [:argb, s(:int, 456)]
       end
 
       it 'returns nothing else' do
-        expect(@defaults.length).to eq(2)
+        expect(defaults.length).to eq(2)
       end
     end
   end

data/spec/reek/context/module_context_spec.rb

@@ -8,7 +8,7 @@ RSpec.describe Reek::Context::ModuleContext do
       module Fred
         def simple(x) x + 1; end
       end
-    ').to reek_of(:UncommunicativeParameterName,  name: 'x')
+    ').to reek_of(:UncommunicativeParameterName, name: 'x')
   end
 
   it 'should not report module with empty class' do

data/spec/reek/context/root_context_spec.rb

@@ -2,15 +2,11 @@ require_relative '../../spec_helper'
 require_relative '../../../lib/reek/context/root_context'
 
 RSpec.describe Reek::Context::RootContext do
-  before :each do
-    src = 'foo = 1'
-    ast = Reek::Source::SourceCode.from(src).syntax_tree
-    @root = Reek::Context::RootContext.new(ast)
-  end
-
   context 'full_name' do
     it 'reports full context' do
-      expect(@root.full_name).to eq('')
+      ast = Reek::Source::SourceCode.from('foo = 1').syntax_tree
+      root = Reek::Context::RootContext.new(ast)
+      expect(root.full_name).to eq('')
     end
   end
 end

data/spec/reek/examiner_spec.rb

@@ -3,64 +3,53 @@ require_relative '../../lib/reek/examiner'
 
 RSpec.shared_examples_for 'no smells found' do
   it 'is not smelly' do
-    expect(@examiner).not_to be_smelly
+    expect(examiner).not_to be_smelly
   end
   it 'finds no smells' do
-    expect(@examiner.smells.length).to eq(0)
+    expect(examiner.smells.length).to eq(0)
   end
 end
 
 RSpec.shared_examples_for 'one smell found' do
   it 'is smelly' do
-    expect(@examiner).to be_smelly
+    expect(examiner).to be_smelly
   end
   it 'reports the smell' do
-    expect(@examiner.smells.length).to eq(1)
+    expect(examiner.smells.length).to eq(1)
   end
   it 'reports the correct smell' do
-    expect(@examiner.smells[0].smell_category).to eq(@expected_first_smell)
+    expect(examiner.smells[0].smell_category).to eq(expected_first_smell)
   end
 end
 
 RSpec.describe Reek::Examiner do
-  before :each do
-    @expected_first_smell = 'NestedIterators'
-  end
+  let(:expected_first_smell) { 'NestedIterators' }
 
   context 'with a fragrant String' do
-    before :each do
-      @examiner = described_class.new('def good() true; end')
-    end
+    let(:examiner) { described_class.new('def good() true; end') }
 
     it_should_behave_like 'no smells found'
   end
 
   context 'with a smelly String' do
-    before :each do
-      @examiner = described_class.new('def fine() y = 4; end')
-      @expected_first_smell = 'UncommunicativeName'
-    end
+    let(:examiner) { described_class.new('def fine() y = 4; end') }
+    let(:expected_first_smell) { 'UncommunicativeName' }
 
     it_should_behave_like 'one smell found'
   end
 
   context 'with a partially masked smelly File' do
-    let(:path) { SAMPLES_PATH.join('all_but_one_masked/masked.reek') }
     let(:configuration) { test_configuration_for(path) }
-
-    before :each do
-      smelly_file = Pathname.glob(SAMPLES_PATH.join('all_but_one_masked/d*.rb')).first
-      @examiner = described_class.new(smelly_file, [], configuration: configuration)
-    end
+    let(:examiner) { described_class.new(smelly_file, [], configuration: configuration) }
+    let(:path) { SAMPLES_PATH.join('all_but_one_masked/masked.reek') }
+    let(:smelly_file) { Pathname.glob(SAMPLES_PATH.join('all_but_one_masked/d*.rb')).first }
 
     it_should_behave_like 'one smell found'
   end
 
   context 'with a fragrant File' do
-    before :each do
-      clean_file = Pathname.glob(SAMPLES_PATH.join('three_clean_files/*.rb')).first
-      @examiner = described_class.new(clean_file)
-    end
+    let(:clean_file) { Pathname.glob(SAMPLES_PATH.join('three_clean_files/*.rb')).first }
+    let(:examiner) { described_class.new(clean_file) }
 
     it_should_behave_like 'no smells found'
   end

data/spec/reek/smells/attribute_spec.rb

@@ -3,10 +3,8 @@ require_relative '../../../lib/reek/smells/attribute'
 require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::Attribute do
-  before(:each) do
-    @source_name = 'dummy_source'
-    @detector = build(:smell_detector, smell_type: :Attribute, source: @source_name)
-  end
+  let(:detector) { build(:smell_detector, smell_type: :Attribute, source: source_name) }
+  let(:source_name) { 'dummy_source' }
 
   it_should_behave_like 'SmellDetector'
 

data/spec/reek/smells/boolean_parameter_spec.rb

@@ -66,22 +66,20 @@ RSpec.describe Reek::Smells::BooleanParameter do
   end
 
   context 'when a smell is reported' do
-    before(:each) do
-      @source_name = 'dummy_source'
-      @detector = build(:smell_detector, smell_type: :BooleanParameter, source: @source_name)
-    end
+    let(:detector) { build(:smell_detector, smell_type: :BooleanParameter, source: source_name) }
+    let(:source_name) { 'dummy_source' }
 
     it_should_behave_like 'SmellDetector'
 
     it 'reports the fields correctly' do
       src = 'def cc(arga = true) end'
       ctx = Reek::Context::MethodContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      @detector.examine(ctx)
-      smells = @detector.smells_found.to_a
+      detector.examine(ctx)
+      smells = detector.smells_found.to_a
       expect(smells.length).to eq(1)
       expect(smells[0].smell_category).to eq(described_class.smell_category)
       expect(smells[0].parameters[:name]).to eq('arga')
-      expect(smells[0].source).to eq(@source_name)
+      expect(smells[0].source).to eq(source_name)
       expect(smells[0].smell_type).to eq(described_class.smell_type)
       expect(smells[0].lines).to eq([1])
     end

data/spec/reek/smells/class_variable_spec.rb

@@ -4,90 +4,75 @@ require_relative '../../../lib/reek/context/module_context'
 require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::ClassVariable do
-  before :each do
-    @source_name = 'dummy_source'
-    @detector = build(:smell_detector, smell_type: :ClassVariable, source: @source_name)
-    @class_variable = '@@things'
-  end
+  let(:class_variable) { '@@things' }
+  let(:detector) { build(:smell_detector, smell_type: :ClassVariable, source: source_name) }
+  let(:source_name) { 'dummy_source' }
 
   it_should_behave_like 'SmellDetector'
 
   context 'with no class variables' do
     it 'records nothing in the class' do
       exp = ast(:class, :Fred)
-      expect(@detector.examine_context(Reek::Context::CodeContext.new(nil, exp))).to be_empty
+      expect(detector.examine_context(Reek::Context::CodeContext.new(nil, exp))).to be_empty
     end
 
     it 'records nothing in the module' do
       exp = ast(:module, :Fred)
-      expect(@detector.examine_context(Reek::Context::CodeContext.new(nil, exp))).to be_empty
+      expect(detector.examine_context(Reek::Context::CodeContext.new(nil, exp))).to be_empty
     end
   end
 
   context 'with one class variable' do
     shared_examples_for 'one variable found' do
-      before :each do
-        ast = Reek::Source::SourceCode.from(@src).syntax_tree
-        @smells = @detector.examine_context(Reek::Context::CodeContext.new(nil, ast))
-      end
+      let(:ast) { Reek::Source::SourceCode.from(src).syntax_tree }
+      let(:smells) { detector.examine_context(Reek::Context::CodeContext.new(nil, ast)) }
 
       it 'records only that class variable' do
-        expect(@smells.length).to eq(1)
+        expect(smells.length).to eq(1)
       end
 
       it 'records the variable name' do
-        expect(@smells[0].parameters[:name]).to eq(@class_variable)
+        expect(smells[0].parameters[:name]).to eq(class_variable)
       end
     end
 
     ['class', 'module'].each do |scope|
       context "declared in a #{scope}" do
-        before :each do
-          @src = "#{scope} Fred; #{@class_variable} = {}; end"
-        end
-
+        let(:src) { "#{scope} Fred; #{class_variable} = {}; end" }
         it_should_behave_like 'one variable found'
       end
 
       context "used in a #{scope}" do
-        before :each do
-          @src = "#{scope} Fred; def jim() #{@class_variable} = {}; end; end"
-        end
-
+        let(:src) { "#{scope} Fred; def jim() #{class_variable} = {}; end; end" }
         it_should_behave_like 'one variable found'
       end
 
       context "indexed in a #{scope}" do
-        before :each do
-          @src = "#{scope} Fred; def jim() #{@class_variable}[mash] = {}; end; end"
-        end
-
+        let(:src) { "#{scope} Fred; def jim() #{class_variable}[mash] = {}; end; end" }
         it_should_behave_like 'one variable found'
       end
 
       context "declared and used in a #{scope}" do
-        before :each do
-          @src = "
+        let(:src) do
+          <<-EOS
             #{scope} Fred
-              #{@class_variable} = {}
-              def jim() #{@class_variable} = {}; end
+              #{class_variable} = {}
+              def jim() #{class_variable} = {}; end
             end
-          "
+          EOS
         end
-
         it_should_behave_like 'one variable found'
       end
 
       context "used twice in a #{scope}" do
-        before :each do
-          @src = "
+        let(:src) do
+          <<-EOS
             #{scope} Fred
-              def jeff() #{@class_variable} = {}; end
-              def jim()  #{@class_variable} = {}; end
+              def jeff() #{class_variable} = {}; end
+              def jim()  #{class_variable} = {}; end
             end
-          "
+          EOS
         end
-
         it_should_behave_like 'one variable found'
       end
     end
@@ -96,15 +81,15 @@ RSpec.describe Reek::Smells::ClassVariable do
   it 'reports the correct fields' do
     src = <<-EOS
       module Fred
-        #{@class_variable} = {}
+        #{class_variable} = {}
       end
     EOS
     ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-    @warning = @detector.examine_context(ctx)[0]
-    expect(@warning.source).to eq(@source_name)
-    expect(@warning.smell_category).to eq(described_class.smell_category)
-    expect(@warning.smell_type).to eq(described_class.smell_type)
-    expect(@warning.parameters[:name]).to eq(@class_variable)
-    expect(@warning.lines).to eq([2])
+    warning = detector.examine_context(ctx)[0]
+    expect(warning.source).to eq(source_name)
+    expect(warning.smell_category).to eq(described_class.smell_category)
+    expect(warning.smell_type).to eq(described_class.smell_type)
+    expect(warning.parameters[:name]).to eq(class_variable)
+    expect(warning.lines).to eq([2])
   end
 end

data/spec/reek/smells/control_parameter_spec.rb

@@ -3,10 +3,8 @@ require_relative '../../../lib/reek/smells/control_parameter'
 require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::ControlParameter do
-  before(:each) do
-    @source_name = 'dummy_source'
-    @detector = build(:smell_detector, smell_type: :ControlParameter, source: @source_name)
-  end
+  let(:detector) { build(:smell_detector, smell_type: :ControlParameter, source: source_name) }
+  let(:source_name) { 'dummy_source' }
 
   it_should_behave_like 'SmellDetector'
 
@@ -263,7 +261,7 @@ RSpec.describe Reek::Smells::ControlParameter do
   end
 
   context 'when a smell is reported' do
-    before :each do
+    let(:warning) do
       src = <<-EOS
         def things(arg)
           @text.map do |blk|
@@ -273,16 +271,16 @@ RSpec.describe Reek::Smells::ControlParameter do
         end
       EOS
       ctx = Reek::Context::MethodContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      smells = @detector.examine(ctx)
+      smells = detector.examine(ctx)
       expect(smells.length).to eq(1)
-      @warning = smells[0]
+      smells.first
     end
 
     it_should_behave_like 'common fields set correctly'
 
     it 'has the correct fields' do
-      expect(@warning.parameters[:name]).to eq('arg')
-      expect(@warning.lines).to eq([3, 5])
+      expect(warning.parameters[:name]).to eq('arg')
+      expect(warning.lines).to eq([3, 5])
     end
   end
 end

data/spec/reek/smells/data_clump_spec.rb

@@ -6,7 +6,7 @@ RSpec.shared_examples_for 'a data clump detector' do
   it 'does not report small parameter sets' do
     src = <<-EOS
       # test module
-      #{@context} Scrunch
+      #{context} Scrunch
         def first(pa) @field == :sym ? 0 : 3; end
         def second(pa) @field == :sym; end
         def third(pa) pa - pb + @fred; end
@@ -16,52 +16,51 @@ RSpec.shared_examples_for 'a data clump detector' do
   end
 
   context 'with 3 identical pairs' do
-    before :each do
-      @module_name = 'Scrunch'
-      @src = <<-EOS
-        #{@context} #{@module_name}
+    let(:module_name) { 'Scrunch' }
+    let(:smells) do
+      src = <<-EOS
+        #{context} #{module_name}
           def first(pa, pb) @field == :sym ? 0 : 3; end
           def second(pa, pb) @field == :sym; end
           def third(pa, pb) pa - pb + @fred; end
         end
       EOS
-      ctx = Reek::Context::ModuleContext.new(nil, Reek::Source::SourceCode.from(@src).syntax_tree)
-      detector = build(:smell_detector, smell_type: :DataClump)
-      @smells = detector.examine_context(ctx)
+      ctx = Reek::Context::ModuleContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
+      build(:smell_detector, smell_type: :DataClump).examine_context(ctx)
     end
 
     it 'records only the one smell' do
-      expect(@smells.length).to eq(1)
+      expect(smells.length).to eq(1)
     end
 
     it 'reports all parameters' do
-      expect(@smells[0].parameters[:parameters]).to eq(['pa', 'pb'])
+      expect(smells[0].parameters[:parameters]).to eq(['pa', 'pb'])
     end
 
     it 'reports the number of occurrences' do
-      expect(@smells[0].parameters[:count]).to eq(3)
+      expect(smells[0].parameters[:count]).to eq(3)
     end
 
     it 'reports all methods' do
-      expect(@smells[0].parameters[:methods]).to eq(['first', 'second', 'third'])
+      expect(smells[0].parameters[:methods]).to eq(['first', 'second', 'third'])
     end
 
     it 'reports the declaration line numbers' do
-      expect(@smells[0].lines).to eq([2, 3, 4])
+      expect(smells[0].lines).to eq([2, 3, 4])
     end
 
     it 'reports the correct smell class' do
-      expect(@smells[0].smell_category).to eq(Reek::Smells::DataClump.smell_category)
+      expect(smells[0].smell_category).to eq(Reek::Smells::DataClump.smell_category)
     end
 
     it 'reports the context fq name' do
-      expect(@smells[0].context).to eq(@module_name)
+      expect(smells[0].context).to eq(module_name)
     end
   end
 
   it 'reports 3 swapped pairs' do
     src = <<-EOS
-      #{@context} Scrunch
+      #{context} Scrunch
         def one(pa, pb) @field == :sym ? 0 : 3; end
         def two(pb, pa) @field == :sym; end
         def tri(pa, pb) pa - pb + @fred; end
@@ -74,7 +73,7 @@ RSpec.shared_examples_for 'a data clump detector' do
 
   it 'reports 3 identical parameter sets' do
     src = <<-EOS
-      #{@context} Scrunch
+      #{context} Scrunch
         def first(pa, pb, pc) @field == :sym ? 0 : 3; end
         def second(pa, pb, pc) @field == :sym; end
         def third(pa, pb, pc) pa - pb + @fred; end
@@ -87,7 +86,7 @@ RSpec.shared_examples_for 'a data clump detector' do
 
   it 'reports re-ordered identical parameter sets' do
     src = <<-EOS
-      #{@context} Scrunch
+      #{context} Scrunch
         def first(pb, pa, pc) @field == :sym ? 0 : 3; end
         def second(pc, pb, pa) @field == :sym; end
         def third(pa, pb, pc) pa - pb + @fred; end
@@ -100,7 +99,7 @@ RSpec.shared_examples_for 'a data clump detector' do
 
   it 'counts only identical parameter sets' do
     src = <<-EOS
-      #{@context} RedCloth
+      #{context} RedCloth
         def fa(p1, p2, p3, conten) end
         def fb(p1, p2, p3, conten) end
         def fc(name, windowW, windowH) end
@@ -111,7 +110,7 @@ RSpec.shared_examples_for 'a data clump detector' do
 
   it 'gets a real example right' do
     src = <<-EOS
-      #{@context} Inline
+      #{context} Inline
         def generate(src, options) end
         def c (src, options) end
         def c_singleton (src, options) end
@@ -124,7 +123,7 @@ RSpec.shared_examples_for 'a data clump detector' do
 
   it 'correctly checks number of occurences' do
     src = <<-EOS
-      #{@context} Smelly
+      #{context} Smelly
         def fa(p1, p2, p3) end
         def fb(p2, p3, p4) end
         def fc(p3, p4, p5) end
@@ -137,7 +136,7 @@ RSpec.shared_examples_for 'a data clump detector' do
 
   it 'detects clumps smaller than the total number of arguments' do
     src = <<-EOS
-      #{@context} Smelly
+      #{context} Smelly
         def fa(p1, p2, p3) end
         def fb(p1, p3, p2) end
         def fc(p4, p1, p2) end
@@ -149,7 +148,7 @@ RSpec.shared_examples_for 'a data clump detector' do
 
   it 'ignores anonymous parameters' do
     src = <<-EOS
-      #{@context} Smelly
+      #{context} Smelly
         def fa(p1, p2, *) end
         def fb(p1, p2, *) end
         def fc(p1, p2, *) end
@@ -161,24 +160,18 @@ RSpec.shared_examples_for 'a data clump detector' do
 end
 
 RSpec.describe Reek::Smells::DataClump do
-  before(:each) do
-    @detector = build(:smell_detector, smell_type: :DataClump)
-  end
+  let(:detector) { build(:smell_detector, smell_type: :DataClump) }
 
   it_should_behave_like 'SmellDetector'
 
   context 'in a class' do
-    before :each do
-      @context = 'class'
-    end
+    let(:context) { 'class' }
 
     it_should_behave_like 'a data clump detector'
   end
 
   context 'in a module' do
-    before :each do
-      @context = 'module'
-    end
+    let(:context) { 'module' }
 
     it_should_behave_like 'a data clump detector'
   end