rubocop 0.13.1 → 0.14.0

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

@@ -2,101 +2,98 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe Blocks do
-        subject(:cop) { described_class.new }
+describe Rubocop::Cop::Style::Blocks do
+  subject(:cop) { described_class.new }
 
-        it 'accepts a multiline block with do-end' do
-          inspect_source(cop, ['each do |x|',
-                               'end'])
-          expect(cop.offences).to be_empty
-        end
-
-        it 'registers an offence for a single line block with do-end' do
-          inspect_source(cop, ['each do |x| end'])
-          expect(cop.messages).to eq([Blocks::SINGLE_LINE_MSG])
-        end
+  it 'accepts a multiline block with do-end' do
+    inspect_source(cop, ['each do |x|',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'accepts a single line block with braces' do
-          inspect_source(cop, ['each { |x| }'])
-          expect(cop.offences).to be_empty
-        end
+  it 'registers an offence for a single line block with do-end' do
+    inspect_source(cop, ['each do |x| end'])
+    expect(cop.messages)
+      .to eq(['Prefer {...} over do...end for single-line blocks.'])
+  end
 
-        it 'auto-corrects do and end for single line blocks to { and }' do
-          new_source = autocorrect_source(cop, 'block do |x| end')
-          expect(new_source).to eq('block { |x| }')
-        end
+  it 'accepts a single line block with braces' do
+    inspect_source(cop, ['each { |x| }'])
+    expect(cop.offences).to be_empty
+  end
 
-        context 'when there are braces around a multi-line block' do
-          it 'registers an offence in the simple case' do
-            inspect_source(cop, ['each { |x|',
-                                 '}'])
-            expect(cop.messages).to eq([Blocks::MULTI_LINE_MSG])
-          end
+  it 'auto-corrects do and end for single line blocks to { and }' do
+    new_source = autocorrect_source(cop, 'block do |x| end')
+    expect(new_source).to eq('block { |x| }')
+  end
 
-          it 'accepts braces if do-end would change the meaning' do
-            src = ['scope :foo, lambda { |f|',
-                   '  where(condition: "value")',
-                   '}',
-                   '',
-                   'expect { something }.to raise_error(ErrorClass) { |error|',
-                   '  # ...',
-                   '}',
-                   '',
-                   'expect { x }.to change {',
-                   '  Counter.count',
-                   '}.from(0).to(1)']
-            inspect_source(cop, src)
-            expect(cop.offences).to be_empty
-          end
+  context 'when there are braces around a multi-line block' do
+    it 'registers an offence in the simple case' do
+      inspect_source(cop, ['each { |x|',
+                           '}'])
+      expect(cop.messages)
+        .to eq(['Avoid using {...} for multi-line blocks.'])
+    end
 
-          it 'registers an offence for braces if do-end would not change ' +
-            'the meaning' do
-            src = ['scope :foo, (lambda { |f|',
-                   '  where(condition: "value")',
-                   '})',
-                   '',
-                   'expect { something }.to(raise_error(ErrorClass) { |error|',
-                   '  # ...',
-                   '})']
-            inspect_source(cop, src)
-            expect(cop.offences.size).to eq(2)
-          end
+    it 'accepts braces if do-end would change the meaning' do
+      src = ['scope :foo, lambda { |f|',
+             '  where(condition: "value")',
+             '}',
+             '',
+             'expect { something }.to raise_error(ErrorClass) { |error|',
+             '  # ...',
+             '}',
+             '',
+             'expect { x }.to change {',
+             '  Counter.count',
+             '}.from(0).to(1)']
+      inspect_source(cop, src)
+      expect(cop.offences).to be_empty
+    end
 
-          it 'can handle special method names such as []= and done?' do
-            src = ['h2[k2] = Hash.new { |h3,k3|',
-                   '  h3[k3] = 0',
-                   '}',
-                   '',
-                   'x = done? list.reject { |e|',
-                   '  e.nil?',
-                   '}']
-            inspect_source(cop, src)
-            expect(cop.messages).to eq([Blocks::MULTI_LINE_MSG])
-          end
+    it 'registers an offence for braces if do-end would not change ' +
+      'the meaning' do
+      src = ['scope :foo, (lambda { |f|',
+             '  where(condition: "value")',
+             '})',
+             '',
+             'expect { something }.to(raise_error(ErrorClass) { |error|',
+             '  # ...',
+             '})']
+      inspect_source(cop, src)
+      expect(cop.offences.size).to eq(2)
+    end
 
-          it 'auto-corrects do and end for single line blocks to { and }' do
-            source = <<-END.strip_indent
-              each { |x|
-                some_method
-                other_method
-              }
-            END
+    it 'can handle special method names such as []= and done?' do
+      src = ['h2[k2] = Hash.new { |h3,k3|',
+             '  h3[k3] = 0',
+             '}',
+             '',
+             'x = done? list.reject { |e|',
+             '  e.nil?',
+             '}']
+      inspect_source(cop, src)
+      expect(cop.messages)
+        .to eq(['Avoid using {...} for multi-line blocks.'])
+    end
 
-            expected_source = <<-END.strip_indent
-              each do |x|
-                some_method
-                other_method
-              end
-            END
+    it 'auto-corrects { and } to do and end' do
+      source = <<-END.strip_indent
+        each{ |x|
+          some_method
+          other_method
+        }
+      END
 
-            new_source = autocorrect_source(cop, source)
-            expect(new_source).to eq(expected_source)
-          end
+      expected_source = <<-END.strip_indent
+        each do |x|
+          some_method
+          other_method
         end
-      end
+      END
+
+      new_source = autocorrect_source(cop, source)
+      expect(new_source).to eq(expected_source)
     end
   end
 end

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

@@ -2,17 +2,11 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe CaseEquality do
-        subject(:ce) { CaseEquality.new }
+describe Rubocop::Cop::Style::CaseEquality do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for ===' do
-          inspect_source(ce, ['Array === var'])
-          expect(ce.offences.size).to eq(1)
-        end
-      end
-    end
+  it 'registers an offence for ===' do
+    inspect_source(cop, ['Array === var'])
+    expect(cop.offences.size).to eq(1)
   end
 end

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

@@ -2,87 +2,81 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe CaseIndentation do
-        subject(:ind) { CaseIndentation.new }
+describe Rubocop::Cop::Style::CaseIndentation do
+  subject(:cop) { described_class.new }
 
-        it "registers an offence for a when clause that's deeper than case" do
-          source = ['case a',
-                    '    when 0 then return',
-                    '        case b',
-                    '         when 1 then return',
-                    '        end',
-                    'end']
-          inspect_source(ind, source)
-          expect(ind.messages).to eq(
-            ['Indent when as deep as case.'] * 2)
-        end
+  it "registers an offence for a when clause that's deeper than case" do
+    source = ['case a',
+              '    when 0 then return',
+              '        case b',
+              '         when 1 then return',
+              '        end',
+              'end']
+    inspect_source(cop, source)
+    expect(cop.messages).to eq(
+      ['Indent when as deep as case.'] * 2)
+  end
 
-        it "accepts a when clause that's equally indented with case" do
-          source = ['y = case a',
-                    '    when 0 then break',
-                    '    when 0 then return',
-                    '      z = case b',
-                    '          when 1 then return',
-                    '          when 1 then break',
-                    '          end',
-                    '    end',
-                    'case c',
-                    'when 2 then encoding',
-                    'end',
-                    '']
-          inspect_source(ind, source)
-          expect(ind.offences).to be_empty
-        end
+  it "accepts a when clause that's equally indented with case" do
+    source = ['y = case a',
+              '    when 0 then break',
+              '    when 0 then return',
+              '      z = case b',
+              '          when 1 then return',
+              '          when 1 then break',
+              '          end',
+              '    end',
+              'case c',
+              'when 2 then encoding',
+              'end',
+              '']
+    inspect_source(cop, source)
+    expect(cop.offences).to be_empty
+  end
 
-        it "doesn't get confused by strings with case in them" do
-          source = ['a = "case"',
-                    'case x',
-                    'when 0',
-                    'end',
-                    '']
-          inspect_source(ind, source)
-          expect(ind.messages).to be_empty
-        end
+  it "doesn't get confused by strings with case in them" do
+    source = ['a = "case"',
+              'case x',
+              'when 0',
+              'end',
+              '']
+    inspect_source(cop, source)
+    expect(cop.messages).to be_empty
+  end
 
-        it "doesn't get confused by symbols named case or when" do
-          source = ['KEYWORDS = { :case => true, :when => true }',
-                    'case type',
-                    'when 0',
-                    '  ParameterNode',
-                    'when 1',
-                    '  MethodCallNode',
-                    'end',
-                    '']
-          inspect_source(ind, source)
-          expect(ind.messages).to be_empty
-        end
+  it "doesn't get confused by symbols named case or when" do
+    source = ['KEYWORDS = { :case => true, :when => true }',
+              'case type',
+              'when 0',
+              '  ParameterNode',
+              'when 1',
+              '  MethodCallNode',
+              'end',
+              '']
+    inspect_source(cop, source)
+    expect(cop.messages).to be_empty
+  end
 
-        it 'accepts correctly indented whens in complex combinations' do
-          source = ['each {',
-                    '  case state',
-                    '  when 0',
-                    '    case name',
-                    '    when :a',
-                    '    end',
-                    '  when 1',
-                    '    loop {',
-                    '      case name',
-                    '      when :b',
-                    '      end',
-                    '    }',
-                    '  end',
-                    '}',
-                    'case s',
-                    'when Array',
-                    'end',
-                    '']
-          inspect_source(ind, source)
-          expect(ind.messages).to be_empty
-        end
-      end
-    end
+  it 'accepts correctly indented whens in complex combinations' do
+    source = ['each {',
+              '  case state',
+              '  when 0',
+              '    case name',
+              '    when :a',
+              '    end',
+              '  when 1',
+              '    loop {',
+              '      case name',
+              '      when :b',
+              '      end',
+              '    }',
+              '  end',
+              '}',
+              'case s',
+              'when Array',
+              'end',
+              '']
+    inspect_source(cop, source)
+    expect(cop.messages).to be_empty
   end
 end

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

@@ -2,42 +2,36 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe CharacterLiteral do
-        subject(:cop) { CharacterLiteral.new }
-
-        it 'registers an offence for character literals' do
-          inspect_source(cop, ['x = ?x'])
-          expect(cop.offences.size).to eq(1)
-        end
-
-        it 'registers an offence for literals like \n' do
-          inspect_source(cop, ['x = ?\n'])
-          expect(cop.offences.size).to eq(1)
-        end
-
-        it 'accepts literals like ?\C-\M-d' do
-          inspect_source(cop, ['x = ?\C-\M-d'])
-          expect(cop.offences).to be_empty
-        end
-
-        it 'accepts ? in a %w literal' do
-          inspect_source(cop, ['%w{? A}'])
-          expect(cop.offences).to be_empty
-        end
-
-        it "auto-corrects ?x to 'x'" do
-          new_source = autocorrect_source(cop, 'x = ?x')
-          expect(new_source).to eq("x = 'x'")
-        end
-
-        it 'auto-corrects ?\n to "\\n"' do
-          new_source = autocorrect_source(cop, 'x = ?\n')
-          expect(new_source).to eq('x = "\\n"')
-        end
-      end
-    end
+describe Rubocop::Cop::Style::CharacterLiteral do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for character literals' do
+    inspect_source(cop, ['x = ?x'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for literals like \n' do
+    inspect_source(cop, ['x = ?\n'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts literals like ?\C-\M-d' do
+    inspect_source(cop, ['x = ?\C-\M-d'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts ? in a %w literal' do
+    inspect_source(cop, ['%w{? A}'])
+    expect(cop.offences).to be_empty
+  end
+
+  it "auto-corrects ?x to 'x'" do
+    new_source = autocorrect_source(cop, 'x = ?x')
+    expect(new_source).to eq("x = 'x'")
+  end
+
+  it 'auto-corrects ?\n to "\\n"' do
+    new_source = autocorrect_source(cop, 'x = ?\n')
+    expect(new_source).to eq('x = "\\n"')
   end
 end

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

@@ -2,45 +2,39 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe ClassAndModuleCamelCase do
-        subject(:camel_case) { ClassAndModuleCamelCase.new }
+describe Rubocop::Cop::Style::ClassAndModuleCamelCase do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for underscore in class and module name' do
-          inspect_source(camel_case,
-                         ['class My_Class',
-                          'end',
-                          '',
-                          'module My_Module',
-                          'end',
-                         ])
-          expect(camel_case.offences.size).to eq(2)
-        end
+  it 'registers an offence for underscore in class and module name' do
+    inspect_source(cop,
+                   ['class My_Class',
+                    'end',
+                    '',
+                    'module My_Module',
+                    'end',
+                   ])
+    expect(cop.offences.size).to eq(2)
+  end
 
-        it 'is not fooled by qualified names' do
-          inspect_source(camel_case,
-                         ['class Top::My_Class',
-                          'end',
-                          '',
-                          'module My_Module::Ala',
-                          'end',
-                         ])
-          expect(camel_case.offences.size).to eq(2)
-        end
+  it 'is not fooled by qualified names' do
+    inspect_source(cop,
+                   ['class Top::My_Class',
+                    'end',
+                    '',
+                    'module My_Module::Ala',
+                    'end',
+                   ])
+    expect(cop.offences.size).to eq(2)
+  end
 
-        it 'accepts CamelCase names' do
-          inspect_source(camel_case,
-                         ['class MyClass',
-                          'end',
-                          '',
-                          'module Mine',
-                          'end',
-                         ])
-          expect(camel_case.offences).to be_empty
-        end
-      end
-    end
+  it 'accepts CamelCase names' do
+    inspect_source(cop,
+                   ['class MyClass',
+                    'end',
+                    '',
+                    'module Mine',
+                    'end',
+                   ])
+    expect(cop.offences).to be_empty
   end
 end