reek 3.2.1 → 3.3.0

data/spec/reek/smells/smell_detector_shared.rb

@@ -3,39 +3,38 @@ require_relative '../../../lib/reek/smells/smell_configuration'
 
 RSpec.shared_examples_for 'SmellDetector' do
   context 'exception matching follows the context' do
-    before :each do
-      @ctx = double('context')
-      allow(@ctx).to receive(:config_for).and_return({})
-    end
+    let(:ctx) { double('context') }
+
+    before { allow(ctx).to receive(:config_for).and_return({}) }
 
     it 'when false' do
-      expect(@ctx).to receive(:matches?).at_least(:once).and_return(false)
-      expect(@detector.exception?(@ctx)).to eq(false)
+      expect(ctx).to receive(:matches?).at_least(:once).and_return(false)
+      expect(detector.exception?(ctx)).to eq(false)
     end
 
     it 'when true' do
-      expect(@ctx).to receive(:matches?).at_least(:once).and_return(true)
-      expect(@detector.exception?(@ctx)).to eq(true)
+      expect(ctx).to receive(:matches?).at_least(:once).and_return(true)
+      expect(detector.exception?(ctx)).to eq(true)
     end
   end
 
   context 'configuration' do
     it 'becomes disabled when disabled' do
       enabled_key = Reek::Smells::SmellConfiguration::ENABLED_KEY
-      @detector.configure_with(enabled_key => false)
-      expect(@detector).not_to be_enabled
+      detector.configure_with(enabled_key => false)
+      expect(detector).not_to be_enabled
     end
   end
 end
 
 RSpec.shared_examples_for 'common fields set correctly' do
   it 'reports the source' do
-    expect(@warning.source).to eq(@source_name)
+    expect(warning.source).to eq(source_name)
   end
   it 'reports the smell class' do
-    expect(@warning.smell_category).to eq(@detector.smell_category)
+    expect(warning.smell_category).to eq(detector.smell_category)
   end
   it 'reports the smell sub class' do
-    expect(@warning.smell_type).to eq(@detector.smell_type)
+    expect(warning.smell_type).to eq(detector.smell_type)
   end
 end

data/spec/reek/smells/smell_warning_spec.rb

@@ -9,78 +9,77 @@ RSpec.describe Reek::Smells::SmellWarning do
   context 'sort order' do
     shared_examples_for 'first sorts ahead of second' do
       it 'hash differently' do
-        expect(@first.hash).not_to eq(@second.hash)
+        expect(first.hash).not_to eq(second.hash)
       end
       it 'are not equal' do
-        expect(@first).not_to eq(@second)
+        expect(first).not_to eq(second)
       end
       it 'sort correctly' do
-        expect(@first <=> @second).to be < 0
+        expect(first <=> second).to be < 0
       end
       it 'does not match using eql?' do
-        expect(@first).not_to eql(@second)
-        expect(@second).not_to eql(@first)
+        expect(first).not_to eql(second)
+        expect(second).not_to eql(first)
       end
     end
 
     context 'smells differing only by detector' do
-      before :each do
-        @first  = build(:smell_warning, smell_detector: duplication_detector)
-        @second = build(:smell_warning, smell_detector: feature_envy_detector)
-      end
+      let(:first) { build(:smell_warning, smell_detector: duplication_detector) }
+      let(:second) { build(:smell_warning, smell_detector: feature_envy_detector) }
 
       it_should_behave_like 'first sorts ahead of second'
     end
 
     context 'smells differing only by context' do
-      before :each do
-        @first  = build(:smell_warning, smell_detector: duplication_detector,
-                                        context: 'first')
-        @second = build(:smell_warning, smell_detector: duplication_detector,
-                                        context: 'second')
+      let(:first) { build(:smell_warning, smell_detector: duplication_detector, context: 'first') }
+      let(:second) do
+        build(:smell_warning, smell_detector: duplication_detector, context: 'second')
       end
 
       it_should_behave_like 'first sorts ahead of second'
     end
 
     context 'smells differing only by message' do
-      before :each do
-        @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')
+      let(:first) do
+        build(:smell_warning, smell_detector: duplication_detector,
+                              context: 'ctx', message: 'first message')
+      end
+      let(:second) do
+        build(:smell_warning, smell_detector: duplication_detector,
+                              context: 'ctx', message: 'second message')
       end
 
       it_should_behave_like 'first sorts ahead of second'
     end
 
     context 'message takes precedence over smell name' do
-      before :each do
-        @first  = build(:smell_warning, smell_detector: utility_function_detector,
-                                        message: 'first message')
-        @second = build(:smell_warning, smell_detector: feature_envy_detector,
-                                        message: 'second message')
+      let(:first) do
+        build(:smell_warning, smell_detector: utility_function_detector, message: 'first message')
+      end
+      let(:second) do
+        build(:smell_warning, smell_detector: feature_envy_detector, message: 'second message')
       end
 
       it_should_behave_like 'first sorts ahead of second'
     end
 
     context 'smells differing everywhere' do
-      before :each do
+      let(:first) do
         uncommunicative_name_detector = build(:smell_detector,
                                               smell_type: 'UncommunicativeVariableName',
                                               source: true)
+        build(:smell_warning, smell_detector: uncommunicative_name_detector,
+                              context: 'Dirty',
+                              message: "has the variable name '@s'")
+      end
+
+      let(:second) do
         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')
+        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'
@@ -88,53 +87,50 @@ RSpec.describe Reek::Smells::SmellWarning do
   end
 
   context '#yaml_hash' do
-    before :each do
-      @message = 'test message'
-      @lines = [24, 513]
-      @class = 'FeatureEnvy'
-      @context_name = 'Module::Class#method/block'
-      # Use a random string and a random bool
-    end
+    let(:class) { 'FeatureEnvy' }
+    let(:context_name) { 'Module::Class#method/block' }
+    let(:lines) { [24, 513] }
+    let(:message) { 'test message' }
 
     shared_examples_for 'common fields' do
       it 'includes the smell type' do
-        expect(@yaml['smell_type']).to eq 'FeatureEnvy'
+        expect(yaml['smell_type']).to eq 'FeatureEnvy'
       end
       it 'includes the context' do
-        expect(@yaml['context']).to eq @context_name
+        expect(yaml['context']).to eq context_name
       end
       it 'includes the message' do
-        expect(@yaml['message']).to eq @message
+        expect(yaml['message']).to eq message
       end
       it 'includes the line numbers' do
-        expect(@yaml['lines']).to match_array @lines
+        expect(yaml['lines']).to match_array lines
       end
     end
 
     context 'with all details specified' do
-      before :each do
-        @source = 'a/ruby/source/file.rb'
-        @smell_type = 'FeatureEnvy'
-        @parameters = { 'one' => 34, 'two' => 'second' }
-        @detector = Reek::Smells::FeatureEnvy.new @source
-        @warning = Reek::Smells::SmellWarning.new(@detector, context: @context_name,
-                                                             lines: @lines,
-                                                             message: @message,
-                                                             parameters: @parameters)
-        @yaml = @warning.yaml_hash
+      let(:detector) { Reek::Smells::FeatureEnvy.new source }
+      let(:parameters) { { 'one' => 34, 'two' => 'second' } }
+      let(:smell_type) { 'FeatureEnvy' }
+      let(:source) { 'a/ruby/source/file.rb' }
+      let(:yaml) do
+        warning = Reek::Smells::SmellWarning.new(detector, context: context_name,
+                                                           lines: lines,
+                                                           message: message,
+                                                           parameters: parameters)
+        warning.yaml_hash
       end
 
       it_should_behave_like 'common fields'
 
       it 'includes the smell type' do
-        expect(@yaml['smell_type']).to eq @smell_type
+        expect(yaml['smell_type']).to eq smell_type
       end
       it 'includes the source' do
-        expect(@yaml['source']).to eq @source
+        expect(yaml['source']).to eq source
       end
       it 'includes the parameters' do
-        @parameters.each do |key, value|
-          expect(@yaml[key]).to eq value
+        parameters.each do |key, value|
+          expect(yaml[key]).to eq value
         end
       end
     end

data/spec/reek/smells/too_many_instance_variables_spec.rb

@@ -3,9 +3,9 @@ require_relative '../../../lib/reek/smells/too_many_instance_variables'
 require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::TooManyInstanceVariables do
-  before(:each) do
-    @source_name = 'dummy_source'
-    @detector = build(:smell_detector, smell_type: :TooManyInstanceVariables, source: @source_name)
+  let(:source_name) { 'dummy_source' }
+  let(:detector) do
+    build(:smell_detector, smell_type: :TooManyInstanceVariables, source: source_name)
   end
 
   it_should_behave_like 'SmellDetector'
@@ -87,11 +87,11 @@ RSpec.describe Reek::Smells::TooManyInstanceVariables do
       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(Reek::Smells::TooManyInstanceVariables.smell_category)
-    expect(@warning.smell_type).to eq(Reek::Smells::TooManyInstanceVariables.smell_type)
-    expect(@warning.parameters[:count]).to eq(too_many_ivars)
-    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(Reek::Smells::TooManyInstanceVariables.smell_category)
+    expect(warning.smell_type).to eq(Reek::Smells::TooManyInstanceVariables.smell_type)
+    expect(warning.parameters[:count]).to eq(too_many_ivars)
+    expect(warning.lines).to eq([2])
   end
 end

data/spec/reek/smells/too_many_methods_spec.rb

@@ -3,11 +3,10 @@ require_relative '../../../lib/reek/smells/too_many_methods'
 require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::TooManyMethods do
-  before(:each) do
-    @source_name = 'dummy_source'
-    @detector = described_class.new(@source_name)
-    @detector.configure_with 'max_methods' => 2
-  end
+  let(:detector) { described_class.new(source_name) }
+  let(:source_name) { 'dummy_name' }
+
+  before(:each) { detector.configure_with 'max_methods' => 2 }
 
   it_should_behave_like 'SmellDetector'
 
@@ -21,7 +20,7 @@ RSpec.describe Reek::Smells::TooManyMethods do
       EOS
       syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
       ctx = Reek::Context::ModuleContext.new(nil, syntax_tree)
-      expect(@detector.examine_context(ctx)).to be_empty
+      expect(detector.examine_context(ctx)).to be_empty
     end
 
     it 'should report if we exceed max_methods' do
@@ -34,7 +33,7 @@ RSpec.describe Reek::Smells::TooManyMethods do
       EOS
       syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
       ctx = Reek::Context::ModuleContext.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[:count]).to eq(3)
@@ -57,7 +56,7 @@ RSpec.describe Reek::Smells::TooManyMethods do
       EOS
       syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
       ctx = Reek::Context::ModuleContext.new(nil, syntax_tree)
-      expect(@detector.examine_context(ctx)).to be_empty
+      expect(detector.examine_context(ctx)).to be_empty
     end
   end
 
@@ -72,11 +71,11 @@ RSpec.describe Reek::Smells::TooManyMethods do
 
     syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
     ctx = Reek::Context::ModuleContext.new(nil, 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[:count]).to eq(3)
-    expect(@warning.lines).to eq([1])
+    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[:count]).to eq(3)
+    expect(warning.lines).to eq([1])
   end
 end

data/spec/reek/smells/too_many_statements_spec.rb

@@ -41,31 +41,29 @@ RSpec.describe Reek::Smells::TooManyStatements do
 end
 
 RSpec.describe Reek::Smells::TooManyStatements do
-  before(:each) do
-    @detector = build(:smell_detector, smell_type: :TooManyStatements, source: 'source_name')
-  end
+  let(:detector) { build(:smell_detector, smell_type: :TooManyStatements, source: 'source_name') }
 
   it_should_behave_like 'SmellDetector'
 
   context 'when the method has 30 statements' do
-    before :each do
-      @num_statements = 30
+    let(:num_statements) { 30 }
+    let(:smells) do
       ctx = double('method_context').as_null_object
-      expect(ctx).to receive(:num_statements).and_return(@num_statements)
+      expect(ctx).to receive(:num_statements).and_return(num_statements)
       expect(ctx).to receive(:config_for).with(described_class).and_return({})
-      @smells = @detector.examine_context(ctx)
+      detector.examine_context(ctx)
     end
 
     it 'reports only 1 smell' do
-      expect(@smells.length).to eq(1)
+      expect(smells.length).to eq(1)
     end
 
     it 'reports the number of statements' do
-      expect(@smells[0].parameters[:count]).to eq(@num_statements)
+      expect(smells[0].parameters[:count]).to eq(num_statements)
     end
 
     it 'reports the correct 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
   end
 end

data/spec/reek/smells/uncommunicative_method_name_spec.rb

@@ -3,9 +3,9 @@ require_relative '../../../lib/reek/smells/uncommunicative_method_name'
 require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::UncommunicativeMethodName do
-  before do
-    @source_name = 'dummy_source'
-    @detector = build(:smell_detector, smell_type: :UncommunicativeMethodName, source: @source_name)
+  let(:source_name) { 'dummy_source' }
+  let(:detector) do
+    build(:smell_detector, smell_type: :UncommunicativeMethodName, source: source_name)
   end
 
   it_should_behave_like 'SmellDetector'
@@ -19,19 +19,18 @@ RSpec.describe Reek::Smells::UncommunicativeMethodName do
 
   ['x', 'x2', 'method2'].each do |method_name|
     context 'with a bad name' do
-      before do
+      let(:warning) do
         src = "def #{method_name}; end"
         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[:name]).to eq(method_name)
-        expect(@warning.lines).to eq([1])
-        expect(@warning.context).to eq(method_name)
+        expect(warning.parameters[:name]).to eq(method_name)
+        expect(warning.lines).to eq([1])
+        expect(warning.context).to eq(method_name)
       end
     end
   end

data/spec/reek/smells/uncommunicative_module_name_spec.rb

@@ -4,9 +4,9 @@ require_relative 'smell_detector_shared'
 require_relative '../../../lib/reek/context/code_context'
 
 RSpec.describe Reek::Smells::UncommunicativeModuleName do
-  before do
-    @source_name = 'dummy_source'
-    @detector = build(:smell_detector, smell_type: :UncommunicativeModuleName, source: @source_name)
+  let(:source_name) { 'dummy_source' }
+  let(:detector) do
+    build(:smell_detector, smell_type: :UncommunicativeModuleName, source: source_name)
   end
 
   it_should_behave_like 'SmellDetector'
@@ -17,21 +17,21 @@ RSpec.describe Reek::Smells::UncommunicativeModuleName do
     end
 
     it 'reports one-letter name' do
-      expect("#{type} X; end").to reek_of(:UncommunicativeModuleName,  name: 'X')
+      expect("#{type} X; end").to reek_of(:UncommunicativeModuleName, name: 'X')
     end
 
     it 'reports name of the form "x2"' do
-      expect("#{type} X2; end").to reek_of(:UncommunicativeModuleName,  name: 'X2')
+      expect("#{type} X2; end").to reek_of(:UncommunicativeModuleName, name: 'X2')
     end
 
     it 'reports long name ending in a number' do
-      expect("#{type} Printer2; end").to reek_of(:UncommunicativeModuleName,  name: 'Printer2')
+      expect("#{type} Printer2; end").to reek_of(:UncommunicativeModuleName, name: 'Printer2')
     end
 
     it 'reports a bad scoped name' do
       src = "#{type} Foo::X; end"
       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)
       expect(smells[0].smell_category).to eq(Reek::Smells::UncommunicativeModuleName.smell_category)
       expect(smells[0].smell_type).to eq(Reek::Smells::UncommunicativeModuleName.smell_type)
@@ -44,23 +44,22 @@ RSpec.describe Reek::Smells::UncommunicativeModuleName do
     it 'accepts Inline::C' do
       src = 'module Inline::C; end'
       ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      expect(@detector.examine_context(ctx)).to be_empty
+      expect(detector.examine_context(ctx)).to be_empty
     end
   end
 
   context 'looking at the YAML' do
-    before :each do
+    let(:warning) do
       src = 'module Printer2; end'
       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[:name]).to eq('Printer2')
-      expect(@warning.lines).to eq([1])
+      expect(warning.parameters[:name]).to eq('Printer2')
+      expect(warning.lines).to eq([1])
     end
   end
 end