rubocop 0.20.1 → 0.21.0

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

@@ -23,7 +23,7 @@ describe Rubocop::Cop::Lint::UselessElseWithoutRescue do
     it 'registers an offense' do
       expect(cop.offenses.size).to eq(1)
       expect(cop.offenses.first.message)
-        .to eq('Else without rescue is useless')
+        .to eq('`else` without `rescue` is useless.')
       expect(cop.highlights).to eq(['else'])
     end
   end

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

@@ -13,6 +13,8 @@ describe Rubocop::Cop::Lint::UselessSetterCall do
                     'end'
                    ])
     expect(cop.offenses.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Useless setter call to local variable `top`.'])
   end
 
   it 'registers an offense for defs ending with lvar attr assignment' do

data/spec/rubocop/cop/rails/delegate_spec.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Rails::Delegate do
+  subject(:cop) { described_class.new }
+
+  it 'finds trivial delegate' do
+    inspect_source(cop,
+                   ['def foo',
+                    '  bar.foo',
+                    'end'])
+    expect(cop.offenses.size).to eq(1)
+    expect(cop.offenses
+            .map(&:line).sort).to eq([1])
+    expect(cop.messages)
+      .to eq(['Use `delegate` to define delegations.'])
+    expect(cop.highlights).to eq(['def'])
+  end
+
+  it 'finds trivial delegate with arguments' do
+    inspect_source(cop,
+                   ['def foo(baz)',
+                    '  bar.foo(baz)',
+                    'end'])
+    expect(cop.offenses.size).to eq(1)
+    expect(cop.offenses
+            .map(&:line).sort).to eq([1])
+    expect(cop.messages)
+      .to eq(['Use `delegate` to define delegations.'])
+    expect(cop.highlights).to eq(['def'])
+  end
+
+  it 'finds trivial delegate with prefix' do
+    inspect_source(cop,
+                   ['def bar_foo',
+                    '  bar.foo',
+                    'end'])
+    expect(cop.offenses.size).to eq(1)
+    expect(cop.offenses
+            .map(&:line).sort).to eq([1])
+    expect(cop.messages)
+      .to eq(['Use `delegate` to define delegations.'])
+    expect(cop.highlights).to eq(['def'])
+  end
+
+  it 'ignores non trivial delegate' do
+    inspect_source(cop,
+                   ['def fox',
+                    '  bar.foo.fox',
+                    'end'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'ignores trivial delegate with mismatched arguments' do
+    inspect_source(cop,
+                   ['def fox(baz)',
+                    '  bar.fox(foo)',
+                    'end'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'ignores trivial delegate with mismatched arguments' do
+    inspect_source(cop,
+                   ['def fox(foo = nil)',
+                    '  bar.fox(foo || 5)',
+                    'end'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'ignores trivial delegate with mismatched arguments' do
+    inspect_source(cop,
+                   ['def fox(a, baz)',
+                    '  bar.fox(a)',
+                    'end'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'ignores trivial delegate with other prefix' do
+    inspect_source(cop,
+                   ['def fox_foo',
+                    '  bar.foo',
+                    'end'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'ignores methods with arguments' do
+    inspect_source(cop,
+                   ['def fox(bar)',
+                    '  bar.fox',
+                    'end'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'ignores private delegations' do
+    inspect_source(cop,
+                   ['  private def fox', # leading spaces are on purpose
+                    '    bar.fox',
+                    '  end',
+                    '  ',
+                    '    private',
+                    '  ',
+                    '  def fox',
+                    '    bar.fox',
+                    '  end'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'ignores protected delegations' do
+    inspect_source(cop,
+                   ['  protected def fox', # leading spaces are on purpose
+                    '    bar.fox',
+                    '  end',
+                    '  ',
+                    '  protected',
+                    '  ' ,
+                    '  def fox',
+                    '    bar.fox',
+                    '  end'])
+    expect(cop.offenses).to be_empty
+  end
+
+  describe '#autocorrect' do
+    context 'trivial delegation' do
+      let(:source) do
+        ['def bar',
+         '  foo.bar',
+         'end']
+      end
+
+      let(:corrected_source) { 'delegate :bar, to: :foo' }
+
+      it 'autocorrects' do
+        expect(autocorrect_source(cop, source)).to eq(corrected_source)
+      end
+    end
+
+    context 'trivial delegation with prefix' do
+      let(:source) do
+        ['def foo_bar',
+         '  foo.bar',
+         'end']
+      end
+
+      let(:corrected_source) { 'delegate :bar, to: :foo, prefix: true' }
+
+      it 'autocorrects' do
+        expect(autocorrect_source(cop, source)).to eq(corrected_source)
+      end
+    end
+  end
+end

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

@@ -2,55 +2,150 @@
 
 require 'spec_helper'
 
-describe Rubocop::Cop::Style::Encoding do
-  subject(:cop) { described_class.new }
+describe Rubocop::Cop::Style::Encoding, :config do
+  subject(:cop) { described_class.new(config) }
 
-  it 'registers an offense when no encoding present', ruby: 1.9 do
-    inspect_source(cop, ['def foo() end'])
+  context 'when_needed' do
+    let(:cop_config) do
+      { 'EnforcedStyle' => 'when_needed' }
+    end
 
-    expect(cop.messages).to eq(
-      ['Missing utf-8 encoding comment.'])
-  end
+    it 'registers no offense when no encoding present but only ASCII ' \
+       'characters', ruby: 1.9 do
+      inspect_source(cop, ['def foo() end'])
 
-  it 'accepts encoding on first line', ruby: 1.9 do
-    inspect_source(cop, ['# encoding: utf-8',
-                         'def foo() end'])
+      expect(cop.offenses).to be_empty
+    end
 
-    expect(cop.offenses).to be_empty
-  end
+    it 'registers an offense when there is no encoding present but non ' \
+       'ASCII characters', ruby: 1.9 do
+      inspect_source(cop, ['def foo() \'ä\' end'])
 
-  it 'accepts encoding on second line when shebang present', ruby: 1.9 do
-    inspect_source(cop, ['#!/usr/bin/env ruby',
-                         '# encoding: utf-8',
-                         'def foo() end'])
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.messages).to eq(
+        ['Missing utf-8 encoding comment.'])
+    end
 
-    expect(cop.messages).to be_empty
-  end
+    it 'registers an offense when encoding present but only ASCII ' \
+       'characters', ruby: 1.9 do
+      inspect_source(cop, ['# encoding: utf-8',
+                           'def foo() end'])
 
-  it 'books an offense when encoding is in the wrong place', ruby: 1.9 do
-    inspect_source(cop, ['def foo() end',
-                         '# encoding: utf-8'])
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.messages).to eq(
+        ['Unnecessary utf-8 encoding comment.'])
+    end
 
-    expect(cop.messages).to eq(
-      ['Missing utf-8 encoding comment.'])
-  end
+    it 'accepts an empty file', ruby: 1.9 do
+      inspect_source(cop, '')
 
-  it 'does not register an offense on Ruby 2.0', ruby: 2.0 do
-    inspect_source(cop, ['def foo() end'])
+      expect(cop.offenses).to be_empty
+    end
 
-    expect(cop.offenses).to be_empty
-  end
+    it 'accepts encoding on first line', ruby: 1.9 do
+      inspect_source(cop, ['# encoding: utf-8',
+                           'def foo() \'ä\' end'])
+
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'accepts encoding on second line when shebang present', ruby: 1.9 do
+      inspect_source(cop, ['#!/usr/bin/env ruby',
+                           '# encoding: utf-8',
+                           'def foo() \'ä\' end'])
 
-  it 'accepts encoding inserted by magic_encoding gem', ruby: 1.9 do
-    inspect_source(cop, ['# -*- encoding : utf-8 -*-',
-                         'def foo() end'])
+      expect(cop.messages).to be_empty
+    end
 
-    expect(cop.messages).to be_empty
+    it 'books an offense when encoding is in the wrong place', ruby: 1.9 do
+      inspect_source(cop, ['def foo() \'ä\' end',
+                           '# encoding: utf-8'])
+
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.messages).to eq(
+        ['Missing utf-8 encoding comment.'])
+    end
+
+    it 'does not register an offense on Ruby 2.0', ruby: 2.0 do
+      inspect_source(cop, ['def foo() \'ä\' end'])
+
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'accepts encoding inserted by magic_encoding gem', ruby: 1.9 do
+      inspect_source(cop, ['# -*- encoding : utf-8 -*-',
+                           'def foo() \'ä\' end'])
+
+      expect(cop.messages).to be_empty
+    end
+
+    it 'accepts vim-style encoding comments', ruby: 1.9 do
+      inspect_source(cop, ['# vim:fileencoding=utf-8',
+                           'def foo() \'ä\' end'])
+      expect(cop.messages).to be_empty
+    end
   end
 
-  it 'accepts vim-style encoding comments', ruby: 1.9 do
-    inspect_source(cop, ['# vim:fileencoding=utf-8',
-                         'def foo() end'])
-    expect(cop.messages).to be_empty
+  context 'always' do
+    let(:cop_config) do
+      { 'EnforcedStyle' => 'always' }
+    end
+
+    it 'registers an offense when no encoding present', ruby: 1.9 do
+      inspect_source(cop, ['def foo() end'])
+
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.messages).to eq(
+        ['Missing utf-8 encoding comment.'])
+    end
+
+    it 'accepts an empty file', ruby: 1.9 do
+      inspect_source(cop, '')
+
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'accepts encoding on first line', ruby: 1.9 do
+      inspect_source(cop, ['# encoding: utf-8',
+                           'def foo() end'])
+
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'accepts encoding on second line when shebang present', ruby: 1.9 do
+      inspect_source(cop, ['#!/usr/bin/env ruby',
+                           '# encoding: utf-8',
+                           'def foo() end'])
+
+      expect(cop.messages).to be_empty
+    end
+
+    it 'books an offense when encoding is in the wrong place', ruby: 1.9 do
+      inspect_source(cop, ['def foo() end',
+                           '# encoding: utf-8'])
+
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.messages).to eq(
+        ['Missing utf-8 encoding comment.'])
+    end
+
+    it 'does not register an offense on Ruby 2.0', ruby: 2.0 do
+      inspect_source(cop, ['def foo() end'])
+
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'accepts encoding inserted by magic_encoding gem', ruby: 1.9 do
+      inspect_source(cop, ['# -*- encoding : utf-8 -*-',
+                           'def foo() end'])
+
+      expect(cop.messages).to be_empty
+    end
+
+    it 'accepts vim-style encoding comments', ruby: 1.9 do
+      inspect_source(cop, ['# vim:fileencoding=utf-8',
+                           'def foo() end'])
+      expect(cop.messages).to be_empty
+    end
   end
 end

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

@@ -106,6 +106,20 @@ describe Rubocop::Cop::Style::IndentationWidth do
       expect(cop.offenses).to be_empty
     end
 
+    it 'accepts a correctly aligned if/elsif/else/end as a method argument' do
+      inspect_source(cop,
+                     ['foo(',
+                      '  if a1',
+                      '    b1',
+                      '  elsif a2',
+                      '    b2',
+                      '  else',
+                      '    c',
+                      '  end',
+                      ')'])
+      expect(cop.offenses).to be_empty
+    end
+
     it 'accepts if/elsif/else/end laid out as a table' do
       inspect_source(cop,
                      ['if    @io == $stdout then str << "$stdout"',
@@ -136,6 +150,22 @@ describe Rubocop::Cop::Style::IndentationWidth do
     context 'with assignment' do
       context 'when alignment style is variable' do
         context 'and end is aligned with variable' do
+          it 'accepts an if with end aligned with setter' do
+            inspect_source(cop,
+                           ['foo.bar = if baz',
+                            '  derp',
+                            'end'])
+            expect(cop.offenses).to be_empty
+          end
+
+          it 'accepts an if with end aligned with element assignment' do
+            inspect_source(cop,
+                           ['foo[bar] = if baz',
+                            '  derp',
+                            'end'])
+            expect(cop.offenses).to be_empty
+          end
+
           it 'accepts an if with end aligned with variable' do
             inspect_source(cop,
                            ['var = if a',
@@ -194,6 +224,24 @@ describe Rubocop::Cop::Style::IndentationWidth do
         end
 
         context 'and end is aligned with keyword' do
+          it 'registers an offense for an if with setter' do
+            inspect_source(cop,
+                           ['foo.bar = if baz',
+                            '            derp',
+                            '          end'])
+            expect(cop.messages)
+              .to eq(['Use 2 (not 12) spaces for indentation.'])
+          end
+
+          it 'registers an offense for an if with element assignment' do
+            inspect_source(cop,
+                           ['foo[bar] = if baz',
+                            '             derp',
+                            '           end'])
+            expect(cop.messages)
+              .to eq(['Use 2 (not 13) spaces for indentation.'])
+          end
+
           it 'registers an offense for an if' do
             inspect_source(cop,
                            ['var = if a',
@@ -512,6 +560,27 @@ describe Rubocop::Cop::Style::IndentationWidth do
                       'end'])
       expect(cop.offenses).to be_empty
     end
+
+    if RUBY_VERSION >= '2.1'
+      context 'when modifier and def are on the same line' do
+        it 'accepts a correctly aligned body' do
+          inspect_source(cop,
+                         ['private def test',
+                          '  something',
+                          'end'])
+          expect(cop.offenses).to be_empty
+        end
+
+        it 'registers an offense for bad indentation of a def body' do
+          inspect_source(cop,
+                         ['private def test',
+                          '          something',
+                          '        end'])
+          expect(cop.messages)
+            .to eq(['Use 2 (not 10) spaces for indentation.'])
+        end
+      end
+    end
   end
 
   context 'with class' do
@@ -602,5 +671,15 @@ describe Rubocop::Cop::Style::IndentationWidth do
                       'end'])
       expect(cop.offenses).to be_empty
     end
+
+    # The cop uses the block end/} as the base for indentation, so if it's not
+    # on its own line, all bets are off.
+    it 'accepts badly indented code if block end is not on separate line' do
+      inspect_source(cop,
+                     ['foo {',
+                      'def baz',
+                      'end }'])
+      expect(cop.offenses).to be_empty
+    end
   end
 end