ridecharge-rubocop 0.0.1

data/spec/rubocop/cop/variable_inspector_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::VariableInspector do
+  include AST::Sexp
+
+  class ExampleInspector
+    include Rubocop::Cop::VariableInspector
+  end
+
+  subject(:inspector) { ExampleInspector.new }
+
+  describe '#process_node' do
+    before do
+      inspector.variable_table.push_scope(s(:def))
+    end
+
+    context 'when processing lvar node' do
+      let(:node) { s(:lvar, :foo) }
+
+      context 'when the variable is not yet declared' do
+        it 'does not raise error' do
+          expect { inspector.process_node(node) }.not_to raise_error
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/file_inspector_spec.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+class Rubocop::FileInspector
+  attr_writer :errors # Needed only for testing.
+end
+
+describe Rubocop::FileInspector do
+  subject(:inspector) { described_class.new(options) }
+  let(:options) { {} }
+  let(:offences) { [] }
+  let(:errors) { [] }
+
+  before(:each) do
+    $stdout = StringIO.new
+    $stderr = StringIO.new
+
+    allow(inspector).to receive(:inspect_file) do
+      inspector.errors = errors
+      offences
+    end
+  end
+
+  after(:each) do
+    $stdout = STDOUT
+    $stderr = STDERR
+  end
+
+  describe '#display_error_summary' do
+    let(:errors) do
+      ['An error occurred while Encoding cop was inspecting file.rb.']
+    end
+
+    it 'displays an error message to stderr when errors are present' do
+      inspector.process_files(['file.rb'], nil) {}
+      inspector.display_error_summary
+      expect($stderr.string.lines.to_a[-6..-5])
+        .to eq(["1 error occurred:\n", "#{errors.first}\n"])
+    end
+  end
+
+  describe '#process_files' do
+    context 'if there are no offences in inspected files' do
+      it 'returns false' do
+        result = inspector.process_files(['file.rb'], nil) {}
+        expect(result).to eq(false)
+      end
+    end
+
+    context 'if there is an offence in an inspected file' do
+      let(:offences) do
+        [Rubocop::Cop::Offence.new(:convention,
+                                   Struct.new(:line, :column,
+                                              :source_line).new(1, 0, ''),
+                                   'Use alias_method instead of alias.',
+                                   'Alias')]
+      end
+
+      it 'returns true' do
+        expect(inspector.process_files(['file.rb'], nil) {}).to eq(true)
+      end
+
+      it 'sends the offence to a formatter' do
+        inspector.process_files(['file.rb'], nil) {}
+        expect($stdout.string.split("\n"))
+          .to eq(['Inspecting 1 file',
+                  'C',
+                  '',
+                  'Offences:',
+                  '',
+                  "file.rb:1:1: C: #{offences.first.message}",
+                  '',
+                  '1 file inspected, 1 offence detected'])
+      end
+    end
+  end
+end

data/spec/rubocop/formatter/base_formatter_spec.rb

@@ -0,0 +1,191 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Formatter
+    describe BaseFormatter do
+      include FileHelper
+
+      describe 'how the API methods are invoked', :isolated_environment do
+        subject(:formatter) { double('formatter').as_null_object }
+        let(:cli) { CLI.new }
+        let(:output) { $stdout.string }
+
+        before do
+          create_file('1_offence.rb', [
+            '# encoding: utf-8',
+            '#' * 90
+          ])
+
+          create_file('4_offences.rb', [
+            '# encoding: utf-8',
+            'puts x ',
+            'test;',
+            'top;',
+            '#' * 90
+          ])
+
+          create_file('no_offence.rb', [
+            '# encoding: utf-8'
+          ])
+
+          allow(SimpleTextFormatter).to receive(:new).and_return(formatter)
+          $stdout = StringIO.new
+        end
+
+        after do
+          $stdout = STDOUT
+        end
+
+        def run
+          cli.run([])
+        end
+
+        describe 'invocation order' do
+          subject(:formatter) do
+            formatter = double('formatter')
+            def formatter.method_missing(method_name, *args)
+              return if method_name == :output
+              puts method_name
+            end
+            formatter
+          end
+
+          it 'is called in the proper sequence' do
+            run
+            expect(output).to eq([
+              'started',
+              'file_started',
+              'file_finished',
+              'file_started',
+              'file_finished',
+              'file_started',
+              'file_finished',
+              'finished',
+              ''
+            ].join("\n"))
+          end
+        end
+
+        shared_examples 'receives all file paths' do |method_name|
+          it 'receives all file paths' do
+            expected_paths = [
+              '1_offence.rb',
+              '4_offences.rb',
+              'no_offence.rb'
+            ].map { |path| File.expand_path(path) }.sort
+
+            expect(formatter).to receive(method_name) do |all_files|
+              expect(all_files.sort).to eq(expected_paths)
+            end
+
+            run
+          end
+
+          describe 'the passed files paths' do
+            it 'is frozen' do
+              expect(formatter).to receive(method_name) do |all_files|
+                all_files.each do |path|
+                  expect(path).to be_frozen
+                end
+              end
+              run
+            end
+          end
+        end
+
+        describe '#started' do
+          include_examples 'receives all file paths', :started
+        end
+
+        describe '#finished' do
+          context 'when RuboCop finished inspecting all files normally' do
+            include_examples 'receives all file paths', :started
+          end
+
+          context 'when RuboCop is interrupted by user' do
+            it 'received processed file paths' do
+              class << formatter
+                attr_reader :processed_file_count
+
+                def file_finished(file, offences)
+                  @processed_file_count ||= 0
+                  @processed_file_count += 1
+                end
+              end
+
+              allow(cli).to receive(:wants_to_quit?) do
+                formatter.processed_file_count == 2
+              end
+
+              expect(formatter).to receive(:finished) do |processed_files|
+                expect(processed_files.size).to eq(2)
+              end
+
+              run
+            end
+          end
+        end
+
+        shared_examples 'receives a file path' do |method_name|
+          it 'receives a file path' do
+            expect(formatter).to receive(method_name)
+              .with(File.expand_path('1_offence.rb'), anything)
+
+            expect(formatter).to receive(method_name)
+              .with(File.expand_path('4_offences.rb'), anything)
+
+            expect(formatter).to receive(method_name)
+              .with(File.expand_path('no_offence.rb'), anything)
+
+            run
+          end
+
+          describe 'the passed path' do
+            it 'is frozen' do
+              expect(formatter)
+                .to receive(method_name).exactly(3).times do |path|
+                expect(path).to be_frozen
+              end
+              run
+            end
+          end
+        end
+
+        describe '#file_started' do
+          include_examples 'receives a file path', :file_started
+
+          it 'receives file specific information hash' do
+            expect(formatter).to receive(:file_started)
+              .with(anything, an_instance_of(Hash)).exactly(3).times
+            run
+          end
+        end
+
+        describe '#file_finished' do
+          include_examples 'receives a file path', :file_finished
+
+          it 'receives an array of detected offences for the file' do
+            expect(formatter).to receive(:file_finished)
+            .exactly(3).times do |file, offences|
+              case File.basename(file)
+              when '1_offence.rb'
+                expect(offences.size).to eq(1)
+              when '4_offences.rb'
+                expect(offences.size).to eq(4)
+              when 'no_offence.rb'
+                expect(offences).to be_empty
+              else
+                fail
+              end
+              expect(offences.all? { |o| o.is_a?(Rubocop::Cop::Offence) })
+                .to be_true
+            end
+            run
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/formatter/clang_style_formatter_spec.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+
+module Rubocop
+  module Formatter
+    describe ClangStyleFormatter do
+      subject(:formatter) { described_class.new(output) }
+      let(:output) { StringIO.new }
+
+      describe '#report_file' do
+        it 'displays text containing the offending source line' do
+          cop = Cop::Cop.new
+          source_buffer = Parser::Source::Buffer.new('test', 1)
+          source_buffer.source = ('aa'..'az').to_a.join($RS)
+          cop.add_offence(nil,
+                          Parser::Source::Range.new(source_buffer, 0, 2),
+                          'message 1')
+          cop.add_offence(nil,
+                          Parser::Source::Range.new(source_buffer, 30, 32),
+                          'message 2')
+
+          formatter.report_file('test', cop.offences)
+          expect(output.string).to eq ['test:1:1: C: message 1',
+                                       'aa',
+                                       '^^',
+                                       'test:11:1: C: message 2',
+                                       'ak',
+                                       '^^',
+                                       ''].join("\n")
+        end
+
+        context 'when the source line is blank' do
+          it 'does not display offending source line' do
+            cop = Cop::Cop.new
+            source_buffer = Parser::Source::Buffer.new('test', 1)
+            source_buffer.source = (['     ', 'yaba']).to_a.join($RS)
+            cop.add_offence(nil,
+                            Parser::Source::Range.new(source_buffer, 0, 2),
+                            'message 1')
+            cop.add_offence(nil,
+                            Parser::Source::Range.new(source_buffer, 6, 10),
+                            'message 2')
+
+            formatter.report_file('test', cop.offences)
+            expect(output.string).to eq ['test:1:1: C: message 1',
+                                         'test:2:1: C: message 2',
+                                         'yaba',
+                                         '^^^^',
+                                         ''].join("\n")
+          end
+        end
+
+        context 'when the offending source spans multiple lines' do
+          it 'displays the first line' do
+            source = ['do_something([this,',
+                      '              is,',
+                      '              target])'].join($RS)
+
+            source_buffer = Parser::Source::Buffer.new('test', 1)
+            source_buffer.source = source
+
+            location = Parser::Source::Range.new(source_buffer,
+                                                 source.index('['),
+                                                 source.index(']') + 1)
+
+            cop = Cop::Cop.new
+            cop.add_offence(nil, location, 'message 1')
+
+            formatter.report_file('test', cop.offences)
+            expect(output.string).to eq ['test:1:14: C: message 1',
+                                         'do_something([this,',
+                                         '             ^^^^^^',
+                                         ''].join("\n")
+          end
+        end
+
+        let(:file) { '/path/to/file' }
+
+        let(:offence) do
+          Cop::Offence.new(:convention, location,
+                           'This is a message.', 'CopName', corrected)
+        end
+
+        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
+
+        context 'when the offence is not corrected' do
+          let(:corrected) { false }
+
+          it 'prints message as-is' do
+            formatter.report_file(file, [offence])
+            expect(output.string)
+              .to include(': This is a message.')
+          end
+        end
+
+        context 'when the offence is automatically corrected' do
+          let(:corrected) { true }
+
+          it 'prints [Corrected] along with message' do
+            formatter.report_file(file, [offence])
+            expect(output.string)
+              .to include(': [Corrected] This is a message.')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/formatter/colorizable_spec.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'rubocop/formatter/colorizable'
+require 'stringio'
+
+module Rubocop
+  module Formatter
+    describe Colorizable do
+      let(:formatter_class) do
+        Class.new(BaseFormatter) do
+          include Colorizable
+        end
+      end
+
+      let(:formatter) do
+        formatter_class.new(output)
+      end
+
+      let(:output) { double('output') }
+
+      around do |example|
+        original_state = Rainbow.enabled
+
+        begin
+          example.run
+        ensure
+          Rainbow.enabled = original_state
+        end
+      end
+
+      describe '#colorize' do
+        subject { formatter.colorize('foo', :red) }
+
+        shared_examples 'does nothing' do
+          it 'does nothing' do
+            should == 'foo'
+          end
+        end
+
+        context 'when the global Rainbow.enabled is true' do
+          before do
+            Rainbow.enabled = true
+          end
+
+          context "and the formatter's output is a tty" do
+            before do
+              allow(output).to receive(:tty?).and_return(true)
+            end
+
+            it 'colorize the passed string' do
+              should == "\e[31mfoo\e[0m"
+            end
+          end
+
+          context "and the formatter's output is not a tty" do
+            before do
+              allow(output).to receive(:tty?).and_return(false)
+            end
+
+            include_examples 'does nothing'
+          end
+        end
+
+        context 'when the global Rainbow.enabled is false' do
+          before do
+            Rainbow.enabled = false
+          end
+
+          context "and the formatter's output is a tty" do
+            before do
+              allow(output).to receive(:tty?).and_return(true)
+            end
+
+            include_examples 'does nothing'
+          end
+
+          context "and the formatter's output is not a tty" do
+            before do
+              allow(output).to receive(:tty?).and_return(false)
+            end
+
+            include_examples 'does nothing'
+          end
+        end
+      end
+
+      [
+        :black,
+        :red,
+        :green,
+        :yellow,
+        :blue,
+        :magenta,
+        :cyan,
+        :white
+      ].each do |color|
+        describe "##{color}" do
+          it "invokes #colorize(string, #{color}" do
+            expect(formatter).to receive(:colorize).with('foo', color)
+            formatter.send(color, 'foo')
+          end
+        end
+      end
+    end
+  end
+end