rubocop 0.29.1 → 0.30.0

data/spec/rubocop/formatter/disabled_lines_formatter_spec.rb

@@ -1,67 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'stringio'
-
-module RuboCop
-  module Formatter
-    describe DisabledLinesFormatter 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(:file_started) do
-        formatter.file_started(files.first, cop_disabled_line_ranges)
-      end
-
-      describe '#file_started' do
-        before { formatter.started(files) }
-
-        context 'when no disable cop comments are detected' do
-          let(:cop_disabled_line_ranges) { {} }
-          it 'does not add to cop_disabled_line_ranges' do
-            expect { file_started }.to_not(
-              change { formatter.cop_disabled_line_ranges })
-          end
-        end
-
-        context 'when any disable cop comments are detected' do
-          let(:cop_disabled_line_ranges) do
-            { cop_disabled_line_ranges: { 'LineLength' => [1..1] } }
-          end
-          it 'merges the changes into cop_disabled_line_ranges' do
-            expect { file_started }.to(
-              change { formatter.cop_disabled_line_ranges })
-          end
-        end
-      end
-
-      describe '#finished' do
-        context 'when there disabled cops detected' do
-          let(:cop_disabled_line_ranges) do
-            { cop_disabled_line_ranges: { 'LineLength' => [1..1] } }
-          end
-
-          before do
-            formatter.started(files)
-            formatter.file_started('lib/rubocop.rb', cop_disabled_line_ranges)
-          end
-
-          it 'lists disabled cops by file' do
-            formatter.finished(files)
-            expect(output.string).to eq(['',
-                                         'Cops disabled line ranges:',
-                                         '',
-                                         'lib/rubocop.rb:1..1: LineLength',
-                                         ''].join("\n"))
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rubocop/formatter/emacs_style_formatter_spec.rb

@@ -1,63 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'stringio'
-
-module RuboCop
-  module Formatter
-    describe EmacsStyleFormatter do
-      subject(:formatter) { described_class.new(output) }
-      let(:output) { StringIO.new }
-
-      describe '#file_finished' do
-        it 'displays parsable text' do
-          cop = Cop::Cop.new
-          source_buffer = Parser::Source::Buffer.new('test', 1)
-          source_buffer.source = %w(a b cdefghi).join("\n")
-
-          cop.add_offense(nil,
-                          Parser::Source::Range.new(source_buffer, 0, 1),
-                          'message 1')
-          cop.add_offense(nil,
-                          Parser::Source::Range.new(source_buffer, 9, 10),
-                          'message 2')
-
-          formatter.file_finished('test', cop.offenses)
-          expect(output.string).to eq ['test:1:1: C: message 1',
-                                       'test:3:6: C: message 2',
-                                       ''].join("\n")
-        end
-
-        context 'when the offense is automatically corrected' do
-          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) { true }
-
-          it 'prints [Corrected] along with message' do
-            formatter.file_finished(file, [offense])
-            expect(output.string)
-              .to include(': [Corrected] This is a message.')
-          end
-        end
-      end
-
-      describe '#finished' do
-        it 'does not report summary' do
-          formatter.finished(['/path/to/file'])
-          expect(output.string).to be_empty
-        end
-      end
-    end
-  end
-end

data/spec/rubocop/formatter/file_list_formatter_spec.rb

@@ -1,33 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'stringio'
-
-module RuboCop
-  module Formatter
-    describe FileListFormatter do
-      subject(:formatter) { described_class.new(output) }
-      let(:output) { StringIO.new }
-
-      describe '#file_finished' do
-        it 'displays parsable text' do
-          cop = Cop::Cop.new
-          source_buffer = Parser::Source::Buffer.new('test', 1)
-          source_buffer.source = %w(a b cdefghi).join("\n")
-
-          cop.add_offense(nil,
-                          Parser::Source::Range.new(source_buffer, 0, 1),
-                          'message 1')
-          cop.add_offense(nil,
-                          Parser::Source::Range.new(source_buffer, 9, 10),
-                          'message 2')
-
-          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
-      end
-    end
-  end
-end

data/spec/rubocop/formatter/formatter_set_spec.rb

@@ -1,141 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'tempfile'
-
-module RuboCop
-  module Formatter
-    describe FormatterSet do
-      subject(:formatter_set) { described_class.new }
-
-      it 'responds to all formatter API methods' do
-        [:started, :file_started, :file_finished, :finished].each do |method|
-          expect(formatter_set).to respond_to(method)
-        end
-      end
-
-      describe 'formatter API method' do
-        before do
-          formatter_set.add_formatter('simple')
-          formatter_set.add_formatter('emacs')
-        end
-
-        let(:files) { ['/path/to/file1', '/path/to/file2'] }
-
-        it 'invokes same method of all containing formatters' do
-          formatter_set.each do |formatter|
-            expect(formatter).to receive(:started).with(files)
-          end
-          formatter_set.started(files)
-        end
-      end
-
-      describe 'add_formatter' do
-        it 'adds a formatter to itself' do
-          formatter_set.add_formatter('simple')
-          expect(formatter_set.size).to eq(1)
-        end
-
-        it 'adds a formatter with specified formatter type' do
-          formatter_set.add_formatter('simple')
-          expect(formatter_set.first.class).to eq(SimpleTextFormatter)
-        end
-
-        it 'can add multiple formatters by being invoked multiple times' do
-          formatter_set.add_formatter('simple')
-          formatter_set.add_formatter('emacs')
-          expect(formatter_set[0].class).to eq(SimpleTextFormatter)
-          expect(formatter_set[1].class).to eq(EmacsStyleFormatter)
-        end
-
-        context 'when output path is omitted' do
-          it 'adds a formatter outputs to $stdout' do
-            formatter_set.add_formatter('simple')
-            expect(formatter_set.first.output).to eq($stdout)
-          end
-        end
-
-        context 'when output path is specified' do
-          it 'adds a formatter outputs to the specified file' do
-            output_path = Tempfile.new('').path
-            formatter_set.add_formatter('simple', output_path)
-            expect(formatter_set.first.output.class).to eq(File)
-            expect(formatter_set.first.output.path).to eq(output_path)
-          end
-
-          it "creates parent directories if they don't exist" do
-            Dir.mktmpdir do |tmpdir|
-              output_path = File.join(tmpdir, 'path/does/not/exist')
-              formatter_set.add_formatter('simple', output_path)
-              expect(formatter_set.first.output.class).to eq(File)
-              expect(formatter_set.first.output.path).to eq(output_path)
-            end
-          end
-        end
-      end
-
-      describe '#close_output_files' do
-        before do
-          2.times do
-            output_path = Tempfile.new('').path
-            formatter_set.add_formatter('simple', output_path)
-          end
-          formatter_set.add_formatter('simple')
-        end
-
-        it 'closes all output files' do
-          formatter_set.close_output_files
-          formatter_set[0..1].each do |formatter|
-            expect(formatter.output).to be_closed
-          end
-        end
-
-        it 'does not close non file output' do
-          expect(formatter_set[2].output).not_to be_closed
-        end
-      end
-
-      describe '#builtin_formatter_class' do
-        def builtin_formatter_class(string)
-          described_class.new.send(:builtin_formatter_class, string)
-        end
-
-        it 'returns class which matches passed alias name exactly' do
-          expect(builtin_formatter_class('simple'))
-            .to eq(SimpleTextFormatter)
-        end
-
-        it 'returns class whose first letter of alias name ' \
-           'matches passed letter' do
-          expect(builtin_formatter_class('s'))
-            .to eq(SimpleTextFormatter)
-        end
-      end
-
-      describe '#custom_formatter_class' do
-        def custom_formatter_class(string)
-          described_class.new.send(:custom_formatter_class, string)
-        end
-
-        it 'returns constant represented by the passed string' do
-          expect(custom_formatter_class('RuboCop')).to eq(RuboCop)
-        end
-
-        it 'can handle namespaced constant name' do
-          expect(custom_formatter_class('RuboCop::CLI')).to eq(RuboCop::CLI)
-        end
-
-        it 'can handle top level namespaced constant name' do
-          expect(custom_formatter_class('::RuboCop::CLI')).to eq(RuboCop::CLI)
-        end
-
-        context 'when non-existent constant name is passed' do
-          it 'raises error' do
-            expect { custom_formatter_class('RuboCop::NonExistentClass') }
-              .to raise_error(NameError)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rubocop/formatter/fuubar_style_formatter_spec.rb

@@ -1,129 +0,0 @@
-# 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/html_formatter_spec.rb

@@ -1,48 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'fileutils'
-
-module RuboCop
-  module Formatter
-    describe HTMLFormatter, :isolated_environment do
-      spec_root = File.expand_path('../../..', __FILE__)
-
-      around do |example|
-        project_path = File.join(spec_root, 'fixtures/html_formatter/project')
-        FileUtils.cp_r(project_path, '.')
-
-        Dir.chdir(File.basename(project_path)) do
-          example.run
-        end
-      end
-
-      let(:actual_html_path) do
-        path = File.expand_path('result.html')
-        CLI.new.run(['--format', 'html', '--out', path])
-        path
-      end
-
-      let(:actual_html) do
-        File.read(actual_html_path, encoding: 'UTF-8')
-      end
-
-      let(:expected_html_path) do
-        File.join(spec_root, 'fixtures/html_formatter/expected.html')
-      end
-
-      let(:expected_html) do
-        html = File.read(expected_html_path, encoding: 'UTF-8')
-        # Avoid failure on version bump
-        html.sub(/(class="version".{0,20})\d+(?:\.\d+){2}/i) do
-          Regexp.last_match(1) + RuboCop::Version::STRING
-        end
-      end
-
-      it 'outputs the result in HTML' do
-        # FileUtils.copy(actual_html_path, expected_html_path)
-        expect(actual_html).to eq(expected_html)
-      end
-    end
-  end
-end