reek 0.3.0 → 0.3.1

data/lib/reek/version.rb

@@ -2,7 +2,7 @@ module Reek #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 3
-    TINY  = 0
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/spec/integration_spec.rb

@@ -10,20 +10,20 @@ describe 'Integration test:' do
 
       it 'should report the correct smells' do
         actual = `ruby -Ilib bin/reek #{source} 2>/dev/null`.split(/\n/)
-        actual.length.should == @expected.length
         @expected.zip(actual).each do |p|
-          actual = p[1] ? p[1].chomp : p[1]
-          actual.should == p[0]
+          actual_line = p[1] ? p[1].chomp : p[1]
+          actual_line.should == p[0]
         end
+        actual.length.should == @expected.length
       end
 
       it 'should report the correct smells in smell order' do
         actual = `ruby -Ilib bin/reek --sort smell #{source} 2>/dev/null`.split(/\n/)
-        actual.length.should == @expected.length
         @expected.sort.zip(actual).each do |p|
-          actual = p[1] ? p[1].chomp : p[1]
-          actual.should == p[0]
+          actual_line = p[1] ? p[1].chomp : p[1]
+          actual_line.should == p[0]
         end
+        actual.length.should == @expected.length
       end
     end
   end

data/spec/reek/printer_spec.rb

@@ -1,30 +1,30 @@
 require File.dirname(__FILE__) + '/../spec_helper.rb'
 
-require 'reek/method_checker'
-require 'reek/smells'
-require 'reek/report'
+require 'reek/checker'
+require 'reek/printer'
 
 include Reek
 
-def render(source)
-  sexp = Checker.parse_tree_for(source)[0]
-  Printer.print(sexp)
+def check(examples)
+  examples.each do |actual|
+    it "should format #{actual} correctly" do
+      sexp = Checker.parse_tree_for(actual)[0]
+      Printer.print(sexp).should == actual
+    end
+  end
 end
 
 describe Printer do
-  it 'should format a simple constant' do
-    render('Alpha').should == 'Alpha'
-  end
-
-  it 'should format "::" correctly' do
-    render('Alpha::Beta').should == 'Alpha::Beta'
-  end
-
-  it 'should format class variables correctly' do
-    render('@@fred').should == '@@fred'
-  end
-
-  it 'should format xstr correctly' do
-    render('`ls`').should == '`ls`'
-  end
+  check 'Alpha'
+  check 'Alpha::Beta'
+  check '@@fred'
+  check '`ls`'
+  check 'array[0]'
+  check 'array[0, 1, 2]'
+  check 'obj.method(arg1, arg2)'
+  check 'obj.method'
+  check '$1'
+  check 'o=q.downcase'
+  check 'true'
+  check '"-#{q}xxx#{z.size}"'
 end

data/spec/reek/report_spec.rb

@@ -54,12 +54,12 @@ describe SortByContext do
   end
 
   it 'should return 0 for identical smells' do
-    smell = LongMethod.new('Class#method')
+    smell = LongMethod.new('Class#method', 30)
     @sorter.compare(smell, smell).should == 0
   end
 
   it 'should return non-0 for different smells' do
-    @sorter.compare(LongMethod.new('x'), LargeClass.new('y')).should == -1
+    @sorter.compare(LongMethod.new('x', 30), LargeClass.new('y')).should == -1
   end
 end
 
@@ -69,14 +69,14 @@ describe SortBySmell do
   end
   
   it 'should return 0 for identical smells' do
-    @sorter.compare(LongMethod.new('x'), LongMethod.new('x')).should == 0
+    @sorter.compare(LongMethod.new('x', 30), LongMethod.new('x', 30)).should == 0
   end
 
   it 'should differentiate identical smells with different contexts' do
-    @sorter.compare(LongMethod.new('x'), LongMethod.new('y')).should == -1
+    @sorter.compare(LongMethod.new('x', 29), LongMethod.new('y', 29)).should == -1
   end
 
   it 'should differentiate different smells with identical contexts' do
-    @sorter.compare(LongMethod.new('x'), LargeClass.new('x')).should == 1
+    @sorter.compare(LongMethod.new('x', 28), LargeClass.new('x')).should == 1
   end
 end

data/spec/reek/{control_couple_spec.rb → smells/control_couple_spec.rb}

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 require 'reek/method_checker'
 require 'reek/report'

data/spec/reek/smells/duplication_spec.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+require 'reek/method_checker'
+require 'reek/smells/duplication'
+require 'reek/report'
+
+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
+  end
+end
+
+describe Duplication, "repeated method calls" do
+  check 'should report repeated call',
+    'def double_thing() @other.thing + @other.thing end', [[/@other.thing/]]
+  check 'should report repeated call to lvar',
+    'def double_thing() other[@thing] + other[@thing] end', [[/other\[@thing\]/]]
+  check 'should report call parameters',
+    'def double_thing() @other.thing(2,3) + @other.thing(2,3) end', [[/@other.thing\(2, 3\)/]]
+  check 'should report nested calls',
+    'def double_thing() @other.thing.foo + @other.thing.foo end', [[/@other.thing[^\.]/], [/@other.thing.foo/]]
+  check 'should ignore calls to new',
+    'def double_thing() @other.new + @other.new end', []
+end
+
+describe Duplication, "non-repeated method calls" do
+  check 'should not report similar calls',
+    'def equals(other) other.thing == self.thing end', []
+  check 'should respect call parameters',
+    'def double_thing() @other.thing(3) + @other.thing(2) end', []
+end
+
+require 'ostruct'
+
+describe Duplication, '#examine' do
+  
+  before :each do
+    @mc = OpenStruct.new
+  end
+
+  it 'should return true when reporting a smell' do
+    @mc.calls = {'x' => 47}
+    Duplication.examine(@mc, []).should == true
+  end
+  
+  it 'should return false when not reporting a smell' do
+    @mc.calls = []
+    Duplication.examine(@mc, []).should == false
+  end
+end

data/spec/reek/smells/feature_envy_spec.rb

@@ -0,0 +1,91 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+require 'reek/method_checker'
+require 'reek/smells'
+require 'reek/report'
+
+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
+  end
+end
+
+describe FeatureEnvy, 'with only messages to self' do
+  check 'should not report use of self', 'def simple() self.to_s + self.to_i end', []
+  check 'should not report vcall with no argument', 'def simple() func + grunc end', []
+  check 'should not report vcall with argument', 'def simple(arga) func(17) + grunc(arga) end', []
+end
+
+describe FeatureEnvy, 'when the receiver is a parameter' do
+  check 'should not report single use', 'def no_envy(arga) arga.barg(@item) end', []
+  check 'should not report return value', 'def no_envy(arga) arga.barg(@item); arga end', []
+  check 'should report many calls to parameter', 'def envy(arga) arga.b(arga) + arga.c(@fred) end', [[/arga/]]
+end
+
+describe FeatureEnvy, 'when there are many possible receivers' do
+  check 'should report highest affinity',
+    'def total_envy
+      fred = @item
+      total = 0
+      total += fred.price
+      total += fred.tax
+      total *= 1.15
+    end', [[/total/]]
+  check 'should report multiple affinities',
+    'def total_envy
+      fred = @item
+      total = 0
+      total += fred.price
+      total += fred.tax
+    end', [[/fred/], [/total/]]
+end
+
+describe FeatureEnvy, 'when the receiver is external' do
+  check 'should ignore global variables', 'def no_envy() $s2.to_a; $s2[@item] end', []
+  check 'should not report class methods', 'def simple() self.class.new.flatten_merge(self) end', []
+end
+
+describe FeatureEnvy, 'when the receiver is an ivar' do
+  check 'should not report single use of an ivar', 'def no_envy() @item.to_a end', []
+  check 'should not report returning an ivar', 'def no_envy() @item.to_a; @item end', []
+  check 'should not report ivar usage in a parameter',
+    'def no_envy; @item.price + tax(@item) - savings(@item) end', []
+end
+
+describe FeatureEnvy, 'when the receiver is an lvar' do
+  check 'should not report single use of an lvar', 'def no_envy() lv = @item; lv.to_a end', []
+  check 'should not report returning an lvar', 'def no_envy() lv = @item; lv.to_a; lv end', []
+  check 'should report many calls to lvar', 'def envy; lv = @item; lv.price + lv.tax end', [[/lv/]]
+  check 'should not report lvar usage in a parameter', 'def no_envy; lv = @item; lv.price + tax(lv) - savings(lv) end', []
+end
+
+require 'ostruct'
+
+describe FeatureEnvy, '#examine' do
+
+  before :each do
+    @mc = OpenStruct.new   # SMELL: this is a mock!!
+    @mc.name = 'cool'
+    @mc.refs = ObjectRefs.new
+  end
+
+  it 'should return true when reporting a smell' do
+    @mc.refs.record_ref([:lvar, :thing])
+    @mc.refs.record_ref([:lvar, :thing])
+    FeatureEnvy.examine(@mc, []).should == true
+  end
+  
+  it 'should return false when not reporting a smell' do
+    FeatureEnvy.examine(@mc, []).should == false
+  end
+end

data/spec/reek/{large_class_spec.rb → smells/large_class_spec.rb}

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 require 'reek/class_checker'
 require 'reek/report'
@@ -9,7 +9,7 @@ describe ClassChecker, "(Large Class)" do
 
   class BigOne
     26.times do |i|
-      define_method "m#{i}".to_sym do
+      define_method "method#{i}".to_sym do
         @melting
       end
     end
@@ -22,12 +22,12 @@ describe ClassChecker, "(Large Class)" do
 
   it 'should not report short class' do
     class ShortClass
-      def m1() @m1; end
-      def m2() @m2; end
-      def m3() @m3; end
-      def m4() @m4; end
-      def m5() @m5; end
-      def m6() @m6; end
+      def method1() @var1; end
+      def method2() @var2; end
+      def method3() @var3; end
+      def method4() @var4; end
+      def method5() @var5; end
+      def method6() @var6; end
     end
     @cchk.check_object(ShortClass)
     @rpt.should be_empty

data/spec/reek/{long_method_spec.rb → smells/long_method_spec.rb}

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 require 'reek/method_checker'
 require 'reek/report'

data/spec/reek/{long_parameter_list_spec.rb → smells/long_parameter_list_spec.rb}

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 require 'reek/method_checker'
 require 'reek/report'

data/spec/reek/smells/nested_iterators_spec.rb

@@ -0,0 +1,43 @@
+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
+
+describe MethodChecker, " nested iterators" do
+
+  check 'should report nested iterators in a method',
+    'def bad(fred) @fred.each {|item| item.each {|ting| ting.ting} } end', [[/nested iterators/]]
+
+  check 'should not report method with successive iterators',
+    'def bad(fred)
+      @fred.each {|item| item.each }
+      @jim.each {|ting| ting.each }
+    end', []
+
+  check 'should not report method with chained iterators',
+    'def chained
+      @sig.keys.sort_by { |x| x.to_s }.each { |m| md5 << m.to_s }
+    end', []
+
+  check 'should report nested iterators only once per method',
+    'def bad(fred)
+  @fred.each {|item| item.each {|part| @joe.send} }
+  @jim.each {|ting| ting.each {|piece| @hal.send} }
+end', [[/nested iterators/]]
+end
+

data/spec/reek/{smell_spec.rb → smells/smell_spec.rb}

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 require 'reek/smells'
 
@@ -10,7 +10,7 @@ describe Smell, "camel case converter" do
   end
   
   it "should display correct name in report" do
-    smell = LongMethod.new(self)
+    smell = LongMethod.new(self, 25)
     smell.report.should match(/[#{smell.name}]/)
   end
 end

data/spec/reek/smells/uncommunicative_name_spec.rb

@@ -0,0 +1,83 @@
+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
+
+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/]]
+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/]]
+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', [[]]
+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/]]
+end
+
+describe MethodChecker, "several uncommunicative names" do
+
+  check 'should report all bad names', 'def y(x) @z = x end', [[/'@z'/], [/'y'/], [/'x'/]]
+
+  source =<<EOS
+def bad(fred)
+  @fred.each {|x| 4 - x }
+  @jim.each {|y| y - 4 }
+end
+EOS
+  check 'should report all bad block parameters', source, [[/'x'/], [/'y'/]], 'bug'
+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 = []
+  end
+
+  it 'should return true when reporting a smell' do
+    @mc.name = 'x'
+    UncommunicativeName.examine(@mc, []).should == true
+  end
+  
+  it 'should return false when not reporting a smell' do
+    @mc.name = 'not_bad'
+    UncommunicativeName.examine(@mc, []).should == false
+  end
+end