rubocop 0.51.0 → 0.87.0

data/lib/rubocop/rspec/shared_contexts.rb

@@ -1,90 +1,129 @@
 # frozen_string_literal: true
 
 require 'tmpdir'
-require 'fileutils'
 
-shared_context 'isolated environment', :isolated_environment do
+RSpec.shared_context 'isolated environment', :isolated_environment do
   around do |example|
     Dir.mktmpdir do |tmpdir|
       original_home = ENV['HOME']
+      original_xdg_config_home = ENV['XDG_CONFIG_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 .rubocop.yml files stop at this directory.
-      RuboCop::ConfigLoader.root_level = tmpdir
+      RuboCop::FileFinder.root_level = tmpdir
 
       begin
         virtual_home = File.expand_path(File.join(tmpdir, 'home'))
         Dir.mkdir(virtual_home)
         ENV['HOME'] = virtual_home
+        ENV.delete('XDG_CONFIG_HOME')
 
         working_dir = File.join(tmpdir, 'work')
         Dir.mkdir(working_dir)
 
-        Dir.chdir(working_dir) do
+        RuboCop::PathUtil.chdir(working_dir) do
           example.run
         end
       ensure
         ENV['HOME'] = original_home
+        ENV['XDG_CONFIG_HOME'] = original_xdg_config_home
+
+        RuboCop::FileFinder.root_level = nil
       end
     end
   end
 end
 
-# `cop_config` must be declared with #let.
-shared_context 'config', :config do
-  let(:config) do
-    # Module#<
-    unless described_class < RuboCop::Cop::Cop
-      raise '`config` must be used in `describe SomeCopClass do .. end`'
-    end
+# This context assumes nothing and defines `cop`, among others.
+RSpec.shared_context 'config', :config do # rubocop:disable Metrics/BlockLength
+  ### Meant to be overridden at will
+
+  let(:source) { 'code = {some: :ruby}' }
 
-    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] = RuboCop::ConfigLoader
-                       .default_configuration[cop_name]
-                       .merge(cop_config)
+  let(:cop_class) do
+    unless described_class.is_a?(Class) && described_class < RuboCop::Cop::Base
+      raise 'Specify which cop class to use (e.g `let(:cop_class) { RuboCop::Cop::Base }`, ' \
+            'or RuboCop::Cop::Cop for legacy)'
     end
+    described_class
+  end
+
+  let(:cop_config) { {} }
+
+  let(:other_cops) { {} }
 
-    hash = other_cops.merge hash if respond_to?(:other_cops)
+  let(:cop_options) { {} }
+
+  ### Utilities
+
+  def source_range(range, buffer: source_buffer)
+    Parser::Source::Range.new(buffer, range.begin,
+                              range.exclude_end? ? range.end : range.end + 1)
+  end
+
+  ### Useful intermediary steps (less likely to be overridden)
+
+  let(:processed_source) { parse_source(source, 'test') }
+
+  let(:source_buffer) { processed_source.buffer }
+
+  let(:all_cops_config) do
+    rails = { 'TargetRubyVersion' => ruby_version }
+    rails['TargetRailsVersion'] = rails_version if rails_version
+    rails
+  end
+
+  let(:cur_cop_config) do
+    RuboCop::ConfigLoader
+      .default_configuration.for_cop(cop_class)
+      .merge({
+               'Enabled' => true, # in case it is 'pending'
+               'AutoCorrect' => true # in case defaults set it to false
+             })
+      .merge(cop_config)
+  end
+
+  let(:config) do
+    hash = { 'AllCops' => all_cops_config,
+             cop_class.cop_name => cur_cop_config }.merge!(other_cops)
 
     RuboCop::Config.new(hash, "#{Dir.pwd}/.rubocop.yml")
   end
-end
 
-shared_context 'ruby 2.1', :ruby21 do
-  let(:ruby_version) { 2.1 }
+  let(:cop) do
+    cop_class.new(config, cop_options).tap do |cop|
+      cop.send :begin_investigation, processed_source
+    end
+  end
 end
 
-shared_context 'ruby 2.2', :ruby22 do
-  let(:ruby_version) { 2.2 }
-end
+RSpec.shared_context 'mock console output' do
+  before do
+    $stdout = StringIO.new
+    $stderr = StringIO.new
+  end
 
-shared_context 'ruby 2.3', :ruby23 do
-  let(:ruby_version) { 2.3 }
+  after do
+    $stdout = STDOUT
+    $stderr = STDERR
+  end
 end
 
-shared_context 'ruby 2.4', :ruby24 do
+RSpec.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 }
+RSpec.shared_context 'ruby 2.5', :ruby25 do
+  let(:ruby_version) { 2.5 }
 end
 
-shared_context 'with Rails 4', :rails4 do
-  let(:rails_version) { 4.0 }
+RSpec.shared_context 'ruby 2.6', :ruby26 do
+  let(:ruby_version) { 2.6 }
 end
 
-shared_context 'with Rails 5', :rails5 do
-  let(:rails_version) { 5.0 }
+RSpec.shared_context 'ruby 2.7', :ruby27 do
+  let(:ruby_version) { 2.7 }
 end

data/lib/rubocop/rspec/support.rb

@@ -5,5 +5,9 @@
 require_relative 'cop_helper'
 require_relative 'host_environment_simulation_helper'
 require_relative 'shared_contexts'
-require_relative 'shared_examples'
 require_relative 'expect_offense'
+
+RSpec.configure do |config|
+  config.include CopHelper
+  config.include HostEnvironmentSimulatorHelper
+end

data/lib/rubocop/runner.rb

@@ -19,8 +19,8 @@ module RuboCop
 
     MAX_ITERATIONS = 200
 
-    attr_reader :errors, :warnings, :aborting
-    alias aborting? aborting
+    attr_reader :errors, :warnings
+    attr_writer :aborting
 
     def initialize(options, config_store)
       @options = options
@@ -38,16 +38,22 @@ module RuboCop
         warm_cache(target_files) if @options[:parallel]
         inspect_files(target_files)
       end
+    rescue Interrupt
+      self.aborting = true
+      warn ''
+      warn 'Exiting...'
+
+      false
     end
 
-    def abort
-      @aborting = true
+    def aborting?
+      @aborting
     end
 
     private
 
     # Warms up the RuboCop cache by forking a suitable number of rubocop
-    # instances that each inspects its alotted group of files.
+    # instances that each inspects its allotted group of files.
     def warm_cache(target_files)
       puts 'Running parallel inspection' if @options[:debug]
       Parallel.each(target_files, &method(:file_offenses))
@@ -55,7 +61,12 @@ module RuboCop
 
     def find_target_files(paths)
       target_finder = TargetFinder.new(@config_store, @options)
-      target_files = target_finder.find(paths)
+      mode = if @options[:only_recognized_file_types]
+               :only_recognized_file_types
+             else
+               :all_file_types
+             end
+      target_files = target_finder.find(paths, mode)
       target_files.each(&:freeze).freeze
     end
 
@@ -66,20 +77,22 @@ module RuboCop
 
       each_inspected_file(files) { |file| inspected_files << file }
     ensure
-      ResultCache.cleanup(@config_store, @options[:debug]) if cached_run?
+      # OPTIMIZE: Calling `ResultCache.cleanup` takes time. This optimization
+      # mainly targets editors that integrates RuboCop. When RuboCop is run
+      # by an editor, it should be inspecting only one file.
+      ResultCache.cleanup(@config_store, @options[:debug]) if files.size > 1 && 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
 
@@ -94,30 +107,43 @@ module RuboCop
     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)
+      offenses = e.offenses.compact.sort.freeze
       raise
+    ensure
+      file_finished(file, offenses || [])
     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)
+        offenses = add_redundant_disables(file, offenses.compact.sort, source)
+        offenses.sort.reject(&:disabled?).freeze
       end
     end
 
+    def cached_result(file, team)
+      ResultCache.new(file, team, @options, @config_store)
+    end
+
     def file_offense_cache(file)
-      cache = ResultCache.new(file, @options, @config_store) if cached_run?
-      if cache && cache.valid?
+      config = @config_store.for_file(file)
+      cache = cached_result(file, standby_team(config)) if cached_run?
+
+      if cache&.valid?
         offenses = cache.load
+        # If we're running --auto-correct and the cache says there are
+        # offenses, we need to actually inspect the file. If the cache shows no
+        # offenses, we're good.
+        real_run_needed = @options[:auto_correct] && offenses.any?
       else
+        real_run_needed = true
+      end
+
+      if real_run_needed
         offenses = yield
         save_in_cache(cache, offenses)
       end
@@ -125,58 +151,73 @@ module RuboCop
       offenses
     end
 
-    def add_unneeded_disables(file, offenses, source)
-      if check_for_unneeded_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
+    def add_redundant_disables(file, offenses, source)
+      team_for_redundant_disables(file, offenses, source) do |team|
+        new_offenses, redundant_updated = inspect_file(source, team)
+        offenses += new_offenses
+        if redundant_updated
+          # Do one extra inspection loop if any redundant disables were
+          # removed. This is done in order to find rubocop:enable directives that
+          # have now become useless.
+          _source, new_offenses = do_inspection_loop(file,
+                                                     get_processed_source(file))
+          offenses |= new_offenses
         end
-        offenses
       end
+      offenses
+    end
+
+    def team_for_redundant_disables(file, offenses, source)
+      return unless check_for_redundant_disables?(source)
 
-      offenses.sort.reject(&:disabled?).freeze
+      config = @config_store.for_file(file)
+      team = Cop::Team.mobilize([Cop::Lint::RedundantCopDisableDirective], config, @options)
+      return if team.cops.empty?
+
+      team.cops.first.offenses_to_check = offenses
+      yield team
     end
 
-    def check_for_unneeded_disables?(source)
+    def check_for_redundant_disables?(source)
       !source.disabled_line_ranges.empty? && !filtered_run?
     end
 
-    def filtered_run?
-      @options[:except] || @options[:only]
+    def redundant_cop_disable_directive(file)
+      config = @config_store.for_file(file)
+      if config.for_cop(Cop::Lint::RedundantCopDisableDirective)
+               .fetch('Enabled')
+        cop = Cop::Lint::RedundantCopDisableDirective.new(config, @options)
+        yield cop if cop.relevant_file?(file)
+      end
     end
 
-    def autocorrect_unneeded_disables(source, cop)
-      cop.processed_source = source
-
-      Cop::Team.new(
-        RuboCop::Cop::Registry.new,
-        nil,
-        @options
-      ).autocorrect(source.buffer, [cop])
+    def filtered_run?
+      @options[:except] || @options[:only]
     end
 
     def file_started(file)
+      puts "Scanning #{file}" if @options[:debug]
       formatter_set.file_started(file,
                                  cli_options: @options,
                                  config_store: @config_store)
     end
 
+    def file_finished(file, offenses)
+      if @options[:display_only_fail_level_offenses]
+        offenses = offenses.select { |o| considered_failure?(o) }
+      end
+      formatter_set.file_finished(file, offenses)
+    end
+
     def cached_run?
       @cached_run ||=
         (@options[:cache] == 'true' ||
          @options[:cache] != 'false' &&
-         @config_store.for(Dir.pwd).for_all_cops['UseCache']) &&
+         @config_store.for_dir(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.
+        # need to do that processing and cannot 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
@@ -251,19 +292,16 @@ module RuboCop
       @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)
+    def inspect_file(processed_source, team = mobilize_team(processed_source))
+      report = team.investigate(processed_source)
       @errors.concat(team.errors)
       @warnings.concat(team.warnings)
-      [offenses, team.updated_source_file?]
+      [report.offenses, team.updated_source_file?]
     end
 
-    def enable_rails_cops(config)
-      config['Rails'] ||= {}
-      config['Rails']['Enabled'] = true
+    def mobilize_team(processed_source)
+      config = @config_store.for_file(processed_source.path)
+      Cop::Team.mobilize(mobilized_cop_classes(config), config, @options)
     end
 
     def mobilized_cop_classes(config)
@@ -271,9 +309,7 @@ module RuboCop
       @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
+        OptionsValidator.new(@options).validate_cop_options
 
         if @options[:only]
           cop_classes.select! { |c| c.match?(@options[:only]) }
@@ -283,7 +319,7 @@ module RuboCop
 
         cop_classes.reject! { |c| c.match?(@options[:except]) }
 
-        Cop::Registry.new(cop_classes)
+        Cop::Registry.new(cop_classes, @options)
       end
     end
 
@@ -326,13 +362,27 @@ module RuboCop
     end
 
     def get_processed_source(file)
-      ruby_version = @config_store.for(file).target_ruby_version
+      ruby_version = @config_store.for_file(file).target_ruby_version
 
       if @options[:stdin]
         ProcessedSource.new(@options[:stdin], ruby_version, file)
       else
-        ProcessedSource.from_file(file, ruby_version)
+        begin
+          ProcessedSource.from_file(file, ruby_version)
+        rescue Errno::ENOENT
+          raise RuboCop::Error, "No such file or directory: #{file}"
+        end
       end
     end
+
+    # A Cop::Team instance is stateful and may change when inspecting.
+    # The "standby" team for a given config is an initialized but
+    # otherwise dormant team that can be used for config- and option-
+    # level caching in ResultCache.
+    def standby_team(config)
+      @team_by_config ||= {}
+      @team_by_config[config.object_id] ||=
+        Cop::Team.mobilize(mobilized_cop_classes(config), config, @options)
+    end
   end
 end

data/lib/rubocop/string_interpreter.rb

@@ -16,7 +16,7 @@ module RuboCop
                             u[0-9a-fA-F]{4}   |   # unicode char escape
                             u\{[^}]*\}        |   # extended unicode escape
                             .                     # any other escaped char
-                          )/x
+                          )/x.freeze
     class << self
       def interpret(string)
         # We currently don't handle \cx, \C-x, and \M-x
@@ -29,8 +29,8 @@ module RuboCop
 
       def interpret_string_escape(escape)
         case escape[1]
-        when 'u'.freeze then interpret_unicode(escape)
-        when 'x'.freeze then interpret_hex(escape)
+        when 'u' then interpret_unicode(escape)
+        when 'x' then interpret_hex(escape)
         when /\d/       then interpret_octal(escape)
         else
           escape[1] # literal escaped char, like \\
@@ -38,19 +38,19 @@ module RuboCop
       end
 
       def interpret_unicode(escape)
-        if escape[2] == '{'.freeze
-          escape[3..-1].split(/\s+/).map(&:hex).pack('U*'.freeze)
+        if escape[2] == '{'
+          escape[3..-1].split(/\s+/).map(&:hex).pack('U*')
         else
-          [escape[2..-1].hex].pack('U'.freeze)
+          [escape[2..-1].hex].pack('U')
         end
       end
 
       def interpret_hex(escape)
-        [escape[2..-1].hex].pack('C'.freeze)
+        [escape[2..-1].hex].pack('C')
       end
 
       def interpret_octal(escape)
-        [escape[1..-1].to_i(8)].pack('C'.freeze)
+        [escape[1..-1].to_i(8)].pack('C')
       end
     end
   end