rubbycop 0.49.0

data/lib/rubbycop/rspec/shared_contexts.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require 'fileutils'
+
+shared_context 'isolated environment', :isolated_environment do
+  around do |example|
+    Dir.mktmpdir do |tmpdir|
+      original_home = ENV['HOME']
+
+      # Make sure to expand all symlinks in the path first. Otherwise we may
+      # get mismatched pathnames when loading config files later on.
+      tmpdir = File.realpath(tmpdir)
+
+      # Make upwards search for .rubbycop.yml files stop at this directory.
+      RubbyCop::ConfigLoader.root_level = tmpdir
+
+      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
+
+# `cop_config` must be declared with #let.
+shared_context 'config', :config do
+  let(:config) do
+    # Module#<
+    unless described_class < RubbyCop::Cop::Cop
+      raise '`config` must be used in `describe SomeCopClass do .. end`'
+    end
+
+    hash = { 'AllCops' => { 'TargetRubyVersion' => ruby_version } }
+    hash['Rails'] = { 'Enabled' => true } if enabled_rails
+    hash['AllCops']['TargetRailsVersion'] = rails_version if rails_version
+    if respond_to?(:cop_config)
+      cop_name = described_class.cop_name
+      hash[cop_name] = RubbyCop::ConfigLoader
+                       .default_configuration[cop_name]
+                       .merge(cop_config)
+    end
+
+    hash = other_cops.merge hash if respond_to?(:other_cops)
+
+    RubbyCop::Config.new(hash, "#{Dir.pwd}/.rubbycop.yml")
+  end
+end
+
+shared_context 'ruby 1.9', :ruby19 do
+  let(:ruby_version) { 1.9 }
+end
+
+shared_context 'ruby 2.0', :ruby20 do
+  let(:ruby_version) { 2.0 }
+end
+
+shared_context 'ruby 2.1', :ruby21 do
+  let(:ruby_version) { 2.1 }
+end
+
+shared_context 'ruby 2.2', :ruby22 do
+  let(:ruby_version) { 2.2 }
+end
+
+shared_context 'ruby 2.3', :ruby23 do
+  let(:ruby_version) { 2.3 }
+end
+
+shared_context 'ruby 2.4', :ruby24 do
+  let(:ruby_version) { 2.4 }
+end
+
+shared_context 'with Rails', :enabled_rails do
+  let(:enabled_rails) { true }
+end
+
+shared_context 'with Rails 3', :rails3 do
+  let(:rails_version) { 3.0 }
+end
+
+shared_context 'with Rails 4', :rails4 do
+  let(:rails_version) { 4.0 }
+end
+
+shared_context 'with Rails 5', :rails5 do
+  let(:rails_version) { 5.0 }
+end

data/lib/rubbycop/rspec/shared_examples.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# `cop` and `source` must be declared with #let.
+
+shared_examples_for 'accepts' do
+  it 'accepts' do
+    inspect_source(cop, source)
+    expect(cop.offenses).to be_empty
+  end
+end
+
+shared_examples_for 'mimics MRI 2.1' do |grep_mri_warning|
+  if RUBY_ENGINE == 'ruby' && RUBY_VERSION.start_with?('2.1')
+    it "mimics MRI #{RUBY_VERSION} built-in syntax checking" do
+      inspect_source(cop, source)
+      offenses_by_mri = MRISyntaxChecker.offenses_for_source(
+        source, cop.name, grep_mri_warning
+      )
+
+      # Compare objects before comparing counts for clear failure output.
+      cop.offenses.each_with_index do |offense_by_cop, index|
+        offense_by_mri = offenses_by_mri[index]
+        # Exclude column attribute since MRI does not
+        # output column number.
+        %i[severity line cop_name].each do |a|
+          expect(offense_by_cop.send(a)).to eq(offense_by_mri.send(a))
+        end
+      end
+
+      expect(cop.offenses.count).to eq(offenses_by_mri.count)
+    end
+  end
+end
+
+shared_examples_for 'misaligned' do |prefix, alignment_base, arg, end_kw, name|
+  name ||= alignment_base
+  source = ["#{prefix}#{alignment_base} #{arg}",
+            end_kw]
+
+  it "registers an offense for mismatched #{name} ... end" do
+    inspect_source(cop, source)
+    expect(cop.offenses.size).to eq(1)
+    base_regexp = Regexp.escape(alignment_base)
+    regexp = /`end` at 2, \d+ is not aligned with `#{base_regexp}` at 1,/
+    expect(cop.messages.first).to match(regexp)
+    expect(cop.highlights.first).to eq('end')
+
+    other_styles = (cop.supported_styles - [cop.style]).map(&:to_s)
+    # In some cases, the code under test will happen to match an alternative
+    # style. In other cases, it won't match any style at all
+    expect(cop.config_to_allow_offenses).to(
+      eq('Enabled' => false).or(
+        satisfy { |h| other_styles.include?(h['EnforcedStyleAlignWith']) }
+      )
+    )
+  end
+
+  it "auto-corrects mismatched #{name} ... end" do
+    aligned_source = ["#{prefix}#{alignment_base} #{arg}",
+                      "#{' ' * prefix.length}#{end_kw.strip}"].join("\n")
+    corrected = autocorrect_source(cop, source)
+    expect(corrected).to eq(aligned_source)
+  end
+end
+
+shared_examples_for 'aligned' do |alignment_base, arg, end_kw, name|
+  name ||= alignment_base
+  name = name.gsub(/\n/, ' <newline>')
+  it "accepts matching #{name} ... end" do
+    inspect_source(cop, ["#{alignment_base} #{arg}",
+                         end_kw])
+    expect(cop.offenses).to be_empty
+  end
+end
+
+shared_examples_for 'debugger' do |name, src|
+  it "reports an offense for a #{name} call" do
+    inspect_source(cop, src)
+    src = [src] if src.is_a? String
+    expect(cop.offenses.size).to eq(src.size)
+    expect(cop.messages)
+      .to eq(src.map { |s| "Remove debugger entry point `#{s}`." })
+    expect(cop.highlights).to eq(src)
+  end
+end
+
+shared_examples_for 'non-debugger' do |name, src|
+  it "does not report an offense for #{name}" do
+    inspect_source(cop, src)
+    expect(cop.offenses).to be_empty
+  end
+end

data/lib/rubbycop/rspec/support.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Require this file to load code that supports testing using RSpec.
+
+require 'rubbycop/rspec/cop_helper'
+require 'rubbycop/rspec/host_environment_simulation_helper'
+require 'rubbycop/rspec/shared_contexts'
+require 'rubbycop/rspec/shared_examples'

data/lib/rubbycop/runner.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+require 'parallel'
+
+module RubbyCop
+  # This class handles the processing of files, which includes dealing with
+  # formatters and letting cops inspect the files.
+  class Runner # rubbycop:disable Metrics/ClassLength
+    # An exception indicating that the inspection loop got stuck correcting
+    # offenses back and forth.
+    class InfiniteCorrectionLoop < RuntimeError
+      attr_reader :offenses
+
+      def initialize(path, offenses)
+        super "Infinite loop detected in #{path}."
+        @offenses = offenses
+      end
+    end
+
+    MAX_ITERATIONS = 200
+
+    attr_reader :errors, :warnings, :aborting
+    alias aborting? aborting
+
+    def initialize(options, config_store)
+      @options = options
+      @config_store = config_store
+      @errors = []
+      @warnings = []
+      @aborting = false
+    end
+
+    def run(paths)
+      target_files = find_target_files(paths)
+      if @options[:list_target_files]
+        list_files(target_files)
+      else
+        warm_cache(target_files) if @options[:parallel]
+        inspect_files(target_files)
+      end
+    end
+
+    def abort
+      @aborting = true
+    end
+
+    private
+
+    # Warms up the RubbyCop cache by forking a suitable number of rubbycop
+    # instances that each inspects its alotted group of files.
+    def warm_cache(target_files)
+      puts 'Running parallel inspection'
+      Parallel.each(target_files, &method(:file_offenses))
+    end
+
+    def find_target_files(paths)
+      target_finder = TargetFinder.new(@config_store, @options)
+      target_files = target_finder.find(paths)
+      target_files.each(&:freeze).freeze
+    end
+
+    def inspect_files(files)
+      inspected_files = []
+
+      formatter_set.started(files)
+
+      each_inspected_file(files) { |file| inspected_files << file }
+    ensure
+      ResultCache.cleanup(@config_store, @options[:debug]) if cached_run?
+      formatter_set.finished(inspected_files.freeze)
+      formatter_set.close_output_files
+    end
+
+    def each_inspected_file(files)
+      files.reduce(true) do |all_passed, file|
+        break false if aborting?
+
+        offenses = process_file(file)
+        yield file
+
+        if offenses.any? { |o| considered_failure?(o) }
+          break false if @options[:fail_fast]
+          next false
+        end
+
+        all_passed
+      end
+    end
+
+    def list_files(paths)
+      paths.each do |path|
+        puts PathUtil.relative_path(path)
+      end
+    end
+
+    def process_file(file)
+      puts "Scanning #{file}" if @options[:debug]
+      file_started(file)
+
+      offenses = file_offenses(file)
+      formatter_set.file_finished(file, offenses)
+      offenses
+    rescue InfiniteCorrectionLoop => e
+      formatter_set.file_finished(file, e.offenses.compact.sort.freeze)
+      raise
+    end
+
+    def file_offenses(file)
+      file_offense_cache(file) do
+        source = get_processed_source(file)
+        source, offenses = do_inspection_loop(file, source)
+        add_unneeded_disables(file, offenses.compact.sort, source)
+      end
+    end
+
+    def file_offense_cache(file)
+      cache = ResultCache.new(file, @options, @config_store) if cached_run?
+      if cache && cache.valid?
+        offenses = cache.load
+      else
+        offenses = yield
+        save_in_cache(cache, offenses)
+      end
+
+      offenses
+    end
+
+    def add_unneeded_disables(file, offenses, source)
+      if check_for_unneded_disables?(source)
+        config = @config_store.for(file)
+        if config.for_cop(Cop::Lint::UnneededDisable).fetch('Enabled')
+          cop = Cop::Lint::UnneededDisable.new(config, @options)
+          if cop.relevant_file?(file)
+            cop.check(offenses, source.disabled_line_ranges, source.comments)
+            offenses += cop.offenses
+            autocorrect_unneeded_disables(source, cop)
+          end
+        end
+        offenses
+      end
+
+      offenses.sort.reject(&:disabled?).freeze
+    end
+
+    def check_for_unneded_disables?(source)
+      !source.disabled_line_ranges.empty? && !filtered_run?
+    end
+
+    def filtered_run?
+      @options[:except] || @options[:only]
+    end
+
+    def autocorrect_unneeded_disables(source, cop)
+      cop.processed_source = source
+
+      Cop::Team.new(
+        RubbyCop::Cop::Registry.new,
+        nil,
+        @options
+      ).autocorrect(source.buffer, [cop])
+    end
+
+    def file_started(file)
+      formatter_set.file_started(file,
+                                 cli_options: @options,
+                                 config_store: @config_store)
+    end
+
+    def cached_run?
+      @cached_run ||=
+        (@options[:cache] == 'true' ||
+         @options[:cache] != 'false' &&
+         @config_store.for(Dir.pwd).for_all_cops['UseCache']) &&
+        # When running --auto-gen-config, there's some processing done in the
+        # cops related to calculating the Max parameters for Metrics cops. We
+        # need to do that processing and can not use caching.
+        !@options[:auto_gen_config] &&
+        # Auto-correction needs a full run. It can not use cached results.
+        !@options[:auto_correct] &&
+        # We can't cache results from code which is piped in to stdin
+        !@options[:stdin]
+    end
+
+    def save_in_cache(cache, offenses)
+      return unless cache
+      # Caching results when a cop has crashed would prevent the crash in the
+      # next run, since the cop would not be called then. We want crashes to
+      # show up the same in each run.
+      return if errors.any? || warnings.any?
+
+      cache.save(offenses)
+    end
+
+    def do_inspection_loop(file, processed_source)
+      offenses = []
+
+      # When running with --auto-correct, we need to inspect the file (which
+      # includes writing a corrected version of it) until no more corrections
+      # are made. This is because automatic corrections can introduce new
+      # offenses. In the normal case the loop is only executed once.
+      iterate_until_no_changes(processed_source, offenses) do
+        # The offenses that couldn't be corrected will be found again so we
+        # only keep the corrected ones in order to avoid duplicate reporting.
+        offenses.select!(&:corrected?)
+        new_offenses, updated_source_file = inspect_file(processed_source)
+        offenses.concat(new_offenses).uniq!
+
+        # We have to reprocess the source to pickup the changes. Since the
+        # change could (theoretically) introduce parsing errors, we break the
+        # loop if we find any.
+        break unless updated_source_file
+
+        processed_source = get_processed_source(file)
+      end
+
+      [processed_source, offenses]
+    end
+
+    def iterate_until_no_changes(source, offenses)
+      # Keep track of the state of the source. If a cop modifies the source
+      # and another cop undoes it producing identical source we have an
+      # infinite loop.
+      @processed_sources = []
+
+      # It is also possible for a cop to keep adding indefinitely to a file,
+      # making it bigger and bigger. If the inspection loop runs for an
+      # excessively high number of iterations, this is likely happening.
+      iterations = 0
+
+      loop do
+        check_for_infinite_loop(source, offenses)
+
+        if (iterations += 1) > MAX_ITERATIONS
+          raise InfiniteCorrectionLoop.new(source.path, offenses)
+        end
+
+        source = yield
+        break unless source
+      end
+    end
+
+    # Check whether a run created source identical to a previous run, which
+    # means that we definitely have an infinite loop.
+    def check_for_infinite_loop(processed_source, offenses)
+      checksum = processed_source.checksum
+
+      if @processed_sources.include?(checksum)
+        raise InfiniteCorrectionLoop.new(processed_source.path, offenses)
+      end
+
+      @processed_sources << checksum
+    end
+
+    def inspect_file(processed_source)
+      config = @config_store.for(processed_source.path)
+      enable_rails_cops(config) if @options[:rails]
+      team = Cop::Team.new(mobilized_cop_classes(config), config, @options)
+      offenses = team.inspect_file(processed_source)
+      @errors.concat(team.errors)
+      @warnings.concat(team.warnings)
+      [offenses, team.updated_source_file?]
+    end
+
+    def enable_rails_cops(config)
+      config['Rails'] ||= {}
+      config['Rails']['Enabled'] = true
+    end
+
+    def mobilized_cop_classes(config)
+      @mobilized_cop_classes ||= {}
+      @mobilized_cop_classes[config.object_id] ||= begin
+        cop_classes = Cop::Cop.all
+
+        %i[only except].each do |opt|
+          OptionsValidator.validate_cop_list(@options[opt])
+        end
+
+        if @options[:only]
+          cop_classes.select! { |c| c.match?(@options[:only]) }
+        else
+          filter_cop_classes(cop_classes, config)
+        end
+
+        cop_classes.reject! { |c| c.match?(@options[:except]) }
+
+        Cop::Registry.new(cop_classes)
+      end
+    end
+
+    def filter_cop_classes(cop_classes, config)
+      # use only cops that link to a style guide if requested
+      return unless style_guide_cops_only?(config)
+
+      cop_classes.select! { |cop| config.for_cop(cop)['StyleGuide'] }
+    end
+
+    def style_guide_cops_only?(config)
+      @options[:only_guide_cops] || config.for_all_cops['StyleGuideCopsOnly']
+    end
+
+    def formatter_set
+      @formatter_set ||= begin
+        set = Formatter::FormatterSet.new(@options)
+        pairs = @options[:formatters] || [['progress']]
+        pairs.each do |formatter_key, output_path|
+          set.add_formatter(formatter_key, output_path)
+        end
+        set
+      end
+    end
+
+    def considered_failure?(offense)
+      # For :autocorrect level, any offense - corrected or not - is a failure.
+      return false if offense.disabled?
+
+      return true if @options[:fail_level] == :autocorrect
+
+      !offense.corrected? && offense.severity >= minimum_severity_to_fail
+    end
+
+    def minimum_severity_to_fail
+      @minimum_severity_to_fail ||= begin
+        name = @options[:fail_level] || :refactor
+        RubbyCop::Cop::Severity.new(name)
+      end
+    end
+
+    def get_processed_source(file)
+      ruby_version = @config_store.for(file).target_ruby_version
+
+      if @options[:stdin]
+        ProcessedSource.new(@options[:stdin], ruby_version, file)
+      else
+        ProcessedSource.from_file(file, ruby_version)
+      end
+    end
+  end
+end