ridecharge-rubocop 0.0.1

data/spec/rubocop/formatter/disabled_config_formatter_spec.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+require 'ostruct'
+
+module Rubocop
+  module Formatter
+    describe DisabledConfigFormatter do
+      subject(:formatter) { described_class.new(output) }
+      let(:output) do
+        o = StringIO.new
+        def o.path
+          'rubocop-todo.yml'
+        end
+        o
+      end
+      let(:offences) do
+        [Rubocop::Cop::Offence.new(:convention, location, 'message', 'Cop1'),
+         Rubocop::Cop::Offence.new(:convention, location, 'message', 'Cop2')]
+      end
+      let(:location) { OpenStruct.new(line: 1, column: 5) }
+      before { $stdout = StringIO.new }
+
+      describe '#finished' do
+        it 'displays YAML configuration disabling all cops with offences' do
+          formatter.file_finished('test.rb', offences)
+          formatter.finished(['test.rb'])
+          expect(output.string).to eq(described_class::HEADING +
+                                      ['',
+                                       '',
+                                       '# Offence count: 1',
+                                       'Cop1:',
+                                       '  Enabled: false',
+                                       '',
+                                       '# Offence count: 1',
+                                       'Cop2:',
+                                       '  Enabled: false',
+                                       ''].join("\n"))
+          expect($stdout.string)
+            .to eq(['Created rubocop-todo.yml.',
+                    'Run rubocop with --config rubocop-todo.yml, or',
+                    'add inherit_from: rubocop-todo.yml in a .rubocop.yml ' \
+                    'file.',
+                    ''].join("\n"))
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/formatter/emacs_style_formatter_spec.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+
+module Rubocop
+  module Formatter
+    describe EmacsStyleFormatter do
+      subject(:formatter) { described_class.new(output) }
+      let(:output) { StringIO.new }
+
+      describe '#file_finished' do
+        it 'displays parsable text' do
+          cop = Cop::Cop.new
+          source_buffer = Parser::Source::Buffer.new('test', 1)
+          source_buffer.source = %w(a b cdefghi).join("\n")
+
+          cop.add_offence(nil,
+                          Parser::Source::Range.new(source_buffer, 0, 1),
+                          'message 1')
+          cop.add_offence(nil,
+                          Parser::Source::Range.new(source_buffer, 9, 10),
+                          'message 2')
+
+          formatter.file_finished('test', cop.offences)
+          expect(output.string).to eq ['test:1:1: C: message 1',
+                                       "test:3:6: C: message 2\n"].join("\n")
+        end
+
+        context 'when the offence is automatically corrected' do
+          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
+
+          let(:corrected) { true }
+
+          it 'prints [Corrected] along with message' do
+            formatter.file_finished(file, [offence])
+            expect(output.string)
+              .to include(': [Corrected] This is a message.')
+          end
+        end
+      end
+
+      describe '#finished' do
+        it 'does not report summary' do
+          formatter.finished(['/path/to/file'])
+          expect(output.string).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/formatter/file_list_formatter_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+
+module Rubocop
+  module Formatter
+    describe FileListFormatter do
+      subject(:formatter) { described_class.new(output) }
+      let(:output) { StringIO.new }
+
+      describe '#file_finished' do
+        it 'displays parsable text' do
+          cop = Cop::Cop.new
+          source_buffer = Parser::Source::Buffer.new('test', 1)
+          source_buffer.source = %w(a b cdefghi).join("\n")
+
+          cop.add_offence(nil,
+                          Parser::Source::Range.new(source_buffer, 0, 1),
+                          'message 1')
+          cop.add_offence(nil,
+                          Parser::Source::Range.new(source_buffer, 9, 10),
+                          'message 2')
+
+          formatter.file_finished('test', cop.offences)
+          formatter.file_finished('test_2', cop.offences)
+          expect(output.string).to eq ['test',
+                                       "test_2\n"].join("\n")
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/formatter/formatter_set_spec.rb

@@ -0,0 +1,132 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'tempfile'
+
+module Rubocop
+  module Formatter
+    describe FormatterSet do
+      subject(:formatter_set) { described_class.new }
+
+      it 'responds to all formatter API methods' do
+        [:started, :file_started, :file_finished, :finished].each do |method|
+          expect(formatter_set).to respond_to(method)
+        end
+      end
+
+      describe 'formatter API method' do
+        before do
+          formatter_set.add_formatter('simple')
+          formatter_set.add_formatter('emacs')
+        end
+
+        let(:files) { ['/path/to/file1', '/path/to/file2'] }
+
+        it 'invokes same method of all containing formatters' do
+          formatter_set.each do |formatter|
+            expect(formatter).to receive(:started).with(files)
+          end
+          formatter_set.started(files)
+        end
+      end
+
+      describe 'add_formatter' do
+        it 'adds a formatter to itself' do
+          formatter_set.add_formatter('simple')
+          expect(formatter_set.size).to eq(1)
+        end
+
+        it 'adds a formatter with specified formatter type' do
+          formatter_set.add_formatter('simple')
+          expect(formatter_set.first.class).to eq(SimpleTextFormatter)
+        end
+
+        it 'can add multiple formatters by being invoked multiple times' do
+          formatter_set.add_formatter('simple')
+          formatter_set.add_formatter('emacs')
+          expect(formatter_set[0].class).to eq(SimpleTextFormatter)
+          expect(formatter_set[1].class).to eq(EmacsStyleFormatter)
+        end
+
+        context 'when output path is omitted' do
+          it 'adds a formatter outputs to $stdout' do
+            formatter_set.add_formatter('simple')
+            expect(formatter_set.first.output).to eq($stdout)
+          end
+        end
+
+        context 'when output path is specified' do
+          it 'adds a formatter outputs to the specified file' do
+            output_path = Tempfile.new('').path
+            formatter_set.add_formatter('simple', output_path)
+            expect(formatter_set.first.output.class).to eq(File)
+            expect(formatter_set.first.output.path).to eq(output_path)
+          end
+        end
+      end
+
+      describe '#close_output_files' do
+        before do
+          2.times do
+            output_path = Tempfile.new('').path
+            formatter_set.add_formatter('simple', output_path)
+          end
+          formatter_set.add_formatter('simple')
+        end
+
+        it 'closes all output files' do
+          formatter_set.close_output_files
+          formatter_set[0..1].each do |formatter|
+            expect(formatter.output).to be_closed
+          end
+        end
+
+        it 'does not close non file output' do
+          expect(formatter_set[2].output).not_to be_closed
+        end
+      end
+
+      describe '#builtin_formatter_class' do
+        def builtin_formatter_class(string)
+          described_class.new.send(:builtin_formatter_class, string)
+        end
+
+        it 'returns class which matches passed alias name exactly' do
+          expect(builtin_formatter_class('simple'))
+            .to eq(SimpleTextFormatter)
+        end
+
+        it 'returns class whose first letter of alias name ' \
+           'matches passed letter' do
+          expect(builtin_formatter_class('s'))
+            .to eq(SimpleTextFormatter)
+        end
+      end
+
+      describe '#custom_formatter_class' do
+        def custom_formatter_class(string)
+          described_class.new.send(:custom_formatter_class, string)
+        end
+
+        it 'returns constant represented by the passed string' do
+          expect(custom_formatter_class('Rubocop')).to eq(Rubocop)
+        end
+
+        it 'can handle namespaced constant name' do
+          expect(custom_formatter_class('Rubocop::CLI')).to eq(Rubocop::CLI)
+        end
+
+        it 'can handle top level namespaced constant name' do
+          expect(custom_formatter_class('::Rubocop::CLI')).to eq(Rubocop::CLI)
+        end
+
+        context 'when non-existent constant name is passed' do
+          it 'raises error' do
+            expect { custom_formatter_class('Rubocop::NonExistentClass') }
+              .to raise_error(NameError)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/formatter/json_formatter_spec.rb

@@ -0,0 +1,148 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+
+module Rubocop
+  describe Formatter::JSONFormatter do
+    subject(:formatter) { described_class.new(output) }
+    let(:output) { StringIO.new }
+    let(:files) { %w(/path/to/file1 /path/to/file2) }
+    let(:location) do
+      source_buffer = Parser::Source::Buffer.new('test', 1)
+      source_buffer.source = %w(a b cdefghi).join("\n")
+      Parser::Source::Range.new(source_buffer, 9, 10)
+    end
+    let(:offence) do
+      Cop::Offence.new(:convention, location,
+                       'This is message', 'CopName', true)
+    end
+
+    describe '#started' do
+      let(:summary) { formatter.output_hash[:summary] }
+
+      it 'sets target file count in summary' do
+        expect(summary[:target_file_count]).to be_nil
+        formatter.started(%w(/path/to/file1 /path/to/file2))
+        expect(summary[:target_file_count]).to eq(2)
+      end
+    end
+
+    describe '#file_finished' do
+      before do
+        count = 0
+        allow(formatter).to receive(:hash_for_file) do
+          count += 1
+        end
+      end
+
+      let(:summary) { formatter.output_hash[:summary] }
+
+      it 'adds detected offence count in summary' do
+        expect(summary[:offence_count]).to eq(0)
+
+        formatter.file_started(files[0], {})
+        expect(summary[:offence_count]).to eq(0)
+        formatter.file_finished(files[0], [
+          double('offence1'), double('offence2')
+        ])
+        expect(summary[:offence_count]).to eq(2)
+      end
+
+      it 'adds value of #hash_for_file to #output_hash[:files]' do
+        expect(formatter.output_hash[:files]).to be_empty
+
+        formatter.file_started(files[0], {})
+        expect(formatter.output_hash[:files]).to be_empty
+        formatter.file_finished(files[0], [])
+        expect(formatter.output_hash[:files]).to eq([1])
+
+        formatter.file_started(files[1], {})
+        expect(formatter.output_hash[:files]).to eq([1])
+        formatter.file_finished(files[1], [])
+        expect(formatter.output_hash[:files]).to eq([1, 2])
+      end
+    end
+
+    describe '#finished' do
+      let(:summary) { formatter.output_hash[:summary] }
+
+      it 'sets inspected file count in summary' do
+        expect(summary[:inspected_file_count]).to be_nil
+        formatter.finished(%w(/path/to/file1 /path/to/file2))
+        expect(summary[:inspected_file_count]).to eq(2)
+      end
+
+      it 'outputs #output_hash as JSON' do
+        formatter.finished(files)
+        json = output.string
+        restored_hash = JSON.parse(json, symbolize_names: true)
+        expect(restored_hash).to eq(formatter.output_hash)
+      end
+    end
+
+    describe '#hash_for_file' do
+      subject(:hash) { formatter.hash_for_file(file, offences) }
+      let(:file) { File.expand_path('spec/spec_helper.rb') }
+      let(:offences) { [double('offence1'), double('offence2')] }
+
+      it 'sets relative file path for :path key' do
+        expect(hash[:path]).to eq('spec/spec_helper.rb')
+      end
+
+      before do
+        count = 0
+        allow(formatter).to receive(:hash_for_offence) do
+          count += 1
+        end
+      end
+
+      it 'sets an array of #hash_for_offence values for :offences key' do
+        expect(hash[:offences]).to eq([1, 2])
+      end
+    end
+
+    describe '#hash_for_offence' do
+      subject(:hash) { formatter.hash_for_offence(offence) }
+
+      it 'sets Offence#severity value for :severity key' do
+        expect(hash[:severity]).to eq(:convention)
+      end
+
+      it 'sets Offence#message value for :message key' do
+        expect(hash[:message]).to eq('This is message')
+      end
+
+      it 'sets Offence#cop_name value for :cop_name key' do
+        expect(hash[:cop_name]).to eq('CopName')
+      end
+
+      it 'sets Offence#corrected? value for :corrected key' do
+        expect(hash[:corrected]).to be_true
+      end
+
+      before do
+        allow(formatter)
+          .to receive(:hash_for_location).and_return(location_hash)
+      end
+
+      let(:location_hash) { { line: 1, column: 2 } }
+
+      it 'sets value of #hash_for_location for :location key' do
+        expect(hash[:location]).to eq(location_hash)
+      end
+    end
+
+    describe '#hash_for_location' do
+      subject(:hash) { formatter.hash_for_location(offence) }
+
+      it 'sets line value for :line key' do
+        expect(hash[:line]).to eq(3)
+      end
+
+      it 'sets column value for :column key' do
+        expect(hash[:column]).to eq(6)
+      end
+    end
+  end
+end

data/spec/rubocop/formatter/offence_count_formatter_spec.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+require 'tempfile'
+
+module Rubocop
+  module Formatter
+    describe OffenceCountFormatter do
+      subject(:formatter) { described_class.new(output) }
+      let(:output) { StringIO.new }
+
+      let(:files) do
+        %w(lib/rubocop.rb spec/spec_helper.rb bin/rubocop).map do |path|
+          File.expand_path(path)
+        end
+      end
+
+      describe '#file_finished' do
+        before { formatter.started(files) }
+
+        let(:finish) { formatter.file_finished(files.first, offences) }
+
+        context 'when no offences are detected' do
+          let(:offences) { [] }
+          it 'shouldn\'t add to offence_counts' do
+            expect { finish }.to_not change { formatter.offence_counts }
+          end
+        end
+
+        context 'when any offences are detected' do
+          let(:offences) { [double('offence', cop_name: 'OffendedCop')] }
+          it 'should increment the count for the cop in offence_counts' do
+            expect { finish }.to change { formatter.offence_counts }
+          end
+        end
+      end
+
+      describe '#report_summary' do
+        context 'when a offence detected' do
+          let(:cop_counts) { { 'OffendedCop' => 1 } }
+          it 'shows the cop and the offence count' do
+            formatter.report_summary(1, cop_counts)
+            expect(output.string).to include(
+              "\n1  OffendedCop")
+          end
+        end
+      end
+
+    end
+  end
+end