reek 1.3.6 → 1.3.7

data/spec/reek/cli/report_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 require 'reek/examiner'
 require 'reek/cli/report'
+require 'rainbow'
+require 'stringio'
 
 include Reek
 include Reek::Cli
@@ -17,18 +19,46 @@ describe QuietReport, " when empty" do
 
   context 'with a couple of smells' do
     before :each do
-      examiner = Examiner.new('def simple(a) a[3] end')
-      rpt = QuietReport.new
-      @result = rpt.add_examiner(examiner).gather_results.first
+      @examiner = Examiner.new('def simple(a) a[3] end')
+      @rpt = QuietReport.new(SimpleWarningFormatter, ReportFormatter, false, :text)
     end
 
-    it 'has a header' do
-      @result.should match('string -- 2 warnings')
+    context 'with colors disabled' do
+      before :each do
+        Rainbow.enabled = false
+        @result = @rpt.add_examiner(@examiner).gather_results.first
+      end
+
+      it 'has a header' do
+        @result.should match('string -- 2 warnings')
+      end
+
+      it 'should mention every smell name' do
+        @result.should match('[UncommunicativeParameterName]')
+        @result.should match('[Feature Envy]')
+      end
     end
 
-    it 'should mention every smell name' do
-      @result.should match('[UncommunicativeParameterName]')
-      @result.should match('[Feature Envy]')
+    context 'with colors enabled' do
+      before :each do
+        Rainbow.enabled = true
+        @rpt.add_examiner(Examiner.new('def simple(a) a[3] end'))
+        @rpt.add_examiner(Examiner.new('def simple(a) a[3] end'))
+        @result = @rpt.gather_results
+      end
+
+      it 'has a header in color' do
+        @result.first.should start_with "\e[36mstring -- \e[0m\e[33m2 warning\e[0m\e[33ms\e[0m"
+      end
+
+      it 'has a footer in color' do
+        stdout = StringIO.new
+        $stdout = stdout
+        @rpt.show
+        $stdout = STDOUT
+
+        stdout.string.should end_with "\e[31m4 total warnings\n\e[0m"
+      end
     end
   end
 end

data/spec/reek/core/code_context_spec.rb

@@ -36,8 +36,8 @@ describe CodeContext do
       before :each do
         @outer_name = 'another_random sting'
         outer = double('outer')
-        outer.should_receive(:full_name).at_least(:once).and_return(@outer_name)
-        outer.should_receive(:config).and_return({})
+        allow(outer).to receive(:full_name).at_least(:once).and_return(@outer_name)
+        allow(outer).to receive(:config).and_return({})
         @ctx = CodeContext.new(outer, @exp)
       end
       it 'creates the correct full name' do
@@ -56,7 +56,7 @@ describe CodeContext do
     it 'should pass unknown method calls down the stack' do
       stop = StopContext.new
       def stop.bananas(arg1, arg2) arg1 + arg2 + 43 end
-      element = ModuleContext.new(stop, 'mod', ast(:module, :mod, nil))
+      element = ModuleContext.new(stop, ast(:module, :mod, nil))
       element = MethodContext.new(element, ast(:defn, :bad))
       element.bananas(17, -5).should == 55
     end
@@ -142,4 +142,36 @@ EOS
       ctx.each_node(:if, []).length.should == 3
     end
   end
+
+  describe '#config_for' do
+    let(:exp) { double('exp') }
+    let(:outer) { nil }
+    let(:ctx) { CodeContext.new(outer, exp) }
+    let(:sniffer) { double('sniffer') }
+
+    before :each do
+      allow(sniffer).to receive(:smell_class_name).and_return('DuplicateMethodCall')
+      allow(exp).to receive(:comments).and_return(
+        ':reek:DuplicateMethodCall: { allow_calls: [ puts ] }')
+    end
+
+    it 'gets its configuration from the exp comments' do
+      ctx.config_for(sniffer).should == {
+        'allow_calls' => [ 'puts' ] }
+    end
+
+    context 'when there is an outer' do
+      let(:outer) { double('outer') }
+
+      before :each do
+        allow(outer).to receive(:config_for).with(sniffer).and_return(
+          { 'max_calls' => 2 })
+      end
+
+      it 'merges the outer config with its own configuration' do
+        ctx.config_for(sniffer).should == { 'allow_calls' => [ 'puts' ],
+                                            'max_calls' => 2 }
+      end
+    end
+  end
 end

data/spec/reek/core/module_context_spec.rb

@@ -6,7 +6,7 @@ include Reek::Core
 
 describe ModuleContext do
   it 'should report module name for smell in method' do
-    'module Fred; def simple(x) true; end; end'.should reek_of(:UncommunicativeParameterName, /x/, /simple/)
+    'module Fred; def simple(x) x + 1; end; end'.should reek_of(:UncommunicativeParameterName, /x/, /simple/)
   end
 
   it 'should not report module with empty class' do

data/spec/reek/smells/repeated_conditional_spec.rb

@@ -86,7 +86,7 @@ EOS
         @yaml.should match(/subclass:\s*RepeatedConditional/)
       end
       it 'reports the expression' do
-        @yaml.should match(/expression:\s*\(#{@cond}\)/)
+        @yaml.should match(/expression:\s*"?\(#{@cond}\)"?/)
       end
       it 'reports the number of occurrences' do
         @yaml.should match(/occurrences:\s*3/)

data/spec/reek/smells/smell_detector_shared.rb

@@ -7,8 +7,7 @@ shared_examples_for 'SmellDetector' do
   context 'exception matching follows the context' do
     before :each do
       @ctx = double('context')
-#      @ctx.should_receive(:exp).and_return(nil)
-      @ctx.should_receive(:config).and_return({})
+      allow(@ctx).to receive(:config_for).and_return({})
     end
     it 'when false' do
       @ctx.should_receive(:matches?).at_least(:once).and_return(false)

data/spec/reek/smells/too_many_statements_spec.rb

@@ -110,6 +110,11 @@ describe TooManyStatements do
     method = process_method('def one() val = 4; true; end')
     method.num_statements.should == 2
   end
+
+  it 'counts nil returns' do
+    method = process_method('def one() val = 4; nil; end')
+    method.num_statements.should == 2
+  end
 end
 
 describe TooManyStatements, 'does not count control statements' do
@@ -123,11 +128,26 @@ describe TooManyStatements, 'does not count control statements' do
     method.num_statements.should == 3
   end
 
+  it 'counts 1 statements in an else' do
+    method = process_method('def one() if val == 4; callee(); else; callee(); end; end')
+    method.num_statements.should == 2
+  end
+
+  it 'counts 3 statements in an else' do
+    method = process_method('def one() if val == 4; callee(); callee(); callee(); else; callee(); callee(); callee(); end; end')
+    method.num_statements.should == 6
+  end
+
   it 'does not count empty conditional expression' do
     method = process_method('def one() if val == 4; ; end; end')
     method.num_statements.should == 0
   end
 
+  it 'does not count empty else' do
+    method = process_method('def one() if val == 4; ; else; ; end; end')
+    method.num_statements.should == 0
+  end
+
   it 'counts 1 statement in a while loop' do
     method = process_method('def one() while val < 4; callee(); end; end')
     method.num_statements.should == 1
@@ -178,18 +198,32 @@ describe TooManyStatements, 'does not count control statements' do
     method.num_statements.should == 3
   end
 
+  it 'counts 1 statement in a case else' do
+    method = process_method('def one() case fred; when "hi"; callee(); else; callee(); end; end')
+    method.num_statements.should == 2
+  end
+
+  it 'counts 3 statements in a case else' do
+    method = process_method('def one() case fred; when "hi"; callee(); callee(); callee(); else; callee(); callee(); callee(); end; end')
+    method.num_statements.should == 6
+  end
+
   it 'does not count empty case' do
     method = process_method('def one() case fred; when "hi"; ; when "lo"; ; end; end')
     method.num_statements.should == 0
   end
 
-  it 'counts 1 statement in a block' do
+  it 'does not count empty case else' do
+    method = process_method('def one() case fred; when "hi"; ; else; ; end; end')
+    method.num_statements.should == 0
+  end
+
+  it 'counts 2 statement in an iterator' do
     method = process_method('def one() fred.each do; callee(); end; end')
-    method.num_statements.should == 1
+    method.num_statements.should == 2
   end
 
-  # FIXME: I think this is wrong, but it specs current behavior.
-  it 'counts 4 statements in a block' do
+  it 'counts 4 statements in an iterator' do
     method = process_method('def one() fred.each do; callee(); callee(); callee(); end; end')
     method.num_statements.should == 4
   end
@@ -198,26 +232,6 @@ describe TooManyStatements, 'does not count control statements' do
     method = process_singleton_method('def self.foo; callee(); end')
     method.num_statements.should == 1
   end
-
-  it 'counts else statement' do
-    src = <<EOS
-def parse(arg, argv, &error)
-  if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
-    return nil, block, nil
-  end
-  opt = (val = parse_arg(val, &error))[1]
-  val = conv_arg(*val)
-  if opt and !arg
-    argv.shift
-  else
-    val[0] = nil
-  end
-  val
-end
-EOS
-    method = process_method(src)
-    method.num_statements.should == 6
-  end
 end
 
 describe TooManyStatements do
@@ -232,7 +246,7 @@ describe TooManyStatements do
       @num_statements = 30
       ctx = double('method_context').as_null_object
       ctx.should_receive(:num_statements).and_return(@num_statements)
-      ctx.should_receive(:config).and_return({})
+      ctx.should_receive(:config_for).with(TooManyStatements).and_return({})
       @smells = @detector.examine_context(ctx)
     end
     it 'reports only 1 smell' do

data/spec/reek/smells/uncommunicative_parameter_name_spec.rb

@@ -14,49 +14,63 @@ describe UncommunicativeParameterName do
 
   it_should_behave_like 'SmellDetector'
 
-  context "parameter name" do
-    ['obj.', ''].each do |host|
+  { 'obj.' => 'with a receiveer',
+    '' => 'without a receiver'}.each do |host, description|
+    context "in a method definition #{description}" do
       it 'does not recognise *' do
-        "def #{host}help(xray, *) basics(17) end".should_not smell_of(UncommunicativeParameterName)
+        "def #{host}help(xray, *) basics(17) end".
+          should_not smell_of(UncommunicativeParameterName)
       end
+
       it "reports parameter's name" do
+        src = "def #{host}help(x) basics(x) end"
+        src.should smell_of(UncommunicativeParameterName,
+                            {UncommunicativeParameterName::PARAMETER_NAME_KEY => 'x'})
+      end
+
+      it "does not report unused parameters" do
         src = "def #{host}help(x) basics(17) end"
-        src.should smell_of(UncommunicativeParameterName, {UncommunicativeParameterName::PARAMETER_NAME_KEY => 'x'})
+        src.should_not smell_of(UncommunicativeParameterName)
       end
 
-      context 'with a name of the form "x2"' do
-        before :each do
-          @bad_param = 'x2'
-          src = "def #{host}help(#{@bad_param}) basics(17) end"
-          ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
-          @smells = @detector.examine_context(ctx)
-        end
-        it 'reports only 1 smell' do
-          @smells.length.should == 1
-        end
-        it 'reports uncommunicative parameter name' do
-          @smells[0].subclass.should == UncommunicativeParameterName::SMELL_SUBCLASS
-        end
-        it 'reports the parameter name' do
-          @smells[0].smell[UncommunicativeParameterName::PARAMETER_NAME_KEY].should == @bad_param
-        end
+      it 'does not report two-letter parameter names' do
+        "def #{host}help(ab) basics(ab) end".
+          should_not smell_of(UncommunicativeParameterName)
       end
+
+      it 'reports names of the form "x2"' do
+        src = "def #{host}help(x2) basics(x2) end"
+        src.should smell_of(UncommunicativeParameterName,
+                            {UncommunicativeParameterName::PARAMETER_NAME_KEY => 'x2'})
+      end
+
       it 'reports long name ending in a number' do
-        @bad_param = 'param2'
-        src = "def #{host}help(#{@bad_param}) basics(17) end"
-        ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
-        smells = @detector.examine_context(ctx)
-        smells.length.should == 1
-        smells[0].subclass.should == UncommunicativeParameterName::SMELL_SUBCLASS
-        smells[0].smell[UncommunicativeParameterName::PARAMETER_NAME_KEY].should == @bad_param
+        src = "def #{host}help(param2) basics(param2) end"
+        src.should smell_of(UncommunicativeParameterName,
+                            {UncommunicativeParameterName::PARAMETER_NAME_KEY => 'param2'})
+      end
+
+      it 'does not report unused anonymous parameter' do
+        "def #{host}help(_) basics(17) end".
+          should_not smell_of(UncommunicativeParameterName)
+      end
+
+      it 'reports used anonymous parameter' do
+        "def #{host}help(_) basics(_) end".
+          should smell_of(UncommunicativeParameterName)
+      end
+
+      it 'reports used parameters marked as unused' do
+        "def #{host}help(_unused) basics(_unused) end".
+          should smell_of(UncommunicativeParameterName)
       end
     end
   end
 
-  context 'looking at the YAML' do
+  context 'looking at the smell result fields' do
     before :each do
-      src = 'def bad(good, bad2, good_again) end'
-      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      src = 'def bad(good, bad2, good_again); basics(good, bad2, good_again); end'
+      ctx = MethodContext.new(nil, src.to_reek_source.syntax_tree)
       @smells = @detector.examine_context(ctx)
       @warning = @smells[0]
     end

data/spec/reek/smells/unused_parameters_spec.rb

@@ -9,54 +9,58 @@ describe UnusedParameters do
 
   context 'for methods' do
 
-    it 'should report nothing for no parameters' do
+    it 'reports nothing for no parameters' do
       'def simple; true end'.should_not smell_of(UnusedParameters)
     end
 
-    it 'should report nothing for used parameter' do
+    it 'reports nothing for used parameter' do
       'def simple(sum); sum end'.should_not smell_of(UnusedParameters)
     end
 
-    it 'should report for 1 used and 2 unused parameter' do
+    it 'reports for 1 used and 2 unused parameter' do
       src = 'def simple(num,sum,denum); sum end'
       src.should smell_of(UnusedParameters,
                           {UnusedParameters::PARAMETER_KEY => 'num'},
                           {UnusedParameters::PARAMETER_KEY => 'denum'})
     end
 
-    it 'should report for 3 used and 1 unused parameter' do
+    it 'reports for 3 used and 1 unused parameter' do
       src = 'def simple(num,sum,denum,quotient); num + denum + sum end'
       src.should smell_of(UnusedParameters,
                           {UnusedParameters::PARAMETER_KEY => 'quotient'})
     end
 
-    it 'should report nothing for used splatted parameter' do
+    it 'reports nothing for used splatted parameter' do
       'def simple(*sum); sum end'.should_not smell_of(UnusedParameters)
     end
 
-    it 'should report nothing for unused anonymous parameter' do
+    it 'reports nothing for unused anonymous parameter' do
       'def simple(_); end'.should_not smell_of(UnusedParameters)
     end
 
-    it 'should report nothing for named parameters prefixed with _' do
+    it 'reports nothing for named parameters prefixed with _' do
       'def simple(_name); end'.should_not smell_of(UnusedParameters)
     end
 
-    it 'should report nothing for unused anonymous splatted parameter' do
+    it 'reports nothing for unused anonymous splatted parameter' do
       'def simple(*); end'.should_not smell_of(UnusedParameters)
     end
 
-    it 'should report nothing when using super with implicit arguments' do
+    it 'reports nothing when using super with implicit arguments' do
       'def simple(*args); super; end'.should_not smell_of(UnusedParameters)
     end
 
-    it 'should report something when using super explicitely passing no arguments' do
+    it 'reports something when using super explicitely passing no arguments' do
       'def simple(*args); super(); end'.should smell_of(UnusedParameters)
     end
 
-    it 'should report nothing when using super explicitely passing all arguments' do
+    it 'reports nothing when using super explicitely passing all arguments' do
       'def simple(*args); super(*args); end'.should_not smell_of(UnusedParameters)
     end
 
+    it 'reports nothing when using super in a nested context' do
+      'def simple(*args); call_other("something", super); end'.
+        should_not smell_of(UnusedParameters)
+    end
   end
 end

data/spec/reek/source/sexp_extensions_spec.rb

@@ -92,7 +92,7 @@ describe SexpExtensions::DefnNode do
 
     it 'has a body extended with SexpNode' do
       b = @node.body
-      (class << b; self; end).ancestors.first.should == SexpNode
+      (class << b; self; end).included_modules.first.should == SexpNode
     end
   end
 end
@@ -186,7 +186,7 @@ describe SexpExtensions::DefsNode do
 
     it 'has a body extended with SexpNode' do
       b = @node.body
-      (class << b; self; end).ancestors.first.should == SexpNode
+      (class << b; self; end).included_modules.first.should == SexpNode
     end
   end
 end

data/spec/reek/source/sexp_node_spec.rb

@@ -25,4 +25,3 @@ describe SexpNode do
     end
   end
 end
-