rubocop 0.29.1 → 0.30.0

data/spec/rubocop/formatter/json_formatter_spec.rb

@@ -1,152 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'stringio'
-
-module RuboCop
-  describe Formatter::JSONFormatter do
-    subject(:formatter) { described_class.new(output) }
-    let(:output) { StringIO.new }
-    let(:files) { %w(/path/to/file1 /path/to/file2) }
-    let(:location) do
-      source_buffer = Parser::Source::Buffer.new('test', 1)
-      source_buffer.source = %w(a b cdefghi).join("\n")
-      Parser::Source::Range.new(source_buffer, 9, 10)
-    end
-    let(:offense) do
-      Cop::Offense.new(:convention, location,
-                       'This is message', 'CopName', true)
-    end
-
-    describe '#started' do
-      let(:summary) { formatter.output_hash[:summary] }
-
-      it 'sets target file count in summary' do
-        expect(summary[:target_file_count]).to be_nil
-        formatter.started(%w(/path/to/file1 /path/to/file2))
-        expect(summary[:target_file_count]).to eq(2)
-      end
-    end
-
-    describe '#file_finished' do
-      before do
-        count = 0
-        allow(formatter).to receive(:hash_for_file) do
-          count += 1
-        end
-      end
-
-      let(:summary) { formatter.output_hash[:summary] }
-
-      it 'adds detected offense count in summary' do
-        expect(summary[:offense_count]).to eq(0)
-
-        formatter.file_started(files[0], {})
-        expect(summary[:offense_count]).to eq(0)
-        formatter.file_finished(files[0], [
-          double('offense1'), double('offense2')
-        ])
-        expect(summary[:offense_count]).to eq(2)
-      end
-
-      it 'adds value of #hash_for_file to #output_hash[:files]' do
-        expect(formatter.output_hash[:files]).to be_empty
-
-        formatter.file_started(files[0], {})
-        expect(formatter.output_hash[:files]).to be_empty
-        formatter.file_finished(files[0], [])
-        expect(formatter.output_hash[:files]).to eq([1])
-
-        formatter.file_started(files[1], {})
-        expect(formatter.output_hash[:files]).to eq([1])
-        formatter.file_finished(files[1], [])
-        expect(formatter.output_hash[:files]).to eq([1, 2])
-      end
-    end
-
-    describe '#finished' do
-      let(:summary) { formatter.output_hash[:summary] }
-
-      it 'sets inspected file count in summary' do
-        expect(summary[:inspected_file_count]).to be_nil
-        formatter.finished(%w(/path/to/file1 /path/to/file2))
-        expect(summary[:inspected_file_count]).to eq(2)
-      end
-
-      it 'outputs #output_hash as JSON' do
-        formatter.finished(files)
-        json = output.string
-        restored_hash = JSON.parse(json, symbolize_names: true)
-        expect(restored_hash).to eq(formatter.output_hash)
-      end
-    end
-
-    describe '#hash_for_file' do
-      subject(:hash) { formatter.hash_for_file(file, offenses) }
-      let(:file) { File.expand_path('spec/spec_helper.rb') }
-      let(:offenses) { [double('offense1'), double('offense2')] }
-
-      it 'sets relative file path for :path key' do
-        expect(hash[:path]).to eq('spec/spec_helper.rb')
-      end
-
-      before do
-        count = 0
-        allow(formatter).to receive(:hash_for_offense) do
-          count += 1
-        end
-      end
-
-      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_offense' do
-      subject(:hash) { formatter.hash_for_offense(offense) }
-
-      it 'sets Offense#severity value for :severity key' do
-        expect(hash[:severity]).to eq(:convention)
-      end
-
-      it 'sets Offense#message value for :message key' do
-        expect(hash[:message]).to eq('This is message')
-      end
-
-      it 'sets Offense#cop_name value for :cop_name key' do
-        expect(hash[:cop_name]).to eq('CopName')
-      end
-
-      it 'sets Offense#corrected? value for :corrected key' do
-        expect(hash[:corrected]).to be_truthy
-      end
-
-      before do
-        allow(formatter)
-          .to receive(:hash_for_location).and_return(location_hash)
-      end
-
-      let(:location_hash) { { line: 1, column: 2 } }
-
-      it 'sets value of #hash_for_location for :location key' do
-        expect(hash[:location]).to eq(location_hash)
-      end
-    end
-
-    describe '#hash_for_location' do
-      subject(:hash) { formatter.hash_for_location(offense) }
-
-      it 'sets line value for :line key' do
-        expect(hash[:line]).to eq(3)
-      end
-
-      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

@@ -1,75 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'stringio'
-
-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 'does not 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 'increments 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(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

@@ -1,182 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'stringio'
-
-module RuboCop
-  describe Formatter::ProgressFormatter 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
-
-    describe '#file_finished' do
-      before do
-        formatter.started(files)
-        formatter.file_started(files.first, {})
-      end
-
-      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, offenses)
-        end
-      end
-
-      context 'when no offenses are detected' do
-        let(:offenses) { [] }
-        include_examples 'calls #report_file_as_mark'
-      end
-
-      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(offenses)
-      end
-
-      def offense_with_severity(severity)
-        source_buffer = Parser::Source::Buffer.new('test', 1)
-        source_buffer.source = "a\n"
-        Cop::Offense.new(severity,
-                         Parser::Source::Range.new(source_buffer, 0, 1),
-                         'message',
-                         'CopName')
-      end
-
-      context 'when no offenses are detected' do
-        let(:offenses) { [] }
-
-        it 'prints "."' do
-          expect(output.string).to eq('.')
-        end
-      end
-
-      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 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 offenses are detected' do
-        let(:offenses) do
-          [
-            offense_with_severity(:refactor),
-            offense_with_severity(:error)
-          ]
-        end
-
-        it 'prints highest level mark' do
-          expect(output.string).to eq('E')
-        end
-      end
-    end
-
-    describe '#finished' do
-      before do
-        formatter.started(files)
-      end
-
-      context 'when any offenses are detected' do
-        before do
-          source_buffer = Parser::Source::Buffer.new('test', 1)
-          source = 9.times.map do |index|
-            "This is line #{index + 1}."
-          end
-          source_buffer.source = source.join("\n")
-          line_length = source[0].length + "\n".length
-
-          formatter.file_started(files[0], {})
-          formatter.file_finished(files[0], [
-            Cop::Offense.new(
-              :convention,
-              Parser::Source::Range.new(source_buffer,
-                                        line_length + 2,
-                                        line_length + 3),
-              'foo',
-              'Cop'
-            )
-          ])
-
-          formatter.file_started(files[1], {})
-          formatter.file_finished(files[1], [
-          ])
-
-          formatter.file_started(files[2], {})
-          formatter.file_finished(files[2], [
-            Cop::Offense.new(
-              :error,
-              Parser::Source::Range.new(source_buffer,
-                                        4 * line_length + 1,
-                                        4 * line_length + 2),
-              'bar',
-              'Cop'
-            ),
-            Cop::Offense.new(
-              :convention,
-              Parser::Source::Range.new(source_buffer,
-                                        5 * line_length,
-                                        5 * line_length + 1),
-              'foo',
-              'Cop'
-            )
-          ])
-        end
-
-        it 'reports all detected offenses for all failed files' do
-          formatter.finished(files)
-          expect(output.string).to include([
-            'Offenses:',
-            '',
-            'lib/rubocop.rb:2:3: C: foo',
-            'This is line 2.',
-            '  ^',
-            'bin/rubocop:5:2: E: bar',
-            'This is line 5.',
-            ' ^',
-            'bin/rubocop:6:1: C: foo',
-            'This is line 6.',
-            '^'
-          ].join("\n"))
-        end
-      end
-
-      context 'when no offenses are detected' do
-        before do
-          files.each do |file|
-            formatter.file_started(file, {})
-            formatter.file_finished(file, [])
-          end
-        end
-
-        it 'does not report offenses' do
-          formatter.finished(files)
-          expect(output.string).not_to include('Offenses:')
-        end
-      end
-
-      it 'calls #report_summary' do
-        expect(formatter).to receive(:report_summary)
-        formatter.finished(files)
-      end
-    end
-  end
-end

data/spec/rubocop/formatter/simple_text_formatter_spec.rb

@@ -1,135 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'stringio'
-require 'tempfile'
-
-module RuboCop
-  module Formatter
-    describe SimpleTextFormatter do
-      subject(:formatter) { described_class.new(output) }
-      let(:output) { StringIO.new }
-
-      describe '#report_file' do
-        before do
-          formatter.report_file(file, [offense])
-        end
-
-        let(:file) { '/path/to/file' }
-
-        let(:offense) do
-          Cop::Offense.new(:convention, location,
-                           'This is a message.', 'CopName', corrected)
-        end
-
-        let(:location) do
-          source_buffer = Parser::Source::Buffer.new('test', 1)
-          source_buffer.source = "a\n"
-          Parser::Source::Range.new(source_buffer, 0, 1)
-        end
-
-        let(:corrected) { false }
-
-        context 'the file is under the current working directory' do
-          let(:file) { File.expand_path('spec/spec_helper.rb') }
-
-          it 'prints as relative path' do
-            expect(output.string).to include('== spec/spec_helper.rb ==')
-          end
-        end
-
-        context 'the file is outside of the current working directory' do
-          let(:file) do
-            tempfile = Tempfile.new('')
-            tempfile.close
-            File.expand_path(tempfile.path)
-          end
-
-          it 'prints as absolute path' do
-            expect(output.string).to include("== #{file} ==")
-          end
-        end
-
-        context 'when the offense is not corrected' do
-          let(:corrected) { false }
-
-          it 'prints message as-is' do
-            expect(output.string)
-              .to include(': This is a message.')
-          end
-        end
-
-        context 'when the offense is automatically corrected' do
-          let(:corrected) { true }
-
-          it 'prints [Corrected] along with message' do
-            expect(output.string)
-              .to include(': [Corrected] This is a message.')
-          end
-        end
-      end
-
-      describe '#report_summary' do
-        context 'when no files inspected' do
-          it 'handles pluralization correctly' do
-            formatter.report_summary(0, 0, 0)
-            expect(output.string).to eq(
-              ['',
-               '0 files inspected, no offenses detected',
-               ''].join("\n"))
-          end
-        end
-
-        context 'when a file inspected and no offenses detected' do
-          it 'handles pluralization correctly' do
-            formatter.report_summary(1, 0, 0)
-            expect(output.string).to eq(
-              ['',
-               '1 file inspected, no offenses detected',
-               ''].join("\n"))
-          end
-        end
-
-        context 'when a offense detected' do
-          it 'handles pluralization correctly' do
-            formatter.report_summary(1, 1, 0)
-            expect(output.string).to eq(
-              ['',
-               '1 file inspected, 1 offense detected',
-               ''].join("\n"))
-          end
-        end
-
-        context 'when 2 offenses detected' do
-          it 'handles pluralization correctly' do
-            formatter.report_summary(2, 2, 0)
-            expect(output.string).to eq(
-              ['',
-               '2 files inspected, 2 offenses detected',
-               ''].join("\n"))
-          end
-        end
-
-        context 'when an offense is corrected' do
-          it 'prints about correction' do
-            formatter.report_summary(1, 1, 1)
-            expect(output.string).to eq(
-              ['',
-               '1 file inspected, 1 offense detected, 1 offense corrected',
-               ''].join("\n"))
-          end
-        end
-
-        context 'when 2 offenses are corrected' do
-          it 'handles pluralization correctly' do
-            formatter.report_summary(1, 1, 2)
-            expect(output.string).to eq(
-              ['',
-               '1 file inspected, 1 offense detected, 2 offenses corrected',
-               ''].join("\n"))
-          end
-        end
-      end
-    end
-  end
-end