reek 3.2.1 → 3.3.0

data/spec/reek/smells/uncommunicative_parameter_name_spec.rb

@@ -4,12 +4,10 @@ require_relative 'smell_detector_shared'
 require_relative '../../../lib/reek/context/method_context'
 
 RSpec.describe Reek::Smells::UncommunicativeParameterName do
-  before :each do
-    @source_name = 'dummy_source'
-    @detector = build(:smell_detector,
-                      smell_type: :UncommunicativeParameterName,
-                      source: @source_name)
+  let(:detector) do
+    build(:smell_detector, smell_type: :UncommunicativeParameterName, source: source_name)
   end
+  let(:source_name) { 'dummy_source' }
 
   it_should_behave_like 'SmellDetector'
 
@@ -79,18 +77,17 @@ RSpec.describe Reek::Smells::UncommunicativeParameterName do
   end
 
   context 'looking at the smell result fields' do
-    before :each do
+    let(:warning) do
       src = 'def bad(good, bad2, good_again); basics(good, bad2, good_again); end'
       ctx = Reek::Context::MethodContext.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[:name]).to eq('bad2')
-      expect(@warning.lines).to eq([1])
+      expect(warning.parameters[:name]).to eq('bad2')
+      expect(warning.lines).to eq([1])
     end
   end
 end

data/spec/reek/smells/uncommunicative_variable_name_spec.rb

@@ -3,11 +3,9 @@ require_relative '../../../lib/reek/smells/uncommunicative_variable_name'
 require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::UncommunicativeVariableName do
-  before :each do
-    @source_name = 'dummy_source'
-    @detector = build(:smell_detector,
-                      smell_type: :UncommunicativeVariableName,
-                      source: @source_name)
+  let(:source_name) { 'dummy_source' }
+  let(:detector) do
+    build(:smell_detector, smell_type: :UncommunicativeVariableName, source: source_name)
   end
 
   it_should_behave_like 'SmellDetector'
@@ -19,7 +17,7 @@ RSpec.describe Reek::Smells::UncommunicativeVariableName do
     end
     it 'reports one-letter fieldname in assignment' do
       src = 'class Thing; def simple(fred) @x = fred end end'
-      expect(src).to reek_of(:UncommunicativeVariableName,  name: '@x')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: '@x')
     end
   end
 
@@ -44,17 +42,17 @@ RSpec.describe Reek::Smells::UncommunicativeVariableName do
     end
 
     it 'reports long name ending in a number' do
-      @bad_var = 'var123'
-      src = "def simple(fred) #{@bad_var} = jim(45) end"
+      bad_var = 'var123'
+      src = "def simple(fred) #{bad_var} = jim(45) end"
       expect(src).to reek_of(:UncommunicativeVariableName,
-                             name: @bad_var)
+                             name: bad_var)
     end
 
     it 'reports variable name only once' do
       src = 'def simple(fred) x = jim(45); x = y end'
       syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
       ctx = Reek::Context::CodeContext.new(nil, syntax_tree)
-      smells = @detector.examine_context(ctx)
+      smells = detector.examine_context(ctx)
       expect(smells.length).to eq(1)
       expect(smells[0].smell_type).to eq(described_class.smell_type)
       expect(smells[0].parameters[:name]).to eq('x')
@@ -67,7 +65,7 @@ RSpec.describe Reek::Smells::UncommunicativeVariableName do
     end
 
     it 'reports variable name outside any method' do
-      expect('class Simple; x = jim(45); end').to reek_of(:UncommunicativeVariableName,  name: 'x')
+      expect('class Simple; x = jim(45); end').to reek_of(:UncommunicativeVariableName, name: 'x')
     end
   end
 
@@ -154,7 +152,7 @@ RSpec.describe Reek::Smells::UncommunicativeVariableName do
   end
 
   context 'when a smell is reported' do
-    before :each do
+    let(:warning) do
       src = <<-EOS
         def bad
           unless @mod then
@@ -166,31 +164,29 @@ RSpec.describe Reek::Smells::UncommunicativeVariableName do
       EOS
       syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
       ctx = Reek::Context::CodeContext.new(nil, 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[:name]).to eq('x2')
-      expect(@warning.lines).to eq([3, 5])
+      expect(warning.parameters[:name]).to eq('x2')
+      expect(warning.lines).to eq([3, 5])
     end
   end
 
   context 'when a smell is reported in a singleton method' do
-    before :each do
+    let(:warning) do
       src = 'def self.bad() x2 = 4; end'
       syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
       ctx = Reek::Context::CodeContext.new(nil, 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 fq context' do
-      expect(@warning.context).to eq('self.bad')
+      expect(warning.context).to eq('self.bad')
     end
   end
 end

data/spec/reek/smells/utility_function_spec.rb

@@ -5,29 +5,25 @@ require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::UtilityFunction do
   describe 'a detector' do
-    before(:each) do
-      @source_name = 'string'
-      @detector = build(:smell_detector,
-                        smell_type: :UtilityFunction,
-                        source: @source_name)
-    end
+    let(:detector) { build(:smell_detector, smell_type: :UtilityFunction, source: source_name) }
+    let(:source_name) { 'string' }
 
     it_should_behave_like 'SmellDetector'
 
     context 'when a smells is reported' do
-      before :each do
+      let(:warning) do
         src = <<-EOS
-        def simple(arga)
-          arga.b.c
-        end
+          def simple(arga)
+            arga.b.c
+          end
         EOS
-        @warning = Reek::Examiner.new(src, ['UtilityFunction']).smells[0]
+        Reek::Examiner.new(src, ['UtilityFunction']).smells[0]
       end
 
       it_should_behave_like 'common fields set correctly'
 
       it 'reports the line number of the method' do
-        expect(@warning.lines).to eq([1])
+        expect(warning.lines).to eq([1])
       end
     end
   end
@@ -158,7 +154,7 @@ RSpec.describe Reek::Smells::UtilityFunction do
 
   context 'with only one call' do
     it 'reports a call to a parameter' do
-      expect('def simple(arga) arga.to_s end').to reek_of(:UtilityFunction,  name: 'simple')
+      expect('def simple(arga) arga.to_s end').to reek_of(:UtilityFunction, name: 'simple')
     end
 
     it 'reports a call to a constant' do
@@ -169,7 +165,7 @@ RSpec.describe Reek::Smells::UtilityFunction do
   context 'with two or more calls' do
     it 'reports two calls' do
       src = 'def simple(arga) arga.to_s + arga.to_i end'
-      expect(src).to reek_of(:UtilityFunction,  name: 'simple')
+      expect(src).to reek_of(:UtilityFunction, name: 'simple')
       expect(src).not_to reek_of(:FeatureEnvy)
     end
 
@@ -194,7 +190,7 @@ RSpec.describe Reek::Smells::UtilityFunction do
 
     it 'should report message chain' do
       src = 'def simple(arga) arga.b.c end'
-      expect(src).to reek_of(:UtilityFunction,  name: 'simple')
+      expect(src).to reek_of(:UtilityFunction, name: 'simple')
       expect(src).not_to reek_of(:FeatureEnvy)
     end
 

data/spec/reek/source/source_code_spec.rb

@@ -26,16 +26,13 @@ RSpec.describe Reek::Source::SourceCode do
   end
 
   context 'when the parser fails' do
+    let(:catcher) { StringIO.new }
     let(:source_name) { 'Test source' }
     let(:error_message) { 'Error message' }
     let(:parser) { double('parser') }
     let(:src) { Reek::Source::SourceCode.new('', source_name, parser) }
 
-    before :each do
-      @catcher = StringIO.new
-      @old_std_err = $stderr
-      $stderr = @catcher
-    end
+    before { $stderr = catcher }
 
     shared_examples_for 'handling and recording the error' do
       it 'does not raise an error' do
@@ -48,17 +45,17 @@ RSpec.describe Reek::Source::SourceCode do
 
       it 'records the syntax error' do
         src.syntax_tree
-        expect(@catcher.string).to match(error_class.name)
+        expect(catcher.string).to match(error_class.name)
       end
 
       it 'records the source name' do
         src.syntax_tree
-        expect(@catcher.string).to match(source_name)
+        expect(catcher.string).to match(source_name)
       end
 
       it 'records the error message' do
         src.syntax_tree
-        expect(@catcher.string).to match(error_message)
+        expect(catcher.string).to match(error_message)
       end
     end
 
@@ -98,8 +95,6 @@ RSpec.describe Reek::Source::SourceCode do
       end
     end
 
-    after :each do
-      $stderr = @old_std_err
-    end
+    after { $stderr = STDERR }
   end
 end

data/spec/reek/spec/should_reek_of_spec.rb

@@ -4,71 +4,60 @@ require_relative '../../../lib/reek/spec'
 
 RSpec.describe Reek::Spec::ShouldReekOf do
   context 'rdoc demo example' do
-    before :each do
-      @ruby = 'def double_thing() @other.thing.foo + @other.thing.foo end'
-    end
+    let(:ruby) { 'def double_thing() @other.thing.foo + @other.thing.foo end' }
 
     it 'reports duplicate calls to @other.thing' do
-      expect(@ruby).to reek_of(:Duplication,  name: '@other.thing')
+      expect(ruby).to reek_of(:Duplication, name: '@other.thing')
     end
 
     it 'reports duplicate calls to @other.thing.foo' do
-      expect(@ruby).to reek_of(:Duplication,  name: '@other.thing.foo')
+      expect(ruby).to reek_of(:Duplication, name: '@other.thing.foo')
     end
 
     it 'does not report any feature envy' do
-      expect(@ruby).not_to reek_of(:FeatureEnvy)
+      expect(ruby).not_to reek_of(:FeatureEnvy)
     end
   end
 
   context 'checking code in a string' do
-    before :each do
-      @clean_code = 'def good() true; end'
-      @smelly_code = 'def x() y = 4; end'
-      @matcher = Reek::Spec::ShouldReekOf.new(:UncommunicativeVariableName,
-                                              name: 'y')
-    end
+    let(:clean_code) { 'def good() true; end' }
+    let(:matcher) { Reek::Spec::ShouldReekOf.new(:UncommunicativeVariableName, name: 'y') }
+    let(:smelly_code) { 'def x() y = 4; end' }
 
     it 'matches a smelly String' do
-      expect(@matcher.matches?(@smelly_code)).to be_truthy
+      expect(matcher.matches?(smelly_code)).to be_truthy
     end
 
     it 'doesnt match a fragrant String' do
-      expect(@matcher.matches?(@clean_code)).to be_falsey
+      expect(matcher.matches?(clean_code)).to be_falsey
     end
 
     it 'reports the smells when should_not fails' do
-      expect(@matcher.matches?(@smelly_code)).to be_truthy
-      expect(@matcher.failure_message_when_negated).to match('UncommunicativeVariableName')
+      expect(matcher.matches?(smelly_code)).to be_truthy
+      expect(matcher.failure_message_when_negated).to match('UncommunicativeVariableName')
     end
   end
 
   context 'passing in smell_details with unknown parameter name' do
-    before :each do
-      @smelly_code = 'def x() y = 4; end'
-      @matcher = Reek::Spec::ShouldReekOf.new(:UncommunicativeVariableName,
-                                              foo: 'y')
-    end
+    let(:matcher) { Reek::Spec::ShouldReekOf.new(:UncommunicativeVariableName, foo: 'y') }
+    let(:smelly_code) { 'def x() y = 4; end' }
 
     it 'raises ArgumentError' do
-      expect { @matcher.matches?(@smelly_code) }.to raise_error(ArgumentError)
+      expect { matcher.matches?(smelly_code) }.to raise_error(ArgumentError)
     end
   end
 
   context 'checking code in a File' do
-    before :each do
-      @clean_file = Pathname.glob("#{SAMPLES_PATH}/three_clean_files/*.rb").first
-      @smelly_file = Pathname.glob("#{SAMPLES_PATH}/two_smelly_files/*.rb").first
-      @matcher = Reek::Spec::ShouldReekOf.new(:UncommunicativeVariableName,
-                                              name: '@s')
-    end
+    let(:clean_file) { Pathname.glob("#{SAMPLES_PATH}/three_clean_files/*.rb").first }
+    let(:matcher) { Reek::Spec::ShouldReekOf.new(:UncommunicativeVariableName, name: '@s') }
+    let(:smelly_file) { Pathname.glob("#{SAMPLES_PATH}/two_smelly_files/*.rb").first }
 
     it 'matches a smelly String' do
-      expect(@matcher.matches?(@smelly_file)).to be_truthy
+      expect(matcher.matches?(smelly_file)).to be_truthy
     end
 
     it 'doesnt match a fragrant String' do
-      expect(@matcher.matches?(@clean_file)).to be_falsey
+      expect(matcher.matches?(clean_file)).to be_falsey
     end
   end
 end

data/spec/reek/spec/should_reek_only_of_spec.rb

@@ -2,50 +2,46 @@ require_relative '../../spec_helper'
 require_relative '../../../lib/reek/spec'
 
 RSpec.describe Reek::Spec::ShouldReekOnlyOf do
-  before :each do
-    @expected_smell_type = :NestedIterators
-    @expected_context_name = 'SmellyClass#big_method'
-    @matcher = Reek::Spec::ShouldReekOnlyOf.new(@expected_smell_type)
-    @examiner = double('examiner').as_null_object
-    expect(@examiner).to receive(:smells) { smells }
-    @match = @matcher.matches_examiner?(@examiner)
+  let(:examiner) { double('examiner').as_null_object }
+  let(:expected_context_name) { 'SmellyClass#big_method' }
+  let(:expected_smell_type) { :NestedIterators }
+  let(:matcher) { Reek::Spec::ShouldReekOnlyOf.new(expected_smell_type) }
+  let(:matcher_matches) { matcher.matches_examiner?(examiner) }
+
+  before do
+    expect(examiner).to receive(:smells) { smells }
+    matcher_matches
   end
 
   shared_examples_for 'no match' do
     it 'does not match' do
-      expect(@match).to be_falsey
+      expect(matcher_matches).to be_falsey
     end
 
     context 'when a match was expected' do
-      before :each do
-        @source = 'the_path/to_a/source_file.rb'
-        expect(@examiner).to receive(:description).and_return(@source)
-      end
+      let(:source) { 'the_path/to_a/source_file.rb' }
+
+      before { expect(examiner).to receive(:description).and_return(source) }
 
       it 'reports the source' do
-        expect(@matcher.failure_message).to match(@source)
+        expect(matcher.failure_message).to match(source)
       end
 
       it 'reports the expected smell class' do
-        expect(@matcher.failure_message).to match(@expected_smell_type.to_s)
+        expect(matcher.failure_message).to match(expected_smell_type.to_s)
       end
     end
   end
 
   context 'with no smells' do
-    def smells
-      []
-    end
+    let(:smells) { [] }
 
     it_should_behave_like 'no match'
   end
 
   context 'with 1 non-matching smell' do
     let(:control_couple_detector) { build(:smell_detector, smell_type: 'ControlParameter') }
-
-    def smells
-      [build(:smell_warning, smell_detector: control_couple_detector)]
-    end
+    let(:smells) { [build(:smell_warning, smell_detector: control_couple_detector)] }
 
     it_should_behave_like 'no match'
   end
@@ -53,8 +49,7 @@ RSpec.describe Reek::Spec::ShouldReekOnlyOf do
   context 'with 2 non-matching smells' do
     let(:control_couple_detector) { build(:smell_detector, smell_type: 'ControlParameter') }
     let(:feature_envy_detector) { build(:smell_detector, smell_type: 'FeatureEnvy') }
-
-    def smells
+    let(:smells) do
       [
         build(:smell_warning, smell_detector: control_couple_detector),
         build(:smell_warning, smell_detector: feature_envy_detector)
@@ -66,13 +61,12 @@ RSpec.describe Reek::Spec::ShouldReekOnlyOf do
 
   context 'with 1 non-matching and 1 matching smell' do
     let(:control_couple_detector) { build(:smell_detector, smell_type: 'ControlParameter') }
-
-    def smells
-      detector = build(:smell_detector, smell_type: @expected_smell_type.to_s)
+    let(:smells) do
+      detector = build(:smell_detector, smell_type: expected_smell_type.to_s)
       [
         build(:smell_warning, smell_detector: control_couple_detector),
         build(:smell_warning, smell_detector: detector,
-                              message: "message mentioning #{@expected_context_name}")
+                              message: "message mentioning #{expected_context_name}")
       ]
     end
 
@@ -80,25 +74,25 @@ RSpec.describe Reek::Spec::ShouldReekOnlyOf do
   end
 
   context 'with 1 matching smell' do
-    def smells
-      detector = build(:smell_detector, smell_type: @expected_smell_type.to_s)
+    let(:smells) do
+      detector = build(:smell_detector, smell_type: expected_smell_type.to_s)
 
       [build(:smell_warning, smell_detector: detector,
-                             message: "message mentioning #{@expected_context_name}")]
+                             message: "message mentioning #{expected_context_name}")]
     end
 
     it 'matches' do
-      expect(@match).to be_truthy
+      expect(matcher_matches).to be_truthy
     end
 
     it 'reports the expected smell when no match was expected' do
-      expect(@matcher.failure_message_when_negated).to match(@expected_smell_type.to_s)
+      expect(matcher.failure_message_when_negated).to match(expected_smell_type.to_s)
     end
 
     it 'reports the source when no match was expected' do
       source = 'the_path/to_a/source_file.rb'
-      expect(@examiner).to receive(:description).and_return(source)
-      expect(@matcher.failure_message_when_negated).to match(source)
+      expect(examiner).to receive(:description).and_return(source)
+      expect(matcher.failure_message_when_negated).to match(source)
     end
   end
 end