sabat-rubocop 0.9.0

data/spec/rubocop/formatter/progress_formatter_spec.rb

@@ -0,0 +1,196 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+
+module Rubocop
+  describe Formatter::ProgressFormatter do
+    let(:formatter) { Formatter::ProgressFormatter.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
+          formatter.should_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 #reports_summary? is true' do
+        before { formatter.reports_summary = true }
+
+        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
+          formatter.should_receive(:report_summary)
+          formatter.finished(files)
+        end
+      end
+
+      context 'when #reports_summary? is false' do
+        before { formatter.reports_summary = false }
+
+        it 'reports nothing' do
+          output.string = ''
+          formatter.finished(files)
+          expect(output.string).to eq("\n")
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/formatter/simple_text_formatter_spec.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+require 'tempfile'
+
+module Rubocop
+  module Formatter
+    describe SimpleTextFormatter do
+      subject(:formatter) { SimpleTextFormatter.new(output) }
+      let(:output) { StringIO.new }
+
+      describe '#report_file' do
+        before do
+          formatter.report_file(file, [])
+        end
+
+        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
+      end
+
+      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
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+if ENV['TRAVIS'] && RUBY_ENGINE == 'jruby'
+  # Force JRuby not to select working directory
+  # as temporary directory on Travis CI.
+  # https://github.com/jruby/jruby/issues/405
+  require 'fileutils'
+  tmp_dir = ENV['TMPDIR'] || ENV['TMP'] || ENV['TEMP'] ||
+            Etc.systmpdir || '/tmp'
+  non_world_writable_tmp_dir = File.join(tmp_dir, 'rubocop')
+  FileUtils.makedirs(non_world_writable_tmp_dir, mode: 0700)
+  ENV['TMPDIR'] = non_world_writable_tmp_dir
+end
+
+if ENV['TRAVIS'] || ENV['COVERAGE']
+  require 'simplecov'
+
+  if ENV['TRAVIS']
+    require 'coveralls'
+    SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+  end
+
+  SimpleCov.start do
+    add_filter '/spec/'
+    add_filter '/vendor/bundle/'
+  end
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'rubocop'
+require 'rubocop/cli'
+
+# disable colors in specs
+Sickill::Rainbow.enabled = false
+
+module ExitCodeMatchers
+  RSpec::Matchers.define :exit_with_code do |code|
+    actual = nil
+    match do |block|
+      begin
+        block.call
+      rescue SystemExit => e
+        actual = e.status
+      end
+      actual && actual == code
+    end
+    failure_message_for_should do |block|
+      "expected block to call exit(#{code}) but exit" +
+        (actual.nil? ? ' not called' : "(#{actual}) was called")
+    end
+    failure_message_for_should_not do |block|
+      "expected block not to call exit(#{code})"
+    end
+    description do
+      "expect block to call exit(#{code})"
+    end
+  end
+end
+
+RSpec.configure do |config|
+  broken_filter = lambda do |v|
+    v.is_a?(Symbol) ? RUBY_ENGINE == v.to_s : v
+  end
+  config.filter_run_excluding ruby: ->(v) { !RUBY_VERSION.start_with?(v.to_s) }
+  config.filter_run_excluding broken: broken_filter
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect # disables `should`
+  end
+
+  config.include(ExitCodeMatchers)
+end
+
+def inspect_source(cop, source)
+  ast, comments, tokens, src_buffer, _ = Rubocop::CLI.parse('(string)') do |sb|
+    sb.source = source.join($RS)
+  end
+  cop.inspect(src_buffer, source, tokens, ast, comments)
+end
+
+class Rubocop::Cop::Cop
+  def messages
+    offences.map(&:message)
+  end
+end
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }

data/spec/support/file_helper.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'fileutils'
+
+module FileHelper
+  def create_file(file_path, content)
+    file_path = File.expand_path(file_path)
+
+    dir_path = File.dirname(file_path)
+    FileUtils.makedirs dir_path unless File.exists?(dir_path)
+
+    File.open(file_path, 'w') do |file|
+      case content
+      when String
+        file.puts content
+      when Array
+        file.puts content.join("\n")
+      end
+    end
+  end
+end

data/spec/support/isolated_environment.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'tmpdir'
+require 'fileutils'
+
+shared_context 'isolated environment', :isolated_environment do
+  around do |example|
+    Dir.mktmpdir do |tmpdir|
+      original_home = ENV['HOME']
+
+      begin
+        virtual_home = File.expand_path(File.join(tmpdir, 'home'))
+        Dir.mkdir(virtual_home)
+        ENV['HOME'] = virtual_home
+
+        working_dir = File.join(tmpdir, 'work')
+        Dir.mkdir(working_dir)
+
+        Dir.chdir(working_dir) do
+          example.run
+        end
+      ensure
+        ENV['HOME'] = original_home
+      end
+    end
+  end
+end

data/spec/support/mri_syntax_checker.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+require 'open3'
+
+# The reincarnation of syntax cop :)
+module MRISyntaxChecker
+  module_function
+
+  def offences_for_source(source, fake_cop_name = 'Syntax', grep_message = nil)
+    if source.is_a?(Array)
+      source_lines = source
+      source = source_lines.join("\n")
+    else
+      source_lines = source.each_line.to_a
+    end
+
+    source_buffer = Parser::Source::Buffer.new('test', 1)
+    source_buffer.source = source
+
+    offences = []
+
+    check_syntax(source).each_line do |line|
+      line_number, severity, message = process_line(line)
+      next unless line_number
+      next if grep_message && !message.include?(grep_message)
+      begin_pos = source_lines[0...(line_number - 1)].reduce(0) do |a, e|
+        a + e.length + "\n".length
+      end
+      offences << Rubocop::Cop::Offence.new(
+        severity,
+        Parser::Source::Range.new(source_buffer, begin_pos, begin_pos + 1),
+        message.capitalize,
+        fake_cop_name
+      )
+    end
+
+    offences
+  end
+
+  def check_syntax(source)
+    fail 'Must be running with MRI' unless RUBY_ENGINE == 'ruby'
+
+    stdin, stderr, thread = nil
+
+    # It's extremely important to run the syntax check in a
+    # clean environment - otherwise it will be extremely slow.
+    if defined? Bundler
+      Bundler.with_clean_env do
+        stdin, _, stderr, thread = Open3.popen3('ruby', '-cw')
+      end
+    else
+      stdin, _, stderr, thread = Open3.popen3('ruby', '-cw')
+    end
+
+    stdin.write(source)
+    stdin.close
+    thread.join
+
+    stderr.read
+  end
+
+  def process_line(line)
+    match_data = line.match(/.+:(\d+): (warning: )?(.+)/)
+    return nil unless match_data
+    line_number, warning, message = match_data.captures
+    severity = warning ? :warning : :error
+    [line_number.to_i, severity, message]
+  end
+end