ridecharge-rubocop 0.0.1

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

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::MultilineTernaryOperator do
+  subject(:cop) { described_class.new }
+
+  it 'registers offence for a multiline ternary operator expression' do
+    inspect_source(cop, ['a = cond ?',
+                         '  b : c'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts a single line ternary operator expression' do
+    inspect_source(cop, ['a = cond ? b : c'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::NestedTernaryOperator do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for a nested ternary operator expression' do
+    inspect_source(cop, ['a ? (b ? b1 : b2) : a2'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts a non-nested ternary operator within an if' do
+    inspect_source(cop, ['a = if x',
+                         '  cond ? b : c',
+                         'else',
+                         '  d',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::NilComparison do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for == nil' do
+    inspect_source(cop,
+                   ['x == nil'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for === nil' do
+    inspect_source(cop,
+                   ['x === nil'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for === nil' do
+    inspect_source(cop,
+                   ['x != nil'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'works with lambda.()' do
+    inspect_source(cop, ['a.(x) == nil'])
+    expect(cop.offences.size).to eq(1)
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::Not do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for not' do
+    inspect_source(cop, ['not test'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'does not register an offence for !' do
+    inspect_source(cop, ['!test'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for :not' do
+    inspect_source(cop, ['[:not, :if, :else]'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::NumericLiterals, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'MinDigits' => 5 } }
+
+  it 'registers an offence for a long integer without underscores' do
+    inspect_source(cop, ['a = 123456'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.config_to_allow_offences).to eq('MinDigits' => 6)
+  end
+
+  it 'registers an offence for an integer with misplaced underscore' do
+    inspect_source(cop, ['a = 123_456_78_90_00'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+  end
+
+  it 'accepts long numbers with underscore' do
+    inspect_source(cop, ['a = 123_456',
+                         'b = 123_456.55'])
+    expect(cop.messages).to be_empty
+  end
+
+  it 'accepts a short integer without underscore' do
+    inspect_source(cop, ['a = 123'])
+    expect(cop.messages).to be_empty
+  end
+
+  it 'does not count a leading minus sign as a digit' do
+    inspect_source(cop, ['a = -1230'])
+    expect(cop.messages).to be_empty
+  end
+
+  it 'accepts short numbers without underscore' do
+    inspect_source(cop, ['a = 123',
+                         'b = 123.456'])
+    expect(cop.messages).to be_empty
+  end
+
+  it 'ignores non-decimal literals' do
+    inspect_source(cop, ['a = 0b1010101010101',
+                         'b = 01717171717171',
+                         'c = 0xab11111111bb'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'autocorrects a long integer offence' do
+    corrected = autocorrect_source(cop, ['a = 123456'])
+    expect(corrected).to eq 'a = 123_456'
+  end
+
+  it 'autocorrects an integer with misplaced underscore' do
+    corrected = autocorrect_source(cop, ['a = 123_456_78_90_00'])
+    expect(corrected).to eq 'a = 123_456_789_000'
+  end
+
+  it 'autocorrects negative numbers' do
+    corrected = autocorrect_source(cop, ['a = -123456'])
+    expect(corrected).to eq 'a = -123_456'
+  end
+end

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

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::OneLineConditional do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for one line if/then/end' do
+    inspect_source(cop, ['if cond then run else dont end'])
+    expect(cop.messages).to eq(['Favor the ternary operator (?:)' \
+                                ' over if/then/else/end constructs.'])
+  end
+end

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

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::OpMethod do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for arg not named other' do
+    inspect_source(cop,
+                   ['def +(another)',
+                    '  another',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['When defining the + operator, name its argument *other*.'])
+  end
+
+  it 'works properly even if the argument not surrounded with braces' do
+    inspect_source(cop,
+                   ['def + another',
+                    '  another',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['When defining the + operator, name its argument *other*.'])
+  end
+
+  it 'does not register an offence for arg named other' do
+    inspect_source(cop,
+                   ['def +(other)',
+                    '  other',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for []' do
+    inspect_source(cop,
+                   ['def [](index)',
+                    '  other',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for []=' do
+    inspect_source(cop,
+                   ['def []=(index, value)',
+                    '  other',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for <<' do
+    inspect_source(cop,
+                   ['def <<(cop)',
+                    '  other',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'does not register an offence for non binary operators' do
+    inspect_source(cop,
+                   ['def -@', # Unary minus
+                    'end',
+                    '',
+                    # This + is not a unary operator. It can only be
+                    # called with dot notation.
+                    'def +',
+                    'end',
+                    '',
+                    'def *(a, b)', # Quite strange, but legal ruby.
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::ParameterLists, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) do
+    {
+      'Max' => 4,
+      'CountKeywordArgs' => true
+    }
+  end
+
+  it 'registers an offence for a method def with 5 parameters' do
+    inspect_source(cop, ['def meth(a, b, c, d, e)',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.config_to_allow_offences).to eq('Max' => 5)
+  end
+
+  it 'accepts a method def with 4 parameters' do
+    inspect_source(cop, ['def meth(a, b, c, d)',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  context 'When CountKeywordArgs is true' do
+    it 'counts keyword arguments as well', ruby: 2.0 do
+      inspect_source(cop, ['def meth(a, b, c, d: 1, e: 2)',
+                           'end'])
+      expect(cop.offences.size).to eq(1)
+    end
+  end
+
+  context 'When CountKeywordArgs is false' do
+    before { cop_config['CountKeywordArgs'] = false }
+
+    it 'it does not count keyword arguments', ruby: 2.0 do
+      inspect_source(cop, ['def meth(a, b, c, d: 1, e: 2)',
+                           'end'])
+      expect(cop.offences).to be_empty
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::ParenthesesAroundCondition, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'AllowSafeAssignment' => true } }
+
+  it 'registers an offence for parentheses around condition' do
+    inspect_source(cop, ['if (x > 10)',
+                         'elsif (x < 3)',
+                         'end',
+                         'unless (x > 10)',
+                         'end',
+                         'while (x > 10)',
+                         'end',
+                         'until (x > 10)',
+                         'end',
+                         'x += 1 if (x < 10)',
+                         'x += 1 unless (x < 10)',
+                         'x += 1 until (x < 10)',
+                         'x += 1 while (x < 10)'
+                        ])
+    expect(cop.offences.size).to eq(9)
+    expect(cop.messages.first)
+      .to eq("Don't use parentheses around the condition of an if.")
+    expect(cop.messages.last)
+      .to eq("Don't use parentheses around the condition of a while.")
+  end
+
+  it 'accepts parentheses if there is no space between the keyword and (.' do
+    inspect_source(cop, ['if(x > 5) then something end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'auto-corrects parentheses around condition' do
+    corrected = autocorrect_source(cop, ['if (x > 10)',
+                                         'elsif (x < 3)',
+                                         'end',
+                                         'unless (x > 10)',
+                                         'end',
+                                         'while (x > 10)',
+                                         'end',
+                                         'until (x > 10)',
+                                         'end',
+                                         'x += 1 if (x < 10)',
+                                         'x += 1 unless (x < 10)',
+                                         'x += 1 while (x < 10)',
+                                         'x += 1 until (x < 10)'
+                                        ])
+    expect(corrected).to eq ['if x > 10',
+                             'elsif x < 3',
+                             'end',
+                             'unless x > 10',
+                             'end',
+                             'while x > 10',
+                             'end',
+                             'until x > 10',
+                             'end',
+                             'x += 1 if x < 10',
+                             'x += 1 unless x < 10',
+                             'x += 1 while x < 10',
+                             'x += 1 until x < 10'
+                            ].join("\n")
+  end
+
+  it 'accepts condition without parentheses' do
+    inspect_source(cop, ['if x > 10',
+                         'end',
+                         'unless x > 10',
+                         'end',
+                         'while x > 10',
+                         'end',
+                         'until x > 10',
+                         'end',
+                         'x += 1 if x < 10',
+                         'x += 1 unless x < 10',
+                         'x += 1 while x < 10',
+                         'x += 1 until x < 10'
+                        ])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts parentheses around condition in a ternary' do
+    inspect_source(cop, '(a == 0) ? b : a')
+    expect(cop.offences).to be_empty
+  end
+
+  it 'is not confused by leading parenthesis in subexpression' do
+    inspect_source(cop, ['(a > b) && other ? one : two'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'is not confused by unbalanced parentheses' do
+    inspect_source(cop, ['if (a + b).c()',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  context 'safe assignment is allowed' do
+    it 'accepts = in condition surrounded with parentheses' do
+      inspect_source(cop,
+                     ['if (test = 10)',
+                      'end'
+                     ])
+      expect(cop.offences).to be_empty
+    end
+
+  end
+
+  context 'safe assignment is not allowed' do
+    let(:cop_config) { { 'AllowSafeAssignment' => false } }
+
+    it 'does not accept = in condition surrounded with parentheses' do
+      inspect_source(cop,
+                     ['if (test = 10)',
+                      'end'
+                     ])
+      expect(cop.offences.size).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::PerlBackrefs do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for $1' do
+    inspect_source(cop, ['puts $1'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'auto-corrects $1 to Regexp.last_match[1]' do
+    new_source = autocorrect_source(cop, '$1')
+    expect(new_source).to eq('Regexp.last_match[1]')
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::PredicateName, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'NamePrefixBlacklist' => %w(has_ is_) } }
+
+  %w(has_ is_).each do |prefix|
+    it 'registers an offence for blacklisted method_name' do
+      inspect_source(cop, ["def #{prefix}_attr",
+                           '  # ...',
+                           'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(["#{prefix}_attr"])
+    end
+  end
+
+  it 'accepts non-blacklisted method name' do
+    inspect_source(cop, ['def have_attr',
+                         '  # ...',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+end