rubocop 0.11.1 → 0.12.0

data/spec/rubocop/cop/style/method_and_variable_snake_case_spec.rb

@@ -6,88 +6,96 @@ module Rubocop
   module Cop
     module Style
       describe MethodAndVariableSnakeCase do
-        let(:snake_case) { MethodAndVariableSnakeCase.new }
+        let(:cop) { described_class.new }
+        let(:highlights) { cop.offences.map { |o| o.location.source } }
 
         it 'registers an offence for camel case in instance method name' do
-          inspect_source(snake_case,
-                         ['def myMethod',
-                          '  # ...',
-                          'end',
-                         ])
-          expect(snake_case.offences.map(&:message)).to eq(
-            ['Use snake_case for methods and variables.'])
+          inspect_source(cop, ['def myMethod',
+                               '  # ...',
+                               'end'])
+          expect(cop.offences).to have(1).item
+          expect(highlights).to eq(['myMethod'])
         end
 
         it 'registers an offence for camel case in singleton method name' do
-          inspect_source(snake_case,
-                         ['def self.myMethod',
-                          '  # ...',
-                          'end',
-                         ])
-          expect(snake_case.offences.map(&:message)).to eq(
-            ['Use snake_case for methods and variables.'])
+          inspect_source(cop, ['def self.myMethod',
+                               '  # ...',
+                               'end'])
+          expect(cop.offences).to have(1).item
+          expect(highlights).to eq(['myMethod'])
         end
 
         it 'registers an offence for camel case in local variable name' do
-          inspect_source(snake_case, ['myLocal = 1'])
-          expect(snake_case.offences.map(&:message)).to eq(
-            ['Use snake_case for methods and variables.'])
+          inspect_source(cop, 'myLocal = 1')
+          expect(cop.offences).to have(1).item
+          expect(highlights).to eq(['myLocal'])
         end
 
         it 'registers an offence for camel case in instance variable name' do
-          inspect_source(snake_case, ['@myAttribute = 3'])
-          expect(snake_case.offences.map(&:message)).to eq(
-            ['Use snake_case for methods and variables.'])
+          inspect_source(cop, '@myAttribute = 3')
+          expect(cop.offences).to have(1).item
+          expect(highlights).to eq(['@myAttribute'])
         end
 
         it 'registers an offence for camel case in setter name' do
-          inspect_source(snake_case, ['self.mySetter = 2'])
-          expect(snake_case.offences.map(&:message)).to eq(
-            ['Use snake_case for methods and variables.'])
+          inspect_source(cop, 'self.mySetter = 2')
+          expect(cop.offences).to have(1).item
+          expect(highlights).to eq(['mySetter'])
         end
 
         it 'registers an offence for capitalized camel case' do
-          inspect_source(snake_case,
-                         ['def MyMethod',
-                          'end',
-                         ])
-          expect(snake_case.offences.map(&:message)).to eq(
-            ['Use snake_case for methods and variables.'])
+          inspect_source(cop, ['def MyMethod',
+                               'end'])
+          expect(cop.offences).to have(1).item
+          expect(highlights).to eq(['MyMethod'])
         end
 
         it 'accepts snake case in names' do
-          inspect_source(snake_case,
-                         ['def my_method',
-                          '  my_local_html = 1',
-                          '  self.my_setter = 2',
-                          '  @my_attribute = 3',
-                          'end',
-                         ])
-          expect(snake_case.offences.map(&:message)).to be_empty
+          inspect_source(cop, ['def my_method',
+                               '  my_local_html = 1',
+                               '  self.my_setter = 2',
+                               '  @my_attribute = 3',
+                               'end'])
+          expect(cop.offences).to be_empty
         end
 
         it 'registers an offence for mixed snake case and camel case' do
-          inspect_source(snake_case,
-                         ['def visit_Arel_Nodes_SelectStatement',
-                          'end'])
-          expect(snake_case.offences.map(&:message)).to eq(
-            ['Use snake_case for methods and variables.'])
+          inspect_source(cop, ['def visit_Arel_Nodes_SelectStatement',
+                               'end'])
+          expect(cop.offences).to have(1).item
+          expect(highlights).to eq(['visit_Arel_Nodes_SelectStatement'])
         end
 
         it 'accepts screaming snake case globals' do
-          inspect_source(snake_case, ['$MY_GLOBAL = 0'])
-          expect(snake_case.offences.map(&:message)).to be_empty
+          inspect_source(cop, '$MY_GLOBAL = 0')
+          expect(cop.offences).to be_empty
         end
 
         it 'accepts screaming snake case constants' do
-          inspect_source(snake_case, ['MY_CONSTANT = 0'])
-          expect(snake_case.offences.map(&:message)).to be_empty
+          inspect_source(cop, 'MY_CONSTANT = 0')
+          expect(cop.offences).to be_empty
         end
 
         it 'accepts assigning to camel case constant' do
-          inspect_source(snake_case,
-                         ['Paren = Struct.new :left, :right, :kind'])
-          expect(snake_case.offences.map(&:message)).to be_empty
+          inspect_source(cop, 'Paren = Struct.new :left, :right, :kind')
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts one line methods' do
+          inspect_source(cop, "def body; '' end")
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts operator definitions' do
+          inspect_source(cop, ['def +(other)',
+                               '  # ...',
+                               'end'])
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts assignment with indexing of self' do
+          inspect_source(cop, 'self[:a] = b')
+          expect(cop.offences).to be_empty
         end
       end
     end

data/spec/rubocop/cop/style/method_call_parentheses_spec.rb

@@ -6,7 +6,7 @@ module Rubocop
   module Cop
     module Style
       describe MethodCallParentheses do
-        let(:cop) { MethodCallParentheses.new }
+        let(:cop) { described_class.new }
 
         it 'registers an offence for parens in method call without args' do
           inspect_source(cop, ['top.test()'])
@@ -19,6 +19,11 @@ module Rubocop
         it 'it accepts parens in method call with args' do
           inspect_source(cop, ['top.test(a)'])
         end
+
+        it 'auto-corrects by removing unneeded braces' do
+          new_source = autocorrect_source(cop, 'test()')
+          expect(new_source).to eq('test')
+        end
       end
     end
   end

data/spec/rubocop/cop/style/nil_comparison_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe NilComparison do
+        let(:cop) { described_class.new }
+
+        it 'registers an offence for == nil' do
+          inspect_source(cop,
+                         ['x == nil'])
+          expect(cop.offences.size).to eq(1)
+        end
+
+        it 'registers an offence for === nil' do
+          inspect_source(cop,
+                         ['x === nil'])
+          expect(cop.offences.size).to eq(1)
+        end
+
+        it 'registers an offence for === nil' do
+          inspect_source(cop,
+                         ['x != nil'])
+          expect(cop.offences.size).to eq(1)
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cop/style/signal_exception_spec.rb

@@ -68,6 +68,34 @@ module Rubocop
           expect(cop.messages).to eq([SignalException::FAIL_MSG] * 2 +
                                      [SignalException::RAISE_MSG])
         end
+
+        it 'auto-corrects raise to fail when appropriate' do
+          new_source = autocorrect_source(cop,
+                                          ['begin',
+                                           '  raise',
+                                           'rescue Exception',
+                                           '  raise',
+                                           'end'])
+          expect(new_source).to eq(['begin',
+                                    '  fail',
+                                    'rescue Exception',
+                                    '  raise',
+                                    'end'].join("\n"))
+        end
+
+        it 'auto-corrects fail to raise when appropriate' do
+          new_source = autocorrect_source(cop,
+                                          ['begin',
+                                           '  fail',
+                                           'rescue Exception',
+                                           '  fail',
+                                           'end'])
+          expect(new_source).to eq(['begin',
+                                    '  fail',
+                                    'rescue Exception',
+                                    '  raise',
+                                    'end'].join("\n"))
+        end
       end
     end
   end

data/spec/rubocop/cop/style/space_after_method_name_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SpaceAfterMethodName do
+        let(:cop) { SpaceAfterMethodName.new }
+
+        it 'registers an offence for def with space before the parenthesis' do
+          inspect_source(cop,
+                         ['def func (x)',
+                          '  a',
+                          'end'])
+          expect(cop.offences).to have(1).item
+        end
+
+        it 'registers an offence for defs with space before the parenthesis' do
+          inspect_source(cop,
+                         ['def self.func (x)',
+                          '  a',
+                          'end'])
+          expect(cop.offences).to have(1).item
+        end
+
+        it 'accepts a def without arguments' do
+          inspect_source(cop,
+                         ['def func',
+                          '  a',
+                          'end'])
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts a defs without arguments' do
+          inspect_source(cop,
+                         ['def self.func',
+                          '  a',
+                          'end'])
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts a def with arguments but no parentheses' do
+          inspect_source(cop,
+                         ['def func x',
+                          '  a',
+                          'end'])
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts a defs with arguments but no parentheses' do
+          inspect_source(cop,
+                         ['def self.func x',
+                          '  a',
+                          'end'])
+          expect(cop.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/formatter/emacs_style_formatter_spec.rb

@@ -9,7 +9,7 @@ module Rubocop
       let(:formatter) { EmacsStyleFormatter.new(output) }
       let(:output) { StringIO.new }
 
-      describe '#report_file' do
+      describe '#file_finished' do
         it 'displays parsable text' do
           cop = Cop::Cop.new
           source_buffer = Parser::Source::Buffer.new('test', 1)
@@ -22,11 +22,18 @@ module Rubocop
                           Parser::Source::Range.new(source_buffer, 9, 10),
                           'message 2')
 
-          formatter.report_file('test', cop.offences)
+          formatter.file_finished('test', cop.offences)
           expect(output.string).to eq ['test:1:1: C: message 1',
                                        "test:3:6: F: message 2\n"].join("\n")
         end
       end
+
+      describe '#finished' do
+        it 'does not report summary' do
+          formatter.finished(['/path/to/file'])
+          expect(output.string).to be_empty
+        end
+      end
     end
   end
 end

data/spec/rubocop/formatter/file_list_formatter_spec.rb

@@ -9,7 +9,7 @@ module Rubocop
       let(:formatter) { FileListFormatter.new(output) }
       let(:output) { StringIO.new }
 
-      describe '#report_file' do
+      describe '#file_finished' do
         it 'displays parsable text' do
           cop = Cop::Cop.new
           source_buffer = Parser::Source::Buffer.new('test', 1)
@@ -22,8 +22,8 @@ module Rubocop
                           Parser::Source::Range.new(source_buffer, 9, 10),
                           'message 2')
 
-          formatter.report_file('test', cop.offences)
-          formatter.report_file('test_2', cop.offences)
+          formatter.file_finished('test', cop.offences)
+          formatter.file_finished('test_2', cop.offences)
           expect(output.string).to eq ['test',
                                        "test_2\n"].join("\n")
         end

data/spec/rubocop/formatter/offence_count_formatter_spec.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+require 'tempfile'
+
+module Rubocop
+  module Formatter
+    describe OffenceCountFormatter do
+      subject(:formatter) { Formatter::OffenceCountFormatter.new(output) }
+      let(:output) { StringIO.new }
+
+      let(:files) do
+        %w(lib/rubocop.rb spec/spec_helper.rb bin/rubocop).map do |path|
+          File.expand_path(path)
+        end
+      end
+
+      describe '#file_finished' do
+        before { formatter.started(files) }
+
+        let(:finish) { formatter.file_finished(files.first, offences) }
+
+        context 'when no offences are detected' do
+          let(:offences) { [] }
+          it 'shouldn\'t add to offence_counts' do
+            expect { finish }.to_not change { formatter.offence_counts }
+          end
+        end
+
+        context 'when any offences are detected' do
+          let(:offences) { [double('offence', cop_name: 'OffendedCop')] }
+          it 'should increment the count for the cop in offence_counts' do
+            expect { finish }.to change { formatter.offence_counts }
+          end
+        end
+      end
+
+      describe '#report_summary' do
+        context 'when a offence detected' do
+          let(:cop_counts) { { 'OffendedCop' => 1 } }
+          it 'shows the cop and the offence count' do
+            formatter.report_summary(1, cop_counts)
+            expect(output.string).to include(
+              "\n1  OffendedCop")
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/rubocop/formatter/progress_formatter_spec.rb

@@ -95,101 +95,87 @@ module Rubocop
         formatter.started(files)
       end
 
-      context 'when #reports_summary? is true' do
-        before { formatter.reports_summary = true }
-
-        context 'when any offences are detected' do
-          before do
-            source_buffer = Parser::Source::Buffer.new('test', 1)
-            source = 9.times.map do |index|
-              "This is line #{index + 1}."
-            end
-            source_buffer.source = source.join("\n")
-            line_length = source[0].length + "\n".length
-
-            formatter.file_started(files[0], {})
-            formatter.file_finished(files[0], [
-              Cop::Offence.new(
-                :convention,
-                Parser::Source::Range.new(source_buffer,
-                                          line_length + 2,
-                                          line_length + 3),
-                'foo',
-                'Cop'
-              )
-            ])
-
-            formatter.file_started(files[1], {})
-            formatter.file_finished(files[1], [
-            ])
-
-            formatter.file_started(files[2], {})
-            formatter.file_finished(files[2], [
-              Cop::Offence.new(
-                :error,
-                Parser::Source::Range.new(source_buffer,
-                                          4 * line_length + 1,
-                                          4 * line_length + 2),
-                'bar',
-                'Cop'
-              ),
-              Cop::Offence.new(
-                :convention,
-                Parser::Source::Range.new(source_buffer,
-                                          5 * line_length,
-                                          5 * line_length + 1),
-                'foo',
-                'Cop'
-              )
-            ])
-          end
-
-          it 'reports all detected offences for all failed files' do
-            formatter.finished(files)
-            expect(output.string).to include([
-              'Offences:',
-              '',
-              'lib/rubocop.rb:2:3: C: foo',
-              'This is line 2.',
-              '  ^',
-              'bin/rubocop:5:2: E: bar',
-              'This is line 5.',
-              ' ^',
-              'bin/rubocop:6:1: C: foo',
-              'This is line 6.',
-              '^'
-            ].join("\n"))
+      context 'when any offences are detected' do
+        before do
+          source_buffer = Parser::Source::Buffer.new('test', 1)
+          source = 9.times.map do |index|
+            "This is line #{index + 1}."
           end
+          source_buffer.source = source.join("\n")
+          line_length = source[0].length + "\n".length
+
+          formatter.file_started(files[0], {})
+          formatter.file_finished(files[0], [
+            Cop::Offence.new(
+              :convention,
+              Parser::Source::Range.new(source_buffer,
+                                        line_length + 2,
+                                        line_length + 3),
+              'foo',
+              'Cop'
+            )
+          ])
+
+          formatter.file_started(files[1], {})
+          formatter.file_finished(files[1], [
+          ])
+
+          formatter.file_started(files[2], {})
+          formatter.file_finished(files[2], [
+            Cop::Offence.new(
+              :error,
+              Parser::Source::Range.new(source_buffer,
+                                        4 * line_length + 1,
+                                        4 * line_length + 2),
+              'bar',
+              'Cop'
+            ),
+            Cop::Offence.new(
+              :convention,
+              Parser::Source::Range.new(source_buffer,
+                                        5 * line_length,
+                                        5 * line_length + 1),
+              'foo',
+              'Cop'
+            )
+          ])
         end
 
-        context 'when no offences are detected' do
-          before do
-            files.each do |file|
-              formatter.file_started(file, {})
-              formatter.file_finished(file, [])
-            end
-          end
+        it 'reports all detected offences for all failed files' do
+          formatter.finished(files)
+          expect(output.string).to include([
+            'Offences:',
+            '',
+            'lib/rubocop.rb:2:3: C: foo',
+            'This is line 2.',
+            '  ^',
+            'bin/rubocop:5:2: E: bar',
+            'This is line 5.',
+            ' ^',
+            'bin/rubocop:6:1: C: foo',
+            'This is line 6.',
+            '^'
+          ].join("\n"))
+        end
+      end
 
-          it 'does not report offences' do
-            formatter.finished(files)
-            expect(output.string).not_to include('Offences:')
+      context 'when no offences are detected' do
+        before do
+          files.each do |file|
+            formatter.file_started(file, {})
+            formatter.file_finished(file, [])
           end
         end
 
-        it 'calls #report_summary' do
-          formatter.should_receive(:report_summary)
+        it 'does not report offences' do
           formatter.finished(files)
+          expect(output.string).not_to include('Offences:')
         end
       end
 
-      context 'when #reports_summary? is false' do
-        before { formatter.reports_summary = false }
-
-        it 'reports nothing' do
-          output.string = ''
-          formatter.finished(files)
-          expect(output.string).to eq("\n")
-        end
+      it 'calls #report_summary' do
+        formatter.should_receive(:report_summary)
+        formatter.finished(files)
       end
     end
   end