rubocop 0.13.1 → 0.14.0

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

@@ -2,57 +2,51 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe SingleLineMethods, :config do
-        subject(:slm) { SingleLineMethods.new(config) }
-        let(:cop_config) { { 'AllowIfMethodIsEmpty' => true } }
-
-        it 'registers an offence for a single-line method' do
-          inspect_source(slm,
-                         ['def some_method; body end',
-                          'def link_to(name, url); {:name => name}; end',
-                          'def @table.columns; super; end'])
-          expect(slm.messages).to eq(
-            [SingleLineMethods::MSG] * 3)
-        end
-
-        context 'when AllowIfMethodIsEmpty is disabled' do
-          let(:cop_config) { { 'AllowIfMethodIsEmpty' => false } }
-
-          it 'registers an offence for an empty method' do
-            inspect_source(slm, ['def no_op; end',
-                                 'def self.resource_class=(klass); end',
-                                 'def @table.columns; end'])
-            expect(slm.offences.size).to eq(3)
-          end
-        end
-
-        context 'when AllowIfMethodIsEmpty is enabled' do
-          let(:cop_config) { { 'AllowIfMethodIsEmpty' => true } }
-
-          it 'accepts a single-line empty method' do
-            inspect_source(slm, ['def no_op; end',
-                                 'def self.resource_class=(klass); end',
-                                 'def @table.columns; end'])
-            expect(slm.offences).to be_empty
-          end
-        end
-
-        it 'accepts a multi-line method' do
-          inspect_source(slm, ['def some_method',
-                               '  body',
-                               'end'])
-          expect(slm.offences).to be_empty
-        end
-
-        it 'does not crash on an method with a capitalized name' do
-          inspect_source(slm, ['def NoSnakeCase',
-                               'end'])
-          expect(slm.offences).to be_empty
-        end
-      end
+describe Rubocop::Cop::Style::SingleLineMethods, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'AllowIfMethodIsEmpty' => true } }
+
+  it 'registers an offence for a single-line method' do
+    inspect_source(cop,
+                   ['def some_method; body end',
+                    'def link_to(name, url); {:name => name}; end',
+                    'def @table.columns; super; end'])
+    expect(cop.messages).to eq(
+      ['Avoid single-line method definitions.'] * 3)
+  end
+
+  context 'when AllowIfMethodIsEmpty is disabled' do
+    let(:cop_config) { { 'AllowIfMethodIsEmpty' => false } }
+
+    it 'registers an offence for an empty method' do
+      inspect_source(cop, ['def no_op; end',
+                           'def self.resource_class=(klass); end',
+                           'def @table.columns; end'])
+      expect(cop.offences.size).to eq(3)
     end
   end
+
+  context 'when AllowIfMethodIsEmpty is enabled' do
+    let(:cop_config) { { 'AllowIfMethodIsEmpty' => true } }
+
+    it 'accepts a single-line empty method' do
+      inspect_source(cop, ['def no_op; end',
+                           'def self.resource_class=(klass); end',
+                           'def @table.columns; end'])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  it 'accepts a multi-line method' do
+    inspect_source(cop, ['def some_method',
+                         '  body',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not crash on an method with a capitalized name' do
+    inspect_source(cop, ['def NoSnakeCase',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
 end

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

@@ -2,28 +2,22 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe SpaceAfterColon do
-        subject(:space) { SpaceAfterColon.new }
+describe Rubocop::Cop::Style::SpaceAfterColon do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for colon without space after it' do
-          inspect_source(space, ['x = w ? {a:3}:4'])
-          expect(space.messages).to eq(
-            ['Space missing after colon.'] * 2)
-        end
+  it 'registers an offence for colon without space after it' do
+    inspect_source(cop, ['x = w ? {a:3}:4'])
+    expect(cop.messages).to eq(
+      ['Space missing after colon.'] * 2)
+  end
 
-        it 'allows the colons in symbols' do
-          inspect_source(space, ['x = :a'])
-          expect(space.messages).to be_empty
-        end
+  it 'allows the colons in symbols' do
+    inspect_source(cop, ['x = :a'])
+    expect(cop.messages).to be_empty
+  end
 
-        it 'allows colons in strings' do
-          inspect_source(space, ["str << ':'"])
-          expect(space.messages).to be_empty
-        end
-      end
-    end
+  it 'allows colons in strings' do
+    inspect_source(cop, ["str << ':'"])
+    expect(cop.messages).to be_empty
   end
 end

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

@@ -2,30 +2,24 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe SpaceAfterComma do
-        subject(:space) { SpaceAfterComma.new }
+describe Rubocop::Cop::Style::SpaceAfterComma do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for block argument commas without space' do
-          inspect_source(space, ['each { |s,t| }'])
-          expect(space.messages).to eq(
-            ['Space missing after comma.'])
-        end
+  it 'registers an offence for block argument commas without space' do
+    inspect_source(cop, ['each { |s,t| }'])
+    expect(cop.messages).to eq(
+      ['Space missing after comma.'])
+  end
 
-        it 'registers an offence for array index commas without space' do
-          inspect_source(space, ['formats[0,1]'])
-          expect(space.messages).to eq(
-            ['Space missing after comma.'])
-        end
+  it 'registers an offence for array index commas without space' do
+    inspect_source(cop, ['formats[0,1]'])
+    expect(cop.messages).to eq(
+      ['Space missing after comma.'])
+  end
 
-        it 'registers an offence for method call arg commas without space' do
-          inspect_source(space, ['a(1,2)'])
-          expect(space.messages).to eq(
-            ['Space missing after comma.'])
-        end
-      end
-    end
+  it 'registers an offence for method call arg commas without space' do
+    inspect_source(cop, ['a(1,2)'])
+    expect(cop.messages).to eq(
+      ['Space missing after comma.'])
   end
 end

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

@@ -2,68 +2,62 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe SpaceAfterControlKeyword do
-        subject(:ap) { SpaceAfterControlKeyword.new }
+describe Rubocop::Cop::Style::SpaceAfterControlKeyword do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for normal if' do
-          inspect_source(ap,
-                         ['if(test) then result end'])
-          expect(ap.offences.size).to eq(1)
-        end
+  it 'registers an offence for normal if' do
+    inspect_source(cop,
+                   ['if(test) then result end'])
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'registers an offence for modifier unless' do
-          inspect_source(ap, ['action unless(test)'])
+  it 'registers an offence for modifier unless' do
+    inspect_source(cop, ['action unless(test)'])
 
-          expect(ap.offences.size).to eq(1)
-        end
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'does not get confused by keywords' do
-          inspect_source(ap, ['[:if, :unless].action'])
-          expect(ap.offences).to be_empty
-        end
+  it 'does not get confused by keywords' do
+    inspect_source(cop, ['[:if, :unless].action'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not get confused by the ternary operator' do
-          inspect_source(ap, ['a ? b : c'])
-          expect(ap.offences).to be_empty
-        end
+  it 'does not get confused by the ternary operator' do
+    inspect_source(cop, ['a ? b : c'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'registers an offence for if, elsif, and unless' do
-          inspect_source(ap,
-                         ['if(a)',
-                          'elsif(b)',
-                          '  unless(c)',
-                          '  end',
-                          'end'])
-          expect(ap.offences.map(&:line)).to eq([1, 2, 3])
-        end
+  it 'registers an offence for if, elsif, and unless' do
+    inspect_source(cop,
+                   ['if(a)',
+                    'elsif(b)',
+                    '  unless(c)',
+                    '  end',
+                    'end'])
+    expect(cop.offences.map(&:line)).to eq([1, 2, 3])
+  end
 
-        it 'registers an offence for case and when' do
-          inspect_source(ap,
-                         ['case(a)',
-                          'when(0) then 1',
-                          'end'])
-          expect(ap.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 case and when' do
-          inspect_source(ap,
-                         ['case(a)',
-                          'when(0) then 1',
-                          'end'])
-          expect(ap.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(ap,
-                         ['while(a)',
-                          '  b until(c)',
-                          'end'])
-          expect(ap.offences.map(&:line)).to eq([1, 2])
-        end
-      end
-    end
+  it 'registers an offence for while and until' do
+    inspect_source(cop,
+                   ['while(a)',
+                    '  b until(c)',
+                    'end'])
+    expect(cop.offences.map(&:line)).to eq([1, 2])
   end
 end

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

@@ -2,60 +2,54 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe SpaceAfterMethodName do
-        subject(:cop) { SpaceAfterMethodName.new }
-
-        it 'registers an offence for def with space before the parenthesis' do
-          inspect_source(cop,
-                         ['def func (x)',
-                          '  a',
-                          'end'])
-          expect(cop.offences).to have(1).item
-        end
-
-        it 'registers an offence for defs with space before the parenthesis' do
-          inspect_source(cop,
-                         ['def self.func (x)',
-                          '  a',
-                          'end'])
-          expect(cop.offences).to have(1).item
-        end
-
-        it 'accepts a def without arguments' do
-          inspect_source(cop,
-                         ['def func',
-                          '  a',
-                          'end'])
-          expect(cop.offences).to be_empty
-        end
-
-        it 'accepts a defs without arguments' do
-          inspect_source(cop,
-                         ['def self.func',
-                          '  a',
-                          'end'])
-          expect(cop.offences).to be_empty
-        end
-
-        it 'accepts a def with arguments but no parentheses' do
-          inspect_source(cop,
-                         ['def func x',
-                          '  a',
-                          'end'])
-          expect(cop.offences).to be_empty
-        end
-
-        it 'accepts a defs with arguments but no parentheses' do
-          inspect_source(cop,
-                         ['def self.func x',
-                          '  a',
-                          'end'])
-          expect(cop.offences).to be_empty
-        end
-      end
-    end
+describe Rubocop::Cop::Style::SpaceAfterMethodName do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for def with space before the parenthesis' do
+    inspect_source(cop,
+                   ['def func (x)',
+                    '  a',
+                    'end'])
+    expect(cop.offences).to have(1).item
+  end
+
+  it 'registers an offence for defs with space before the parenthesis' do
+    inspect_source(cop,
+                   ['def self.func (x)',
+                    '  a',
+                    'end'])
+    expect(cop.offences).to have(1).item
+  end
+
+  it 'accepts a def without arguments' do
+    inspect_source(cop,
+                   ['def func',
+                    '  a',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a defs without arguments' do
+    inspect_source(cop,
+                   ['def self.func',
+                    '  a',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a def with arguments but no parentheses' do
+    inspect_source(cop,
+                   ['def func x',
+                    '  a',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a defs with arguments but no parentheses' do
+    inspect_source(cop,
+                   ['def self.func x',
+                    '  a',
+                    'end'])
+    expect(cop.offences).to be_empty
   end
 end

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

@@ -2,23 +2,17 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe SpaceAfterSemicolon do
-        subject(:space) { SpaceAfterSemicolon.new }
+describe Rubocop::Cop::Style::SpaceAfterSemicolon do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for semicolon without space after it' do
-          inspect_source(space, ['x = 1;y = 2'])
-          expect(space.messages).to eq(
-            ['Space missing after semicolon.'])
-        end
+  it 'registers an offence for semicolon without space after it' do
+    inspect_source(cop, ['x = 1;y = 2'])
+    expect(cop.messages).to eq(
+      ['Space missing after semicolon.'])
+  end
 
-        it 'does not crash if semicolon is the last character of the file' do
-          inspect_source(space, ['x = 1;'])
-          expect(space.messages).to be_empty
-        end
-      end
-    end
+  it 'does not crash if semicolon is the last character of the file' do
+    inspect_source(cop, ['x = 1;'])
+    expect(cop.messages).to be_empty
   end
 end