ridecharge-rubocop 0.0.1

data/spec/rubocop/config_store_spec.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::ConfigStore do
+  subject(:config_store) { described_class.new }
+
+  before do
+    allow(Rubocop::ConfigLoader).to receive(:configuration_file_for) do |arg|
+      # File tree:
+      # file1
+      # dir/.rubocop.yml
+      # dir/file2
+      # dir/subdir/file3
+      (arg =~ /dir/ ? 'dir' : '.') + '/.rubocop.yml'
+    end
+    allow(Rubocop::ConfigLoader)
+      .to receive(:configuration_from_file) { |arg| arg }
+    allow(Rubocop::ConfigLoader)
+      .to receive(:load_file) { |arg| "#{arg} loaded" }
+    allow(Rubocop::ConfigLoader)
+      .to receive(:merge_with_default) { |config, file| "merged #{config}" }
+  end
+
+  describe '.for' do
+    it 'always uses config specified in command line' do
+      config_store.options_config = :options_config
+      expect(config_store.for('file1')).to eq('merged options_config loaded')
+    end
+
+    context 'when no config specified in command line' do
+      it 'gets config path and config from cache if available' do
+        expect(Rubocop::ConfigLoader).to receive(:configuration_file_for).once
+          .with('dir')
+        expect(Rubocop::ConfigLoader).to receive(:configuration_file_for).once
+          .with('dir/subdir')
+        # The stub returns the same config path for dir and dir/subdir.
+        expect(Rubocop::ConfigLoader).to receive(:configuration_from_file).once
+          .with('dir/.rubocop.yml')
+
+        config_store.for('dir/file2')
+        config_store.for('dir/file2')
+        config_store.for('dir/subdir/file3')
+      end
+
+      it 'searches for config path if not available in cache' do
+        expect(Rubocop::ConfigLoader).to receive(:configuration_file_for).once
+        expect(Rubocop::ConfigLoader).to receive(:configuration_from_file).once
+        config_store.for('file1')
+      end
+    end
+  end
+end

data/spec/rubocop/cop/commissioner_spec.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+# rubocop:disable LineLength
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Commissioner do
+  describe '#investigate' do
+    let(:cop) { double(Rubocop::Cop, offences: []).as_null_object }
+
+    it 'returns all offences found by the cops' do
+      allow(cop).to receive(:offences).and_return([1])
+
+      commissioner = described_class.new([cop])
+      source = []
+      processed_source = parse_source(source)
+
+      expect(commissioner.investigate(processed_source)).to eq [1]
+    end
+
+    context 'when a cop has no interest in the file' do
+      it 'returns all offences except the ones of the cop' do
+        cops = []
+        cops << double('cop A', offences: %w(foo), relevant_file?: true)
+        cops << double('cop B', offences: %w(bar), relevant_file?: false)
+        cops << double('cop C', offences: %w(baz), relevant_file?: true)
+        cops.each(&:as_null_object)
+
+        commissioner = described_class.new(cops)
+        source = []
+        processed_source = parse_source(source)
+
+        expect(commissioner.investigate(processed_source)).to eq %w(foo baz)
+      end
+    end
+
+    it 'traverses the AST and invoke cops specific callbacks' do
+      expect(cop).to receive(:on_def)
+
+      commissioner = described_class.new([cop])
+      source = ['def method', '1', 'end']
+      processed_source = parse_source(source)
+
+      commissioner.investigate(processed_source)
+    end
+
+    it 'passes the input params to all cops that implement their own #investigate method' do
+      source = []
+      processed_source = parse_source(source)
+      expect(cop).to receive(:investigate).with(processed_source)
+
+      commissioner = described_class.new([cop])
+
+      commissioner.investigate(processed_source)
+    end
+
+    it 'stores all errors raised by the cops' do
+      allow(cop).to receive(:on_def) { fail RuntimeError }
+
+      commissioner = described_class.new([cop])
+      source = ['def method', '1', 'end']
+      processed_source = parse_source(source)
+
+      commissioner.investigate(processed_source)
+
+      expect(commissioner.errors[cop].size).to eq(1)
+      expect(commissioner.errors[cop][0]).to be_instance_of(RuntimeError)
+    end
+
+    context 'when passed :raise_error option' do
+      it 're-raises the exception received while processing' do
+        allow(cop).to receive(:on_def) { fail RuntimeError }
+
+        commissioner = described_class.new([cop], raise_error: true)
+        source = ['def method', '1', 'end']
+        processed_source = parse_source(source)
+
+        expect do
+          commissioner.investigate(processed_source)
+        end.to raise_error(RuntimeError)
+      end
+    end
+  end
+end

data/spec/rubocop/cop/cop_spec.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Cop do
+  subject(:cop) { described_class.new }
+  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
+
+  it 'initially has 0 offences' do
+    expect(cop.offences).to be_empty
+  end
+
+  it 'keeps track of offences' do
+    cop.add_offence(nil, location, 'message')
+
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'will report registered offences' do
+    cop.add_offence(nil, location, 'message')
+
+    expect(cop.offences).not_to be_empty
+  end
+
+  it 'will set default severity' do
+    cop.add_offence(nil, location, 'message')
+
+    expect(cop.offences.first.severity).to eq(:convention)
+  end
+
+  it 'will set custom severity if present' do
+    cop.config[cop.name] = { 'Severity' => 'warning' }
+    cop.add_offence(nil, location, 'message')
+
+    expect(cop.offences.first.severity).to eq(:warning)
+  end
+
+  it 'will warn if custom severity is invalid' do
+    cop.config[cop.name] = { 'Severity' => 'superbad' }
+    expect(cop).to receive(:warn)
+    cop.add_offence(nil, location, 'message')
+  end
+
+  it 'registers offence with its name' do
+    cop = Rubocop::Cop::Style::For.new
+    cop.add_offence(nil, location, 'message')
+    expect(cop.offences.first.cop_name).to eq('For')
+  end
+
+  context 'with no submodule' do
+    subject(:cop) { described_class }
+    it('has right name') { expect(cop.cop_name).to eq('Cop') }
+    it('has right type') { expect(cop.cop_type).to eq(:cop) }
+  end
+
+  context 'with style cops' do
+    subject(:cop) { Rubocop::Cop::Style::For }
+    it('has right name') { expect(cop.cop_name).to eq('For') }
+    it('has right type') { expect(cop.cop_type).to eq(:style) }
+  end
+
+  context 'with lint cops' do
+    subject(:cop) { Rubocop::Cop::Lint::Loop }
+    it('has right name') { expect(cop.cop_name).to eq('Loop') }
+    it('has right type') { expect(cop.cop_type).to eq(:lint) }
+  end
+
+  context 'with rails cops' do
+    subject(:cop) { Rubocop::Cop::Rails::Validation }
+    it('has right name') { expect(cop.cop_name).to eq('Validation') }
+    it('has right type') { expect(cop.cop_type).to eq(:rails) }
+  end
+
+  describe 'CopStore' do
+    context '#types' do
+      subject { described_class.all.types }
+      it('has types') { expect(subject.length).not_to eq(0) }
+      it { should include :lint }
+      it do
+        pending 'Rails cops are usually removed after CLI start, ' \
+                'so CLI spec impacts this one'
+        should include :rails
+      end
+      it { should include :style }
+      it 'contains every value only once' do
+        expect(subject.length).to eq(subject.uniq.length)
+      end
+    end
+    context '#with_type' do
+      let(:types) { described_class.all.types }
+      it 'has at least one cop per type' do
+        types.each do |c|
+          expect(described_class.all.with_type(c).length).to be > 0
+        end
+      end
+
+      it 'has each cop in exactly one type' do
+        sum = 0
+        types.each do |c|
+          sum = sum + described_class.all.with_type(c).length
+        end
+        expect(sum).to be described_class.all.length
+      end
+
+      it 'returns 0 for an invalid type' do
+        expect(described_class.all.with_type('x').length).to be 0
+      end
+    end
+  end
+end

data/spec/rubocop/cop/corrector_spec.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Corrector do
+  describe '#rewrite' do
+    it 'allows removal of a range' do
+      source = 'true and false'
+      processed_source = parse_source(source)
+
+      correction = lambda do |corrector|
+        node = processed_source.ast
+        corrector.remove(node.loc.operator)
+      end
+
+      corrector = described_class.new(processed_source.buffer, [correction])
+      expect(corrector.rewrite).to eq 'true  false'
+    end
+
+    it 'allows insertion before a source range' do
+      source = 'true and false'
+      processed_source = parse_source(source)
+
+      correction = lambda do |corrector|
+        node = processed_source.ast
+        corrector.insert_before(node.loc.operator, ';nil ')
+      end
+
+      corrector = described_class.new(processed_source.buffer, [correction])
+      expect(corrector.rewrite).to eq 'true ;nil and false'
+    end
+
+    it 'allows insertion after a source range' do
+      source = 'true and false'
+      processed_source = parse_source(source)
+
+      correction = lambda do |corrector|
+        node = processed_source.ast
+        corrector.insert_after(node.loc.operator, ' nil;')
+      end
+
+      corrector = described_class.new(processed_source.buffer, [correction])
+      expect(corrector.rewrite).to eq 'true and nil; false'
+    end
+
+    it 'allows replacement of a range' do
+      source = 'true and false'
+      processed_source = parse_source(source)
+
+      correction = lambda do |corrector|
+        node = processed_source.ast
+        corrector.replace(node.loc.operator, 'or')
+      end
+
+      corrector = described_class.new(processed_source.buffer, [correction])
+      expect(corrector.rewrite).to eq 'true or false'
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Lint::AmbiguousOperator do
+  subject(:cop) { described_class.new }
+
+  before do
+    inspect_source(cop, source)
+  end
+
+  context 'with a splat operator in the first argument' do
+    context 'without parentheses' do
+      context 'without whitespaces on the right of the operator' do
+        let(:source) do
+          [
+            'array = [1, 2, 3]',
+            'puts *array'
+          ]
+        end
+
+        it 'registers an offence' do
+          expect(cop.offences.size).to eq(1)
+          expect(cop.offences.first.message).to eq(
+            'Ambiguous splat operator. ' \
+            "Parenthesize the method arguments if it's surely a splat " +
+            'operator, ' +
+            'or add a whitespace to the right of the * if it should be a ' +
+            'multiplication.'
+          )
+          expect(cop.highlights).to eq(['*'])
+        end
+      end
+
+      context 'with a whitespace on the right of the operator' do
+        let(:source) do
+          [
+            'array = [1, 2, 3]',
+            'puts * array'
+          ]
+        end
+
+        it 'accepts' do
+          expect(cop.offences).to be_empty
+        end
+      end
+    end
+
+    context 'with parentheses' do
+      let(:source) do
+        [
+          'array = [1, 2, 3]',
+          'puts(*array)'
+        ]
+      end
+
+      it 'accepts' do
+        expect(cop.offences).to be_empty
+      end
+    end
+  end
+
+  context 'with a block ampersand in the first argument' do
+    context 'without parentheses' do
+      context 'without whitespaces on the right of the operator' do
+        let(:source) do
+          [
+            'process = proc { do_something }',
+            '2.times &process'
+          ]
+        end
+
+        it 'registers an offence' do
+          expect(cop.offences.size).to eq(1)
+          expect(cop.offences.first.message).to eq(
+            'Ambiguous block operator. ' \
+            "Parenthesize the method arguments if it's surely a block " +
+            'operator, ' +
+            'or add a whitespace to the right of the & if it should be a ' +
+            'binary AND.'
+          )
+          expect(cop.highlights).to eq(['&'])
+        end
+      end
+
+      context 'with a whitespace on the right of the operator' do
+        let(:source) do
+          [
+            'process = proc { do_something }',
+            '2.times & process'
+          ]
+        end
+
+        it 'accepts' do
+          expect(cop.offences).to be_empty
+        end
+      end
+    end
+
+    context 'with parentheses' do
+      let(:source) do
+        [
+          'process = proc { do_something }',
+          '2.times(&process)'
+        ]
+      end
+
+      it 'accepts' do
+        expect(cop.offences).to be_empty
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Lint::AmbiguousRegexpLiteral do
+  subject(:cop) { described_class.new }
+
+  before do
+    inspect_source(cop, source)
+  end
+
+  context 'with a regexp literal in the first argument' do
+    context 'without parentheses' do
+      let(:source) { 'p /pattern/' }
+
+      it 'registers an offence' do
+        expect(cop.offences.size).to eq(1)
+        expect(cop.offences.first.message).to eq(
+          'Ambiguous regexp literal. Parenthesize the method arguments ' \
+          "if it's surely a regexp literal, or add a whitespace to the " +
+          'right of the / if it should be a division.'
+        )
+        expect(cop.highlights).to eq(['/'])
+      end
+    end
+
+    context 'with parentheses' do
+      let(:source) { 'p(/pattern/)' }
+
+      it 'accepts' do
+        expect(cop.offences).to be_empty
+      end
+    end
+  end
+end