reek 0.3.1 → 1.0.0

data/spec/reek/smells/large_class_spec.rb

@@ -1,11 +1,12 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-require 'reek/class_checker'
+require 'reek/code_parser'
 require 'reek/report'
+require 'reek/smells/large_class'
 
 include Reek
+include Reek::Smells
 
-describe ClassChecker, "(Large Class)" do
+describe LargeClass do
 
   class BigOne
     26.times do |i|
@@ -17,7 +18,7 @@ describe ClassChecker, "(Large Class)" do
 
   before(:each) do
     @rpt = Report.new
-    @cchk = ClassChecker.new(@rpt)
+    @cchk = CodeParser.new(@rpt, SmellConfig.new.smell_listeners)
   end
 
   it 'should not report short class' do
@@ -42,4 +43,44 @@ describe ClassChecker, "(Large Class)" do
     @cchk.check_object(BigOne)
     @rpt[0].report.should match(/BigOne/)
   end
+
+  describe 'when exceptions are listed' do
+    before :each do
+      @ctx = ClassContext.create(StopContext.new, [0, :Humungous])
+      30.times { |num| @ctx.record_method("method#{num}") }
+      @config = LargeClass.default_config
+    end
+
+    it 'should ignore first excepted name' do
+      @config[LargeClass::EXCLUDE_KEY] = ['Humungous']
+      lc = LargeClass.new(@config)
+      lc.examine(@ctx, @rpt).should == false
+      @rpt.length.should == 0
+    end
+
+    it 'should ignore second excepted name' do
+      @config[LargeClass::EXCLUDE_KEY] = ['Oversized', 'Humungous']
+      lc = LargeClass.new(@config)
+      lc.examine(@ctx, @rpt).should == false
+      @rpt.length.should == 0
+    end
+
+    it 'should report non-excepted name' do
+      @config[LargeClass::EXCLUDE_KEY] = ['SmellMe']
+      lc = LargeClass.new(@config)
+      lc.examine(@ctx, @rpt).should == true
+      @rpt.length.should == 1
+    end
+  end
+end
+
+describe LargeClass do
+  it 'should not report empty class in another module' do
+    'class Treetop::Runtime::SyntaxNode; end'.should_not reek
+  end
+
+  it 'should deal with :: scoped names' do
+    element = ClassContext.create(StopContext.new, [:colon2, [:colon2, [:const, :Treetop], :Runtime], :SyntaxNode])
+    element.num_methods.should == 0
+  end
 end

data/spec/reek/smells/long_method_spec.rb

@@ -1,58 +1,43 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-require 'reek/method_checker'
+require 'reek/code_parser'
 require 'reek/report'
 
 include Reek
 
-describe MethodChecker, "(Long Method)" do
-
-  before(:each) do
-    @rpt = Report.new
-    @cchk = MethodChecker.new(@rpt, 'Thing')
-  end
-
+describe CodeParser, "(Long Method)" do
   it 'should not report short methods' do
-    @cchk.check_source('def short(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;end')
-    @rpt.should be_empty
+    'def short(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;end'.should_not reek
   end
 
   it 'should report long methods' do
-    @cchk.check_source('def long(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;@fry = 6;end')
-    @rpt.length.should == 1
-    @rpt[0].should be_instance_of(LongMethod)
+    'def long(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;@fry = 6;end'.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
   end
 
   it 'should only report a long method once' do
     source =<<EOS
-  def standard_entries(rbconfig)
-    @abc = rbconfig
-    rubypath = File.join(@abc['bindir'], @abcf['ruby_install_name'] + cff['EXEEXT'])
-    major = yyy['MAJOR'].to_i
-    minor = zzz['MINOR'].to_i
-    teeny = ccc['TEENY'].to_i
-    version = ""
-    if c['rubylibdir']
-      @libruby         = "/lib/ruby"
-      @librubyver      = "/lib/ruby/"
-      @librubyverarch  = "/lib/ruby/"
-      @siteruby        = "lib/ruby/version/site_ruby"
-      @siterubyver     = siteruby
-      @siterubyverarch = "$siterubyver/['arch']}"
-    end
-  end
-EOS
-    @cchk.check_source(source)
-    @rpt.length.should == 1
-    @rpt[0].should be_instance_of(LongMethod)
+def standard_entries(rbconfig)
+  @abc = rbconfig
+  rubypath = File.join(@abc['bindir'], @abcf['ruby_install_name'] + cff['EXEEXT'])
+  major = yyy['MAJOR'].to_i
+  minor = zzz['MINOR'].to_i
+  teeny = ccc['TEENY'].to_i
+  version = ""
+  if c['rubylibdir']
+    @libruby         = "/lib/ruby"
+    @librubyver      = "/lib/ruby/"
+    @librubyverarch  = "/lib/ruby/"
+    @siteruby        = "lib/ruby/version/site_ruby"
+    @siterubyver     = siteruby
+    @siterubyverarch = "$siterubyver/['arch']}"
   end
 end
-
-describe MethodChecker, "(Long Block)" do
-
-  before(:each) do
-    @rpt = Report.new
-    @cchk = MethodChecker.new(@rpt, 'Thing')
+EOS
+    source.should reek_only_of(:LongMethod)
   end
 
   it 'should report long inner block' do
@@ -69,7 +54,6 @@ def long(arga)
   end
 end
 EOS
-    @cchk.check_source(src)
-    @rpt.length.should == 1
+    src.should reek_only_of(:LongMethod)
   end
 end

data/spec/reek/smells/long_parameter_list_spec.rb

@@ -1,89 +1,67 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-require 'reek/method_checker'
+require 'reek/code_parser'
+require 'reek/smells/long_parameter_list'
 require 'reek/report'
 
 include Reek
+include Reek::Smells
 
-describe MethodChecker, "(Long Parameter List)" do
-  
-  before(:each) do
-    @rpt = Report.new
-    @cchk = MethodChecker.new(@rpt, 'Thing')
-  end
+describe CodeParser, "(Long Parameter List)" do
   
   describe 'for methods with few parameters' do
     it 'should report nothing for no parameters' do
-      @cchk.check_source('def simple; f(3);true; end')
-      @rpt.should be_empty
+      'def simple; f(3);true; end'.should_not reek
     end
-
     it 'should report nothing for 1 parameter' do
-      @cchk.check_source('def simple(yep) f(3);true end')
-      @rpt.should be_empty
+      'def simple(yep) f(3);true end'.should_not reek
     end
-
     it 'should report nothing for 2 parameters' do
-      @cchk.check_source('def simple(yep,zero) f(3);true end')
-      @rpt.should be_empty
+      'def simple(yep,zero) f(3);true end'.should_not reek
     end
-
     it 'should not count an optional block' do
-      @cchk.check_source('def simple(alpha, yep, zero, &opt) f(3);true end')
-      @rpt.should be_empty
+      'def simple(alpha, yep, zero, &opt) f(3);true end'.should_not reek
     end
-
     it 'should not report inner block with too many parameters' do
-      @cchk.check_source('def simple(yep,zero); m[3]; rand(34); f.each { |arga, argb, argc, argd| true}; end')
-      @rpt.should be_empty
+      'def simple(yep,zero); m[3]; rand(34); f.each { |arga, argb, argc, argd| true}; end'.should_not reek
     end
     
     describe 'and default values' do
       it 'should report nothing for 1 parameter' do
-        @cchk.check_source('def simple(zero=nil) f(3);false end')
-        @rpt.should be_empty
+        'def simple(zero=nil) f(3);false end'.should_not reek
       end
-      
       it 'should report nothing for 2 parameters with 1 default' do
-        @cchk.check_source('def simple(yep, zero=nil) f(3);false end')
-        @rpt.should be_empty
+        'def simple(yep, zero=nil) f(3);false end'.should_not reek
       end
-      
       it 'should report nothing for 2 defaulted parameters' do
-        @cchk.check_source('def simple(yep=4, zero=nil) f(3);false end')
-        @rpt.should be_empty
+        'def simple(yep=4, zero=nil) f(3);false end'.should_not reek
       end
     end
   end
 
   describe 'for methods with too many parameters' do
     it 'should report 4 parameters' do
-      @cchk.check_source('def simple(arga, argb, argc, argd) f(3);true end')
-      @rpt.length.should == 1
-      @rpt[0].should be_instance_of(LongParameterList)
+      'def simple(arga, argb, argc, argd) f(3);true end'.should reek_only_of(:LongParameterList, /4 parameters/)
     end
-    
     it 'should report 8 parameters' do
-      @cchk.check_source('def simple(arga, argb, argc, argd,arge, argf, argg, argh) f(3);true end')
-      @rpt.length.should == 1
-      @rpt[0].should be_instance_of(LongParameterList)
+      'def simple(arga, argb, argc, argd,arge, argf, argg, argh) f(3);true end'.should reek_only_of(:LongParameterList, /8 parameters/)
     end
 
     describe 'and default values' do
       it 'should report 3 with 1 defaulted' do
-        @cchk.check_source('def simple(polly, queue, yep, zero=nil) f(3);false end')
-        @rpt.length.should == 1
-        @rpt[0].should be_instance_of(LongParameterList)
+        'def simple(polly, queue, yep, zero=nil) f(3);false end'.should reek_only_of(:LongParameterList, /4 parameters/)
       end
-
       it 'should report with 3 defaulted' do
-        @cchk.check_source('def simple(aarg, polly=2, yep=true, zero=nil) f(3);false end')
-        @rpt.length.should == 1
-        @rpt[0].should be_instance_of(LongParameterList)
+        'def simple(aarg, polly=2, yep=true, zero=nil) f(3);false end'.should reek_only_of(:LongParameterList, /4 parameters/)
       end
     end
     
     describe 'in a class' do
+      before(:each) do
+        @rpt = Report.new
+        @cchk = CodeParser.new(@rpt, SmellConfig.new.smell_listeners)
+      end
+
       class InnerTest
         def xyzero(arga,argb) f(3);true end
         def abc(argx,yep,zero,argm) f(3);false end
@@ -92,47 +70,23 @@ describe MethodChecker, "(Long Parameter List)" do
       it 'should only report long param list' do
         @cchk.check_object(InnerTest)
         @rpt.length.should == 1
-        @rpt[0].should be_instance_of(LongParameterList)
+        @rpt[0].report.should match(/Long Parameter List/)
       end
     end
   end
   
   describe 'yield' do
+    it 'should not report yield with no parameters' do
+      'def simple(arga, argb, &blk) f(3);yield; end'.should_not reek
+    end
     it 'should not report yield with few parameters' do
-      @cchk.check_source('def simple(arga, argb, &blk) f(3);yield a,b; end')
-      @rpt.should be_empty
+      'def simple(arga, argb, &blk) f(3);yield a,b; end'.should_not reek
     end
-
     it 'should report yield with many parameters' do
-      @cchk.check_source('def simple(arga, argb, &blk) f(3);yield a,b,a,b; end')
-      @rpt.length.should == 1
-      @rpt[0].should be_instance_of(LongYieldList)
+      'def simple(arga, argb, &blk) f(3);yield a,b,a,b; end'.should reek_only_of(:LongYieldList, /simple/, /yields/, /4/)
+    end
+    it 'should not report yield of a long expression' do
+      'def simple(arga, argb, &blk) f(3);yield(if @dec then argb else 5+3 end); end'.should_not reek
     end
-
-  end
-
-end
-
-describe LongParameterList, 'when given the class name' do
-  
-  before(:each) do
-    @rpt = Report.new
-    @cchk = MethodChecker.new(@rpt, 'classname')
-  end
-
-  it 'should report the class name' do
-    @cchk.check_source('def simple(arga, argb, argc, argd) f(3);true end')
-    @rpt.length.should == 1
-    @rpt[0].should be_instance_of(LongParameterList)
-    @rpt[0].report.should match(/classname#simple/)
-  end
-end
-
-describe LongParameterList, '#report' do
-  it 'should report the method name and num params' do
-    mchk = MethodChecker.new([], 'Class')
-    smell = LongParameterList.new(mchk)
-    smell.report.should match(/Class/)
   end
-
 end

data/spec/reek/smells/nested_iterators_spec.rb

@@ -1,43 +1,33 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-require 'reek/method_checker'
-require 'reek/report'
-
-include Reek
-
-def check(desc, src, expected, pending_str = nil)
-  it(desc) do
-    pending(pending_str) unless pending_str.nil?
-    rpt = Report.new
-    cchk = MethodChecker.new(rpt, 'Thing')
-    cchk.check_source(src)
-    rpt.length.should == expected.length
-    (0...rpt.length).each do |smell|
-      expected[smell].each { |patt| rpt[smell].detailed_report.should match(patt) }
-    end
-  end
-end
+require 'reek/smells/nested_iterators'
 
-describe MethodChecker, " nested iterators" do
+include Reek::Smells
 
-  check 'should report nested iterators in a method',
-    'def bad(fred) @fred.each {|item| item.each {|ting| ting.ting} } end', [[/nested iterators/]]
+describe NestedIterators do
+
+  it 'should report nested iterators in a method' do
+    'def bad(fred) @fred.each {|item| item.each {|ting| ting.ting} } end'.should reek_only_of(:NestedIterators)
+  end
 
-  check 'should not report method with successive iterators',
+  it 'should not report method with successive iterators' do
     'def bad(fred)
       @fred.each {|item| item.each }
       @jim.each {|ting| ting.each }
-    end', []
+    end'.should_not reek
+  end
 
-  check 'should not report method with chained iterators',
+  it 'should not report method with chained iterators' do
     'def chained
-      @sig.keys.sort_by { |x| x.to_s }.each { |m| md5 << m.to_s }
-    end', []
+      @sig.keys.sort_by { |xray| xray.to_s }.each { |min| md5 << min.to_s }
+    end'.should_not reek
+  end
 
-  check 'should report nested iterators only once per method',
+  it 'should report nested iterators only once per method' do
     'def bad(fred)
-  @fred.each {|item| item.each {|part| @joe.send} }
-  @jim.each {|ting| ting.each {|piece| @hal.send} }
-end', [[/nested iterators/]]
+      @fred.each {|item| item.each {|part| @joe.send} }
+      @jim.each {|ting| ting.each {|piece| @hal.send} }
+    end'.should reek_only_of(:NestedIterators)
+  end
 end
 

data/spec/reek/smells/smell_spec.rb

@@ -1,33 +1,24 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-require 'reek/smells'
+require 'reek/smells/smells'
 
 include Reek
 
-describe Smell, "camel case converter" do
-  it "should convert camel case name" do
-    Smell.convert_camel_case('LongParameterList').should == 'Long Parameter List'
+describe SmellWarning, ' in comparisons' do
+  before :each do
+    @first = SmellWarning.new(Smells::FeatureEnvy.new, "self", "self")
+    @second = SmellWarning.new(Smells::FeatureEnvy.new, "self", "self")
   end
-  
-  it "should display correct name in report" do
-    smell = LongMethod.new(self, 25)
-    smell.report.should match(/[#{smell.name}]/)
-  end
-end
 
-describe Smell, ' in comparisons' do
   it 'should hash equal when the smell is the same' do
-    UtilityFunction.new(self, 2).hash.should == UtilityFunction.new(self, 2).hash
-    NestedIterators.new(self).hash.should == NestedIterators.new(self).hash
+    @first.hash.should == @second.hash
   end
 
   it 'should compare equal when the smell is the same' do
-    UtilityFunction.new(self, 2).should == UtilityFunction.new(self, 2)
-    NestedIterators.new(self).should == NestedIterators.new(self)
+    @first.should == @second
   end
 
   it 'should compare equal when using <=>' do
-    (UtilityFunction.new(self, 2) <=> UtilityFunction.new(self, 2)).should == 0
-    (NestedIterators.new(self) <=> NestedIterators.new(self)).should == 0
+    (@first <=> @second).should == 0
   end
-end
+end

data/spec/reek/smells/uncommunicative_name_spec.rb

@@ -1,83 +1,118 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-require 'reek/method_checker'
-require 'reek/report'
+require 'ostruct'
+require 'reek/method_context'
+require 'reek/smells/uncommunicative_name'
 
 include Reek
+include Reek::Smells
 
-def check(desc, src, expected, pending_str = nil)
-  it(desc) do
-    pending(pending_str) unless pending_str.nil?
-    rpt = Report.new
-    cchk = MethodChecker.new(rpt, 'Thing')
-    cchk.check_source(src)
-    rpt.length.should == expected.length
-    (0...rpt.length).each do |smell|
-      expected[smell].each { |patt| rpt[smell].detailed_report.should match(patt) }
-    end
+describe UncommunicativeName, "method name" do
+  it 'should not report one-word method name' do
+    'def help(fred) basics(17) end'.should_not reek
+  end
+  it 'should report one-letter method name' do
+    'def x(fred) basics(17) end'.should reek_only_of(:UncommunicativeName, /x/)
+  end
+  it 'should report name of the form "x2"' do
+    'def x2(fred) basics(17) end'.should reek_only_of(:UncommunicativeName, /x2/)
   end
 end
 
-describe MethodChecker, "uncommunicative method name" do
-  check 'should not report one-word method name', 'def help(fred) basics(17) end', []
-  check 'should report one-letter method name', 'def x(fred) basics(17) end', [[/x/, /method name/]]
-  check 'should report name of the form "x2"', 'def x2(fred) basics(17) end', [[/x2/, /method name/]]
+describe UncommunicativeName, "field name" do
+  it 'should not report one-word field name' do
+    'class Thing; def help(fred) @simple end end'.should_not reek
+  end
+  it 'should report one-letter fieldname' do
+    'class Thing; def simple(fred) @x end end'.should reek_only_of(:UncommunicativeName, /@x/, /Thing/, /variable name/)
+  end
+  it 'should report name of the form "x2"' do
+    'class Thing; def simple(fred) @x2 end end'.should reek_only_of(:UncommunicativeName, /@x2/, /Thing/, /variable name/)
+  end
+  it 'should report one-letter fieldname in assignment' do
+    'class Thing; def simple(fred) @x = fred end end'.should reek_only_of(:UncommunicativeName, /@x/, /Thing/, /variable name/)
+  end
 end
 
-describe MethodChecker, "uncommunicative field name" do
-  check 'should not report one-word field name', 'def help(fred) @simple end', []
-  check 'should report one-letter fieldname', 'def simple(fred) @x end', [[/@x/, /field name/]]
-  check 'should report name of the form "x2"', 'def simple(fred) @x2 end', [[/@x2/, /field name/]]
-  check 'should report one-letter fieldname in assignment', 'def simple(fred) @x = fred end', [[/@x/, /field name/]]
+describe UncommunicativeName, "local variable name" do
+  it 'should not report one-word variable name' do
+    'def help(fred) simple = jim(45) end'.should_not reek
+  end
+  it 'should report one-letter variable name' do
+    'def simple(fred) x = jim(45) end'.should reek_only_of(:UncommunicativeName, /x/, /variable name/)
+  end
+  it 'should report name of the form "x2"' do
+    'def simple(fred) x2 = jim(45) end'.should reek_only_of(:UncommunicativeName, /x2/, /variable name/)
+  end
+  it 'should report variable name only once' do
+    'def simple(fred) x = jim(45); x = y end'.should reek_only_of(:UncommunicativeName, /x/)
+  end
 end
 
-describe MethodChecker, "uncommunicative local variable name" do
-  check 'should not report one-word variable name', 'def help(fred) simple = jim(45) end', []
-  check 'should report one-letter variable name', 'def simple(fred) x = jim(45) end', [[/x/, /local variable name/]]
-  check 'should report name of the form "x2"', 'def simple(fred) x2 = jim(45) end', [[/x2/, /local variable name/]]
-  check 'should report variable name only once', 'def simple(fred) x = jim(45); x = y end', [[]]
+describe UncommunicativeName, "parameter name" do
+  it 'should not recognise *' do
+    'def help(xray, *) basics(17) end'.should_not reek
+  end
+  it "should report parameter's name" do
+    'def help(x) basics(17) end'.should reek_only_of(:UncommunicativeName, /x/, /variable name/)
+  end
+  it 'should report name of the form "x2"' do
+    'def help(x2) basics(17) end'.should reek_only_of(:UncommunicativeName, /x2/, /variable name/)
+  end
 end
 
-describe MethodChecker, "uncommunicative parameter name" do
-  check 'should recognise short parameter name', 'def help(x) basics(17) end', [[]]
-  check 'should not recognise *', 'def help(xray, *) basics(17) end', []
-  check "should report parameter's name", 'def help(x) basics(17) end', [[/x/, /parameter name/]]
-  check 'should report name of the form "x2"', 'def help(x2) basics(17) end', [[/x2/, /parameter name/]]
+describe UncommunicativeName, "block parameter name" do
+  it "should report parameter's name" do
+    'def help() @stuff.each {|x|} end'.should reek_only_of(:UncommunicativeName, /x/, /block/, /variable name/)
+  end
+  
+  it "should report method name via if context" do
+    src = <<EOS
+def bad
+  unless @mod then
+    @sig.each { |x| x.to_s }
+  end
+end
+EOS
+    src.should reek_only_of(:UncommunicativeName, /'x'/)
+  end
 end
 
-describe MethodChecker, "several uncommunicative names" do
+describe UncommunicativeName, "several names" do
 
-  check 'should report all bad names', 'def y(x) @z = x end', [[/'@z'/], [/'y'/], [/'x'/]]
+  it 'should report all bad names' do
+    ruby = Source.from_s('class Oof; def y(x) @z = x end end')
+    ruby.should reek_of(:UncommunicativeName, /'x'/)
+    ruby.should reek_of(:UncommunicativeName, /'y'/)
+    ruby.should reek_of(:UncommunicativeName, /'@z'/)
+  end
 
-  source =<<EOS
-def bad(fred)
-  @fred.each {|x| 4 - x }
-  @jim.each {|y| y - 4 }
+  it 'should report all bad block parameters' do
+    source =<<EOS
+class Thing
+  def bad(fred)
+    @fred.each {|x| 4 - x }
+    @jim.each {|y| y - 4 }
+  end
 end
 EOS
-  check 'should report all bad block parameters', source, [[/'x'/], [/'y'/]], 'bug'
+    source.should reek_of(:UncommunicativeName, /'x'/)
+    source.should reek_of(:UncommunicativeName, /'y'/)
+  end
 end
 
-require 'ostruct'
-require 'reek/smells/uncommunicative_name'
-include Reek::Smells
-
 describe UncommunicativeName, '#examine' do
-  
   before :each do
-    @mc = OpenStruct.new
-    @mc.parameters = []
-    @mc.local_variables = []
-    @mc.instance_variables = []
+    @report = Report.new
+    @uc = UncommunicativeName.new
   end
-
+  
   it 'should return true when reporting a smell' do
-    @mc.name = 'x'
-    UncommunicativeName.examine(@mc, []).should == true
+    mc = MethodContext.new(StopContext.new, [:defn, :x, nil])
+    @uc.examine(mc, @report).should == true
   end
   
   it 'should return false when not reporting a smell' do
-    @mc.name = 'not_bad'
-    UncommunicativeName.examine(@mc, []).should == false
+    mc = MethodContext.new(StopContext.new, [:defn, :not_bad, nil])
+    @uc.examine(mc, @report).should == false
   end
 end