rubocop 0.29.1 → 0.30.0

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

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::NilComparison do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for == nil' do
-    inspect_source(cop, 'x == nil')
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.highlights).to eq(['=='])
-  end
-
-  it 'registers an offense for === nil' do
-    inspect_source(cop, 'x === nil')
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.highlights).to eq(['==='])
-  end
-
-  it 'autocorrects by replacing == nil with .nil?' do
-    corrected = autocorrect_source(cop, 'x == nil')
-    expect(corrected).to eq 'x.nil?'
-  end
-
-  it 'autocorrects by replacing === nil with .nil?' do
-    corrected = autocorrect_source(cop, 'x === nil')
-    expect(corrected).to eq 'x.nil?'
-  end
-end

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

@@ -1,132 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::NonNilCheck, :config do
-  subject(:cop) { described_class.new(config) }
-
-  context 'when not allowing semantic changes' do
-    let(:cop_config) do
-      {
-        'IncludeSemanticChanges' => false
-      }
-    end
-
-    it 'registers an offense for != nil' do
-      inspect_source(cop, 'x != nil')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.highlights).to eq(['!='])
-      expect(cop.messages)
-        .to eq(['Prefer `!expression.nil?` over `expression != nil`.'])
-    end
-
-    it 'does not register an offense for != 0' do
-      inspect_source(cop, 'x != 0')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'does not register an offense for !x.nil?' do
-      inspect_source(cop, '!x.nil?')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'does not register an offense for not x.nil?' do
-      inspect_source(cop, 'not x.nil?')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'does not register an offense if only expression in predicate' do
-      inspect_source(cop, ['def signed_in?',
-                           '  !current_user.nil?',
-                           'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'does not register an offense if only expression in class predicate' do
-      inspect_source(cop, ['def Test.signed_in?',
-                           '  current_user != nil',
-                           'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'does not register an offense if last expression in predicate' do
-      inspect_source(cop, ['def signed_in?',
-                           '  something',
-                           '  current_user != nil',
-                           'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'does not register an offense if last expression in class predicate' do
-      inspect_source(cop, ['def Test.signed_in?',
-                           '  something',
-                           '  current_user != nil',
-                           'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'autocorrects by changing `!= nil` to `!x.nil?`' do
-      corrected = autocorrect_source(cop, 'x != nil')
-      expect(corrected).to eq '!x.nil?'
-    end
-
-    it 'does not autocorrect by removing non-nil (!x.nil?) check' do
-      corrected = autocorrect_source(cop, '!x.nil?')
-      expect(corrected).to eq '!x.nil?'
-    end
-
-    it 'does not blow up when autocorrecting implicit receiver' do
-      corrected = autocorrect_source(cop, '!nil?')
-      expect(corrected).to eq '!nil?'
-    end
-  end
-
-  context 'when allowing semantic changes' do
-    subject(:cop) { described_class.new(config) }
-
-    let(:cop_config) do
-      {
-        'IncludeSemanticChanges' => true
-      }
-    end
-
-    it 'registers an offense for `!x.nil?`' do
-      inspect_source(cop, '!x.nil?')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Explicit non-nil checks are usually redundant.'])
-      expect(cop.highlights).to eq(['!x.nil?'])
-    end
-
-    it 'does not register an offense for `x.nil?`' do
-      inspect_source(cop, 'x.nil?')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'does not register an offense for `!x`' do
-      inspect_source(cop, '!x')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'registers an offense for `not x.nil?`' do
-      inspect_source(cop, 'not x.nil?')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.highlights).to eq(['not x.nil?'])
-    end
-
-    it 'autocorrects by changing `x != nil` to `x`' do
-      corrected = autocorrect_source(cop, 'x != nil')
-      expect(corrected).to eq 'x'
-    end
-
-    it 'autocorrects by changing `!x.nil?` to `x`' do
-      corrected = autocorrect_source(cop, '!x.nil?')
-      expect(corrected).to eq 'x'
-    end
-
-    it 'does not blow up when autocorrecting implicit receiver' do
-      corrected = autocorrect_source(cop, '!nil?')
-      expect(corrected).to eq 'self'
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::Not do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for not' do
-    inspect_source(cop, 'not test')
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'does not register an offense for !' do
-    inspect_source(cop, '!test')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'auto-corrects "not" with !' do
-    new_source = autocorrect_source(cop, 'x = 10 if not y')
-    expect(new_source).to eq('x = 10 if !y')
-  end
-
-  it 'leaves "not" as is if auto-correction changes the meaning' do
-    src = 'not x < y'
-    new_source = autocorrect_source(cop, src)
-    expect(new_source).to eq(src)
-  end
-end

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

@@ -1,80 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::NumericLiterals, :config do
-  subject(:cop) { described_class.new(config) }
-  let(:cop_config) { { 'MinDigits' => 5 } }
-
-  it 'registers an offense for a long undelimited integer' do
-    inspect_source(cop, 'a = 12345')
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.config_to_allow_offenses).to eq('MinDigits' => 6)
-  end
-
-  it 'registers an offense for a float with a long undelimited integer part' do
-    inspect_source(cop, 'a = 123456.789')
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.config_to_allow_offenses).to eq('MinDigits' => 7)
-  end
-
-  it 'registers an offense for an integer with misplaced underscore' do
-    inspect_source(cop, 'a = 123_456_78_90_00')
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-  end
-
-  it 'accepts long numbers with underscore' do
-    inspect_source(cop, ['a = 123_456',
-                         'b = 123_456.55'])
-    expect(cop.messages).to be_empty
-  end
-
-  it 'accepts a short integer without underscore' do
-    inspect_source(cop, 'a = 123')
-    expect(cop.messages).to be_empty
-  end
-
-  it 'does not count a leading minus sign as a digit' do
-    inspect_source(cop, 'a = -1230')
-    expect(cop.messages).to be_empty
-  end
-
-  it 'accepts short numbers without underscore' do
-    inspect_source(cop, ['a = 123',
-                         'b = 123.456'])
-    expect(cop.messages).to be_empty
-  end
-
-  it 'ignores non-decimal literals' do
-    inspect_source(cop, ['a = 0b1010101010101',
-                         'b = 01717171717171',
-                         'c = 0xab11111111bb'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'autocorrects a long integer offense' do
-    corrected = autocorrect_source(cop, ['a = 123456'])
-    expect(corrected).to eq 'a = 123_456'
-  end
-
-  it 'autocorrects an integer with misplaced underscore' do
-    corrected = autocorrect_source(cop, ['a = 123_456_78_90_00'])
-    expect(corrected).to eq 'a = 123_456_789_000'
-  end
-
-  it 'autocorrects negative numbers' do
-    corrected = autocorrect_source(cop, ['a = -123456'])
-    expect(corrected).to eq 'a = -123_456'
-  end
-
-  it 'autocorrects floating-point numbers' do
-    corrected = autocorrect_source(cop, ['a = 123456.78'])
-    expect(corrected).to eq 'a = 123_456.78'
-  end
-
-  it 'autocorrects negative floating-point numbers' do
-    corrected = autocorrect_source(cop, ['a = -123456.78'])
-    expect(corrected).to eq 'a = -123_456.78'
-  end
-end

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

@@ -1,13 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::OneLineConditional do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for one line if/then/end' do
-    inspect_source(cop, 'if cond then run else dont end')
-    expect(cop.messages).to eq(['Favor the ternary operator (?:)' \
-                                ' over if/then/else/end constructs.'])
-  end
-end

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

@@ -1,85 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::OpMethod do
-  subject(:cop) { described_class.new }
-
-  [:+, :eql?, :equal?].each do |op|
-    it "registers an offense for #{op} with arg not named other" do
-      inspect_source(cop,
-                     ["def #{op}(another)",
-                      '  another',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(["When defining the `#{op}` operator, " \
-                'name its argument `other`.'])
-    end
-  end
-
-  it 'works properly even if the argument not surrounded with braces' do
-    inspect_source(cop,
-                   ['def + another',
-                    '  another',
-                    'end'])
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.messages)
-      .to eq(['When defining the `+` operator, name its argument `other`.'])
-  end
-
-  it 'does not register an offense for arg named other' do
-    inspect_source(cop,
-                   ['def +(other)',
-                    '  other',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not register an offense for arg named _other' do
-    inspect_source(cop,
-                   ['def <=>(_other)',
-                    '  0',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not register an offense for []' do
-    inspect_source(cop,
-                   ['def [](index)',
-                    '  other',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not register an offense for []=' do
-    inspect_source(cop,
-                   ['def []=(index, value)',
-                    '  other',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not register an offense for <<' do
-    inspect_source(cop,
-                   ['def <<(cop)',
-                    '  other',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not register an offense for non binary operators' do
-    inspect_source(cop,
-                   ['def -@', # Unary minus
-                    'end',
-                    '',
-                    # This + is not a unary operator. It can only be
-                    # called with dot notation.
-                    'def +',
-                    'end',
-                    '',
-                    'def *(a, b)', # Quite strange, but legal ruby.
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-end

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

@@ -1,161 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::ParenthesesAroundCondition, :config do
-  subject(:cop) { described_class.new(config) }
-  let(:cop_config) { { 'AllowSafeAssignment' => true } }
-
-  it 'registers an offense for parentheses around condition' do
-    inspect_source(cop, ['if (x > 10)',
-                         'elsif (x < 3)',
-                         'end',
-                         'unless (x > 10)',
-                         'end',
-                         'while (x > 10)',
-                         'end',
-                         'until (x > 10)',
-                         'end',
-                         'x += 1 if (x < 10)',
-                         'x += 1 unless (x < 10)',
-                         'x += 1 until (x < 10)',
-                         'x += 1 while (x < 10)'
-                        ])
-    expect(cop.offenses.size).to eq(9)
-    expect(cop.messages.first)
-      .to eq("Don't use parentheses around the condition of an `if`.")
-    expect(cop.messages.last)
-      .to eq("Don't use parentheses around the condition of a `while`.")
-  end
-
-  it 'accepts parentheses if there is no space between the keyword and (.' do
-    inspect_source(cop, ['if(x > 5) then something end',
-                         'do_something until(x > 5)'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'auto-corrects parentheses around condition' do
-    corrected = autocorrect_source(cop, ['if (x > 10)',
-                                         'elsif (x < 3)',
-                                         'end',
-                                         'unless (x > 10)',
-                                         'end',
-                                         'while (x > 10)',
-                                         'end',
-                                         'until (x > 10)',
-                                         'end',
-                                         'x += 1 if (x < 10)',
-                                         'x += 1 unless (x < 10)',
-                                         'x += 1 while (x < 10)',
-                                         'x += 1 until (x < 10)'
-                                        ])
-    expect(corrected).to eq ['if x > 10',
-                             'elsif x < 3',
-                             'end',
-                             'unless x > 10',
-                             'end',
-                             'while x > 10',
-                             'end',
-                             'until x > 10',
-                             'end',
-                             'x += 1 if x < 10',
-                             'x += 1 unless x < 10',
-                             'x += 1 while x < 10',
-                             'x += 1 until x < 10'
-                            ].join("\n")
-  end
-
-  it 'accepts condition without parentheses' do
-    inspect_source(cop, ['if x > 10',
-                         'end',
-                         'unless x > 10',
-                         'end',
-                         'while x > 10',
-                         'end',
-                         'until x > 10',
-                         'end',
-                         'x += 1 if x < 10',
-                         'x += 1 unless x < 10',
-                         'x += 1 while x < 10',
-                         'x += 1 until x < 10'
-                        ])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts parentheses around condition in a ternary' do
-    inspect_source(cop, '(a == 0) ? b : a')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'is not confused by leading parenthesis in subexpression' do
-    inspect_source(cop, '(a > b) && other ? one : two')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'is not confused by unbalanced parentheses' do
-    inspect_source(cop, ['if (a + b).c()',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  %w(rescue if unless while until).each do |op|
-    it "allows parens if the condition node is a modifier #{op} op" do
-      inspect_source(cop, ["if (something #{op} top)",
-                           'end'])
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  it 'does not blow up when the condition is a ternary op' do
-    inspect_source(cop, 'x if (a ? b : c)')
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  context 'safe assignment is allowed' do
-    it 'accepts variable assignment in condition surrounded with parentheses' do
-      inspect_source(cop,
-                     ['if (test = 10)',
-                      'end'
-                     ])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts element assignment in condition surrounded with parentheses' do
-      inspect_source(cop,
-                     ['if (test[0] = 10)',
-                      'end'
-                     ])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts setter in condition surrounded with parentheses' do
-      inspect_source(cop,
-                     ['if (self.test = 10)',
-                      'end'
-                     ])
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  context 'safe assignment is not allowed' do
-    let(:cop_config) { { 'AllowSafeAssignment' => false } }
-
-    it 'does not accept variable assignment in condition surrounded with ' \
-       'parentheses' do
-      inspect_source(cop,
-                     ['if (test = 10)',
-                      'end'
-                     ])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it 'does not accept element assignment in condition surrounded with ' \
-       'parentheses' do
-      inspect_source(cop,
-                     ['if (test[0] = 10)',
-                      'end'
-                     ])
-      expect(cop.offenses.size).to eq(1)
-    end
-  end
-end