ridecharge-rubocop 0.0.1

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

@@ -0,0 +1,222 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::AlignParameters do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for parameters with single indent' do
+    inspect_source(cop, ['function(a,',
+                         '  if b then c else d end)'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.highlights).to eq(['if b then c else d end'])
+  end
+
+  it 'registers an offence for parameters with double indent' do
+    inspect_source(cop, ['function(a,',
+                         '    if b then c else d end)'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts multiline []= method call' do
+    inspect_source(cop, ['Test.config["something"] =',
+                         ' true'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts correctly aligned parameters' do
+    inspect_source(cop, ['function(a,',
+                         '         0, 1,',
+                         '         (x + y),',
+                         '         if b then c else d end)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts calls that only span one line' do
+    inspect_source(cop, ['find(path, s, @special[sexp[0]])'])
+    expect(cop.offences).to be_empty
+  end
+
+  it "doesn't get confused by a symbol argument" do
+    inspect_source(cop, ['add_offence(index,',
+                         '            MSG % kind)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it "doesn't get confused by splat operator" do
+    inspect_source(cop, ['func1(*a,',
+                         '      *b,',
+                         '      c)',
+                         'func2(a,',
+                         '     *b,',
+                         '      c)',
+                         'func3(*a)'
+                        ])
+    expect(cop.offences.map(&:to_s))
+      .to eq(['C:  5:  6: Align the parameters of a method call if ' \
+              'they span more than one line.'])
+    expect(cop.highlights).to eq(['*b'])
+  end
+
+  it "doesn't get confused by extra comma at the end" do
+    inspect_source(cop, ['func1(a,',
+                         '     b,)'])
+    expect(cop.offences.map(&:to_s))
+      .to eq(['C:  2:  6: Align the parameters of a method call if ' \
+              'they span more than one line.'])
+    expect(cop.highlights).to eq(['b'])
+  end
+
+  it 'can handle a correctly aligned string literal as first argument' do
+    inspect_source(cop, ['add_offence(x,',
+                         '            a)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'can handle a string literal as other argument' do
+    inspect_source(cop, ['add_offence(',
+                         '            "", a)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it "doesn't get confused by a line break inside a parameter" do
+    inspect_source(cop, ['read(path, { headers:    true,',
+                         '             converters: :numeric })'])
+    expect(cop.offences).to be_empty
+  end
+
+  it "doesn't get confused by symbols with embedded expressions" do
+    inspect_source(cop, ['send(:"#{name}_comments_path")'])
+    expect(cop.offences).to be_empty
+  end
+
+  it "doesn't get confused by regexen with embedded expressions" do
+    inspect_source(cop, ['a(/#{name}/)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts braceless hashes' do
+    inspect_source(cop, ['run(collection, :entry_name => label,',
+                         '                :paginator  => paginator)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts the first parameter being on a new row' do
+    inspect_source(cop, ['  match(',
+                         '    a,',
+                         '    b',
+                         '  )'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'can handle heredoc strings' do
+    inspect_source(cop, ['class_eval(<<-EOS, __FILE__, __LINE__ + 1)',
+                         '            def run_#{name}_callbacks(*args)',
+                         '              a = 1',
+                         '              return value',
+                         '            end',
+                         '            EOS'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'can handle a method call within a method call' do
+    inspect_source(cop, ['a(a1,',
+                         '  b(b1,',
+                         '    b2),',
+                         '  a2)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'can handle a call embedded in a string' do
+    inspect_source(cop, ['model("#{index(name)}", child)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'can handle do-end' do
+    inspect_source(cop, ['      run(lambda do |e|',
+                         "        w = e['warden']",
+                         '      end)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'can handle a call with a block inside another call' do
+    src = ['new(table_name,',
+           '    exec_query("info(\'#{row[\'name\']}\')").map { |col|',
+           "      col['name']",
+           '    })']
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'can handle a ternary condition with a block reference' do
+    inspect_source(cop, ['cond ? a : func(&b)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'can handle parentheses used with no parameters' do
+    inspect_source(cop, ['func()'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'can handle a multiline hash as second parameter' do
+    inspect_source(cop, ['tag(:input, {',
+                         '  :value => value',
+                         '})'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'can handle method calls without parentheses' do
+    inspect_source(cop, ['a(b c, d)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'can handle other method calls without parentheses' do
+    src = ['chars(Unicode.apply_mapping @wrapped_string, :uppercase)']
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'auto-corrects alignment' do
+    new_source = autocorrect_source(cop, ['func(a,',
+                                          '       b,',
+                                          'c)'])
+    expect(new_source).to eq(['func(a,',
+                              '     b,',
+                              '     c)'].join("\n"))
+  end
+
+  it 'auto-corrects each line of a multi-line parameter to the right' do
+    new_source =
+      autocorrect_source(cop,
+                         ['create :transaction, :closed,',
+                          '      account:          account,',
+                          '      open_price:       1.29,',
+                          '      close_price:      1.30'])
+    expect(new_source)
+      .to eq(['create :transaction, :closed,',
+              '       account:          account,',
+              '       open_price:       1.29,',
+              '       close_price:      1.30'].join("\n"))
+  end
+
+  it 'auto-corrects each line of a multi-line parameter to the left' do
+    new_source =
+      autocorrect_source(cop,
+                         ['create :transaction, :closed,',
+                          '         account:          account,',
+                          '         open_price:       1.29,',
+                          '         close_price:      1.30'])
+    expect(new_source)
+      .to eq(['create :transaction, :closed,',
+              '       account:          account,',
+              '       open_price:       1.29,',
+              '       close_price:      1.30'].join("\n"))
+  end
+
+  it 'auto-corrects only parameters that begin a line' do
+    original_source = ['foo(: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/and_or_spec.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::AndOr do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for OR' do
+    inspect_source(cop,
+                   ['test if a or b'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages).to eq(['Use || instead of or.'])
+  end
+
+  it 'registers an offence for AND' do
+    inspect_source(cop,
+                   ['test if a and b'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages).to eq(['Use && instead of and.'])
+  end
+
+  it 'accepts ||' do
+    inspect_source(cop,
+                   ['test if a || b'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts &&' do
+    inspect_source(cop,
+                   ['test if a && b'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'auto-corrects "and" with &&' do
+    new_source = autocorrect_source(cop, 'true and false')
+    expect(new_source).to eq('true && false')
+  end
+
+  it 'auto-corrects "or" with ||' do
+    new_source = autocorrect_source(cop, ['x = 12345',
+                                          'true or false'])
+    expect(new_source).to eq(['x = 12345',
+                              'true || false'].join("\n"))
+  end
+
+  it 'leaves *or* as is if auto-correction changes the meaning' do
+    src = "teststring.include? 'a' or teststring.include? 'b'"
+    new_source = autocorrect_source(cop, src)
+    expect(new_source).to eq(src)
+  end
+
+  it 'leaves *and* as is if auto-correction changes the meaning' do
+    src = 'x = a + b and return x'
+    new_source = autocorrect_source(cop, src)
+    expect(new_source).to eq(src)
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::AsciiComments do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for a comment with non-ascii chars' do
+    inspect_source(cop,
+                   ['# encoding: utf-8',
+                    '# 这是什么？'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Use only ascii symbols in comments.'])
+  end
+
+  it 'accepts comments with only ascii chars' do
+    inspect_source(cop,
+                   ['# AZaz1@$%~,;*_`|'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::AsciiIdentifiers do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for a variable name with non-ascii chars' do
+    inspect_source(cop,
+                   ['# encoding: utf-8',
+                    'älg = 1'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Use only ascii symbols in identifiers.'])
+  end
+
+  it 'accepts identifiers with only ascii chars' do
+    inspect_source(cop,
+                   ['x.empty?'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not get confused by a byte order mark' do
+    bom = "\xef\xbb\xbf"
+    inspect_source(cop,
+                   [bom + '# encoding: utf-8',
+                    "puts 'foo'"])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not get confused by an empty file' do
+    inspect_source(cop,
+                   [''])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::Attr do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence attr' do
+    inspect_source(cop, ['class SomeClass',
+                         '  attr :name',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'auto-corrects attr to attr_reader' do
+    new_source = autocorrect_source(cop, 'attr')
+    expect(new_source).to eq('attr_reader')
+  end
+end

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

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::BeginBlock do
+  subject(:cop) { described_class.new }
+
+  it 'reports an offence for a BEGIN block' do
+    src = ['BEGIN { test }']
+    inspect_source(cop, src)
+    expect(cop.offences.size).to eq(1)
+  end
+end

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

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::BlockComments do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for block comments' do
+    inspect_source(cop,
+                   ['=begin',
+                    'comment',
+                    '=end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts regular comments' do
+    inspect_source(cop,
+                   ['# comment'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,156 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::BlockNesting, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'Max' => 2 } }
+
+  it 'accepts `Max` levels of nesting' do
+    source = ['if a',
+              '  if b',
+              '    puts b',
+              '  end',
+              'end']
+    expect_nesting_offences(source, [])
+  end
+
+  it 'registers an offence for `Max + 1` levels of `if` nesting' do
+    source = ['if a',
+              '  if b',
+              '    if c',
+              '      puts c',
+              '    end',
+              '  end',
+              'end']
+    expect_nesting_offences(source, [3])
+  end
+
+  it 'registers a single offence for `Max + 2` levels of `if` nesting' do
+    source = ['if a',
+              '  if b',
+              '    if c',
+              '      if d',
+              '        puts d',
+              '      end',
+              '    end',
+              '  end',
+              'end']
+    expect_nesting_offences(source, [3])
+  end
+
+  it 'registers 2 offences' do
+    source = ['if a',
+              '  if b',
+              '    if c',
+              '      puts c',
+              '    end',
+              '  end',
+              '  if d',
+              '    if e',
+              '      puts e',
+              '    end',
+              '  end',
+              'end']
+    expect_nesting_offences(source, [3, 8])
+  end
+
+  it 'registers an offence for nested `case`' do
+    source = ['if a',
+              '  if b',
+              '    case c',
+              '      when C',
+              '        puts C',
+              '    end',
+              '  end',
+              'end']
+    expect_nesting_offences(source, [3])
+  end
+
+  it 'registers an offence for nested `while`' do
+    source = ['if a',
+              '  if b',
+              '    while c',
+              '      puts c',
+              '    end',
+              '  end',
+              'end']
+    expect_nesting_offences(source, [3])
+  end
+
+  it 'registers an offence for nested modifier `while`' do
+    source = ['if a',
+              '  if b',
+              '    begin',
+              '      puts c',
+              '    end while c',
+              '  end',
+              'end']
+    expect_nesting_offences(source, [3])
+  end
+
+  it 'registers an offence for nested `until`' do
+    source = ['if a',
+              '  if b',
+              '    until c',
+              '      puts c',
+              '    end',
+              '  end',
+              'end']
+    expect_nesting_offences(source, [3])
+  end
+
+  it 'registers an offence for nested modifier `until`' do
+    source = ['if a',
+              '  if b',
+              '    begin',
+              '      puts c',
+              '    end until c',
+              '  end',
+              'end']
+    expect_nesting_offences(source, [3])
+  end
+
+  it 'registers an offence for nested `for`' do
+    source = ['if a',
+              '  if b',
+              '    for c in [1,2] do',
+              '      puts c',
+              '    end',
+              '  end',
+              'end']
+    expect_nesting_offences(source, [3])
+  end
+
+  it 'registers an offence for nested `rescue`' do
+    source = ['if a',
+              '  if b',
+              '    begin',
+              '      puts c',
+              '    rescue',
+              '      puts x',
+              '    end',
+              '  end',
+              'end']
+    expect_nesting_offences(source, [5])
+  end
+
+  it 'accepts if/elsif' do
+    source = ['if a',
+              'elsif b',
+              'elsif c',
+              'elsif d',
+              'end']
+    expect_nesting_offences(source, [])
+  end
+
+  def expect_nesting_offences(source, lines, used_nesting_level = 3)
+    inspect_source(cop, source)
+    expect(cop.offences.map(&:line)).to eq(lines)
+    expect(cop.messages).to eq(
+      ['Avoid more than 2 levels of block nesting.'] * lines.length)
+    if cop.offences.size > 0
+      expect(cop.config_to_allow_offences['Max']).to eq(used_nesting_level)
+    end
+  end
+end