rubocop 0.29.1 → 0.30.0

data/spec/rubocop/formatter/text_util_spec.rb

@@ -1,55 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module RuboCop
-  module Formatter
-    describe TextUtil do
-      subject(:text_util) { RuboCop::Formatter::TextUtil }
-
-      describe 'pluralize' do
-        it 'will not change 0 to no' do
-          pluralized_text = text_util.pluralize(0, 'file')
-
-          expect(pluralized_text).to eq('0 files')
-        end
-
-        it 'will change 0 to no when configured' do
-          pluralized_text = text_util.pluralize(0, 'file', no_for_zero: true)
-
-          expect(pluralized_text).to eq('no files')
-        end
-
-        it 'will not pluralize 1' do
-          pluralized_text = text_util.pluralize(1, 'file')
-
-          expect(pluralized_text).to eq('1 file')
-        end
-
-        it 'will pluralize quantities greater than 1' do
-          pluralized_text = text_util.pluralize(3, 'file')
-
-          expect(pluralized_text).to eq('3 files')
-        end
-
-        it 'will pluralize fractions' do
-          pluralized_text = text_util.pluralize(0.5, 'file')
-
-          expect(pluralized_text).to eq('0.5 files')
-        end
-
-        it 'will pluralize -1' do
-          pluralized_text = text_util.pluralize(-1, 'file')
-
-          expect(pluralized_text).to eq('-1 files')
-        end
-
-        it 'will pluralize negative quantities less than -1' do
-          pluralized_text = text_util.pluralize(-2, 'file')
-
-          expect(pluralized_text).to eq('-2 files')
-        end
-      end
-    end
-  end
-end

data/spec/rubocop/options_spec.rb

@@ -1,181 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Options, :isolated_environment do
-  include FileHelper
-
-  subject(:options) { described_class.new }
-
-  before(:each) do
-    $stdout = StringIO.new
-    $stderr = StringIO.new
-  end
-
-  after(:each) do
-    $stdout = STDOUT
-    $stderr = STDERR
-  end
-
-  def abs(path)
-    File.expand_path(path)
-  end
-
-  describe 'option' do
-    describe '-h/--help' do
-      it 'exits cleanly' do
-        expect { options.parse ['-h'] }.to exit_with_code(0)
-        expect { options.parse ['--help'] }.to exit_with_code(0)
-      end
-
-      it 'shows help text' do
-        begin
-          options.parse(['--help'])
-        rescue SystemExit # rubocop:disable Lint/HandleExceptions
-        end
-
-        expected_help = <<-END
-Usage: rubocop [options] [file1, file2, ...]
-        --except [COP1,COP2,...]     Disable the given cop(s).
-        --only [COP1,COP2,...]       Run only the given cop(s).
-        --only-guide-cops            Run only cops for rules that link to a
-                                     style guide.
-    -c, --config FILE                Specify configuration file.
-        --auto-gen-config            Generate a configuration file acting as a
-                                     TODO list.
-        --force-exclusion            Force excluding files specified in the
-                                     configuration `Exclude` even if they are
-                                     explicitly passed as arguments.
-    -f, --format FORMATTER           Choose an output formatter. This option
-                                     can be specified multiple times to enable
-                                     multiple formatters at the same time.
-                                       [p]rogress (default)
-                                       [s]imple
-                                       [c]lang
-                                       [d]isabled cops via inline comments
-                                       [fu]ubar
-                                       [e]macs
-                                       [j]son
-                                       [h]tml
-                                       [fi]les
-                                       [o]ffenses
-                                       custom formatter class name
-    -o, --out FILE                   Write output to a file instead of STDOUT.
-                                     This option applies to the previously
-                                     specified --format, or the default format
-                                     if no format is specified.
-    -r, --require FILE               Require Ruby file.
-        --fail-level SEVERITY        Minimum severity (A/R/C/W/E/F) for exit
-                                     with error code.
-        --show-cops [COP1,COP2,...]  Shows the given cops, or all cops by
-                                     default, and their configurations for the
-                                     current directory.
-    -F, --fail-fast                  Inspect files in order of modification
-                                     time and stop after the first file
-                                     containing offenses.
-    -d, --debug                      Display debug info.
-    -D, --display-cop-names          Display cop names in offense messages.
-    -R, --rails                      Run extra Rails cops.
-    -l, --lint                       Run only lint cops.
-    -a, --auto-correct               Auto-correct offenses.
-    -n, --no-color                   Disable color output.
-    -v, --version                    Display version.
-    -V, --verbose-version            Display verbose version.
-      END
-
-        expect($stdout.string).to eq(expected_help)
-      end
-
-      it 'lists all builtin formatters' do
-        begin
-          options.parse(['--help'])
-        rescue SystemExit # rubocop:disable Lint/HandleExceptions
-        end
-
-        option_sections = $stdout.string.lines.slice_before(/^\s*-/)
-
-        format_section = option_sections.find do |lines|
-          lines.first =~ /^\s*-f/
-        end
-
-        formatter_keys = format_section.reduce([]) do |keys, line|
-          match = line.match(/^[ ]{39}(\[[a-z\]]+)/)
-          next keys unless match
-          keys << match.captures.first.gsub(/\[|\]/, '')
-        end.sort
-
-        expected_formatter_keys =
-          RuboCop::Formatter::FormatterSet::BUILTIN_FORMATTERS_FOR_KEYS
-          .keys.sort
-
-        expect(formatter_keys).to eq(expected_formatter_keys)
-      end
-    end
-
-    describe 'incompatible cli options' do
-      it 'fails with argument correct error' do
-        msg = 'Incompatible cli options: [:version, :verbose_version]'
-        expect { options.parse %w(-vV) }
-          .to raise_error(ArgumentError, msg)
-      end
-
-      it 'fails with argument correct error' do
-        msg = 'Incompatible cli options: [:version, :show_cops]'
-        expect { options.parse %w(-v --show-cops) }
-          .to raise_error(ArgumentError, msg)
-      end
-
-      it 'fails with argument correct error' do
-        msg = 'Incompatible cli options: [:verbose_version, :show_cops]'
-        expect { options.parse %w(-V --show-cops) }
-          .to raise_error(ArgumentError, msg)
-      end
-
-      it 'fails with argument correct error' do
-        msg = ['Incompatible cli options: [:version, :verbose_version,',
-               ' :show_cops]'].join
-        expect { options.parse %w(-vV --show-cops) }
-          .to raise_error(ArgumentError, msg)
-      end
-    end
-
-    describe '--fail-level' do
-      it 'accepts full severity names' do
-        %w(refactor convention warning error fatal).each do |severity|
-          expect { options.parse(['--fail-level', severity]) }
-            .not_to raise_error
-        end
-      end
-
-      it 'accepts severity initial letters' do
-        %w(R C W E F).each do |severity|
-          expect { options.parse(['--fail-level', severity]) }
-            .not_to raise_error
-        end
-      end
-
-      it 'accepts the "fake" severities A/autocorrect' do
-        %w(autocorrect A).each do |severity|
-          expect { options.parse(['--fail-level', severity]) }
-            .not_to raise_error
-        end
-      end
-    end
-
-    describe '--require' do
-      let(:required_file_path) { './path/to/required_file.rb' }
-
-      before do
-        create_file('example.rb', '# encoding: utf-8')
-
-        create_file(required_file_path, ['# encoding: utf-8',
-                                         "puts 'Hello from required file!'"])
-      end
-
-      it 'requires the passed path' do
-        options.parse(['--require', required_file_path, 'example.rb'])
-        expect($stdout.string).to start_with('Hello from required file!')
-      end
-    end
-  end
-end

data/spec/rubocop/path_util_spec.rb

@@ -1,77 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::PathUtil do
-  describe '#relative_path' do
-    it 'builds paths relative to PWD by default as a stop-gap' do
-      relative = File.join(Dir.pwd, 'relative')
-      expect(subject.relative_path(relative)).to eq('relative')
-    end
-
-    it 'supports custom base paths' do
-      expect(subject.relative_path('/foo/bar', '/foo')).to eq('bar')
-    end
-  end
-
-  describe '#match_path?', :isolated_environment do
-    include FileHelper
-
-    before do
-      create_file('file', '')
-      create_file('dir/file', '')
-      create_file('dir/files', '')
-      create_file('dir/dir/file', '')
-      create_file('dir/sub/file', '')
-      $stderr = StringIO.new
-    end
-
-    after { $stderr = STDERR }
-
-    context 'with deprecated patterns' do
-      it 'matches dir/** and prints warning' do
-        expect(subject.match_path?('dir/**', 'dir/sub/file', '.rubocop.yml'))
-          .to be_truthy
-        expect($stderr.string)
-          .to eq(["Warning: Deprecated pattern style 'dir/**' in " \
-                  ".rubocop.yml. Change to 'dir/**/*'.",
-                  ''].join("\n"))
-      end
-
-      it 'matches strings to the basename and prints warning' do
-        expect(subject.match_path?('file', 'dir/file', '.rubocop.yml'))
-          .to be_truthy
-        expect($stderr.string)
-          .to eq(["Warning: Deprecated pattern style 'file' in .rubocop.yml. " \
-                  "Change to '**/file'.",
-                  ''].join("\n"))
-
-        expect(subject.match_path?('file', 'dir/files', '')).to be_falsey
-        expect(subject.match_path?('dir', 'dir/file', '')).to be_falsey
-      end
-    end
-
-    it 'matches strings to the full path' do
-      expect(subject.match_path?("#{Dir.pwd}/dir/file",
-                                 "#{Dir.pwd}/dir/file", '')).to be_truthy
-      expect(subject.match_path?("#{Dir.pwd}/dir/file",
-                                 "#{Dir.pwd}/dir/dir/file", '')).to be_falsey
-    end
-
-    it 'matches glob expressions' do
-      expect(subject.match_path?('dir/*',    'dir/file', '')).to be_truthy
-      expect(subject.match_path?('dir/*/*',  'dir/sub/file', '')).to be_truthy
-      expect(subject.match_path?('dir/**/*', 'dir/sub/file', '')).to be_truthy
-      expect(subject.match_path?('dir/**/*', 'dir/file', '')).to be_truthy
-      expect(subject.match_path?('**/*',     'dir/sub/file', '')).to be_truthy
-      expect(subject.match_path?('**/file',  'file', '')).to be_truthy
-
-      expect(subject.match_path?('sub/*',    'dir/sub/file', '')).to be_falsey
-    end
-
-    it 'matches regexps' do
-      expect(subject.match_path?(/^d.*e$/, 'dir/file', '')).to be_truthy
-      expect(subject.match_path?(/^d.*e$/, 'dir/filez', '')).to be_falsey
-    end
-  end
-end

data/spec/rubocop/processed_source_spec.rb

@@ -1,184 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::ProcessedSource do
-  include FileHelper
-
-  subject(:processed_source) { described_class.new(source, path) }
-
-  let(:source) { <<-END.strip_indent }
-    # encoding: utf-8
-    def some_method
-      puts 'foo'
-    end
-    some_method
-  END
-
-  let(:path) { 'path/to/file.rb' }
-
-  describe '.from_file', :isolated_environment do
-    before do
-      create_file(path, 'foo')
-    end
-
-    let(:processed_source) { described_class.from_file(path) }
-
-    it 'returns an instance of ProcessedSource' do
-      expect(processed_source).to be_a(described_class)
-    end
-
-    it "sets the file path to the instance's #path" do
-      expect(processed_source.path).to eq(path)
-    end
-  end
-
-  describe '#path' do
-    it 'is the path passed to .new' do
-      expect(processed_source.path).to eq(path)
-    end
-  end
-
-  describe '#buffer' do
-    it 'is a source buffer' do
-      expect(processed_source.buffer).to be_a(Parser::Source::Buffer)
-    end
-  end
-
-  describe '#ast' do
-    it 'is the root node of AST' do
-      expect(processed_source.ast).to be_a(Astrolabe::Node)
-    end
-  end
-
-  describe '#comments' do
-    it 'is an array of comments' do
-      expect(processed_source.comments).to be_a(Array)
-      expect(processed_source.comments.first).to be_a(Parser::Source::Comment)
-    end
-  end
-
-  describe '#tokens' do
-    it 'has an array of tokens' do
-      expect(processed_source.tokens).to be_a(Array)
-      expect(processed_source.tokens.first).to be_a(RuboCop::Token)
-    end
-  end
-
-  shared_context 'invalid encoding source' do
-    let(:source) do
-      [
-        '# encoding: utf-8',
-        "# \xf9"
-      ].join("\n")
-    end
-  end
-
-  describe '#parser_error' do
-    context 'when the source was properly parsed' do
-      it 'is nil' do
-        expect(processed_source.parser_error).to be_nil
-      end
-    end
-
-    context 'when the source lacks encoding comment and is really utf-8 ' \
-            'encoded but has been read as US-ASCII' do
-      let(:source) do
-        # When files are read into RuboCop, the encoding of source code lacking
-        # an encoding comment will default to the external encoding, which
-        # could for example be US-ASCII if the LC_ALL environment variable is
-        # set to "C".
-        '号码 = 3'.force_encoding('US-ASCII')
-      end
-
-      it 'is nil' do
-        # ProcessedSource#parse sets UTF-8 as default encoding, so no error.
-        expect(processed_source.parser_error).to be_nil
-      end
-    end
-
-    context 'when the source could not be parsed due to encoding error' do
-      include_context 'invalid encoding source'
-
-      it 'returns the error' do
-        expect(processed_source.parser_error).to be_a(Exception)
-        expect(processed_source.parser_error.message)
-          .to include('invalid byte sequence')
-      end
-    end
-  end
-
-  describe '#lines' do
-    it 'is an array' do
-      expect(processed_source.lines).to be_a(Array)
-    end
-
-    it 'has same number of elements as line count' do
-      expect(processed_source.lines.size).to eq(5)
-    end
-
-    it 'contains lines as string without linefeed' do
-      first_line = processed_source.lines.first
-      expect(first_line).to eq('# encoding: utf-8')
-    end
-  end
-
-  describe '#[]' do
-    context 'when an index is passed' do
-      it 'returns the line' do
-        expect(processed_source[3]).to eq('end')
-      end
-    end
-
-    context 'when a range is passed' do
-      it 'returns the array of lines' do
-        expect(processed_source[3..4]).to eq(%w(end some_method))
-      end
-    end
-
-    context 'when start index and length are passed' do
-      it 'returns the array of lines' do
-        expect(processed_source[3, 2]).to eq(%w(end some_method))
-      end
-    end
-  end
-
-  describe 'valid_syntax?' do
-    subject { processed_source.valid_syntax? }
-
-    context 'when the source is completely valid' do
-      let(:source) { 'def valid_code; end' }
-
-      it 'returns true' do
-        expect(processed_source.diagnostics).to be_empty
-        expect(processed_source).to be_valid_syntax
-      end
-    end
-
-    context 'when the source is invalid' do
-      let(:source) { 'def invalid_code; en' }
-
-      it 'returns false' do
-        expect(processed_source).not_to be_valid_syntax
-      end
-    end
-
-    context 'when the source is valid but has some warning diagnostics' do
-      let(:source) { 'do_something *array' }
-
-      it 'returns true' do
-        expect(processed_source.diagnostics).not_to be_empty
-        expect(processed_source.diagnostics.first.level).to eq(:warning)
-        expect(processed_source).to be_valid_syntax
-      end
-    end
-
-    context 'when the source could not be parsed due to encoding error' do
-      include_context 'invalid encoding source'
-
-      it 'returns false' do
-        expect(processed_source).not_to be_valid_syntax
-      end
-    end
-  end
-end