ridecharge-rubocop 0.0.1

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

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::Proc do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for a Proc.new call' do
+    inspect_source(cop, ['f = Proc.new { |x| puts x }'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts the proc method' do
+    inspect_source(cop, ['f = proc { |x| puts x }'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts the Proc.new call outside of block' do
+    inspect_source(cop, ['p = Proc.new'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'auto-corrects Proc.new to proc' do
+    corrected = autocorrect_source(cop, ['Proc.new { test }'])
+    expect(corrected).to eq 'proc { test }'
+  end
+end

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

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::RaiseArgs, :config do
+  subject(:cop) { described_class.new(config) }
+
+  context 'when enforced style is compact' do
+    let(:cop_config) { { 'EnforcedStyle' => 'compact' } }
+
+    it 'reports an offence for a raise with 2 args' do
+      inspect_source(cop, ['raise RuntimeError, msg'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.config_to_allow_offences).to eq('EnforcedStyle' => 'exploded')
+    end
+
+    it 'reports an offence for correct + opposite' do
+      inspect_source(cop, ['if a',
+                           '  raise RuntimeError, msg',
+                           'else',
+                           '  raise Ex.new(msg)',
+                           'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
+    it 'reports an offence for a raise with 3 args' do
+      inspect_source(cop, ['raise RuntimeError, msg, caller'])
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it 'accepts a raise with msg argument' do
+      inspect_source(cop, ['raise msg'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts a raise with an exception argument' do
+      inspect_source(cop, ['raise Ex.new(msg)'])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'when enforced style is exploded' do
+    let(:cop_config) { { 'EnforcedStyle' => 'exploded' } }
+
+    it 'reports an offence for a raise with exception object' do
+      inspect_source(cop, ['raise Ex.new(msg)'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.config_to_allow_offences).to eq('EnforcedStyle' => 'compact')
+    end
+
+    it 'reports an offence for opposite + correct' do
+      inspect_source(cop, ['if a',
+                           '  raise RuntimeError, msg',
+                           'else',
+                           '  raise Ex.new(msg)',
+                           'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
+    it 'accepts exception constructor with more than 1 argument' do
+      inspect_source(cop, ['raise RuntimeError.new(a1, a2, a3)'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts a raise with 3 args' do
+      inspect_source(cop, ['raise RuntimeError, msg, caller'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts a raise with 2 args' do
+      inspect_source(cop, ['raise RuntimeError, msg'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts a raise with msg argument' do
+      inspect_source(cop, ['raise msg'])
+      expect(cop.offences).to be_empty
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::RedundantBegin do
+  subject(:cop) { described_class.new }
+
+  it 'reports an offence for def with redundant begin block' do
+    src = ['def func',
+           '  begin',
+           '    ala',
+           '  rescue => e',
+           '    bala',
+           '  end',
+           'end']
+    inspect_source(cop, src)
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'reports an offence for defs with redundant begin block' do
+    src = ['def Test.func',
+           '  begin',
+           '    ala',
+           '  rescue => e',
+           '    bala',
+           '  end',
+           'end']
+    inspect_source(cop, src)
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts a def with required begin block' do
+    src = ['def func',
+           '  begin',
+           '    ala',
+           '  rescue => e',
+           '    bala',
+           '  end',
+           '  something',
+           'end']
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a defs with required begin block' do
+    src = ['def Test.func',
+           '  begin',
+           '    ala',
+           '  rescue => e',
+           '    bala',
+           '  end',
+           '  something',
+           'end']
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::RedundantException do
+  subject(:cop) { described_class.new }
+
+  it 'reports an offence for a raise with RuntimeError' do
+    inspect_source(cop, ['raise RuntimeError, msg'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'reports an offence for a fail with RuntimeError' do
+    inspect_source(cop, ['fail RuntimeError, msg'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts a raise with RuntimeError if it does not have 2 args' do
+    inspect_source(cop, ['raise RuntimeError, msg, caller'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a fail with RuntimeError if it does not have 2 args' do
+    inspect_source(cop, ['fail RuntimeError, msg, caller'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,171 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::RedundantReturn, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'AllowMultipleReturnValues' => false } }
+
+  it 'reports an offence for def with only a return' do
+    src = ['def func',
+           '  return something',
+           'end']
+    inspect_source(cop, src)
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'reports an offence for defs with only a return' do
+    src = ['def Test.func',
+           '  return something',
+           'end']
+    inspect_source(cop, src)
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'reports an offence for def ending with return' do
+    src = ['def func',
+           '  one',
+           '  two',
+           '  return something',
+           'end']
+    inspect_source(cop, src)
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'reports an offence for defs ending with return' do
+    src = ['def func',
+           '  one',
+           '  two',
+           '  return something',
+           'end']
+    inspect_source(cop, src)
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts return in a non-final position' do
+    src = ['def func',
+           '  return something if something_else',
+           'end']
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not blow up on empty method body' do
+    src = ['def func',
+           'end']
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'auto-corrects by removing redundant returns' do
+    src = ['def func',
+           '  one',
+           '  two',
+           '  return something',
+           'end'].join("\n")
+    result_src = ['def func',
+                  '  one',
+                  '  two',
+                  '  something',
+                  'end'].join("\n")
+    new_source = autocorrect_source(cop, src)
+    expect(new_source).to eq(result_src)
+  end
+
+  context 'when multi-value returns are not allowed' do
+    it 'reports an offence for def with only a return' do
+      src = ['def func',
+             '  return something, test',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it 'reports an offence for defs with only a return' do
+      src = ['def Test.func',
+             '  return something, test',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it 'reports an offence for def ending with return' do
+      src = ['def func',
+             '  one',
+             '  two',
+             '  return something, test',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it 'reports an offence for defs ending with return' do
+      src = ['def func',
+             '  one',
+             '  two',
+             '  return something, test',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it 'auto-corrects by making implicit arrays explicit' do
+      src = ['def func',
+             '  return  1, 2',
+             'end'].join("\n")
+      result_src = ['def func',
+                    '  [1, 2]', # Just 1, 2 is not valid Ruby.
+                    'end'].join("\n")
+      new_source = autocorrect_source(cop, src)
+      expect(new_source).to eq(result_src)
+    end
+  end
+
+  context 'when multi-value returns are allowed' do
+    let(:cop_config) { { 'AllowMultipleReturnValues' => true } }
+
+    it 'accepts def with only a return' do
+      src = ['def func',
+             '  return something, test',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts defs with only a return' do
+      src = ['def Test.func',
+             '  return something, test',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts def ending with return' do
+      src = ['def func',
+             '  one',
+             '  two',
+             '  return something, test',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts defs ending with return' do
+      src = ['def func',
+             '  one',
+             '  two',
+             '  return something, test',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offences).to be_empty
+    end
+
+    it 'does not auto-correct' do
+      src = ['def func',
+             '  return  1, 2',
+             'end'].join("\n")
+      new_source = autocorrect_source(cop, src)
+      expect(new_source).to eq(src)
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::RedundantSelf do
+  subject(:cop) { described_class.new }
+
+  it 'reports an offence a self receiver on an rvalue' do
+    src = ['a = self.b']
+    inspect_source(cop, src)
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts a self receiver on an lvalue of an assignment' do
+    src = ['self.a = b']
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a self receiver on an lvalue of an or-assignment' do
+    src = ['self.logger ||= Rails.logger']
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a self receiver on an lvalue of an and-assignment' do
+    src = ['self.flag &&= value']
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a self receiver on an lvalue of a plus-assignment' do
+    src = ['self.sum += 10']
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a self receiver with the square bracket operator' do
+    src = ['self[a]']
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a self receiver with the double less-than operator' do
+    src = ['self << a']
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a self receiver for methods named like ruby keywords' do
+    src = ['a = self.class',
+           'self.for(deps, [], true)',
+           'self.and(other)',
+           'self.or(other)',
+           'self.alias',
+           'self.begin',
+           'self.break',
+           'self.case',
+           'self.def',
+           'self.defined',
+           'self.do',
+           'self.else',
+           'self.elsif',
+           'self.end',
+           'self.ensure',
+           'self.false',
+           'self.if',
+           'self.in',
+           'self.module',
+           'self.next',
+           'self.nil',
+           'self.not',
+           'self.redo',
+           'self.rescue',
+           'self.retry',
+           'self.return',
+           'self.self',
+           'self.super',
+           'self.then',
+           'self.true',
+           'self.undef',
+           'self.unless',
+           'self.until',
+           'self.when',
+           'self.while',
+           'self.yield'
+          ]
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a self receiver used to distinguish from blockarg' do
+    src = ['def requested_specs(&groups)',
+           '  some_method(self.groups)',
+           'end'
+          ]
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a self receiver used to distinguish from argument' do
+    src = ['def requested_specs(groups)',
+           '  some_method(self.groups)',
+           'end'
+          ]
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a self receiver used to distinguish from argument' do
+    src = ['def requested_specs(final = true)',
+           '  something if self.final != final',
+           'end'
+          ]
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a self receiver used to distinguish from local variable' do
+    src = ['def requested_specs',
+           '  @requested_specs ||= begin',
+           '    groups = self.groups - Bundler.settings.without',
+           '    groups.map! { |g| g.to_sym }',
+           '    specs_for(groups)',
+           '  end',
+           'end'
+          ]
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a self receiver used to distinguish from constant' do
+    src = ['self.Foo']
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'auto-corrects by removing redundant self' do
+    new_source = autocorrect_source(cop, ['self.x'])
+    expect(new_source).to eq('x')
+  end
+end