rubocop 0.29.1 → 0.30.0

data/spec/rubocop/cop/lint/else_layout_spec.rb

@@ -1,65 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::ElseLayout do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for expr on same line as else' do
-    inspect_source(cop,
-                   ['if something',
-                    '  test',
-                    'else ala',
-                    '  something',
-                    '  test',
-                    'end'
-                   ])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'accepts proper else' do
-    inspect_source(cop,
-                   ['if something',
-                    '  test',
-                    'else',
-                    '  something',
-                    '  test',
-                    'end'
-                   ])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts single-expr else regardless of layout' do
-    inspect_source(cop,
-                   ['if something',
-                    '  test',
-                    'else bala',
-                    'end'
-                   ])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'can handle elsifs' do
-    inspect_source(cop,
-                   ['if something',
-                    '  test',
-                    'elsif something',
-                    '  bala',
-                    'else ala',
-                    '  something',
-                    '  test',
-                    'end'
-                   ])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'handles ternary ops' do
-    inspect_source(cop, 'x ? a : b')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'handles modifier forms' do
-    inspect_source(cop, 'x if something')
-    expect(cop.offenses).to be_empty
-  end
-end

data/spec/rubocop/cop/lint/empty_ensure_spec.rb

@@ -1,27 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::EmptyEnsure do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for empty ensure' do
-    inspect_source(cop,
-                   ['begin',
-                    '  something',
-                    'ensure',
-                    'end'])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'does not register an offense for non-empty ensure' do
-    inspect_source(cop,
-                   ['begin',
-                    '  something',
-                    '  return',
-                    'ensure',
-                    '  file.close',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-end

data/spec/rubocop/cop/lint/empty_interpolation_spec.rb

@@ -1,18 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::EmptyInterpolation do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for #{} in interpolation' do
-    inspect_source(cop, '"this is the #{}"')
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.highlights).to eq(['#{}'])
-  end
-
-  it 'accepts non-empty interpolation' do
-    inspect_source(cop, '"this is #{top} silly"')
-    expect(cop.offenses).to be_empty
-  end
-end

data/spec/rubocop/cop/lint/end_alignment_spec.rb

@@ -1,91 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::EndAlignment, :config do
-  subject(:cop) { described_class.new(config) }
-  let(:cop_config) { { 'AlignWith' => 'keyword' } }
-  let(:opposite) do
-    cop_config['AlignWith'] == 'keyword' ? 'variable' : 'keyword'
-  end
-
-  include_examples 'misaligned', '', 'class',  'Test',      '  end'
-  include_examples 'misaligned', '', 'module', 'Test',      '  end'
-  include_examples 'misaligned', '', 'if',     'test',      '  end'
-  include_examples 'misaligned', '', 'unless', 'test',      '  end'
-  include_examples 'misaligned', '', 'while',  'test',      '  end'
-  include_examples 'misaligned', '', 'until',  'test',      '  end'
-
-  include_examples 'aligned', 'class',  'Test',      'end'
-  include_examples 'aligned', 'module', 'Test',      'end'
-  include_examples 'aligned', 'if',     'test',      'end'
-  include_examples 'aligned', 'unless', 'test',      'end'
-  include_examples 'aligned', 'while',  'test',      'end'
-  include_examples 'aligned', 'until',  'test',      'end'
-
-  it 'can handle ternary if' do
-    inspect_source(cop, 'a = cond ? x : y')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'can handle modifier if' do
-    inspect_source(cop, 'a = x if cond')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'registers an offense for correct + opposite' do
-    inspect_source(cop, ['x = if a',
-                         '      a1',
-                         '    end',
-                         'y = if b',
-                         '  b1',
-                         'end'])
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.messages.first)
-      .to eq('`end` at 6, 0 is not aligned with `if` at 4, 4')
-    expect(cop.highlights.first).to eq('end')
-    expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-  end
-
-  context 'regarding assignment' do
-    context 'when AlignWith is keyword' do
-      include_examples 'misaligned', 'var = ', 'if',     'test', 'end'
-      include_examples 'misaligned', 'var = ', 'unless', 'test', 'end'
-      include_examples 'misaligned', 'var = ', 'while',  'test', 'end'
-      include_examples 'misaligned', 'var = ', 'until',  'test', 'end'
-
-      include_examples 'aligned', 'var = if',     'test', '      end'
-      include_examples 'aligned', 'var = unless', 'test', '      end'
-      include_examples 'aligned', 'var = while',  'test', '      end'
-      include_examples 'aligned', 'var = until',  'test', '      end'
-    end
-
-    context 'when AlignWith is variable' do
-      let(:cop_config) { { 'AlignWith' => 'variable' } }
-
-      include_examples 'aligned', 'var = if',     'test', 'end'
-      include_examples 'aligned', 'var = unless', 'test', 'end'
-      include_examples 'aligned', 'var = while',  'test', 'end'
-      include_examples 'aligned', 'var = until',  'test', 'end'
-      include_examples 'aligned', 'var = until',  'test', 'end.abc.join("")'
-      include_examples 'aligned', 'var = until',  'test', 'end.abc.tap {}'
-
-      include_examples 'misaligned', '', 'var = if',     'test', '      end'
-      include_examples 'misaligned', '', 'var = unless', 'test', '      end'
-      include_examples 'misaligned', '', 'var = while',  'test', '      end'
-      include_examples 'misaligned', '', 'var = until',  'test', '      end'
-      include_examples 'misaligned', '', 'var = until',  'test', '      end.j'
-
-      include_examples 'aligned', '@var = if',  'test', 'end'
-      include_examples 'aligned', '@@var = if', 'test', 'end'
-      include_examples 'aligned', '$var = if',  'test', 'end'
-      include_examples 'aligned', 'CNST = if',  'test', 'end'
-      include_examples 'aligned', 'a, b = if',  'test', 'end'
-      include_examples 'aligned', 'var ||= if', 'test', 'end'
-      include_examples 'aligned', 'var &&= if', 'test', 'end'
-      include_examples 'aligned', 'var += if',  'test', 'end'
-      include_examples 'aligned', 'h[k] = if',  'test', 'end'
-      include_examples 'aligned', 'h.k = if',   'test', 'end'
-    end
-  end
-end

data/spec/rubocop/cop/lint/end_in_method_spec.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::EndInMethod do
-  subject(:cop) { described_class.new }
-
-  it 'reports an offense for def with an END inside' do
-    src = ['def test',
-           '  END { something }',
-           'end']
-    inspect_source(cop, src)
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'reports an offense for defs with an END inside' do
-    src = ['def self.test',
-           '  END { something }',
-           'end']
-    inspect_source(cop, src)
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'accepts END outside of def(s)' do
-    src = 'END { something }'
-    inspect_source(cop, src)
-    expect(cop.offenses).to be_empty
-  end
-end

data/spec/rubocop/cop/lint/ensure_return_spec.rb

@@ -1,39 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::EnsureReturn do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for return in ensure' do
-    inspect_source(cop,
-                   ['begin',
-                    '  something',
-                    'ensure',
-                    '  file.close',
-                    '  return',
-                    'end'])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'does not register an offense for return outside ensure' do
-    inspect_source(cop,
-                   ['begin',
-                    '  something',
-                    '  return',
-                    'ensure',
-                    '  file.close',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not check when ensure block has no body' do
-    expect do
-      inspect_source(cop,
-                     ['begin',
-                      '  something',
-                      'ensure',
-                      'end'])
-    end.to_not raise_exception
-  end
-end

data/spec/rubocop/cop/lint/eval_spec.rb

@@ -1,33 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::Eval do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for eval as function' do
-    inspect_source(cop,
-                   'eval(something)')
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.highlights) .to eq(['eval'])
-  end
-
-  it 'registers an offense for eval as command' do
-    inspect_source(cop,
-                   'eval something')
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.highlights) .to eq(['eval'])
-  end
-
-  it 'does not register an offense for eval as variable' do
-    inspect_source(cop,
-                   'eval = something')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not register an offense for eval as method' do
-    inspect_source(cop,
-                   'something.eval')
-    expect(cop.offenses).to be_empty
-  end
-end

data/spec/rubocop/cop/lint/handle_exceptions_spec.rb

@@ -1,30 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::HandleExceptions do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for empty rescue block' do
-    inspect_source(cop,
-                   ['begin',
-                    '  something',
-                    'rescue',
-                    '  #do nothing',
-                    'end'])
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.messages)
-      .to eq(['Do not suppress exceptions.'])
-  end
-
-  it 'does not register an offense for rescue with body' do
-    inspect_source(cop,
-                   ['begin',
-                    '  something',
-                    '  return',
-                    'rescue',
-                    '  file.close',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-end

data/spec/rubocop/cop/lint/invalid_character_literal_spec.rb

@@ -1,33 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::InvalidCharacterLiteral do
-  subject(:cop) { described_class.new }
-
-  # Is there a way to emit this warning without syntax error?
-  #
-  #   $ ruby -w
-  #   p(? )
-  #   -:1: warning: invalid character syntax; use ?\s
-  #   -:1: syntax error, unexpected '?', expecting ')'
-  #   p(? )
-  #      ^
-  #
-  # https://github.com/ruby/ruby/blob/v2_1_0/parse.y#L7276
-  # https://github.com/whitequark/parser/blob/v2.1.2/lib/parser/lexer.rl#L1660
-  context 'with a non-escaped whitespace character literal' do
-    let(:source) { 'p(? )' }
-
-    it 'registers an offense' do
-      pending 'Is there a way to emit this warning without syntax errors?'
-
-      inspect_source(cop, source)
-
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.offenses.first.message)
-        .to eq('Invalid character literal; use ?\s')
-      expect(cop.highlights).to eq([' '])
-    end
-  end
-end

data/spec/rubocop/cop/lint/literal_in_condition_spec.rb

@@ -1,172 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::LiteralInCondition do
-  subject(:cop) { described_class.new }
-
-  %w(1 2.0 [1] {}).each do |lit|
-    it "registers an offense for literal #{lit} in if" do
-      inspect_source(cop,
-                     ["if #{lit}",
-                      '  top',
-                      'end'
-                     ])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "registers an offense for literal #{lit} in while" do
-      inspect_source(cop,
-                     ["while #{lit}",
-                      '  top',
-                      'end'
-                     ])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "registers an offense for literal #{lit} in post-loop while" do
-      inspect_source(cop,
-                     ['begin',
-                      '  top',
-                      "end while(#{lit})"
-                     ])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "registers an offense for literal #{lit} in until" do
-      inspect_source(cop,
-                     ["until #{lit}",
-                      '  top',
-                      'end'
-                     ])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "registers an offense for literal #{lit} in post-loop until" do
-      inspect_source(cop,
-                     ['begin',
-                      '  top',
-                      "end until #{lit}"
-                     ])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "registers an offense for literal #{lit} in case" do
-      inspect_source(cop,
-                     ["case #{lit}",
-                      'when x then top',
-                      'end'
-                     ])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "registers an offense for literal #{lit} in a when " \
-       'of a case without anything after case keyword' do
-      inspect_source(cop,
-                     ['case',
-                      "when #{lit} then top",
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "accepts literal #{lit} in a when of a case with " \
-       'something after case keyword' do
-      inspect_source(cop,
-                     ['case x',
-                      "when #{lit} then top",
-                      'end'
-                     ])
-      expect(cop.offenses).to be_empty
-    end
-
-    it "registers an offense for literal #{lit} in &&" do
-      inspect_source(cop,
-                     ["if x && #{lit}",
-                      '  top',
-                      'end'
-                     ])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "registers an offense for literal #{lit} in complex cond" do
-      inspect_source(cop,
-                     ["if x && !(a && #{lit}) && y && z",
-                      '  top',
-                      'end'
-                     ])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "registers an offense for literal #{lit} in !" do
-      inspect_source(cop,
-                     ["if !#{lit}",
-                      '  top',
-                      'end'
-                     ])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "registers an offense for literal #{lit} in complex !" do
-      inspect_source(cop,
-                     ["if !(x && (y && #{lit}))",
-                      '  top',
-                      'end'
-                     ])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "accepts literal #{lit} if it's not an and/or operand" do
-      inspect_source(cop,
-                     ["if test(#{lit})",
-                      '  top',
-                      'end'
-                     ])
-      expect(cop.offenses).to be_empty
-    end
-
-    it "accepts literal #{lit} in non-toplevel and/or" do
-      inspect_source(cop,
-                     ["if (a || #{lit}).something",
-                      '  top',
-                      'end'
-                     ])
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  it 'accepts array literal in case, if it has non-literal elements' do
-    inspect_source(cop,
-                   ['case [1, 2, x]',
-                    'when [1, 2, 5] then top',
-                    'end'
-                   ])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts array literal in case, if it has non-literal elements' do
-    inspect_source(cop,
-                   ['case [1, 2, [x, 1]]',
-                    'when [1, 2, 5] then top',
-                    'end'
-                   ])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'registers an offense for case with a primitive array condition' do
-    inspect_source(cop,
-                   ['case [1, 2, [3, 4]]',
-                    'when [1, 2, 5] then top',
-                    'end'
-                   ])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'accepts dstr literal in case' do
-    inspect_source(cop,
-                   ['case "#{x}"',
-                    'when [1, 2, 5] then top',
-                    'end'
-                   ])
-    expect(cop.offenses).to be_empty
-  end
-end