ridecharge-rubocop 0.0.1

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

@@ -0,0 +1,147 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::MethodLength, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'Max' => 5, 'CountComments' => false } }
+
+  it 'rejects a method with more than 5 lines' do
+    inspect_source(cop, ['def m()',
+                         '  a = 1',
+                         '  a = 2',
+                         '  a = 3',
+                         '  a = 4',
+                         '  a = 5',
+                         '  a = 6',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences.map(&:line).sort).to eq([1])
+    expect(cop.config_to_allow_offences).to eq('Max' => 6)
+  end
+
+  it 'accepts a method with less than 5 lines' do
+    inspect_source(cop, ['def m()',
+                         '  a = 1',
+                         '  a = 2',
+                         '  a = 3',
+                         '  a = 4',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not count blank lines' do
+    inspect_source(cop, ['def m()',
+                         '  a = 1',
+                         '  a = 2',
+                         '  a = 3',
+                         '  a = 4',
+                         '',
+                         '',
+                         '  a = 7',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts empty methods' do
+    inspect_source(cop, ['def m()',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'is not fooled by one-liner methods, syntax #1' do
+    inspect_source(cop, ['def one_line; 10 end',
+                         'def self.m()',
+                         '  a = 1',
+                         '  a = 2',
+                         '  a = 4',
+                         '  a = 5',
+                         '  a = 6',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'is not fooled by one-liner methods, syntax #2' do
+    inspect_source(cop, ['def one_line(test) 10 end',
+                         'def self.m()',
+                         '  a = 1',
+                         '  a = 2',
+                         '  a = 4',
+                         '  a = 5',
+                         '  a = 6',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'checks class methods, syntax #1' do
+    inspect_source(cop, ['def self.m()',
+                         '  a = 1',
+                         '  a = 2',
+                         '  a = 3',
+                         '  a = 4',
+                         '  a = 5',
+                         '  a = 6',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences.map(&:line).sort).to eq([1])
+  end
+
+  it 'checks class methods, syntax #2' do
+    inspect_source(cop, ['class K',
+                         '  class << self',
+                         '    def m()',
+                         '      a = 1',
+                         '      a = 2',
+                         '      a = 3',
+                         '      a = 4',
+                         '      a = 5',
+                         '      a = 6',
+                         '    end',
+                         '  end',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences.map(&:line).sort).to eq([3])
+  end
+
+  it 'properly counts lines when method ends with block' do
+    inspect_source(cop, ['def m()',
+                         '  something do',
+                         '    a = 2',
+                         '    a = 3',
+                         '    a = 4',
+                         '    a = 5',
+                         '  end',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences.map(&:line).sort).to eq([1])
+  end
+
+  it 'does not count commented lines by default' do
+    inspect_source(cop, ['def m()',
+                         '  a = 1',
+                         '  #a = 2',
+                         '  a = 3',
+                         '  #a = 4',
+                         '  a = 5',
+                         '  a = 6',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  context 'when CountComments is enabled' do
+    before { cop_config['CountComments'] = true }
+
+    it 'also counts commented lines' do
+      inspect_source(cop, ['def m()',
+                           '  a = 1',
+                           '  #a = 2',
+                           '  a = 3',
+                           '  #a = 4',
+                           '  a = 5',
+                           '  a = 6',
+                           'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.offences.map(&:line).sort).to eq([1])
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::MethodName, :config do
+  subject(:cop) { described_class.new(config) }
+
+  shared_examples 'never accepted' do
+    it 'registers an offence for mixed snake case and camel case' do
+      inspect_source(cop, ['def visit_Arel_Nodes_SelectStatement',
+                           'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(['visit_Arel_Nodes_SelectStatement'])
+    end
+
+    it 'registers an offence for capitalized camel case' do
+      inspect_source(cop, ['def MyMethod',
+                           'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(['MyMethod'])
+    end
+  end
+
+  shared_examples 'always accepted' do
+    it 'accepts one line methods' do
+      inspect_source(cop, "def body; '' end")
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts operator definitions' do
+      inspect_source(cop, ['def +(other)',
+                           '  # ...',
+                           'end'])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'when configured for snake_case' do
+    let(:cop_config) { { 'EnforcedStyle' => 'snake_case' } }
+
+    it 'registers an offence for camel case in instance method name' do
+      inspect_source(cop, ['def myMethod',
+                           '  # ...',
+                           'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(['myMethod'])
+      expect(cop.config_to_allow_offences).to eq('EnforcedStyle' =>
+                                                 'camelCase')
+    end
+
+    it 'registers an offence for opposite + correct' do
+      inspect_source(cop, ['def my_method',
+                           'end',
+                           'def myMethod',
+                           'end'])
+      expect(cop.highlights).to eq(['myMethod'])
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
+    it 'registers an offence for camel case in singleton method name' do
+      inspect_source(cop, ['def self.myMethod',
+                           '  # ...',
+                           'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(['myMethod'])
+    end
+
+    it 'accepts snake case in names' do
+      inspect_source(cop, ['def my_method',
+                           'end'])
+      expect(cop.offences).to be_empty
+    end
+
+    include_examples 'never accepted'
+    include_examples 'always accepted'
+  end
+
+  context 'when configured for camelCase' do
+    let(:cop_config) { { 'EnforcedStyle' => 'camelCase' } }
+
+    it 'accepts camel case in instance method name' do
+      inspect_source(cop, ['def myMethod',
+                           '  # ...',
+                           'end'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts camel case in singleton method name' do
+      inspect_source(cop, ['def self.myMethod',
+                           '  # ...',
+                           'end'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'registers an offence for snake case in names' do
+      inspect_source(cop, ['def my_method',
+                           'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(['my_method'])
+      expect(cop.config_to_allow_offences).to eq('EnforcedStyle' =>
+                                                 'snake_case')
+    end
+
+    it 'registers an offence for correct + opposite' do
+      inspect_source(cop, ['def my_method',
+                           'end',
+                           'def myMethod',
+                           'end'])
+      expect(cop.highlights).to eq(['my_method'])
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
+    include_examples 'always accepted'
+    include_examples 'never accepted'
+  end
+
+  context 'when configured with a bad value' do
+    let(:cop_config) { { 'EnforcedStyle' => 'other' } }
+
+    it 'fails' do
+      expect { inspect_source(cop, ['def a', 'end']) }
+        .to raise_error(RuntimeError)
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::ModuleFunction do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for extend self in module' do
+    inspect_source(cop,
+                   ['module Test',
+                    '  extend self',
+                    '  def test; end',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts extend self in class' do
+    inspect_source(cop,
+                   ['class Test',
+                    '  extend self',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::MultilineBlockChain do
+  subject(:cop) { described_class.new }
+
+  context 'with multi-line block chaining' do
+    it 'registers an offence for a simple case' do
+      inspect_source(cop, ['a do',
+                           '  b',
+                           'end.c do',
+                           '  d',
+                           'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(['end.c'])
+    end
+
+    it 'registers an offence for a slightly more complicated case' do
+      inspect_source(cop, ['a do',
+                           '  b',
+                           'end.c1.c2 do',
+                           '  d',
+                           'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(['end.c1.c2'])
+    end
+
+    it 'registers two offences for a chain of three blocks' do
+      inspect_source(cop, ['a do',
+                           '  b',
+                           'end.c do',
+                           '  d',
+                           'end.e do',
+                           '  f',
+                           'end'])
+      expect(cop.offences.size).to eq(2)
+      expect(cop.highlights).to eq(['end.c', 'end.e'])
+    end
+
+    it 'registers an offence for a chain where the second block is ' \
+      'single-line' do
+      inspect_source(cop, ['Thread.list.find_all { |t|',
+                           '  t.alive?',
+                           '}.map { |thread| thread.object_id }'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(['}.map'])
+    end
+
+    it 'accepts a chain where the first block is single-line' do
+      inspect_source(cop,
+                     ['Thread.list.find_all { |t| t.alive? }.map { |t| ',
+                      '  t.object_id',
+                      '}'])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  it 'accepts a chain of blocks spanning one line' do
+    inspect_source(cop, ['a { b }.c { d }',
+                         'w do x end.y do z end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a multi-line block chained with calls on one line' do
+    inspect_source(cop, ['a do',
+                         '  b',
+                         'end.c.d'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a chain of calls followed by a multi-line block' do
+    inspect_source(cop, ['a1.a2.a3 do',
+                         '  b',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::MultilineIfThen do
+  subject(:cop) { described_class.new }
+
+  # if
+
+  it 'registers an offence for then in multiline if' do
+    inspect_source(cop, ['if cond then',
+                         'end',
+                         "if cond then\t",
+                         'end',
+                         'if cond then  ',
+                         'end',
+                         'if cond',
+                         'then',
+                         'end',
+                         'if cond then # bad',
+                         'end'])
+    expect(cop.offences.map(&:line)).to eq([1, 3, 5, 7, 10])
+  end
+
+  it 'accepts multiline if without then' do
+    inspect_source(cop, ['if cond',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts table style if/then/elsif/ends' do
+    inspect_source(cop,
+                   ['if    @io == $stdout then str << "$stdout"',
+                    'elsif @io == $stdin  then str << "$stdin"',
+                    'elsif @io == $stderr then str << "$stderr"',
+                    'else                      str << @io.class.to_s',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not get confused by a then in a when' do
+    inspect_source(cop,
+                   ['if a',
+                    '  case b',
+                    '  when c then',
+                    '  end',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not get confused by a commented-out then' do
+    inspect_source(cop,
+                   ['if a # then',
+                    '  b',
+                    'end',
+                    'if c # then',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not raise an error for an implicit match if' do
+    expect do
+      inspect_source(cop,
+                     ['if //',
+                      'end'])
+    end.not_to raise_error
+  end
+
+  # unless
+
+  it 'registers an offence for then in multiline unless' do
+    inspect_source(cop, ['unless cond then',
+                         'end'])
+    expect(cop.messages).to eq(
+      ['Never use then for multi-line unless.'])
+  end
+
+  it 'accepts multiline unless without then' do
+    inspect_source(cop, ['unless cond',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not get confused by a postfix unless' do
+    inspect_source(cop,
+                   ['two unless one'
+                   ])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not get confused by a nested postfix unless' do
+    inspect_source(cop,
+                   ['if two',
+                    '  puts 1',
+                    'end unless two'
+                   ])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not raise an error for an implicit match unless' do
+    expect do
+      inspect_source(cop,
+                     ['unless //',
+                      'end'])
+    end.not_to raise_error
+  end
+end