rubocop 0.14.1 → 0.15.0

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

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::EmptyLinesAroundAccessModifier do
+  subject(:cop) { described_class.new }
+
+  %w(private protected public).each do |access_modifier|
+    it "requires blank line before #{access_modifier}" do
+      inspect_source(cop,
+                     ['class Test',
+                      '  something',
+                      "  #{access_modifier}",
+                      '',
+                      '  def test; end',
+                      'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(["Keep a blank line before and after #{access_modifier}."])
+    end
+
+    it 'requires blank line after #{access_modifier}' do
+      inspect_source(cop,
+                     ['class Test',
+                      '  something',
+                      '',
+                      "  #{access_modifier}",
+                      '  def test; end',
+                      'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(["Keep a blank line before and after #{access_modifier}."])
+    end
+
+    it 'accepts missing blank line when at the beginning of class/module' do
+      inspect_source(cop,
+                     ['class Test',
+                      "  #{access_modifier}",
+                      '',
+                      '  def test; end',
+                      'end'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'recognizes blank lines with DOS style line endings' do
+      inspect_source(cop,
+                     ["class Test\r",
+                      "\r",
+                      "  #{access_modifier}\r",
+                      "\r",
+                      "  def test; end\r",
+                      "end\r"])
+      expect(cop.offences.size).to eq(0)
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::EmptyLinesAroundBody do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for method body starting with a blank' do
+    inspect_source(cop,
+                   ['def some_method',
+                    '',
+                    '  do_something',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for class method body starting with a blank' do
+    inspect_source(cop,
+                   ['def Test.some_method',
+                    '',
+                    '  do_something',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for method body ending with a blank' do
+    inspect_source(cop,
+                   ['def some_method',
+                    '  do_something',
+                    '',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for class method body ending with a blank' do
+    inspect_source(cop,
+                   ['def Test.some_method',
+                    '  do_something',
+                    '',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for class body starting with a blank' do
+    inspect_source(cop,
+                   ['class SomeClass',
+                    '',
+                    '  do_something',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for module body starting with a blank' do
+    inspect_source(cop,
+                   ['module SomeModule',
+                    '',
+                    '  do_something',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for class body ending with a blank' do
+    inspect_source(cop,
+                   ['class SomeClass',
+                    '  do_something',
+                    '',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for module body ending with a blank' do
+    inspect_source(cop,
+                   ['module SomeModule',
+                    '  do_something',
+                    '',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'is not fooled by single line methods' do
+    inspect_source(cop,
+                   ['def some_method; do_something; end',
+                    '',
+                    'something_else'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -1,21 +1,30 @@
 # encoding: utf-8
 
 require 'spec_helper'
+require 'tempfile'
 
 describe Rubocop::Cop::Style::EndOfLine do
   subject(:cop) { described_class.new }
 
   it 'registers an offence for CR+LF' do
-    pending 'Fails after upgdate to parser-2.0.0.pre3.'
-    inspect_source(cop, ["x=0\r", ''])
-    expect(cop.messages).to eq(
-      ['Carriage return character detected.'])
+    inspect_source_file(cop, ['x=0', '', "y=1\r"])
+    expect(cop.messages).to eq(['Carriage return character detected.'])
+  end
+
+  it 'highlights the whole offendng line' do
+    inspect_source_file(cop, ['x=0', '', "y=1\r"])
+    expect(cop.highlights).to eq(["y=1\r"])
   end
 
   it 'registers an offence for CR at end of file' do
-    pending
-    inspect_source(cop, ["x=0\r"])
-    expect(cop.messages).to eq(
-      ['Carriage return character detected.'])
+    inspect_source_file(cop, ["x=0\r"])
+    expect(cop.messages).to eq(['Carriage return character detected.'])
+  end
+
+  context 'when there are many lines ending with CR+LF' do
+    it 'registers only one offence' do
+      inspect_source_file(cop, ['x=0', '', 'y=1'].join("\r\n"))
+      expect(cop.messages.size).to eq(1)
+    end
   end
 end

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

@@ -89,6 +89,40 @@ describe Rubocop::Cop::Style::IfUnlessModifier do
                          'end'])
     expect(cop.offences).to be_empty
   end
+
+  context 'with implicit match conditional' do
+    let(:source) do
+      [
+        "  if #{conditional}",
+        "    #{body}",
+        '  end'
+      ]
+    end
+
+    let(:body) { 'b' * 35 }
+
+    context 'when a multiline if fits on one line' do
+      let(:conditional) { "/#{'a' * 36}/" }
+
+      it 'registers an offence' do
+        expect("  #{body} if #{conditional}".length).to eq(79)
+
+        inspect_source(cop, source)
+        expect(cop.offences.size).to eq(1)
+      end
+    end
+
+    context "when a multiline if doesn't fit on one line" do
+      let(:conditional) { "/#{'a' * 37}/" }
+
+      it 'accepts' do
+        expect("  #{body} if #{conditional}".length).to eq(80)
+
+        inspect_source(cop, source)
+        expect(cop.offences).to be_empty
+      end
+    end
+  end
 end
 
 describe Rubocop::Cop::Style::WhileUntilModifier do

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

@@ -22,4 +22,9 @@ describe Rubocop::Cop::Style::FinalNewline do
     inspect_source(cop, source)
     expect(cop.offences).to be_empty
   end
+
+  it 'auto-corrects missing newline' do
+    new_source = autocorrect_source(cop, ['x = 0'])
+    expect(new_source).to eq(['x = 0', ''].join("\n"))
+  end
 end

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

@@ -6,7 +6,10 @@ describe Rubocop::Cop::Style::HashSyntax, :config do
   subject(:cop) { described_class.new(config) }
 
   context 'configured to enforce ruby19 style' do
-    let(:cop_config) { { 'EnforcedStyle' => 'ruby19' } }
+    let(:config) do
+      Rubocop::Config.new('HashSyntax' => { 'EnforcedStyle' => 'ruby19' },
+                          'SpaceAroundOperators' => { 'Enabled' => true })
+    end
 
     it 'registers offence for hash rocket syntax when new is possible' do
       inspect_source(cop, ['x = { :a => 0 }'])
@@ -62,9 +65,26 @@ describe Rubocop::Cop::Style::HashSyntax, :config do
       new_source = autocorrect_source(cop, '{ :a => 1, :b   =>  2}')
       expect(new_source).to eq('{ a: 1, b: 2}')
     end
+
+    it 'does not auto-correct if it interferes with SpaceAroundOperators' do
+      new_source = autocorrect_source(cop, '{ :a=>1, :b=>2 }')
+      expect(new_source).to eq('{ :a=>1, :b=>2 }')
+    end
+
+    context 'with SpaceAroundOperators disabled' do
+      let(:config) do
+        Rubocop::Config.new('HashSyntax' => { 'EnforcedStyle' => 'ruby19' },
+                            'SpaceAroundOperators' => { 'Enabled' => false })
+      end
+
+      it 'auto-corrects even if there is no space around =>' do
+        new_source = autocorrect_source(cop, '{ :a=>1, :b=>2 }')
+        expect(new_source).to eq('{ a: 1, b: 2 }')
+      end
+    end
   end
 
-  context 'configured to enforce ruby19 style' do
+  context 'configured to enforce hash rockets style' do
     let(:cop_config) { { 'EnforcedStyle' => 'hash_rockets' } }
 
     it 'registers offence for Ruby 1.9 style' do

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

@@ -56,4 +56,9 @@ describe Rubocop::Cop::Style::LeadingCommentSpace do
 
     expect(cop.offences).to be_empty
   end
+
+  it 'auto-corrects missing space' do
+    new_source = autocorrect_source(cop, '#comment')
+    expect(new_source).to eq('# comment')
+  end
 end

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

@@ -2,23 +2,58 @@
 
 require 'spec_helper'
 
-describe Rubocop::Cop::Style::MethodCallParentheses do
-  subject(:cop) { described_class.new }
+describe Rubocop::Cop::Style::MethodCallParentheses, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:config) do
+    Rubocop::Config.new('EmptyLiteral' => { 'Enabled' => true })
+  end
 
   it 'registers an offence for parens in method call without args' do
     inspect_source(cop, ['top.test()'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts parentheses for methods starting with an upcase letter' do
+    inspect_source(cop, ['Test()'])
+    expect(cop.offences).to be_empty
   end
 
-  it 'it accepts no parens in method call without args' do
+  it 'accepts no parens in method call without args' do
     inspect_source(cop, ['top.test'])
+    expect(cop.offences).to be_empty
   end
 
-  it 'it accepts parens in method call with args' do
+  it 'accepts parens in method call with args' do
     inspect_source(cop, ['top.test(a)'])
+    expect(cop.offences).to be_empty
   end
 
   it 'auto-corrects by removing unneeded braces' do
     new_source = autocorrect_source(cop, 'test()')
     expect(new_source).to eq('test')
   end
+
+  it 'does not auto-correct calls that will be changed to empty literals' do
+    original = ['Hash.new()',
+                'Array.new()',
+                'String.new()']
+    new_source = autocorrect_source(cop, original)
+    expect(new_source).to eq(original.join("\n"))
+  end
+
+  context 'when EmptyLiteral is disabled' do
+    let(:config) do
+      Rubocop::Config.new('EmptyLiteral' => { 'Enabled' => false })
+    end
+
+    it 'auto-corrects calls that could be empty literals' do
+      original = ['Hash.new()',
+                  'Array.new()',
+                  'String.new()']
+      new_source = autocorrect_source(cop, original)
+      expect(new_source).to eq(['Hash.new',
+                                'Array.new',
+                                'String.new'].join("\n"))
+    end
+  end
 end

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

@@ -27,6 +27,11 @@ describe Rubocop::Cop::Style::NumericLiterals, :config do
     expect(cop.messages).to be_empty
   end
 
+  it 'does not count a leading minus sign as a digit' do
+    inspect_source(cop, ['a = -1230'])
+    expect(cop.messages).to be_empty
+  end
+
   it 'accepts short numbers without underscore' do
     inspect_source(cop, ['a = 123',
                          'b = 123.456'])

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

@@ -66,6 +66,17 @@ describe Rubocop::Cop::Style::SignalException, :config do
         .to eq(['Use `raise` instead of `fail` to rethrow exceptions.'])
     end
 
+    it 'registers only offence for one raise that should be fail' do
+      # This is a special case that has caused double reporting.
+      inspect_source(cop,
+                     ['map do',
+                      "  raise 'I'",
+                      'end.flatten.compact'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(['Use `fail` instead of `raise` to signal exceptions.'])
+    end
+
     it 'accepts raise in def rescue section' do
       inspect_source(cop,
                      ['def test',

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

@@ -6,6 +6,8 @@ describe Rubocop::Cop::Style::SpaceAfterColon do
   subject(:cop) { described_class.new }
 
   it 'registers an offence for colon without space after it' do
+    # TODO: There is double reporting of the last colon (also from
+    # SpaceAroundOperators).
     inspect_source(cop, ['x = w ? {a:3}:4'])
     expect(cop.messages).to eq(
       ['Space missing after colon.'] * 2)
@@ -20,4 +22,9 @@ describe Rubocop::Cop::Style::SpaceAfterColon do
     inspect_source(cop, ["str << ':'"])
     expect(cop.messages).to be_empty
   end
+
+  it 'auto-corrects missing space' do
+    new_source = autocorrect_source(cop, 'x = w ? {a:3}:4')
+    expect(new_source).to eq('x = w ? {a: 3}: 4')
+  end
 end

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

@@ -22,4 +22,9 @@ describe Rubocop::Cop::Style::SpaceAfterComma do
     expect(cop.messages).to eq(
       ['Space missing after comma.'])
   end
+
+  it 'auto-corrects missing space' do
+    new_source = autocorrect_source(cop, 'each { |s,t| a(1,formats[0,1])}')
+    expect(new_source).to eq('each { |s, t| a(1, formats[0, 1])}')
+  end
 end

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

@@ -45,14 +45,6 @@ describe Rubocop::Cop::Style::SpaceAfterControlKeyword do
     expect(cop.offences.map(&:line)).to eq([1, 2])
   end
 
-  it 'registers an offence for case and when' do
-    inspect_source(cop,
-                   ['case(a)',
-                    'when(0) then 1',
-                    'end'])
-    expect(cop.offences.map(&:line)).to eq([1, 2])
-  end
-
   it 'registers an offence for while and until' do
     inspect_source(cop,
                    ['while(a)',
@@ -60,4 +52,33 @@ describe Rubocop::Cop::Style::SpaceAfterControlKeyword do
                     'end'])
     expect(cop.offences.map(&:line)).to eq([1, 2])
   end
+
+  it 'auto-corrects missing space' do
+    new_source = autocorrect_source(cop, ['if(test) then result end',
+                                          'action unless(test)',
+                                          'if(a)',
+                                          'elsif(b)',
+                                          '  unless(c)',
+                                          '  end',
+                                          'end',
+                                          'case(a)',
+                                          'when(0) then 1',
+                                          'end',
+                                          'while(a)',
+                                          '  b until(c)',
+                                          'end'])
+    expect(new_source).to eq(['if (test) then result end',
+                              'action unless (test)',
+                              'if (a)',
+                              'elsif (b)',
+                              '  unless (c)',
+                              '  end',
+                              'end',
+                              'case (a)',
+                              'when (0) then 1',
+                              'end',
+                              'while (a)',
+                              '  b until (c)',
+                              'end'].join("\n"))
+  end
 end