rubocop 0.13.1 → 0.14.0

data/spec/rubocop/processed_source_spec.rb

@@ -2,65 +2,108 @@
 
 require 'spec_helper'
 
-module Rubocop
-  describe ProcessedSource do
-    subject(:processed_source) do
-      ProcessedSource.new(
-        buffer,
-        double('ast'),
-        double('comments'),
-        double('tokens'),
-        double('diagnostics')
-      )
+describe Rubocop::ProcessedSource do
+  subject(:processed_source) do
+    described_class.new(
+      buffer,
+      double('ast'),
+      double('comments'),
+      double('tokens'),
+      diagnostics
+    )
+  end
+
+  let(:diagnostics) { double('diagnostics') }
+
+  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
 
-    let(:source) do
-      [
-        'def some_method',
-        "  puts 'foo'",
-        'end',
-        'some_method'
-      ].join("\n")
+    it 'has same number of elements as line count' do
+      expect(processed_source.lines.size).to eq(4)
     end
 
-    let(:buffer) do
-      buffer = Parser::Source::Buffer.new('(string)', 1)
-      buffer.source = source
-      buffer
+    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 '#lines' do
-      it 'is an array' do
-        expect(processed_source.lines).to be_a(Array)
+  describe '#[]' do
+    context 'when an index is passed' do
+      it 'returns the line' do
+        expect(processed_source[2]).to eq('end')
       end
+    end
 
-      it 'has same number of elements as line count' do
-        expect(processed_source.lines.size).to eq(4)
+    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
 
-      it 'contains lines as string without linefeed' do
-        first_line = processed_source.lines.first
-        expect(first_line).to eq('def some_method')
+    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
 
-    describe '#[]' do
-      context 'when an index is passed' do
-        it 'returns the line' do
-          expect(processed_source[2]).to eq('end')
-        end
+  describe 'valid_syntax?' do
+    let(:diagnostics) do
+      [Parser::Diagnostic.new(level, 'message', double('location'))]
+    end
+
+    context 'when the source has diagnostic with error level' do
+      let(:level) { :error }
+
+      it 'returns false' do
+        expect(processed_source.valid_syntax?).to be_false
+      end
+    end
+
+    context 'when the source has diagnostic with error level' do
+      let(:level) { :fatal }
+
+      it 'returns false' do
+        expect(processed_source.valid_syntax?).to be_false
       end
+    end
+
+    context 'when the source has diagnostic with error level' do
+      let(:level) { :warning }
+
+      it 'returns false' do
+        expect(processed_source.valid_syntax?).to be_true
+      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
+    context 'when the source has diagnostics with error and warning level' do
+      let(:diagnostics) do
+        [
+          Parser::Diagnostic.new(:error, 'message', double('location')),
+          Parser::Diagnostic.new(:warning, 'message', double('location'))
+        ]
       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
+      it 'returns false' do
+        expect(processed_source.valid_syntax?).to be_false
       end
     end
   end

data/spec/rubocop/source_parser_spec.rb

@@ -2,139 +2,137 @@
 
 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
+describe Rubocop::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
+    before do
+      create_file(file, source)
+    end
 
-      let(:processed_source) do
-        SourceParser.parse_file(file)
-      end
+    let(:processed_source) do
+      described_class.parse_file(file)
+    end
+
+    it 'returns ProcessedSource' do
+      expect(processed_source).to be_a(Rubocop::ProcessedSource)
+    end
 
-      it 'returns ProcessedSource' do
-        expect(processed_source).to be_a(ProcessedSource)
+    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
 
-      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 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(Rubocop::Token)
+      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
 
-        it 'has a source buffer' do
-          expect(processed_source.buffer).to be_a(Parser::Source::Buffer)
+      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 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
+      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
 
-        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
+        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
+  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) }
+    let(:disabled_lines) { described_class.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 '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 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 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)
+    it 'supports disabling all cops with keyword all' do
+      all_cop_names = Rubocop::Cop::Cop.all.map(&:cop_name).sort
+      expect(disabled_lines.keys.sort).to eq(all_cop_names)
 
-        expected_part = (9..10).to_a
+      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
+      disabled_lines.each_value do |each_cop_disabled_lines|
+        expect(each_cop_disabled_lines & expected_part)
+          .to eq(expected_part)
       end
     end
   end

data/spec/rubocop/target_finder_spec.rb

@@ -2,177 +2,175 @@
 
 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 Rubocop::TargetFinder, :isolated_environment do
+  include FileHelper
+
+  subject(:target_finder) { described_class.new(config_store, debug) }
+  let(:config_store) { Rubocop::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) { [] }
+  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
+    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) { [] }
+    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
+      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'] }
+    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
+      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'] }
+    context 'when a file is passed' do
+      let(:args) { ['dir2/file'] }
 
-        it 'picks the file' do
-          expect(found_basenames).to eq(['file'])
-        end
+      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'] }
+    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
+      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) }
+    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
+      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
+  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 ruby executable files with no extension' do
-        expect(found_basenames).to include('executable')
-      end
+    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 '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 '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 'does not pick directories' do
-        found_basenames = found_files.map { |f| File.basename(f) }
-        expect(found_basenames).not_to include('dir1')
-      end
+    it 'picks ruby executable files with no extension' do
+      expect(found_basenames).to include('executable')
+    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)
+    it 'does not pick directories' do
+      found_basenames = found_files.map { |f| File.basename(f) }
+      expect(found_basenames).not_to include('dir1')
+    end
 
-        expect(found_basenames).to include('file')
+    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)
 
-      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).to include('file')
+    end
 
-        expect(found_basenames).not_to include('ruby2.rb')
+    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)
+    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
+      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)
+    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
+        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 }
+      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
+        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 }
+      context 'and debug mode is disabled' do
+        let(:debug) { false }
 
-          it 'outputs nothing' do
-            found_files
-            expect($stderr.string).to be_empty
-          end
+        it 'outputs nothing' do
+          found_files
+          expect($stderr.string).to be_empty
         end
       end
     end