rubocop 0.9.1 → 0.10.0

data/spec/rubocop/cops/style/when_then_spec.rb

@@ -6,25 +6,25 @@ module Rubocop
   module Cop
     module Style
       describe WhenThen do
-        let(:wt) { WhenThen.new }
+        let(:cop) { WhenThen.new }
 
         it 'registers an offence for when x;' do
-          inspect_source(wt, ['case a',
+          inspect_source(cop, ['case a',
                               'when b; c',
                               'end'])
-          expect(wt.offences.map(&:message)).to eq(
+          expect(cop.offences.map(&:message)).to eq(
             ['Never use "when x;". Use "when x then" instead.'])
         end
 
         it 'accepts when x then' do
-          inspect_source(wt, ['case a',
+          inspect_source(cop, ['case a',
                               'when b then c',
                               'end'])
-          expect(wt.offences.map(&:message)).to be_empty
+          expect(cop.offences.map(&:message)).to be_empty
         end
 
         it 'accepts ; separating statements in the body of when' do
-          inspect_source(wt, ['case a',
+          inspect_source(cop, ['case a',
                               'when b then c; d',
                               'end',
                               '',
@@ -32,7 +32,14 @@ module Rubocop
                               'when f',
                               '  g; h',
                               'end'])
-          expect(wt.offences.map(&:message)).to be_empty
+          expect(cop.offences.map(&:message)).to be_empty
+        end
+
+        it 'auto-corrects "when x;" with "when x then"' do
+          new_source = autocorrect_source(cop, ['case a',
+                                                'when b; c',
+                                                'end'])
+          expect(new_source).to eq("case a\nwhen b then c\nend")
         end
       end
     end

data/spec/rubocop/cops/style/while_until_do_spec.rb

@@ -41,6 +41,18 @@ module Rubocop
                                'end'])
           expect(cop.offences).to be_empty
         end
+
+        it 'auto-corrects the usage of "do" in multiline while' do
+          new_source = autocorrect_source(cop, ['while cond do',
+                                                'end'])
+          expect(new_source).to eq("while cond \nend")
+        end
+
+        it 'auto-corrects the usage of "do" in multiline until' do
+          new_source = autocorrect_source(cop, ['until cond do',
+                                                'end'])
+          expect(new_source).to eq("until cond \nend")
+        end
       end
     end
   end

data/spec/rubocop/cops/variable_inspector_spec.rb

@@ -32,7 +32,7 @@ module Rubocop
           context 'when begin node is passed' do
             it 'accepts that as pseudo scope for top level scope' do
               node = s(:begin)
-              expect { Scope.new(node) }.not_to raise_error(ArgumentError)
+              expect { Scope.new(node) }.not_to raise_error
             end
           end
         end
@@ -260,10 +260,8 @@ module Rubocop
         end
 
         let(:ast) do
-          ast, *_ = Rubocop::CLI.parse('(string)') do |sb|
-            sb.source = source
-          end
-          ast
+          processed_source = Rubocop::SourceParser.parse(source)
+          processed_source.ast
         end
 
         # (class

data/spec/rubocop/formatter/file_list_formatter_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+
+module Rubocop
+  module Formatter
+    describe FileListFormatter do
+      let(:formatter) { FileListFormatter.new(output) }
+      let(:output) { StringIO.new }
+
+      describe '#report_file' 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_offence(:convention,
+                          Parser::Source::Range.new(source_buffer, 0, 1),
+                          'message 1')
+          cop.add_offence(:fatal,
+                          Parser::Source::Range.new(source_buffer, 9, 10),
+                          'message 2')
+
+          formatter.report_file('test', cop.offences)
+          formatter.report_file('test_2', cop.offences)
+          expect(output.string).to eq ['test',
+                                       "test_2\n"].join("\n")
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/processed_source_spec.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  describe ProcessedSource do
+    subject(:processed_source) do
+      ProcessedSource.new(
+        buffer,
+        double('ast'),
+        double('comments'),
+        double('tokens'),
+        double('diagnostics')
+      )
+    end
+
+    let(:source) do
+      [
+        'def some_method',
+        "  puts 'foo'",
+        'end',
+        'some_method'
+      ].join("\n")
+    end
+
+    let(:buffer) do
+      buffer = Parser::Source::Buffer.new('(string)', 1)
+      buffer.source = source
+      buffer
+    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).to have(4).items
+      end
+
+      it 'contains lines as string without linefeed' do
+        first_line = processed_source.lines.first
+        expect(first_line).to eq('def some_method')
+      end
+    end
+
+    describe '#[]' do
+      context 'when an index is passed' do
+        it 'returns the line' do
+          expect(processed_source[2]).to eq('end')
+        end
+      end
+
+      context 'when a range is passed' do
+        it 'returns the array of lines' do
+          expect(processed_source[2..3]).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[2, 2]).to eq(%w(end some_method))
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/source_parser_spec.rb

@@ -0,0 +1,141 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  describe SourceParser, :isolated_environment do
+    include FileHelper
+
+    describe '.parse_file' do
+      let(:file) { 'example.rb' }
+
+      let(:source) do
+        [
+          '# encoding: utf-8',
+          '',
+          'def some_method',
+          "  puts 'foo'",
+          'end',
+          '',
+          'some_method'
+        ]
+      end
+
+      before do
+        create_file(file, source)
+      end
+
+      let (:processed_source) do
+        SourceParser.parse_file(file)
+      end
+
+      it 'returns ProcessedSource' do
+        expect(processed_source).to be_a(ProcessedSource)
+      end
+
+      describe 'the returned processed source' do
+        it 'has the root node of AST' do
+          expect(processed_source.ast).to be_a(Parser::AST::Node)
+        end
+
+        it 'has 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
+
+        it 'has an array of tokens' do
+          expect(processed_source.tokens).to be_a(Array)
+          expect(processed_source.tokens.first).to be_a(Token)
+        end
+
+        it 'has a source buffer' do
+          expect(processed_source.buffer).to be_a(Parser::Source::Buffer)
+        end
+
+        context 'when the source is valid' do
+          it 'does not have diagnostics' do
+            expect(processed_source.diagnostics).to be_a(Array)
+            expect(processed_source.diagnostics).to be_empty
+          end
+        end
+
+        context 'when the source has invalid syntax' do
+          let(:source) do
+            [
+              '# encoding: utf-8',
+              '',
+              'def some_method',
+              "  puts 'foo'",
+              'end',
+              '',
+              'some_method',
+              '',
+              '?invalid_syntax'
+            ]
+          end
+
+          it 'has an array of diagnostics' do
+            expect(processed_source.diagnostics).to be_a(Array)
+            expect(processed_source.diagnostics.first)
+              .to be_a(Parser::Diagnostic)
+          end
+        end
+      end
+    end
+
+    describe '.cop_disabled_lines_in' do
+      let(:source) do
+        [
+          '# encoding: utf-8',
+          '',
+          '# rubocop:disable MethodLength',
+          'def some_method',
+          "  puts 'foo'",
+          'end',
+          '# rubocop:enable MethodLength',
+          '',
+          '# rubocop:disable all',
+          'some_method',
+          '# rubocop:enable all',
+          '',
+          "code = 'This is evil.'",
+          'eval(code) # rubocop:disable Eval',
+          "puts 'This is not evil.'"
+        ]
+      end
+
+      let(:disabled_lines) { SourceParser.cop_disabled_lines_in(source) }
+
+      it 'has keys for disabled cops' do
+        expect(disabled_lines).to have_key('MethodLength')
+        expect(disabled_lines).to have_key('Eval')
+      end
+
+      it 'supports disabling multiple lines with a pair of directive' do
+        method_length_disabled_lines = disabled_lines['MethodLength']
+        expected_part = (3..6).to_a
+        expect(method_length_disabled_lines & expected_part)
+          .to eq(expected_part)
+      end
+
+      it 'supports disabling single line with a direcive at end of line' do
+        eval_disabled_lines = disabled_lines['Eval']
+        expect(eval_disabled_lines).to include(14)
+        expect(eval_disabled_lines).not_to include(15)
+      end
+
+      it 'supports disabling all cops with keyword all' do
+        all_cop_names = Cop::Cop.all.map(&:cop_name).sort
+        expect(disabled_lines.keys.sort).to eq(all_cop_names)
+
+        expected_part = (9..10).to_a
+
+        disabled_lines.each_value do |each_cop_disabled_lines|
+          expect(each_cop_disabled_lines & expected_part)
+            .to eq(expected_part)
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/target_finder_spec.rb

@@ -0,0 +1,180 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  describe TargetFinder, :isolated_environment do
+    include FileHelper
+
+    subject(:target_finder) { TargetFinder.new(config_store, debug) }
+    let(:config_store) { ConfigStore.new }
+    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
+    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')
+        config.stub(:file_to_include?) do |file|
+          File.basename(file) == 'file'
+        end
+        config.stub(:file_to_exclude?).and_return(false)
+        config_store.stub(: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
+        config.stub(:file_to_include?).and_return(false)
+        config.stub(:file_to_exclude?) do |file|
+          File.basename(file) == 'ruby2.rb'
+        end
+        config_store.stub(:for).and_return(config)
+
+        expect(found_basenames).not_to include('ruby2.rb')
+      end
+
+      it 'does not return duplicated paths' do
+        config = double('config').as_null_object
+        config.stub(:file_to_include?).and_return(true)
+        config.stub(:file_to_exclude?).and_return(false)
+        config_store.stub(:for).and_return(config)
+
+        count = found_basenames.count { |f| f == 'ruby1.rb' }
+        expect(count).to eq(1)
+      end
+
+      context 'when an exception is raised while reading file' do
+        around do |example|
+          File.any_instance.stub(:readline).and_raise(EOFError)
+
+          original_stderr = $stderr
+          $stderr = StringIO.new
+          begin
+            example.run
+          ensure
+            $stderr = original_stderr
+          end
+        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
+end