ridecharge-rubocop 0.0.1

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

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::AccessorMethodName do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for method get_... with no args' do
+    inspect_source(cop, ['def get_attr',
+                         '  # ...',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.highlights).to eq(['get_attr'])
+  end
+
+  it 'registers an offence for singleton method get_... with no args' do
+    inspect_source(cop, ['def self.get_attr',
+                         '  # ...',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.highlights).to eq(['get_attr'])
+  end
+
+  it 'accepts method get_something with args' do
+    inspect_source(cop, ['def get_something(arg)',
+                         '  # ...',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts singleton method get_something with args' do
+    inspect_source(cop, ['def self.get_something(arg)',
+                         '  # ...',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'registers an offence for method set_something with one arg' do
+    inspect_source(cop, ['def set_attr(arg)',
+                         '  # ...',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.highlights).to eq(['set_attr'])
+  end
+
+  it 'registers an offence for singleton method set_... with one args' do
+    inspect_source(cop, ['def self.set_attr(arg)',
+                         '  # ...',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.highlights).to eq(['set_attr'])
+  end
+
+  it 'accepts method set_something with no args' do
+    inspect_source(cop, ['def set_something',
+                         '  # ...',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts singleton method set_something with no args' do
+    inspect_source(cop, ['def self.set_something',
+                         '  # ...',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts method set_something with two args' do
+    inspect_source(cop, ['def set_something(arg1, arg2)',
+                         '  # ...',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts singleton method set_something with two args' do
+    inspect_source(cop, ['def self.get_something(arg1, arg2)',
+                         '  # ...',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::Alias do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for alias with symbol args' do
+    inspect_source(cop,
+                   ['alias :ala :bala'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Use alias_method instead of alias.'])
+  end
+
+  it 'autocorrects alias with symbol args' do
+    corrected = autocorrect_source(cop, ['alias :ala :bala'])
+    expect(corrected).to eq 'alias_method :ala, :bala'
+  end
+
+  it 'registers an offence for alias with bareword args' do
+    inspect_source(cop,
+                   ['alias ala bala'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Use alias_method instead of alias.'])
+  end
+
+  it 'autocorrects alias with bareword args' do
+    corrected = autocorrect_source(cop, ['alias ala bala'])
+    expect(corrected).to eq 'alias_method :ala, :bala'
+  end
+
+  it 'does not register an offence for alias_method' do
+    inspect_source(cop,
+                   ['alias_method :ala, :bala'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for :alias' do
+    inspect_source(cop,
+                   ['[:alias, :ala, :bala]'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for alias with gvars' do
+    inspect_source(cop,
+                   ['alias $ala $bala'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts alias in an instance_exec block' do
+    inspect_source(cop,
+                   ['cli.instance_exec do',
+                    '  alias :old_trap_interrupt :trap_interrupt',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::AlignArray do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for misaligned array elements' do
+    inspect_source(cop, ['array = [',
+                         '  a,',
+                         '   b,',
+                         '  c,',
+                         '   d',
+                         ']'])
+    expect(cop.messages).to eq(['Align the elements of an array ' \
+                                'literal if they span more than ' +
+                                'one line.'] * 2)
+    expect(cop.highlights).to eq(%w(b d))
+  end
+
+  it 'accepts aligned array keys' do
+    inspect_source(cop, ['array = [',
+                         '  a,',
+                         '  b,',
+                         '  c,',
+                         '  d',
+                         ']'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts single line array' do
+    inspect_source(cop, 'array = [ a, b ]')
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts several elements per line' do
+    inspect_source(cop, ['array = [ a, b,',
+                         '          c, d ]'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'auto-corrects alignment' do
+    new_source = autocorrect_source(cop, ['array = [',
+                                          '  a,',
+                                          '   b,',
+                                          '  c,',
+                                          ' d',
+                                          ']'])
+    expect(new_source).to eq(['array = [',
+                              '  a,',
+                              '  b,',
+                              '  c,',
+                              '  d',
+                              ']'].join("\n"))
+  end
+
+  it 'auto-corrects array within array' do
+    original_source = ['[:l1,',
+                       '  [:l2,',
+                       '    [:l3,',
+                       '      [:l4]]]]']
+    new_source = autocorrect_source(cop, original_source)
+    expect(new_source).to eq(['[:l1,',
+                              ' [:l2,',
+                              '  [:l3,',
+                              '   [:l4]]]]'].join("\n"))
+  end
+
+  it 'auto-corrects only elements that begin a line' do
+    original_source = ['array = [:bar, {',
+                       '         whiz: 2, bang: 3 }, option: 3]']
+    new_source = autocorrect_source(cop, original_source)
+    expect(new_source).to eq(original_source.join("\n"))
+  end
+end

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

@@ -0,0 +1,310 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::AlignHash, :config do
+  shared_examples 'not on separate lines' do
+    it 'accepts single line hash' do
+      inspect_source(cop, 'func(a: 0, bb: 1)')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts several pairs per line' do
+      inspect_source(cop, ['func(a: 1, bb: 2,',
+                           '     ccc: 3, dddd: 4)'])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) do
+    {
+      'EnforcedHashRocketStyle' => 'key',
+      'EnforcedColonStyle' => 'key'
+    }
+  end
+
+  context 'with default configuration' do
+    it 'registers an offence for misaligned hash keys' do
+      inspect_source(cop, ['hash1 = {',
+                           '  a: 0,',
+                           '   bb: 1',
+                           '}',
+                           'hash2 = {',
+                           "  'ccc' => 2,",
+                           " 'dddd'  =>  2",
+                           '}'])
+      expect(cop.messages).to eq(['Align the elements of a hash ' \
+                                  'literal if they span more than ' +
+                                  'one line.'] * 2)
+      expect(cop.highlights).to eq(['bb: 1',
+                                    "'dddd'  =>  2"])
+    end
+
+    it 'accepts aligned hash keys' do
+      inspect_source(cop, ['hash1 = {',
+                           '  a: 0,',
+                           '  bb: 1,',
+                           '}',
+                           'hash2 = {',
+                           "  'ccc' => 2,",
+                           "  'dddd'  =>  2",
+                           '}'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'registers an offence for separator alignment' do
+      inspect_source(cop, ['hash = {',
+                           "    'a' => 0,",
+                           "  'bbb' => 1",
+                           '}'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(["'bbb' => 1"])
+    end
+
+    context 'with braceless hash as last argument' do
+      it 'registers an offence for misaligned hash keys' do
+        inspect_source(cop, ['func(a: 0,',
+                             '  b: 1)'])
+        expect(cop.offences.size).to eq(1)
+      end
+
+      it 'registers an offence for right alignment of keys' do
+        inspect_source(cop, ['func(a: 0,',
+                             '   bbb: 1)'])
+        expect(cop.offences.size).to eq(1)
+      end
+
+      it 'accepts aligned hash keys' do
+        inspect_source(cop, ['func(a: 0,',
+                             '     b: 1)'])
+        expect(cop.offences).to be_empty
+      end
+
+      it 'accepts an empty hash' do
+        inspect_source(cop, 'h = {}')
+        expect(cop.offences).to be_empty
+      end
+    end
+
+    it 'auto-corrects alignment' do
+      new_source = autocorrect_source(cop, ['hash1 = { a: 0,',
+                                            '     bb: 1,',
+                                            '           ccc: 2 }',
+                                            'hash2 = { :a   => 0,',
+                                            '     :bb  => 1,',
+                                            '          :ccc  =>2 }'
+                                           ])
+      expect(new_source).to eq(['hash1 = { a: 0,',
+                                '          bb: 1,',
+                                '          ccc: 2 }',
+                                'hash2 = { :a   => 0,',
+                                '          :bb  => 1,',
+                                # Separator and value are not corrected
+                                # in 'key' mode.
+                                '          :ccc  =>2 }'].join("\n"))
+    end
+  end
+
+  include_examples 'not on separate lines'
+
+  context 'with table alignment configuration' do
+    let(:cop_config) do
+      {
+        'EnforcedHashRocketStyle' => 'table',
+        'EnforcedColonStyle' => 'table'
+      }
+    end
+
+    include_examples 'not on separate lines'
+
+    it 'accepts aligned hash keys' do
+      inspect_source(cop, ['hash1 = {',
+                           "  'a'   => 0,",
+                           "  'bbb' => 1",
+                           '}',
+                           'hash2 = {',
+                           '  a:   0,',
+                           '  bbb: 1',
+                           '}'
+                          ])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts an empty hash' do
+      inspect_source(cop, 'h = {}')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts a multiline array of single line hashes' do
+      inspect_source(cop, ['def self.scenarios_order',
+                           '    [',
+                           '      { before:   %w( l k ) },',
+                           '      { ending:   %w( m l ) },',
+                           '      { starting: %w( m n ) },',
+                           '      { after:    %w( n o ) }',
+                           '    ]',
+                           '  end'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'registers an offence for misaligned hash values' do
+      inspect_source(cop, ['hash1 = {',
+                           "  'a'   =>  0,",
+                           "  'bbb' => 1",
+                           '}',
+                           'hash2 = {',
+                           '  a:   0,',
+                           '  bbb:1',
+                           '}'
+                          ])
+      expect(cop.highlights).to eq(["'a'   =>  0",
+                                    'bbb:1'])
+    end
+
+    it 'registers an offence for misaligned hash rockets' do
+      inspect_source(cop, ['hash = {',
+                           "  'a'   => 0,",
+                           "  'bbb'  => 1",
+                           '}'])
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it 'auto-corrects alignment' do
+      new_source = autocorrect_source(cop, ['hash1 = { a: 0,',
+                                            '     bb:   1,',
+                                            '           ccc: 2 }',
+                                            "hash2 = { 'a' => 0,",
+                                            "     'bb' =>   1,",
+                                            "           'ccc'  =>2 }"])
+      expect(new_source).to eq(['hash1 = { a:   0,',
+                                '          bb:  1,',
+                                '          ccc: 2 }',
+                                "hash2 = { 'a'   => 0,",
+                                "          'bb'  => 1,",
+                                "          'ccc' => 2 }"].join("\n"))
+    end
+  end
+
+  context 'with table+separator alignment configuration' do
+    let(:cop_config) do
+      {
+        'EnforcedHashRocketStyle' => 'table',
+        'EnforcedColonStyle' => 'separator'
+      }
+    end
+
+    it 'accepts a single method argument entry with colon' do
+      inspect_source(cop, ['merge(parent: nil)'])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'with invalid configuration' do
+    let(:cop_config) do
+      {
+        'EnforcedHashRocketStyle' => 'junk',
+        'EnforcedColonStyle' => 'junk'
+      }
+    end
+    it 'fails' do
+      src = ['hash = {',
+             '  a: 0,',
+             '  bb: 1',
+             '}']
+      expect { inspect_source(cop, src) }.to raise_error(RuntimeError)
+    end
+  end
+
+  context 'with separator alignment configuration' do
+    let(:cop_config) do
+      {
+        'EnforcedHashRocketStyle' => 'separator',
+        'EnforcedColonStyle' => 'separator'
+      }
+    end
+
+    it 'accepts aligned hash keys' do
+      inspect_source(cop, ['hash1 = {',
+                           '    a: 0,',
+                           '  bbb: 1',
+                           '}',
+                           'hash2 = {',
+                           "    'a' => 0,",
+                           "  'bbb' => 1",
+                           '}'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts an empty hash' do
+      inspect_source(cop, 'h = {}')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'registers an offence for misaligned hash values' do
+      inspect_source(cop, ['hash = {',
+                           "    'a' =>  0,",
+                           "  'bbb' => 1",
+                           '}'])
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it 'registers an offence for misaligned hash rockets' do
+      inspect_source(cop, ['hash = {',
+                           "    'a'  => 0,",
+                           "  'bbb' =>  1",
+                           '}'])
+      expect(cop.offences.size).to eq(1)
+    end
+
+    include_examples 'not on separate lines'
+
+    it 'auto-corrects alignment' do
+      new_source = autocorrect_source(cop, ['hash1 = { a: 0,',
+                                            '     bb:    1,',
+                                            '           ccc: 2 }',
+                                            'hash2 = { a => 0,',
+                                            '     bb =>    1,',
+                                            '           ccc  =>2 }'])
+      expect(new_source).to eq(['hash1 = { a: 0,',
+                                '         bb: 1,',
+                                '        ccc: 2 }',
+                                'hash2 = { a => 0,',
+                                '         bb => 1,',
+                                '        ccc => 2 }'].join("\n"))
+    end
+  end
+
+  context 'with different settings for => and :' do
+    let(:cop_config) do
+      {
+        'EnforcedHashRocketStyle' => 'key',
+        'EnforcedColonStyle' => 'separator'
+      }
+    end
+
+    it 'registers offences for misaligned entries' do
+      inspect_source(cop, ['hash1 = {',
+                           '  a:   0,',
+                           '  bbb: 1',
+                           '}',
+                           'hash2 = {',
+                           "    'a' => 0,",
+                           "  'bbb' => 1",
+                           '}'])
+      expect(cop.highlights).to eq(['bbb: 1', "'bbb' => 1"])
+    end
+
+    it 'accepts aligned entries' do
+      inspect_source(cop, ['hash1 = {',
+                           '    a: 0,',
+                           '  bbb: 1',
+                           '}',
+                           'hash2 = {',
+                           "  'a' => 0,",
+                           "  'bbb' => 1",
+                           '}'])
+      expect(cop.offences).to be_empty
+    end
+  end
+end