rubocop 0.20.1 → 0.21.0

data/spec/rubocop/cop/lint/end_alignment_spec.rb

@@ -15,8 +15,9 @@ describe Rubocop::Cop::Lint::EndAlignment, :config do
       inspect_source(cop, ["#{prefix}#{alignment_base} #{arg}",
                            end_kw])
       expect(cop.offenses.size).to eq(1)
-      expect(cop.messages.first)
-        .to match(/end at 2, \d+ is not aligned with #{alignment_base} at 1,/)
+      expect(cop.messages.first).to match(
+        /`end` at 2, \d+ is not aligned with `#{alignment_base}` at 1,/
+      )
       expect(cop.highlights.first).to eq('end')
       expect(cop.config_to_allow_offenses).to eq('AlignWith' => opposite)
     end
@@ -88,7 +89,7 @@ describe Rubocop::Cop::Lint::EndAlignment, :config do
                          'end'])
     expect(cop.offenses.size).to eq(1)
     expect(cop.messages.first)
-      .to eq('end at 6, 0 is not aligned with if at 4, 4')
+      .to eq('`end` at 6, 0 is not aligned with `if` at 4, 4')
     expect(cop.highlights.first).to eq('end')
     expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
   end
@@ -130,6 +131,8 @@ describe Rubocop::Cop::Lint::EndAlignment, :config do
       include_examples 'aligned', 'var ||= if', 'test', 'end'
       include_examples 'aligned', 'var &&= if', 'test', 'end'
       include_examples 'aligned', 'var += if',  'test', 'end'
+      include_examples 'aligned', 'h[k] = if',  'test', 'end'
+      include_examples 'aligned', 'h.k = if',   'test', 'end'
     end
   end
 end

data/spec/rubocop/cop/lint/invalid_character_literal_spec.rb

@@ -16,18 +16,19 @@ describe Rubocop::Cop::Lint::InvalidCharacterLiteral do
   #
   # https://github.com/ruby/ruby/blob/v2_1_0/parse.y#L7276
   # https://github.com/whitequark/parser/blob/v2.1.2/lib/parser/lexer.rl#L1660
-  context 'with a non-escaped whitespace character literal ' do
+  context 'with a non-escaped whitespace character literal' do
     let(:source) { 'p(? )' }
 
     it 'registers an offense' do
-      pending 'Is there a way to emit this warning without syntax errors?'
+      pending 'Is there a way to emit this warning without syntax errors?' do
 
-      inspect_source(cop, source)
+        inspect_source(cop, source)
 
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.offenses.first.message)
+        expect(cop.offenses.size).to eq(1)
+        expect(cop.offenses.first.message)
         .to eq('Invalid character literal; use ?\s')
-      expect(cop.highlights).to eq([' '])
+        expect(cop.highlights).to eq([' '])
+      end
     end
   end
 end

data/spec/rubocop/cop/lint/rescue_exception_spec.rb

@@ -120,4 +120,40 @@ describe Rubocop::Cop::Lint::RescueException do
                     'end'])
     expect(cop.offenses).to be_empty
   end
+
+  context 'without exception capture' do
+    let(:source) do
+      ['begin',
+       'rescue Exception',
+       'end']
+    end
+
+    let(:corrected_source) do
+      ['begin', # rubocop:disable WordArray
+       'rescue',
+       'end'].join("\n")
+    end
+
+    it 'autocorrects by unspecifying the exception class' do
+      expect(autocorrect_source(cop, source)).to eq(corrected_source)
+    end
+  end
+
+  context 'with exception capture' do
+    let(:source) do
+      ['begin',
+       'rescue Exception => e',
+       'end']
+    end
+
+    let(:corrected_source) do
+      ['begin',
+       'rescue => e',
+       'end'].join("\n")
+    end
+
+    it 'autocorrects by unspecifying the exception class' do
+      expect(autocorrect_source(cop, source)).to eq(corrected_source)
+    end
+  end
 end

data/spec/rubocop/cop/lint/shadowing_outer_local_variable_spec.rb

@@ -22,7 +22,7 @@ describe Rubocop::Cop::Lint::ShadowingOuterLocalVariable do
       inspect_source(cop, source)
       expect(cop.offenses.size).to eq(1)
       expect(cop.offenses.first.message)
-        .to include('Shadowing outer local variable - `foo`')
+        .to eq('Shadowing outer local variable - `foo`.')
       expect(cop.offenses.first.line).to eq(4)
     end
 
@@ -46,7 +46,7 @@ describe Rubocop::Cop::Lint::ShadowingOuterLocalVariable do
       inspect_source(cop, source)
       expect(cop.offenses.size).to eq(1)
       expect(cop.offenses.first.message)
-        .to include('Shadowing outer local variable - `foo`')
+        .to eq('Shadowing outer local variable - `foo`.')
       expect(cop.offenses.first.line).to eq(4)
     end
 
@@ -72,7 +72,7 @@ describe Rubocop::Cop::Lint::ShadowingOuterLocalVariable do
       inspect_source(cop, source)
       expect(cop.offenses.size).to eq(1)
       expect(cop.offenses.first.message)
-        .to include('Shadowing outer local variable - `foo`')
+        .to eq('Shadowing outer local variable - `foo`.')
       expect(cop.offenses.first.line).to eq(4)
     end
 
@@ -97,7 +97,7 @@ describe Rubocop::Cop::Lint::ShadowingOuterLocalVariable do
       inspect_source(cop, source)
       expect(cop.offenses.size).to eq(1)
       expect(cop.offenses.first.message)
-        .to include('Shadowing outer local variable - `foo`')
+        .to eq('Shadowing outer local variable - `foo`.')
       expect(cop.offenses.first.line).to eq(4)
     end
 

data/spec/rubocop/cop/lint/underscore_prefixed_variable_name_spec.rb

@@ -0,0 +1,179 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Lint::UnderscorePrefixedVariableName do
+  subject(:cop) { described_class.new }
+
+  before do
+    inspect_source(cop, source)
+  end
+
+  context 'when an underscore-prefixed variable is used' do
+    let(:source) { <<-END }
+      def some_method
+        _foo = 1
+        puts _foo
+      end
+    END
+
+    it 'registers an offense' do
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.offenses.first.message)
+        .to eq('Do not use prefix `_` for a variable that is used.')
+      expect(cop.offenses.first.severity.name).to eq(:warning)
+      expect(cop.offenses.first.line).to eq(2)
+      expect(cop.highlights).to eq(['_foo'])
+    end
+  end
+
+  context 'when non-underscore-prefixed variable is used' do
+    let(:source) { <<-END }
+      def some_method
+        foo = 1
+        puts foo
+      end
+    END
+
+    it 'accepts' do
+      expect(cop.offenses).to be_empty
+    end
+  end
+
+  context 'when an underscore-prefixed variable is reassigned' do
+    let(:source) { <<-END }
+      def some_method
+        _foo = 1
+        _foo = 2
+      end
+    END
+
+    it 'accepts' do
+      expect(cop.offenses).to be_empty
+    end
+  end
+
+  context 'when an underscore-prefixed method argument is used' do
+    let(:source) { <<-END }
+      def some_method(_foo)
+        puts _foo
+      end
+    END
+
+    it 'registers an offense' do
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.offenses.first.line).to eq(1)
+      expect(cop.highlights).to eq(['_foo'])
+    end
+  end
+
+  context 'when an underscore-prefixed block argument is used' do
+    let(:source) { <<-END }
+      1.times do |_foo|
+        puts _foo
+      end
+    END
+
+    it 'registers an offense' do
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.offenses.first.line).to eq(1)
+      expect(cop.highlights).to eq(['_foo'])
+    end
+  end
+
+  context 'when an underscore-prefixed variable in top-level scope is used' do
+    let(:source) { <<-END }
+      _foo = 1
+      puts _foo
+    END
+
+    it 'registers an offense' do
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.offenses.first.line).to eq(1)
+      expect(cop.highlights).to eq(['_foo'])
+    end
+  end
+
+  context 'when an underscore-prefixed variable is captured by a block' do
+    let(:source) { <<-END }
+      _foo = 1
+      1.times do
+        _foo = 2
+      end
+    END
+
+    it 'accepts' do
+      expect(cop.offenses).to be_empty
+    end
+  end
+
+  context 'when an underscore-prefixed named capture variable is used' do
+    let(:source) { <<-END }
+      /(?<_foo>\\w+)/ =~ 'FOO'
+      puts _foo
+    END
+
+    it 'registers an offense' do
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.offenses.first.line).to eq(1)
+      expect(cop.highlights).to eq(['/(?<_foo>\\w+)/'])
+    end
+  end
+
+  context 'in a method calling `super` without arguments' do
+    context 'when an underscore-prefixed argument is not used explicitly' do
+      let(:source) { <<-END }
+        def some_method(*_)
+          super
+        end
+      END
+
+      it 'accepts' do
+        expect(cop.offenses).to be_empty
+      end
+    end
+
+    context 'when an underscore-prefixed argument is used explicitly' do
+      let(:source) { <<-END }
+        def some_method(*_)
+          super
+          puts _
+        end
+      END
+
+      it 'registers an offense' do
+        expect(cop.offenses.size).to eq(1)
+        expect(cop.offenses.first.line).to eq(1)
+        expect(cop.highlights).to eq(['_'])
+      end
+    end
+  end
+
+  context 'in a method calling `super` with arguments' do
+    context 'when an underscore-prefixed argument is not used' do
+      let(:source) { <<-END }
+        def some_method(*_)
+          super(:something)
+        end
+      END
+
+      it 'accepts' do
+        expect(cop.offenses).to be_empty
+      end
+    end
+
+    context 'when an underscore-prefixed argument is used explicitly' do
+      let(:source) { <<-END }
+        def some_method(*_)
+          super(*_)
+        end
+      END
+
+      it 'registers an offense' do
+        expect(cop.offenses.size).to eq(1)
+        expect(cop.offenses.first.line).to eq(1)
+        expect(cop.highlights).to eq(['_'])
+      end
+    end
+  end
+end

data/spec/rubocop/cop/lint/unused_block_argument_spec.rb

@@ -0,0 +1,147 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Lint::UnusedBlockArgument do
+  subject(:cop) { described_class.new }
+
+  before do
+    inspect_source(cop, source)
+  end
+
+  context 'when a block takes multiple arguments' do
+    context 'and an argument is unused' do
+      let(:source) { <<-END }
+        hash = { foo: 'FOO', bar: 'BAR' }
+        hash.each do |key, value|
+          puts key
+        end
+      END
+
+      it 'registers an offense' do
+        expect(cop.offenses.size).to eq(1)
+        expect(cop.offenses.first.message).to eq(
+          'Unused block argument - `value`. ' \
+          "If it's necessary, use `_` or `_value` as an argument name " \
+          "to indicate that it won't be used."
+        )
+        expect(cop.offenses.first.severity.name).to eq(:warning)
+        expect(cop.offenses.first.line).to eq(2)
+        expect(cop.highlights).to eq(['value'])
+      end
+    end
+
+    context 'and all the arguments are unused' do
+      let(:source) { <<-END }
+        hash = { foo: 'FOO', bar: 'BAR' }
+        hash.each do |key, value|
+          puts :something
+        end
+      END
+
+      it 'registers offenses and suggests omitting them' do
+        expect(cop.offenses.size).to eq(2)
+        expect(cop.offenses.first.message).to eq(
+          'Unused block argument - `key`. ' \
+          "You can omit all the arguments if you don't care about them."
+        )
+        expect(cop.offenses.first.line).to eq(2)
+        expect(cop.highlights).to eq(%w(key value))
+      end
+    end
+  end
+
+  context 'when a block takes single argument' do
+    context 'and the argument is unused' do
+      let(:source) { <<-END }
+        1.times do |index|
+          puts :something
+        end
+      END
+
+      it 'registers an offense and suggests omitting that' do
+        expect(cop.offenses.size).to eq(1)
+        expect(cop.offenses.first.message).to eq(
+          'Unused block argument - `index`. ' \
+          "You can omit the argument if you don't care about it."
+        )
+        expect(cop.offenses.first.line).to eq(1)
+        expect(cop.highlights).to eq(['index'])
+      end
+    end
+  end
+
+  context 'when a lambda block takes arguments' do
+    context 'and all the arguments are unused' do
+      let(:source) { <<-END }
+        -> (foo, bar) { do_something }
+      END
+
+      it 'registers offenses and suggests using a proc' do
+        expect(cop.offenses.size).to eq(2)
+        expect(cop.offenses.first.message).to eq(
+          'Unused block argument - `foo`. ' \
+          "If it's necessary, use `_` or `_foo` as an argument name " \
+          "to indicate that it won't be used. " \
+          'Also consider using a proc without arguments instead of a lambda ' \
+          "if you want it to accept any arguments but don't care about them."
+
+        )
+        expect(cop.offenses.first.line).to eq(1)
+        expect(cop.highlights).to eq(%w(foo bar))
+      end
+    end
+
+    context 'and an arguments is unused' do
+      let(:source) { <<-END }
+        -> (foo, bar) { puts bar }
+      END
+
+      it 'registers an offense' do
+        expect(cop.offenses.size).to eq(1)
+        expect(cop.offenses.first.message).to eq(
+          'Unused block argument - `foo`. ' \
+          "If it's necessary, use `_` or `_foo` as an argument name " \
+          "to indicate that it won't be used."
+        )
+        expect(cop.offenses.first.line).to eq(1)
+        expect(cop.highlights).to eq(['foo'])
+      end
+    end
+  end
+
+  context 'when an underscore-prefixed block argument is not used' do
+    let(:source) { <<-END }
+      1.times do |_index|
+        puts 'foo'
+      end
+    END
+
+    it 'accepts' do
+      expect(cop.offenses).to be_empty
+    end
+  end
+
+  context 'when a method argument is not used' do
+    let(:source) { <<-END }
+      def some_method(foo)
+      end
+    END
+
+    it 'does not care' do
+      expect(cop.offenses).to be_empty
+    end
+  end
+
+  context 'when a variable is not used' do
+    let(:source) { <<-END }
+      1.times do
+        foo = 1
+      end
+    END
+
+    it 'does not care' do
+      expect(cop.offenses).to be_empty
+    end
+  end
+end