reek 0.3.1 → 1.0.0

data/spec/reek/if_context_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'reek/if_context'
+
+include Reek
+
+describe IfContext do
+  it 'should find a class within top-level code' do
+    'unless jim; class Array; end; end'.should_not reek
+  end
+
+  it 'should find class within top-level code' do
+    stopctx = StopContext.new
+    ifctx = IfContext.new(stopctx, [:if, [:vcall, :jim]])
+    ifctx.find_module(Name.new(:Array)).should_not be_nil
+  end
+end

data/spec/reek/method_context_spec.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'reek/method_context'
+require 'reek/stop_context'
+
+include Reek
+
+describe MethodContext, 'matching' do
+  before :each do
+    @element = MethodContext.new(StopContext.new, [0, :mod])
+  end
+
+  it 'should recognise itself in a collection of names' do
+    @element.matches?(['banana', 'mod']).should == true
+    @element.matches?(['banana']).should == false
+  end
+
+  it 'should recognise itself in a collection of REs' do
+    @element.matches?([/banana/, /mod/]).should == true
+    @element.matches?([/banana/]).should == false
+  end
+end
+
+describe MethodContext, 'matching fq names' do
+  before :each do
+    element = StopContext.new
+    element = ModuleContext.new(element, [0, :mod])
+    element = ClassContext.new(element, [0, :klass])
+    @element = MethodContext.new(element, [0, :meth])
+  end
+
+  it 'should recognise itself in a collection of names' do
+    @element.matches?(['banana', 'meth']).should == true
+    @element.matches?(['banana', 'klass#meth']).should == true
+    @element.matches?(['banana']).should == false
+  end
+
+  it 'should recognise itself in a collection of names' do
+    @element.matches?([/banana/, /meth/]).should == true
+    @element.matches?([/banana/, /klass#meth/]).should == true
+    @element.matches?([/banana/]).should == false
+  end
+end
+
+describe MethodContext do
+  it 'should record ivars as refs to self' do
+    mctx = MethodContext.new(StopContext.new, [:defn, :feed])
+    mctx.envious_receivers.should == []
+    mctx.record_call_to([:call, [:ivar, :@cow], :feed_to])
+    mctx.envious_receivers.should == []
+  end
+end

data/spec/reek/module_context_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require 'reek/module_context'
+require 'reek/stop_context'
+
+include Reek
+
+describe ModuleContext do
+  it 'should report module name for smell in method' do
+    'module Fred; def simple(x) true; end; end'.should reek_of(:UncommunicativeName, /x/, /simple/, /Fred/)
+  end
+
+  it 'should not report module with empty class' do
+    'module Fred; class Jim; end; end'.should_not reek
+  end
+
+  it 'should handle module with empty class' do
+    stop = StopContext.new
+    modctx = ModuleContext.create(stop, [:module, :Fred, []])
+    modctx.find_module(Name.new(:Jim)).should be_nil
+  end
+end
+
+describe ModuleContext do
+  it 'should recognise global constant' do
+    'module ::Global class Inside; end; end'.should_not reek
+  end
+
+  it 'should not find missing global constant' do
+    element = ModuleContext.create(StopContext.new, [:module, [:colon3, :Global], nil])
+    element.myself.should be_nil
+  end
+
+  it 'should find global constant' do
+    module ::GlobalTestModule; end
+    element = ModuleContext.create(StopContext.new, [:module, [:colon3, :GlobalTestModule], nil])
+    element.myself.name.should == 'GlobalTestModule'
+  end
+end

data/spec/reek/options_spec.rb

@@ -6,34 +6,8 @@ include Reek
 
 describe Options, ' when given no arguments' do
   it "should retain the default sort order" do
-    default_order = Options[:sort_order]
+    default_order = Options[:format]
     Options.parse ['nosuchfile.rb']
-    Options[:sort_order].should == default_order
-  end
-end
-
-describe Options, ' when --sort_order is specified' do
-  before :each do
-    @default_order = Options[:sort_order]
-  end
-
-  it 'should require an argument' do
-    lambda { Options.parse_args(['-s']) }.should raise_error(OptionParser::MissingArgument)
-    Options[:sort_order].should == @default_order
-  end
-
-  it "should allow sort by smell" do
-    Options.parse %w{-s smell xx}
-    Options[:sort_order].should == Report::SORT_ORDERS[:smell]
-  end
-
-  it "should allow sort by context" do
-    Options.parse %w{-s context xx}
-    Options[:sort_order].should == Report::SORT_ORDERS[:context]
-  end
-
-  it "should reject illegal sort order" do
-    lambda { Options.parse_args(%w{-s tarts}) }.should raise_error(OptionParser::InvalidArgument)
-    Options[:sort_order].should == @default_order
+    Options[:format].should == default_order
   end
 end

data/spec/reek/report_spec.rb

@@ -1,8 +1,9 @@
 require File.dirname(__FILE__) + '/../spec_helper.rb'
 
-require 'reek/method_checker'
-require 'reek/smells'
+require 'reek/smells/smell_detector'
 require 'reek/report'
+require 'reek/source'
+require 'reek/smells/feature_envy'
 
 include Reek
 
@@ -22,9 +23,7 @@ end
 
 describe Report, "to_s" do
   before(:each) do
-    rpt = Report.new
-    chk = MethodChecker.new(rpt, 'Thing')
-    chk.check_source('def simple(a) a[3] end')
+    rpt = Source.from_s('def simple(a) a[3] end').report
     @report = rpt.to_s.split("\n")
   end
 
@@ -41,42 +40,9 @@ end
 describe Report, " as a SortedSet" do
   it 'should only add a smell once' do
     rpt = Report.new
-    rpt << UtilityFunction.new(self, 1)
+    rpt << SmellWarning.new(Smells::FeatureEnvy.new, "self", 'too many!')
     rpt.length.should == 1
-    rpt << UtilityFunction.new(self, 1)
+    rpt << SmellWarning.new(Smells::FeatureEnvy.new, "self", 'too many!')
     rpt.length.should == 1
   end
 end
-
-describe SortByContext do
-  before :each do
-    @sorter = SortByContext
-  end
-
-  it 'should return 0 for identical smells' do
-    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', 30), LargeClass.new('y')).should == -1
-  end
-end
-
-describe SortBySmell do
-  before :each do
-    @sorter = SortBySmell
-  end
-  
-  it 'should return 0 for identical smells' do
-    @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', 29), LongMethod.new('y', 29)).should == -1
-  end
-
-  it 'should differentiate different smells with identical contexts' do
-    @sorter.compare(LongMethod.new('x', 28), LargeClass.new('x')).should == 1
-  end
-end

data/spec/reek/sexp_formatter_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'reek/code_parser'
+require 'reek/sexp_formatter'
+
+include Reek
+
+def should_print(example)
+  it "should format #{example} correctly" do
+    sexp = CodeParser.parse_tree_for(example)[0]
+    SexpFormatter.format(sexp).should == example
+  end
+end
+
+describe SexpFormatter do
+  should_print 'self'
+  should_print 'Alpha'
+  should_print 'Alpha::Beta'
+  should_print '@@fred'
+  should_print '`ls`'
+  should_print 'array[0]'
+  should_print 'array[0, 1, 2]'
+  should_print 'obj.method(arg1, arg2)'
+  should_print 'obj.method'
+  should_print '$1'
+  should_print 'o=q.downcase'
+  should_print 'true'
+  should_print '"-#{q}xxx#{z.size}"'
+  should_print '0..5'
+  should_print '0..temp'
+end

data/spec/reek/singleton_method_context_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'reek/module_context'
+require 'reek/singleton_method_context'
+require 'reek/stop_context'
+
+include Reek
+
+describe SingletonMethodContext, 'outer_name' do
+
+  it "should report full context" do
+    element = StopContext.new
+    element = ModuleContext.new(element, [0, :mod])
+    element = SingletonMethodContext.new(element,  [:defs, [:vcall, :a], :b, nil])
+    element.outer_name.should match(/mod::a\.b/)
+  end
+end

data/spec/reek/smells/control_couple_spec.rb

@@ -1,31 +1,23 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
-require 'reek/method_checker'
-require 'reek/report'
+require 'reek/smells/control_couple'
 
-include Reek
-
-describe MethodChecker, "(Control Couple)" do
-
-  before(:each) do
-    @rpt = Report.new
-    @cchk = MethodChecker.new(@rpt, 'Thing')
-  end
+include Reek::Smells
 
+describe ControlCouple do
   it 'should report a ternary check on a parameter' do
-    @cchk.check_source('def simple(arga) arga ? @ivar : 3 end')
-    @rpt.length.should == 1
-    ControlCouple.should === @rpt[0]
-    @rpt[0].to_s.should match(/arga/)
+    'def simple(arga) arga ? @ivar : 3 end'.should reek_of(:ControlCouple, /arga/)
   end
 
   it 'should not report a ternary check on an ivar' do
-    @cchk.check_source('def simple(arga) @ivar ? arga : 3 end')
-    @rpt.should be_empty
+    'def simple(arga) @ivar ? arga : 3 end'.should_not reek
   end
 
   it 'should not report a ternary check on a lvar' do
-    @cchk.check_source('def simple(arga) lvar = 27; lvar ? arga : @ivar end')
-    @rpt.should be_empty
+    'def simple(arga) lvar = 27; lvar ? arga : @ivar end'.should_not reek
+  end
+
+  it 'should spot a couple inside a block' do
+    'def blocks(arg) @text.map { |blk| arg ? blk : "#{blk}" } end'.should reek_of(:ControlCouple, /arg/)
   end
 end

data/spec/reek/smells/duplication_spec.rb

@@ -1,60 +1,81 @@
 require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-require 'reek/method_checker'
-require 'reek/smells/duplication'
 require 'reek/report'
+require 'reek/method_context'
+require 'reek/stop_context'
+require 'reek/smells/duplication'
 
 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 Duplication, "repeated method calls" do
+  it 'should report repeated call' do
+    'def double_thing() @other.thing + @other.thing end'.should reek_only_of(:Duplication, /@other.thing/)
   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', []
+  it 'should report repeated call to lvar' do
+    'def double_thing() other[@thing] + other[@thing] end'.should reek_only_of(:Duplication, /other\[@thing\]/)
+  end
+
+  it 'should report call parameters' do
+    'def double_thing() @other.thing(2,3) + @other.thing(2,3) end'.should reek_only_of(:Duplication, /@other.thing\(2, 3\)/)
+  end
+
+  it 'should report nested calls' do
+    ruby = 'def double_thing() @other.thing.foo + @other.thing.foo end'.to_source
+    ruby.should reek_of(:Duplication, /@other.thing[^\.]/)
+    ruby.should reek_of(:Duplication, /@other.thing.foo/)
+  end
+
+  it 'should ignore calls to new' do
+    'def double_thing() @other.new + @other.new end'.should_not reek
+  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', []
+  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
 
 require 'ostruct'
 
 describe Duplication, '#examine' do
-  
   before :each do
     @mc = OpenStruct.new
+    @dup = Duplication.new
   end
 
   it 'should return true when reporting a smell' do
     @mc.calls = {'x' => 47}
-    Duplication.examine(@mc, []).should == true
+    @dup.examine(@mc, []).should == true
   end
   
   it 'should return false when not reporting a smell' do
     @mc.calls = []
-    Duplication.examine(@mc, []).should == false
+    @dup.examine(@mc, []).should == false
+  end
+  
+  it 'should return false when not reporting calls to new' do
+    @mc.calls = {[:call, :Set, :new] => 4}
+    @dup.examine(@mc, []).should == false
+  end
+end
+
+describe Duplication, 'when disabled' do
+  before :each do
+    @ctx = MethodContext.new(StopContext.new, [0, :double_thing])
+    @dup = Duplication.new({SmellDetector::ENABLED_KEY => false})
+    @rpt = Report.new
+  end
+
+  it 'should not report repeated call' do
+    @ctx.record_call_to([:fred])
+    @ctx.record_call_to([:fred])
+    @dup.examine(@ctx, @rpt).should == false
+    @rpt.length.should == 0
   end
 end

data/spec/reek/smells/feature_envy_spec.rb

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