rubocop 0.8.3 → 0.9.0

data/spec/rubocop/formatter/base_formatter_spec.rb

@@ -0,0 +1,190 @@
+# 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'
+          ])
+
+          SimpleTextFormatter.stub(: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
+
+            formatter.should_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
+              formatter.should_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
+
+              cli.stub(:wants_to_quit?) do
+                formatter.processed_file_count == 2
+              end
+
+              formatter.should_receive(:finished) do |processed_files|
+                expect(processed_files).to have(2).items
+              end
+
+              run
+            end
+          end
+        end
+
+        shared_examples 'receives a file path' do |method_name|
+          it 'receives a file path' do
+            formatter.should_receive(method_name)
+              .with(File.expand_path('1_offence.rb'), anything)
+
+            formatter.should_receive(method_name)
+              .with(File.expand_path('4_offences.rb'), anything)
+
+            formatter.should_receive(method_name)
+              .with(File.expand_path('no_offence.rb'), anything)
+
+            run
+          end
+
+          describe 'the passed path' do
+            it 'is frozen' do
+              formatter.should_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
+            formatter.should_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
+            formatter.should_receive(:file_finished)
+            .exactly(3).times do |file, offences|
+              case File.basename(file)
+              when '1_offence.rb'
+                expect(offences).to have(1).item
+              when '4_offences.rb'
+                expect(offences).to have(4).items
+              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,70 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+
+module Rubocop
+  module Formatter
+    describe ClangStyleFormatter do
+      subject(:formatter) { ClangStyleFormatter.new(output) }
+      let(:output) { StringIO.new }
+
+      describe '#report_summary' do
+        context 'when no files inspected' do
+          it 'handles pluralization correctly' do
+            formatter.report_summary(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)
+            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)
+            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)
+            expect(output.string).to eq(
+              "\n2 files inspected, 2 offences detected\n")
+          end
+        end
+      end
+
+      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(:convention,
+                          Parser::Source::Range.new(source_buffer, 0, 2),
+                          'message 1')
+          cop.add_offence(:fatal,
+                          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: F: message 2',
+                                       'ak',
+                                       '^^',
+                                       ''].join("\n")
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/formatter/emacs_style_formatter_spec.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+
+module Rubocop
+  module Formatter
+    describe EmacsStyleFormatter do
+      let(:formatter) { EmacsStyleFormatter.new(output) }
+      let(:output) { StringIO.new }
+
+      describe '#report_file' 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(:convention,
+                          Parser::Source::Range.new(source_buffer, 0, 1),
+                          'message 1')
+          cop.add_offence(:fatal,
+                          Parser::Source::Range.new(source_buffer, 9, 10),
+                          'message 2')
+
+          formatter.report_file('test', cop.offences)
+          expect(output.string).to eq ['test:1:1: C: message 1',
+                                       "test:3:6: F: message 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) { FormatterSet.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|
+            formatter.should_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).to have(1).item
+        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)
+          FormatterSet.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)
+          FormatterSet.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,142 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+
+module Rubocop
+  describe Formatter::JSONFormatter do
+    subject(:formatter) { Formatter::JSONFormatter.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')
+    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
+        formatter.stub(: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
+        formatter.stub(: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
+
+      before do
+        formatter.stub(: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