reek 1.5.1 → 1.6.0

data/spec/reek/smells/control_parameter_spec.rb

@@ -12,7 +12,6 @@ describe ControlParameter do
 
   it_should_behave_like 'SmellDetector'
 
-
   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'
@@ -35,76 +34,75 @@ describe ControlParameter do
     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 smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arga')
+      expect(src).to smell_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 smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_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 smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_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 smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_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 smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_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 smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_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 smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_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 smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'a')
+      expect(src).to smell_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 smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_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 smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_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 smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on && notation' do
       src = 'def simple(arg) args = {}; arg && args.merge(\'a\' => \'A\') end'
-      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on || notation' do
       src = 'def simple(arg) args = {}; arg || args.merge(\'a\' => \'A\') end'
-      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_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 smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on nested if statements that are both control parameters' do
@@ -116,7 +114,7 @@ describe ControlParameter do
           end
         end
       EOS
-      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on nested if statements where the inner if is a control parameter' do
@@ -128,7 +126,7 @@ describe ControlParameter do
           end
         end
       EOS
-      expect(src).to smell_of(ControlParameter, ControlParameter::PARAMETER_KEY => 'arg')
+      expect(src).to smell_of(ControlParameter, name: 'arg')
     end
 
     it 'reports on explicit comparison in the condition' do
@@ -285,7 +283,7 @@ describe ControlParameter do
     it_should_behave_like 'common fields set correctly'
 
     it 'has the correct fields' do
-      expect(@warning.smell[ControlParameter::PARAMETER_KEY]).to eq('arg')
+      expect(@warning.parameters[:name]).to eq('arg')
       expect(@warning.lines).to eq([3, 5])
     end
   end

data/spec/reek/smells/data_clump_spec.rb

@@ -27,29 +27,27 @@ EOS
   def third(pa, pb) pa - pb + @fred; end
 end
 EOS
-      ctx = CodeContext.new(nil, @src.to_reek_source.syntax_tree)
+      ctx = ModuleContext.new(nil, @src.to_reek_source.syntax_tree)
       detector = DataClump.new('newt')
       @smells = detector.examine_context(ctx)
-      @warning = @smells[0]   # SMELL: too cumbersome!
-      @yaml = @warning.to_yaml
     end
     it 'records only the one smell' do
       expect(@smells.length).to eq(1)
     end
     it 'reports all parameters' do
-      expect(@smells[0].smell[DataClump::PARAMETERS_KEY]).to eq(['pa', 'pb'])
+      expect(@smells[0].parameters[:parameters]).to eq(['pa', 'pb'])
     end
     it 'reports the number of occurrences' do
-      expect(@smells[0].smell[DataClump::OCCURRENCES_KEY]).to eq(3)
+      expect(@smells[0].parameters[:count]).to eq(3)
     end
     it 'reports all methods' do
-      expect(@smells[0].smell[DataClump::METHODS_KEY]).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])
     end
     it 'reports the correct smell class' do
-      expect(@smells[0].smell_class).to eq(DataClump::SMELL_CLASS)
+      expect(@smells[0].smell_category).to eq(DataClump.smell_category)
     end
     it 'reports the context fq name' do
       expect(@smells[0].context).to eq(@module_name)
@@ -65,8 +63,8 @@ EOS
 end
 EOS
     expect(src).to smell_of(DataClump,
-                            DataClump::OCCURRENCES_KEY => 3,
-                            DataClump::PARAMETERS_KEY => ['pa', 'pb'])
+                            count: 3,
+                            parameters: ['pa', 'pb'])
   end
 
   it 'reports 3 identical parameter sets' do
@@ -78,8 +76,8 @@ EOS
 end
 EOS
     expect(src).to smell_of(DataClump,
-                            DataClump::OCCURRENCES_KEY => 3,
-                            DataClump::PARAMETERS_KEY => ['pa', 'pb', 'pc'])
+                            count: 3,
+                            parameters: ['pa', 'pb', 'pc'])
   end
 
   it 'reports re-ordered identical parameter sets' do
@@ -91,8 +89,8 @@ EOS
 end
 EOS
     expect(src).to smell_of(DataClump,
-                            DataClump::OCCURRENCES_KEY => 3,
-                            DataClump::PARAMETERS_KEY => ['pa', 'pb', 'pc'])
+                            count: 3,
+                            parameters: ['pa', 'pb', 'pc'])
   end
 
   it 'counts only identical parameter sets' do
@@ -116,7 +114,7 @@ EOS
   def c_raw_singleton (src, options) end
 end
 EOS
-    expect(src).to smell_of(DataClump, DataClump::OCCURRENCES_KEY => 5)
+    expect(src).to smell_of(DataClump, count: 5)
   end
 
   it 'correctly checks number of occurences' do
@@ -141,7 +139,19 @@ EOS
       end
     EOS
     expect(src).to smell_of(DataClump,
-                            DataClump::PARAMETERS_KEY => %w(p1 p2))
+                            parameters: %w(p1 p2))
+  end
+
+  it 'ignores anonymous parameters' do
+    src = <<-EOS
+      #{@context} Smelly
+        def fa(p1, p2, *) end
+        def fb(p1, p2, *) end
+        def fc(p1, p2, *) end
+      end
+    EOS
+    expect(src).to smell_of(DataClump,
+                            parameters: %w(p1 p2))
   end
 end
 

data/spec/reek/smells/duplicate_method_call_spec.rb

@@ -8,7 +8,6 @@ include Reek
 include Reek::Smells
 
 describe DuplicateMethodCall do
-
   context 'when a smell is reported' do
     before :each do
       @source_name = 'copy-cat'
@@ -30,7 +29,7 @@ EOS
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the call' do
-      expect(@warning.smell[DuplicateMethodCall::CALL_KEY]).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])
@@ -40,20 +39,20 @@ EOS
   context 'with repeated method calls' do
     it 'reports repeated call' do
       src = 'def double_thing() @other.thing + @other.thing end'
-      expect(src).to smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => '@other.thing')
+      expect(src).to smell_of(DuplicateMethodCall, name: '@other.thing')
     end
     it 'reports repeated call to lvar' do
       src = 'def double_thing(other) other[@thing] + other[@thing] end'
-      expect(src).to smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => 'other[@thing]')
+      expect(src).to smell_of(DuplicateMethodCall, name: 'other[@thing]')
     end
     it 'reports call parameters' do
       src = 'def double_thing() @other.thing(2,3) + @other.thing(2,3) end'
-      expect(src).to smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => '@other.thing(2, 3)')
+      expect(src).to smell_of(DuplicateMethodCall, name: '@other.thing(2, 3)')
     end
     it 'should report nested calls' do
       src = 'def double_thing() @other.thing.foo + @other.thing.foo end'
-      expect(src).to smell_of(DuplicateMethodCall, { DuplicateMethodCall::CALL_KEY => '@other.thing' },
-                              DuplicateMethodCall::CALL_KEY => '@other.thing.foo')
+      expect(src).to smell_of(DuplicateMethodCall, { name: '@other.thing' },
+                              { name: '@other.thing.foo' })
     end
     it 'should ignore calls to new' do
       src = 'def double_thing() @other.new + @other.new end'
@@ -124,7 +123,7 @@ EOS
   context 'with repeated attribute assignment' do
     it 'reports repeated assignment' do
       src = 'def double_thing(thing) @other[thing] = true; @other[thing] = true; end'
-      expect(src).to smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => '@other[thing] = true')
+      expect(src).to smell_of(DuplicateMethodCall, name: '@other[thing] = true')
     end
     it 'does not report multi-assignments' do
       src = <<EOS
@@ -161,8 +160,13 @@ EOS
       expect(src).not_to smell_of(DuplicateMethodCall).with_config(@config)
     end
     it 'reports quadruple calls' do
-      src = 'def double_thing() @other.thing + @other.thing + @other.thing + @other.thing end'
-      expect(src).to smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => '@other.thing', DuplicateMethodCall::OCCURRENCES_KEY => 4).with_config(@config)
+      src = '
+        def double_thing()
+          @other.thing + @other.thing + @other.thing + @other.thing
+        end
+      '
+      expect(src).to smell_of(DuplicateMethodCall, name: '@other.thing', count: 4).
+        with_config(@config)
     end
   end
 
@@ -176,11 +180,13 @@ EOS
     end
     it 'reports calls to other methods' do
       src = 'def double_other_thing() @other.thing + @other.thing end'
-      expect(src).to smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => '@other.thing').with_config(@config)
+      expect(src).to smell_of(DuplicateMethodCall, name: '@other.thing').
+        with_config(@config)
     end
     it 'does not report calls to methods specifed with a regular expression' do
       src = 'def double_puts() puts @other.thing; puts @other.thing end'
-      expect(src).to smell_of(DuplicateMethodCall, DuplicateMethodCall::CALL_KEY => '@other.thing').with_config(@config)
+      expect(src).to smell_of(DuplicateMethodCall, name: '@other.thing').
+        with_config(@config)
     end
   end
 end

data/spec/reek/smells/feature_envy_spec.rb

@@ -69,7 +69,11 @@ EOS
 
   context 'with 2 calls to a parameter' do
     it 'reports the smell' do
-      expect('def envy(arga) arga.b(arga) + arga.c(@fred) end').to reek_only_of(:FeatureEnvy, /arga/)
+      expect('
+        def envy(arga)
+          arga.b(arga) + arga.c(@fred)
+        end
+      ').to reek_only_of(:FeatureEnvy, /arga/)
     end
   end
 
@@ -100,15 +104,30 @@ EOS
   end
 
   it 'should not be fooled by duplication' do
-    expect('def feed(thing) @cow.feed_to(thing.pig); @duck.feed_to(thing.pig) end').to reek_only_of(:Duplication, /thing.pig/)
+    expect('
+      def feed(thing)
+        @cow.feed_to(thing.pig)
+        @duck.feed_to(thing.pig)
+      end
+    ').to reek_only_of(:Duplication, /thing.pig/)
   end
 
   it 'should count local calls' do
-    expect('def feed(thing) cow.feed_to(thing.pig); duck.feed_to(thing.pig) end').to reek_only_of(:Duplication, /thing.pig/)
+    expect('
+      def feed(thing)
+        cow.feed_to(thing.pig)
+        duck.feed_to(thing.pig)
+      end
+    ').to reek_only_of(:Duplication, /thing.pig/)
   end
 
   it 'should report many calls to lvar' do
-    expect('def envy() lv = @item; lv.price + lv.tax; end').to reek_only_of(:FeatureEnvy, /lv/)
+    expect('
+      def envy()
+        lv = @item
+        lv.price + lv.tax
+      end
+    ').to reek_only_of(:FeatureEnvy, /lv/)
     #
     # def moved_version
     #   price + tax
@@ -228,17 +247,17 @@ EOS
     it 'reports the source' do
       expect(@smells[0].source).to eq(@source_name)
     end
-    it 'reports the class' do
-      expect(@smells[0].smell_class).to eq(FeatureEnvy::SMELL_CLASS)
+    it 'reports the smell class' do
+      expect(@smells[0].smell_category).to eq(FeatureEnvy.smell_category)
     end
-    it 'reports the subclass' do
-      expect(@smells[0].subclass).to eq(FeatureEnvy::SMELL_SUBCLASS)
+    it 'reports the smell sub class' do
+      expect(@smells[0].smell_type).to eq(FeatureEnvy.smell_type)
     end
     it 'reports the envious receiver' do
-      expect(@smells[0].smell[FeatureEnvy::RECEIVER_KEY]).to eq(@receiver)
+      expect(@smells[0].parameters[:name]).to eq(@receiver)
     end
     it 'reports the number of references' do
-      expect(@smells[0].smell[FeatureEnvy::REFERENCES_KEY]).to eq(3)
+      expect(@smells[0].parameters[:count]).to eq(3)
     end
     it 'reports the referring lines' do
       skip

data/spec/reek/smells/irresponsible_module_spec.rb

@@ -35,10 +35,10 @@ describe IrresponsibleModule do
     ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
     smells = @detector.examine_context(ctx)
     expect(smells.length).to eq(1)
-    expect(smells[0].smell_class).to eq(IrresponsibleModule::SMELL_CLASS)
-    expect(smells[0].subclass).to eq(IrresponsibleModule::SMELL_SUBCLASS)
+    expect(smells[0].smell_category).to eq(IrresponsibleModule.smell_category)
+    expect(smells[0].smell_type).to eq(IrresponsibleModule.smell_type)
     expect(smells[0].lines).to eq([1])
-    expect(smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY]).to eq(@bad_module_name)
+    expect(smells[0].parameters[:name]).to eq(@bad_module_name)
   end
 
   it 'reports a class with an empty comment' do
@@ -67,9 +67,9 @@ describe IrresponsibleModule do
     ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
     smells = @detector.examine_context(ctx)
     expect(smells.length).to eq(1)
-    expect(smells[0].smell_class).to eq(IrresponsibleModule::SMELL_CLASS)
-    expect(smells[0].subclass).to eq(IrresponsibleModule::SMELL_SUBCLASS)
-    expect(smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY]).to eq('Foo::Bar')
-    expect(smells[0].context).to match(/#{smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY]}/)
+    expect(smells[0].smell_category).to eq(IrresponsibleModule.smell_category)
+    expect(smells[0].smell_type).to eq(IrresponsibleModule.smell_type)
+    expect(smells[0].parameters[:name]).to eq('Foo::Bar')
+    expect(smells[0].context).to match(/#{smells[0].parameters['name']}/)
   end
 end

data/spec/reek/smells/long_parameter_list_spec.rb

@@ -6,7 +6,6 @@ include Reek
 include Reek::Smells
 
 describe LongParameterList do
-
   context 'for methods with few parameters' do
     it 'should report nothing for no parameters' do
       expect('def simple; f(3);true; end').not_to smell_of(LongParameterList)
@@ -18,10 +17,15 @@ describe LongParameterList do
       expect('def simple(yep,zero) f(3);true end').not_to smell_of(LongParameterList)
     end
     it 'should not count an optional block' do
-      expect('def simple(alpha, yep, zero, &opt) f(3);true end').not_to smell_of(LongParameterList)
+      src = 'def simple(alpha, yep, zero, &opt) f(3); true end'
+      expect(src).not_to smell_of(LongParameterList)
     end
     it 'should not report inner block with too many parameters' do
-      src = 'def simple(yep,zero); m[3]; rand(34); f.each { |arga, argb, argc, argd| true}; end'
+      src = '
+        def simple(yep,zero)
+          m[3]; rand(34); f.each { |arga, argb, argc, argd| true}
+        end
+      '
       expect(src).not_to smell_of(LongParameterList)
     end
 
@@ -30,10 +34,12 @@ describe LongParameterList do
         expect('def simple(zero=nil) f(3);false end').not_to smell_of(LongParameterList)
       end
       it 'should report nothing for 2 parameters with 1 default' do
-        expect('def simple(yep, zero=nil) f(3);false end').not_to smell_of(LongParameterList)
+        source = 'def simple(yep, zero=nil) f(3); false end'
+        expect(source).not_to smell_of(LongParameterList)
       end
       it 'should report nothing for 2 defaulted parameters' do
-        expect('def simple(yep=4, zero=nil) f(3);false end').not_to smell_of(LongParameterList)
+        source = 'def simple(yep=4, zero=nil) f(3); false end'
+        expect(source).not_to smell_of(LongParameterList)
       end
     end
   end
@@ -41,21 +47,21 @@ describe LongParameterList do
   describe 'for methods with too many parameters' do
     it 'should report 4 parameters' do
       src = 'def simple(arga, argb, argc, argd) f(3);true end'
-      expect(src).to smell_of(LongParameterList, LongParameterList::PARAMETER_COUNT_KEY => 4)
+      expect(src).to smell_of(LongParameterList, count: 4)
     end
     it 'should report 8 parameters' do
       src = 'def simple(arga, argb, argc, argd,arge, argf, argg, argh) f(3);true end'
-      expect(src).to smell_of(LongParameterList, LongParameterList::PARAMETER_COUNT_KEY => 8)
+      expect(src).to smell_of(LongParameterList, count: 8)
     end
 
     describe 'and default values' do
       it 'should report 3 with 1 defaulted' do
         src = 'def simple(polly, queue, yep, zero=nil) f(3);false end'
-        expect(src).to smell_of(LongParameterList, LongParameterList::PARAMETER_COUNT_KEY => 4)
+        expect(src).to smell_of(LongParameterList, count: 4)
       end
       it 'should report with 3 defaulted' do
         src = 'def simple(aarg, polly=2, yep=:truth, zero=nil) f(3);false end'
-        expect(src).to smell_of(LongParameterList, LongParameterList::PARAMETER_COUNT_KEY => 4)
+        expect(src).to smell_of(LongParameterList, count: 4)
       end
     end
   end
@@ -85,7 +91,7 @@ EOS
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the number of parameters' do
-      expect(@warning.smell[LongParameterList::PARAMETER_COUNT_KEY]).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])