ridecharge-rubocop 0.0.1

data/spec/rubocop/formatter/progress_formatter_spec.rb

@@ -0,0 +1,182 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+
+module Rubocop
+  describe Formatter::ProgressFormatter 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 do
+        formatter.started(files)
+        formatter.file_started(files.first, {})
+      end
+
+      shared_examples 'calls #report_file_as_mark' do
+        it 'calls #report_as_with_mark' do
+          expect(formatter).to receive(:report_file_as_mark)
+          formatter.file_finished(files.first, offences)
+        end
+      end
+
+      context 'when no offences are detected' do
+        let(:offences) { [] }
+        include_examples 'calls #report_file_as_mark'
+      end
+
+      context 'when any offences are detected' do
+        let(:offences) { [double('offence').as_null_object] }
+        include_examples 'calls #report_file_as_mark'
+      end
+    end
+
+    describe '#report_file_as_mark' do
+      before do
+        formatter.report_file_as_mark(files.first, offences)
+      end
+
+      def offence_with_severity(severity)
+        source_buffer = Parser::Source::Buffer.new('test', 1)
+        source_buffer.source = "a\n"
+        Cop::Offence.new(severity,
+                         Parser::Source::Range.new(source_buffer, 0, 1),
+                         'message',
+                         'CopName')
+      end
+
+      context 'when no offences are detected' do
+        let(:offences) { [] }
+
+        it 'prints "."' do
+          expect(output.string).to eq('.')
+        end
+      end
+
+      context 'when a refactor severity offence is detected' do
+        let(:offences) { [offence_with_severity(:refactor)] }
+
+        it 'prints "R"' do
+          expect(output.string).to eq('R')
+        end
+      end
+
+      context 'when a refactor convention offence is detected' do
+        let(:offences) { [offence_with_severity(:convention)] }
+
+        it 'prints "C"' do
+          expect(output.string).to eq('C')
+        end
+      end
+
+      context 'when different severity offences are detected' do
+        let(:offences) do
+          [
+            offence_with_severity(:refactor),
+            offence_with_severity(:error)
+          ]
+        end
+
+        it 'prints highest level mark' do
+          expect(output.string).to eq('E')
+        end
+      end
+    end
+
+    describe '#finished' do
+      before do
+        formatter.started(files)
+      end
+
+      context 'when any offences are detected' do
+        before do
+          source_buffer = Parser::Source::Buffer.new('test', 1)
+          source = 9.times.map do |index|
+            "This is line #{index + 1}."
+          end
+          source_buffer.source = source.join("\n")
+          line_length = source[0].length + "\n".length
+
+          formatter.file_started(files[0], {})
+          formatter.file_finished(files[0], [
+            Cop::Offence.new(
+              :convention,
+              Parser::Source::Range.new(source_buffer,
+                                        line_length + 2,
+                                        line_length + 3),
+              'foo',
+              'Cop'
+            )
+          ])
+
+          formatter.file_started(files[1], {})
+          formatter.file_finished(files[1], [
+          ])
+
+          formatter.file_started(files[2], {})
+          formatter.file_finished(files[2], [
+            Cop::Offence.new(
+              :error,
+              Parser::Source::Range.new(source_buffer,
+                                        4 * line_length + 1,
+                                        4 * line_length + 2),
+              'bar',
+              'Cop'
+            ),
+            Cop::Offence.new(
+              :convention,
+              Parser::Source::Range.new(source_buffer,
+                                        5 * line_length,
+                                        5 * line_length + 1),
+              'foo',
+              'Cop'
+            )
+          ])
+        end
+
+        it 'reports all detected offences for all failed files' do
+          formatter.finished(files)
+          expect(output.string).to include([
+            'Offences:',
+            '',
+            'lib/rubocop.rb:2:3: C: foo',
+            'This is line 2.',
+            '  ^',
+            'bin/rubocop:5:2: E: bar',
+            'This is line 5.',
+            ' ^',
+            'bin/rubocop:6:1: C: foo',
+            'This is line 6.',
+            '^'
+          ].join("\n"))
+        end
+      end
+
+      context 'when no offences are detected' do
+        before do
+          files.each do |file|
+            formatter.file_started(file, {})
+            formatter.file_finished(file, [])
+          end
+        end
+
+        it 'does not report offences' do
+          formatter.finished(files)
+          expect(output.string).not_to include('Offences:')
+        end
+      end
+
+      it 'calls #report_summary' do
+        expect(formatter).to receive(:report_summary)
+        formatter.finished(files)
+      end
+    end
+  end
+end

data/spec/rubocop/formatter/simple_text_formatter_spec.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+require 'tempfile'
+
+module Rubocop
+  module Formatter
+    describe SimpleTextFormatter do
+      subject(:formatter) { described_class.new(output) }
+      let(:output) { StringIO.new }
+
+      describe '#report_file' do
+        before do
+          formatter.report_file(file, [offence])
+        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
+
+        let(:corrected) { false }
+
+        context 'the file is under the current working directory' do
+          let(:file) { File.expand_path('spec/spec_helper.rb') }
+
+          it 'prints as relative path' do
+            expect(output.string).to include('== spec/spec_helper.rb ==')
+          end
+        end
+
+        context 'the file is outside of the current working directory' do
+          let(:file) do
+            tempfile = Tempfile.new('')
+            tempfile.close
+            File.expand_path(tempfile.path)
+          end
+
+          it 'prints as absolute path' do
+            expect(output.string).to include("== #{file} ==")
+          end
+        end
+
+        context 'when the offence is not corrected' do
+          let(:corrected) { false }
+
+          it 'prints message as-is' do
+            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
+            expect(output.string)
+              .to include(': [Corrected] This is a message.')
+          end
+        end
+      end
+
+      describe '#report_summary' do
+        context 'when no files inspected' do
+          it 'handles pluralization correctly' do
+            formatter.report_summary(0, 0, 0)
+            expect(output.string).to eq(
+              "\n0 files inspected, no offences detected\n")
+          end
+        end
+
+        context 'when a file inspected and no offences detected' do
+          it 'handles pluralization correctly' do
+            formatter.report_summary(1, 0, 0)
+            expect(output.string).to eq(
+              "\n1 file inspected, no offences detected\n")
+          end
+        end
+
+        context 'when a offence detected' do
+          it 'handles pluralization correctly' do
+            formatter.report_summary(1, 1, 0)
+            expect(output.string).to eq(
+              "\n1 file inspected, 1 offence detected\n")
+          end
+        end
+
+        context 'when 2 offences detected' do
+          it 'handles pluralization correctly' do
+            formatter.report_summary(2, 2, 0)
+            expect(output.string).to eq(
+              "\n2 files inspected, 2 offences detected\n")
+          end
+        end
+
+        context 'when an offence is corrected' do
+          it 'prints about correction' do
+            formatter.report_summary(1, 1, 1)
+            expect(output.string).to eq(
+              "\n1 file inspected, 1 offence detected, 1 offence corrected\n")
+          end
+        end
+
+        context 'when 2 offences are corrected' do
+          it 'handles pluralization correctly' do
+            formatter.report_summary(1, 1, 2)
+            expect(output.string).to eq(
+              "\n1 file inspected, 1 offence detected, 2 offences corrected\n")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/options_spec.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Options, :isolated_environment do
+  include FileHelper
+
+  subject(:options) { described_class.new }
+
+  before(:each) do
+    $stdout = StringIO.new
+    $stderr = StringIO.new
+  end
+
+  after(:each) do
+    $stdout = STDOUT
+    $stderr = STDERR
+  end
+
+  def abs(path)
+    File.expand_path(path)
+  end
+
+  describe 'option' do
+    describe '-h/--help' do
+      it 'exits cleanly' do
+        expect { options.parse ['-h'] }.to exit_with_code(0)
+        expect { options.parse ['--help'] }.to exit_with_code(0)
+      end
+
+      it 'shows help text' do
+        begin
+          options.parse(['--help'])
+        rescue SystemExit # rubocop:disable HandleExceptions
+        end
+
+        expected_help = <<-END
+Usage: rubocop [options] [file1, file2, ...]
+        --only COP                   Run just one cop.
+    -c, --config FILE                Specify configuration file.
+        --auto-gen-config            Generate a configuration file acting as a
+                                     TODO list.
+    -f, --format FORMATTER           Choose an output formatter. This option
+                                     can be specified multiple times to enable
+                                     multiple formatters at the same time.
+                                       [p]rogress (default)
+                                       [s]imple
+                                       [c]lang
+                                       [e]macs
+                                       [j]son
+                                       [f]iles
+                                       [o]ffences
+                                       custom formatter class name
+    -o, --out FILE                   Write output to a file instead of STDOUT.
+                                     This option applies to the previously
+                                     specified --format, or the default format
+                                     if no format is specified.
+    -r, --require FILE               Require Ruby file.
+        --show-cops [cop1,cop2,...]  Shows the given cops, or all cops by
+                                     default, and their configurations for the
+                                     current directory.
+    -d, --debug                      Display debug info.
+    -D, --display-cop-names          Display cop names in offence messages.
+    -R, --rails                      Run extra Rails cops.
+    -l, --lint                       Run only lint cops.
+    -a, --auto-correct               Auto-correct offences.
+    -n, --no-color                   Disable color output.
+    -v, --version                    Display version.
+    -V, --verbose-version            Display verbose version.
+      END
+
+        expect($stdout.string).to eq(expected_help)
+      end
+
+      it 'lists all builtin formatters' do
+        begin
+          options.parse(['--help'])
+        rescue SystemExit # rubocop:disable HandleExceptions
+        end
+
+        option_sections = $stdout.string.lines.slice_before(/^\s*-/)
+
+        format_section = option_sections.find do |lines|
+          lines.first =~ /^\s*-f/
+        end
+
+        formatter_keys = format_section.reduce([]) do |keys, line|
+          match = line.match(/^[ ]{39}(\[[a-z\]]+)/)
+          next keys unless match
+          keys << match.captures.first.gsub(/\[|\]/, '')
+        end.sort
+
+        expected_formatter_keys =
+          Rubocop::Formatter::FormatterSet::BUILTIN_FORMATTERS_FOR_KEYS
+          .keys.sort
+
+        expect(formatter_keys).to eq(expected_formatter_keys)
+      end
+    end
+
+    describe '--only' do
+      it 'exits with error if an incorrect cop name is passed' do
+        expect { options.parse(%w(--only 123)) }
+          .to raise_error(ArgumentError, /Unrecognized cop name: 123./)
+      end
+    end
+
+    describe '--require' do
+      let(:required_file_path) { './path/to/required_file.rb' }
+
+      before do
+        create_file('example.rb', '# encoding: utf-8')
+
+        create_file(required_file_path, [
+                                         '# encoding: utf-8',
+                                         "puts 'Hello from required file!'"
+                                        ])
+      end
+
+      it 'requires the passed path' do
+        options.parse(['--require', required_file_path, 'example.rb'])
+        expect($stdout.string).to start_with('Hello from required file!')
+      end
+    end
+  end
+
+  unless Rubocop::Version::STRING.start_with?('0')
+    describe '-e/--emacs option' do
+      it 'is dropped in RuboCop 1.0.0' do
+        # This spec can be removed once the option is dropped.
+        expect { options.parse(['--emacs']) }
+          .to raise_error(OptionParser::InvalidOption)
+      end
+    end
+
+    describe '-s/--silent option' do
+      it 'raises error in RuboCop 1.0.0' do
+        # This spec can be removed
+        # once Options#ignore_dropped_options is removed.
+        expect { options.parse(['--silent']) }
+          .to raise_error(OptionParser::InvalidOption)
+      end
+    end
+  end
+end