ridecharge-rubocop 0.0.1

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::UnlessElse do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for an unless with else' do
+    inspect_source(cop, ['unless x',
+                         '  a = 1',
+                         'else',
+                         '  a = 0',
+                         'end'])
+    expect(cop.messages).to eq(
+      ['Never use unless with else. Rewrite these with the ' \
+       'positive case first.'])
+  end
+
+  it 'accepts an unless without else' do
+    inspect_source(cop, ['unless x',
+                         '  a = 1',
+                         'end'])
+    expect(cop.messages).to be_empty
+  end
+end

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::VariableInterpolation do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for interpolated global variables' do
+    inspect_source(cop,
+                   ['puts "this is a #$test"'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Replace interpolated var $test' \
+        ' with expression #{$test}.'])
+  end
+
+  it 'registers an offence for interpolated regexp back references' do
+    inspect_source(cop,
+                   ['puts "this is a #$1"'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Replace interpolated var $1 with expression #{$1}.'])
+  end
+
+  it 'registers an offence for interpolated instance variables' do
+    inspect_source(cop,
+                   ['puts "this is a #@test"'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Replace interpolated var @test' \
+        ' with expression #{@test}.'])
+  end
+
+  it 'registers an offence for interpolated class variables' do
+    inspect_source(cop,
+                   ['puts "this is a #@@t"'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['Replace interpolated var @@t with expression #{@@t}.'])
+  end
+
+  it 'does not register an offence for variables in expressions' do
+    inspect_source(cop,
+                   ['puts "this is a #{@test} #{@@t} #{$t} #{$1}"'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::VariableName, :config do
+  subject(:cop) { described_class.new(config) }
+
+  shared_examples 'always accepted' do
+    it 'accepts screaming snake case globals' do
+      inspect_source(cop, '$MY_GLOBAL = 0')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts screaming snake case constants' do
+      inspect_source(cop, 'MY_CONSTANT = 0')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts assigning to camel case constant' do
+      inspect_source(cop, 'Paren = Struct.new :left, :right, :kind')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts assignment with indexing of self' do
+      inspect_source(cop, 'self[:a] = b')
+      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 local variable name' do
+      inspect_source(cop, 'myLocal = 1')
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(['myLocal'])
+      expect(cop.config_to_allow_offences).to eq('EnforcedStyle' =>
+                                                 'camelCase')
+    end
+
+    it 'registers an offence for correct + opposite' do
+      inspect_source(cop, ['my_local = 1',
+                           'myLocal = 1'])
+      expect(cop.highlights).to eq(['myLocal'])
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
+    it 'registers an offence for camel case in instance variable name' do
+      inspect_source(cop, '@myAttribute = 3')
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(['@myAttribute'])
+    end
+
+    it 'registers an offence for camel case in setter name' do
+      inspect_source(cop, 'self.mySetter = 2')
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(['mySetter'])
+    end
+
+    include_examples 'always accepted'
+  end
+
+  context 'when configured for camelCase' do
+    let(:cop_config) { { 'EnforcedStyle' => 'camelCase' } }
+
+    it 'registers an offence for snake case in local variable name' do
+      inspect_source(cop, 'my_local = 1')
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(['my_local'])
+      expect(cop.config_to_allow_offences).to eq('EnforcedStyle' =>
+                                                 'snake_case')
+    end
+
+    it 'registers an offence for opposite + correct' do
+      inspect_source(cop, ['my_local = 1',
+                           'myLocal = 1'])
+      expect(cop.highlights).to eq(['my_local'])
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
+    it 'accepts camel case in local variable name' do
+      inspect_source(cop, 'myLocal = 1')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts camel case in instance variable name' do
+      inspect_source(cop, '@myAttribute = 3')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts camel case in setter name' do
+      inspect_source(cop, 'self.mySetter = 2')
+      expect(cop.offences).to be_empty
+    end
+
+    include_examples 'always accepted'
+  end
+
+  context 'when configured with a bad value' do
+    let(:cop_config) { { 'EnforcedStyle' => 'other' } }
+
+    it 'fails' do
+      expect { inspect_source(cop, 'a = 3') }
+        .to raise_error(RuntimeError)
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::WhenThen do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for when x;' do
+    inspect_source(cop, ['case a',
+                         'when b; c',
+                         'end'])
+    expect(cop.messages).to eq(
+      ['Never use "when x;". Use "when x then" instead.'])
+  end
+
+  it 'accepts when x then' do
+    inspect_source(cop, ['case a',
+                         'when b then c',
+                         'end'])
+    expect(cop.messages).to be_empty
+  end
+
+  it 'accepts ; separating statements in the body of when' do
+    inspect_source(cop, ['case a',
+                         'when b then c; d',
+                         'end',
+                         '',
+                         'case e',
+                         'when f',
+                         '  g; h',
+                         'end'])
+    expect(cop.messages).to be_empty
+  end
+
+  it 'auto-corrects "when x;" with "when x then"' do
+    new_source = autocorrect_source(cop, ['case a',
+                                          'when b; c',
+                                          'end'])
+    expect(new_source).to eq("case a\nwhen b then c\nend")
+  end
+end

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::WhileUntilDo do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for do in multiline while' do
+    inspect_source(cop, ['while cond do',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for do in multiline until' do
+    inspect_source(cop, ['until cond do',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts do in single-line while' do
+    inspect_source(cop, ['while cond do something end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts do in single-line until' do
+    inspect_source(cop, ['until cond do something end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'it accepts multi-line while without do' do
+    inspect_source(cop, ['while cond',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'it accepts multi-line until without do' do
+    inspect_source(cop, ['until cond',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'auto-corrects the usage of "do" in multiline while' do
+    new_source = autocorrect_source(cop, ['while cond do',
+                                          'end'])
+    expect(new_source).to eq("while cond\nend")
+  end
+
+  it 'auto-corrects the usage of "do" in multiline until' do
+    new_source = autocorrect_source(cop, ['until cond do',
+                                          'end'])
+    expect(new_source).to eq("until cond\nend")
+  end
+end

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

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::WhileUntilModifier do
+  include StatementModifierHelper
+
+  subject(:cop) { described_class.new(config) }
+  let(:config) do
+    hash = { 'LineLength' => { 'Max' => 79 } }
+    Rubocop::Config.new(hash)
+  end
+
+  it "accepts multiline unless that doesn't fit on one line" do
+    check_too_long(cop, 'unless')
+  end
+
+  it 'accepts multiline unless whose body is more than one line' do
+    check_short_multiline(cop, 'unless')
+  end
+
+  it 'registers an offence for multiline while that fits on one line' do
+    check_really_short(cop, 'while')
+  end
+
+  it "accepts multiline while that doesn't fit on one line" do
+    check_too_long(cop, 'while')
+  end
+
+  it 'accepts multiline while whose body is more than one line' do
+    check_short_multiline(cop, 'while')
+  end
+
+  it 'accepts oneline while when condition has local variable assignment' do
+    inspect_source(cop, ['lines = %w{first second third}',
+                         'while (line = lines.shift)',
+                         '  puts line',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'registers an offence for oneline while when assignment is in body' do
+    inspect_source(cop, ['while true',
+                         '  x = 0',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for multiline until that fits on one line' do
+    check_really_short(cop, 'until')
+  end
+
+  it "accepts multiline until that doesn't fit on one line" do
+    check_too_long(cop, 'until')
+  end
+
+  it 'accepts multiline until whose body is more than one line' do
+    check_short_multiline(cop, 'until')
+  end
+
+  it 'accepts an empty condition' do
+    check_empty(cop, 'while')
+    check_empty(cop, 'until')
+  end
+
+  it 'accepts modifier while' do
+    inspect_source(cop, ['ala while bala'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts modifier until' do
+    inspect_source(cop, ['ala until bala'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::WordArray, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'MinSize' => 0 } }
+
+  it 'registers an offence for arrays of single quoted strings' do
+    inspect_source(cop,
+                   ["['one', 'two', 'three']"])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.config_to_allow_offences).to eq('MinSize' => 3)
+  end
+
+  it 'registers an offence for arrays of double quoted strings' do
+    inspect_source(cop,
+                   ['["one", "two", "three"]'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for arrays with character constants' do
+    inspect_source(cop,
+                   ['["one", ?\n]'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'does not register an offence for array of non-words' do
+    inspect_source(cop,
+                   ['["one space", "two", "three"]'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for array containing non-string' do
+    inspect_source(cop,
+                   ['["one", "two", 3]'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for array starting with %w' do
+    inspect_source(cop,
+                   ['%w(one two three)'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for array with one element' do
+    inspect_source(cop,
+                   ['["three"]'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for array with empty strings' do
+    inspect_source(cop,
+                   ['["", "two", "three"]'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for array with allowed number of strings' do
+    cop_config['MinSize'] = 3
+
+    inspect_source(cop,
+                   ['["one", "two", "three"]'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for an array with comments in it' do
+    inspect_source(cop,
+                   ['[',
+                    '"foo", # comment here',
+                    '"bar", # this thing was done because of a bug',
+                    '"baz" # do not delete this line',
+                    ']'])
+
+    expect(cop.offences).to be_empty
+  end
+
+  it 'registers an offence for an array with comments outside of it' do
+    inspect_source(cop,
+                   ['[',
+                    '"foo",',
+                    '"bar",',
+                    '"baz"',
+                    '] # test'])
+
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'auto-corrects an array of words' do
+    new_source = autocorrect_source(cop, "['one', %q(two), 'three']")
+    expect(new_source).to eq('%w(one two three)')
+  end
+
+  it 'auto-corrects an array of words and character constants' do
+    new_source = autocorrect_source(cop, '[%{one}, %Q(two), ?\n, ?\t]')
+    expect(new_source).to eq('%W(one two \n \t)')
+  end
+end