reek 1.2.7.3 → 1.2.8

data/spec/reek/smells/duplication_spec.rb

@@ -8,29 +8,63 @@ include Reek
 include Reek::Smells
 
 describe Duplication do
+
+  context 'when a smell is reported' do
+    before :each do
+      @source_name = 'copy-cat'
+      @detector = Duplication.new(@source_name)
+      src = <<EOS
+def double_thing(other)
+  other[@thing]
+  not_the_sam(at = all)
+  other[@thing]
+end
+EOS
+      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      smells = @detector.examine_context(ctx)
+      smells.length.should == 1
+      @warning = smells[0]
+    end
+
+    it_should_behave_like 'SmellDetector'
+    it_should_behave_like 'common fields set correctly'
+
+    it 'reports the call' do
+      @warning.smell[Duplication::CALL_KEY].should == 'other[@thing]'
+    end
+    it 'reports the correct lines' do
+      @warning.lines.should == [2,4]
+    end
+  end
+
   context "with repeated method calls" do
     it 'reports repeated call' do
-      'def double_thing() @other.thing + @other.thing end'.should reek_only_of(:Duplication, /@other.thing/)
+      src = 'def double_thing() @other.thing + @other.thing end'
+      src.should smell_of(Duplication, Duplication::CALL_KEY => '@other.thing')
     end
     it 'reports repeated call to lvar' do
-      'def double_thing(other) other[@thing] + other[@thing] end'.should reek_only_of(:Duplication, /other\[@thing\]/)
+      src = 'def double_thing(other) other[@thing] + other[@thing] end'
+      src.should smell_of(Duplication, Duplication::CALL_KEY => 'other[@thing]')
     end
     it 'reports call parameters' do
-      'def double_thing() @other.thing(2,3) + @other.thing(2,3) end'.should reek_only_of(:Duplication, /@other.thing\(2, 3\)/)
+      src = 'def double_thing() @other.thing(2,3) + @other.thing(2,3) end'
+      src.should smell_of(Duplication, Duplication::CALL_KEY => '@other.thing(2, 3)')
     end
     it 'should report nested calls' do
-      ruby = 'def double_thing() @other.thing.foo + @other.thing.foo end'
-      ruby.should reek_of(:Duplication, /@other.thing[^\.]/)
-      ruby.should reek_of(:Duplication, /@other.thing.foo/)
+      src = 'def double_thing() @other.thing.foo + @other.thing.foo end'
+      src.should smell_of(Duplication, {Duplication::CALL_KEY => '@other.thing'},
+                                       {Duplication::CALL_KEY => '@other.thing.foo'})
     end
     it 'should ignore calls to new' do
-      'def double_thing() @other.new + @other.new end'.should_not reek
+      src = 'def double_thing() @other.new + @other.new end'
+      src.should_not smell_of(Duplication)
     end
   end
 
   context 'with repeated attribute assignment' do
     it 'reports repeated assignment' do
-      'def double_thing(thing) @other[thing] = true; @other[thing] = true; end'.should reek_only_of(:Duplication, /@other\[thing\] = true/)
+      src = 'def double_thing(thing) @other[thing] = true; @other[thing] = true; end'
+      src.should smell_of(Duplication, Duplication::CALL_KEY => '@other[thing] = true')
     end
     it 'does not report multi-assignments' do
       src = <<EOS
@@ -39,58 +73,54 @@ def _parse ctxt
   error, ctxt.index = @err, @err_ind
 end
 EOS
-      src.should_not reek
+      src.should_not smell_of(Duplication)
     end
   end
-end
-
-describe Duplication, "non-repeated method calls" do
-  it 'should not report similar calls' do
-    'def equals(other) other.thing == self.thing end'.should_not reek
-  end
 
-  it 'should respect call parameters' do
-    'def double_thing() @other.thing(3) + @other.thing(2) end'.should_not reek
-  end
-end
-
-describe Duplication do
-  before(:each) do
-    @source_name = 'copy-cat'
-    @detector = Duplication.new(@source_name)
+  context "non-repeated method calls" do
+    it 'should not report similar calls' do
+      src = 'def equals(other) other.thing == self.thing end'
+      src.should_not smell_of(Duplication)
+    end
+    it 'should respect call parameters' do
+      src = 'def double_thing() @other.thing(3) + @other.thing(2) end'
+      src.should_not smell_of(Duplication)
+    end
   end
 
-  it_should_behave_like 'SmellDetector'
-
-  context 'when a smell is reported' do
+  context "allowing up to 3 calls" do
     before :each do
-      src = <<EOS
-def double_thing(other)
-  other[@thing]
-  not_the_sam(at = all)
-  other[@thing]
-end
-EOS
-      source = src.to_reek_source
-      sniffer = Core::Sniffer.new(source)
-      @mctx = Core::CodeParser.new(sniffer).process_defn(source.syntax_tree)
-      @detector.examine(@mctx)
-      @warning = @detector.smells_found.to_a[0]   # SMELL: too cumbersome!
+      @config = {Duplication::MAX_ALLOWED_CALLS_KEY => 3}
     end
-    it 'reports the source' do
-      @warning.source.should == @source_name
+    it 'does not report double calls' do
+      src = 'def double_thing() @other.thing + @other.thing end'
+      src.should_not smell_of(Duplication).with_config(@config)
     end
-    it 'reports the class' do
-      @warning.smell_class.should == 'Duplication'
+    it 'does not report triple calls' do
+      src = 'def double_thing() @other.thing + @other.thing + @other.thing end'
+      src.should_not smell_of(Duplication).with_config(@config)
     end
-    it 'reports the subclass' do
-      @warning.subclass.should == 'DuplicateMethodCall'
+    it 'reports quadruple calls' do
+      src = 'def double_thing() @other.thing + @other.thing + @other.thing + @other.thing end'
+      src.should smell_of(Duplication, {Duplication::CALL_KEY => '@other.thing', Duplication::OCCURRENCES_KEY => 4}).with_config(@config)
     end
-    it 'reports the call' do
-      @warning.smell['call'].should == 'other[@thing]'
+  end
+
+  context "allowing calls to some methods" do
+    before :each do
+      @config = {Duplication::ALLOW_CALLS_KEY => ['@some.thing',/puts/]}
     end
-    it 'reports the correct lines' do
-      @warning.lines.should == [2,4]
+    it 'does not report calls to some methods' do
+      src = 'def double_some_thing() @some.thing + @some.thing end'
+      src.should_not smell_of(Duplication).with_config(@config)
+    end
+    it 'reports calls to other methods' do
+      src = 'def double_other_thing() @other.thing + @other.thing end'
+      src.should smell_of(Duplication, {Duplication::CALL_KEY => '@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'
+      src.should smell_of(Duplication, {Duplication::CALL_KEY => '@other.thing'}).with_config(@config)
     end
   end
 end

data/spec/reek/smells/feature_envy_spec.rb

@@ -190,8 +190,7 @@ EOS
       source = src.to_reek_source
       sniffer = Sniffer.new(source)
       @mctx = CodeParser.new(sniffer).process_defn(source.syntax_tree)
-      @detector.examine_context(@mctx)
-      @smells = @detector.smells_found.to_a
+      @smells = @detector.examine_context(@mctx)
     end
     it 'reports only that smell' do
       @smells.length.should == 1

data/spec/reek/smells/irresponsible_module_spec.rb

@@ -5,33 +5,54 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'smell_detector_shar
 include Reek::Smells
 
 describe IrresponsibleModule do
-  ['class'].each do |unit|
-    it "does not report a #{unit} having a comment" do
-      src = <<EOS
-# test #{unit}
-#{unit} Responsible; end
+  before(:each) do
+    @bad_module_name = 'WrongUn'
+    @detector = IrresponsibleModule.new('yoof')
+  end
+
+  it_should_behave_like 'SmellDetector'
+
+  it "does not report a class having a comment" do
+    src = <<EOS
+# test class
+class Responsible; end
 EOS
-      src.should_not reek
-    end
-    it "reports a #{unit} without a comment" do
-      "#{unit} Responsible; end".should reek_only_of(:IrresponsibleModule, /Responsible/)
-    end
-    it "reports a #{unit} with an empty comment" do
-      src = <<EOS
+    ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+    @detector.examine_context(ctx).should be_empty
+  end
+  it "reports a class without a comment" do
+    src = "class #{@bad_module_name}; end"
+    ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+    smells = @detector.examine_context(ctx)
+    smells.length.should == 1
+    smells[0].smell_class.should == IrresponsibleModule::SMELL_CLASS
+    smells[0].subclass.should == IrresponsibleModule::SMELL_SUBCLASS
+    smells[0].lines.should == [1]
+    smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY].should == @bad_module_name
+  end
+  it "reports a class with an empty comment" do
+    src = <<EOS
 #
 #
 #  
-#{unit} Responsible; end
+class #{@bad_module_name}; end
 EOS
-      src.should reek_only_of(:IrresponsibleModule, /Responsible/)
-    end
+    ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+    smells = @detector.examine_context(ctx)
+    smells.length.should == 1
+    smells[0].smell_class.should == IrresponsibleModule::SMELL_CLASS
+    smells[0].subclass.should == IrresponsibleModule::SMELL_SUBCLASS
+    smells[0].lines.should == [4]
+    smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY].should == @bad_module_name
   end
-end
-
-describe IrresponsibleModule do
-  before(:each) do
-    @detector = IrresponsibleModule.new('yoof')
+  it 'reports a fq module name correctly' do
+    src = 'class Foo::Bar; end'
+    ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+    smells = @detector.examine_context(ctx)
+    smells.length.should == 1
+    smells[0].smell_class.should == IrresponsibleModule::SMELL_CLASS
+    smells[0].subclass.should == IrresponsibleModule::SMELL_SUBCLASS
+    smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY].should == 'Foo::Bar'
+    smells[0].context.should match(/#{smells[0].smell[IrresponsibleModule::MODULE_NAME_KEY]}/)
   end
-
-  it_should_behave_like 'SmellDetector'
 end

data/spec/reek/smells/large_class_spec.rb

@@ -7,7 +7,13 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'smell_detector_shar
 include Reek
 include Reek::Smells
 
-describe LargeClass, 'checking source code' do
+describe LargeClass do
+  before(:each) do
+    @source_name = 'elephant'
+    @detector = LargeClass.new(@source_name)
+  end
+
+  it_should_behave_like 'SmellDetector'
 
   context 'counting instance variables' do
     it 'should not report 9 ivars' do
@@ -49,7 +55,8 @@ class Full
   def me41x()3 end;def me42x()3 end;def me43x()3 end;def me44x()3 end;def me45x()3 end
 end
 EOS
-      src.should_not reek
+      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      @detector.examine_context(ctx).should be_empty
     end
 
     it 'should report 26 methods' do
@@ -63,7 +70,11 @@ class Full
   def me51x()3 end
 end
 EOS
-      src.should reek_of(:LargeClass)
+      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      smells = @detector.examine_context(ctx)
+      smells.length.should == 1
+      smells[0].subclass.should == LargeClass::SUBCLASS_TOO_MANY_METHODS
+      smells[0].smell[LargeClass::METHOD_COUNT_KEY].should == 26
     end
   end
 
@@ -79,22 +90,13 @@ class Full
   def me51x()3 end
 end
 EOS
-      src.should_not reek_of(:LargeClass)
+      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      @detector.examine_context(ctx).should be_empty
     end
   end
-end
-
-describe LargeClass, 'looking at the YAML' do
-  before(:each) do
-    @source_name = 'elephant'
-    @detector = LargeClass.new(@source_name)
-  end
-
-  it_should_behave_like 'SmellDetector'
 
-  context 'when the class has many methods' do
-    before :each do
-      src = <<EOS
+  it 'reports correctly when the class has many methods' do
+    src = <<EOS
 class Full
   def me01x()3 end;def me02x()3 end;def me03x()3 end;def me04x()3 end;def me05x()3 end
   def me11x()3 end;def me12x()3 end;def me13x()3 end;def me14x()3 end;def me15x()3 end
@@ -104,29 +106,17 @@ class Full
   def me51x()3 end
 end
 EOS
-      @yaml = Examiner.new(src).smells[0].to_yaml
-    end
-    it 'reports the source' do
-      @yaml.should match(/source:\s*string/)
-    end
-    it 'reports the correct class' do
-      @yaml.should match(/\sclass:\s*LargeClass/)
-    end
-    it 'reports the correct subclass' do
-      @yaml.should match(/\ssubclass:\s*#{LargeClass::SUBCLASS_TOO_MANY_METHODS}/)
-    end
-    it 'reports the number of methods' do
-      @yaml.should match(/method_count:[\s]*26/)
-      # SMELL: many tests duplicate the names of the YAML fields
-    end
-    it 'reports the line number of the declaration' do
-      @yaml.should match(/lines:\s*- 1/)
-    end
+    ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+    @warning = @detector.examine_context(ctx)[0]
+    @warning.source.should == @source_name
+    @warning.smell_class.should == 'LargeClass'
+    @warning.subclass.should == LargeClass::SUBCLASS_TOO_MANY_METHODS
+    @warning.smell[LargeClass::METHOD_COUNT_KEY].should == 26
+    @warning.lines.should == [1]
   end
 
-  context 'when the class has 30 instance variables' do
-    before :each do
-      src = <<EOS
+  it 'reports correctly when the class has 30 instance variables' do
+    src = <<EOS
 # smelly class for testing purposes
 class Empty
   def ivars
@@ -134,27 +124,12 @@ class Empty
   end
 end
 EOS
-      source = src.to_reek_source
-      sniffer = Core::Sniffer.new(source)
-      ctx = Core::CodeParser.new(sniffer).process_class(source.syntax_tree)
-      @detector.examine_context(ctx)
-      @yaml = @detector.smells_found.to_a[0].to_yaml   # SMELL: too cumbersome!
-    end
-    it 'reports the source' do
-      @yaml.should match(/source:\s*#{@source_name}/)
-    end
-    it 'reports the correct class' do
-      @yaml.should match(/\sclass:\s*LargeClass/)
-    end
-    it 'reports the correct subclass' do
-      @yaml.should match(/\ssubclass:\s*#{LargeClass::SUBCLASS_TOO_MANY_IVARS}/)
-    end
-    it 'reports the number of methods' do
-      @yaml.should match(/ivar_count:\s*10/)
-      # SMELL: many tests duplicate the names of the YAML fields
-    end
-    it 'reports the line number of the declaration' do
-      @yaml.should match(/lines:\s*- 2/)
-    end
+    ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+    @warning = @detector.examine_context(ctx)[0]
+    @warning.source.should == @source_name
+    @warning.smell_class.should == 'LargeClass'
+    @warning.subclass.should == LargeClass::SUBCLASS_TOO_MANY_IVARS
+    @warning.smell[LargeClass::IVAR_COUNT_KEY].should == 10
+    @warning.lines.should == [2]
   end
 end

data/spec/reek/smells/long_method_spec.rb

@@ -15,15 +15,18 @@ end
 
 describe LongMethod do
   it 'should not report short methods' do
-    'def short(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;end'.should_not reek
+    src = 'def short(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;end'
+    src.should_not smell_of(LongMethod)
   end
 
   it 'should report long methods' do
-    'def long(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;@fry = 6;end'.should reek_only_of(:LongMethod, /6 statements/)
+    src = 'def long(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;@fry = 6;end'
+    src.should reek_only_of(:LongMethod, /6 statements/)
   end
 
   it 'should not report initialize' do
-    'def initialize(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;@fry = 6;end'.should_not reek
+    src = 'def initialize(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;@fry = 6;end'
+    src.should_not smell_of(LongMethod)
   end
 
   it 'should only report a long method once' do
@@ -205,17 +208,19 @@ describe LongMethod do
   context 'when the method has 30 statements' do
     before :each do
       @num_statements = 30
-      @ctx = mock('method_context', :null_object => true)
-      @ctx.should_receive(:num_statements).and_return(@num_statements)
-      @detector.examine_context(@ctx)
-      @yaml = @detector.smells_found.to_a[0].to_yaml   # SMELL: too cumbersome!
+      ctx = mock('method_context', :null_object => true)
+      ctx.should_receive(:num_statements).and_return(@num_statements)
+      ctx.should_receive(:config).and_return({})
+      @smells = @detector.examine_context(ctx)
+    end
+    it 'reports only 1 smell' do
+      @smells.length.should == 1
     end
     it 'reports the number of statements' do
-      @yaml.should match(/statement_count:[\s]*#{@num_statements}/)
-      # SMELL: many tests duplicate the names of the YAML fields
+      @smells[0].smell[LongMethod::STATEMENT_COUNT_KEY].should == @num_statements
     end
     it 'reports the correct subclass' do
-      @yaml.should match(/subclass:[\s]*#{LongMethod::SUBCLASS_TOO_MANY_STATEMENTS}/)
+      @smells[0].subclass.should == LongMethod::SUBCLASS_TOO_MANY_STATEMENTS
     end
   end
 end

data/spec/reek/smells/long_parameter_list_spec.rb

@@ -6,51 +6,56 @@ include Reek
 include Reek::Smells
 
 describe LongParameterList do
-  
-  describe 'for methods with few parameters' do
+
+  context 'for methods with few parameters' do
     it 'should report nothing for no parameters' do
-      'def simple; f(3);true; end'.should_not reek
+      'def simple; f(3);true; end'.should_not smell_of(LongParameterList)
     end
     it 'should report nothing for 1 parameter' do
-      'def simple(yep) f(3);true end'.should_not reek
+      'def simple(yep) f(3);true end'.should_not smell_of(LongParameterList)
     end
     it 'should report nothing for 2 parameters' do
-      'def simple(yep,zero) f(3);true end'.should_not reek
+      'def simple(yep,zero) f(3);true end'.should_not smell_of(LongParameterList)
     end
     it 'should not count an optional block' do
-      'def simple(alpha, yep, zero, &opt) f(3);true end'.should_not reek
+      'def simple(alpha, yep, zero, &opt) f(3);true end'.should_not smell_of(LongParameterList)
     end
     it 'should not report inner block with too many parameters' do
-      'def simple(yep,zero); m[3]; rand(34); f.each { |arga, argb, argc, argd| true}; end'.should_not reek
+      src = 'def simple(yep,zero); m[3]; rand(34); f.each { |arga, argb, argc, argd| true}; end'
+      src.should_not smell_of(LongParameterList)
     end
 
     describe 'and default values' do
       it 'should report nothing for 1 parameter' do
-        'def simple(zero=nil) f(3);false end'.should_not reek
+        'def simple(zero=nil) f(3);false end'.should_not smell_of(LongParameterList)
       end
       it 'should report nothing for 2 parameters with 1 default' do
-        'def simple(yep, zero=nil) f(3);false end'.should_not reek
+        'def simple(yep, zero=nil) f(3);false end'.should_not smell_of(LongParameterList)
       end
       it 'should report nothing for 2 defaulted parameters' do
-        'def simple(yep=4, zero=nil) f(3);false end'.should_not reek
+        'def simple(yep=4, zero=nil) f(3);false end'.should_not smell_of(LongParameterList)
       end
     end
   end
 
   describe 'for methods with too many parameters' do
     it 'should report 4 parameters' do
-      'def simple(arga, argb, argc, argd) f(3);true end'.should reek_only_of(:LongParameterList, /4 parameters/)
+      src = 'def simple(arga, argb, argc, argd) f(3);true end'
+      src.should smell_of(LongParameterList, LongParameterList::PARAMETER_COUNT_KEY => 4)
     end
     it 'should report 8 parameters' do
-      'def simple(arga, argb, argc, argd,arge, argf, argg, argh) f(3);true end'.should reek_only_of(:LongParameterList, /8 parameters/)
+      src = 'def simple(arga, argb, argc, argd,arge, argf, argg, argh) f(3);true end'
+      src.should smell_of(LongParameterList, LongParameterList::PARAMETER_COUNT_KEY => 8)
     end
 
     describe 'and default values' do
       it 'should report 3 with 1 defaulted' do
-        'def simple(polly, queue, yep, zero=nil) f(3);false end'.should reek_only_of(:LongParameterList, /4 parameters/)
+        src = 'def simple(polly, queue, yep, zero=nil) f(3);false end'
+        src.should smell_of(LongParameterList, LongParameterList::PARAMETER_COUNT_KEY => 4)
       end
       it 'should report with 3 defaulted' do
-        'def simple(aarg, polly=2, yep=:truth, zero=nil) f(3);false end'.should reek_only_of(:LongParameterList, /4 parameters/)
+        src = 'def simple(aarg, polly=2, yep=:truth, zero=nil) f(3);false end'
+        src.should smell_of(LongParameterList, LongParameterList::PARAMETER_COUNT_KEY => 4)
       end
     end
   end
@@ -59,9 +64,7 @@ end
 describe LongParameterList do
   before(:each) do
     @source_name = 'smokin'
-    @detector = LongParameterList.new(@source_name, {})
-    # SMELL: can't use the default config, because that contains an override,
-    # which causes the mocked matches?() method to be called twice!!
+    @detector = LongParameterList.new(@source_name)
   end
 
   it_should_behave_like 'SmellDetector'
@@ -74,18 +77,15 @@ def badguy(arga, argb, argc, argd)
   true
 end
 EOS
-      source = src.to_reek_source
-      sniffer = Sniffer.new(source)
-      mctx = CodeParser.new(sniffer).process_defn(source.syntax_tree)
-      @detector.examine_context(mctx)
-      @warning = @detector.smells_found.to_a[0]   # SMELL: too cumbersome!
+      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      @smells = @detector.examine_context(ctx)
+      @warning = @smells[0]
     end
 
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the number of parameters' do
-      @warning.smell['parameter_count'].should == 4
-      # SMELL: many tests duplicate the names of the YAML fields
+      @warning.smell[LongParameterList::PARAMETER_COUNT_KEY].should == 4
     end
     it 'reports the line number of the method' do
       @warning.lines.should == [1]