ridecharge-rubocop 0.0.1

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

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::Tab do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for a line indented with tab' do
+    inspect_source(cop, ["\tx = 0"])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts a line with tab in a string' do
+    inspect_source(cop, ["(x = \"\t\")"])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::TrailingBlankLines do
+  subject(:cop) { described_class.new(config) }
+  let(:config) do
+    Rubocop::Config.new('TrailingWhitespace' => { 'Enabled' => true })
+  end
+
+  it 'accepts final newline' do
+    inspect_source(cop, ['x = 0', ''])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'registers an offence for multiple trailing blank lines' do
+    inspect_source(cop, ['x = 0', '', '', '', ''])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages).to eq(['3 trailing blank lines detected.'])
+  end
+
+  it 'auto-corrects unwanted blank lines' do
+    new_source = autocorrect_source(cop, ['x = 0', '', '', '', ''])
+    expect(new_source).to eq(['x = 0', ''].join("\n"))
+  end
+
+  it 'does not auto-correct if it interferes with TrailingWhitespace' do
+    original = ['x = 0', '', '  ', '', '']
+    new_source = autocorrect_source(cop, original)
+    expect(new_source).to eq(original.join("\n"))
+  end
+
+  context 'with TrailingWhitespace disabled' do
+    let(:config) do
+      Rubocop::Config.new('TrailingWhitespace' => { 'Enabled' => false })
+    end
+
+    it 'auto-corrects even if some lines have space' do
+      new_source = autocorrect_source(cop, ['x = 0', '', '  ', '', ''])
+      expect(new_source).to eq(['x = 0', ''].join("\n"))
+    end
+  end
+end

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

@@ -0,0 +1,230 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::TrailingComma, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'EnforcedStyleForMultiline' => 'no_comma' } }
+
+  context 'with single line list of values' do
+    it 'registers an offence for trailing comma in an Array literal' do
+      inspect_source(cop, 'VALUES = [1001, 2020, 3333, ]')
+      expect(cop.messages)
+        .to eq(['Avoid comma after the last item of an array.'])
+      expect(cop.highlights).to eq([','])
+    end
+
+    it 'registers an offence for trailing comma in a Hash literal' do
+      inspect_source(cop, 'MAP = { a: 1001, b: 2020, c: 3333, }')
+      expect(cop.messages)
+        .to eq(['Avoid comma after the last item of a hash.'])
+      expect(cop.highlights).to eq([','])
+    end
+
+    it 'registers an offence for trailing comma in a method call' do
+      inspect_source(cop, 'some_method(a, b, c, )')
+      expect(cop.messages)
+        .to eq(['Avoid comma after the last parameter of a method call.'])
+      expect(cop.highlights).to eq([','])
+    end
+
+    it 'registers an offence for trailing comma in a method call with hash' \
+      ' parameters at the end' do
+      inspect_source(cop, 'some_method(a, b, c: 0, d: 1, )')
+      expect(cop.messages)
+        .to eq(['Avoid comma after the last parameter of a method call.'])
+      expect(cop.highlights).to eq([','])
+    end
+
+    it 'accepts Array literal without trailing comma' do
+      inspect_source(cop, 'VALUES = [1001, 2020, 3333]')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts empty Array literal' do
+      inspect_source(cop, 'VALUES = []')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts rescue clause' do
+      # The list of rescued classes is an array.
+      inspect_source(cop, ['begin',
+                           '  do_something',
+                           'rescue RuntimeError',
+                           'end'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts Hash literal without trailing comma' do
+      inspect_source(cop, 'MAP = { a: 1001, b: 2020, c: 3333 }')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts empty Hash literal' do
+      inspect_source(cop, 'MAP = {}')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts method call without trailing comma' do
+      inspect_source(cop, 'some_method(a, b, c)')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts method call without parameters' do
+      inspect_source(cop, 'some_method')
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'with multi-line list of values' do
+    context 'when EnforcedStyleForMultiline is no_comma' do
+      it 'registers an offence for trailing comma in an Array literal' do
+        inspect_source(cop, ['VALUES = [',
+                             '           1001,',
+                             '           2020,',
+                             '           3333,',
+                             '         ]'])
+        expect(cop.highlights).to eq([','])
+      end
+
+      it 'registers an offence for trailing comma in a Hash literal' do
+        inspect_source(cop, ['MAP = { a: 1001,',
+                             '        b: 2020,',
+                             '        c: 3333,',
+                             '      }'])
+        expect(cop.highlights).to eq([','])
+      end
+
+      it 'registers an offence for trailing comma in a method call with ' \
+        'hash parameters at the end' do
+        inspect_source(cop, ['some_method(',
+                             '              a,',
+                             '              b,',
+                             '              c: 0,',
+                             '              d: 1,)'])
+        expect(cop.highlights).to eq([','])
+      end
+
+      it 'accepts an Array literal with no trailing comma' do
+        inspect_source(cop, ['VALUES = [ 1001,',
+                             '           2020,',
+                             '           3333 ]'])
+        expect(cop.offences).to be_empty
+      end
+
+      it 'accepts a Hash literal with no trailing comma' do
+        inspect_source(cop, ['MAP = {',
+                             '        a: 1001,',
+                             '        b: 2020,',
+                             '        c: 3333',
+                             '      }'])
+        expect(cop.offences).to be_empty
+      end
+
+      it 'accepts a method call with ' \
+        'hash parameters at the end and no trailing comma' do
+        inspect_source(cop, ['some_method(a,',
+                             '            b,',
+                             '            c: 0,',
+                             '            d: 1',
+                             '           )'])
+        expect(cop.offences).to be_empty
+      end
+
+      it 'accepts comma inside a heredoc' \
+        ' parameters at the end' do
+        inspect_source(cop, ['route(help: {',
+                             "  'auth' => <<-HELP.chomp",
+                             ',',
+                             'HELP',
+                             '})'])
+        expect(cop.offences).to be_empty
+      end
+    end
+
+    context 'when EnforcedStyleForMultiline is comma' do
+      let(:cop_config) { { 'EnforcedStyleForMultiline' => 'comma' } }
+
+      it 'registers an offence for no trailing comma in an Array literal' do
+        inspect_source(cop, ['VALUES = [',
+                             '           1001,',
+                             '           2020,',
+                             '           3333]'])
+        expect(cop.messages)
+          .to eq(['Put a comma after the last item of a multiline array.'])
+        expect(cop.highlights).to eq(['3333'])
+      end
+
+      it 'registers an offence for no trailing comma in a Hash literal' do
+        inspect_source(cop, ['MAP = { a: 1001,',
+                             '        b: 2020,',
+                             '        c: 3333 }'])
+        expect(cop.messages)
+          .to eq(['Put a comma after the last item of a multiline hash.'])
+        expect(cop.highlights).to eq(['c: 3333'])
+      end
+
+      it 'registers an offence for no trailing comma in a method call with' \
+        ' hash parameters at the end' do
+        inspect_source(cop, ['some_method(',
+                             '              a,',
+                             '              b,',
+                             '              c: 0,',
+                             '              d: 1',
+                             '           )'])
+        expect(cop.messages)
+          .to eq(['Put a comma after the last parameter of a multiline ' \
+                  'method call.'])
+        expect(cop.highlights).to eq(['d: 1'])
+      end
+
+      it 'accepts trailing comma in an Array literal' do
+        inspect_source(cop, ['VALUES = [1001,',
+                             '          2020,',
+                             '          3333,',
+                             '         ]'])
+        expect(cop.offences).to be_empty
+      end
+
+      it 'accepts trailing comma in a Hash literal' do
+        inspect_source(cop, ['MAP = {',
+                             '        a: 1001,',
+                             '        b: 2020,',
+                             '        c: 3333,',
+                             '      }'])
+        expect(cop.offences).to be_empty
+      end
+
+      it 'accepts trailing comma in a method call with hash' \
+        ' parameters at the end' do
+        inspect_source(cop, ['some_method(',
+                             '              a,',
+                             '              b,',
+                             '              c: 0,',
+                             '              d: 1,',
+                             '           )'])
+        expect(cop.offences).to be_empty
+      end
+
+      it 'accepts a multiline word array' do
+        inspect_source(cop, ['ingredients = %w(',
+                             '  sausage',
+                             '  anchovies',
+                             '  olives',
+                             ')'])
+        expect(cop.offences).to be_empty
+      end
+
+      it 'accepts missing comma after a heredoc' do
+        # A heredoc that's the last item in a literal or parameter list can not
+        # have a trailing comma. It's a syntax error.
+        inspect_source(cop, ['route(help: {',
+                             "  'auth' => <<-HELP.chomp",
+                             '...',
+                             'HELP',
+                             '},)']) # We still need a comma after the hash.
+        expect(cop.offences).to be_empty
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::TrailingWhitespace do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for a line ending with space' do
+    source = ['x = 0 ']
+    inspect_source(cop, source)
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for a line ending with tab' do
+    inspect_source(cop, ["x = 0\t"])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts a line without trailing whitespace' do
+    inspect_source(cop, ["x = 0\n"])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'auto-corrects unwanted space' do
+    new_source = autocorrect_source(cop, ['x = 0 ',
+                                          "x = 0\t"])
+    expect(new_source).to eq(['x = 0',
+                              'x = 0'].join("\n"))
+  end
+end

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

@@ -0,0 +1,415 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::TrivialAccessors, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { {} }
+
+  it 'finds trivial reader' do
+    inspect_source(cop,
+                   ['def foo',
+                    '  @foo',
+                    'end',
+                    '',
+                    'def Foo',
+                    '  @Foo',
+                    'end'])
+    expect(cop.offences.size).to eq(2)
+    expect(cop.offences
+             .map(&:line).sort).to eq([1, 5])
+  end
+
+  it 'finds trivial reader in a class' do
+    inspect_source(cop,
+                   ['class TrivialFoo',
+                    '  def foo',
+                    '    @foo',
+                    '  end',
+                    '  def bar',
+                    '    !foo',
+                    '  end',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences
+             .map(&:line).sort).to eq([2])
+  end
+
+  it 'finds trivial reader in a class method' do
+    inspect_source(cop,
+                   ['class TrivialFoo',
+                    '  def self.foo',
+                    '    @foo',
+                    '  end',
+                    '  def bar',
+                    '    !foo',
+                    '  end',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences
+             .map(&:line).sort).to eq([2])
+  end
+
+  it 'finds trivial reader in a nested class' do
+    inspect_source(cop,
+                   ['class TrivialFoo',
+                    '  class Nested',
+                    '    def foo',
+                    '      @foo',
+                    '    end',
+                    '  end',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences
+             .map(&:line).sort).to eq([3])
+  end
+
+  it 'finds trivial readers in a little less trivial class' do
+    inspect_source(cop,
+                   ['class TrivialFoo',
+                    '  def foo',
+                    '    @foo',
+                    '  end',
+                    '  def foo_and_bar',
+                    '    @foo_bar = @foo + @bar',
+                    '  end',
+                    '  def foo_bar',
+                    '    @foo_bar',
+                    '  end',
+                    '  def foo?',
+                    '    foo.present?',
+                    '  end',
+                    '  def bar?',
+                    '    !bar',
+                    '  end',
+                    '  def foobar',
+                    '    foo? ? foo.value : "bar"',
+                    '  end',
+                    '  def bar',
+                    '    foo.bar',
+                    '  end',
+                    '  def foo_required?',
+                    '    super && !bar_required?',
+                    '  end',
+                    '  def self.from_omniauth(auth)',
+                    '    foobars.each do |f|',
+                    '      # do stuff',
+                    '    end',
+                    '  end',
+                    '  def regex',
+                    '    %r{\A#{visit node}\Z}',
+                    '  end',
+                    '  def array',
+                    '    [foo, bar].join',
+                    '  end',
+                    '  def string',
+                    '    "string"',
+                    '  end',
+                    '  def class',
+                    '    Foo.class',
+                    '  end',
+                    ' def with_return',
+                    '   return foo',
+                    ' end',
+                    ' def captures',
+                    '   (length - 1).times.map { |i| self[i + 1] }',
+                    ' end',
+                    ' def foo val',
+                    '   super',
+                    '   @val',
+                    ' end',
+                    'end'])
+    expect(cop.offences.size).to eq(2)
+    expect(cop.offences
+             .map(&:line).sort).to eq([2, 8])
+  end
+
+  it 'finds trivial reader with braces' do
+    inspect_source(cop,
+                   ['class Test',
+                    '  # trivial reader with braces',
+                    '  def name()',
+                    '    @name',
+                    '  end',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences
+             .map(&:line).sort).to eq([3])
+  end
+
+  it 'finds trivial writer without braces' do
+    inspect_source(cop,
+                   ['class Test',
+                    '  # trivial writer without braces',
+                    '  def name= name',
+                    '    @name = name',
+                    '  end',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences
+             .map(&:line).sort).to eq([3])
+  end
+
+  it 'does not find trivial writer with function calls' do
+    inspect_source(cop,
+                   ['class TrivialTest',
+                    ' def test=(val)',
+                    '   @test = val',
+                    '   some_function_call',
+                    '   or_more_of_them',
+                    ' end',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'finds trivials with less peculiar methods' do
+    inspect_source(cop,
+                   ['class NilStats',
+                    'def most_traded_pair',
+                    'end',
+                    'def win_ratio',
+                    'end',
+                    'def win_ratio_percentage()',
+                    'end',
+                    'def pips_won',
+                    '  0.0',
+                    'end',
+                    'def gain_at(date)',
+                    '  1',
+                    'end',
+                    'def gain_percentage',
+                    '  0',
+                    'end',
+                    'def gain_breakdown(options = {})',
+                    '  []',
+                    'end',
+                    'def copy_to_all_ratio',
+                    '  nil',
+                    'end',
+                    'def trade_population',
+                    '  {}',
+                    'end',
+                    'def average_leverage',
+                    '  1',
+                    'end',
+                    'def with_yield',
+                    '  yield',
+                    'rescue Error => e',
+                    '  #do stuff',
+                    'end',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'treats splats as non-trivial' do
+    inspect_source(cop,
+                   [' def splatomatic(*values)',
+                    '   @splatomatic = values',
+                    ' end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'finds oneliner trivials' do
+    inspect_source(cop,
+                   ['class Oneliner',
+                    '  def foo; @foo; end',
+                    '  def foo= foo; @foo = foo; end',
+                    'end'])
+    expect(cop.offences.size).to eq(2)
+    expect(cop.offences
+             .map(&:line).sort).to eq([2, 3])
+  end
+
+  it 'does not find a trivial reader' do
+    inspect_source(cop,
+                   ['def bar',
+                    '  @bar + foo',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'finds trivial writer' do
+    inspect_source(cop,
+                   ['def foo=(val)',
+                    ' @foo = val',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences
+             .map(&:line).sort).to eq([1])
+  end
+
+  it 'finds trivial writer in a class' do
+    inspect_source(cop,
+                   ['class TrivialFoo',
+                    '  def foo=(val)',
+                    '    @foo = val',
+                    '  end',
+                    '  def void(no_value)',
+                    '  end',
+                    '  def inspect(sexp)',
+                    '    each(:def, sexp) do |item|',
+                    '      #do stuff',
+                    '    end',
+                    '  end',
+                    '  def if_method(foo)',
+                    '    if true',
+                    '      unless false',
+                    '        #do stuff',
+                    '      end',
+                    '    end',
+                    '  end',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences
+             .map(&:line).sort).to eq([2])
+  end
+
+  it 'finds trivial accessors in a little less trivial class' do
+    inspect_source(cop,
+                   ['class TrivialFoo',
+                    ' def foo',
+                    ' @foo',
+                    ' end',
+                    ' def foo_and_bar',
+                    ' @foo_bar = @foo + @bar',
+                    ' end',
+                    ' def foo_bar',
+                    ' @foo_bar',
+                    ' end',
+                    ' def bar=(bar_value)',
+                    ' @bar = bar_value',
+                    ' end',
+                    'end'])
+    expect(cop.offences.size).to eq(3)
+    expect(cop.offences
+             .map(&:line).sort).to eq([2, 8, 11])
+  end
+
+  it 'does not find a trivial writer' do
+    inspect_source(cop,
+                   ['def bar=(value)',
+                    ' @bar = value + 42',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'finds trivial writers in a little less trivial class' do
+    inspect_source(cop,
+                   ['class TrivialFoo',
+                    ' def foo_bar=(foo, bar)',
+                    ' @foo_bar = foo + bar',
+                    ' end',
+                    ' def universal=(answer=42)',
+                    ' @universal = answer',
+                    ' end',
+                    ' def bar=(bar_value)',
+                    ' @bar = bar_value',
+                    ' end',
+                    'end'])
+    expect(cop.offences.size).to eq(2)
+    expect(cop.offences
+             .map(&:line).sort).to eq([5, 8])
+  end
+
+  it 'does not find trivial accessors with method calls' do
+    inspect_source(cop,
+                   ['class TrivialFoo',
+                    ' def foo_bar(foo)',
+                    '   foo_bar = foo + 42',
+                    ' end',
+                    ' def foo(value)',
+                    '   foo = []',
+                    '   # do stuff',
+                    '   foo',
+                    ' end',
+                    ' def bar',
+                    '   foo_method',
+                    ' end',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not find trivial writer with exceptions' do
+    inspect_source(cop,
+                   [' def expiration_formatted=(value)',
+                    '   begin',
+                    '     @expiration = foo_stuff',
+                    '   rescue ArgumentError',
+                    '     @expiration = nil',
+                    '   end',
+                    '   self[:expiration] = @expiration',
+                    ' end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts an initialize method looking like a writer' do
+    inspect_source(cop,
+                   [' def initialize(value)',
+                    '   @top = value',
+                    ' end'])
+    expect(cop.offences).to be_empty
+  end
+
+  context 'exact name match required' do
+    let(:cop_config) { { 'ExactNameMatch' => true } }
+
+    it 'finds only 1 trivial reader' do
+      inspect_source(cop,
+                     ['def foo',
+                      '  @foo',
+                      'end',
+                      '',
+                      'def bar',
+                      '  @barr',
+                      'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.offences
+               .map(&:line).sort).to eq([1])
+    end
+
+    it 'finds only 1 trivial writer' do
+      inspect_source(cop,
+                     ['def foo=(foo)',
+                      '  @foo = foo',
+                      'end',
+                      '',
+                      'def bar=(bar)',
+                      '  @barr = bar',
+                      'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.offences
+               .map(&:line).sort).to eq([1])
+    end
+  end
+
+  context 'with predicates allowed' do
+    let(:cop_config) { { 'AllowPredicates' => true } }
+
+    it 'ignores accessors ending with a question mark' do
+      inspect_source(cop,
+                     [' def foo?',
+                      '   @foo',
+                      ' end'])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'with whitelist defined' do
+    let(:cop_config) { { 'Whitelist' => ['to_foo', 'bar='] } }
+
+    it 'ignores accessors in the whitelist' do
+      inspect_source(cop,
+                     [' def to_foo',
+                      '   @foo',
+                      ' end'])
+      expect(cop.offences).to be_empty
+    end
+    it 'ignores writers in the whitelist' do
+      inspect_source(cop,
+                     [' def bar=(bar)',
+                      '   @bar = bar',
+                      ' end'])
+      expect(cop.offences).to be_empty
+    end
+  end
+end