rubocop 0.13.1 → 0.14.0

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

@@ -2,28 +2,46 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe LambdaCall do
-        subject(:cop) { described_class.new }
-
-        it 'registers an offence for x.()' do
-          inspect_source(cop,
-                         ['x.(a, b)'])
-          expect(cop.offences.size).to eq(1)
-        end
-
-        it 'accepts x.call()' do
-          inspect_source(cop, ['x.call(a, b)'])
-          expect(cop.offences).to be_empty
-        end
-
-        it 'auto-corrects x.() to x.call()' do
-          new_source = autocorrect_source(cop, ['a.(x)'])
-          expect(new_source).to eq('a.call(x)')
-        end
-      end
+describe Rubocop::Cop::Style::LambdaCall, :config do
+  subject(:cop) { described_class.new(config) }
+
+  context 'when style is set to call' do
+    let(:cop_config) { { 'EnforcedStyle' => 'call' } }
+
+    it 'registers an offence for x.()' do
+      inspect_source(cop,
+                     ['x.(a, b)'])
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it 'accepts x.call()' do
+      inspect_source(cop, ['x.call(a, b)'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'auto-corrects x.() to x.call()' do
+      new_source = autocorrect_source(cop, ['a.(x)'])
+      expect(new_source).to eq('a.call(x)')
+    end
+  end
+
+  context 'when style is set to braces' do
+    let(:cop_config) { { 'EnforcedStyle' => 'braces' } }
+
+    it 'registers an offence for x.call()' do
+      inspect_source(cop,
+                     ['x.call(a, b)'])
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it 'accepts x.()' do
+      inspect_source(cop, ['x.(a, b)'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'auto-corrects x.call() to x.()' do
+      new_source = autocorrect_source(cop, ['a.call(x)'])
+      expect(new_source).to eq('a.(x)')
     end
   end
 end

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

@@ -2,44 +2,40 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe Lambda do
-        subject(:lambda) { Lambda.new }
+describe Rubocop::Cop::Style::Lambda do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for an old single-line lambda call' do
-          inspect_source(lambda, ['f = lambda { |x| x }'])
-          expect(lambda.offences.size).to eq(1)
-          expect(lambda.messages).to eq([Lambda::SINGLE_MSG])
-        end
+  it 'registers an offence for an old single-line lambda call' do
+    inspect_source(cop, ['f = lambda { |x| x }'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Use the new lambda literal syntax ->(params) {...}.'])
+  end
 
-        it 'accepts the new lambda literal with single-line body' do
-          inspect_source(lambda, ['lambda = ->(x) { x }',
-                                  'lambda.(1)'])
-          expect(lambda.offences).to be_empty
-        end
+  it 'accepts the new lambda literal with single-line body' do
+    inspect_source(cop, ['lambda = ->(x) { x }',
+                         'lambda.(1)'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'registers an offence for a new multi-line lambda call' do
-          inspect_source(lambda, ['f = ->(x) do',
-                                  '  x',
-                                  'end'])
-          expect(lambda.offences.size).to eq(1)
-          expect(lambda.messages).to eq([Lambda::MULTI_MSG])
-        end
+  it 'registers an offence for a new multi-line lambda call' do
+    inspect_source(cop, ['f = ->(x) do',
+                         '  x',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Use the lambda method for multi-line lambdas.'])
+  end
 
-        it 'accepts the old lambda syntax with multi-line body' do
-          inspect_source(lambda, ['l = lambda do |x|',
-                                  '  x',
-                                  'end'])
-          expect(lambda.offences).to be_empty
-        end
+  it 'accepts the old lambda syntax with multi-line body' do
+    inspect_source(cop, ['l = lambda do |x|',
+                         '  x',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'accepts the lambda call outside of block' do
-          inspect_source(lambda, ['l = lambda.test'])
-          expect(lambda.offences).to be_empty
-        end
-      end
-    end
+  it 'accepts the lambda call outside of block' do
+    inspect_source(cop, ['l = lambda.test'])
+    expect(cop.offences).to be_empty
   end
 end

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

@@ -2,64 +2,58 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe LeadingCommentSpace do
-        subject(:lcs) { LeadingCommentSpace.new }
+describe Rubocop::Cop::Style::LeadingCommentSpace do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for comment without leading space' do
-          inspect_source(lcs,
-                         ['#missing space'])
-          expect(lcs.offences.size).to eq(1)
-        end
+  it 'registers an offence for comment without leading space' do
+    inspect_source(cop,
+                   ['#missing space'])
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'does not register an offence for # followed by no text' do
-          inspect_source(lcs,
-                         ['#'])
-          expect(lcs.offences).to be_empty
-        end
+  it 'does not register an offence for # followed by no text' do
+    inspect_source(cop,
+                   ['#'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not register an offence for more than one space' do
-          inspect_source(lcs,
-                         ['#   heavily indented'])
-          expect(lcs.offences).to be_empty
-        end
+  it 'does not register an offence for more than one space' do
+    inspect_source(cop,
+                   ['#   heavily indented'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not register an offence for more than one #' do
-          inspect_source(lcs,
-                         ['###### heavily indented'])
-          expect(lcs.offences).to be_empty
-        end
+  it 'does not register an offence for more than one #' do
+    inspect_source(cop,
+                   ['###### heavily indented'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not register an offence for only #s' do
-          inspect_source(lcs,
-                         ['######'])
-          expect(lcs.offences).to be_empty
-        end
+  it 'does not register an offence for only #s' do
+    inspect_source(cop,
+                   ['######'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not register an offence for #! on first line' do
-          inspect_source(lcs,
-                         ['#!/usr/bin/ruby',
-                          'test'])
-          expect(lcs.offences).to be_empty
-        end
+  it 'does not register an offence for #! on first line' do
+    inspect_source(cop,
+                   ['#!/usr/bin/ruby',
+                    'test'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'registers an offence for #! after the first line' do
-          inspect_source(lcs,
-                         ['test', '#!/usr/bin/ruby'])
-          expect(lcs.offences.size).to eq(1)
-        end
+  it 'registers an offence for #! after the first line' do
+    inspect_source(cop,
+                   ['test', '#!/usr/bin/ruby'])
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'accepts rdoc syntax' do
-          inspect_source(lcs,
-                         ['#++',
-                          '#--',
-                          '#:nodoc:'])
+  it 'accepts rdoc syntax' do
+    inspect_source(cop,
+                   ['#++',
+                    '#--',
+                    '#:nodoc:'])
 
-          expect(lcs.offences).to be_empty
-        end
-      end
-    end
+    expect(cop.offences).to be_empty
   end
 end

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

@@ -2,24 +2,18 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe LineLength, :config do
-        subject(:ll) { LineLength.new(config) }
-        let(:cop_config) { { 'Max' => 79 } }
+describe Rubocop::Cop::Style::LineLength, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'Max' => 79 } }
 
-        it "registers an offence for a line that's 80 characters wide" do
-          inspect_source(ll, ['#' * 80])
-          expect(ll.offences.size).to eq(1)
-          expect(ll.offences.first.message).to eq('Line is too long. [80/79]')
-        end
+  it "registers an offence for a line that's 80 characters wide" do
+    inspect_source(cop, ['#' * 80])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences.first.message).to eq('Line is too long. [80/79]')
+  end
 
-        it "accepts a line that's 79 characters wide" do
-          inspect_source(ll, ['#' * 79])
-          expect(ll.offences).to be_empty
-        end
-      end
-    end
+  it "accepts a line that's 79 characters wide" do
+    inspect_source(cop, ['#' * 79])
+    expect(cop.offences).to be_empty
   end
 end

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

@@ -2,29 +2,23 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe MethodCallParentheses do
-        subject(:cop) { described_class.new }
+describe Rubocop::Cop::Style::MethodCallParentheses do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for parens in method call without args' do
-          inspect_source(cop, ['top.test()'])
-        end
+  it 'registers an offence for parens in method call without args' do
+    inspect_source(cop, ['top.test()'])
+  end
 
-        it 'it accepts no parens in method call without args' do
-          inspect_source(cop, ['top.test'])
-        end
+  it 'it accepts no parens in method call without args' do
+    inspect_source(cop, ['top.test'])
+  end
 
-        it 'it accepts parens in method call with args' do
-          inspect_source(cop, ['top.test(a)'])
-        end
+  it 'it accepts parens in method call with args' do
+    inspect_source(cop, ['top.test(a)'])
+  end
 
-        it 'auto-corrects by removing unneeded braces' do
-          new_source = autocorrect_source(cop, 'test()')
-          expect(new_source).to eq('test')
-        end
-      end
-    end
+  it 'auto-corrects by removing unneeded braces' do
+    new_source = autocorrect_source(cop, 'test()')
+    expect(new_source).to eq('test')
   end
 end

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

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::MethodCalledOnDoEndBlock do
+  subject(:cop) { described_class.new }
+
+  context 'with a multi-line do..end block' do
+    it 'registers an offence for a chained call' do
+      inspect_source(cop, ['a do',
+                           '  b',
+                           'end.c'])
+      expect(cop.offences).to have(1).item
+      expect(cop.highlights).to eq(['end.c'])
+    end
+
+    it 'accepts it if there is no chained call' do
+      inspect_source(cop, ['a do',
+                           '  b',
+                           'end'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts a chained block' do
+      inspect_source(cop, ['a do',
+                           '  b',
+                           'end.c do',
+                           '  d',
+                           'end'])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'with a single-line do..end block' do
+    it 'registers an offence for a chained call' do
+      inspect_source(cop, ['a do b end.c'])
+      expect(cop.offences).to have(1).item
+      expect(cop.highlights).to eq(['end.c'])
+    end
+
+    it 'accepts a single-line do..end block with a chained block' do
+      inspect_source(cop, ['a do b end.c do d end'])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'with a {} block' do
+    it 'accepts a multi-line block with a chained call' do
+      inspect_source(cop, ['a {',
+                           '  b',
+                           '}.c'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts a single-line block with a chained call' do
+      inspect_source(cop, ['a { b }.c'])
+      expect(cop.offences).to be_empty
+    end
+  end
+end

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

@@ -2,151 +2,145 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe MethodLength, :config do
-        subject(:method_length) { MethodLength.new(config) }
-        let(:cop_config) { { 'Max' => 5, 'CountComments' => false } }
+describe Rubocop::Cop::Style::MethodLength, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'Max' => 5, 'CountComments' => false } }
 
-        it 'rejects a method with more than 5 lines' do
-          inspect_source(method_length, ['def m()',
-                                         '  a = 1',
-                                         '  a = 2',
-                                         '  a = 3',
-                                         '  a = 4',
-                                         '  a = 5',
-                                         '  a = 6',
-                                         'end'])
-          expect(method_length.offences.size).to eq(1)
-          expect(method_length.offences.map(&:line).sort).to eq([1])
-        end
+  it 'rejects a method with more than 5 lines' do
+    inspect_source(cop, ['def m()',
+                         '  a = 1',
+                         '  a = 2',
+                         '  a = 3',
+                         '  a = 4',
+                         '  a = 5',
+                         '  a = 6',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences.map(&:line).sort).to eq([1])
+  end
 
-        it 'accepts a method with less than 5 lines' do
-          inspect_source(method_length, ['def m()',
-                                         '  a = 1',
-                                         '  a = 2',
-                                         '  a = 3',
-                                         '  a = 4',
-                                         'end'])
-          expect(method_length.offences).to be_empty
-        end
+  it 'accepts a method with less than 5 lines' do
+    inspect_source(cop, ['def m()',
+                         '  a = 1',
+                         '  a = 2',
+                         '  a = 3',
+                         '  a = 4',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not count blank lines' do
-          inspect_source(method_length, ['def m()',
-                                         '  a = 1',
-                                         '  a = 2',
-                                         '  a = 3',
-                                         '  a = 4',
-                                         '',
-                                         '',
-                                         '  a = 7',
-                                         'end'])
-          expect(method_length.offences).to be_empty
-        end
+  it 'does not count blank lines' do
+    inspect_source(cop, ['def m()',
+                         '  a = 1',
+                         '  a = 2',
+                         '  a = 3',
+                         '  a = 4',
+                         '',
+                         '',
+                         '  a = 7',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'accepts empty methods' do
-          inspect_source(method_length, ['def m()',
-                                         'end'])
-          expect(method_length.offences).to be_empty
-        end
+  it 'accepts empty methods' do
+    inspect_source(cop, ['def m()',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'is not fooled by one-liner methods, syntax #1' do
-          inspect_source(method_length, ['def one_line; 10 end',
-                                         'def self.m()',
-                                         '  a = 1',
-                                         '  a = 2',
-                                         '  a = 4',
-                                         '  a = 5',
-                                         '  a = 6',
-                                         'end'])
-          expect(method_length.offences).to be_empty
-        end
+  it 'is not fooled by one-liner methods, syntax #1' do
+    inspect_source(cop, ['def one_line; 10 end',
+                         'def self.m()',
+                         '  a = 1',
+                         '  a = 2',
+                         '  a = 4',
+                         '  a = 5',
+                         '  a = 6',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'is not fooled by one-liner methods, syntax #2' do
-          inspect_source(method_length, ['def one_line(test) 10 end',
-                                         'def self.m()',
-                                         '  a = 1',
-                                         '  a = 2',
-                                         '  a = 4',
-                                         '  a = 5',
-                                         '  a = 6',
-                                         'end'])
-          expect(method_length.offences).to be_empty
-        end
+  it 'is not fooled by one-liner methods, syntax #2' do
+    inspect_source(cop, ['def one_line(test) 10 end',
+                         'def self.m()',
+                         '  a = 1',
+                         '  a = 2',
+                         '  a = 4',
+                         '  a = 5',
+                         '  a = 6',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'checks class methods, syntax #1' do
-          inspect_source(method_length, ['def self.m()',
-                                         '  a = 1',
-                                         '  a = 2',
-                                         '  a = 3',
-                                         '  a = 4',
-                                         '  a = 5',
-                                         '  a = 6',
-                                         'end'])
-          expect(method_length.offences.size).to eq(1)
-          expect(method_length.offences.map(&:line).sort).to eq([1])
-        end
+  it 'checks class methods, syntax #1' do
+    inspect_source(cop, ['def self.m()',
+                         '  a = 1',
+                         '  a = 2',
+                         '  a = 3',
+                         '  a = 4',
+                         '  a = 5',
+                         '  a = 6',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences.map(&:line).sort).to eq([1])
+  end
 
-        it 'checks class methods, syntax #2' do
-          inspect_source(method_length, ['class K',
-                                         '  class << self',
-                                         '    def m()',
-                                         '      a = 1',
-                                         '      a = 2',
-                                         '      a = 3',
-                                         '      a = 4',
-                                         '      a = 5',
-                                         '      a = 6',
-                                         '    end',
-                                         '  end',
-                                         'end'])
-          expect(method_length.offences.size).to eq(1)
-          expect(method_length.offences.map(&:line).sort).to eq([3])
-        end
+  it 'checks class methods, syntax #2' do
+    inspect_source(cop, ['class K',
+                         '  class << self',
+                         '    def m()',
+                         '      a = 1',
+                         '      a = 2',
+                         '      a = 3',
+                         '      a = 4',
+                         '      a = 5',
+                         '      a = 6',
+                         '    end',
+                         '  end',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences.map(&:line).sort).to eq([3])
+  end
 
-        it 'properly counts lines when method ends with block' do
-          inspect_source(method_length, ['def m()',
-                                         '  something do',
-                                         '    a = 2',
-                                         '    a = 3',
-                                         '    a = 4',
-                                         '    a = 5',
-                                         '  end',
-                                         'end'])
-          expect(method_length.offences.size).to eq(1)
-          expect(method_length.offences.map(&:line).sort).to eq([1])
-        end
+  it 'properly counts lines when method ends with block' do
+    inspect_source(cop, ['def m()',
+                         '  something do',
+                         '    a = 2',
+                         '    a = 3',
+                         '    a = 4',
+                         '    a = 5',
+                         '  end',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences.map(&:line).sort).to eq([1])
+  end
 
-        it 'does not count commented lines by default' do
-          inspect_source(method_length, ['def m()',
-                                         '  a = 1',
-                                         '  #a = 2',
-                                         '  a = 3',
-                                         '  #a = 4',
-                                         '  a = 5',
-                                         '  a = 6',
-                                         'end'])
-          expect(method_length.offences).to be_empty
-        end
+  it 'does not count commented lines by default' do
+    inspect_source(cop, ['def m()',
+                         '  a = 1',
+                         '  #a = 2',
+                         '  a = 3',
+                         '  #a = 4',
+                         '  a = 5',
+                         '  a = 6',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        context 'when CountComments is enabled' do
-          before { cop_config['CountComments'] = true }
+  context 'when CountComments is enabled' do
+    before { cop_config['CountComments'] = true }
 
-          it 'also counts commented lines' do
-            inspect_source(method_length, ['def m()',
-                                           '  a = 1',
-                                           '  #a = 2',
-                                           '  a = 3',
-                                           '  #a = 4',
-                                           '  a = 5',
-                                           '  a = 6',
-                                           'end'])
-            expect(method_length.offences.size).to eq(1)
-            expect(method_length.offences.map(&:line).sort).to eq([1])
-          end
-        end
-      end
+    it 'also counts commented lines' do
+      inspect_source(cop, ['def m()',
+                           '  a = 1',
+                           '  #a = 2',
+                           '  a = 3',
+                           '  #a = 4',
+                           '  a = 5',
+                           '  a = 6',
+                           'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.offences.map(&:line).sort).to eq([1])
     end
   end
 end