reek 2.0.0 → 2.0.1

data/spec/reek/smells/data_clump_spec.rb

@@ -2,119 +2,124 @@ require 'spec_helper'
 require 'reek/smells/data_clump'
 require 'reek/smells/smell_detector_shared'
 
-include Reek::Smells
-
 shared_examples_for 'a data clump detector' do
   it 'does not report small parameter sets' do
-    src = <<EOS
-# test module
-#{@context} Scrunch
-  def first(pa) @field == :sym ? 0 : 3; end
-  def second(pa) @field == :sym; end
-  def third(pa) pa - pb + @fred; end
-end
-EOS
-    expect(src).not_to reek_of(DataClump)
+    src = <<-EOS
+      # test module
+      #{@context} Scrunch
+        def first(pa) @field == :sym ? 0 : 3; end
+        def second(pa) @field == :sym; end
+        def third(pa) pa - pb + @fred; end
+      end
+    EOS
+    expect(src).not_to reek_of(:DataClump)
   end
 
   context 'with 3 identical pairs' do
     before :each do
       @module_name = 'Scrunch'
-      @src = <<EOS
-#{@context} #{@module_name}
-  def first(pa, pb) @field == :sym ? 0 : 3; end
-  def second(pa, pb) @field == :sym; end
-  def third(pa, pb) pa - pb + @fred; end
-end
-EOS
-      ctx = ModuleContext.new(nil, @src.to_reek_source.syntax_tree)
-      detector = DataClump.new('newt')
+      @src = <<-EOS
+        #{@context} #{@module_name}
+          def first(pa, pb) @field == :sym ? 0 : 3; end
+          def second(pa, pb) @field == :sym; end
+          def third(pa, pb) pa - pb + @fred; end
+        end
+      EOS
+      ctx = Reek::Core::ModuleContext.new(nil, @src.to_reek_source.syntax_tree)
+      detector = build(:smell_detector, smell_type: :DataClump)
       @smells = detector.examine_context(ctx)
     end
+
     it 'records only the one smell' do
       expect(@smells.length).to eq(1)
     end
+
     it 'reports all parameters' do
       expect(@smells[0].parameters[:parameters]).to eq(['pa', 'pb'])
     end
+
     it 'reports the number of occurrences' do
       expect(@smells[0].parameters[:count]).to eq(3)
     end
+
     it 'reports all methods' do
       expect(@smells[0].parameters[:methods]).to eq(['first', 'second', 'third'])
     end
+
     it 'reports the declaration line numbers' do
       expect(@smells[0].lines).to eq([2, 3, 4])
     end
+
     it 'reports the correct smell class' do
-      expect(@smells[0].smell_category).to eq(DataClump.smell_category)
+      expect(@smells[0].smell_category).to eq(Reek::Smells::DataClump.smell_category)
     end
+
     it 'reports the context fq name' do
       expect(@smells[0].context).to eq(@module_name)
     end
   end
 
   it 'reports 3 swapped pairs' do
-    src = <<EOS
-#{@context} Scrunch
-  def one(pa, pb) @field == :sym ? 0 : 3; end
-  def two(pb, pa) @field == :sym; end
-  def tri(pa, pb) pa - pb + @fred; end
-end
-EOS
-    expect(src).to reek_of(DataClump,
+    src = <<-EOS
+      #{@context} Scrunch
+        def one(pa, pb) @field == :sym ? 0 : 3; end
+        def two(pb, pa) @field == :sym; end
+        def tri(pa, pb) pa - pb + @fred; end
+      end
+    EOS
+    expect(src).to reek_of(:DataClump,
                            count: 3,
                            parameters: ['pa', 'pb'])
   end
 
   it 'reports 3 identical parameter sets' do
-    src = <<EOS
-#{@context} Scrunch
-  def first(pa, pb, pc) @field == :sym ? 0 : 3; end
-  def second(pa, pb, pc) @field == :sym; end
-  def third(pa, pb, pc) pa - pb + @fred; end
-end
-EOS
-    expect(src).to reek_of(DataClump,
+    src = <<-EOS
+      #{@context} Scrunch
+        def first(pa, pb, pc) @field == :sym ? 0 : 3; end
+        def second(pa, pb, pc) @field == :sym; end
+        def third(pa, pb, pc) pa - pb + @fred; end
+      end
+    EOS
+    expect(src).to reek_of(:DataClump,
                            count: 3,
                            parameters: ['pa', 'pb', 'pc'])
   end
 
   it 'reports re-ordered identical parameter sets' do
-    src = <<EOS
-#{@context} Scrunch
-  def first(pb, pa, pc) @field == :sym ? 0 : 3; end
-  def second(pc, pb, pa) @field == :sym; end
-  def third(pa, pb, pc) pa - pb + @fred; end
-end
-EOS
-    expect(src).to reek_of(DataClump,
+    src = <<-EOS
+      #{@context} Scrunch
+        def first(pb, pa, pc) @field == :sym ? 0 : 3; end
+        def second(pc, pb, pa) @field == :sym; end
+        def third(pa, pb, pc) pa - pb + @fred; end
+      end
+    EOS
+    expect(src).to reek_of(:DataClump,
                            count: 3,
                            parameters: ['pa', 'pb', 'pc'])
   end
 
   it 'counts only identical parameter sets' do
-    src = <<EOS
-#{@context} RedCloth
-  def fa(p1, p2, p3, conten) end
-  def fb(p1, p2, p3, conten) end
-  def fc(name, windowW, windowH) end
-end
-EOS
-    expect(src).not_to reek_of(DataClump)
+    src = <<-EOS
+      #{@context} RedCloth
+        def fa(p1, p2, p3, conten) end
+        def fb(p1, p2, p3, conten) end
+        def fc(name, windowW, windowH) end
+      end
+    EOS
+    expect(src).not_to reek_of(:DataClump)
   end
 
   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
-    expect(src).to reek_of(DataClump, count: 5)
+    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
+    expect(src).to reek_of(:DataClump, count: 5)
   end
 
   it 'correctly checks number of occurences' do
@@ -127,7 +132,7 @@ EOS
         def fe(p5, p1, p2) end
       end
     EOS
-    expect(src).not_to reek_of(DataClump)
+    expect(src).not_to reek_of(:DataClump)
   end
 
   it 'detects clumps smaller than the total number of arguments' do
@@ -138,7 +143,7 @@ EOS
         def fc(p4, p1, p2) end
       end
     EOS
-    expect(src).to reek_of(DataClump,
+    expect(src).to reek_of(:DataClump,
                            parameters: %w(p1 p2))
   end
 
@@ -150,14 +155,14 @@ EOS
         def fc(p1, p2, *) end
       end
     EOS
-    expect(src).to reek_of(DataClump,
+    expect(src).to reek_of(:DataClump,
                            parameters: %w(p1 p2))
   end
 end
 
-describe DataClump do
+describe Reek::Smells::DataClump do
   before(:each) do
-    @detector = DataClump.new('newt')
+    @detector = build(:smell_detector, smell_type: :DataClump)
   end
 
   it_should_behave_like 'SmellDetector'
@@ -177,6 +182,4 @@ describe DataClump do
 
     it_should_behave_like 'a data clump detector'
   end
-
-  # TODO: include singleton methods in the calcs
 end

data/spec/reek/smells/duplicate_method_call_spec.rb

@@ -1,17 +1,15 @@
 require 'spec_helper'
 require 'reek/smells/duplicate_method_call'
-require 'reek/core/code_parser'
+require 'reek/core/code_context'
+require 'reek/core/tree_walker'
 require 'reek/core/sniffer'
 require 'reek/smells/smell_detector_shared'
 
-include Reek
-include Reek::Smells
-
-describe DuplicateMethodCall do
+describe Reek::Smells::DuplicateMethodCall do
   context 'when a smell is reported' do
     before :each do
-      @source_name = 'copy-cat'
-      @detector = DuplicateMethodCall.new(@source_name)
+      @source_name = 'dummy_source'
+      @detector = build(:smell_detector, smell_type: :DuplicateMethodCall, source: @source_name)
       src = <<-EOS
         def double_thing(other)
           other[@thing]
@@ -19,7 +17,7 @@ describe DuplicateMethodCall do
           other[@thing]
         end
       EOS
-      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      ctx = Reek::Core::CodeContext.new(nil, src.to_reek_source.syntax_tree)
       smells = @detector.examine_context(ctx)
       expect(smells.length).to eq(1)
       @warning = smells[0]
@@ -31,6 +29,7 @@ describe DuplicateMethodCall do
     it 'reports the call' do
       expect(@warning.parameters[:name]).to eq('other[@thing]')
     end
+
     it 'reports the correct lines' do
       expect(@warning.lines).to eq([2, 4])
     end
@@ -39,28 +38,28 @@ describe DuplicateMethodCall do
   context 'with repeated method calls' do
     it 'reports repeated call' do
       src = 'def double_thing() @other.thing + @other.thing end'
-      expect(src).to reek_of(DuplicateMethodCall, name: '@other.thing')
+      expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing')
     end
 
     it 'reports repeated call to lvar' do
       src = 'def double_thing(other) other[@thing] + other[@thing] end'
-      expect(src).to reek_of(DuplicateMethodCall, name: 'other[@thing]')
+      expect(src).to reek_of(:DuplicateMethodCall, name: 'other[@thing]')
     end
 
     it 'reports call parameters' do
       src = 'def double_thing() @other.thing(2,3) + @other.thing(2,3) end'
-      expect(src).to reek_of(DuplicateMethodCall, name: '@other.thing(2, 3)')
+      expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing(2, 3)')
     end
 
     it 'should report nested calls' do
       src = 'def double_thing() @other.thing.foo + @other.thing.foo end'
-      expect(src).to reek_of(DuplicateMethodCall, name: '@other.thing')
-      expect(src).to reek_of(DuplicateMethodCall, name: '@other.thing.foo')
+      expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing')
+      expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing.foo')
     end
 
     it 'should ignore calls to new' do
       src = 'def double_thing() @other.new + @other.new end'
-      expect(src).not_to reek_of(DuplicateMethodCall)
+      expect(src).not_to reek_of(:DuplicateMethodCall)
     end
   end
 
@@ -76,7 +75,7 @@ describe DuplicateMethodCall do
           end
         end
       EOS
-      expect(src).not_to reek_of(DuplicateMethodCall)
+      expect(src).not_to reek_of(:DuplicateMethodCall)
     end
   end
 
@@ -88,7 +87,7 @@ describe DuplicateMethodCall do
           bar { baz }
         end
       EOS
-      expect(src).to reek_of(DuplicateMethodCall)
+      expect(src).to reek_of(:DuplicateMethodCall)
     end
 
     it 'reports no smell if the blocks are different' do
@@ -98,7 +97,7 @@ describe DuplicateMethodCall do
           bar { qux }
         end
       EOS
-      expect(src).not_to reek_of(DuplicateMethodCall)
+      expect(src).not_to reek_of(:DuplicateMethodCall)
     end
   end
 
@@ -110,7 +109,7 @@ describe DuplicateMethodCall do
           bar.qux { baz }
         end
       EOS
-      expect(src).to reek_of(DuplicateMethodCall)
+      expect(src).to reek_of(:DuplicateMethodCall)
     end
 
     it 'reports a smell if the blocks are different' do
@@ -120,53 +119,55 @@ describe DuplicateMethodCall do
           bar.qux { qux }
         end
       EOS
-      expect(src).to reek_of(DuplicateMethodCall)
+      expect(src).to reek_of(:DuplicateMethodCall)
     end
   end
 
   context 'with repeated attribute assignment' do
     it 'reports repeated assignment' do
       src = 'def double_thing(thing) @other[thing] = true; @other[thing] = true; end'
-      expect(src).to reek_of(DuplicateMethodCall, name: '@other[thing] = true')
+      expect(src).to reek_of(:DuplicateMethodCall, name: '@other[thing] = true')
     end
     it 'does not report multi-assignments' do
-      src = <<EOS
-def _parse ctxt
-  ctxt.index, result = @ind, @result
-  error, ctxt.index = @err, @err_ind
-end
-EOS
-      expect(src).not_to reek_of(DuplicateMethodCall)
+      src = <<-EOS
+        def _parse ctxt
+          ctxt.index, result = @ind, @result
+          error, ctxt.index = @err, @err_ind
+        end
+      EOS
+      expect(src).not_to reek_of(:DuplicateMethodCall)
     end
   end
 
   context 'non-repeated method calls' do
     it 'should not report similar calls' do
       src = 'def equals(other) other.thing == self.thing end'
-      expect(src).not_to reek_of(DuplicateMethodCall)
+      expect(src).not_to reek_of(:DuplicateMethodCall)
     end
+
     it 'should respect call parameters' do
       src = 'def double_thing() @other.thing(3) + @other.thing(2) end'
-      expect(src).not_to reek_of(DuplicateMethodCall)
+      expect(src).not_to reek_of(:DuplicateMethodCall)
     end
   end
 
   context 'allowing up to 3 calls' do
     before :each do
-      @config = { DuplicateMethodCall: { DuplicateMethodCall::MAX_ALLOWED_CALLS_KEY => 3 } }
+      @config = { DuplicateMethodCall:
+                  { Reek::Smells::DuplicateMethodCall::MAX_ALLOWED_CALLS_KEY => 3 } }
     end
 
     it 'does not report double calls' do
       src = 'def double_thing() @other.thing + @other.thing end'
       with_test_config(@config) do
-        expect(src).not_to reek_of(DuplicateMethodCall)
+        expect(src).not_to reek_of(:DuplicateMethodCall)
       end
     end
 
     it 'does not report triple calls' do
       src = 'def double_thing() @other.thing + @other.thing + @other.thing end'
       with_test_config(@config) do
-        expect(src).not_to reek_of(DuplicateMethodCall)
+        expect(src).not_to reek_of(:DuplicateMethodCall)
       end
     end
 
@@ -177,7 +178,7 @@ EOS
         end
       '
       with_test_config(@config) do
-        expect(src).to reek_of(DuplicateMethodCall, name: '@other.thing', count: 4)
+        expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing', count: 4)
       end
     end
   end
@@ -185,14 +186,15 @@ EOS
   context 'allowing calls to some methods' do
     before :each do
       @config = { DuplicateMethodCall:
-                  { DuplicateMethodCall::ALLOW_CALLS_KEY => ['@some.thing', /puts/] } }
+                  { Reek::Smells::DuplicateMethodCall::ALLOW_CALLS_KEY =>
+                    ['@some.thing', /puts/] } }
     end
 
     it 'does not report calls to some methods' do
       src = 'def double_some_thing() @some.thing + @some.thing end'
 
       with_test_config(@config) do
-        expect(src).not_to reek_of(DuplicateMethodCall)
+        expect(src).not_to reek_of(:DuplicateMethodCall)
       end
     end
 
@@ -200,7 +202,7 @@ EOS
       src = 'def double_other_thing() @other.thing + @other.thing end'
 
       with_test_config(@config) do
-        expect(src).to reek_of(DuplicateMethodCall, name: '@other.thing')
+        expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing')
       end
     end
 
@@ -208,7 +210,7 @@ EOS
       src = 'def double_puts() puts @other.thing; puts @other.thing end'
 
       with_test_config(@config) do
-        expect(src).to reek_of(DuplicateMethodCall, name: '@other.thing')
+        expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing')
       end
     end
   end

data/spec/reek/smells/feature_envy_spec.rb

@@ -2,10 +2,7 @@ require 'spec_helper'
 require 'reek/smells/feature_envy'
 require 'reek/smells/smell_detector_shared'
 
-include Reek
-include Reek::Smells
-
-describe FeatureEnvy do
+describe Reek::Smells::FeatureEnvy do
   context 'with no smell' do
     it 'should not report use of self' do
       expect('def simple() self.to_s + self.to_i end').not_to reek_of(:FeatureEnvy)
@@ -132,14 +129,6 @@ describe FeatureEnvy do
         lv.price + lv.tax
       end
     ').to reek_only_of(:FeatureEnvy)
-    #
-    # def moved_version
-    #   price + tax
-    # end
-    #
-    # def envy
-    #   @item.moved_version
-    # end
   end
 
   it 'ignores frequent use of a call' do
@@ -177,54 +166,54 @@ describe FeatureEnvy do
   end
 
   it 'counts self references correctly' do
-    src = <<EOS
-def adopt(other)
-  other.keys.each do |key|
-    self[key] += 3
-    self[key] = o4
-  end
-  self
-end
-EOS
+    src = <<-EOS
+      def adopt(other)
+        other.keys.each do |key|
+          self[key] += 3
+          self[key] = o4
+        end
+        self
+      end
+    EOS
     expect(src).not_to reek_of(:FeatureEnvy)
   end
 end
 
-describe FeatureEnvy do
+describe Reek::Smells::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 = <<-EOS
+      def report
+        unless @report
+          @report = Report.new
+          cf = SmellConfig.new
+          cf = cf.load_local(@dir) if @dir
+          TreeWalker.new(@report, cf.smell_listeners).check_source(@source)
+        end
+        @report
+      end
+    EOS
     expect(ruby).not_to reek_of(:FeatureEnvy)
   end
 
   it 'interprets << correctly' do
-    ruby = <<EOS
-def report_on(report)
-  if @is_doubled
-    report.record_doubled_smell(self)
-  else
-    report << self
-  end
-end
-EOS
+    ruby = <<-EOS
+      def report_on(report)
+        if @is_doubled
+          report.record_doubled_smell(self)
+        else
+          report << self
+        end
+      end
+    EOS
 
     expect(ruby).not_to reek_of(:FeatureEnvy)
   end
 end
 
-describe FeatureEnvy do
+describe Reek::Smells::FeatureEnvy do
   before(:each) do
-    @source_name = 'green as a cucumber'
-    @detector = FeatureEnvy.new(@source_name)
+    @source_name = 'dummy_source'
+    @detector = build(:smell_detector, smell_type: :FeatureEnvy, source: @source_name)
   end
 
   it_should_behave_like 'SmellDetector'
@@ -232,37 +221,44 @@ describe FeatureEnvy do
   context 'when reporting yaml' do
     before :each do
       @receiver = 'other'
-      src = <<EOS
-def envious(other)
-  #{@receiver}.call
-  self.do_nothing
-  #{@receiver}.other
-  #{@receiver}.fred
-end
-EOS
+      src = <<-EOS
+        def envious(other)
+          #{@receiver}.call
+          self.do_nothing
+          #{@receiver}.other
+          #{@receiver}.fred
+        end
+      EOS
       source = src.to_reek_source
-      sniffer = Sniffer.new(source)
-      @mctx = CodeParser.new(sniffer).process_def(source.syntax_tree)
+      sniffer = Reek::Core::Sniffer.new(source)
+      @mctx = Reek::Core::TreeWalker.new(sniffer).process_def(source.syntax_tree)
       @smells = @detector.examine_context(@mctx)
     end
+
     it 'reports only that smell' do
       expect(@smells.length).to eq(1)
     end
+
     it 'reports the source' do
       expect(@smells[0].source).to eq(@source_name)
     end
+
     it 'reports the smell class' do
-      expect(@smells[0].smell_category).to eq(FeatureEnvy.smell_category)
+      expect(@smells[0].smell_category).to eq(described_class.smell_category)
     end
+
     it 'reports the smell sub class' do
-      expect(@smells[0].smell_type).to eq(FeatureEnvy.smell_type)
+      expect(@smells[0].smell_type).to eq(described_class.smell_type)
     end
+
     it 'reports the envious receiver' do
       expect(@smells[0].parameters[:name]).to eq(@receiver)
     end
+
     it 'reports the number of references' do
       expect(@smells[0].parameters[:count]).to eq(3)
     end
+
     it 'reports the referring lines' do
       skip
       expect(@smells[0].lines).to eq([2, 4, 5])