rubocop 0.29.1 → 0.30.0

data/spec/rubocop/cop/variable_force_spec.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'astrolabe/sexp'
-
-describe RuboCop::Cop::VariableForce do
-  include Astrolabe::Sexp
-
-  subject(:force) { described_class.new([]) }
-
-  describe '#process_node' do
-    before do
-      force.variable_table.push_scope(s(:def))
-    end
-
-    context 'when processing lvar node' do
-      let(:node) { s(:lvar, :foo) }
-
-      context 'when the variable is not yet declared' do
-        it 'does not raise error' do
-          expect { force.process_node(node) }.not_to raise_error
-        end
-      end
-    end
-  end
-end

data/spec/rubocop/formatter/base_formatter_spec.rb

@@ -1,191 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module RuboCop
-  module Formatter
-    describe BaseFormatter do
-      include FileHelper
-
-      describe 'how the API methods are invoked', :isolated_environment do
-        subject(:formatter) { double('formatter').as_null_object }
-        let(:runner) { Runner.new({}, ConfigStore.new) }
-        let(:output) { $stdout.string }
-
-        before do
-          create_file('1_offense.rb', [
-            '# encoding: utf-8',
-            '#' * 90
-          ])
-
-          create_file('4_offenses.rb', [
-            '# encoding: utf-8',
-            'puts x ',
-            'test;',
-            'top;',
-            '#' * 90
-          ])
-
-          create_file('no_offense.rb', [
-            '# encoding: utf-8'
-          ])
-
-          allow(SimpleTextFormatter).to receive(:new).and_return(formatter)
-          $stdout = StringIO.new
-        end
-
-        after do
-          $stdout = STDOUT
-        end
-
-        def run
-          runner.run([])
-        end
-
-        describe 'invocation order' do
-          subject(:formatter) do
-            formatter = double('formatter')
-            def formatter.method_missing(method_name, *)
-              return if method_name == :output
-              puts method_name
-            end
-            formatter
-          end
-
-          it 'is called in the proper sequence' do
-            run
-            expect(output).to eq([
-              'started',
-              'file_started',
-              'file_finished',
-              'file_started',
-              'file_finished',
-              'file_started',
-              'file_finished',
-              'finished',
-              ''
-            ].join("\n"))
-          end
-        end
-
-        shared_examples 'receives all file paths' do |method_name|
-          it 'receives all file paths' do
-            expected_paths = [
-              '1_offense.rb',
-              '4_offenses.rb',
-              'no_offense.rb'
-            ].map { |path| File.expand_path(path) }.sort
-
-            expect(formatter).to receive(method_name) do |all_files|
-              expect(all_files.sort).to eq(expected_paths)
-            end
-
-            run
-          end
-
-          describe 'the passed files paths' do
-            it 'is frozen' do
-              expect(formatter).to receive(method_name) do |all_files|
-                all_files.each do |path|
-                  expect(path).to be_frozen
-                end
-              end
-              run
-            end
-          end
-        end
-
-        describe '#started' do
-          include_examples 'receives all file paths', :started
-        end
-
-        describe '#finished' do
-          context 'when RuboCop finished inspecting all files normally' do
-            include_examples 'receives all file paths', :started
-          end
-
-          context 'when RuboCop is interrupted by user' do
-            it 'receives only processed file paths' do
-              class << formatter
-                attr_reader :processed_file_count
-
-                def file_finished(_file, _offenses)
-                  @processed_file_count ||= 0
-                  @processed_file_count += 1
-                end
-              end
-
-              allow(runner).to receive(:aborting?) do
-                formatter.processed_file_count == 2
-              end
-
-              expect(formatter).to receive(:finished) do |processed_files|
-                expect(processed_files.size).to eq(2)
-              end
-
-              run
-            end
-          end
-        end
-
-        shared_examples 'receives a file path' do |method_name|
-          it 'receives a file path' do
-            expect(formatter).to receive(method_name)
-              .with(File.expand_path('1_offense.rb'), anything)
-
-            expect(formatter).to receive(method_name)
-              .with(File.expand_path('4_offenses.rb'), anything)
-
-            expect(formatter).to receive(method_name)
-              .with(File.expand_path('no_offense.rb'), anything)
-
-            run
-          end
-
-          describe 'the passed path' do
-            it 'is frozen' do
-              expect(formatter)
-                .to receive(method_name).exactly(3).times do |path|
-                expect(path).to be_frozen
-              end
-              run
-            end
-          end
-        end
-
-        describe '#file_started' do
-          include_examples 'receives a file path', :file_started
-
-          it 'receives file specific information hash' do
-            expect(formatter).to receive(:file_started)
-              .with(anything, an_instance_of(Hash)).exactly(3).times
-            run
-          end
-        end
-
-        describe '#file_finished' do
-          include_examples 'receives a file path', :file_finished
-
-          it 'receives an array of detected offenses for the file' do
-            expect(formatter).to receive(:file_finished)
-              .exactly(3).times do |file, offenses|
-              case File.basename(file)
-              when '1_offense.rb'
-                expect(offenses.size).to eq(1)
-              when '4_offenses.rb'
-                expect(offenses.size).to eq(4)
-              when 'no_offense.rb'
-                expect(offenses).to be_empty
-              else
-                fail
-              end
-              expect(offenses.all? { |o| o.is_a?(RuboCop::Cop::Offense) })
-                .to be_truthy
-            end
-            run
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rubocop/formatter/clang_style_formatter_spec.rb

@@ -1,114 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'stringio'
-
-module RuboCop
-  module Formatter
-    describe ClangStyleFormatter do
-      subject(:formatter) { described_class.new(output) }
-      let(:output) { StringIO.new }
-
-      describe '#report_file' do
-        it 'displays text containing the offending source line' do
-          cop = Cop::Cop.new
-          source_buffer = Parser::Source::Buffer.new('test', 1)
-          source_buffer.source = ('aa'..'az').to_a.join($RS)
-          cop.add_offense(nil,
-                          Parser::Source::Range.new(source_buffer, 0, 2),
-                          'message 1')
-          cop.add_offense(nil,
-                          Parser::Source::Range.new(source_buffer, 30, 32),
-                          'message 2')
-
-          formatter.report_file('test', cop.offenses)
-          expect(output.string).to eq ['test:1:1: C: message 1',
-                                       'aa',
-                                       '^^',
-                                       'test:11:1: C: message 2',
-                                       'ak',
-                                       '^^',
-                                       ''].join("\n")
-        end
-
-        context 'when the source line is blank' do
-          it 'does not display offending source line' do
-            cop = Cop::Cop.new
-            source_buffer = Parser::Source::Buffer.new('test', 1)
-            source_buffer.source = (['     ', 'yaba']).to_a.join($RS)
-            cop.add_offense(nil,
-                            Parser::Source::Range.new(source_buffer, 0, 2),
-                            'message 1')
-            cop.add_offense(nil,
-                            Parser::Source::Range.new(source_buffer, 6, 10),
-                            'message 2')
-
-            formatter.report_file('test', cop.offenses)
-            expect(output.string).to eq ['test:1:1: C: message 1',
-                                         'test:2:1: C: message 2',
-                                         'yaba',
-                                         '^^^^',
-                                         ''].join("\n")
-          end
-        end
-
-        context 'when the offending source spans multiple lines' do
-          it 'displays the first line' do
-            source = ['do_something([this,',
-                      '              is,',
-                      '              target])'].join($RS)
-
-            source_buffer = Parser::Source::Buffer.new('test', 1)
-            source_buffer.source = source
-
-            location = Parser::Source::Range.new(source_buffer,
-                                                 source.index('['),
-                                                 source.index(']') + 1)
-
-            cop = Cop::Cop.new
-            cop.add_offense(nil, location, 'message 1')
-
-            formatter.report_file('test', cop.offenses)
-            expect(output.string).to eq ['test:1:14: C: message 1',
-                                         'do_something([this,',
-                                         '             ^^^^^^',
-                                         ''].join("\n")
-          end
-        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
-
-        context 'when the offense is not corrected' do
-          let(:corrected) { false }
-
-          it 'prints message as-is' do
-            formatter.report_file(file, [offense])
-            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
-            formatter.report_file(file, [offense])
-            expect(output.string)
-              .to include(': [Corrected] This is a message.')
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rubocop/formatter/colorizable_spec.rb

@@ -1,107 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'rubocop/formatter/colorizable'
-require 'stringio'
-
-module RuboCop
-  module Formatter
-    describe Colorizable do
-      let(:formatter_class) do
-        Class.new(BaseFormatter) do
-          include Colorizable
-        end
-      end
-
-      let(:formatter) do
-        formatter_class.new(output)
-      end
-
-      let(:output) { double('output') }
-
-      around do |example|
-        original_state = Rainbow.enabled
-
-        begin
-          example.run
-        ensure
-          Rainbow.enabled = original_state
-        end
-      end
-
-      describe '#colorize' do
-        subject { formatter.colorize('foo', :red) }
-
-        shared_examples 'does nothing' do
-          it 'does nothing' do
-            should eq('foo')
-          end
-        end
-
-        context 'when the global Rainbow.enabled is true' do
-          before do
-            Rainbow.enabled = true
-          end
-
-          context "and the formatter's output is a tty" do
-            before do
-              allow(output).to receive(:tty?).and_return(true)
-            end
-
-            it 'colorize the passed string' do
-              should eq("\e[31mfoo\e[0m")
-            end
-          end
-
-          context "and the formatter's output is not a tty" do
-            before do
-              allow(output).to receive(:tty?).and_return(false)
-            end
-
-            include_examples 'does nothing'
-          end
-        end
-
-        context 'when the global Rainbow.enabled is false' do
-          before do
-            Rainbow.enabled = false
-          end
-
-          context "and the formatter's output is a tty" do
-            before do
-              allow(output).to receive(:tty?).and_return(true)
-            end
-
-            include_examples 'does nothing'
-          end
-
-          context "and the formatter's output is not a tty" do
-            before do
-              allow(output).to receive(:tty?).and_return(false)
-            end
-
-            include_examples 'does nothing'
-          end
-        end
-      end
-
-      [
-        :black,
-        :red,
-        :green,
-        :yellow,
-        :blue,
-        :magenta,
-        :cyan,
-        :white
-      ].each do |color|
-        describe "##{color}" do
-          it "invokes #colorize(string, #{color}" do
-            expect(formatter).to receive(:colorize).with('foo', color)
-            formatter.send(color, 'foo')
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rubocop/formatter/disabled_config_formatter_spec.rb

@@ -1,50 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'stringio'
-require 'ostruct'
-
-module RuboCop
-  module Formatter
-    describe DisabledConfigFormatter do
-      subject(:formatter) { described_class.new(output) }
-      let(:output) do
-        o = StringIO.new
-        def o.path
-          '.rubocop_todo.yml'
-        end
-        o
-      end
-      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 offenses' do
-          formatter.file_finished('test.rb', offenses)
-          formatter.finished(['test.rb'])
-          expect(output.string).to eq(described_class::HEADING +
-                                      ['',
-                                       '',
-                                       '# Offense count: 1',
-                                       'Cop1:',
-                                       '  Enabled: false',
-                                       '',
-                                       '# Offense count: 1',
-                                       'Cop2:',
-                                       '  Enabled: false',
-                                       ''].join("\n"))
-          expect($stdout.string)
-            .to eq(['Created .rubocop_todo.yml.',
-                    'Run `rubocop --config .rubocop_todo.yml`, or',
-                    'add inherit_from: .rubocop_todo.yml in a .rubocop.yml ' \
-                    'file.',
-                    ''].join("\n"))
-        end
-      end
-    end
-  end
-end