ridecharge-rubocop 0.0.1

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::LambdaCall, :config do
+  subject(:cop) { described_class.new(config) }
+
+  context 'when style is set to call' do
+    let(:cop_config) { { 'EnforcedStyle' => 'call' } }
+
+    it 'registers an offence for x.()' do
+      inspect_source(cop,
+                     ['x.(a, b)'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.config_to_allow_offences).to eq('EnforcedStyle' => 'braces')
+    end
+
+    it 'registers an offence for correct + opposite' do
+      inspect_source(cop,
+                     ['x.call(a, b)',
+                      'x.(a, b)'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
+    it 'accepts x.call()' do
+      inspect_source(cop, ['x.call(a, b)'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'auto-corrects x.() to x.call()' do
+      new_source = autocorrect_source(cop, ['a.(x)'])
+      expect(new_source).to eq('a.call(x)')
+    end
+  end
+
+  context 'when style is set to braces' do
+    let(:cop_config) { { 'EnforcedStyle' => 'braces' } }
+
+    it 'registers an offence for x.call()' do
+      inspect_source(cop,
+                     ['x.call(a, b)'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.config_to_allow_offences).to eq('EnforcedStyle' => 'call')
+    end
+
+    it 'registers an offence for opposite + correct' do
+      inspect_source(cop,
+                     ['x.call(a, b)',
+                      'x.(a, b)'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
+    it 'accepts x.()' do
+      inspect_source(cop, ['x.(a, b)'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'auto-corrects x.call() to x.()' do
+      new_source = autocorrect_source(cop, ['a.call(x)'])
+      expect(new_source).to eq('a.(x)')
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::Lambda do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for an old single-line lambda call' do
+    inspect_source(cop, ['f = lambda { |x| x }'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Use the new lambda literal syntax ->(params) {...}.'])
+  end
+
+  it 'accepts the new lambda literal with single-line body' do
+    inspect_source(cop, ['lambda = ->(x) { x }',
+                         'lambda.(1)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'registers an offence for a new multi-line lambda call' do
+    inspect_source(cop, ['f = ->(x) do',
+                         '  x',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Use the lambda method for multi-line lambdas.'])
+  end
+
+  it 'accepts the old lambda syntax with multi-line body' do
+    inspect_source(cop, ['l = lambda do |x|',
+                         '  x',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts the lambda call outside of block' do
+    inspect_source(cop, ['l = lambda.test'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::LeadingCommentSpace do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for comment without leading space' do
+    inspect_source(cop,
+                   ['#missing space'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'does not register an offence for # followed by no text' do
+    inspect_source(cop,
+                   ['#'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for more than one space' do
+    inspect_source(cop,
+                   ['#   heavily indented'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for more than one #' do
+    inspect_source(cop,
+                   ['###### heavily indented'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for only #s' do
+    inspect_source(cop,
+                   ['######'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for #! on first line' do
+    inspect_source(cop,
+                   ['#!/usr/bin/ruby',
+                    'test'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'registers an offence for #! after the first line' do
+    inspect_source(cop,
+                   ['test', '#!/usr/bin/ruby'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts rdoc syntax' do
+    inspect_source(cop,
+                   ['#++',
+                    '#--',
+                    '#:nodoc:'])
+
+    expect(cop.offences).to be_empty
+  end
+
+  it 'auto-corrects missing space' do
+    new_source = autocorrect_source(cop, '#comment')
+    expect(new_source).to eq('# comment')
+  end
+end

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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::LineEndConcatenation do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for string concat at line end' do
+    inspect_source(cop,
+                   ['top = "test" +',
+                    '"top"'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts string concat on the same line' do
+    inspect_source(cop,
+                   ['top = "test" + "top"'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts string concat at line end when followed by comment' do
+    inspect_source(cop,
+                   ['top = "test" + # something',
+                    '"top"'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'autocorrects by replacing + with \\' do
+    corrected = autocorrect_source(cop,
+                                   ['top = "test" +',
+                                    '"top"'])
+    expect(corrected).to eq ['top = "test" \\', '"top"'].join("\n")
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::LineLength, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'Max' => 79 } }
+
+  it "registers an offence for a line that's 80 characters wide" do
+    inspect_source(cop, ['#' * 80])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences.first.message).to eq('Line is too long. [80/79]')
+    expect(cop.config_to_allow_offences).to eq('Max' => 80)
+  end
+
+  it "accepts a line that's 79 characters wide" do
+    inspect_source(cop, ['#' * 79])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::MethodCallParentheses, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:config) do
+    Rubocop::Config.new('EmptyLiteral' => { 'Enabled' => true })
+  end
+
+  it 'registers an offence for parens in method call without args' do
+    inspect_source(cop, ['top.test()'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts parentheses for methods starting with an upcase letter' do
+    inspect_source(cop, ['Test()'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts no parens in method call without args' do
+    inspect_source(cop, ['top.test'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts parens in method call with args' do
+    inspect_source(cop, ['top.test(a)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'auto-corrects by removing unneeded braces' do
+    new_source = autocorrect_source(cop, 'test()')
+    expect(new_source).to eq('test')
+  end
+
+  it 'does not auto-correct calls that will be changed to empty literals' do
+    original = ['Hash.new()',
+                'Array.new()',
+                'String.new()']
+    new_source = autocorrect_source(cop, original)
+    expect(new_source).to eq(original.join("\n"))
+  end
+
+  context 'when EmptyLiteral is disabled' do
+    let(:config) do
+      Rubocop::Config.new('EmptyLiteral' => { 'Enabled' => false })
+    end
+
+    it 'auto-corrects calls that could be empty literals' do
+      original = ['Hash.new()',
+                  'Array.new()',
+                  'String.new()']
+      new_source = autocorrect_source(cop, original)
+      expect(new_source).to eq(['Hash.new',
+                                'Array.new',
+                                'String.new'].join("\n"))
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::MethodCalledOnDoEndBlock do
+  subject(:cop) { described_class.new }
+
+  context 'with a multi-line do..end block' do
+    it 'registers an offence for a chained call' do
+      inspect_source(cop, ['a do',
+                           '  b',
+                           'end.c'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(['end.c'])
+    end
+
+    it 'accepts it if there is no chained call' do
+      inspect_source(cop, ['a do',
+                           '  b',
+                           'end'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts a chained block' do
+      inspect_source(cop, ['a do',
+                           '  b',
+                           'end.c do',
+                           '  d',
+                           'end'])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'with a single-line do..end block' do
+    it 'registers an offence for a chained call' do
+      inspect_source(cop, ['a do b end.c'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(['end.c'])
+    end
+
+    it 'accepts a single-line do..end block with a chained block' do
+      inspect_source(cop, ['a do b end.c do d end'])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'with a {} block' do
+    it 'accepts a multi-line block with a chained call' do
+      inspect_source(cop, ['a {',
+                           '  b',
+                           '}.c'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts a single-line block with a chained call' do
+      inspect_source(cop, ['a { b }.c'])
+      expect(cop.offences).to be_empty
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::MethodDefParentheses, :config do
+  subject(:cop) { described_class.new(config) }
+
+  context 'require_parentheses' do
+    let(:cop_config) { { 'EnforcedStyle' => 'require_parentheses' } }
+
+    it 'reports an offence for def with parameters but no parens' do
+      src = ['def func a, b',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offences.size).to eq(1)
+      expect(cop.config_to_allow_offences).to eq('EnforcedStyle' =>
+                                                 'require_no_parentheses')
+    end
+
+    it 'reports an offence for correct + opposite' do
+      src = ['def func(a, b)',
+             'end',
+             'def func a, b',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offences.size).to eq(1)
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
+    it 'reports an offence for class def with parameters but no parens' do
+      src = ['def Test.func a, b',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it 'accepts def with no args and no parens' do
+      src = ['def func',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offences).to be_empty
+    end
+
+    it 'auto-adds required parens for a def' do
+      new_source = autocorrect_source(cop, 'def test param; end')
+      expect(new_source).to eq('def test(param); end')
+    end
+
+    it 'auto-adds required parens for a defs' do
+      new_source = autocorrect_source(cop, 'def self.test param; end')
+      expect(new_source).to eq('def self.test(param); end')
+    end
+
+    it 'auto-adds required parens to argument lists on multiple lines' do
+      new_source = autocorrect_source(cop, ['def test one,', 'two', 'end'])
+      expect(new_source).to eq("def test(one,\ntwo)\nend")
+    end
+  end
+
+  context 'require_no_parentheses' do
+    let(:cop_config) { { 'EnforcedStyle' => 'require_no_parentheses' } }
+
+    it 'reports an offence for def with parameters with parens' do
+      src = ['def func(a, b)',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offences.size).to eq(1)
+      expect(cop.config_to_allow_offences).to eq('EnforcedStyle' =>
+                                                 'require_parentheses')
+    end
+
+    it 'reports an offence for opposite + correct' do
+      src = ['def func(a, b)',
+             'end',
+             'def func a, b',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offences.size).to eq(1)
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
+    it 'reports an offence for class def with parameters with parens' do
+      src = ['def Test.func(a, b)',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it 'reports an offence for def with no args and parens' do
+      src = ['def func()',
+             'end']
+      inspect_source(cop, src)
+      expect(cop.offences.size).to eq(1)
+    end
+
+    it 'auto-removes the parens' do
+      new_source = autocorrect_source(cop, 'def test(param); end')
+      expect(new_source).to eq('def test param; end')
+    end
+
+    it 'auto-removes the parens for defs' do
+      new_source = autocorrect_source(cop, 'def self.test(param); end')
+      expect(new_source).to eq('def self.test param; end')
+    end
+  end
+end