reek 1.0.0 → 1.1.3

data/spec/reek/block_context_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'reek/block_context'
+require 'reek/method_context'
+
+include Reek
+
+describe BlockContext do
+
+  it "should record single parameter" do
+    element = StopContext.new
+    element = BlockContext.new(element, s(s(:lasgn, :x), nil))
+    element.variable_names.should == [Name.new(:x)]
+  end
+
+  it "should record single parameter within a method" do
+    element = StopContext.new
+    element = MethodContext.new(element, s(:defn, :help))
+    element = BlockContext.new(element, s(s(:lasgn, :x), nil))
+    element.variable_names.should == [Name.new(:x)]
+  end
+
+  it "records multiple parameters" do
+    element = StopContext.new
+    element = BlockContext.new(element, s(s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))), nil))
+    element.variable_names.should == [Name.new(:x), Name.new(:y)]
+  end
+
+  it "should not pass parameters upward" do
+    mc = MethodContext.new(StopContext.new, s(:defn, :help))
+    element = BlockContext.new(mc, s(s(:lasgn, :x)))
+    mc.variable_names.should be_empty
+  end
+
+  it 'records local variables' do
+    bctx = BlockContext.new(StopContext.new, nil)
+    bctx.record_local_variable(:q2)
+    bctx.variable_names.should include(Name.new(:q2))
+  end
+end

data/spec/reek/class_context_spec.rb

@@ -39,46 +39,6 @@ EOEX
   end
 end
 
-describe Class do
-  
-  module Insert
-    def meth_a() end
-  private
-    def meth_b() end
-  protected
-    def meth_c() end
-  end
-
-  class Parent
-    def meth1() end
-  private
-    def meth2() end
-  protected
-    def meth3() end
-  end
-  
-  class FullChild < Parent
-    include Insert
-    def meth7() end
-  private
-    def meth8() end
-  protected
-    def meth6() end
-  end
-
-  describe 'with no superclass or modules' do
-    it 'should report correct number of methods' do
-      Parent.non_inherited_methods.length.should == 3
-    end
-  end
-
-  describe 'with superclass and modules' do
-    it 'should report correct number of methods' do
-      FullChild.non_inherited_methods.length.should == 3
-    end
-  end
-end
-
 describe ClassContext, 'overridden methods' do
   class Above
     def above() end
@@ -196,3 +156,14 @@ describe CodeContext, 'find class' do
     end
   end
 end
+
+describe ClassContext 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/code_context_spec.rb

@@ -45,7 +45,8 @@ describe CodeContext, 'instance variables' do
     element = MethodContext.new(class_element, [0, :bad])
     element = BlockContext.new(element, nil)
     element.record_instance_variable(:fred)
-    class_element.variable_names.should == [Name.new(:fred)]
+    class_element.variable_names.size.should == 1
+    class_element.variable_names.should include(Name.new(:fred))
   end
 end
 

data/spec/reek/code_parser_spec.rb

@@ -20,16 +20,6 @@ describe CodeParser, 'with a global method definition' do
   end
 end
 
-describe CodeParser, 'when given a C extension' do
-  before(:each) do
-    @cchk = CodeParser.new(Report.new, SmellConfig.new.smell_listeners)
-  end
-
-  it 'should ignore :cfunc' do
-    @cchk.check_object(Enumerable)
-  end
-end
-
 describe CodeParser, 'when a yield is the receiver' do
   it 'should report no problems' do
     source = 'def values(*args)

data/spec/reek/config_spec.rb

@@ -17,7 +17,7 @@ describe 'Config' do
     other = Hash.new {|hash,key| hash[key] = {} }
     other['one']['gunk'] = 45
     other['two']['four'] = false
-    @first.value_merge!(other).to_yaml
+    other.push_keys(@first)
     @first['two']['four'].should == false
     @first['one'].keys.length.should == 3
   end
@@ -36,7 +36,7 @@ describe Config, 'merging arrays' do
   it 'should merge array values' do
     first = {'key' => {'one' => [1,2,3]}}
     second = {'key' => {'one' => [4,5]}}
-    first.value_merge!(second)
+    second.push_keys(first)
     first['key']['one'].should == [1,2,3,4,5]
   end
 end

data/spec/reek/method_context_spec.rb

@@ -49,4 +49,18 @@ describe MethodContext do
     mctx.record_call_to([:call, [:ivar, :@cow], :feed_to])
     mctx.envious_receivers.should == []
   end
+
+  it 'should count calls to self' do
+    mctx = MethodContext.new(StopContext.new, [:defn, :equals])
+    mctx.refs.record_ref([:lvar, :other])
+    mctx.record_call_to([:call, [:self], :thing])
+    mctx.envious_receivers.should be_empty
+  end
+
+  it 'should recognise a call on self' do
+    mc = MethodContext.new(StopContext.new, s(:defn, :deep))
+    mc.record_call_to(s(:call, s(:lvar, :text), :each, s(:arglist)))
+    mc.record_call_to(s(:call, nil, :shelve, s(:arglist)))
+    mc.envious_receivers.should be_empty
+  end
 end

data/spec/reek/name_spec.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require 'reek/name'
+
+include Reek
+
+describe Name, 'resolving symbols' do
+  it 'finds fq loaded class' do
+    exp = [:class, :"Reek::Smells::LargeClass", nil]
+    ctx = StopContext.new
+    res = Name.resolve(exp[1], ctx)
+    res[1].should == "LargeClass"
+  end
+end

data/spec/reek/object_refs_spec.rb

@@ -9,8 +9,8 @@ describe ObjectRefs, 'when empty' do
     @refs = ObjectRefs.new
   end
 
-  it 'should report one ref to self' do
-    @refs.refs_to_self.should == 1
+  it 'should report no refs to self' do
+    @refs.refs_to_self.should == 0
   end
 end
 
@@ -23,7 +23,7 @@ describe ObjectRefs, 'with no refs to self' do
   end
 
   it 'should report no refs to self' do
-    @refs.refs_to_self.should == 1
+    @refs.refs_to_self.should == 0
   end
 
   it 'should report :a as the max' do
@@ -45,16 +45,16 @@ describe ObjectRefs, 'with one ref to self' do
   end
 
   it 'should report 1 ref to self' do
-    @refs.refs_to_self.should == 2
+    @refs.refs_to_self.should == 1
   end
 
-  it 'should report self among the max' do
+  it 'should not report self among the max' do
     @refs.max_keys.should be_include('a')
-    @refs.max_keys.should be_include(Sexp.from_array([:lit, :self]))
+    @refs.max_keys.should_not include(Sexp.from_array([:lit, :self]))
   end
 
-  it 'should report self as the max' do
-    @refs.self_is_max?.should == true
+  it 'should not report self as the max' do
+    @refs.self_is_max?.should == false
   end
 end
 
@@ -62,6 +62,7 @@ describe ObjectRefs, 'with many refs to self' do
   before(:each) do
     @refs = ObjectRefs.new
     @refs.record_reference_to_self
+    @refs.record_reference_to_self
     @refs.record_ref('a')
     @refs.record_reference_to_self
     @refs.record_ref('b')
@@ -87,6 +88,7 @@ describe ObjectRefs, 'when self is not the only max' do
     @refs = ObjectRefs.new
     @refs.record_ref('a')
     @refs.record_reference_to_self
+    @refs.record_reference_to_self
     @refs.record_ref('b')
     @refs.record_ref('a')
   end
@@ -115,7 +117,7 @@ describe ObjectRefs, 'when self is not among the max' do
   end
 
   it 'should report all refs to self' do
-    @refs.refs_to_self.should == 1
+    @refs.refs_to_self.should == 0
   end
 
   it 'should not report self among the max' do

data/spec/reek/report_spec.rb

@@ -28,7 +28,7 @@ describe Report, "to_s" do
   end
 
   it 'should place each detailed report on a separate line' do
-    @report.length.should == 2
+    @report.should have_at_least(2).lines
   end
 
   it 'should mention every smell name' do

data/spec/reek/singleton_method_context_spec.rb

@@ -11,7 +11,7 @@ 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 = SingletonMethodContext.new(element,  [:defs, [:call, nil, :a, [:arglist]], :b, nil])
     element.outer_name.should match(/mod::a\.b/)
   end
 end

data/spec/reek/smells/duplication_spec.rb

@@ -13,7 +13,7 @@ describe Duplication, "repeated method calls" do
   end
 
   it 'should report repeated call to lvar' do
-    'def double_thing() other[@thing] + other[@thing] end'.should reek_only_of(:Duplication, /other\[@thing\]/)
+    'def double_thing(other) other[@thing] + other[@thing] end'.should reek_only_of(:Duplication, /other\[@thing\]/)
   end
 
   it 'should report call parameters' do
@@ -50,7 +50,7 @@ describe Duplication, '#examine' do
   end
 
   it 'should return true when reporting a smell' do
-    @mc.calls = {'x' => 47}
+    @mc.calls = {s(:call, nil, :other, s(:arglist)) => 47}
     @dup.examine(@mc, []).should == true
   end
   

data/spec/reek/smells/feature_envy_spec.rb

@@ -6,7 +6,7 @@ require 'reek/stop_context'
 include Reek
 include Reek::Smells
 
-describe FeatureEnvy, 'with only messages to self' do
+describe FeatureEnvy do
   it 'should not report use of self' do
     'def simple() self.to_s + self.to_i end'.should_not reek
   end
@@ -18,23 +18,26 @@ describe FeatureEnvy, 'with only messages to self' do
   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
   it 'should not report single use' do
-    'def no_envy(arga) arga.barg(@item) end'.should_not reek
+    '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
+    '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/)
+    '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
   it 'should report highest affinity' do
     ruby = 'def total_envy
       fred = @item
@@ -56,9 +59,7 @@ describe FeatureEnvy, 'when there are many possible receivers' do
     ruby.should reek_of(:FeatureEnvy, /total/)
     ruby.should reek_of(:FeatureEnvy, /fred/)
   end
-end
 
-describe FeatureEnvy, 'when the receiver is external' do
   it 'should ignore global variables' do
     'def no_envy() $s2.to_a; $s2[@item] end'.should_not reek
   end
@@ -66,9 +67,7 @@ describe FeatureEnvy, 'when the receiver is external' do
   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
   it 'should not report single use of an ivar' do
     'def no_envy() @item.to_a end'.should_not reek
   end
@@ -78,17 +77,132 @@ describe FeatureEnvy, 'when the receiver is an ivar' do
   end
 
   it 'should not report ivar usage in a parameter' do
-    'def no_envy; @item.price + tax(@item) - savings(@item) end'.should_not reek
+    'def no_envy
+        @item.price + tax(@item) - savings(@item)
+      end'.should_not reek
   end
 
   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/)
+    'def feed(thing)
+        @cow.feed_to(thing.pig)
+        @duck.feed_to(thing.pig)
+      end'.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/)
+    'def feed(thing)
+        cow.feed_to(thing.pig)
+        duck.feed_to(thing.pig)
+      end'.should reek_only_of(:Duplication, /thing.pig/)
+  end
+
+  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/)
+    #
+    # def moved_version
+    #   price + tax
+    # end
+    #
+    # def envy
+    #   @item.moved_version
+    # end
+  end
+
+  it 'ignores lvar usage in a parameter' do
+    'def no_envy
+       lv = @item
+       lv.price + tax(lv) - savings(lv)
+     end'.should_not reek
+  end
+
+  it 'reports the most-used ivar' do
+    pending('bug')
+    'def func
+       @other.a
+       @other.b
+       @nother.c
+     end'.should reek_of(:FeatureEnvy, /@other/)
+    #
+    # def other.func(me)
+    #   a
+    #   b
+    #   me.nother_c
+    # end
+    #
+  end
+
+  it 'ignores multiple ivars' do
+    'def func
+       @other.a
+       @other.b
+       @nother.c
+       @nother.d
+     end'.should_not reek
+    #
+    # def other.func(me)
+    #   a
+    #   b
+    #   me.nother_c
+    #   me.nother_d
+    # end
+    #
+  end
+
+  it 'ignores frequent use of a call' do
+    'def func
+       other.a
+       other.b
+       nother.c
+     end'.should_not reek_of(:FeatureEnvy)
+  end
+
+  it 'counts self references correctly' do
+    'def adopt!(other)
+      other.keys.each do |key|
+        ov = other[key]
+        if Array === ov and has_key?(key)
+          self[key] += ov
+        else
+          self[key] = ov
+        end
+      end
+      self
+    end'.should_not reek
+  end
+end
+
+describe FeatureEnvy do
+  it 'counts references to self correctly' do
+    ruby = <<EOS
+def report
+  unless @report
+    @report = Report.new
+    cf = SmellConfig.new
+    cf = cf.load_local(@dir) if @dir
+    CodeParser.new(@report, cf.smell_listeners).check_source(@source)
+  end
+  @report
+end
+EOS
+    ruby.should reek_only_of(:LongMethod)
   end
 end
 
@@ -104,26 +218,8 @@ describe FeatureEnvy, '#examine' do
     @context.refs.record_ref([:lvar, :thing])
     @fe.examine(@context, []).should == true
   end
-  
+
   it 'should return false when not reporting a smell' do
     @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