reek 2.0.0 → 2.0.1

data/lib/reek/spec/should_reek.rb

@@ -21,11 +21,5 @@ module Reek
         "Expected no smells, but got:\n#{rpt}"
       end
     end
-    #
-    # Returns +true+ if and only if the target source code contains smells.
-    #
-    def reek
-      ShouldReek.new
-    end
   end
 end

data/lib/reek/spec/should_reek_of.rb

@@ -35,54 +35,5 @@ module Reek
         smell_category_or_type.to_s.split(/::/)[-1]
       end
     end
-
-    #
-    # Checks the target source code for instances of "smell category"
-    # and returns true only if it can find one of them that matches.
-    #
-    # Remember that this includes our "smell types" as well. So it could be the
-    # "smell type" UtilityFunction, which is represented as a concrete class
-    # in reek but it could also be "Duplication" which is a "smell categgory".
-    #
-    # In theory you could pass many different types of input here:
-    #   - :UtilityFunction
-    #   - "UtilityFunction"
-    #   - UtilityFunction (this works in our specs because we tend to do "include Reek:Smells")
-    #   - Reek::Smells::UtilityFunction (the right way if you really want to pass a class)
-    #   - "Duplication" or :Duplication which is an abstract "smell category"
-    #
-    # It is recommended to pass this as a symbol like :UtilityFunction. However we don't
-    # enforce this.
-    #
-    # Additionally you can be more specific and pass in "smell_details" you
-    # want to check for as well e.g. "name" or "count" (see the examples below).
-    # The parameters you can check for are depending on the smell you are checking for.
-    # For instance "count" doesn't make sense everywhere whereas "name" does in most cases.
-    # If you pass in a parameter that doesn't exist (e.g. you make a typo like "namme") reek will
-    # raise an ArgumentError to give you a hint that you passed something that doesn't make
-    # much sense.
-    #
-    # smell_category - The "smell category" or "smell_type" we check for.
-    # smells_details - A hash containing "smell warning" parameters
-    #
-    # Examples
-    #
-    #   Without smell_details:
-    #
-    #   reek_of(:FeatureEnvy)
-    #   reek_of(Reek::Smells::UtilityFunction)
-    #
-    #   With smell_details:
-    #
-    #   reek_of(UncommunicativeParameterName, name: 'x2')
-    #   reek_of(DataClump, count: 3)
-    #
-    # Examples from a real spec
-    #
-    #   expect(src).to reek_of(Reek::Smells::DuplicateMethodCall, name: '@other.thing')
-    #
-    def reek_of(smell_category, smell_details = {})
-      ShouldReekOf.new(smell_category, smell_details)
-    end
   end
 end

data/lib/reek/spec/should_reek_only_of.rb

@@ -28,16 +28,5 @@ module Reek
         "Expected #{@examiner.description} not to reek only of #{@smell_category}, but it did"
       end
     end
-
-    #
-    # See the documentaton for "reek_of".
-    #
-    # Notable differences to reek_of:
-    #   1.) "reek_of" doesn't mind if there are other smells of a different category.
-    #       "reek_only_of" will fail in that case.
-    #   2.) "reek_only_of" doesn't support the additional smell_details hash.
-    def reek_only_of(smell_category)
-      ShouldReekOnlyOf.new(smell_category)
-    end
   end
 end

data/lib/reek/version.rb

@@ -1,3 +1,8 @@
 module Reek
-  VERSION = '2.0.0'
+  #
+  # This module holds the Reek version informations
+  #
+  module Version
+    STRING = '2.0.1'
+  end
 end

data/reek.gemspec

@@ -4,7 +4,7 @@ require 'reek/version'
 
 Gem::Specification.new do |s|
   s.name = 'reek'
-  s.version = Reek::VERSION
+  s.version = Reek::Version::STRING
 
   s.authors = ['Kevin Rutherford', 'Timo Roessner', 'Matijs van Zuijlen']
   s.default_executable = 'reek'
@@ -33,6 +33,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency('parser', ['~> 2.2'])
   s.add_runtime_dependency('unparser', ['~> 0.2.2'])
   s.add_runtime_dependency('rainbow', ['~> 2.0'])
+  s.add_runtime_dependency('require_all', ['~> 1.3'])
 
   s.add_development_dependency('bundler', ['~> 1.1'])
   s.add_development_dependency('rake', ['~> 10.0'])
@@ -40,5 +41,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency('rspec', ['~> 3.0'])
   s.add_development_dependency('yard', ['>= 0.8.7', '< 0.9'])
   s.add_development_dependency('factory_girl', ['~> 4.0'])
-  s.add_development_dependency('rubocop', ['~> 0.28.0'])
+  s.add_development_dependency('rubocop', ['~> 0.29.0'])
 end

data/spec/reek/cli/json_report_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'reek/examiner'
+require 'reek/cli/report/report'
+require 'reek/cli/report/formatter'
+
+describe Reek::Cli::Report::JsonReport do
+  let(:instance) { Reek::Cli::Report::JsonReport.new }
+
+  context 'empty source' do
+    let(:examiner) { Reek::Examiner.new('') }
+
+    before do
+      instance.add_examiner examiner
+    end
+
+    it 'prints empty json' do
+      expect { instance.show }.to output(/^\[\]$/).to_stdout
+    end
+  end
+end

data/spec/reek/core/code_context_spec.rb

@@ -25,12 +25,18 @@ describe CodeContext do
     it 'does not match when its own short name is not given' do
       expect(@ctx.matches?(['banana'])).to eq(false)
     end
+    it 'does not let pipe-ended Strings make matching ignore the rest' do
+      expect(@ctx.matches?(['banana|'])).to eq(false)
+    end
     it 'recognises its own short name' do
       expect(@ctx.matches?(['banana', @exp_name])).to eq(true)
     end
     it 'recognises its short name as a regex' do
       expect(@ctx.matches?([/banana/, /#{@exp_name}/])).to eq(true)
     end
+    it 'does not blow up on []-ended Strings' do
+      expect(@ctx.matches?(['banana[]', @exp_name])).to eq(true)
+    end
 
     context 'when there is an outer' do
       let(:outer) { double('outer') }

data/spec/reek/core/smell_configuration_spec.rb

@@ -47,9 +47,9 @@ describe SmellConfiguration do
 
     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]$/]
+        'enabled' => false, 'exclude' => [],
+        'reject' => [/^.$/, /[0-9]$/, /[A-Z]/],
+        'accept' => [/[A-Z]$/]
       )
     end
   end

data/spec/reek/core/{code_parser_spec.rb → tree_walker_spec.rb}

@@ -1,9 +1,9 @@
 require 'spec_helper'
-require 'reek/core/code_parser'
+require 'reek/core/tree_walker'
 
 include Reek::Core
 
-describe CodeParser, 'with no method definitions' do
+describe TreeWalker, 'with no method definitions' do
   it 'reports no problems for empty source code' do
     expect('').not_to reek
   end
@@ -13,14 +13,14 @@ class Fred; end').not_to reek
   end
 end
 
-describe CodeParser, 'with a global method definition' do
+describe TreeWalker, 'with a global method definition' do
   it 'reports no problems for simple method' do
     src = 'def Outermost::fred() true; end'
     expect(src).not_to reek
   end
 end
 
-describe CodeParser, 'when a yield is the receiver' do
+describe TreeWalker, 'when a yield is the receiver' do
   it 'reports no problems' do
     src = <<EOS
 def values(*args)

data/spec/reek/examiner_spec.rb

@@ -3,21 +3,6 @@ require 'reek/examiner'
 
 include Reek
 
-shared_examples_for 'supports the deprecated api' do
-  it 'returns all smells as active' do
-    expect(@examiner.all_active_smells).to eq(@examiner.smells)
-  end
-  it 'returns all smells as active' do
-    expect(@examiner.all_smells).to eq(@examiner.smells)
-  end
-  it 'counts all smells as active smells' do
-    expect(@examiner.num_active_smells).to eq(@examiner.smells.length)
-  end
-  it 'never reports masked smells' do
-    expect(@examiner.num_masked_smells).to eq(0)
-  end
-end
-
 shared_examples_for 'no smells found' do
   it 'is not smelly' do
     expect(@examiner).not_to be_smelly
@@ -25,8 +10,6 @@ shared_examples_for 'no smells found' do
   it 'finds no smells' do
     expect(@examiner.smells.length).to eq(0)
   end
-
-  it_should_behave_like 'supports the deprecated api'
 end
 
 shared_examples_for 'one smell found' do
@@ -39,8 +22,6 @@ shared_examples_for 'one smell found' do
   it 'reports the correct smell' do
     expect(@examiner.smells[0].smell_category).to eq(@expected_first_smell)
   end
-
-  it_should_behave_like 'supports the deprecated api'
 end
 
 describe Examiner do

data/spec/reek/smells/attribute_spec.rb

@@ -3,13 +3,10 @@ require 'reek/smells/attribute'
 require 'reek/core/module_context'
 require 'reek/smells/smell_detector_shared'
 
-include Reek::Core
-include Reek::Smells
-
-describe Attribute do
+describe Reek::Smells::Attribute do
   before :each do
-    @source_name = 'ticker'
-    @detector = Attribute.new(@source_name)
+    @source_name = 'dummy_source'
+    @detector = build(:smell_detector, smell_type: :Attribute, source: @source_name)
   end
 
   it_should_behave_like 'SmellDetector'
@@ -17,7 +14,7 @@ describe Attribute do
   context 'with no attributes' do
     it 'records nothing in the module' do
       src = 'module Fred; end'
-      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      ctx = Reek::Core::CodeContext.new(nil, src.to_reek_source.syntax_tree)
       expect(@detector.examine_context(ctx)).to be_empty
     end
   end
@@ -29,7 +26,7 @@ describe Attribute do
 
     shared_examples_for 'one attribute found' do
       before :each do
-        ctx = CodeContext.new(nil, @src.to_reek_source.syntax_tree)
+        ctx = Reek::Core::CodeContext.new(nil, @src.to_reek_source.syntax_tree)
         @smells = @detector.examine_context(ctx)
       end
 
@@ -46,7 +43,7 @@ describe Attribute do
       end
 
       it 'reports the correct smell class' do
-        expect(@smells[0].smell_category).to eq(Attribute.smell_category)
+        expect(@smells[0].smell_category).to eq(described_class.smell_category)
       end
 
       it 'reports the context fq name' do

data/spec/reek/smells/boolean_parameter_spec.rb

@@ -2,9 +2,7 @@ require 'spec_helper'
 require 'reek/smells/boolean_parameter'
 require 'reek/smells/smell_detector_shared'
 
-include Reek::Smells
-
-describe BooleanParameter do
+describe Reek::Smells::BooleanParameter do
   context 'parameter defaulted with boolean' do
     context 'in a method' do
       it 'reports a parameter defaulted to true' do
@@ -14,51 +12,51 @@ describe BooleanParameter do
 
       it 'reports a parameter defaulted to false' do
         src = 'def cc(arga = false) end'
-        expect(src).to reek_of(BooleanParameter, name: 'arga')
+        expect(src).to reek_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 reek_of(BooleanParameter, name: 'arga')
-        expect(src).to reek_of(BooleanParameter, name: 'argb')
+        expect(src).to reek_of(:BooleanParameter, name: 'arga')
+        expect(src).to reek_of(:BooleanParameter, 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 reek_of(BooleanParameter, name: 'arga')
+        expect(src).to reek_of(:BooleanParameter, name: 'arga')
       end
       it 'reports a parameter defaulted to false' do
         src = 'def fred.cc(arga = false) end'
-        expect(src).to reek_of(BooleanParameter, name: 'arga')
+        expect(src).to reek_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 reek_of(BooleanParameter, name: 'arga')
-        expect(src).to reek_of(BooleanParameter, name: 'argb')
+        expect(src).to reek_of(:BooleanParameter, name: 'arga')
+        expect(src).to reek_of(:BooleanParameter, name: 'argb')
       end
     end
   end
 
   context 'when a smell is reported' do
     before(:each) do
-      @source_name = 'smokin'
-      @detector = BooleanParameter.new(@source_name)
+      @source_name = 'dummy_source'
+      @detector = build(:smell_detector, smell_type: :BooleanParameter, source: @source_name)
     end
 
     it_should_behave_like 'SmellDetector'
 
     it 'reports the fields correctly' do
       src = 'def cc(arga = true) end'
-      ctx = MethodContext.new(nil, src.to_reek_source.syntax_tree)
+      ctx = Reek::Core::MethodContext.new(nil, src.to_reek_source.syntax_tree)
       @detector.examine(ctx)
       smells = @detector.smells_found.to_a
       expect(smells.length).to eq(1)
-      expect(smells[0].smell_category).to eq(BooleanParameter.smell_category)
+      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].smell_type).to eq(BooleanParameter.smell_type)
+      expect(smells[0].smell_type).to eq(described_class.smell_type)
       expect(smells[0].lines).to eq([1])
     end
   end

data/spec/reek/smells/class_variable_spec.rb

@@ -3,13 +3,10 @@ require 'reek/smells/class_variable'
 require 'reek/core/module_context'
 require 'reek/smells/smell_detector_shared'
 
-include Reek::Core
-include Reek::Smells
-
-describe ClassVariable do
+describe Reek::Smells::ClassVariable do
   before :each do
-    @source_name = 'raffles'
-    @detector = ClassVariable.new(@source_name)
+    @source_name = 'dummy_source'
+    @detector = build(:smell_detector, smell_type: :ClassVariable, source: @source_name)
     @class_variable = '@@things'
   end
 
@@ -18,11 +15,12 @@ describe ClassVariable do
   context 'with no class variables' do
     it 'records nothing in the class' do
       exp = ast(:class, :Fred)
-      expect(@detector.examine_context(CodeContext.new(nil, exp))).to be_empty
+      expect(@detector.examine_context(Reek::Core::CodeContext.new(nil, exp))).to be_empty
     end
+
     it 'records nothing in the module' do
       exp = ast(:module, :Fred)
-      expect(@detector.examine_context(CodeContext.new(nil, exp))).to be_empty
+      expect(@detector.examine_context(Reek::Core::CodeContext.new(nil, exp))).to be_empty
     end
   end
 
@@ -30,11 +28,13 @@ describe ClassVariable do
     shared_examples_for 'one variable found' do
       before :each do
         ast = @src.to_reek_source.syntax_tree
-        @smells = @detector.examine_context(CodeContext.new(nil, ast))
+        @smells = @detector.examine_context(Reek::Core::CodeContext.new(nil, ast))
       end
+
       it 'records only that class variable' do
         expect(@smells.length).to eq(1)
       end
+
       it 'records the variable name' do
         expect(@smells[0].parameters[:name]).to eq(@class_variable)
       end
@@ -94,16 +94,16 @@ describe ClassVariable do
   end
 
   it 'reports the correct fields' do
-    src = <<EOS
-module Fred
-  #{@class_variable} = {}
-end
-EOS
-    ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+    src = <<-EOS
+      module Fred
+        #{@class_variable} = {}
+      end
+    EOS
+    ctx = Reek::Core::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_category).to eq(ClassVariable.smell_category)
-    expect(@warning.smell_type).to eq(ClassVariable.smell_type)
+    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

data/spec/reek/smells/control_parameter_spec.rb

@@ -2,12 +2,10 @@ require 'spec_helper'
 require 'reek/smells/control_parameter'
 require 'reek/smells/smell_detector_shared'
 
-include Reek::Smells
-
-describe ControlParameter do
+describe Reek::Smells::ControlParameter do
   before(:each) do
-    @source_name = 'lets get married'
-    @detector = ControlParameter.new(@source_name)
+    @source_name = 'dummy_source'
+    @detector = build(:smell_detector, smell_type: :ControlParameter, source: @source_name)
   end
 
   it_should_behave_like 'SmellDetector'
@@ -15,94 +13,94 @@ describe ControlParameter do
   context 'parameter not used to determine code path' do
     it 'does not report a ternary check on an ivar' do
       src = 'def simple(arga) @ivar ? arga : 3 end'
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report a ternary check on a lvar' do
       src = 'def simple(arga) lvar = 27; lvar ? arga : @ivar end'
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report when parameter is unused' do
       src = 'def simple(arg) test = 1 end'
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report when parameter is used inside conditional' do
       src = 'def simple(arg) if true then puts arg end end'
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
   end
 
   context 'parameter only used to determine code path' do
     it 'reports a ternary check on a parameter' do
       src = 'def simple(arga) arga ? @ivar : 3 end'
-      expect(src).to reek_of(ControlParameter, name: 'arga')
+      expect(src).to reek_of(:ControlParameter, name: 'arga')
     end
 
     it 'reports a couple inside a block' do
       src = 'def blocks(arg) @text.map { |blk| arg ? blk : "#{blk}" } end'
-      expect(src).to reek_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, name: 'arg')
     end
 
     it 'reports on an if statement modifier' do
       src = 'def simple(arg) args = {}; args.merge(\'a\' => \'A\') if arg end'
-      expect(src).to reek_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, name: 'arg')
     end
 
     it 'reports on an unless statement modifier' do
       src = 'def simple(arg) args = {}; args.merge(\'a\' => \'A\') unless arg end'
-      expect(src).to reek_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, name: 'arg')
     end
 
     it 'reports on if control expression' do
       src = 'def simple(arg) args = {}; if arg then args.merge(\'a\' => \'A\') end end'
-      expect(src).to reek_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, name: 'arg')
     end
 
     it 'reports on if control expression with &&' do
       src = 'def simple(arg) if arg && true then puts "arg" end end'
-      expect(src).to reek_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, name: 'arg')
     end
 
     it 'reports on if control expression with preceding &&' do
       src = 'def simple(arg) if true && arg then puts "arg" end end'
-      expect(src).to reek_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, name: 'arg')
     end
 
     it 'reports on if control expression with two && conditions' do
       src = 'def simple(a) ag = {}; if a && true && true then puts "2" end end'
-      expect(src).to reek_of(ControlParameter, name: 'a')
+      expect(src).to reek_of(:ControlParameter, name: 'a')
     end
 
     it 'reports on if control expression with ||' do
       src = 'def simple(arg) args = {}; if arg || true then puts "arg" end end'
-      expect(src).to reek_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, name: 'arg')
     end
 
     it 'reports on if control expression with or' do
       src = 'def simple(arg) args = {}; if arg or true then puts "arg" end end'
-      expect(src).to reek_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, name: 'arg')
     end
 
     it 'reports on if control expression with if' do
       src = 'def simple(arg) args = {}; if (arg if true) then puts "arg" end end'
-      expect(src).to reek_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, name: 'arg')
     end
 
     it 'reports on && notation' do
       src = 'def simple(arg) args = {}; arg && args.merge(\'a\' => \'A\') end'
-      expect(src).to reek_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, name: 'arg')
     end
 
     it 'reports on || notation' do
       src = 'def simple(arg) args = {}; arg || args.merge(\'a\' => \'A\') end'
-      expect(src).to reek_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, name: 'arg')
     end
 
     it 'reports on case statement' do
       src = 'def simple(arg) case arg when nil; nil when false; nil else nil end end'
-      expect(src).to reek_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, name: 'arg')
     end
 
     it 'reports on nested if statements that are both control parameters' do
@@ -114,7 +112,7 @@ describe ControlParameter do
           end
         end
       EOS
-      expect(src).to reek_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, name: 'arg')
     end
 
     it 'reports on nested if statements where the inner if is a control parameter' do
@@ -126,32 +124,32 @@ describe ControlParameter do
           end
         end
       EOS
-      expect(src).to reek_of(ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, name: 'arg')
     end
 
     it 'reports on explicit comparison in the condition' do
       src = 'def simple(arg) if arg == :foo then :foo else :bar end end'
-      expect(src).to reek_of(ControlParameter)
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports on explicit negative comparison in the condition' do
       src = 'def simple(arg) if arg != :foo then :bar else :foo end end'
-      expect(src).to reek_of(ControlParameter)
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports when the argument is compared to a regexp' do
       src = 'def simple(arg) if arg =~ /foo/ then :foo else :bar end end'
-      expect(src).to reek_of(ControlParameter)
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports when the argument is reverse-compared to a regexp' do
       src = 'def simple(arg) if /foo/ =~ arg then :foo else :bar end end'
-      expect(src).to reek_of(ControlParameter)
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports when the argument is used in a complex regexp' do
       src = 'def simple(arg) if /foo#{arg}/ =~ bar then :foo else :bar end end'
-      expect(src).to reek_of(ControlParameter)
+      expect(src).to reek_of(:ControlParameter)
     end
 
     it 'reports when the argument is a block parameter' do
@@ -160,64 +158,64 @@ describe ControlParameter do
           bar(blk || proc {})
         end
       EOS
-      expect(src).to reek_of(ControlParameter)
+      expect(src).to reek_of(:ControlParameter)
     end
   end
 
   context 'parameter used besides determining code path' do
     it 'does not report on if conditional expression' do
       src = 'def simple(arg) if arg then use(arg) else use(@other) end end'
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report on an if statement modifier' do
       src = 'def simple(arg) args = {}; args.merge(\'a\' => arg) if arg end'
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report on an unless statement modifier' do
       src = 'def simple(arg) args = {}; args.merge(\'a\' => arg) unless arg end'
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report on if control expression' do
       src = 'def simple(arg) args = {}; if arg then args.merge(\'a\' => arg) end end'
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report on if control expression with &&' do
       src = 'def simple(arg) if arg && true then puts arg end end'
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report on && notation' do
       src = 'def simple(arg) args = {}; arg && args.merge(\'a\' => arg) end'
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report on || notation' do
       src = 'def simple(arg) args = {}; arg || args.merge(\'a\' => arg) end'
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report when parameter is used outside conditional' do
       src = 'def simple(arg) puts arg; if arg then @a = 1 end end'
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report when parameter is used as a method call argument in a condition' do
       src = 'def simple(arg) if foo(arg) then @a = 1 end end'
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report when parameter is used as a method call receiver in a condition' do
       src = 'def simple(arg) if arg.foo? then @a = 1 end end'
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report when the argument is a hash on which we access a key' do
       src = 'def simple(arg) if arg[\'a\'] then puts \'a\' else puts \'b\' end end'
-      expect(src).not_to reek_of ControlParameter
+      expect(src).not_to reek_of :ControlParameter
     end
 
     it 'does not report when used in first conditional but not second' do
@@ -231,7 +229,7 @@ describe ControlParameter do
           end
         end
       EOS
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report when used in second conditional but not first' do
@@ -245,7 +243,7 @@ describe ControlParameter do
           end
         end
       EOS
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
 
     it 'does not report when used in body of control flow operator' do
@@ -260,7 +258,7 @@ describe ControlParameter do
           qux or quuz(arg)
         end
       EOS
-      expect(src).not_to reek_of(ControlParameter)
+      expect(src).not_to reek_of(:ControlParameter)
     end
   end
 
@@ -274,7 +272,7 @@ describe ControlParameter do
           puts "hello" if arg
         end
       EOS
-      ctx = MethodContext.new(nil, src.to_reek_source.syntax_tree)
+      ctx = Reek::Core::MethodContext.new(nil, src.to_reek_source.syntax_tree)
       smells = @detector.examine(ctx)
       expect(smells.length).to eq(1)
       @warning = smells[0]