ridecharge-rubocop 0.0.1

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

@@ -0,0 +1,33 @@
+# 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 offence' do
+      pending 'Is there a way to emit this warning without syntax errors?'
+
+      inspect_source(cop, source)
+
+      expect(cop.offences.size).to eq(1)
+      expect(cop.offences.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

@@ -0,0 +1,63 @@
+# 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 offence for literal #{lit} in &&" do
+      inspect_source(cop,
+                     ["if x && #{lit}",
+                      '  top',
+                      'end'
+                     ])
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it "registers an offence for literal #{lit} in complex cond" do
+      inspect_source(cop,
+                     ["if x && !(a && #{lit}) && y && z",
+                      '  top',
+                      'end'
+                     ])
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it "registers an offence for literal #{lit} in !" do
+      inspect_source(cop,
+                     ["if !#{lit}",
+                      '  top',
+                      'end'
+                     ])
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it "registers an offence for literal #{lit} in complex !" do
+      inspect_source(cop,
+                     ["if !(x && (y && #{lit}))",
+                      '  top',
+                      'end'
+                     ])
+      expect(cop.offences.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.offences).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.offences).to be_empty
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Lint::Loop do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for begin/end/while' do
+    inspect_source(cop, ['begin something; top; end while test'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for begin/end/until' do
+    inspect_source(cop, ['begin something; top; end until test'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts normal while' do
+    inspect_source(cop, ['while test; one; two; end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts normal until' do
+    inspect_source(cop, ['until test; one; two; end'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Lint::ParenthesesAsGroupedExpression do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for method call with space before the ' \
+    'parenthesis' do
+    inspect_source(cop, ['a.func (x)'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for predicate method call with space ' \
+    'before the parenthesis' do
+    inspect_source(cop, ['is? (x)'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for math expression' do
+    inspect_source(cop, ['puts (2 + 3) * 4'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts a method call without arguments' do
+    inspect_source(cop, ['func'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a method call with arguments but no parentheses' do
+    inspect_source(cop, ['puts x'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a chain of method calls' do
+    inspect_source(cop, ['a.b',
+                         'a.b 1',
+                         'a.b(1)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts method with parens as arg to method without' do
+    inspect_source(cop, ['a b(c)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts an operator call with argument in parentheses' do
+    inspect_source(cop, ['a % (b + c)',
+                         'a.b = (c == d)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a space inside opening paren followed by left paren' do
+    inspect_source(cop, ['a( (b) )'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Lint::RequireParentheses do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for missing parentheses around expression with ' \
+    '&& operator' do
+    inspect_source(cop, ["if day.is? 'monday' && month == :jan",
+                         '  foo',
+                         'end'])
+    expect(cop.highlights).to eq(["day.is? 'monday' && month == :jan"])
+    expect(cop.messages)
+      .to eq(['Use parentheses in the method call to avoid confusion about ' \
+              'precedence.'])
+  end
+
+  it 'registers an offence for missing parentheses around expression with ' \
+    '|| operator' do
+    inspect_source(cop, "day_is? 'tuesday' || true")
+    expect(cop.highlights).to eq(["day_is? 'tuesday' || true"])
+  end
+
+  it 'registers an offence for missing parentheses around expression in ' \
+    'ternary' do
+    inspect_source(cop, "wd.include? 'tuesday' && true == true ? a : b")
+    expect(cop.highlights).to eq(["wd.include? 'tuesday' && true == true"])
+  end
+
+  it 'accepts missing parentheses around expression with + operator' do
+    inspect_source(cop, ["if day_is? 'tuesday' + rest",
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts method calls without parentheses followed by keyword and/or' do
+    inspect_source(cop, ["if day.is? 'tuesday' and month == :jan",
+                         'end',
+                         "if day.is? 'tuesday' or month == :jan",
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts method calls that are all operations' do
+    inspect_source(cop, ['if current_level == max + 1',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts condition that is not a call' do
+    inspect_source(cop, ['if @debug',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts parentheses around expression with boolean operator' do
+    inspect_source(cop, ["if day.is?('tuesday' && true == true)",
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts method call with parentheses in ternary' do
+    inspect_source(cop, "wd.include?('tuesday' && true == true) ? a : b")
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts missing parentheses when method is not a predicate' do
+    inspect_source(cop, "weekdays.foo 'tuesday' && true == true")
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts calls to methods that are setters' do
+    inspect_source(cop, 's.version = @version || ">= 1.8.5"')
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts calls to methods that are operators' do
+    inspect_source(cop, 'a[b || c]')
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,131 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Lint::RescueException do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for rescue from Exception' do
+    inspect_source(cop,
+                   ['begin',
+                    '  something',
+                    'rescue Exception',
+                    '  #do nothing',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Avoid rescuing the Exception class.'])
+  end
+
+  it 'registers an offence for rescue with ::Exception' do
+    inspect_source(cop,
+                   ['begin',
+                    '  something',
+                    'rescue ::Exception',
+                    '  #do nothing',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Avoid rescuing the Exception class.'])
+  end
+
+  it 'registers an offence for rescue with StandardError, Exception' do
+    inspect_source(cop,
+                   ['begin',
+                    '  something',
+                    'rescue StandardError, Exception',
+                    '  #do nothing',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Avoid rescuing the Exception class.'])
+  end
+
+  it 'registers an offence for rescue with Exception => e' do
+    inspect_source(cop,
+                   ['begin',
+                    '  something',
+                    'rescue Exception => e',
+                    '  #do nothing',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Avoid rescuing the Exception class.'])
+  end
+
+  it 'does not register an offence for rescue with no class' do
+    inspect_source(cop,
+                   ['begin',
+                    '  something',
+                    '  return',
+                    'rescue',
+                    '  file.close',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for rescue with no class and => e' do
+    inspect_source(cop,
+                   ['begin',
+                    '  something',
+                    '  return',
+                    'rescue => e',
+                    '  file.close',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for rescue with other class' do
+    inspect_source(cop,
+                   ['begin',
+                    '  something',
+                    '  return',
+                    'rescue ArgumentError => e',
+                    '  file.close',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for rescue with other classes' do
+    inspect_source(cop,
+                   ['begin',
+                    '  something',
+                    '  return',
+                    'rescue EOFError, ArgumentError => e',
+                    '  file.close',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for rescue with a module prefix' do
+    inspect_source(cop,
+                   ['begin',
+                    '  something',
+                    '  return',
+                    'rescue Test::Exception => e',
+                    '  file.close',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not crash when the splat operator is used in a rescue' do
+    inspect_source(cop,
+                   ['ERRORS = [Exception]',
+                    'begin',
+                    '  a = 3 / 0',
+                    'rescue *ERRORS',
+                    '  puts e',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not crash when the namespace of a rescued class is in a local ' \
+    'variable' do
+    inspect_source(cop,
+                   ['adapter = current_adapter',
+                    'begin',
+                    'rescue adapter::ParseError',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,237 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Lint::ShadowingOuterLocalVariable do
+  subject(:cop) { described_class.new }
+
+  context 'when a block argument has same name ' \
+          'as an outer scope variable' do
+    let(:source) do
+      [
+        'def some_method',
+        '  foo = 1',
+        '  puts foo',
+        '  1.times do |foo|',
+        '  end',
+        'end'
+      ]
+    end
+
+    it 'registers an offence' do
+      inspect_source(cop, source)
+      expect(cop.offences.size).to eq(1)
+      expect(cop.offences.first.message)
+        .to include('Shadowing outer local variable - foo')
+      expect(cop.offences.first.line).to eq(4)
+    end
+
+    include_examples 'mimics MRI 2.1'
+  end
+
+  context 'when a splat block argument has same name ' \
+          'as an outer scope variable' do
+    let(:source) do
+      [
+        'def some_method',
+        '  foo = 1',
+        '  puts foo',
+        '  1.times do |*foo|',
+        '  end',
+        'end'
+      ]
+    end
+
+    it 'registers an offence' do
+      inspect_source(cop, source)
+      expect(cop.offences.size).to eq(1)
+      expect(cop.offences.first.message)
+        .to include('Shadowing outer local variable - foo')
+      expect(cop.offences.first.line).to eq(4)
+    end
+
+    include_examples 'mimics MRI 2.1'
+  end
+
+  context 'when a block block argument has same name ' \
+          'as an outer scope variable' do
+    let(:source) do
+      [
+        'def some_method',
+        '  foo = 1',
+        '  puts foo',
+        '  proc_taking_block = proc do |&foo|',
+        '  end',
+        '  proc_taking_block.call do',
+        '  end',
+        'end'
+      ]
+    end
+
+    it 'registers an offence' do
+      inspect_source(cop, source)
+      expect(cop.offences.size).to eq(1)
+      expect(cop.offences.first.message)
+        .to include('Shadowing outer local variable - foo')
+      expect(cop.offences.first.line).to eq(4)
+    end
+
+    include_examples 'mimics MRI 2.1'
+  end
+
+  context 'when a block local variable has same name ' \
+          'as an outer scope variable' do
+    let(:source) do
+      [
+        'def some_method',
+        '  foo = 1',
+        '  puts foo',
+        '  1.times do |i; foo|',
+        '    puts foo',
+        '  end',
+        'end'
+      ]
+    end
+
+    it 'registers an offence' do
+      inspect_source(cop, source)
+      expect(cop.offences.size).to eq(1)
+      expect(cop.offences.first.message)
+        .to include('Shadowing outer local variable - foo')
+      expect(cop.offences.first.line).to eq(4)
+    end
+
+    include_examples 'mimics MRI 2.1', 'shadowing'
+  end
+
+  context 'when a block argument has different name ' \
+          'with outer scope variables' do
+    let(:source) do
+      [
+        'def some_method',
+        '  foo = 1',
+        '  puts foo',
+        '  1.times do |bar|',
+        '  end',
+        'end'
+      ]
+    end
+
+    include_examples 'accepts'
+    include_examples 'mimics MRI 2.1'
+  end
+
+  context 'when an outer scope variable is reassigned in a block' do
+    let(:source) do
+      [
+        'def some_method',
+        '  foo = 1',
+        '  puts foo',
+        '  1.times do',
+        '    foo = 2',
+        '  end',
+        'end'
+      ]
+    end
+
+    include_examples 'accepts'
+    include_examples 'mimics MRI 2.1'
+  end
+
+  context 'when an outer scope variable is referenced in a block' do
+    let(:source) do
+      [
+        'def some_method',
+        '  foo = 1',
+        '  puts foo',
+        '  1.times do',
+        '    puts foo',
+        '  end',
+        'end'
+      ]
+    end
+
+    include_examples 'accepts'
+    include_examples 'mimics MRI 2.1'
+  end
+
+  context 'when multiple block arguments have same name "_"' do
+    let(:source) do
+      [
+        'def some_method',
+        '  1.times do |_, foo, _|',
+        '  end',
+        'end'
+      ]
+    end
+
+    include_examples 'accepts'
+    include_examples 'mimics MRI 2.1'
+  end
+
+  context 'when multiple block arguments have ' \
+          'a same name starts with "_"' do
+    let(:source) do
+      [
+        'def some_method',
+        '  1.times do |_foo, bar, _foo|',
+        '  end',
+        'end'
+      ]
+    end
+
+    include_examples 'accepts' unless RUBY_VERSION < '2.0'
+    include_examples 'mimics MRI 2.1'
+  end
+
+  context 'when a block argument has same name "_" ' \
+          'as outer scope variable "_"' do
+    let(:source) do
+      [
+        'def some_method',
+        '  _ = 1',
+        '  puts _',
+        '  1.times do |_|',
+        '  end',
+        'end'
+      ]
+    end
+
+    include_examples 'accepts'
+    include_examples 'mimics MRI 2.1'
+  end
+
+  context 'when a block argument has a same name starts with "_" ' \
+          'as an outer scope variable' do
+    let(:source) do
+      [
+        'def some_method',
+        '  _foo = 1',
+        '  puts _foo',
+        '  1.times do |_foo|',
+        '  end',
+        'end'
+      ]
+    end
+
+    include_examples 'accepts'
+    include_examples 'mimics MRI 2.1'
+  end
+
+  context 'when a method argument has same name ' \
+          'as an outer scope variable' do
+    let(:source) do
+      [
+        'class SomeClass',
+        '  foo = 1',
+        '  puts foo',
+        '  def some_method(foo)',
+        '  end',
+        'end'
+      ]
+    end
+
+    include_examples 'accepts'
+    include_examples 'mimics MRI 2.1'
+  end
+end