rubocop 0.29.1 → 0.30.0

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

@@ -1,82 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::SingleLineBlockParams, :config do
-  subject(:cop) { described_class.new(config) }
-  let(:cop_config) do
-    { 'Methods' =>
-      [{ 'reduce' => %w(a e) },
-       { 'test' => %w(x y) }]
-    }
-  end
-
-  it 'finds wrong argument names in calls with different syntax' do
-    inspect_source(cop,
-                   ['def m',
-                    '  [0, 1].reduce { |c, d| c + d }',
-                    '  [0, 1].reduce{ |c, d| c + d }',
-                    '  [0, 1].reduce(5) { |c, d| c + d }',
-                    '  [0, 1].reduce(5){ |c, d| c + d }',
-                    '  [0, 1].reduce (5) { |c, d| c + d }',
-                    '  [0, 1].reduce(5) { |c, d| c + d }',
-                    '  ala.test { |x, z| bala }',
-                    'end'])
-    expect(cop.offenses.size).to eq(7)
-    expect(cop.offenses.map(&:line).sort).to eq((2..8).to_a)
-    expect(cop.messages.first)
-      .to eq('Name `reduce` block params `|a, e|`.')
-  end
-
-  it 'allows calls with proper argument names' do
-    inspect_source(cop,
-                   ['def m',
-                    '  [0, 1].reduce { |a, e| a + e }',
-                    '  [0, 1].reduce{ |a, e| a + e }',
-                    '  [0, 1].reduce(5) { |a, e| a + e }',
-                    '  [0, 1].reduce(5){ |a, e| a + e }',
-                    '  [0, 1].reduce (5) { |a, e| a + e }',
-                    '  [0, 1].reduce(5) { |a, e| a + e }',
-                    '  ala.test { |x, y| bala }',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'allows an unused parameter to have a leading underscore' do
-    inspect_source(cop,
-                   'File.foreach(filename).reduce(0) { |a, _e| a + 1 }')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'finds incorrectly named parameters with leading underscores' do
-    inspect_source(cop,
-                   'File.foreach(filename).reduce(0) { |_x, _y| }')
-    expect(cop.messages).to eq(['Name `reduce` block params `|a, e|`.'])
-  end
-
-  it 'ignores do..end blocks' do
-    inspect_source(cop,
-                   ['def m',
-                    '  [0, 1].reduce do |c, d|',
-                    '    c + d',
-                    '  end',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'ignores :reduce symbols' do
-    inspect_source(cop,
-                   ['def m',
-                    '  call_method(:reduce) { |a, b| a + b}',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not report when destructuring is used' do
-    inspect_source(cop,
-                   ['def m',
-                    '  test.reduce { |a, (id, _)| a + id}',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-end

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

@@ -1,94 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::SingleLineMethods do
-  subject(:cop) { described_class.new(config) }
-  let(:config) do
-    RuboCop::Config.new('Style/SingleLineMethods' => cop_config,
-                        'Style/IndentationWidth' => { 'Width' => 2 })
-  end
-  let(:cop_config) { { 'AllowIfMethodIsEmpty' => true } }
-
-  it 'registers an offense 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 offense for an empty method' do
-      inspect_source(cop, ['def no_op; end',
-                           'def self.resource_class=(klass); end',
-                           'def @table.columns; end'])
-      expect(cop.offenses.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.offenses).to be_empty
-    end
-  end
-
-  it 'accepts a multi-line method' do
-    inspect_source(cop, ['def some_method',
-                         '  body',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not crash on an method with a capitalized name' do
-    inspect_source(cop, ['def NoSnakeCase',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'auto-corrects def with semicolon after method name' do
-    corrected = autocorrect_source(cop,
-                                   ['  def some_method; body end # Cmnt'])
-    expect(corrected).to eq ['  # Cmnt',
-                             '  def some_method; ',
-                             '    body ',
-                             '  end '].join("\n")
-  end
-
-  it 'auto-corrects defs with parentheses after method name' do
-    corrected = autocorrect_source(cop, ['  def self.some_method() body end'])
-    expect(corrected).to eq ['  def self.some_method() ',
-                             '    body ',
-                             '  end'].join("\n")
-  end
-
-  it 'auto-corrects def with argument in parentheses' do
-    corrected = autocorrect_source(cop, ['  def some_method(arg) body end'])
-    expect(corrected).to eq ['  def some_method(arg) ',
-                             '    body ',
-                             '  end'].join("\n")
-  end
-
-  it 'auto-corrects def with argument and no parentheses' do
-    corrected = autocorrect_source(cop, ['  def some_method arg; body end'])
-    expect(corrected).to eq ['  def some_method arg; ',
-                             '    body ',
-                             '  end'].join("\n")
-  end
-
-  it 'auto-corrects def with semicolon before end' do
-    corrected = autocorrect_source(cop, ['  def some_method; b1; b2; end'])
-    expect(corrected).to eq ['  def some_method; ',
-                             '    b1; ',
-                             '    b2; ',
-                             '  end'].join("\n")
-  end
-end

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

@@ -1,63 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::SingleSpaceBeforeFirstArg do
-  subject(:cop) { described_class.new }
-
-  context 'for method calls without parentheses' do
-    it 'registers an offense for method call with two spaces before the ' \
-       'first arg' do
-      inspect_source(cop, ['something  x',
-                           'a.something  y, z'])
-      expect(cop.messages)
-        .to eq(['Put one space between the method name and the first ' \
-                'argument.'] * 2)
-      expect(cop.highlights).to eq(['  ', '  '])
-    end
-
-    it 'auto-corrects extra space' do
-      new_source = autocorrect_source(cop, ['something  x',
-                                            'a.something   y, z'])
-      expect(new_source).to eq(['something x',
-                                'a.something y, z'].join("\n"))
-    end
-
-    it 'accepts a method call with one space before the first arg' do
-      inspect_source(cop, ['something x',
-                           'a.something y, z'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts + operator' do
-      inspect_source(cop, ['something +',
-                           '  x'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts setter call' do
-      inspect_source(cop, ['something.x =',
-                           '  y'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts multiple space containing line break' do
-      inspect_source(cop, ['something \\',
-                           '  x'])
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  context 'for method calls with parentheses' do
-    it 'accepts a method call without space' do
-      inspect_source(cop, ['something(x)',
-                           'a.something(y, z)'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts a method call with space after the left parenthesis' do
-      inspect_source(cop, 'something(  x  )')
-      expect(cop.offenses).to be_empty
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::SpaceAfterColon do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense 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)
-    expect(cop.highlights).to eq([':'] * 2)
-  end
-
-  it 'accepts colons in symbols' do
-    inspect_source(cop, 'x = :a')
-    expect(cop.messages).to be_empty
-  end
-
-  it 'accepts colon in ternary followed by space' do
-    inspect_source(cop, 'x = w ? a : b')
-    expect(cop.messages).to be_empty
-  end
-
-  it 'accepts hash rockets' do
-    inspect_source(cop, 'x = {"a"=>1}')
-    expect(cop.messages).to be_empty
-  end
-
-  it 'accepts if' do
-    inspect_source(cop, ['x = if w',
-                         '      a',
-                         '    end'])
-    expect(cop.messages).to be_empty
-  end
-
-  if RUBY_VERSION >= '2.1'
-    it 'accepts colons denoting required keyword argument' do
-      inspect_source(cop, ['def initialize(table:, nodes:)',
-                           'end'])
-      expect(cop.messages).to be_empty
-    end
-  end
-
-  it 'accepts colons in strings' 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

@@ -1,30 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::SpaceAfterComma do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense 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 offense 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 offense for method call arg commas without space' do
-    inspect_source(cop, 'a(1,2)')
-    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

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

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

@@ -1,70 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::SpaceAfterMethodName do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for def with space before the parenthesis' do
-    inspect_source(cop,
-                   ['def func (x)',
-                    '  a',
-                    'end'])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'registers an offense for defs with space before the parenthesis' do
-    inspect_source(cop,
-                   ['def self.func (x)',
-                    '  a',
-                    'end'])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'accepts a def without arguments' do
-    inspect_source(cop,
-                   ['def func',
-                    '  a',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts a defs without arguments' do
-    inspect_source(cop,
-                   ['def self.func',
-                    '  a',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts a def with arguments but no parentheses' do
-    inspect_source(cop,
-                   ['def func x',
-                    '  a',
-                    'end'])
-    expect(cop.offenses).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.offenses).to be_empty
-  end
-
-  it 'auto-corrects unwanted space' do
-    new_source = autocorrect_source(cop, ['def func (x)',
-                                          '  a',
-                                          'end',
-                                          'def self.func (x)',
-                                          '  a',
-                                          'end'])
-    expect(new_source).to eq(['def func(x)',
-                              '  a',
-                              'end',
-                              'def self.func(x)',
-                              '  a',
-                              'end'].join("\n"))
-  end
-end