ridecharge-rubocop 0.0.1

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::ConstantName do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for camel case in const name' do
+    inspect_source(cop,
+                   ['TopCase = 5'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers offences for camel case in multiple const assignment' do
+    inspect_source(cop,
+                   ['TopCase, Test2, TEST_3 = 5, 6, 7'])
+    expect(cop.offences.size).to eq(2)
+  end
+
+  it 'registers an offence for snake case in const name' do
+    inspect_source(cop,
+                   ['TOP_test = 5'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'allows screaming snake case in const name' do
+    inspect_source(cop,
+                   ['TOP_TEST = 5'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'allows screaming snake case in multiple const assignment' do
+    inspect_source(cop,
+                   ['TOP_TEST, TEST_2 = 5, 6'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not check names if rhs is a method call' do
+    inspect_source(cop,
+                   ['AnythingGoes = test'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not check names if rhs is a method call with block' do
+    inspect_source(cop,
+                   ['AnythingGoes = test do',
+                    '  do_something',
+                    'end'
+                    ])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not check if rhs is another constant' do
+    inspect_source(cop,
+                   ['Parser::CurrentRuby = Parser::Ruby20'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'checks qualified const names' do
+    inspect_source(cop,
+                   ['::AnythingGoes = 30',
+                    'a::Bar_foo = 10'])
+    expect(cop.offences.size).to eq(2)
+  end
+end

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

@@ -0,0 +1,204 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::CyclomaticComplexity, :config do
+  subject(:cop) { described_class.new(config) }
+
+  context 'when Max is 1' do
+    let(:cop_config) { { 'Max' => 1 } }
+
+    it 'accepts a method with no decision points' do
+      inspect_source(cop, ['def method_name',
+                           '  call_foo',
+                           'end'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts complex code outside of methods' do
+      inspect_source(cop,
+                     ['def method_name',
+                      '  call_foo',
+                      'end',
+                      '',
+                      'if first_condition then',
+                      '  call_foo if second_condition && third_condition',
+                      '  call_bar if fourth_condition || fifth_condition',
+                      'end'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'registers an offence for an if modifier' do
+      inspect_source(cop, ['def self.method_name',
+                           '  call_foo if some_condition',
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
+      expect(cop.highlights).to eq(['def'])
+      expect(cop.config_to_allow_offences).to eq('Max' => 2)
+    end
+
+    it 'registers an offence for an unless modifier' do
+      inspect_source(cop, ['def method_name',
+                           '  call_foo unless some_condition',
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
+    end
+
+    it 'registers an offence for an elsif block' do
+      inspect_source(cop, ['def method_name',
+                           '  if first_condition then',
+                           '    call_foo',
+                           '  elsif second_condition then',
+                           '    call_bar',
+                           '  else',
+                           '    call_bam',
+                           '  end',
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Cyclomatic complexity for method_name is too high. [3/1]'])
+    end
+
+    it 'registers an offence for a ternary operator' do
+      inspect_source(cop, ['def method_name',
+                           '  value = some_condition ? 1 : 2',
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
+    end
+
+    it 'registers an offence for a while block' do
+      inspect_source(cop, ['def method_name',
+                           '  while some_condition do',
+                           '    call_foo',
+                           '  end',
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
+    end
+
+    it 'registers an offence for an until block' do
+      inspect_source(cop, ['def method_name',
+                           '  until some_condition do',
+                           '    call_foo',
+                           '  end',
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
+    end
+
+    it 'registers an offence for a for block' do
+      inspect_source(cop, ['def method_name',
+                           '  for i in 1..2 do',
+                           '    call_method',
+                           '  end',
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
+    end
+
+    it 'registers an offence for a rescue block' do
+      inspect_source(cop, ['def method_name',
+                           '  begin',
+                           '    call_foo',
+                           '  rescue Exception',
+                           '    call_bar',
+                           '  end',
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
+    end
+
+    it 'registers an offence for a case/when block' do
+      inspect_source(cop, ['def method_name',
+                           '  case value',
+                           '  when 1',
+                           '    call_foo',
+                           '  when 2',
+                           '    call_bar',
+                           '  end',
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Cyclomatic complexity for method_name is too high. [3/1]'])
+    end
+
+    it 'registers an offence for &&' do
+      inspect_source(cop, ['def method_name',
+                           '  call_foo && call_bar',
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
+    end
+
+    it 'registers an offence for and' do
+      inspect_source(cop, ['def method_name',
+                           '  call_foo and call_bar',
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
+    end
+
+    it 'registers an offence for ||' do
+      inspect_source(cop, ['def method_name',
+                           '  call_foo || call_bar',
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
+    end
+
+    it 'registers an offence for or' do
+      inspect_source(cop, ['def method_name',
+                           '  call_foo or call_bar',
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
+    end
+
+    it 'deals with nested if blocks containing && and ||' do
+      inspect_source(cop,
+                     ['def method_name',
+                      '  if first_condition then',
+                      '    call_foo if second_condition && third_condition',
+                      '    call_bar if fourth_condition || fifth_condition',
+                      '  end',
+                      'end'])
+      expect(cop.messages)
+        .to eq(['Cyclomatic complexity for method_name is too high. [6/1]'])
+    end
+
+    it 'counts only a single method' do
+      inspect_source(cop, ['def method_name_1',
+                           '  call_foo if some_condition',
+                           'end',
+                           '',
+                           'def method_name_2',
+                           '  call_foo if some_condition',
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Cyclomatic complexity for method_name_1 is too high. [2/1]',
+                'Cyclomatic complexity for method_name_2 is too high. [2/1]'])
+    end
+  end
+
+  context 'when Max is 2' do
+    let(:cop_config) { { 'Max' => 2 } }
+
+    it 'counts stupid nested if and else blocks' do
+      inspect_source(cop, ['def method_name',
+                           '  if first_condition then',
+                           '    call_foo',
+                           '  else',
+                           '    if second_condition then',
+                           '      call_bar',
+                           '    else',
+                           '      call_bam if third_condition',
+                           '    end',
+                           '    call_baz if fourth_condition',
+                           '  end',
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Cyclomatic complexity for method_name is too high. [5/2]'])
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::DefWithParentheses do
+  subject(:cop) { described_class.new }
+
+  it 'reports an offence for def with empty parens' do
+    src = ['def func()',
+           'end']
+    inspect_source(cop, src)
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'reports an offence for class def with empty parens' do
+    src = ['def Test.func()',
+           'end']
+    inspect_source(cop, src)
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts def with arg and parens' do
+    src = ['def func(a)',
+           'end']
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts empty parentheses in one liners' do
+    src = ["def to_s() join '/' end"]
+    inspect_source(cop, src)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'auto-removes unneeded parens' do
+    new_source = autocorrect_source(cop, "def test();\nsomething\nend")
+    expect(new_source).to eq("def test;\nsomething\nend")
+  end
+end

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

@@ -0,0 +1,123 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::Documentation do
+
+  subject(:cop) { described_class.new(config) }
+  let(:config) do
+    Rubocop::Config.new('CommentAnnotation' => {
+                          'Keywords' => %w(TODO FIXME OPTIMIZE HACK REVIEW)
+                        })
+  end
+
+  it 'registers an offence for non-empty class' do
+    inspect_source(cop,
+                   ['class My_Class',
+                    '  TEST = 20',
+                    'end'
+                   ])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'does not consider comment followed by empty line to be class ' \
+     'documentation' do
+    inspect_source(cop,
+                   ['# Copyright 2014',
+                    '# Some company',
+                    '',
+                    'class My_Class',
+                    '  TEST = 20',
+                    'end'
+                   ])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for non-namespace' do
+    inspect_source(cop,
+                   ['module My_Class',
+                    '  TEST = 20',
+                    'end'
+                   ])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for empty module without documentation' do
+    # Because why would you have an empty module? It requires some
+    # explanation.
+    inspect_source(cop,
+                   ['module Test',
+                    'end'
+                   ])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts non-empty class with documentation' do
+    inspect_source(cop,
+                   ['# class comment',
+                    'class My_Class',
+                    '  TEST = 20',
+                    'end'
+                   ])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'registers an offence for non-empty class with annotation comment' do
+    inspect_source(cop,
+                   ['# OPTIMIZE: Make this faster.',
+                    'class My_Class',
+                    '  TEST = 20',
+                    'end'
+                   ])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts non-empty module with documentation' do
+    inspect_source(cop,
+                   ['# class comment',
+                    'module My_Class',
+                    '  TEST = 20',
+                    'end'
+                   ])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts empty class without documentation' do
+    inspect_source(cop,
+                   ['class My_Class',
+                    'end'
+                   ])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts namespace module without documentation' do
+    inspect_source(cop,
+                   ['module Test',
+                    '  class A; end',
+                    '  class B; end',
+                    'end'
+                   ])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts namespace class without documentation' do
+    inspect_source(cop,
+                   ['class Test',
+                    '  class A; end',
+                    '  class B; end',
+                    'end'
+                   ])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not raise an error for an implicit match conditional' do
+    expect do
+      inspect_source(cop,
+                     ['class Test',
+                      '  if //',
+                      '  end',
+                      'end'
+                     ])
+    end.to_not raise_error
+  end
+end

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

@@ -0,0 +1,94 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::DotPosition, :config do
+  subject(:cop) { described_class.new(config) }
+
+  context 'Leading dots style' do
+    let(:cop_config) { { 'Style' => 'leading' } }
+
+    it 'registers an offence for trailing dot in multi-line call' do
+      inspect_source(cop, ['something.',
+                           '  method_name'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(['.'])
+      expect(cop.config_to_allow_offences).to eq('Style' => 'trailing')
+    end
+
+    it 'registers an offence for correct + opposite' do
+      inspect_source(cop, ['something',
+                           '  .method_name',
+                           'something.',
+                           '  method_name'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
+    it 'accepts leading do in multi-line method call' do
+      inspect_source(cop, ['something',
+                           '  .method_name'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'does not err on method call with no dots' do
+      inspect_source(cop, ['puts something'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'does not err on method call without a method name' do
+      inspect_source(cop, ['l.', '(1)'])
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it 'does not err on method call on same line' do
+      inspect_source(cop, ['something.method_name'])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'Trailing dots style' do
+    let(:cop_config) { { 'Style' => 'trailing' } }
+
+    it 'registers an offence for leading dot in multi-line call' do
+      inspect_source(cop, ['something',
+                           '  .method_name'])
+      expect(cop.messages)
+        .to eq(['Place the . on the previous line, together with the method ' \
+                'call receiver.'])
+      expect(cop.highlights).to eq(['.'])
+      expect(cop.config_to_allow_offences).to eq('Style' => 'leading')
+    end
+
+    it 'accepts trailing dot in multi-line method call' do
+      inspect_source(cop, ['something.',
+                           '  method_name'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'does not err on method call with no dots' do
+      inspect_source(cop, ['puts something'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'does not err on method call without a method name' do
+      inspect_source(cop, ['l', '.(1)'])
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it 'does not err on method call on same line' do
+      inspect_source(cop, ['something.method_name'])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'Unknown style' do
+    let(:cop_config) { { 'Style' => 'test' } }
+
+    it 'raises an exception' do
+      expect do
+        inspect_source(cop, ['something.top'])
+      end.to raise_error(RuntimeError)
+    end
+  end
+end