ridecharge-rubocop 0.0.1

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

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::SingleLineBlockParams, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) do
+    { 'Methods' =>
+      [{ 'reduce' => %w(a e) },
+       { 'test' => %w(x y) }]
+    }
+  end
+
+  it 'find wrong argument names in calls with different syntax' do
+    inspect_source(cop,
+                   ['def m',
+                    '  [0, 1].reduce { |c, d| c + d }',
+                    '  [0, 1].reduce{ |c, d| c + d }',
+                    '  [0, 1].reduce(5) { |c, d| c + d }',
+                    '  [0, 1].reduce(5){ |c, d| c + d }',
+                    '  [0, 1].reduce (5) { |c, d| c + d }',
+                    '  [0, 1].reduce(5) { |c, d| c + d }',
+                    '  ala.test { |x, z| bala }',
+                    'end'])
+    expect(cop.offences.size).to eq(7)
+    expect(cop.offences.map(&:line).sort).to eq((2..8).to_a)
+  end
+
+  it 'allows calls with proper argument names' do
+    inspect_source(cop,
+                   ['def m',
+                    '  [0, 1].reduce { |a, e| a + e }',
+                    '  [0, 1].reduce{ |a, e| a + e }',
+                    '  [0, 1].reduce(5) { |a, e| a + e }',
+                    '  [0, 1].reduce(5){ |a, e| a + e }',
+                    '  [0, 1].reduce (5) { |a, e| a + e }',
+                    '  [0, 1].reduce(5) { |a, e| a + e }',
+                    '  ala.test { |x, y| bala }',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'ignores do..end blocks' do
+    inspect_source(cop,
+                   ['def m',
+                    '  [0, 1].reduce do |c, d|',
+                    '    c + d',
+                    '  end',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'ignores :reduce symbols' do
+    inspect_source(cop,
+                   ['def m',
+                    '  call_method(:reduce) { |a, b| a + b}',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not report when destructuring is used' do
+    inspect_source(cop,
+                   ['def m',
+                    '  test.reduce { |a, (id, _)| a + id}',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::SingleLineMethods, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'AllowIfMethodIsEmpty' => true } }
+
+  it 'registers an offence for a single-line method' do
+    inspect_source(cop,
+                   ['def some_method; body end',
+                    'def link_to(name, url); {:name => name}; end',
+                    'def @table.columns; super; end'])
+    expect(cop.messages).to eq(
+      ['Avoid single-line method definitions.'] * 3)
+  end
+
+  context 'when AllowIfMethodIsEmpty is disabled' do
+    let(:cop_config) { { 'AllowIfMethodIsEmpty' => false } }
+
+    it 'registers an offence for an empty method' do
+      inspect_source(cop, ['def no_op; end',
+                           'def self.resource_class=(klass); end',
+                           'def @table.columns; end'])
+      expect(cop.offences.size).to eq(3)
+    end
+  end
+
+  context 'when AllowIfMethodIsEmpty is enabled' do
+    let(:cop_config) { { 'AllowIfMethodIsEmpty' => true } }
+
+    it 'accepts a single-line empty method' do
+      inspect_source(cop, ['def no_op; end',
+                           'def self.resource_class=(klass); end',
+                           'def @table.columns; end'])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  it 'accepts a multi-line method' do
+    inspect_source(cop, ['def some_method',
+                         '  body',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not crash on an method with a capitalized name' do
+    inspect_source(cop, ['def NoSnakeCase',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::SpaceAfterColon do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for colon without space after it' do
+    # TODO: There is double reporting of the last colon (also from
+    # SpaceAroundOperators).
+    inspect_source(cop, ['x = w ? {a:3}:4'])
+    expect(cop.messages).to eq(['Space missing after colon.'] * 2)
+    expect(cop.highlights).to eq([':'] * 2)
+  end
+
+  it 'accepts colons in symbols' do
+    inspect_source(cop, ['x = :a'])
+    expect(cop.messages).to be_empty
+  end
+
+  if RUBY_VERSION >= '2.1'
+    it 'accepts colons denoting required keyword argument' do
+      inspect_source(cop, ['def initialize(table:, nodes:)',
+                           'end'])
+      expect(cop.messages).to be_empty
+    end
+  end
+
+  it 'accepts colons in strings' do
+    inspect_source(cop, ["str << ':'"])
+    expect(cop.messages).to be_empty
+  end
+
+  it 'auto-corrects missing space' do
+    new_source = autocorrect_source(cop, 'x = w ? {a:3}:4')
+    expect(new_source).to eq('x = w ? {a: 3}: 4')
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::SpaceAfterComma do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for block argument commas without space' do
+    inspect_source(cop, ['each { |s,t| }'])
+    expect(cop.messages).to eq(
+      ['Space missing after comma.'])
+  end
+
+  it 'registers an offence for array index commas without space' do
+    inspect_source(cop, ['formats[0,1]'])
+    expect(cop.messages).to eq(
+      ['Space missing after comma.'])
+  end
+
+  it 'registers an offence for method call arg commas without space' do
+    inspect_source(cop, ['a(1,2)'])
+    expect(cop.messages).to eq(
+      ['Space missing after comma.'])
+  end
+
+  it 'auto-corrects missing space' do
+    new_source = autocorrect_source(cop, 'each { |s,t| a(1,formats[0,1])}')
+    expect(new_source).to eq('each { |s, t| a(1, formats[0, 1])}')
+  end
+end

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

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::SpaceAfterControlKeyword do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for normal if' do
+    inspect_source(cop,
+                   ['if(test) then result end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for modifier unless' do
+    inspect_source(cop, ['action unless(test)'])
+
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'does not get confused by keywords' do
+    inspect_source(cop, ['[:if, :unless].action'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not get confused by the ternary operator' do
+    inspect_source(cop, ['a ? b : c'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'registers an offence for if, elsif, and unless' do
+    inspect_source(cop,
+                   ['if(a)',
+                    'elsif(b)',
+                    '  unless(c)',
+                    '  end',
+                    'end'])
+    expect(cop.offences.map(&:line)).to eq([1, 2, 3])
+  end
+
+  it 'registers an offence for case and when' do
+    inspect_source(cop,
+                   ['case(a)',
+                    'when(0) then 1',
+                    'end'])
+    expect(cop.offences.map(&:line)).to eq([1, 2])
+  end
+
+  it 'registers an offence for while and until' do
+    inspect_source(cop,
+                   ['while(a)',
+                    '  b until(c)',
+                    'end'])
+    expect(cop.offences.map(&:line)).to eq([1, 2])
+  end
+
+  it 'auto-corrects missing space' do
+    new_source = autocorrect_source(cop, ['if(test) then result end',
+                                          'action unless(test)',
+                                          'if(a)',
+                                          'elsif(b)',
+                                          '  unless(c)',
+                                          '  end',
+                                          'end',
+                                          'case(a)',
+                                          'when(0) then 1',
+                                          'end',
+                                          'while(a)',
+                                          '  b until(c)',
+                                          'end'])
+    expect(new_source).to eq(['if (test) then result end',
+                              'action unless (test)',
+                              'if (a)',
+                              'elsif (b)',
+                              '  unless (c)',
+                              '  end',
+                              'end',
+                              'case (a)',
+                              'when (0) then 1',
+                              'end',
+                              'while (a)',
+                              '  b until (c)',
+                              'end'].join("\n"))
+  end
+end

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

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::SpaceAfterMethodName do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for def with space before the parenthesis' do
+    inspect_source(cop,
+                   ['def func (x)',
+                    '  a',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for defs with space before the parenthesis' do
+    inspect_source(cop,
+                   ['def self.func (x)',
+                    '  a',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts a def without arguments' do
+    inspect_source(cop,
+                   ['def func',
+                    '  a',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a defs without arguments' do
+    inspect_source(cop,
+                   ['def self.func',
+                    '  a',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a def with arguments but no parentheses' do
+    inspect_source(cop,
+                   ['def func x',
+                    '  a',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts a defs with arguments but no parentheses' do
+    inspect_source(cop,
+                   ['def self.func x',
+                    '  a',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'auto-corrects unwanted space' do
+    new_source = autocorrect_source(cop, ['def func (x)',
+                                          '  a',
+                                          'end',
+                                          'def self.func (x)',
+                                          '  a',
+                                          'end'])
+    expect(new_source).to eq(['def func(x)',
+                              '  a',
+                              'end',
+                              'def self.func(x)',
+                              '  a',
+                              'end'].join("\n"))
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::SpaceAfterNot do
+  subject(:cop) { described_class.new }
+
+  it 'reports an offence for space after !' do
+    inspect_source(cop, ['! something'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts no space after !' do
+    inspect_source(cop, ['!something'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'auto-corrects by removing redundant space' do
+    new_source = autocorrect_source(cop, '!  something')
+    expect(new_source).to eq('!something')
+  end
+end

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

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::SpaceAfterSemicolon do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for semicolon without space after it' do
+    inspect_source(cop, ['x = 1;y = 2'])
+    expect(cop.messages).to eq(
+      ['Space missing after semicolon.'])
+  end
+
+  it 'does not crash if semicolon is the last character of the file' do
+    inspect_source(cop, ['x = 1;'])
+    expect(cop.messages).to be_empty
+  end
+
+  it 'auto-corrects missing space' do
+    new_source = autocorrect_source(cop, 'x = 1;y = 2')
+    expect(new_source).to eq('x = 1; y = 2')
+  end
+end

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

@@ -0,0 +1,283 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::SpaceAroundBlockBraces do
+  SUPPORTED_STYLES = %w(space_inside_braces no_space_inside_braces)
+
+  subject(:cop) { described_class.new(config) }
+  let(:config) do
+    merged = Rubocop::ConfigLoader
+      .default_configuration['SpaceAroundBlockBraces'].merge(cop_config)
+    Rubocop::Config.new('Blocks' => { 'Enabled' => false },
+                        'SpaceAroundBlockBraces' => merged)
+  end
+  let(:cop_config) do
+    {
+      'EnforcedStyle' => 'space_inside_braces',
+      'SupportedStyles' => SUPPORTED_STYLES,
+      'SpaceBeforeBlockParameters' => true
+    }
+  end
+
+  context 'with space inside empty braces not allowed' do
+    let(:cop_config) { { 'EnforcedStyleForEmptyBraces' => 'no_space' } }
+
+    it 'accepts empty braces with no space inside' do
+      inspect_source(cop, ['each {}'])
+      expect(cop.messages).to be_empty
+    end
+
+    it 'accepts empty braces with line break inside' do
+      inspect_source(cop, ['  each {',
+                           '  }'])
+      expect(cop.messages).to be_empty
+    end
+
+    it 'registers an offence for empty braces with space inside' do
+      inspect_source(cop, ['each { }'])
+      expect(cop.messages).to eq(['Space inside empty braces detected.'])
+      expect(cop.highlights).to eq([' '])
+    end
+
+    it 'auto-corrects unwanted space' do
+      new_source = autocorrect_source(cop, 'each { }')
+      expect(new_source).to eq('each {}')
+    end
+
+    it 'does not auto-correct when braces are not empty' do
+      old_source = <<-END
+        a {
+          b
+        }
+      END
+      new_source = autocorrect_source(cop, old_source)
+      expect(new_source).to eq(old_source)
+    end
+  end
+
+  context 'with space inside empty braces allowed' do
+    let(:cop_config) { { 'EnforcedStyleForEmptyBraces' => 'space' } }
+
+    it 'accepts empty braces with space inside' do
+      inspect_source(cop, ['each { }'])
+      expect(cop.messages).to be_empty
+    end
+
+    it 'registers an offence for empty braces with no space inside' do
+      inspect_source(cop, ['each {}'])
+      expect(cop.messages).to eq(['Space missing inside empty braces.'])
+      expect(cop.highlights).to eq(['{}'])
+    end
+
+    it 'auto-corrects missing space' do
+      new_source = autocorrect_source(cop, 'each {}')
+      expect(new_source).to eq('each { }')
+    end
+  end
+
+  it 'accepts braces surrounded by spaces' do
+    inspect_source(cop, ['each { puts }'])
+    expect(cop.messages).to be_empty
+    expect(cop.highlights).to be_empty
+  end
+
+  it 'registers an offence for left brace without outer space' do
+    inspect_source(cop, ['each{ puts }'])
+    expect(cop.messages).to eq(['Space missing to the left of {.'])
+    expect(cop.highlights).to eq(['{'])
+  end
+
+  it 'registers an offence for left brace without inner space' do
+    inspect_source(cop, ['each {puts }'])
+    expect(cop.messages).to eq(['Space missing inside {.'])
+    expect(cop.highlights).to eq(['p'])
+  end
+
+  it 'registers an offence for right brace without inner space' do
+    inspect_source(cop, ['each { puts}'])
+    expect(cop.messages).to eq(['Space missing inside }.'])
+    expect(cop.highlights).to eq(['}'])
+    expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+  end
+
+  it 'registers offences for both braces without inner space' do
+    inspect_source(cop, ['a {}',
+                         'b { }',
+                         'each {puts}'])
+    expect(cop.messages).to eq(['Space inside empty braces detected.',
+                                'Space missing inside {.',
+                                'Space missing inside }.'])
+    expect(cop.highlights).to eq([' ', 'p', '}'])
+
+    # Both correct and incorrect code has been found in relation to
+    # EnforcedStyleForEmptyBraces, but that doesn't matter. EnforcedStyle can
+    # be changed to get rid of the EnforcedStyle offences.
+    expect(cop.config_to_allow_offences).to eq('EnforcedStyle' =>
+                                               'no_space_inside_braces')
+  end
+
+  it 'auto-corrects missing space' do
+    new_source = autocorrect_source(cop, 'each {puts}')
+    expect(new_source).to eq('each { puts }')
+  end
+
+  context 'with passed in parameters' do
+    it 'accepts left brace with inner space' do
+      inspect_source(cop, ['each { |x| puts }'])
+      expect(cop.messages).to be_empty
+      expect(cop.highlights).to be_empty
+    end
+
+    it 'registers an offence for left brace without inner space' do
+      inspect_source(cop, ['each {|x| puts }'])
+      expect(cop.messages).to eq(['Space between { and | missing.'])
+      expect(cop.highlights).to eq(['{|'])
+    end
+
+    it 'auto-corrects missing space' do
+      new_source = autocorrect_source(cop, 'each{|x| puts }')
+      expect(new_source).to eq('each { |x| puts }')
+    end
+
+    context 'and Blocks cop enabled' do
+      let(:config) do
+        Rubocop::Config.new('Blocks'                 => { 'Enabled' => true },
+                            'SpaceAroundBlockBraces' => cop_config)
+      end
+
+      it 'does auto-correction for single-line blocks' do
+        new_source = autocorrect_source(cop, 'each{|x| puts}')
+        expect(new_source).to eq('each { |x| puts }')
+      end
+
+      it 'does not do auto-correction for multi-line blocks' do
+        # {} will be changed to do..end by the Blocks cop, and then this cop is
+        # not relevant anymore.
+        old_source = ['each{|x|',
+                      '  puts',
+                      '}']
+        new_source = autocorrect_source(cop, old_source)
+        expect(new_source).to eq(old_source.join("\n"))
+      end
+    end
+
+    context 'and space before block parameters not allowed' do
+      let(:cop_config) do
+        {
+          'EnforcedStyle'              => 'space_inside_braces',
+          'SupportedStyles'            => SUPPORTED_STYLES,
+          'SpaceBeforeBlockParameters' => false
+        }
+      end
+
+      it 'registers an offence for left brace with inner space' do
+        inspect_source(cop, ['each { |x| puts }'])
+        expect(cop.messages).to eq(['Space between { and | detected.'])
+        expect(cop.highlights).to eq([' '])
+      end
+
+      it 'auto-corrects unwanted space' do
+        new_source = autocorrect_source(cop, 'each { |x| puts }')
+        expect(new_source).to eq('each {|x| puts }')
+      end
+
+      it 'accepts left brace without inner space' do
+        inspect_source(cop, ['each {|x| puts }'])
+        expect(cop.messages).to be_empty
+        expect(cop.highlights).to be_empty
+      end
+    end
+  end
+
+  context 'configured with no_space_inside_braces' do
+    let(:cop_config) do
+      {
+        'EnforcedStyle'              => 'no_space_inside_braces',
+        'SupportedStyles'            => SUPPORTED_STYLES,
+        'SpaceBeforeBlockParameters' => true
+      }
+    end
+
+    it 'accepts braces without spaces inside' do
+      inspect_source(cop, ['each {puts}'])
+      expect(cop.messages).to be_empty
+      expect(cop.highlights).to be_empty
+    end
+
+    it 'registers an offence for left brace with inner space' do
+      inspect_source(cop, ['each { puts}'])
+      expect(cop.messages).to eq(['Space inside { detected.'])
+      expect(cop.highlights).to eq([' '])
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
+    it 'registers an offence for right brace with inner space' do
+      inspect_source(cop, ['each {puts  }'])
+      expect(cop.messages).to eq(['Space inside } detected.'])
+      expect(cop.highlights).to eq(['  '])
+    end
+
+    it 'registers offences for both braces with inner space' do
+      inspect_source(cop, ['each { puts  }'])
+      expect(cop.messages).to eq(['Space inside { detected.',
+                                  'Space inside } detected.'])
+      expect(cop.highlights).to eq([' ', '  '])
+      expect(cop.config_to_allow_offences).to eq('EnforcedStyle' =>
+                                                 'space_inside_braces')
+    end
+
+    it 'registers an offence for left brace without outer space' do
+      inspect_source(cop, ['each{puts}'])
+      expect(cop.messages).to eq(['Space missing to the left of {.'])
+      expect(cop.highlights).to eq(['{'])
+    end
+
+    it 'auto-corrects missing space' do
+      new_source = autocorrect_source(cop, 'each{ puts }')
+      expect(new_source).to eq('each {puts}')
+    end
+
+    context 'with passed in parameters' do
+      context 'and space before block parameters allowed' do
+        it 'accepts left brace with inner space' do
+          inspect_source(cop, ['each { |x| puts}'])
+          expect(cop.messages).to eq([])
+          expect(cop.highlights).to eq([])
+        end
+
+        it 'registers an offence for left brace without inner space' do
+          inspect_source(cop, ['each {|x| puts}'])
+          expect(cop.messages).to eq(['Space between { and | missing.'])
+          expect(cop.highlights).to eq(['{|'])
+        end
+
+        it 'auto-corrects missing space' do
+          new_source = autocorrect_source(cop, 'each {|x| puts}')
+          expect(new_source).to eq('each { |x| puts}')
+        end
+      end
+
+      context 'and space before block parameters not allowed' do
+        let(:cop_config) do
+          {
+            'EnforcedStyle'              => 'no_space_inside_braces',
+            'SupportedStyles'            => SUPPORTED_STYLES,
+            'SpaceBeforeBlockParameters' => false
+          }
+        end
+
+        it 'registers an offence for left brace with inner space' do
+          inspect_source(cop, ['each { |x| puts}'])
+          expect(cop.messages).to eq(['Space between { and | detected.'])
+          expect(cop.highlights).to eq([' '])
+        end
+
+        it 'auto-corrects unwanted space' do
+          new_source = autocorrect_source(cop, 'each { |x| puts}')
+          expect(new_source).to eq('each {|x| puts}')
+        end
+      end
+    end
+  end
+end