rubocop 0.13.1 → 0.14.0

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

@@ -2,127 +2,126 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe EmptyLineBetweenDefs, :config do
-        subject(:empty_lines) { EmptyLineBetweenDefs.new(config) }
-        let(:cop_config) { { 'AllowAdjacentOneLineDefs' => false } }
+describe Rubocop::Cop::Style::EmptyLineBetweenDefs, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'AllowAdjacentOneLineDefs' => false } }
 
-        it 'finds offences in inner classes' do
-          inspect_source(empty_lines, ['class K',
-                                       '  def m',
-                                       '  end',
-                                       '  class J',
-                                       '    def n',
-                                       '    end',
-                                       '    def o',
-                                       '    end',
-                                       '  end',
-                                       '  # checks something',
-                                       '  def p',
-                                       '  end',
-                                       'end'])
-          expect(empty_lines.offences.size).to eq(1)
-          expect(empty_lines.offences.map(&:line).sort).to eq([7])
-        end
+  it 'finds offences in inner classes' do
+    source = ['class K',
+              '  def m',
+              '  end',
+              '  class J',
+              '    def n',
+              '    end',
+              '    def o',
+              '    end',
+              '  end',
+              '  # checks something',
+              '  def p',
+              '  end',
+              'end']
+    inspect_source(cop, source)
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences.map(&:line).sort).to eq([7])
+  end
 
-        # Only one def, so rule about empty line *between* defs does not
-        # apply.
-        it 'accepts a def that follows a line with code' do
-          inspect_source(empty_lines, ['x = 0',
-                                       'def m',
-                                       'end'])
-          expect(empty_lines.offences).to be_empty
-        end
+  # Only one def, so rule about empty line *between* defs does not
+  # apply.
+  it 'accepts a def that follows a line with code' do
+    source = ['x = 0',
+              'def m',
+              'end']
+    inspect_source(cop, source)
+    expect(cop.offences).to be_empty
+  end
 
-        # Only one def, so rule about empty line *between* defs does not
-        # apply.
-        it 'accepts a def that follows code and a comment' do
-          inspect_source(empty_lines, ['  x = 0',
-                                       '  # 123',
-                                       '  def m',
-                                       '  end'])
-          expect(empty_lines.offences).to be_empty
-        end
+  # Only one def, so rule about empty line *between* defs does not
+  # apply.
+  it 'accepts a def that follows code and a comment' do
+    source = ['  x = 0',
+              '  # 123',
+              '  def m',
+              '  end']
+    inspect_source(cop, source)
+    expect(cop.offences).to be_empty
+  end
 
-        it 'accepts the first def without leading empty line in a class' do
-          inspect_source(empty_lines, ['class K',
-                                       '  def m',
-                                       '  end',
-                                       'end'])
-          expect(empty_lines.offences).to be_empty
-        end
+  it 'accepts the first def without leading empty line in a class' do
+    source = ['class K',
+              '  def m',
+              '  end',
+              'end']
+    inspect_source(cop, source)
+    expect(cop.offences).to be_empty
+  end
 
-        it 'accepts a def that follows an empty line and then a comment' do
-          inspect_source(empty_lines, ['class A',
-                                       '  # calculates value',
-                                       '  def m',
-                                       '  end',
-                                       '',
-                                       '  private',
-                                       '  # calculates size',
-                                       '  def n',
-                                       '  end',
-                                       'end',
-                                      ])
-          expect(empty_lines.offences).to be_empty
-        end
+  it 'accepts a def that follows an empty line and then a comment' do
+    source = ['class A',
+              '  # calculates value',
+              '  def m',
+              '  end',
+              '',
+              '  private',
+              '  # calculates size',
+              '  def n',
+              '  end',
+              'end',
+             ]
+    inspect_source(cop, source)
+    expect(cop.offences).to be_empty
+  end
 
-        it 'accepts a def that is the first of a module' do
-          source = ['module Util',
-                    '  public',
-                    '  #',
-                    '  def html_escape(s)',
-                    '  end',
-                    'end',
-                   ]
-          inspect_source(empty_lines, source)
-          expect(empty_lines.messages).to be_empty
-        end
+  it 'accepts a def that is the first of a module' do
+    source = ['module Util',
+              '  public',
+              '  #',
+              '  def html_escape(s)',
+              '  end',
+              'end',
+             ]
+    inspect_source(cop, source)
+    expect(cop.messages).to be_empty
+  end
 
-        it 'accepts a nested def' do
-          source = ['def mock_model(*attributes)',
-                    '  Class.new do',
-                    '    def initialize(attrs)',
-                    '    end',
-                    '  end',
-                    'end',
-                   ]
-          inspect_source(empty_lines, source)
-          expect(empty_lines.messages).to be_empty
-        end
+  it 'accepts a nested def' do
+    source = ['def mock_model(*attributes)',
+              '  Class.new do',
+              '    def initialize(attrs)',
+              '    end',
+              '  end',
+              'end',
+             ]
+    inspect_source(cop, source)
+    expect(cop.messages).to be_empty
+  end
 
-        it 'registers an offence for adjacent one-liners by default' do
-          source = ['def a; end',
-                    'def b; end']
-          inspect_source(empty_lines, source)
-          expect(empty_lines.offences).to have(1).item
-        end
+  it 'registers an offence for adjacent one-liners by default' do
+    source = ['def a; end',
+              'def b; end']
+    inspect_source(cop, source)
+    expect(cop.offences).to have(1).item
+  end
 
-        context 'when AllowAdjacentOneLineDefs is enabled' do
-          let(:cop_config) { { 'AllowAdjacentOneLineDefs' => true } }
+  context 'when AllowAdjacentOneLineDefs is enabled' do
+    let(:cop_config) { { 'AllowAdjacentOneLineDefs' => true } }
 
-          it 'accepts adjacent one-liners' do
-            source = ['def a; end',
-                      'def b; end']
-            inspect_source(empty_lines, source)
-            expect(empty_lines.offences).to be_empty
-          end
+    it 'accepts adjacent one-liners' do
+      source = ['def a; end',
+                'def b; end']
+      inspect_source(cop, source)
+      expect(cop.offences).to be_empty
+    end
 
-          it 'registers an offence for adjacent defs if some are multi-line' do
-            source = ['def a; end',
-                      'def b; end',
-                      'def c', # Not a one-liner, so this is an offence.
-                      'end',
-                      # Also an offence since previous was multi-line:
-                      'def d; end'
-                     ]
-            inspect_source(empty_lines, source)
-            expect(empty_lines.offences.map(&:line)).to eq([3, 5])
-          end
-        end
-      end
+    it 'registers an offence for adjacent defs if some are multi-line' do
+      source = ['def a; end',
+                'def b; end',
+                'def c', # Not a one-liner, so this is an offence.
+                'end',
+                # Also an offence since previous was multi-line:
+                'def d; end'
+               ]
+      inspect_source(cop, source)
+      expect(cop.offences.map(&:line)).to eq([3, 5])
     end
   end
 end

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

@@ -2,39 +2,33 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe EmptyLines do
-        subject(:empty_lines) { EmptyLines.new }
-
-        it 'registers an offence for consecutive empty lines' do
-          inspect_source(empty_lines,
-                         ['test = 5', '', '', '', 'top'])
-          expect(empty_lines.offences.size).to eq(2)
-        end
-
-        it 'works when there are no tokens' do
-          inspect_source(empty_lines,
-                         ['#comment'])
-          expect(empty_lines.offences).to be_empty
-        end
-
-        it 'handles comments' do
-          inspect_source(empty_lines,
-                         ['test', '', '#comment', 'top'])
-          expect(empty_lines.offences).to be_empty
-        end
-
-        it 'does not register an offence for empty lines in a string' do
-          inspect_source(empty_lines, ['result = "test
-
-
-
-                                        string"'])
-          expect(empty_lines.offences).to be_empty
-        end
-      end
-    end
+describe Rubocop::Cop::Style::EmptyLines do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for consecutive empty lines' do
+    inspect_source(cop,
+                   ['test = 5', '', '', '', 'top'])
+    expect(cop.offences.size).to eq(2)
+  end
+
+  it 'works when there are no tokens' do
+    inspect_source(cop,
+                   ['#comment'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'handles comments' do
+    inspect_source(cop,
+                   ['test', '', '#comment', 'top'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for empty lines in a string' do
+    inspect_source(cop, ['result = "test
+
+
+
+                                  string"'])
+    expect(cop.offences).to be_empty
   end
 end

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

@@ -2,105 +2,99 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe EmptyLiteral do
-        subject(:cop) { described_class.new }
+describe Rubocop::Cop::Style::EmptyLiteral do
+  subject(:cop) { described_class.new }
 
-        describe 'Empty Array' do
-          it 'registers an offence for Array.new()' do
-            inspect_source(cop,
-                           ['test = Array.new()'])
-            expect(cop.offences.size).to eq(1)
-            expect(cop.messages)
-              .to eq([EmptyLiteral::ARR_MSG])
-          end
+  describe 'Empty Array' do
+    it 'registers an offence for Array.new()' do
+      inspect_source(cop,
+                     ['test = Array.new()'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(['Use array literal [] instead of Array.new.'])
+    end
 
-          it 'registers an offence for Array.new' do
-            inspect_source(cop,
-                           ['test = Array.new'])
-            expect(cop.offences.size).to eq(1)
-            expect(cop.messages)
-              .to eq([EmptyLiteral::ARR_MSG])
-          end
+    it 'registers an offence for Array.new' do
+      inspect_source(cop,
+                     ['test = Array.new'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(['Use array literal [] instead of Array.new.'])
+    end
 
-          it 'does not register an offence for Array.new(3)' do
-            inspect_source(cop,
-                           ['test = Array.new(3)'])
-            expect(cop.offences).to be_empty
-          end
+    it 'does not register an offence for Array.new(3)' do
+      inspect_source(cop,
+                     ['test = Array.new(3)'])
+      expect(cop.offences).to be_empty
+    end
 
-          it 'auto-corrects Array.new to []' do
-            new_source = autocorrect_source(cop, 'test = Array.new')
-            expect(new_source).to eq('test = []')
-          end
-        end
+    it 'auto-corrects Array.new to []' do
+      new_source = autocorrect_source(cop, 'test = Array.new')
+      expect(new_source).to eq('test = []')
+    end
+  end
 
-        describe 'Empty Hash' do
-          it 'registers an offence for Hash.new()' do
-            inspect_source(cop,
-                           ['test = Hash.new()'])
-            expect(cop.offences.size).to eq(1)
-            expect(cop.messages)
-              .to eq([EmptyLiteral::HASH_MSG])
-          end
+  describe 'Empty Hash' do
+    it 'registers an offence for Hash.new()' do
+      inspect_source(cop,
+                     ['test = Hash.new()'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(['Use hash literal {} instead of Hash.new.'])
+    end
 
-          it 'registers an offence for Hash.new' do
-            inspect_source(cop,
-                           ['test = Hash.new'])
-            expect(cop.offences.size).to eq(1)
-            expect(cop.messages)
-              .to eq([EmptyLiteral::HASH_MSG])
-          end
+    it 'registers an offence for Hash.new' do
+      inspect_source(cop,
+                     ['test = Hash.new'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(['Use hash literal {} instead of Hash.new.'])
+    end
 
-          it 'does not register an offence for Hash.new(3)' do
-            inspect_source(cop,
-                           ['test = Hash.new(3)'])
-            expect(cop.offences).to be_empty
-          end
+    it 'does not register an offence for Hash.new(3)' do
+      inspect_source(cop,
+                     ['test = Hash.new(3)'])
+      expect(cop.offences).to be_empty
+    end
 
-          it 'does not register an offence for Hash.new { block }' do
-            inspect_source(cop,
-                           ['test = Hash.new { block }'])
-            expect(cop.offences).to be_empty
-          end
+    it 'does not register an offence for Hash.new { block }' do
+      inspect_source(cop,
+                     ['test = Hash.new { block }'])
+      expect(cop.offences).to be_empty
+    end
 
-          it 'auto-corrects Hash.new to {}' do
-            new_source = autocorrect_source(cop, 'test = Hash.new')
-            expect(new_source).to eq('test = {}')
-          end
-        end
+    it 'auto-corrects Hash.new to {}' do
+      new_source = autocorrect_source(cop, 'test = Hash.new')
+      expect(new_source).to eq('test = {}')
+    end
+  end
 
-        describe 'Empty String' do
-          it 'registers an offence for String.new()' do
-            inspect_source(cop,
-                           ['test = String.new()'])
-            expect(cop.offences.size).to eq(1)
-            expect(cop.messages)
-              .to eq([EmptyLiteral::STR_MSG])
-          end
+  describe 'Empty String' do
+    it 'registers an offence for String.new()' do
+      inspect_source(cop,
+                     ['test = String.new()'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(["Use string literal '' instead of String.new."])
+    end
 
-          it 'registers an offence for String.new' do
-            inspect_source(cop,
-                           ['test = String.new'])
-            expect(cop.offences.size).to eq(1)
-            expect(cop.messages)
-              .to eq([EmptyLiteral::STR_MSG])
-          end
+    it 'registers an offence for String.new' do
+      inspect_source(cop,
+                     ['test = String.new'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(["Use string literal '' instead of String.new."])
+    end
 
-          it 'does not register an offence for String.new("top")' do
-            inspect_source(cop,
-                           ['test = String.new("top")'])
-            expect(cop.offences).to be_empty
-          end
+    it 'does not register an offence for String.new("top")' do
+      inspect_source(cop,
+                     ['test = String.new("top")'])
+      expect(cop.offences).to be_empty
+    end
 
-          it 'auto-corrects String.new to empty string literal' do
-            new_source = autocorrect_source(cop, 'test = String.new')
-            expect(new_source).to eq("test = ''")
-          end
-        end
-      end
+    it 'auto-corrects String.new to empty string literal' do
+      new_source = autocorrect_source(cop, 'test = String.new')
+      expect(new_source).to eq("test = ''")
     end
   end
 end