reek 1.3.8 → 1.4.0

data/spec/reek/cli/report_spec.rb

@@ -1,63 +1,130 @@
 require 'spec_helper'
 require 'reek/examiner'
-require 'reek/cli/report'
+require 'reek/cli/report/report'
+require 'reek/cli/report/formatter'
+require 'reek/cli/report/strategy'
 require 'rainbow'
 require 'stringio'
 
 include Reek
 include Reek::Cli
 
-describe QuietReport, " when empty" do
+def capture_output_stream
+  $stdout = StringIO.new
+  yield
+  $stdout.string
+ensure
+  $stdout = STDOUT
+end
+
+def report_options
+  {
+    warning_formatter: Report::SimpleWarningFormatter,
+    report_formatter: Report::Formatter,
+    strategy: Report::Strategy::Quiet
+  }
+end
+
+describe Report::TextReport, ' when empty' do
   context 'empty source' do
+    let(:examiner) { Examiner.new('') }
+
+    def report(obj)
+      obj.add_examiner examiner
+    end
+
     it 'has an empty quiet_report' do
-      examiner = Examiner.new('')
-      qr = QuietReport.new
-      qr.add_examiner(examiner)
-      qr.gather_results.should == []
+      tr = Report::TextReport.new
+      tr.add_examiner(examiner)
+      expect { tr.show }.to_not output.to_stdout
+    end
+
+    context 'when output format is html' do
+      it 'has the text 0 total warnings' do
+        html_report = report(Report::HtmlReport.new(report_options))
+        html_report.show
+
+        file = File.expand_path('../../../../reek.html', __FILE__)
+        text = File.read(file)
+        File.delete(file)
+
+        expect(text).to include('0 total warnings')
+      end
+    end
+
+    context 'when output format is yaml' do
+      it 'prints empty yaml' do
+        yaml_report = report(Report::YamlReport.new(report_options))
+        output = capture_output_stream { yaml_report.show }
+        expect(output).to match(/^--- \[\]\n.*$/)
+      end
+    end
+
+    context 'when output format is text' do
+      it 'prints nothing' do
+        text_report = report(Report::TextReport.new)
+        expect { text_report.show }.to_not output.to_stdout
+      end
     end
   end
 
   context 'with a couple of smells' do
     before :each do
       @examiner = Examiner.new('def simple(a) a[3] end')
-      @rpt = QuietReport.new(SimpleWarningFormatter, ReportFormatter, false, :text)
+      @rpt = Report::TextReport.new report_options
     end
 
     context 'with colors disabled' do
       before :each do
         Rainbow.enabled = false
-        @result = @rpt.add_examiner(@examiner).gather_results.first
+        @result = @rpt.add_examiner(@examiner).smells.first
       end
 
       it 'has a header' do
-        @result.should match('string -- 2 warnings')
+        expect(@result).to match('string -- 2 warnings')
       end
 
       it 'should mention every smell name' do
-        @result.should match('[UncommunicativeParameterName]')
-        @result.should match('[Feature Envy]')
+        expect(@result).to include('UncommunicativeParameterName')
+        expect(@result).to include('FeatureEnvy')
       end
     end
 
     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"
+      context 'with non smelly files' do
+        before :each do
+          Rainbow.enabled = true
+          @rpt.add_examiner(Examiner.new('def simple() puts "a" end'))
+          @rpt.add_examiner(Examiner.new('def simple() puts "a" end'))
+          @result = @rpt.smells
+        end
+
+        it 'has a footer in color' do
+          output = capture_output_stream { @rpt.show }
+          expect(output).to end_with "\e[32m0 total warnings\n\e[0m"
+        end
       end
 
-      it 'has a footer in color' do
-        stdout = StringIO.new
-        $stdout = stdout
-        @rpt.show
-        $stdout = STDOUT
+      context 'with smelly files' 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.smells
+        end
+
+        it 'has a header in color' do
+          expect(@result.first).to start_with "\e[36mstring -- \e[0m\e[33m2 warning\e[0m\e[33ms\e[0m"
+        end
 
-        stdout.string.should end_with "\e[31m4 total warnings\n\e[0m"
+        it 'has a footer in color' do
+          output = capture_output_stream { @rpt.show }
+          expect(output).to end_with "\e[31m4 total warnings\n\e[0m"
+        end
       end
     end
   end

data/spec/reek/cli/version_command_spec.rb

@@ -6,24 +6,26 @@ include Reek::Cli
 
 describe VersionCommand do
   before :each do
-    @text = 'Piece of interesting text'
-    @cmd = VersionCommand.new(@text)
+    @program_name = 'the_name_of_the_program'
+    @parser = double('parser')
+    expect(@parser).to receive(:program_name).and_return @program_name
+    @cmd = VersionCommand.new(@parser)
     @view = double('view').as_null_object
-    @view.should_not_receive(:report_smells)
   end
 
   it 'displays the text on the view' do
-    @view.should_receive(:output).with(/#{@text}/)
+    expect(@view).to receive(:output).with(/#{@program_name}/)
     @cmd.execute(@view)
   end
 
   it 'displays the Reek version on the view' do
-    @view.should_receive(:output).with(/#{Reek::VERSION}/)
+    expect(@view).to receive(:output).with(/#{Reek::VERSION}/)
     @cmd.execute(@view)
   end
 
   it 'tells the view it succeeded' do
-    @view.should_receive(:report_success)
+    expect(@view).to receive(:report_success)
+    expect(@view).not_to receive(:report_smells)
     @cmd.execute(@view)
   end
 end

data/spec/reek/core/code_context_spec.rb

@@ -17,19 +17,19 @@ describe CodeContext do
       @ctx = CodeContext.new(nil, @exp)
     end
     it 'gets its short name from the exp' do
-      @ctx.name.should == @exp_name
+      expect(@ctx.name).to eq(@exp_name)
     end
     it 'does not match an empty list' do
-      @ctx.matches?([]).should == false
+      expect(@ctx.matches?([])).to eq(false)
     end
     it 'does not match when its own short name is not given' do
-      @ctx.matches?(['banana']).should == false
+      expect(@ctx.matches?(['banana'])).to eq(false)
     end
     it 'recognises its own short name' do
-      @ctx.matches?(['banana', @exp_name]).should == true
+      expect(@ctx.matches?(['banana', @exp_name])).to eq(true)
     end
     it 'recognises its short name as a regex' do
-      @ctx.matches?([/banana/, /#{@exp_name}/]).should == true
+      expect(@ctx.matches?([/banana/, /#{@exp_name}/])).to eq(true)
     end
 
     context 'when there is an outer' do
@@ -41,13 +41,13 @@ describe CodeContext do
         @ctx = CodeContext.new(outer, @exp)
       end
       it 'creates the correct full name' do
-        @ctx.full_name.should == "#{@full_name}"
+        expect(@ctx.full_name).to eq("#{@full_name}")
       end
       it 'recognises its own full name' do
-        @ctx.matches?(['banana', @full_name]).should == true
+        expect(@ctx.matches?(['banana', @full_name])).to eq(true)
       end
       it 'recognises its full name as a regex' do
-        @ctx.matches?([/banana/, /#{@full_name}/]).should == true
+        expect(@ctx.matches?([/banana/, /#{@full_name}/])).to eq(true)
       end
     end
   end
@@ -58,7 +58,7 @@ describe CodeContext do
       def stop.bananas(arg1, arg2) arg1 + arg2 + 43 end
       element = ModuleContext.new(stop, ast(:module, :mod, nil))
       element = MethodContext.new(element, ast(:defn, :bad))
-      element.bananas(17, -5).should == 55
+      expect(element.bananas(17, -5)).to eq(55)
     end
   end
 
@@ -71,20 +71,20 @@ describe CodeContext do
         @ctx = CodeContext.new(nil, ast)
       end
       it 'yields no calls' do
-        @ctx.each_node(:call, []) {|exp| raise "#{exp} yielded by empty module!"}
+        @ctx.each_node(:call, []) { |exp| raise "#{exp} yielded by empty module!" }
       end
       it 'yields one module' do
         mods = 0
-        @ctx.each_node(:module, []) {|exp| mods += 1}
-        mods.should == 1
+        @ctx.each_node(:module, []) { |_exp| mods += 1 }
+        expect(mods).to eq(1)
       end
       it "yields the module's full AST" do
-        @ctx.each_node(:module, []) {|exp| exp[1].should == @module_name.to_sym}
+        @ctx.each_node(:module, []) { |exp| expect(exp[1]).to eq(@module_name.to_sym) }
       end
 
       context 'with no block' do
         it 'returns an empty array of ifs' do
-          @ctx.each_node(:if, []).should be_empty
+          expect(@ctx.each_node(:if, [])).to be_empty
         end
       end
     end
@@ -98,24 +98,24 @@ describe CodeContext do
         @ctx = CodeContext.new(nil, ast)
       end
       it 'yields no ifs' do
-        @ctx.each_node(:if, []) {|exp| raise "#{exp} yielded by empty module!"}
+        @ctx.each_node(:if, []) { |exp| raise "#{exp} yielded by empty module!" }
       end
       it 'yields one module' do
-        @ctx.each_node(:module, []).length.should == 1
+        expect(@ctx.each_node(:module, []).length).to eq(1)
       end
       it "yields the module's full AST" do
-        @ctx.each_node(:module, []) {|exp| exp[1].should == @module_name.to_sym}
+        @ctx.each_node(:module, []) { |exp| expect(exp[1]).to eq(@module_name.to_sym) }
       end
       it 'yields one method' do
-        @ctx.each_node(:defn, []).length.should == 1
+        expect(@ctx.each_node(:defn, []).length).to eq(1)
       end
       it "yields the method's full AST" do
-        @ctx.each_node(:defn, []) {|exp| exp[1].should == @method_name.to_sym}
+        @ctx.each_node(:defn, []) { |exp| expect(exp[1]).to eq(@method_name.to_sym) }
       end
 
       context 'pruning the traversal' do
         it 'ignores the call inside the method' do
-          @ctx.each_node(:call, [:defn]).should be_empty
+          expect(@ctx.each_node(:call, [:defn])).to be_empty
         end
       end
     end
@@ -139,7 +139,7 @@ EOS
 
       ast = src.to_reek_source.syntax_tree
       ctx = CodeContext.new(nil, ast)
-      ctx.each_node(:if, []).length.should == 3
+      expect(ctx.each_node(:if, []).length).to eq(3)
     end
   end
 
@@ -156,8 +156,7 @@ EOS
     end
 
     it 'gets its configuration from the exp comments' do
-      ctx.config_for(sniffer).should == {
-        'allow_calls' => [ 'puts' ] }
+      expect(ctx.config_for(sniffer)).to eq('allow_calls' => ['puts'])
     end
 
     context 'when there is an outer' do
@@ -165,12 +164,12 @@ EOS
 
       before :each do
         allow(outer).to receive(:config_for).with(sniffer).and_return(
-          { 'max_calls' => 2 })
+          '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 }
+        expect(ctx.config_for(sniffer)).to eq('allow_calls' => ['puts'],
+                                              'max_calls' => 2)
       end
     end
   end

data/spec/reek/core/code_parser_spec.rb

@@ -3,20 +3,20 @@ require 'reek/core/code_parser'
 
 include Reek::Core
 
-describe CodeParser, "with no method definitions" do
+describe CodeParser, 'with no method definitions' do
   it 'reports no problems for empty source code' do
-    ''.should_not reek
+    expect('').not_to reek
   end
   it 'reports no problems for empty class' do
-    '# clean class for testing purposes
-class Fred; end'.should_not reek
+    expect('# clean class for testing purposes
+class Fred; end').not_to reek
   end
 end
 
 describe CodeParser, 'with a global method definition' do
   it 'reports no problems for simple method' do
     src = 'def Outermost::fred() true; end'
-    src.should_not reek
+    expect(src).not_to reek
   end
 end
 
@@ -31,6 +31,6 @@ def values(*args)
   self
 end
 EOS
-    src.should_not reek
+    expect(src).not_to reek
   end
 end

data/spec/reek/core/method_context_spec.rb

@@ -7,41 +7,41 @@ include Reek::Core
 describe MethodContext, 'matching' do
   before :each do
     exp = double('exp').as_null_object
-    exp.should_receive(:full_name).at_least(:once).and_return('mod')
+    expect(exp).to receive(:full_name).at_least(:once).and_return('mod')
     @element = MethodContext.new(StopContext.new, exp)
   end
 
   it 'should recognise itself in a collection of names' do
-    @element.matches?(['banana', 'mod']).should == true
-    @element.matches?(['banana']).should == false
+    expect(@element.matches?(['banana', 'mod'])).to eq(true)
+    expect(@element.matches?(['banana'])).to eq(false)
   end
 
   it 'should recognise itself in a collection of REs' do
-    @element.matches?([/banana/, /mod/]).should == true
-    @element.matches?([/banana/]).should == false
+    expect(@element.matches?([/banana/, /mod/])).to eq(true)
+    expect(@element.matches?([/banana/])).to eq(false)
   end
 end
 
 describe MethodContext do
   it 'should record ivars as refs to self' do
     mctx = MethodContext.new(StopContext.new, ast(:defn, :feed))
-    mctx.envious_receivers.should == []
+    expect(mctx.envious_receivers).to eq([])
     mctx.record_call_to(ast(:call, s(:ivar, :@cow), :feed_to))
-    mctx.envious_receivers.should == []
+    expect(mctx.envious_receivers).to eq([])
   end
 
   it 'should count calls to self' do
     mctx = MethodContext.new(StopContext.new, ast(:defn, :equals))
     mctx.refs.record_reference_to([:lvar, :other])
     mctx.record_call_to(ast(:call, s(:self), :thing))
-    mctx.envious_receivers.should be_empty
+    expect(mctx.envious_receivers).to be_empty
   end
 
   it 'should recognise a call on self' do
     mc = MethodContext.new(StopContext.new, s(:defn, :deep))
     mc.record_call_to(ast(:call, s(:lvar, :text), :each, s(:arglist)))
     mc.record_call_to(ast(:call, nil, :shelve, s(:arglist)))
-    mc.envious_receivers.should be_empty
+    expect(mc.envious_receivers).to be_empty
   end
 end
 
@@ -49,40 +49,40 @@ describe MethodParameters, 'default assignments' do
   def assignments_from(src)
     exp = src.to_reek_source.syntax_tree
     ctx = MethodContext.new(StopContext.new, exp)
-    return ctx.parameters.default_assignments
+    ctx.parameters.default_assignments
   end
 
   context 'with no defaults' do
     it 'returns an empty hash' do
       src = 'def meth(arga, argb, &blk) end'
-      assignments_from(src).should be_empty
+      expect(assignments_from(src)).to be_empty
     end
   end
 
   context 'with 1 default' do
     before :each do
-      src = "def meth(arga, argb=456, &blk) end"
+      src = 'def meth(arga, argb=456, &blk) end'
       @defaults = assignments_from(src)
     end
     it 'returns the param-value pair' do
-      @defaults[0].should == s(:argb, s(:lit, 456))
+      expect(@defaults[0]).to eq(s(:argb, s(:lit, 456)))
     end
     it 'returns the nothing else' do
-      @defaults.length.should == 1
+      expect(@defaults.length).to eq(1)
     end
   end
 
   context 'with 2 defaults' do
     before :each do
-      src = "def meth(arga=123, argb=456, &blk) end"
+      src = 'def meth(arga=123, argb=456, &blk) end'
       @defaults = assignments_from(src)
     end
     it 'returns both param-value pairs' do
-      @defaults[0].should == s(:arga, s(:lit, 123))
-      @defaults[1].should == s(:argb, s(:lit, 456))
+      expect(@defaults[0]).to eq(s(:arga, s(:lit, 123)))
+      expect(@defaults[1]).to eq(s(:argb, s(:lit, 456)))
     end
     it 'returns nothing else' do
-      @defaults.length.should == 2
+      expect(@defaults.length).to eq(2)
     end
   end
 end