rubocop 0.18.1 → 0.19.0

data/spec/rubocop/formatter/disabled_config_formatter_spec.rb

@@ -15,25 +15,25 @@ module Rubocop
         end
         o
       end
-      let(:offences) do
-        [Rubocop::Cop::Offence.new(:convention, location, 'message', 'Cop1'),
-         Rubocop::Cop::Offence.new(:convention, location, 'message', 'Cop2')]
+      let(:offenses) do
+        [Rubocop::Cop::Offense.new(:convention, location, 'message', 'Cop1'),
+         Rubocop::Cop::Offense.new(:convention, location, 'message', 'Cop2')]
       end
       let(:location) { OpenStruct.new(line: 1, column: 5) }
       before { $stdout = StringIO.new }
 
       describe '#finished' do
-        it 'displays YAML configuration disabling all cops with offences' do
-          formatter.file_finished('test.rb', offences)
+        it 'displays YAML configuration disabling all cops with offenses' do
+          formatter.file_finished('test.rb', offenses)
           formatter.finished(['test.rb'])
           expect(output.string).to eq(described_class::HEADING +
                                       ['',
                                        '',
-                                       '# Offence count: 1',
+                                       '# Offense count: 1',
                                        'Cop1:',
                                        '  Enabled: false',
                                        '',
-                                       '# Offence count: 1',
+                                       '# Offense count: 1',
                                        'Cop2:',
                                        '  Enabled: false',
                                        ''].join("\n"))

data/spec/rubocop/formatter/emacs_style_formatter_spec.rb

@@ -15,23 +15,23 @@ module Rubocop
           source_buffer = Parser::Source::Buffer.new('test', 1)
           source_buffer.source = %w(a b cdefghi).join("\n")
 
-          cop.add_offence(nil,
+          cop.add_offense(nil,
                           Parser::Source::Range.new(source_buffer, 0, 1),
                           'message 1')
-          cop.add_offence(nil,
+          cop.add_offense(nil,
                           Parser::Source::Range.new(source_buffer, 9, 10),
                           'message 2')
 
-          formatter.file_finished('test', cop.offences)
+          formatter.file_finished('test', cop.offenses)
           expect(output.string).to eq ['test:1:1: C: message 1',
                                        "test:3:6: C: message 2\n"].join("\n")
         end
 
-        context 'when the offence is automatically corrected' do
+        context 'when the offense is automatically corrected' do
           let(:file) { '/path/to/file' }
 
-          let(:offence) do
-            Cop::Offence.new(:convention, location,
+          let(:offense) do
+            Cop::Offense.new(:convention, location,
                              'This is a message.', 'CopName', corrected)
           end
 
@@ -44,7 +44,7 @@ module Rubocop
           let(:corrected) { true }
 
           it 'prints [Corrected] along with message' do
-            formatter.file_finished(file, [offence])
+            formatter.file_finished(file, [offense])
             expect(output.string)
               .to include(': [Corrected] This is a message.')
           end

data/spec/rubocop/formatter/file_list_formatter_spec.rb

@@ -15,15 +15,15 @@ module Rubocop
           source_buffer = Parser::Source::Buffer.new('test', 1)
           source_buffer.source = %w(a b cdefghi).join("\n")
 
-          cop.add_offence(nil,
+          cop.add_offense(nil,
                           Parser::Source::Range.new(source_buffer, 0, 1),
                           'message 1')
-          cop.add_offence(nil,
+          cop.add_offense(nil,
                           Parser::Source::Range.new(source_buffer, 9, 10),
                           'message 2')
 
-          formatter.file_finished('test', cop.offences)
-          formatter.file_finished('test_2', cop.offences)
+          formatter.file_finished('test', cop.offenses)
+          formatter.file_finished('test_2', cop.offenses)
           expect(output.string).to eq ['test',
                                        "test_2\n"].join("\n")
         end

data/spec/rubocop/formatter/fuubar_style_formatter_spec.rb

@@ -0,0 +1,129 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+
+module Rubocop
+  describe Formatter::FuubarStyleFormatter do
+    subject(:formatter) { described_class.new(output) }
+    let(:output) { StringIO.new }
+
+    let(:files) do
+      %w(lib/rubocop.rb spec/spec_helper.rb).map do |path|
+        File.expand_path(path)
+      end
+    end
+
+    describe '#with_color' do
+      around do |example|
+        original_state = formatter.rainbow.enabled
+
+        begin
+          example.run
+        ensure
+          formatter.rainbow.enabled = original_state
+        end
+      end
+
+      context 'when color is enabled' do
+        before do
+          formatter.rainbow.enabled = true
+        end
+
+        it 'outputs coloring sequence code at the beginning and the end' do
+          formatter.with_color { formatter.output.write 'foo' }
+          expect(output.string).to eq("\e[32mfoo\e[0m")
+        end
+      end
+
+      context 'when color is enabled' do
+        before do
+          formatter.rainbow.enabled = false
+        end
+
+        it 'outputs nothing' do
+          formatter.with_color { formatter.output.write 'foo' }
+          expect(output.string).to eq('foo')
+        end
+      end
+    end
+
+    describe '#progressbar_color' do
+      before do
+        formatter.started(files)
+      end
+
+      def offense(severity, corrected = false)
+        source_range = double('source_range').as_null_object
+        Cop::Offense.new(severity, source_range, 'message', 'Cop', corrected)
+      end
+
+      context 'initially' do
+        it 'is green' do
+          expect(formatter.progressbar_color).to eq(:green)
+        end
+      end
+
+      context 'when no offenses are detected in a file' do
+        before do
+          formatter.file_finished(files[0], [])
+        end
+
+        it 'is still green' do
+          expect(formatter.progressbar_color).to eq(:green)
+        end
+      end
+
+      context 'when a convention offense is detected in a file' do
+        before do
+          formatter.file_finished(files[0], [offense(:convention)])
+        end
+
+        it 'is yellow' do
+          expect(formatter.progressbar_color).to eq(:yellow)
+        end
+      end
+
+      context 'when an error offense is detected in a file' do
+        before do
+          formatter.file_finished(files[0], [offense(:error)])
+        end
+
+        it 'is red' do
+          expect(formatter.progressbar_color).to eq(:red)
+        end
+
+        context 'and then a convention offense is detected in the next file' do
+          before do
+            formatter.file_finished(files[1], [offense(:convention)])
+          end
+
+          it 'is still red' do
+            expect(formatter.progressbar_color).to eq(:red)
+          end
+        end
+      end
+
+      context 'when convention and error offenses are detected in a file' do
+        before do
+          offenses = [offense(:convention), offense(:error)]
+          formatter.file_finished(files[0], offenses)
+        end
+
+        it 'is red' do
+          expect(formatter.progressbar_color).to eq(:red)
+        end
+      end
+
+      context 'when a offense is detected in a file and auto-corrected' do
+        before do
+          formatter.file_finished(files[0], [offense(:convention, true)])
+        end
+
+        it 'is green' do
+          expect(formatter.progressbar_color).to eq(:green)
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/formatter/json_formatter_spec.rb

@@ -13,8 +13,8 @@ module Rubocop
       source_buffer.source = %w(a b cdefghi).join("\n")
       Parser::Source::Range.new(source_buffer, 9, 10)
     end
-    let(:offence) do
-      Cop::Offence.new(:convention, location,
+    let(:offense) do
+      Cop::Offense.new(:convention, location,
                        'This is message', 'CopName', true)
     end
 
@@ -38,15 +38,15 @@ module Rubocop
 
       let(:summary) { formatter.output_hash[:summary] }
 
-      it 'adds detected offence count in summary' do
-        expect(summary[:offence_count]).to eq(0)
+      it 'adds detected offense count in summary' do
+        expect(summary[:offense_count]).to eq(0)
 
         formatter.file_started(files[0], {})
-        expect(summary[:offence_count]).to eq(0)
+        expect(summary[:offense_count]).to eq(0)
         formatter.file_finished(files[0], [
-          double('offence1'), double('offence2')
+          double('offense1'), double('offense2')
         ])
-        expect(summary[:offence_count]).to eq(2)
+        expect(summary[:offense_count]).to eq(2)
       end
 
       it 'adds value of #hash_for_file to #output_hash[:files]' do
@@ -82,9 +82,9 @@ module Rubocop
     end
 
     describe '#hash_for_file' do
-      subject(:hash) { formatter.hash_for_file(file, offences) }
+      subject(:hash) { formatter.hash_for_file(file, offenses) }
       let(:file) { File.expand_path('spec/spec_helper.rb') }
-      let(:offences) { [double('offence1'), double('offence2')] }
+      let(:offenses) { [double('offense1'), double('offense2')] }
 
       it 'sets relative file path for :path key' do
         expect(hash[:path]).to eq('spec/spec_helper.rb')
@@ -92,32 +92,32 @@ module Rubocop
 
       before do
         count = 0
-        allow(formatter).to receive(:hash_for_offence) do
+        allow(formatter).to receive(:hash_for_offense) do
           count += 1
         end
       end
 
-      it 'sets an array of #hash_for_offence values for :offences key' do
-        expect(hash[:offences]).to eq([1, 2])
+      it 'sets an array of #hash_for_offense values for :offenses key' do
+        expect(hash[:offenses]).to eq([1, 2])
       end
     end
 
-    describe '#hash_for_offence' do
-      subject(:hash) { formatter.hash_for_offence(offence) }
+    describe '#hash_for_offense' do
+      subject(:hash) { formatter.hash_for_offense(offense) }
 
-      it 'sets Offence#severity value for :severity key' do
+      it 'sets Offense#severity value for :severity key' do
         expect(hash[:severity]).to eq(:convention)
       end
 
-      it 'sets Offence#message value for :message key' do
+      it 'sets Offense#message value for :message key' do
         expect(hash[:message]).to eq('This is message')
       end
 
-      it 'sets Offence#cop_name value for :cop_name key' do
+      it 'sets Offense#cop_name value for :cop_name key' do
         expect(hash[:cop_name]).to eq('CopName')
       end
 
-      it 'sets Offence#corrected? value for :corrected key' do
+      it 'sets Offense#corrected? value for :corrected key' do
         expect(hash[:corrected]).to be_true
       end
 
@@ -134,7 +134,7 @@ module Rubocop
     end
 
     describe '#hash_for_location' do
-      subject(:hash) { formatter.hash_for_location(offence) }
+      subject(:hash) { formatter.hash_for_location(offense) }
 
       it 'sets line value for :line key' do
         expect(hash[:line]).to eq(3)
@@ -143,6 +143,10 @@ module Rubocop
       it 'sets column value for :column key' do
         expect(hash[:column]).to eq(6)
       end
+
+      it 'sets length value for :length key' do
+        expect(hash[:length]).to eq(1)
+      end
     end
   end
 end

data/spec/rubocop/formatter/offense_count_formatter_spec.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+require 'tempfile'
+
+module Rubocop
+  module Formatter
+    describe OffenseCountFormatter do
+      subject(:formatter) { described_class.new(output) }
+      let(:output) { StringIO.new }
+
+      let(:files) do
+        %w(lib/rubocop.rb spec/spec_helper.rb bin/rubocop).map do |path|
+          File.expand_path(path)
+        end
+      end
+
+      let(:finish) { formatter.file_finished(files.first, offenses) }
+
+      describe '#file_finished' do
+        before { formatter.started(files) }
+
+        context 'when no offenses are detected' do
+          let(:offenses) { [] }
+          it 'shouldn\'t add to offense_counts' do
+            expect { finish }.to_not change { formatter.offense_counts }
+          end
+        end
+
+        context 'when any offenses are detected' do
+          let(:offenses) { [double('offense', cop_name: 'OffendedCop')] }
+          it 'should increment the count for the cop in offense_counts' do
+            expect { finish }.to change { formatter.offense_counts }
+          end
+        end
+      end
+
+      describe '#report_summary' do
+        context 'when an offense is detected' do
+          let(:cop_counts) { { 'OffendedCop' => 1 } }
+          it 'shows the cop and the offense count' do
+            formatter.report_summary(1, cop_counts)
+            expect(output.string).to include(
+              "\n1  OffendedCop\n--\n1  Total")
+          end
+        end
+      end
+
+      describe '#finished' do
+        context 'when there are many offenses' do
+          let(:offenses) do
+            %w(CopB CopA CopC CopC).map { |c| double('offense', cop_name: c) }
+          end
+
+          before do
+            formatter.started(files)
+            finish
+          end
+
+          it 'sorts by offense count first and then by cop name' do
+            formatter.finished(files)
+            expect(output.string).to eq(['',
+                                         '2  CopC',
+                                         '1  CopA',
+                                         '1  CopB',
+                                         '--',
+                                         '4  Total',
+                                         '',
+                                         ''].join("\n"))
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/rubocop/formatter/progress_formatter_spec.rb

@@ -23,64 +23,64 @@ module Rubocop
       shared_examples 'calls #report_file_as_mark' do
         it 'calls #report_as_with_mark' do
           expect(formatter).to receive(:report_file_as_mark)
-          formatter.file_finished(files.first, offences)
+          formatter.file_finished(files.first, offenses)
         end
       end
 
-      context 'when no offences are detected' do
-        let(:offences) { [] }
+      context 'when no offenses are detected' do
+        let(:offenses) { [] }
         include_examples 'calls #report_file_as_mark'
       end
 
-      context 'when any offences are detected' do
-        let(:offences) { [double('offence').as_null_object] }
+      context 'when any offenses are detected' do
+        let(:offenses) { [double('offense').as_null_object] }
         include_examples 'calls #report_file_as_mark'
       end
     end
 
     describe '#report_file_as_mark' do
       before do
-        formatter.report_file_as_mark(files.first, offences)
+        formatter.report_file_as_mark(files.first, offenses)
       end
 
-      def offence_with_severity(severity)
+      def offense_with_severity(severity)
         source_buffer = Parser::Source::Buffer.new('test', 1)
         source_buffer.source = "a\n"
-        Cop::Offence.new(severity,
+        Cop::Offense.new(severity,
                          Parser::Source::Range.new(source_buffer, 0, 1),
                          'message',
                          'CopName')
       end
 
-      context 'when no offences are detected' do
-        let(:offences) { [] }
+      context 'when no offenses are detected' do
+        let(:offenses) { [] }
 
         it 'prints "."' do
           expect(output.string).to eq('.')
         end
       end
 
-      context 'when a refactor severity offence is detected' do
-        let(:offences) { [offence_with_severity(:refactor)] }
+      context 'when a refactor severity offense is detected' do
+        let(:offenses) { [offense_with_severity(:refactor)] }
 
         it 'prints "R"' do
           expect(output.string).to eq('R')
         end
       end
 
-      context 'when a refactor convention offence is detected' do
-        let(:offences) { [offence_with_severity(:convention)] }
+      context 'when a refactor convention offense is detected' do
+        let(:offenses) { [offense_with_severity(:convention)] }
 
         it 'prints "C"' do
           expect(output.string).to eq('C')
         end
       end
 
-      context 'when different severity offences are detected' do
-        let(:offences) do
+      context 'when different severity offenses are detected' do
+        let(:offenses) do
           [
-            offence_with_severity(:refactor),
-            offence_with_severity(:error)
+            offense_with_severity(:refactor),
+            offense_with_severity(:error)
           ]
         end
 
@@ -95,7 +95,7 @@ module Rubocop
         formatter.started(files)
       end
 
-      context 'when any offences are detected' do
+      context 'when any offenses are detected' do
         before do
           source_buffer = Parser::Source::Buffer.new('test', 1)
           source = 9.times.map do |index|
@@ -106,7 +106,7 @@ module Rubocop
 
           formatter.file_started(files[0], {})
           formatter.file_finished(files[0], [
-            Cop::Offence.new(
+            Cop::Offense.new(
               :convention,
               Parser::Source::Range.new(source_buffer,
                                         line_length + 2,
@@ -122,7 +122,7 @@ module Rubocop
 
           formatter.file_started(files[2], {})
           formatter.file_finished(files[2], [
-            Cop::Offence.new(
+            Cop::Offense.new(
               :error,
               Parser::Source::Range.new(source_buffer,
                                         4 * line_length + 1,
@@ -130,7 +130,7 @@ module Rubocop
               'bar',
               'Cop'
             ),
-            Cop::Offence.new(
+            Cop::Offense.new(
               :convention,
               Parser::Source::Range.new(source_buffer,
                                         5 * line_length,
@@ -141,10 +141,10 @@ module Rubocop
           ])
         end
 
-        it 'reports all detected offences for all failed files' do
+        it 'reports all detected offenses for all failed files' do
           formatter.finished(files)
           expect(output.string).to include([
-            'Offences:',
+            'Offenses:',
             '',
             'lib/rubocop.rb:2:3: C: foo',
             'This is line 2.',
@@ -159,7 +159,7 @@ module Rubocop
         end
       end
 
-      context 'when no offences are detected' do
+      context 'when no offenses are detected' do
         before do
           files.each do |file|
             formatter.file_started(file, {})
@@ -167,9 +167,9 @@ module Rubocop
           end
         end
 
-        it 'does not report offences' do
+        it 'does not report offenses' do
           formatter.finished(files)
-          expect(output.string).not_to include('Offences:')
+          expect(output.string).not_to include('Offenses:')
         end
       end