rubocop 0.29.1 → 0.30.0

data/spec/rubocop/rake_task_spec.rb

@@ -1,122 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'rubocop/rake_task'
-
-describe RuboCop::RakeTask do
-  describe 'defining tasks' do
-    it 'creates a rubocop task' do
-      RuboCop::RakeTask.new
-
-      expect(Rake::Task.task_defined?(:rubocop)).to be true
-    end
-
-    it 'creates a rubocop:auto_correct task' do
-      RuboCop::RakeTask.new
-
-      expect(Rake::Task.task_defined?('rubocop:auto_correct')).to be true
-    end
-
-    it 'creates a named task' do
-      RuboCop::RakeTask.new(:lint_lib)
-
-      expect(Rake::Task.task_defined?(:lint_lib)).to be true
-    end
-
-    it 'creates an auto_correct task for the named task' do
-      RuboCop::RakeTask.new(:lint_lib)
-
-      expect(Rake::Task.task_defined?('lint_lib:auto_correct')).to be true
-    end
-  end
-
-  describe 'running tasks' do
-    before(:each) do
-      $stdout = StringIO.new
-      $stderr = StringIO.new
-      Rake::Task['rubocop'].clear if Rake::Task.task_defined?('rubocop')
-    end
-
-    after(:each) do
-      $stdout = STDOUT
-      $stderr = STDERR
-    end
-
-    it 'runs with default options' do
-      RuboCop::RakeTask.new
-
-      cli = double('cli', run: 0)
-      allow(RuboCop::CLI).to receive(:new) { cli }
-      expect(cli).to receive(:run).with(['--format', 'progress'])
-
-      Rake::Task['rubocop'].execute
-    end
-
-    it 'runs with specified options if a block is given' do
-      RuboCop::RakeTask.new do |task|
-        task.patterns = ['lib/**/*.rb']
-        task.formatters = ['files']
-        task.fail_on_error = false
-        task.options = ['--display-cop-names']
-        task.verbose = false
-      end
-
-      cli = double('cli', run: 0)
-      allow(RuboCop::CLI).to receive(:new) { cli }
-      options = ['--format', 'files',  '--display-cop-names', 'lib/**/*.rb']
-      expect(cli).to receive(:run).with(options)
-
-      Rake::Task['rubocop'].execute
-    end
-
-    it 'will not error when result is not 0 and fail_on_error is false' do
-      RuboCop::RakeTask.new do |task|
-        task.fail_on_error = false
-      end
-
-      cli = double('cli', run: 1)
-      allow(RuboCop::CLI).to receive(:new) { cli }
-
-      expect { Rake::Task['rubocop'].execute }.to_not raise_error
-    end
-
-    it 'exits when result is not 0 and fail_on_error is true' do
-      RuboCop::RakeTask.new
-
-      cli = double('cli', run: 1)
-      allow(RuboCop::CLI).to receive(:new) { cli }
-
-      expect { Rake::Task['rubocop'].execute }.to raise_error(SystemExit)
-    end
-
-    context 'auto_correct' do
-      it 'runs with --auto-correct' do
-        RuboCop::RakeTask.new
-
-        cli = double('cli', run: 0)
-        allow(RuboCop::CLI).to receive(:new) { cli }
-        options = ['--auto-correct', '--format', 'progress']
-        expect(cli).to receive(:run).with(options)
-
-        Rake::Task['rubocop:auto_correct'].execute
-      end
-
-      it 'runs with with the options that were passed to its parent task' do
-        RuboCop::RakeTask.new do |task|
-          task.patterns = ['lib/**/*.rb']
-          task.formatters = ['files']
-          task.fail_on_error = false
-          task.options = ['-D']
-          task.verbose = false
-        end
-
-        cli = double('cli', run: 0)
-        allow(RuboCop::CLI).to receive(:new) { cli }
-        options = ['--auto-correct', '--format', 'files',  '-D', 'lib/**/*.rb']
-        expect(cli).to receive(:run).with(options)
-
-        Rake::Task['rubocop:auto_correct'].execute
-      end
-    end
-  end
-end

data/spec/rubocop/runner_spec.rb

@@ -1,99 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module RuboCop
-  class Runner
-    attr_writer :errors # Needed only for testing.
-  end
-end
-
-describe RuboCop::Runner, :isolated_environment do
-  include FileHelper
-
-  let(:formatter_output_path) { 'formatter_output.txt' }
-  let(:formatter_output) { File.read(formatter_output_path) }
-
-  before do
-    create_file('example.rb', source)
-  end
-
-  describe '#run' do
-    let(:options) { { formatters: [['progress', formatter_output_path]] } }
-    subject(:runner) { described_class.new(options, RuboCop::ConfigStore.new) }
-    context 'if there are no offenses in inspected files' do
-      let(:source) { <<-END.strip_indent }
-        # coding: utf-8
-        def valid_code
-        end
-      END
-
-      it 'returns true' do
-        expect(runner.run([])).to be true
-      end
-    end
-
-    context 'if there is an offense in an inspected file' do
-      let(:source) { <<-END.strip_indent }
-        # coding: utf-8
-        def INVALID_CODE
-        end
-      END
-
-      it 'returns false' do
-        expect(runner.run([])).to be false
-      end
-
-      it 'sends the offense to a formatter' do
-        runner.run([])
-        expect(formatter_output).to eq <<-END.strip_indent
-          Inspecting 1 file
-          C
-
-          Offenses:
-
-          example.rb:2:5: C: Use snake_case for method names.
-          def INVALID_CODE
-              ^^^^^^^^^^^^
-
-          1 file inspected, 1 offense detected
-        END
-      end
-    end
-  end
-
-  describe '#run with cops autocorrecting each-other' do
-    let(:options) do
-      {
-        auto_correct: true,
-        formatters: [['progress', formatter_output_path]]
-      }
-    end
-
-    subject(:runner) do
-      runner_class = Class.new(RuboCop::Runner) do
-        def mobilized_cop_classes(_config)
-          [
-            RuboCop::Cop::Test::ClassMustBeAModuleCop,
-            RuboCop::Cop::Test::ModuleMustBeAClassCop
-          ]
-        end
-      end
-      runner_class.new(options, RuboCop::ConfigStore.new)
-    end
-
-    context 'if there is an offense in an inspected file' do
-      let(:source) { <<-END.strip_indent }
-        # coding: utf-8
-        class Klass
-        end
-      END
-
-      it 'aborts because of an infinite loop' do
-        expect do
-          runner.run([])
-        end.to raise_error RuboCop::Runner::InfiniteCorrectionLoop
-      end
-    end
-  end
-end

data/spec/rubocop/string_util_spec.rb

@@ -1,46 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module RuboCop
-  module StringUtil
-    describe Jaro do
-      {
-        %w(foo foo)       => 1.000,
-        %w(foo bar)       => 0.000,
-        %w(martha marhta) => 0.944,
-        %w(dwayne duane)  => 0.822
-      }.each do |strings, expected|
-        context "with #{strings.first.inspect} and #{strings.last.inspect}" do
-          subject(:distance) { Jaro.distance(*strings) }
-
-          it "returns #{expected}" do
-            expect(distance).to be_within(0.001).of(expected)
-          end
-        end
-      end
-    end
-
-    describe JaroWinkler do
-      # These samples are derived from Apache Lucene project.
-      # https://github.com/apache/lucene-solr/blob/lucene_solr_4_9_0/lucene/suggest/src/test/org/apache/lucene/search/spell/TestJaroWinklerDistance.java
-      {
-        %w(al al)             => 1.000,
-        %w(martha marhta)     => 0.961,
-        %w(jones johnson)     => 0.832,
-        %w(abcvwxyz cabvwxyz) => 0.958,
-        %w(dwayne duane)      => 0.840,
-        %w(dixon dicksonx)    => 0.813,
-        %w(fvie ten)          => 0.000
-      }.each do |strings, expected|
-        context "with #{strings.first.inspect} and #{strings.last.inspect}" do
-          subject(:distance) { JaroWinkler.distance(*strings) }
-
-          it "returns #{expected}" do
-            expect(distance).to be_within(0.001).of(expected)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rubocop/target_finder_spec.rb

@@ -1,245 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::TargetFinder, :isolated_environment do
-  include FileHelper
-
-  subject(:target_finder) do
-    described_class.new(config_store, options)
-  end
-  let(:config_store) { RuboCop::ConfigStore.new }
-  let(:options) { { force_exclusion: force_exclusion, debug: debug } }
-  let(:force_exclusion) { false }
-  let(:debug) { false }
-
-  before do
-    create_file('dir1/ruby1.rb',   '# encoding: utf-8')
-    create_file('dir1/ruby2.rb',   '# encoding: utf-8')
-    create_file('dir1/file.txt',   '# encoding: utf-8')
-    create_file('dir1/file',       '# encoding: utf-8')
-    create_file('dir1/executable', '#!/usr/bin/env ruby')
-    create_file('dir2/ruby3.rb',   '# encoding: utf-8')
-  end
-
-  describe '#find' do
-    let(:found_files) { target_finder.find(args) }
-    let(:found_basenames) { found_files.map { |f| File.basename(f) } }
-    let(:args) { [] }
-
-    it 'returns absolute paths' do
-      expect(found_files).not_to be_empty
-      found_files.each do |file|
-        expect(file).to start_with('/')
-      end
-    end
-
-    context 'when no argument is passed' do
-      let(:args) { [] }
-
-      it 'finds files under the current directory' do
-        Dir.chdir('dir1') do
-          expect(found_files).not_to be_empty
-          found_files.each do |file|
-            expect(file).to include('/dir1/')
-            expect(file).not_to include('/dir2/')
-          end
-        end
-      end
-    end
-
-    context 'when a directory path is passed' do
-      let(:args) { ['../dir2'] }
-
-      it 'finds files under the specified directory' do
-        Dir.chdir('dir1') do
-          expect(found_files).not_to be_empty
-          found_files.each do |file|
-            expect(file).to include('/dir2/')
-            expect(file).not_to include('/dir1/')
-          end
-        end
-      end
-    end
-
-    context 'when a file is passed' do
-      let(:args) { ['dir2/file'] }
-
-      it 'picks the file' do
-        expect(found_basenames).to eq(['file'])
-      end
-    end
-
-    context 'when a pattern is passed' do
-      let(:args) { ['dir1/*2.rb'] }
-
-      it 'finds files which match the pattern' do
-        expect(found_basenames).to eq(['ruby2.rb'])
-      end
-    end
-
-    context 'when same paths are passed' do
-      let(:args) { %w(dir1 dir1) }
-
-      it 'does not return duplicated file paths' do
-        count = found_basenames.count { |f| f == 'ruby1.rb' }
-        expect(count).to eq(1)
-      end
-    end
-
-    context 'when some paths are specified in the configuration Exclude ' \
-            'and they are explicitly passed as arguments' do
-      before do
-        create_file('.rubocop.yml', [
-          'AllCops:',
-          '  Exclude:',
-          '    - dir1/ruby1.rb',
-          "    - 'dir2/*'"
-        ])
-
-        create_file('dir1/.rubocop.yml', [
-          'AllCops:',
-          '  Exclude:',
-          '    - executable'
-        ])
-      end
-
-      let(:args) do
-        ['dir1/ruby1.rb', 'dir1/ruby2.rb', 'dir1/exe*', 'dir2/ruby3.rb']
-      end
-
-      context 'normally' do
-        it 'does not exclude them' do
-          expect(found_basenames)
-            .to eq(['ruby1.rb', 'ruby2.rb', 'executable', 'ruby3.rb'])
-        end
-      end
-
-      context "when it's forced to adhere file exclusion configuration" do
-        let(:force_exclusion) { true }
-
-        it 'excludes them' do
-          expect(found_basenames).to eq(['ruby2.rb'])
-        end
-      end
-    end
-  end
-
-  describe '#find_files' do
-    let(:found_files) { target_finder.find_files(base_dir, flags) }
-    let(:found_basenames) { found_files.map { |f| File.basename(f) } }
-    let(:base_dir) { Dir.pwd }
-    let(:flags) { 0 }
-
-    it 'does not search excluded top level directories' do
-      config = double('config')
-      exclude_property = { 'Exclude' => [File.expand_path('dir1/**/*')] }
-      allow(config).to receive(:[]).with('AllCops').and_return(exclude_property)
-      allow(config_store).to receive(:for).and_return(config)
-
-      expect(found_basenames).not_to include('ruby1.rb')
-      expect(found_basenames).to include('ruby3.rb')
-    end
-
-    it 'works also if a folder is named ","' do
-      create_file(',/ruby4.rb', '# encoding: utf-8')
-
-      config = double('config')
-      exclude_property = { 'Exclude' => [File.expand_path('dir1/**/*')] }
-      allow(config).to receive(:[]).with('AllCops').and_return(exclude_property)
-      allow(config_store).to receive(:for).and_return(config)
-
-      expect(found_basenames).not_to include('ruby1.rb')
-      expect(found_basenames).to include('ruby3.rb')
-      expect(found_basenames).to include('ruby4.rb')
-    end
-  end
-
-  describe '#target_files_in_dir' do
-    let(:found_files) { target_finder.target_files_in_dir(base_dir) }
-    let(:found_basenames) { found_files.map { |f| File.basename(f) } }
-    let(:base_dir) { '.' }
-
-    it 'picks files with extension .rb' do
-      rb_file_count = found_files.count { |f| f.end_with?('.rb') }
-      expect(rb_file_count).to eq(3)
-    end
-
-    it 'picks ruby executable files with no extension' do
-      expect(found_basenames).to include('executable')
-    end
-
-    it 'does not pick files with no extension and no ruby shebang' do
-      expect(found_basenames).not_to include('file')
-    end
-
-    it 'picks ruby executable files with no extension' do
-      expect(found_basenames).to include('executable')
-    end
-
-    it 'does not pick directories' do
-      found_basenames = found_files.map { |f| File.basename(f) }
-      expect(found_basenames).not_to include('dir1')
-    end
-
-    it 'picks files specified to be included in config' do
-      config = double('config')
-      allow(config).to receive(:file_to_include?) do |file|
-        File.basename(file) == 'file'
-      end
-      allow(config)
-        .to receive(:[]).with('AllCops').and_return('Exclude' => [])
-      allow(config).to receive(:file_to_exclude?).and_return(false)
-      allow(config_store).to receive(:for).and_return(config)
-
-      expect(found_basenames).to include('file')
-    end
-
-    it 'does not pick files specified to be excluded in config' do
-      config = double('config').as_null_object
-      allow(config)
-        .to receive(:[]).with('AllCops').and_return('Exclude' => [])
-      allow(config).to receive(:file_to_include?).and_return(false)
-      allow(config).to receive(:file_to_exclude?) do |file|
-        File.basename(file) == 'ruby2.rb'
-      end
-      allow(config_store).to receive(:for).and_return(config)
-
-      expect(found_basenames).not_to include('ruby2.rb')
-    end
-
-    context 'when an exception is raised while reading file' do
-      around do |example|
-        original_stderr = $stderr
-        $stderr = StringIO.new
-        begin
-          example.run
-        ensure
-          $stderr = original_stderr
-        end
-      end
-
-      before do
-        allow_any_instance_of(File).to receive(:readline).and_raise(EOFError)
-      end
-
-      context 'and debug mode is enabled' do
-        let(:debug) { true }
-
-        it 'outputs error message' do
-          found_files
-          expect($stderr.string).to include('Unprocessable file')
-        end
-      end
-
-      context 'and debug mode is disabled' do
-        let(:debug) { false }
-
-        it 'outputs nothing' do
-          found_files
-          expect($stderr.string).to be_empty
-        end
-      end
-    end
-  end
-end