reek 1.2.7.3 → 1.2.8

data/spec/reek/core/method_context_spec.rb

@@ -24,14 +24,14 @@ end
 
 describe MethodContext do
   it 'should record ivars as refs to self' do
-    mctx = MethodContext.new(StopContext.new, [:defn, :feed])
+    mctx = MethodContext.new(StopContext.new, ast(:defn, :feed))
     mctx.envious_receivers.should == []
     mctx.record_call_to(ast(:call, s(:ivar, :@cow), :feed_to))
     mctx.envious_receivers.should == []
   end
 
   it 'should count calls to self' do
-    mctx = MethodContext.new(StopContext.new, [:defn, :equals])
+    mctx = MethodContext.new(StopContext.new, ast(:defn, :equals))
     mctx.refs.record_ref([:lvar, :other])
     mctx.record_call_to(ast(:call, s(:self), :thing))
     mctx.envious_receivers.should be_empty
@@ -65,7 +65,7 @@ describe MethodParameters, 'default assignments' do
       @defaults = assignments_from(src)
     end
     it 'returns the param-value pair' do
-      @defaults[:argb].should == s(:lit, 456)
+      @defaults[0].should == s(:argb, s(:lit, 456))
     end
     it 'returns the nothing else' do
       @defaults.length.should == 1
@@ -78,8 +78,8 @@ describe MethodParameters, 'default assignments' do
       @defaults = assignments_from(src)
     end
     it 'returns both param-value pairs' do
-      @defaults[:arga].should == s(:lit, 123)
-      @defaults[:argb].should == s(:lit, 456)
+      @defaults[0].should == s(:arga, s(:lit, 123))
+      @defaults[1].should == s(:argb, s(:lit, 456))
     end
     it 'returns nothing else' do
       @defaults.length.should == 2

data/spec/reek/smells/attribute_spec.rb

@@ -18,8 +18,7 @@ describe Attribute do
     it 'records nothing in the module' do
       src = 'module Fred; end'
       ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
-      @detector.examine_context(ctx)
-      @detector.smells_found.should be_empty
+      @detector.examine_context(ctx).should be_empty
     end
   end
 
@@ -31,8 +30,7 @@ describe Attribute do
     shared_examples_for 'one attribute found' do
       before :each do
         ctx = CodeContext.new(nil, @src.to_reek_source.syntax_tree)
-        @detector.examine_context(ctx)
-        @smells = @detector.smells_found.to_a
+        @smells = @detector.examine_context(ctx)
       end
 
       it 'records only that attribute' do

data/spec/reek/smells/boolean_parameter_spec.rb

@@ -8,69 +8,59 @@ describe BooleanParameter do
   context 'parameter defaulted with boolean' do
     context 'in a method' do
       it 'reports a parameter defaulted to true' do
-        'def cc(arga = true) end'.should reek_of(:BooleanParameter, /arga/)
+        src = 'def cc(arga = true) end'
+        src.should smell_of(BooleanParameter, BooleanParameter::PARAMETER_KEY => 'arga')
       end
       it 'reports a parameter defaulted to false' do
-        'def cc(arga = false) end'.should reek_of(:BooleanParameter, /arga/)
+        src = 'def cc(arga = false) end'
+        src.should smell_of(BooleanParameter, BooleanParameter::PARAMETER_KEY => 'arga')
       end
       it 'reports two parameters defaulted to booleans' do
         src = 'def cc(nowt, arga = true, argb = false, &blk) end'
-        src.should reek_of(:BooleanParameter, /arga/)
-        src.should reek_of(:BooleanParameter, /argb/)
+        src.should smell_of(BooleanParameter,
+          {BooleanParameter::PARAMETER_KEY => 'arga'},
+          {BooleanParameter::PARAMETER_KEY => 'argb'})
       end
     end
 
     context 'in a singleton method' do
       it 'reports a parameter defaulted to true' do
-        'def self.cc(arga = true) end'.should reek_of(:BooleanParameter, /arga/)
+        src = 'def self.cc(arga = true) end'
+        src.should smell_of(BooleanParameter, BooleanParameter::PARAMETER_KEY => 'arga')
       end
       it 'reports a parameter defaulted to false' do
-        'def fred.cc(arga = false) end'.should reek_of(:BooleanParameter, /arga/)
+        src = 'def fred.cc(arga = false) end'
+        src.should smell_of(BooleanParameter, BooleanParameter::PARAMETER_KEY => 'arga')
       end
       it 'reports two parameters defaulted to booleans' do
         src = 'def Module.cc(nowt, arga = true, argb = false, &blk) end'
-        src.should reek_of(:BooleanParameter, /arga/)
-        src.should reek_of(:BooleanParameter, /argb/)
+        src.should smell_of(BooleanParameter,
+          {BooleanParameter::PARAMETER_KEY => 'arga'},
+          {BooleanParameter::PARAMETER_KEY => 'argb'})
       end
     end
   end
-end
 
-describe BooleanParameter do
-  before(:each) do
-    @source_name = 'smokin'
-    @detector = BooleanParameter.new(@source_name)
-  end
+  context 'when a smell is reported' do
+    before(:each) do
+      @source_name = 'smokin'
+      @detector = BooleanParameter.new(@source_name)
+    end
 
-  it_should_behave_like 'SmellDetector'
+    it_should_behave_like 'SmellDetector'
 
-  context 'looking at the YAML' do
-    before :each do
-      src = <<EOS
-def cc(arga = true)
-end
-EOS
-      source = src.to_reek_source
-      sniffer = Sniffer.new(source)
-      @mctx = CodeParser.new(sniffer).process_defn(source.syntax_tree)
-      @detector.examine(@mctx)
-      warning = @detector.smells_found.to_a[0]   # SMELL: too cumbersome!
-      @yaml = warning.to_yaml
-    end
-    it 'reports the source' do
-      @yaml.should match(/source:\s*#{@source_name}/)
-    end
-    it 'reports the class' do
-      @yaml.should match(/\sclass:\s*ControlCouple/)
-    end
-    it 'reports the subclass' do
-      @yaml.should match(/subclass:\s*BooleanParameter/)
-    end
-    it 'reports the parameter name' do
-      @yaml.should match(/parameter:\s*arga/)
-    end
-    it 'reports the correct line' do
-      @yaml.should match(/lines:\s*- 1/)
+    it 'reports the fields correctly' do
+      src = 'def cc(arga = true) end'
+      ctx = MethodContext.new(nil, src.to_reek_source.syntax_tree)
+      @detector.examine(ctx)
+      smells = @detector.smells_found.to_a
+      smells.length.should == 1
+      smells[0].smell_class.should == BooleanParameter::SMELL_CLASS
+      smells[0].smell[BooleanParameter::PARAMETER_KEY].should == 'arga'
+      smells[0].source.should == @source_name
+      smells[0].smell_class.should == BooleanParameter::SMELL_CLASS
+      smells[0].subclass.should == BooleanParameter::SMELL_SUBCLASS
+      smells[0].lines.should == [1]
     end
   end
 end

data/spec/reek/smells/class_variable_spec.rb

@@ -8,7 +8,8 @@ include Reek::Smells
 
 describe ClassVariable do
   before :each do
-    @detector = ClassVariable.new('raffles')
+    @source_name = 'raffles'
+    @detector = ClassVariable.new(@source_name)
     @class_variable = '@@things'
   end
 
@@ -17,11 +18,11 @@ describe ClassVariable do
   context 'with no class variables' do
     it 'records nothing in the class' do
       exp = ast(:class, :Fred)
-      @detector.class_variables_in(exp).should be_empty
+      @detector.examine_context(CodeContext.new(nil, exp)).should be_empty
     end
     it 'records nothing in the module' do
       exp = ast(:module, :Fred)
-      @detector.class_variables_in(exp).should be_empty
+      @detector.examine_context(CodeContext.new(nil, exp)).should be_empty
     end
   end
 
@@ -29,13 +30,13 @@ describe ClassVariable do
     shared_examples_for 'one variable found' do
       before :each do
         ast = @src.to_reek_source.syntax_tree
-        @cvars = @detector.class_variables_in(ast).to_a
+        @smells = @detector.examine_context(CodeContext.new(nil, ast))
       end
       it 'records only that class variable' do
-        @cvars.length.should == 1
+        @smells.length.should == 1
       end
       it 'records the variable name' do
-        @cvars[0].to_s.should == @class_variable
+        @smells[0].smell[ClassVariable::VARIABLE_KEY].should == @class_variable
       end
     end
 
@@ -81,4 +82,19 @@ describe ClassVariable do
       end
     end
   end
+
+  it 'reports the correct fields' do
+    src = <<EOS
+module Fred
+  #{@class_variable} = {}
+end
+EOS
+    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 == ClassVariable::SMELL_CLASS
+    @warning.subclass.should == ClassVariable::SMELL_SUBCLASS
+    @warning.smell[ClassVariable::VARIABLE_KEY].should == @class_variable
+    @warning.lines.should == [2]
+  end
 end

data/spec/reek/smells/control_couple_spec.rb

@@ -14,20 +14,24 @@ describe ControlCouple do
 
   context 'conditional on a parameter' do
     it 'should report a ternary check on a parameter' do
-      'def simple(arga) arga ? @ivar : 3 end'.should reek_only_of(:ControlCouple, /arga/)
+      src = 'def simple(arga) arga ? @ivar : 3 end'
+      src.should smell_of(ControlCouple, ControlCouple::PARAMETER_KEY => 'arga')
     end
     it 'should not report a ternary check on an ivar' do
-      'def simple(arga) @ivar ? arga : 3 end'.should_not reek
+      src = 'def simple(arga) @ivar ? arga : 3 end'
+      src.should_not smell_of(ControlCouple)
     end
     it 'should not report a ternary check on a lvar' do
-      'def simple(arga) lvar = 27; lvar ? arga : @ivar end'.should_not reek
+      src = 'def simple(arga) lvar = 27; lvar ? arga : @ivar end'
+      src.should_not smell_of(ControlCouple)
     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/)
+      src = 'def blocks(arg) @text.map { |blk| arg ? blk : "#{blk}" } end'
+      src.should smell_of(ControlCouple, ControlCouple::PARAMETER_KEY => 'arg')
     end
   end
 
-  context 'looking at the YAML' do
+  context 'when a smell is reported' do
     before :each do
       src = <<EOS
 def things(arg)
@@ -37,19 +41,16 @@ def things(arg)
   puts "hello" if arg
 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 = MethodContext.new(nil, src.to_reek_source.syntax_tree)
+      smells = @detector.examine(ctx)
+      smells.length.should == 1
+      @warning = smells[0]
     end
 
     it_should_behave_like 'common fields set correctly'
 
-    it 'reports the control parameter' do
-      @warning.smell['parameter'].should == 'arg'
-    end
-    it 'reports all conditional locations' do
+    it 'has the correct fields' do
+      @warning.smell[ControlCouple::PARAMETER_KEY].should == 'arg'
       @warning.lines.should == [3,6]
     end
   end

data/spec/reek/smells/data_clump_spec.rb

@@ -14,8 +14,7 @@ shared_examples_for 'a data clump detector' do
   def third(pa) pa - pb + @fred; end
 end
 EOS
-
-    src.should_not reek
+    src.should_not smell_of(DataClump)
   end
 
   context 'with 3 identical pairs' do
@@ -30,8 +29,7 @@ end
 EOS
       ctx = CodeContext.new(nil, @src.to_reek_source.syntax_tree)
       detector = DataClump.new('newt')
-      detector.examine(ctx)
-      @smells = detector.smells_found.to_a
+      @smells = detector.examine_context(ctx)
       @warning = @smells[0]   # SMELL: too cumbersome!
       @yaml = @warning.to_yaml
     end
@@ -42,7 +40,7 @@ EOS
       @smells[0].smell[DataClump::PARAMETERS_KEY].should == ['pa', 'pb']
     end
     it 'reports the number of occurrences' do
-      @smells[0].smell['occurrences'].should == 3
+      @smells[0].smell[DataClump::OCCURRENCES_KEY].should == 3
     end
     it 'reports all parameters' do
       @smells[0].smell[DataClump::METHODS_KEY].should == ['first', 'second', 'third']
@@ -66,8 +64,8 @@ EOS
   def tri(pa, pb) pa - pb + @fred; end
 end
 EOS
-
-    src.should reek_of(:DataClump, /\[pa, pb\]/, /3 methods/)
+    src.should smell_of(DataClump, {DataClump::OCCURRENCES_KEY => 3,
+      DataClump::PARAMETERS_KEY => ['pa', 'pb']})
   end
 
   it 'reports 3 identical parameter sets in a class' do
@@ -78,14 +76,11 @@ EOS
   def third(pa, pb, pc) pa - pb + @fred; end
 end
 EOS
-
-    src.should reek_of(:DataClump, /\[pa, pb, pc\]/, /3 methods/)
-    src.should_not reek_of(:DataClump, /\[pa, pb\]/, /3 methods/)
-    src.should_not reek_of(:DataClump, /\[pa, pc\]/, /3 methods/)
-    src.should_not reek_of(:DataClump, /\[pb, pc\]/, /3 methods/)
+    src.should smell_of(DataClump, {DataClump::OCCURRENCES_KEY => 3,
+      DataClump::PARAMETERS_KEY => ['pa', 'pb', 'pc']})
   end
 
-  it 'recognises re-ordered identical parameter sets' do
+  it 'reports re-ordered identical parameter sets' do
     src = <<EOS
 #{@context} Scrunch
   def first(pb, pa, pc) @field == :sym ? 0 : 3; end
@@ -93,11 +88,8 @@ EOS
   def third(pa, pb, pc) pa - pb + @fred; end
 end
 EOS
-
-    src.should reek_of(:DataClump, /\[pa, pb, pc\]/, /3 methods/)
-    src.should_not reek_of(:DataClump, /\[pa, pb\]/, /3 methods/)
-    src.should_not reek_of(:DataClump, /\[pa, pc\]/, /3 methods/)
-    src.should_not reek_of(:DataClump, /\[pb, pc\]/, /3 methods/)
+    src.should smell_of(DataClump, {DataClump::OCCURRENCES_KEY => 3,
+      DataClump::PARAMETERS_KEY => ['pa', 'pb', 'pc']})
   end
 
   it 'counts only identical parameter sets' do
@@ -108,12 +100,30 @@ EOS
   def fc(name, windowW, windowH) end
 end
 EOS
+    src.should_not smell_of(DataClump)
+  end
 
-    src.should_not reek_of(:DataClump)
+  it 'gets a real example right' do
+    src = <<EOS
+#{@context} Inline
+  def generate(src, options) end
+  def c (src, options) end
+  def c_singleton (src, options) end
+  def c_raw (src, options) end
+  def c_raw_singleton (src, options) end
+end
+EOS
+    src.should smell_of(DataClump, DataClump::OCCURRENCES_KEY => 5)
   end
 end
 
 describe DataClump do
+  before(:each) do
+    @detector = DataClump.new('newt')
+  end
+
+  it_should_behave_like 'SmellDetector'
+
   context 'in a class' do
     before :each do
       @context = 'class'
@@ -132,95 +142,3 @@ describe DataClump do
 
   # TODO: include singleton methods in the calcs
 end
-
-describe DataClump do
-  before(:each) do
-    @detector = DataClump.new('newt')
-  end
-
-  it_should_behave_like 'SmellDetector'
-
-  it 'get a real example right' do
-    src = <<-EOS
-module Inline
-  def generate(src, options) end
-  def c (src, options) end
-  def c_singleton (src, options) end
-  def c_raw (src, options) end
-  def c_raw_singleton (src, options) end
-end
-EOS
-    ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
-    detector = DataClump.new('newt')
-    detector.examine(ctx)
-    smells = detector.smells_found.to_a
-    smells.length.should == 1
-    warning = smells[0]
-    warning.smell[DataClump::OCCURRENCES_KEY].should == 5
-  end
-end
-
-#---------------------------------------------------------------------------------
-#
-#def occurrences(potential_clump, all_methods)
-#  all_methods.select do |method|
-#    potential_clump - method == []
-#  end.length
-#end
-#
-#describe 'occurrences' do
-#  it 'counts correctly' do
-#    params = [[:a1, :a2], [:a1, :a2]]
-#    potential_clump = [:a1, :a2]
-#    occurrences(potential_clump, params).should == 2
-#  end
-#end
-#
-#def immediate_clumps(root, other_params, all_methods)
-#  result = []
-#  other_params.map do |param|
-#    potential_clump = (root + [param])
-#    if occurrences(potential_clump, all_methods) >= 2
-#      result << potential_clump
-#      result = result + immediate_clumps(potential_clump, other_params - [param], all_methods)
-#    end
-#  end.compact
-#  result
-#end
-#
-#def clumps_containing(root, other_params, all_methods)
-#  return [] unless other_params
-#  immediate_clumps(root, other_params, all_methods) + clumps_containing([other_params[0]], other_params[1..-1], all_methods)
-#end
-#
-#def clumps_in(all_methods)
-#  all_params = all_methods.flatten.sort {|a,b| a.to_s <=> b.to_s}.uniq
-#  clumps_containing([all_params[0]], all_params[1..-1], all_methods)
-#end
-#
-#describe 'set of parameters' do
-#  it 'finds the trivial clump' do
-#    params = [[:a1, :a2], [:a1, :a2]]
-#    clumps_in(params).should == [[:a1, :a2]]
-#  end
-#
-#  it 'finds the trivial size-3 clump' do
-#    params = [[:a1, :a2, :a3], [:a1, :a2, :a3]]
-#    clumps_in(params).should == [[:a1, :a2, :a3]]
-#  end
-#
-#  it 'doesnt find non clump' do
-#    params = [[:a1, :a2], [:a1, :a3]]
-#    clumps_in(params).should == []
-#  end
-#
-#  it 'finds the trivial sub-clump' do
-#    params = [[:a1, :a2], [:a3, :a1, :a2]]
-#    clumps_in(params).should == [[:a1, :a2]]
-#  end
-#
-#  it 'finds the non-a1 clump' do
-#    params = [[:a1, :a3, :a2], [:a3, :a2]]
-#    clumps_in(params).should == [[:a2, :a3]]
-#  end
-#end