rubocop 0.29.1 → 0.30.0

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

@@ -1,59 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::MethodCallParentheses, :config do
-  subject(:cop) { described_class.new(config) }
-  let(:config) do
-    RuboCop::Config.new('Style/EmptyLiteral' => { 'Enabled' => true })
-  end
-
-  it 'registers an offense for parens in method call without args' do
-    inspect_source(cop, 'top.test()')
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'accepts parentheses for methods starting with an upcase letter' do
-    inspect_source(cop, 'Test()')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts no parens in method call without args' do
-    inspect_source(cop, 'top.test')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts parens in method call with args' do
-    inspect_source(cop, 'top.test(a)')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'auto-corrects by removing unneeded braces' do
-    new_source = autocorrect_source(cop, 'test()')
-    expect(new_source).to eq('test')
-  end
-
-  it 'does not auto-correct calls that will be changed to empty literals' do
-    original = ['Hash.new()',
-                'Array.new()',
-                'String.new()']
-    new_source = autocorrect_source(cop, original)
-    expect(new_source).to eq(original.join("\n"))
-  end
-
-  context 'when EmptyLiteral is disabled' do
-    let(:config) do
-      RuboCop::Config.new('Style/EmptyLiteral' => { 'Enabled' => false })
-    end
-
-    it 'auto-corrects calls that could be empty literals' do
-      original = ['Hash.new()',
-                  'Array.new()',
-                  'String.new()']
-      new_source = autocorrect_source(cop, original)
-      expect(new_source).to eq(['Hash.new',
-                                'Array.new',
-                                'String.new'].join("\n"))
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-# 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 offense for a chained call' do
-      inspect_source(cop, ['a do',
-                           '  b',
-                           'end.c'])
-      expect(cop.offenses.size).to eq(1)
-      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.offenses).to be_empty
-    end
-
-    it 'accepts a chained block' do
-      inspect_source(cop, ['a do',
-                           '  b',
-                           'end.c do',
-                           '  d',
-                           'end'])
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  context 'with a single-line do..end block' do
-    it 'registers an offense for a chained call' do
-      inspect_source(cop, 'a do b end.c')
-      expect(cop.offenses.size).to eq(1)
-      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.offenses).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.offenses).to be_empty
-    end
-
-    it 'accepts a single-line block with a chained call' do
-      inspect_source(cop, 'a { b }.c')
-      expect(cop.offenses).to be_empty
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::MethodDefParentheses, :config do
-  subject(:cop) { described_class.new(config) }
-
-  context 'require_parentheses' do
-    let(:cop_config) { { 'EnforcedStyle' => 'require_parentheses' } }
-
-    it 'reports an offense for def with parameters but no parens' do
-      src = ['def func a, b',
-             'end']
-      inspect_source(cop, src)
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' =>
-                                                 'require_no_parentheses')
-    end
-
-    it 'reports an offense for correct + opposite' do
-      src = ['def func(a, b)',
-             'end',
-             'def func a, b',
-             'end']
-      inspect_source(cop, src)
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    it 'reports an offense for class def with parameters but no parens' do
-      src = ['def Test.func a, b',
-             'end']
-      inspect_source(cop, src)
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it 'accepts def with no args and no parens' do
-      src = ['def func',
-             'end']
-      inspect_source(cop, src)
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'auto-adds required parens for a def' do
-      new_source = autocorrect_source(cop, 'def test param; end')
-      expect(new_source).to eq('def test(param); end')
-    end
-
-    it 'auto-adds required parens for a defs' do
-      new_source = autocorrect_source(cop, 'def self.test param; end')
-      expect(new_source).to eq('def self.test(param); end')
-    end
-
-    it 'auto-adds required parens to argument lists on multiple lines' do
-      new_source = autocorrect_source(cop, ['def test one,', 'two', 'end'])
-      expect(new_source).to eq(['def test(one,',
-                                'two)',
-                                'end'].join("\n"))
-    end
-  end
-
-  context 'require_no_parentheses' do
-    let(:cop_config) { { 'EnforcedStyle' => 'require_no_parentheses' } }
-
-    it 'reports an offense for def with parameters with parens' do
-      src = ['def func(a, b)',
-             'end']
-      inspect_source(cop, src)
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' =>
-                                                 'require_parentheses')
-    end
-
-    it 'reports an offense for opposite + correct' do
-      src = ['def func(a, b)',
-             'end',
-             'def func a, b',
-             'end']
-      inspect_source(cop, src)
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    it 'reports an offense for class def with parameters with parens' do
-      src = ['def Test.func(a, b)',
-             'end']
-      inspect_source(cop, src)
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it 'reports an offense for def with no args and parens' do
-      src = ['def func()',
-             'end']
-      inspect_source(cop, src)
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it 'auto-removes the parens' do
-      new_source = autocorrect_source(cop, 'def test(param); end')
-      expect(new_source).to eq('def test param; end')
-    end
-
-    it 'auto-removes the parens for defs' do
-      new_source = autocorrect_source(cop, 'def self.test(param); end')
-      expect(new_source).to eq('def self.test param; end')
-    end
-  end
-end

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

@@ -1,125 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::MethodName, :config do
-  subject(:cop) { described_class.new(config) }
-
-  shared_examples 'never accepted' do
-    it 'registers an offense for mixed snake case and camel case' do
-      inspect_source(cop, ['def visit_Arel_Nodes_SelectStatement',
-                           'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.highlights).to eq(['visit_Arel_Nodes_SelectStatement'])
-    end
-
-    it 'registers an offense for capitalized camel case' do
-      inspect_source(cop, ['def MyMethod',
-                           'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.highlights).to eq(['MyMethod'])
-    end
-  end
-
-  shared_examples 'always accepted' do
-    it 'accepts one line methods' do
-      inspect_source(cop, "def body; '' end")
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts operator definitions' do
-      inspect_source(cop, ['def +(other)',
-                           '  # ...',
-                           'end'])
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  context 'when configured for snake_case' do
-    let(:cop_config) { { 'EnforcedStyle' => 'snake_case' } }
-
-    it 'registers an offense for camel case in instance method name' do
-      inspect_source(cop, ['def myMethod',
-                           '  # ...',
-                           'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.highlights).to eq(['myMethod'])
-      expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' =>
-                                                 'camelCase')
-    end
-
-    it 'registers an offense for opposite + correct' do
-      inspect_source(cop, ['def my_method',
-                           'end',
-                           'def myMethod',
-                           'end'])
-      expect(cop.highlights).to eq(['myMethod'])
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    it 'registers an offense for camel case in singleton method name' do
-      inspect_source(cop, ['def self.myMethod',
-                           '  # ...',
-                           'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.highlights).to eq(['myMethod'])
-    end
-
-    it 'accepts snake case in names' do
-      inspect_source(cop, ['def my_method',
-                           'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    include_examples 'never accepted'
-    include_examples 'always accepted'
-  end
-
-  context 'when configured for camelCase' do
-    let(:cop_config) { { 'EnforcedStyle' => 'camelCase' } }
-
-    it 'accepts camel case in instance method name' do
-      inspect_source(cop, ['def myMethod',
-                           '  # ...',
-                           'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts camel case in singleton method name' do
-      inspect_source(cop, ['def self.myMethod',
-                           '  # ...',
-                           'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'registers an offense for snake case in names' do
-      inspect_source(cop, ['def my_method',
-                           'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.highlights).to eq(['my_method'])
-      expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' =>
-                                                 'snake_case')
-    end
-
-    it 'registers an offense for correct + opposite' do
-      inspect_source(cop, ['def my_method',
-                           'end',
-                           'def myMethod',
-                           'end'])
-      expect(cop.highlights).to eq(['my_method'])
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    include_examples 'always accepted'
-    include_examples 'never accepted'
-  end
-
-  context 'when configured with a bad value' do
-    let(:cop_config) { { 'EnforcedStyle' => 'other' } }
-
-    it 'fails' do
-      expect { inspect_source(cop, 'def a', 'end') }
-        .to raise_error(RuntimeError)
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::ModuleFunction do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for extend self in module' do
-    inspect_source(cop,
-                   ['module Test',
-                    '  extend self',
-                    '  def test; end',
-                    'end'])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'accepts extend self in class' do
-    inspect_source(cop,
-                   ['class Test',
-                    '  extend self',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-end

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

@@ -1,78 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::MultilineBlockChain do
-  subject(:cop) { described_class.new }
-
-  context 'with multi-line block chaining' do
-    it 'registers an offense for a simple case' do
-      inspect_source(cop, ['a do',
-                           '  b',
-                           'end.c do',
-                           '  d',
-                           'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.highlights).to eq(['end.c'])
-    end
-
-    it 'registers an offense for a slightly more complicated case' do
-      inspect_source(cop, ['a do',
-                           '  b',
-                           'end.c1.c2 do',
-                           '  d',
-                           'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.highlights).to eq(['end.c1.c2'])
-    end
-
-    it 'registers two offenses for a chain of three blocks' do
-      inspect_source(cop, ['a do',
-                           '  b',
-                           'end.c do',
-                           '  d',
-                           'end.e do',
-                           '  f',
-                           'end'])
-      expect(cop.offenses.size).to eq(2)
-      expect(cop.highlights).to eq(['end.c', 'end.e'])
-    end
-
-    it 'registers an offense for a chain where the second block is ' \
-       'single-line' do
-      inspect_source(cop, ['Thread.list.find_all { |t|',
-                           '  t.alive?',
-                           '}.map { |thread| thread.object_id }'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.highlights).to eq(['}.map'])
-    end
-
-    it 'accepts a chain where the first block is single-line' do
-      inspect_source(cop,
-                     ['Thread.list.find_all { |t| t.alive? }.map { |t| ',
-                      '  t.object_id',
-                      '}'])
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  it 'accepts a chain of blocks spanning one line' do
-    inspect_source(cop, ['a { b }.c { d }',
-                         'w do x end.y do z end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts a multi-line block chained with calls on one line' do
-    inspect_source(cop, ['a do',
-                         '  b',
-                         'end.c.d'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts a chain of calls followed by a multi-line block' do
-    inspect_source(cop, ['a1.a2.a3 do',
-                         '  b',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-end