reek 2.0.0 → 2.0.1

data/spec/reek/smells/nil_check_spec.rb

@@ -1,11 +1,9 @@
 require 'spec_helper'
+require 'reek/core/code_context'
 require 'reek/smells/nil_check'
 require 'reek/smells/smell_detector_shared'
 
-include Reek
-include Reek::Smells
-
-describe NilCheck do
+describe Reek::Smells::NilCheck do
   context 'for methods' do
     it 'reports the correct line number' do
       src = <<-EOS
@@ -13,43 +11,43 @@ describe NilCheck do
         foo.nil?
       end
       EOS
-      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
-      detector = NilCheck.new('source_name')
+      ctx = Reek::Core::CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      detector = build(:smell_detector, smell_type: :NilCheck, source: 'source_name')
       smells = detector.examine_context(ctx)
       expect(smells[0].lines).to eq [2]
     end
 
     it 'reports nothing when scope includes no nil checks' do
-      expect('def no_nils; end').not_to reek_of(NilCheck)
+      expect('def no_nils; end').not_to reek_of(:NilCheck)
     end
 
     it 'reports when scope uses multiple nil? methods' do
-      src = <<-eos
+      src = <<-EOS
       def chk_multi_nil(para)
         para.nil?
         puts "Hello"
         \"\".nil?
       end
-      eos
-      expect(src).to reek_of(NilCheck)
+      EOS
+      expect(src).to reek_of(:NilCheck)
     end
 
     it 'reports twice when scope uses == nil and === nil' do
-      src = <<-eos
+      src = <<-EOS
       def chk_eq_nil(para)
         para == nil
         para === nil
       end
-      eos
-      expect(src).to reek_of(NilCheck)
+      EOS
+      expect(src).to reek_of(:NilCheck)
     end
 
     it 'reports when scope uses nil ==' do
-      expect('def chk_eq_nil_rev(para); nil == para; end').to reek_of(NilCheck)
+      expect('def chk_eq_nil_rev(para); nil == para; end').to reek_of(:NilCheck)
     end
 
     it 'reports when scope uses multiple case-clauses checking nil' do
-      src = <<-eos
+      src = <<-EOS
       def case_nil
         case @inst_var
         when nil then puts "Nil"
@@ -60,19 +58,19 @@ describe NilCheck do
         when nil then puts nil.inspect
         end
       end
-      eos
-      expect(src).to reek_of(NilCheck)
+      EOS
+      expect(src).to reek_of(:NilCheck)
     end
 
     it 'reports a when clause that checks nil and other values' do
-      src = <<-eos
+      src = <<-EOS
       def case_nil
         case @inst_var
         when nil, false then puts "Hello"
         end
       end
-      eos
-      expect(src).to reek_of(NilCheck)
+      EOS
+      expect(src).to reek_of(:NilCheck)
     end
   end
 end

data/spec/reek/smells/prima_donna_method_spec.rb

@@ -1,23 +1,20 @@
 require 'spec_helper'
-
+require 'reek/core/module_context'
 require 'reek/smells/smell_detector_shared'
 
-include Reek
-include Reek::Smells
-
-describe PrimaDonnaMethod do
+describe Reek::Smells::PrimaDonnaMethod do
   it 'should report nothing when method and bang counterpart exist' do
-    expect('class C; def m; end; def m!; end; end').not_to reek_of(PrimaDonnaMethod)
+    expect('class C; def m; end; def m!; end; end').not_to reek_of(:PrimaDonnaMethod)
   end
 
   it 'should report PrimaDonnaMethod when only bang method exists' do
-    expect('class C; def m!; end; end').to reek_of(PrimaDonnaMethod)
+    expect('class C; def m!; end; end').to reek_of(:PrimaDonnaMethod)
   end
 
   describe 'the right smell' do
-    let(:detector) { PrimaDonnaMethod.new('dummy_source') }
+    let(:detector) { build(:smell_detector, smell_type: :PrimaDonnaMethod, source: 'source_name') }
     let(:src)      { 'class C; def m!; end; end' }
-    let(:ctx)      { ModuleContext.new(nil, src.to_reek_source.syntax_tree) }
+    let(:ctx)      { Reek::Core::ModuleContext.new(nil, src.to_reek_source.syntax_tree) }
 
     it 'should be reported' do
       smells = detector.examine_context(ctx)

data/spec/reek/smells/repeated_conditional_spec.rb

@@ -3,13 +3,10 @@ require 'reek/smells/repeated_conditional'
 require 'reek/core/code_context'
 require 'reek/smells/smell_detector_shared'
 
-include Reek::Core
-include Reek::Smells
-
-describe RepeatedConditional do
-  before :each do
-    @source_name = 'howdy-doody'
-    @detector = RepeatedConditional.new(@source_name)
+describe Reek::Smells::RepeatedConditional do
+  before(:each) do
+    @source_name = 'dummy_source'
+    @detector = build(:smell_detector, smell_type: :RepeatedConditional, source: @source_name)
   end
 
   it_should_behave_like 'SmellDetector'
@@ -17,7 +14,7 @@ describe RepeatedConditional do
   context 'with no conditionals' do
     it 'gathers an empty hash' do
       ast = 'module Stable; end'.to_reek_source.syntax_tree
-      ctx = CodeContext.new(nil, ast)
+      ctx = Reek::Core::CodeContext.new(nil, ast)
       expect(@detector.conditional_counts(ctx).length).to eq(0)
     end
   end
@@ -25,7 +22,7 @@ describe RepeatedConditional do
   context 'with a test of block_given?' do
     it 'does not record the condition' do
       ast = 'def fred() yield(3) if block_given?; end'.to_reek_source.syntax_tree
-      ctx = CodeContext.new(nil, ast)
+      ctx = Reek::Core::CodeContext.new(nil, ast)
       expect(@detector.conditional_counts(ctx).length).to eq(0)
     end
   end
@@ -33,7 +30,7 @@ describe RepeatedConditional do
   context 'with an empty condition' do
     it 'does not record the condition' do
       ast = 'def fred() case; when 3; end; end'.to_reek_source.syntax_tree
-      ctx = CodeContext.new(nil, ast)
+      ctx = Reek::Core::CodeContext.new(nil, ast)
       expect(@detector.conditional_counts(ctx).length).to eq(0)
     end
   end
@@ -42,25 +39,25 @@ describe RepeatedConditional do
     before :each do
       @cond = '@field == :sym'
       @cond_expr = @cond.to_reek_source.syntax_tree
-      src = <<EOS
-class Scrunch
-  def first
-    puts "hello" if @debug
-    return #{@cond} ? 0 : 3;
-  end
-  def second
-    if #{@cond}
-      @other += " quarts"
-    end
-  end
-  def third
-    raise 'flu!' unless #{@cond}
-  end
-end
-EOS
+      src = <<-EOS
+        class Scrunch
+          def first
+            puts "hello" if @debug
+            return #{@cond} ? 0 : 3;
+          end
+          def second
+            if #{@cond}
+              @other += " quarts"
+            end
+          end
+          def third
+            raise 'flu!' unless #{@cond}
+          end
+        end
+      EOS
 
       ast = src.to_reek_source.syntax_tree
-      @ctx = CodeContext.new(nil, ast)
+      @ctx = Reek::Core::CodeContext.new(nil, ast)
       @conds = @detector.conditional_counts(@ctx)
     end
 
@@ -81,34 +78,35 @@ EOS
     before :each do
       cond = '@field == :sym'
       @cond_expr = cond.to_reek_source.syntax_tree
-      src = <<EOS
-class Scrunch
-  def alpha
-    return #{cond} ? 0 : 2;
-  end
-  def beta
-    case #{cond}
-    when :symbol
-      @tother += " pints"
-    end
-  end
-end
-EOS
+      src = <<-EOS
+        class Scrunch
+          def alpha
+            return #{cond} ? 0 : 2;
+          end
+          def beta
+            case #{cond}
+            when :symbol
+              @tother += " pints"
+            end
+          end
+        end
+      EOS
 
       ast = src.to_reek_source.syntax_tree
-      ctx = CodeContext.new(nil, ast)
+      ctx = Reek::Core::CodeContext.new(nil, ast)
       @conds = @detector.conditional_counts(ctx)
     end
+
     it 'finds exactly one conditional' do
       expect(@conds.length).to eq(1)
     end
+
     it 'returns the condition expr' do
       expect(@conds.keys[0]).to eq(@cond_expr)
     end
+
     it 'knows there are two copies' do
       expect(@conds.values[0].length).to eq(2)
     end
   end
-
-  # And count code in superclasses, if we have it
 end

data/spec/reek/smells/too_many_instance_variables_spec.rb

@@ -1,16 +1,11 @@
 require 'spec_helper'
 require 'reek/smells/too_many_instance_variables'
-require 'reek/examiner'
-require 'reek/core/code_parser'
 require 'reek/smells/smell_detector_shared'
 
-include Reek
-include Reek::Smells
-
-describe TooManyInstanceVariables do
+describe Reek::Smells::TooManyInstanceVariables do
   before(:each) do
-    @source_name = 'elephant'
-    @detector = TooManyInstanceVariables.new(@source_name)
+    @source_name = 'dummy_source'
+    @detector = build(:smell_detector, smell_type: :TooManyInstanceVariables, source: @source_name)
   end
 
   it_should_behave_like 'SmellDetector'
@@ -77,11 +72,11 @@ describe TooManyInstanceVariables do
         end
       end
     EOS
-    ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+    ctx = Reek::Core::CodeContext.new(nil, src.to_reek_source.syntax_tree)
     @warning = @detector.examine_context(ctx)[0]
     expect(@warning.source).to eq(@source_name)
-    expect(@warning.smell_category).to eq(TooManyInstanceVariables.smell_category)
-    expect(@warning.smell_type).to eq(TooManyInstanceVariables.smell_type)
+    expect(@warning.smell_category).to eq(Reek::Smells::TooManyInstanceVariables.smell_category)
+    expect(@warning.smell_type).to eq(Reek::Smells::TooManyInstanceVariables.smell_type)
     expect(@warning.parameters[:count]).to eq(10)
     expect(@warning.lines).to eq([2])
   end

data/spec/reek/smells/too_many_methods_spec.rb

@@ -1,95 +1,78 @@
 require 'spec_helper'
 require 'reek/smells/too_many_methods'
-require 'reek/examiner'
-require 'reek/core/code_parser'
 require 'reek/smells/smell_detector_shared'
 
-include Reek
-include Reek::Smells
-
-describe TooManyMethods do
+describe Reek::Smells::TooManyMethods do
   before(:each) do
-    @source_name = 'elephant'
-    @detector = TooManyMethods.new(@source_name)
+    @source_name = 'dummy_source'
+    @detector = described_class.new(@source_name)
+    @detector.configure_with 'max_methods' => 2
   end
 
   it_should_behave_like 'SmellDetector'
 
   context 'counting methods' do
-    it 'should not report 25 methods' do
-      src = <<EOS
-# smelly class for testing purposes
-class Full
-  def me01x()3 end;def me02x()3 end;def me03x()3 end;def me04x()3 end;def me05x()3 end
-  def me11x()3 end;def me12x()3 end;def me13x()3 end;def me14x()3 end;def me15x()3 end
-  def me21x()3 end;def me22x()3 end;def me23x()3 end;def me24x()3 end;def me25x()3 end
-  def me31x()3 end;def me32x()3 end;def me33x()3 end;def me34x()3 end;def me35x()3 end
-  def me41x()3 end;def me42x()3 end;def me43x()3 end;def me44x()3 end;def me45x()3 end
-end
-EOS
+    it 'should not report if we stay below max_methods' do
+      src = <<-EOS
+        class Dummy
+          def m1; end
+          def m2; end
+        end
+      EOS
       ctx = ModuleContext.new(nil, src.to_reek_source.syntax_tree)
       expect(@detector.examine_context(ctx)).to be_empty
     end
 
-    it 'should report 26 methods' do
-      src = <<EOS
-class Full
-  def me01x()3 end;def me02x()3 end;def me03x()3 end;def me04x()3 end;def me05x()3 end
-  def me11x()3 end;def me12x()3 end;def me13x()3 end;def me14x()3 end;def me15x()3 end
-  def me21x()3 end;def me22x()3 end;def me23x()3 end;def me24x()3 end;def me25x()3 end
-  def me31x()3 end;def me32x()3 end;def me33x()3 end;def me34x()3 end;def me35x()3 end
-  def me41x()3 end;def me42x()3 end;def me43x()3 end;def me44x()3 end;def me45x()3 end
-  def me51x()3 end
-end
-EOS
+    it 'should report if we exceed max_methods' do
+      src = <<-EOS
+        class Dummy
+          def m1; end
+          def m2; end
+          def m3; end
+        end
+      EOS
       ctx = ModuleContext.new(nil, src.to_reek_source.syntax_tree)
       smells = @detector.examine_context(ctx)
       expect(smells.length).to eq(1)
-      expect(smells[0].smell_type).to eq(TooManyMethods.smell_type)
-      expect(smells[0].parameters[:count]).to eq(26)
+      expect(smells[0].smell_type).to eq(described_class.smell_type)
+      expect(smells[0].parameters[:count]).to eq(3)
     end
   end
 
   context 'with a nested module' do
     it 'stops at a nested module' do
-      src = <<EOS
-class Full
-  def me01x()3 end;def me02x()3 end;def me03x()3 end;def me04x()3 end;def me05x()3 end
-  def me11x()3 end;def me12x()3 end;def me13x()3 end;def me14x()3 end;def me15x()3 end
-  def me21x()3 end;def me22x()3 end;def me23x()3 end;def me24x()3 end;def me25x()3 end
-  def me31x()3 end;def me32x()3 end;def me33x()3 end;def me34x()3 end;def me35x()3 end
-  module Hidden
-    def me41x()3 end
-    def me42x()3 end
-    def me43x()3 end
-    def me44x()3 end
-    def me45x()3 end
-  end
-  def me51x()3 end
-end
-EOS
+      src = <<-EOS
+        class Dummy
+          def m1; end
+          def m2; end
+          module Hidden
+            def m3; end
+            def m4; end
+            def m5; end
+            def m6; end
+          end
+        end
+      EOS
       ctx = ModuleContext.new(nil, src.to_reek_source.syntax_tree)
       expect(@detector.examine_context(ctx)).to be_empty
     end
   end
 
   it 'reports correctly when the class has many methods' do
-    src = <<EOS
-class Full
-  def me01x()3 end;def me02x()3 end;def me03x()3 end;def me04x()3 end;def me05x()3 end
-  def me11x()3 end;def me12x()3 end;def me13x()3 end;def me14x()3 end;def me15x()3 end
-  def me21x()3 end;def me22x()3 end;def me23x()3 end;def me24x()3 end;def me25x()3 end
-  def me31x()3 end;def me32x()3 end;def me33x()3 end;def me34x()3 end;def me35x()3 end
-  def me41x()3 end;def me42x()3 end;def me43x()3 end;def me44x()3 end;def me45x()3 end
-  def me51x()3 end
-end
-EOS
+    src = <<-EOS
+      class Dummy
+        def m1; end
+        def m2; end
+        def m3; end
+      end
+    EOS
+
     ctx = ModuleContext.new(nil, src.to_reek_source.syntax_tree)
     @warning = @detector.examine_context(ctx)[0]
     expect(@warning.source).to eq(@source_name)
-    expect(@warning.smell_category).to eq(TooManyMethods.smell_category)
-    expect(@warning.smell_type).to eq(TooManyMethods.smell_type)
-    expect(@warning.parameters[:count]).to eq(26)
+    expect(@warning.smell_category).to eq(described_class.smell_category)
+    expect(@warning.smell_type).to eq(described_class.smell_type)
+    expect(@warning.parameters[:count]).to eq(3)
     expect(@warning.lines).to eq([1])
   end
 end

data/spec/reek/smells/too_many_statements_spec.rb

@@ -1,28 +1,23 @@
 require 'spec_helper'
 require 'reek/smells/too_many_statements'
-require 'reek/core/code_parser'
-require 'reek/core/sniffer'
 require 'reek/smells/smell_detector_shared'
 
-include Reek
-include Reek::Smells
-
 def process_method(src)
   source = src.to_reek_source
-  sniffer = Core::Sniffer.new(source)
-  Core::CodeParser.new(sniffer).process_def(source.syntax_tree)
+  sniffer = Reek::Core::Sniffer.new(source)
+  Reek::Core::TreeWalker.new(sniffer).process_def(source.syntax_tree)
 end
 
 def process_singleton_method(src)
   source = src.to_reek_source
-  sniffer = Core::Sniffer.new(source)
-  Core::CodeParser.new(sniffer).process_defs(source.syntax_tree)
+  sniffer = Reek::Core::Sniffer.new(source)
+  Reek::Core::TreeWalker.new(sniffer).process_defs(source.syntax_tree)
 end
 
-describe TooManyStatements do
+describe Reek::Smells::TooManyStatements do
   it 'should not report short methods' do
     src = 'def short(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;end'
-    expect(src).not_to reek_of(TooManyStatements)
+    expect(src).not_to reek_of(:TooManyStatements)
   end
 
   it 'should report long methods' do
@@ -31,34 +26,12 @@ describe TooManyStatements do
   end
 
   it 'should not report initialize' do
-    src = '
+    src = <<-EOS
       def initialize(arga)
         alf = f(1); @bet = 2; @cut = 3; @dit = 4; @emp = 5; @fry = 6
       end
-    '
-    expect(src).not_to reek_of(TooManyStatements)
-  end
-
-  it 'should only report a long method once' do
-    src = <<-EOS
-      def standard_entries(rbconfig)
-        @abc = rbconfig
-        rubypath = File.join(@abc['bindir'], @abcf['ruby_install_name'] + cff['EXEEXT'])
-        major = yyy['MAJOR'].to_i
-        minor = zzz['MINOR'].to_i
-        teeny = ccc['TEENY'].to_i
-        version = ""
-        if c['rubylibdir']
-          @libruby         = "/lib/ruby"
-          @librubyver      = "/lib/ruby/"
-          @librubyverarch  = "/lib/ruby/"
-          @siteruby        = "lib/ruby/version/site_ruby"
-          @siterubyver     = siteruby
-          @siterubyverarch = "$siterubyver/['arch']}"
-        end
-      end
     EOS
-    expect(src).to reek_only_of(:TooManyStatements)
+    expect(src).not_to reek_of(:TooManyStatements)
   end
 
   it 'should report long inner block' do
@@ -79,7 +52,7 @@ describe TooManyStatements do
   end
 end
 
-describe TooManyStatements do
+describe Reek::Smells::TooManyStatements do
   it 'counts 1 assignment' do
     method = process_method('def one() val = 4; end')
     expect(method.num_statements).to eq(1)
@@ -121,7 +94,7 @@ describe TooManyStatements do
   end
 end
 
-describe TooManyStatements, 'does not count control statements' do
+describe Reek::Smells::TooManyStatements, 'does not count control statements' do
   it 'counts 1 statement in a conditional expression' do
     method = process_method('def one() if val == 4; callee(); end; end')
     expect(method.num_statements).to eq(1)
@@ -278,9 +251,9 @@ describe TooManyStatements, 'does not count control statements' do
   end
 end
 
-describe TooManyStatements do
+describe Reek::Smells::TooManyStatements do
   before(:each) do
-    @detector = TooManyStatements.new('silver')
+    @detector = build(:smell_detector, smell_type: :TooManyStatements, source: 'source_name')
   end
 
   it_should_behave_like 'SmellDetector'
@@ -290,7 +263,7 @@ describe TooManyStatements do
       @num_statements = 30
       ctx = double('method_context').as_null_object
       expect(ctx).to receive(:num_statements).and_return(@num_statements)
-      expect(ctx).to receive(:config_for).with(TooManyStatements).and_return({})
+      expect(ctx).to receive(:config_for).with(described_class).and_return({})
       @smells = @detector.examine_context(ctx)
     end
 
@@ -303,7 +276,7 @@ describe TooManyStatements do
     end
 
     it 'reports the correct smell sub class' do
-      expect(@smells[0].smell_type).to eq(TooManyStatements.smell_type)
+      expect(@smells[0].smell_type).to eq(described_class.smell_type)
     end
   end
 end