ridecharge-rubocop 0.0.1

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

@@ -0,0 +1,127 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::EmptyLineBetweenDefs, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'AllowAdjacentOneLineDefs' => false } }
+
+  it 'finds offences in inner classes' do
+    source = ['class K',
+              '  def m',
+              '  end',
+              '  class J',
+              '    def n',
+              '    end',
+              '    def o',
+              '    end',
+              '  end',
+              '  # checks something',
+              '  def p',
+              '  end',
+              'end']
+    inspect_source(cop, source)
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences.map(&:line).sort).to eq([7])
+  end
+
+  # Only one def, so rule about empty line *between* defs does not
+  # apply.
+  it 'accepts a def that follows a line with code' do
+    source = ['x = 0',
+              'def m',
+              'end']
+    inspect_source(cop, source)
+    expect(cop.offences).to be_empty
+  end
+
+  # Only one def, so rule about empty line *between* defs does not
+  # apply.
+  it 'accepts a def that follows code and a comment' do
+    source = ['  x = 0',
+              '  # 123',
+              '  def m',
+              '  end']
+    inspect_source(cop, source)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts the first def without leading empty line in a class' do
+    source = ['class K',
+              '  def m',
+              '  end',
+              'end']
+    inspect_source(cop, source)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a def that follows an empty line and then a comment' do
+    source = ['class A',
+              '  # calculates value',
+              '  def m',
+              '  end',
+              '',
+              '  private',
+              '  # calculates size',
+              '  def n',
+              '  end',
+              'end'
+             ]
+    inspect_source(cop, source)
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a def that is the first of a module' do
+    source = ['module Util',
+              '  public',
+              '  #',
+              '  def html_escape(s)',
+              '  end',
+              'end'
+             ]
+    inspect_source(cop, source)
+    expect(cop.messages).to be_empty
+  end
+
+  it 'accepts a nested def' do
+    source = ['def mock_model(*attributes)',
+              '  Class.new do',
+              '    def initialize(attrs)',
+              '    end',
+              '  end',
+              'end'
+             ]
+    inspect_source(cop, source)
+    expect(cop.messages).to be_empty
+  end
+
+  it 'registers an offence for adjacent one-liners by default' do
+    source = ['def a; end',
+              'def b; end']
+    inspect_source(cop, source)
+    expect(cop.offences.size).to eq(1)
+  end
+
+  context 'when AllowAdjacentOneLineDefs is enabled' do
+    let(:cop_config) { { 'AllowAdjacentOneLineDefs' => true } }
+
+    it 'accepts adjacent one-liners' do
+      source = ['def a; end',
+                'def b; end']
+      inspect_source(cop, source)
+      expect(cop.offences).to be_empty
+    end
+
+    it 'registers an offence for adjacent defs if some are multi-line' do
+      source = ['def a; end',
+                'def b; end',
+                'def c', # Not a one-liner, so this is an offence.
+                'end',
+                # Also an offence since previous was multi-line:
+                'def d; end'
+               ]
+      inspect_source(cop, source)
+      expect(cop.offences.map(&:line)).to eq([3, 5])
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::EmptyLinesAroundAccessModifier do
+  subject(:cop) { described_class.new }
+
+  %w(private protected public).each do |access_modifier|
+    it "requires blank line before #{access_modifier}" do
+      inspect_source(cop,
+                     ['class Test',
+                      '  something',
+                      "  #{access_modifier}",
+                      '',
+                      '  def test; end',
+                      'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(["Keep a blank line before and after #{access_modifier}."])
+    end
+
+    it 'requires blank line after #{access_modifier}' do
+      inspect_source(cop,
+                     ['class Test',
+                      '  something',
+                      '',
+                      "  #{access_modifier}",
+                      '  def test; end',
+                      'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(["Keep a blank line before and after #{access_modifier}."])
+    end
+
+    it 'accepts missing blank line when at the beginning of class/module' do
+      inspect_source(cop,
+                     ['class Test',
+                      "  #{access_modifier}",
+                      '',
+                      '  def test; end',
+                      'end'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'recognizes blank lines with DOS style line endings' do
+      inspect_source(cop,
+                     ["class Test\r",
+                      "\r",
+                      "  #{access_modifier}\r",
+                      "\r",
+                      "  def test; end\r",
+                      "end\r"])
+      expect(cop.offences.size).to eq(0)
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::EmptyLinesAroundBody do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for method body starting with a blank' do
+    inspect_source(cop,
+                   ['def some_method',
+                    '',
+                    '  do_something',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  # The cop only registers an offence if the extra line is completely emtpy. If
+  # there is trailing whitespace, then that must be dealt with first. Having
+  # two cops registering offence for the line with only spaces would cause
+  # havoc in auto-correction.
+  it 'accepts method body starting with a line with spaces' do
+    inspect_source(cop,
+                   ['def some_method',
+                    '  ',
+                    '  do_something',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'autocorrects method body starting with a blank' do
+    corrected = autocorrect_source(cop,
+                                   ['def some_method',
+                                    '',
+                                    '  do_something',
+                                    'end'])
+    expect(corrected).to eq ['def some_method',
+                             '  do_something',
+                             'end'].join("\n")
+  end
+
+  it 'registers an offence for class method body starting with a blank' do
+    inspect_source(cop,
+                   ['def Test.some_method',
+                    '',
+                    '  do_something',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'autocorrects class method body starting with a blank' do
+    corrected = autocorrect_source(cop,
+                                   ['def Test.some_method',
+                                    '',
+                                    '  do_something',
+                                    'end'])
+    expect(corrected).to eq ['def Test.some_method',
+                             '  do_something',
+                             'end'].join("\n")
+  end
+
+  it 'registers an offence for method body ending with a blank' do
+    inspect_source(cop,
+                   ['def some_method',
+                    '  do_something',
+                    '',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for class method body ending with a blank' do
+    inspect_source(cop,
+                   ['def Test.some_method',
+                    '  do_something',
+                    '',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for class body starting with a blank' do
+    inspect_source(cop,
+                   ['class SomeClass',
+                    '',
+                    '  do_something',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'autocorrects class body containing only a blank' do
+    corrected = autocorrect_source(cop,
+                                   ['class SomeClass',
+                                    '',
+                                    'end'])
+    expect(corrected).to eq ['class SomeClass',
+                             'end'].join("\n")
+  end
+
+  it 'registers an offence for module body starting with a blank' do
+    inspect_source(cop,
+                   ['module SomeModule',
+                    '',
+                    '  do_something',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for class body ending with a blank' do
+    inspect_source(cop,
+                   ['class SomeClass',
+                    '  do_something',
+                    '',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for module body ending with a blank' do
+    inspect_source(cop,
+                   ['module SomeModule',
+                    '  do_something',
+                    '',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'is not fooled by single line methods' do
+    inspect_source(cop,
+                   ['def some_method; do_something; end',
+                    '',
+                    'something_else'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::EmptyLines do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for consecutive empty lines' do
+    inspect_source(cop,
+                   ['test = 5', '', '', '', 'top'])
+    expect(cop.offences.size).to eq(2)
+  end
+
+  it 'auto-corrects consecutive empty lines' do
+    corrected = autocorrect_source(cop,
+                                   ['test = 5', '', '', '', 'top'])
+    expect(corrected).to eq ['test = 5', '', 'top'].join("\n")
+  end
+
+  it 'works when there are no tokens' do
+    inspect_source(cop,
+                   ['#comment'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'handles comments' do
+    inspect_source(cop,
+                   ['test', '', '#comment', 'top'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for empty lines in a string' do
+    inspect_source(cop, ['result = "test
+
+
+
+                                  string"'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::EmptyLiteral do
+  subject(:cop) { described_class.new }
+
+  describe 'Empty Array' do
+    it 'registers an offence for Array.new()' do
+      inspect_source(cop,
+                     ['test = Array.new()'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(['Use array literal [] instead of Array.new.'])
+    end
+
+    it 'registers an offence for Array.new' do
+      inspect_source(cop,
+                     ['test = Array.new'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(['Use array literal [] instead of Array.new.'])
+    end
+
+    it 'does not register an offence for Array.new(3)' do
+      inspect_source(cop,
+                     ['test = Array.new(3)'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'auto-corrects Array.new to []' do
+      new_source = autocorrect_source(cop, 'test = Array.new')
+      expect(new_source).to eq('test = []')
+    end
+  end
+
+  describe 'Empty Hash' do
+    it 'registers an offence for Hash.new()' do
+      inspect_source(cop,
+                     ['test = Hash.new()'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(['Use hash literal {} instead of Hash.new.'])
+    end
+
+    it 'registers an offence for Hash.new' do
+      inspect_source(cop,
+                     ['test = Hash.new'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(['Use hash literal {} instead of Hash.new.'])
+    end
+
+    it 'does not register an offence for Hash.new(3)' do
+      inspect_source(cop,
+                     ['test = Hash.new(3)'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'does not register an offence for Hash.new { block }' do
+      inspect_source(cop,
+                     ['test = Hash.new { block }'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'auto-corrects Hash.new to {}' do
+      new_source = autocorrect_source(cop, 'test = Hash.new')
+      expect(new_source).to eq('test = {}')
+    end
+  end
+
+  describe 'Empty String' do
+    it 'registers an offence for String.new()' do
+      inspect_source(cop,
+                     ['test = String.new()'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(["Use string literal '' instead of String.new."])
+    end
+
+    it 'registers an offence for String.new' do
+      inspect_source(cop,
+                     ['test = String.new'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.messages)
+        .to eq(["Use string literal '' instead of String.new."])
+    end
+
+    it 'does not register an offence for String.new("top")' do
+      inspect_source(cop,
+                     ['test = String.new("top")'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'auto-corrects String.new to empty string literal' do
+      new_source = autocorrect_source(cop, 'test = String.new')
+      expect(new_source).to eq("test = ''")
+    end
+  end
+end