ridecharge-rubocop 0.0.1

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

@@ -0,0 +1,105 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::For, :config do
+  subject(:cop) { described_class.new(config) }
+
+  context 'when each is the enforced style' do
+    let(:cop_config) { { 'EnforcedStyle' => 'each' } }
+
+    it 'registers an offence for for' do
+      inspect_source(cop,
+                     ['def func',
+                      '  for n in [1, 2, 3] do',
+                      '    puts n',
+                      '  end',
+                      'end'])
+      expect(cop.messages).to eq(['Prefer *each* over *for*.'])
+      expect(cop.highlights).to eq(['for'])
+      expect(cop.config_to_allow_offences).to eq('EnforcedStyle' => 'for')
+    end
+
+    it 'registers an offence for opposite + correct style' do
+      inspect_source(cop,
+                     ['def func',
+                      '  for n in [1, 2, 3] do',
+                      '    puts n',
+                      '  end',
+                      '  [1, 2, 3].each do |n|',
+                      '    puts n',
+                      '  end',
+                      'end'])
+      expect(cop.messages).to eq(['Prefer *each* over *for*.'])
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
+    it 'accepts multiline each' do
+      inspect_source(cop,
+                     ['def func',
+                      '  [1, 2, 3].each do |n|',
+                      '    puts n',
+                      '  end',
+                      'end'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts :for' do
+      inspect_source(cop, ['[:for, :ala, :bala]'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts def for' do
+      inspect_source(cop, ['def for; end'])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'when for is the enforced style' do
+    let(:cop_config) { { 'EnforcedStyle' => 'for' } }
+
+    it 'accepts for' do
+      inspect_source(cop,
+                     ['def func',
+                      '  for n in [1, 2, 3] do',
+                      '    puts n',
+                      '  end',
+                      'end'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'registers an offence for multiline each' do
+      inspect_source(cop,
+                     ['def func',
+                      '  [1, 2, 3].each do |n|',
+                      '    puts n',
+                      '  end',
+                      'end'])
+      expect(cop.messages).to eq(['Prefer *for* over *each*.'])
+      expect(cop.highlights).to eq(['each'])
+      expect(cop.config_to_allow_offences).to eq('EnforcedStyle' => 'each')
+    end
+
+    it 'registers an offence for correct + opposite style' do
+      inspect_source(cop,
+                     ['def func',
+                      '  for n in [1, 2, 3] do',
+                      '    puts n',
+                      '  end',
+                      '  [1, 2, 3].each do |n|',
+                      '    puts n',
+                      '  end',
+                      'end'])
+      expect(cop.messages).to eq(['Prefer *for* over *each*.'])
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
+    it 'accepts single line each' do
+      inspect_source(cop,
+                     ['def func',
+                      '  [1, 2, 3].each { |n| puts n }',
+                      'end'])
+      expect(cop.offences).to be_empty
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::GlobalVars, :config do
+  cop_config = {
+    'AllowedVariables' => ['$allowed']
+  }
+
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { cop_config }
+
+  it 'registers an offence for $custom' do
+    inspect_source(cop, ['puts $custom'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'allows user whitelisted variables' do
+    inspect_source(cop, ['puts $allowed'])
+    expect(cop.offences).to be_empty
+  end
+
+  described_class::BUILT_IN_VARS.each do |var|
+    it "does not register an offence for built-in variable #{var}" do
+      inspect_source(cop, ["puts #{var}"])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  it 'does not register an offence for backrefs like $1' do
+    inspect_source(cop, ['puts $1'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::HashMethods do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for has_key? with one arg' do
+    inspect_source(cop,
+                   ['o.has_key?(o)'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['has_key? is deprecated in favor of key?.'])
+  end
+
+  it 'accepts has_key? with no args' do
+    inspect_source(cop,
+                   ['o.has_key?'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'registers an offence for has_value? with one arg' do
+    inspect_source(cop,
+                   ['o.has_value?(o)'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['has_value? is deprecated in favor of value?.'])
+  end
+
+  it 'accepts has_value? with no args' do
+    inspect_source(cop,
+                   ['o.has_value?'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'auto-corrects has_key? with key?' do
+    new_source = autocorrect_source(cop, 'hash.has_key?(:test)')
+    expect(new_source).to eq('hash.key?(:test)')
+  end
+
+  it 'auto-corrects has_value? with value?' do
+    new_source = autocorrect_source(cop, 'hash.has_value?(value)')
+    expect(new_source).to eq('hash.value?(value)')
+  end
+end

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

@@ -0,0 +1,131 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::HashSyntax, :config do
+  subject(:cop) { described_class.new(config) }
+
+  context 'configured to enforce ruby19 style' do
+    let(:config) do
+      Rubocop::Config.new('HashSyntax' => {
+                            'EnforcedStyle'   => 'ruby19',
+                            'SupportedStyles' => %w(ruby19 hash_rockets)
+                          },
+                          'SpaceAroundOperators' => { 'Enabled' => true })
+    end
+
+    it 'registers offence for hash rocket syntax when new is possible' do
+      inspect_source(cop, ['x = { :a => 0 }'])
+      expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
+      expect(cop.config_to_allow_offences)
+        .to eq('EnforcedStyle' => 'hash_rockets')
+    end
+
+    it 'registers an offence for mixed syntax when new is possible' do
+      inspect_source(cop, ['x = { :a => 0, b: 1 }'])
+      expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
+    it 'registers an offence for hash rockets in method calls' do
+      inspect_source(cop, ['func(3, :a => 0)'])
+      expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
+    end
+
+    it 'accepts hash rockets when keys have different types' do
+      inspect_source(cop, ['x = { :a => 0, "b" => 1 }'])
+      expect(cop.messages).to be_empty
+    end
+
+    it 'accepts hash rockets when keys have whitespaces in them' do
+      inspect_source(cop, ['x = { :"t o" => 0 }'])
+      expect(cop.messages).to be_empty
+    end
+
+    it 'accepts hash rockets when keys have special symbols in them' do
+      inspect_source(cop, ['x = { :"\tab" => 1 }'])
+      expect(cop.messages).to be_empty
+    end
+
+    it 'accepts hash rockets when keys start with a digit' do
+      inspect_source(cop, ['x = { :"1" => 1 }'])
+      expect(cop.messages).to be_empty
+    end
+
+    it 'registers offence when keys start with an uppercase letter' do
+      inspect_source(cop, ['x = { :A => 0 }'])
+      expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
+    end
+
+    it 'accepts new syntax in a hash literal' do
+      inspect_source(cop, ['x = { a: 0, b: 1 }'])
+      expect(cop.messages).to be_empty
+    end
+
+    it 'accepts new syntax in method calls' do
+      inspect_source(cop, ['func(3, a: 0)'])
+      expect(cop.messages).to be_empty
+    end
+
+    it 'auto-corrects old to new style' do
+      new_source = autocorrect_source(cop, '{ :a => 1, :b   =>  2}')
+      expect(new_source).to eq('{ a: 1, b: 2}')
+    end
+
+    it 'does not auto-correct if it interferes with SpaceAroundOperators' do
+      new_source = autocorrect_source(cop, '{ :a=>1, :b=>2 }')
+      expect(new_source).to eq('{ :a=>1, :b=>2 }')
+    end
+
+    context 'with SpaceAroundOperators disabled' do
+      let(:config) do
+        Rubocop::Config.new('HashSyntax' => {
+                              'EnforcedStyle'   => 'ruby19',
+                              'SupportedStyles' => %w(ruby19 hash_rockets)
+                            },
+                            'SpaceAroundOperators' => { 'Enabled' => false })
+      end
+
+      it 'auto-corrects even if there is no space around =>' do
+        new_source = autocorrect_source(cop, '{ :a=>1, :b=>2 }')
+        expect(new_source).to eq('{ a: 1, b: 2 }')
+      end
+    end
+  end
+
+  context 'configured to enforce hash rockets style' do
+    let(:cop_config) { { 'EnforcedStyle' => 'hash_rockets' } }
+
+    it 'registers offence for Ruby 1.9 style' do
+      inspect_source(cop, ['x = { a: 0 }'])
+      expect(cop.messages).to eq(['Always use hash rockets in hashes.'])
+      expect(cop.config_to_allow_offences).to eq('EnforcedStyle' => 'ruby19')
+    end
+
+    it 'registers an offence for mixed syntax' do
+      inspect_source(cop, ['x = { :a => 0, b: 1 }'])
+      expect(cop.messages).to eq(['Always use hash rockets in hashes.'])
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
+    it 'registers an offence for 1.9 style in method calls' do
+      inspect_source(cop, ['func(3, a: 0)'])
+      expect(cop.messages).to eq(['Always use hash rockets in hashes.'])
+    end
+
+    it 'accepts hash rockets in a hash literal' do
+      inspect_source(cop, ['x = { :a => 0, :b => 1 }'])
+      expect(cop.messages).to be_empty
+    end
+
+    it 'accepts hash rockets in method calls' do
+      inspect_source(cop, ['func(3, :a => 0)'])
+      expect(cop.messages).to be_empty
+    end
+
+    it 'auto-corrects new style to hash rockets' do
+      new_source = autocorrect_source(cop, '{ a: 1, b: 2}')
+      expect(new_source).to eq('{ :a => 1, :b => 2}')
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::IfUnlessModifier do
+  include StatementModifierHelper
+
+  subject(:cop) { described_class.new(config) }
+  let(:config) do
+    hash = { 'LineLength' => { 'Max' => 79 } }
+    Rubocop::Config.new(hash)
+  end
+
+  it 'registers an offence for multiline if that fits on one line' do
+    # This if statement fits exactly on one line if written as a
+    # modifier.
+    condition = 'a' * 38
+    body = 'b' * 35
+    expect("  #{body} if #{condition}".length).to eq(79)
+
+    inspect_source(cop,
+                   ["  if #{condition}",
+                    "    #{body}",
+                    '  end'])
+    expect(cop.messages).to eq(
+      ['Favor modifier if usage when you have a single-line' \
+       ' body. Another good alternative is the usage of control flow' +
+       ' &&/||.'])
+  end
+
+  it 'registers an offence for short multiline if near an else etc' do
+    inspect_source(cop,
+                   ['if x',
+                    '  y',
+                    'elsif x1',
+                    '  y1',
+                    'else',
+                    '  z',
+                    'end',
+                    'n = a ? 0 : 1',
+                    'm = 3 if m0',
+                    '',
+                    'if a',
+                    '  b',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it "accepts multiline if that doesn't fit on one line" do
+    check_too_long(cop, 'if')
+  end
+
+  it 'accepts multiline if whose body is more than one line' do
+    check_short_multiline(cop, 'if')
+  end
+
+  it 'registers an offence for multiline unless that fits on one line' do
+    inspect_source(cop, ['unless a',
+                         '  b',
+                         'end'])
+    expect(cop.messages).to eq(
+      ['Favor modifier unless usage when you have a single-line' \
+       ' body. Another good alternative is the usage of control flow' +
+       ' &&/||.'])
+  end
+
+  it 'accepts code with EOL comment since user might want to keep it' do
+    inspect_source(cop, ['unless a',
+                         '  b # A comment',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts if-else-end' do
+    inspect_source(cop,
+                   ['if args.last.is_a? Hash then args.pop else ' \
+                    'Hash.new end'])
+    expect(cop.messages).to be_empty
+  end
+
+  it 'accepts an empty condition' do
+    check_empty(cop, 'if')
+    check_empty(cop, 'unless')
+  end
+
+  it 'accepts if/elsif' do
+    inspect_source(cop, ['if test',
+                         '  something',
+                         'elsif test2',
+                         '  something_else',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  context 'with implicit match conditional' do
+    let(:source) do
+      [
+        "  if #{conditional}",
+        "    #{body}",
+        '  end'
+      ]
+    end
+
+    let(:body) { 'b' * 35 }
+
+    context 'when a multiline if fits on one line' do
+      let(:conditional) { "/#{'a' * 36}/" }
+
+      it 'registers an offence' do
+        expect("  #{body} if #{conditional}".length).to eq(79)
+
+        inspect_source(cop, source)
+        expect(cop.offences.size).to eq(1)
+      end
+    end
+
+    context "when a multiline if doesn't fit on one line" do
+      let(:conditional) { "/#{'a' * 37}/" }
+
+      it 'accepts' do
+        expect("  #{body} if #{conditional}".length).to eq(80)
+
+        inspect_source(cop, source)
+        expect(cop.offences).to be_empty
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::IfWithSemicolon do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for one line if/;/end' do
+    inspect_source(cop, ['if cond; run else dont end'])
+    expect(cop.messages).to eq(
+      ['Never use if x; Use the ternary operator instead.'])
+  end
+
+  it 'can handle modifier conditionals' do
+    inspect_source(cop, ['class Hash',
+                         'end if RUBY_VERSION < "1.8.7"'])
+    expect(cop.messages).to be_empty
+  end
+end