ridecharge-rubocop 0.0.1

data/spec/rubocop/cop/lint/useless_comparison_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Lint::UselessComparison do
+  subject(:cop) { described_class.new }
+
+  described_class::OPS.each do |op|
+    it "registers an offence for a simple comparison with #{op}" do
+      inspect_source(cop,
+                     ["5 #{op} 5",
+                      "a #{op} a"
+                     ])
+      expect(cop.offences.size).to eq(2)
+    end
+
+    it "registers an offence for a complex comparison with #{op}" do
+      inspect_source(cop,
+                     ["5 + 10 * 30 #{op} 5 + 10 * 30",
+                      "a.top(x) #{op} a.top(x)"
+                     ])
+      expect(cop.offences.size).to eq(2)
+    end
+  end
+
+  it 'works with lambda.()' do
+    inspect_source(cop, ['a.(x) > a.(x)'])
+    expect(cop.offences.size).to eq(1)
+  end
+end

data/spec/rubocop/cop/lint/useless_else_without_rescue_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Lint::UselessElseWithoutRescue do
+  subject(:cop) { described_class.new }
+
+  before do
+    inspect_source(cop, source)
+  end
+
+  context 'with `else` without `rescue`' do
+    let(:source) do
+      [
+        'begin',
+        '  do_something',
+        'else',
+        '  handle_unknown_errors',
+        'end'
+      ]
+    end
+
+    it 'registers an offence' do
+      expect(cop.offences.size).to eq(1)
+      expect(cop.offences.first.message)
+        .to eq('Else without rescue is useless')
+      expect(cop.highlights).to eq(['else'])
+    end
+  end
+
+  context 'with `else` with `rescue`' do
+    let(:source) do
+      [
+        'begin',
+        '  do_something',
+        'rescue ArgumentError',
+        '  handle_argument_error',
+        'else',
+        '  handle_unknown_errors',
+        'end'
+      ]
+    end
+
+    it 'accepts' do
+      expect(cop.offences).to be_empty
+    end
+  end
+end

data/spec/rubocop/cop/lint/useless_setter_call_spec.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Lint::UselessSetterCall do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for def ending with lvar attr assignment' do
+    inspect_source(cop,
+                   ['def test',
+                    '  top = Top.new',
+                    '  top.attr = 5',
+                    'end'
+                   ])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for defs ending with lvar attr assignment' do
+    inspect_source(cop,
+                   ['def Top.test',
+                    '  top = Top.new',
+                    '  top.attr = 5',
+                    'end'
+                   ])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts def ending with ivar assignment' do
+    inspect_source(cop,
+                   ['def test',
+                    '  something',
+                    '  @top = 5',
+                    'end'
+                   ])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts def ending ivar attr assignment' do
+    inspect_source(cop,
+                   ['def test',
+                    '  something',
+                    '  @top.attr = 5',
+                    'end'
+                   ])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts def ending with argument attr assignment' do
+    inspect_source(cop,
+                   ['def test(some_arg)',
+                    '  unrelated_local_variable = Top.new',
+                    '  some_arg.attr = 5',
+                    'end'
+                   ])
+    expect(cop.offences).to be_empty
+  end
+
+  context 'when a lvar has an object passed as argument ' \
+          'at the end of the method' do
+    it 'accepts the lvar attr assignment' do
+      inspect_source(cop,
+                     ['def test(some_arg)',
+                      '  @some_ivar = some_arg',
+                      '  @some_ivar.do_something',
+                      '  some_lvar = @some_ivar',
+                      '  some_lvar.do_something',
+                      '  some_lvar.attr = 5',
+                      'end'
+                     ])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'when a lvar has an object passed as argument ' \
+          'by multiple-assignment at the end of the method' do
+    it 'accepts the lvar attr assignment' do
+      inspect_source(cop,
+                     ['def test(some_arg)',
+                      '  _first, some_lvar, _third  = 1, some_arg, 3',
+                      '  some_lvar.attr = 5',
+                      'end'
+                     ])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'when a lvar does not have any object passed as argument ' \
+          'with multiple-assignment at the end of the method' do
+    it 'registers an offence' do
+      inspect_source(cop,
+                     ['def test(some_arg)',
+                      '  _first, some_lvar, _third  = do_something',
+                      '  some_lvar.attr = 5',
+                      'end'
+                     ])
+      expect(cop.offences.size).to eq(1)
+    end
+  end
+
+  context 'when a lvar possibly has an object passed as argument ' \
+          'by logical-operator-assignment at the end of the method' do
+    it 'accepts the lvar attr assignment' do
+      inspect_source(cop,
+                     ['def test(some_arg)',
+                      '  some_lvar = nil',
+                      '  some_lvar ||= some_arg',
+                      '  some_lvar.attr = 5',
+                      'end'
+                     ])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'when a lvar does not have any object passed as argument ' \
+          'by binary-operator-assignment at the end of the method' do
+    it 'registers an offence' do
+      inspect_source(cop,
+                     ['def test(some_arg)',
+                      '  some_lvar = some_arg',
+                      '  some_lvar += some_arg',
+                      '  some_lvar.attr = 5',
+                      'end'
+                     ])
+      expect(cop.offences.size).to eq(1)
+    end
+  end
+
+  context 'when a lvar declared as an argument ' \
+          'is no longer the passed object at the end of the method' do
+    it 'registers an offence for the lvar attr assignment' do
+      inspect_source(cop,
+                     ['def test(some_arg)',
+                      '  some_arg = Top.new',
+                      '  some_arg.attr = 5',
+                      'end'
+                     ])
+      expect(cop.offences.size).to eq(1)
+    end
+  end
+
+  it 'is not confused by operators ending with =' do
+    inspect_source(cop,
+                   ['def test',
+                    '  top.attr == 5',
+                    'end'
+                   ])
+    expect(cop.offences).to be_empty
+  end
+end

data/spec/rubocop/cop/lint/void_spec.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Lint::Void do
+  subject(:cop) { described_class.new }
+
+  described_class::OPS.each do |op|
+    it "registers an offence for void op #{op} if not on last line" do
+      inspect_source(cop,
+                     ["a #{op} b",
+                      "a #{op} b",
+                      "a #{op} b"
+                     ])
+      expect(cop.offences.size).to eq(2)
+    end
+  end
+
+  described_class::OPS.each do |op|
+    it "accepts void op #{op} if on last line" do
+      inspect_source(cop,
+                     ['something',
+                      "a #{op} b"
+                     ])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  described_class::OPS.each do |op|
+    it "accepts void op #{op} by itself without a begin block" do
+      inspect_source(cop, ["a #{op} b"])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  %w(var @var @@var VAR).each do |var|
+    it "registers an offence for void var #{var} if not on last line" do
+      inspect_source(cop,
+                     ["#{var} = 5",
+                      "#{var}",
+                      'top'
+                     ])
+      expect(cop.offences.size).to eq(1)
+    end
+  end
+
+  %w(1 2.0 /test/ [1] {}).each do |lit|
+    it "registers an offence for void lit #{lit} if not on last line" do
+      inspect_source(cop,
+                     ["#{lit}",
+                      'top'
+                     ])
+      expect(cop.offences.size).to eq(1)
+    end
+  end
+
+end

data/spec/rubocop/cop/offence_spec.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Offence do
+  let(:location) do
+    source_buffer = Parser::Source::Buffer.new('test', 1)
+    source_buffer.source = "a\n"
+    Parser::Source::Range.new(source_buffer, 0, 1)
+  end
+  subject(:offence) do
+    described_class.new(:convention, location, 'message', 'CopName', true)
+  end
+
+  it 'has a few required attributes' do
+    expect(offence.severity).to eq(:convention)
+    expect(offence.line).to eq(1)
+    expect(offence.message).to eq('message')
+    expect(offence.cop_name).to eq('CopName')
+    expect(offence.corrected?).to be_true
+  end
+
+  it 'overrides #to_s' do
+    expect(offence.to_s).to eq('C:  1:  1: message')
+  end
+
+  it 'does not blow up if a message contains %' do
+    offence = described_class.new(:convention, location, 'message % test',
+                                  'CopName')
+
+    expect(offence.to_s).to eq('C:  1:  1: message % test')
+  end
+
+  it 'redefines == to compare offences based on their contents' do
+    o1 = described_class.new(:convention, location, 'message', 'CopName')
+    o2 = described_class.new(:convention, location, 'message', 'CopName')
+
+    expect(o1 == o2).to be_true
+  end
+
+  it 'is frozen' do
+    expect(offence).to be_frozen
+  end
+
+  [:severity, :location, :line, :column, :message, :cop_name].each do |a|
+    describe "##{a}" do
+      it 'is frozen' do
+        expect(offence.send(a)).to be_frozen
+      end
+    end
+  end
+
+  context 'when unknown severity is passed' do
+    it 'raises error' do
+      expect do
+        described_class.new(:foobar, location, 'message', 'CopName')
+      end.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#severity_level' do
+    subject(:severity_level) do
+      described_class.new(severity, location, 'message', 'CopName')
+        .severity_level
+    end
+
+    context 'when severity is :refactor' do
+      let(:severity) { :refactor }
+      it 'is 1' do
+        expect(severity_level).to eq(1)
+      end
+    end
+
+    context 'when severity is :fatal' do
+      let(:severity) { :fatal }
+      it 'is 5' do
+        expect(severity_level).to eq(5)
+      end
+    end
+  end
+
+  describe '#<=>' do
+    def offence(hash = {})
+      attrs = {
+        sev:  :convention,
+        line: 5,
+        col:  5,
+        mes:  'message',
+        cop:  'CopName'
+      }.merge(hash)
+
+      described_class.new(
+        attrs[:sev],
+        location(attrs[:line], attrs[:col],
+                 %w(aaaaaa bbbbbb cccccc dddddd eeeeee ffffff)),
+        attrs[:mes],
+        attrs[:cop]
+      )
+    end
+
+    def location(line, column, source)
+      source_buffer = Parser::Source::Buffer.new('test', 1)
+      source_buffer.source = source.join("\n")
+      begin_pos = source[0...(line - 1)].reduce(0) do |a, e|
+        a + e.length + "\n".length
+      end + column
+      Parser::Source::Range.new(source_buffer, begin_pos, begin_pos + 1)
+    end
+
+    # We want a nice table layout, so we allow space inside empty hashes.
+    # rubocop:disable SpaceInsideHashLiteralBraces
+    [
+      [{                           }, {                           }, 0],
+
+      [{ line: 6                   }, { line: 5                   }, 1],
+
+      [{ line: 5, col: 6           }, { line: 5, col: 5           }, 1],
+      [{ line: 6, col: 4           }, { line: 5, col: 5           }, 1],
+
+      [{                  cop: 'B' }, {                  cop: 'A' }, 1],
+      [{ line: 6,         cop: 'A' }, { line: 5,         cop: 'B' }, 1],
+      [{          col: 6, cop: 'A' }, {          col: 5, cop: 'B' }, 1]
+    ].each do |one, other, expectation|
+      context "when receiver has #{one} and other has #{other}" do
+        it "returns #{expectation}" do
+          an_offence = offence(one)
+          other_offence = offence(other)
+          expect(an_offence <=> other_offence).to eq(expectation)
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cop/rails/default_scope_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Rails::DefaultScope do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offence for default scope with a lambda arg' do
+    inspect_source(cop,
+                   ['default_scope -> { something }'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for default scope with a proc arg' do
+    inspect_source(cop,
+                   ['default_scope proc { something }'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for default scope with a proc(Proc.new) arg' do
+    inspect_source(cop,
+                   ['default_scope Proc.new { something }'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for non blocks' do
+    inspect_source(cop,
+                   ['default_scope order: "position"'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts a block arg' do
+    inspect_source(cop,
+                   ['default_scope { something }'])
+    expect(cop.offences).to be_empty
+  end
+end