rubocop 0.93.1 → 1.79.2

data/lib/rubocop/remote_config.rb

@@ -12,7 +12,11 @@ module RuboCop
     CACHE_LIFETIME = 24 * 60 * 60
 
     def initialize(url, base_dir)
-      @uri = URI.parse(url)
+      begin
+        @uri = URI.parse(url)
+      rescue URI::InvalidURIError
+        raise ConfigNotFoundError, "Failed to resolve configuration: '#{url}' is not a valid URI"
+      end
       @base_dir = base_dir
     end
 
@@ -23,9 +27,7 @@ module RuboCop
         next if response.is_a?(Net::HTTPNotModified)
         next if response.is_a?(SocketError)
 
-        File.open cache_path, 'w' do |io|
-          io.write response.body
-        end
+        File.write(cache_path, response.body)
       end
 
       cache_path
@@ -33,7 +35,7 @@ module RuboCop
 
     def inherit_from_remote(file, path)
       new_uri = @uri.dup
-      new_uri.path.gsub!(%r{/[^/]*$}, "/#{file}")
+      new_uri.path.gsub!(%r{/[^/]*$}, "/#{file.delete_prefix('./')}")
       RemoteConfig.new(new_uri.to_s, File.dirname(path))
     end
 
@@ -46,17 +48,16 @@ module RuboCop
       http.use_ssl = uri.instance_of?(URI::HTTPS)
 
       generate_request(uri) do |request|
-        begin
-          handle_response(http.request(request), limit, &block)
-        rescue SocketError => e
-          handle_response(e, limit, &block)
-        end
+        handle_response(http.request(request), limit, &block)
+      rescue SocketError => e
+        handle_response(e, limit, &block)
       end
     end
 
     def generate_request(uri)
       request = Net::HTTP::Get.new(uri.request_uri)
 
+      request.basic_auth(uri.user, uri.password) if uri.user
       request['If-Modified-Since'] = File.stat(cache_path).mtime.rfc2822 if cache_path_exists?
 
       yield request
@@ -72,8 +73,7 @@ module RuboCop
         begin
           response.error!
         rescue StandardError => e
-          message = "#{e.message} while downloading remote config"\
-            " file #{uri}"
+          message = "#{e.message} while downloading remote config file #{cloned_url}"
           raise e, message
         end
       end
@@ -97,9 +97,16 @@ module RuboCop
     end
 
     def cache_name_from_uri
-      uri = @uri.clone
+      uri = cloned_url
       uri.query = nil
       uri.to_s.gsub!(/[^0-9A-Za-z]/, '-')
     end
+
+    def cloned_url
+      uri = @uri.clone
+      uri.user = nil if uri.user
+      uri.password = nil if uri.password
+      uri
+    end
   end
 end

data/lib/rubocop/result_cache.rb

@@ -2,32 +2,39 @@
 
 require 'digest/sha1'
 require 'find'
-require 'etc'
 require 'zlib'
+require_relative 'cache_config'
 
 module RuboCop
-  # Provides functionality for caching rubocop runs.
+  # Provides functionality for caching RuboCop runs.
   # @api private
   class ResultCache
-    NON_CHANGING = %i[color format formatters out debug fail_level auto_correct
+    NON_CHANGING = %i[color format formatters out debug fail_level
+                      fix_layout autocorrect safe_autocorrect autocorrect_all
                       cache fail_fast stdin parallel].freeze
 
+    DL_EXTENSIONS = ::RbConfig::CONFIG
+                    .values_at('DLEXT', 'DLEXT2')
+                    .reject { |ext| !ext || ext.empty? }
+                    .map    { |ext| ".#{ext}" }
+                    .freeze
+
     # Remove old files so that the cache doesn't grow too big. When the
     # threshold MaxFilesInCache has been exceeded, the oldest 50% of all the
     # files in the cache are removed. The reason for removing so much is that
     # cleaning should be done relatively seldom, since there is a slight risk
     # that some other RuboCop process was just about to read the file, when
     # there's parallel execution and the cache is shared.
-    def self.cleanup(config_store, verbose, cache_root = nil)
+    def self.cleanup(config_store, verbose, cache_root_override = nil)
       return if inhibit_cleanup # OPTIMIZE: For faster testing
 
-      cache_root ||= cache_root(config_store)
-      return unless File.exist?(cache_root)
+      rubocop_cache_dir = cache_root(config_store, cache_root_override)
+      return unless File.exist?(rubocop_cache_dir)
 
-      files, dirs = Find.find(cache_root).partition { |path| File.file?(path) }
+      files, dirs = Find.find(rubocop_cache_dir).partition { |path| File.file?(path) }
       return unless requires_file_removal?(files.length, config_store)
 
-      remove_oldest_files(files, dirs, cache_root, verbose)
+      remove_oldest_files(files, dirs, rubocop_cache_dir, verbose)
     end
 
     class << self
@@ -39,15 +46,14 @@ module RuboCop
       private
 
       def requires_file_removal?(file_count, config_store)
-        file_count > 1 &&
-          file_count > config_store.for_pwd.for_all_cops['MaxFilesInCache']
+        file_count > 1 && file_count > config_store.for_pwd.for_all_cops['MaxFilesInCache']
       end
 
-      def remove_oldest_files(files, dirs, cache_root, verbose)
+      def remove_oldest_files(files, dirs, rubocop_cache_dir, verbose)
         # Add 1 to half the number of files, so that we remove the file if
         # there's only 1 left.
-        remove_count = 1 + files.length / 2
-        puts "Removing the #{remove_count} oldest files from #{cache_root}" if verbose
+        remove_count = (files.length / 2) + 1
+        puts "Removing the #{remove_count} oldest files from #{rubocop_cache_dir}" if verbose
         sorted = files.sort_by { |path| File.mtime(path) }
         remove_files(sorted, dirs, remove_count)
       rescue Errno::ENOENT
@@ -66,31 +72,24 @@ module RuboCop
       end
     end
 
-    def self.cache_root(config_store)
-      root = ENV['RUBOCOP_CACHE_ROOT']
-      root ||= config_store.for_pwd.for_all_cops['CacheRootDirectory']
-      root ||= if ENV.key?('XDG_CACHE_HOME')
-                 # Include user ID in the path to make sure the user has write
-                 # access.
-                 File.join(ENV['XDG_CACHE_HOME'], Process.uid.to_s)
-               else
-                 File.join(ENV['HOME'], '.cache')
-               end
-      File.join(root, 'rubocop_cache')
+    def self.cache_root(config_store, cache_root_override = nil)
+      CacheConfig.root_dir do
+        cache_root_override || config_store.for_pwd.for_all_cops['CacheRootDirectory']
+      end
     end
 
     def self.allow_symlinks_in_cache_location?(config_store)
       config_store.for_pwd.for_all_cops['AllowSymlinksInCacheRootDirectory']
     end
 
-    attr :path
+    attr_reader :path
 
-    def initialize(file, team, options, config_store, cache_root = nil)
-      cache_root ||= options[:cache_root]
-      cache_root ||= ResultCache.cache_root(config_store)
+    def initialize(file, team, options, config_store, cache_root_override = nil)
+      cache_root_override ||= options[:cache_root] if options[:cache_root]
+      rubocop_cache_dir = ResultCache.cache_root(config_store, cache_root_override)
       @allow_symlinks_in_cache_location =
         ResultCache.allow_symlinks_in_cache_location?(config_store)
-      @path = File.join(cache_root,
+      @path = File.join(rubocop_cache_dir,
                         rubocop_checksum,
                         context_checksum(team, options),
                         file_checksum(file, config_store))
@@ -108,7 +107,7 @@ module RuboCop
 
     def load
       puts "Loading cache from #{@path}" if debug?
-      @cached_data.from_json(IO.read(@path, encoding: Encoding::UTF_8))
+      @cached_data.from_json(File.read(@path, encoding: Encoding::UTF_8))
     end
 
     def save(offenses)
@@ -117,8 +116,7 @@ module RuboCop
       begin
         FileUtils.mkdir_p(dir)
       rescue Errno::EACCES, Errno::EROFS => e
-        warn "Couldn't create cache directory. Continuing without cache."\
-             "\n  #{e.message}"
+        warn "Couldn't create cache directory. Continuing without cache.\n  #{e.message}"
         return
       end
 
@@ -159,9 +157,7 @@ module RuboCop
     def file_checksum(file, config_store)
       digester = Digest::SHA1.new
       mode = File.stat(file).mode
-      digester.update(
-        "#{file}#{mode}#{config_store.for_file(file).signature}"
-      )
+      digester.update("#{file}#{mode}#{config_store.for_file(file).signature}")
       digester.file(file)
       digester.hexdigest
     rescue Errno::ENOENT
@@ -174,7 +170,7 @@ module RuboCop
       attr_accessor :source_checksum, :inhibit_cleanup
     end
 
-    # The checksum of the rubocop program running the inspection.
+    # The checksum of the RuboCop program running the inspection.
     def rubocop_checksum
       ResultCache.source_checksum ||=
         begin
@@ -183,25 +179,41 @@ module RuboCop
             .select { |path| File.file?(path) }
             .sort!
             .each do |path|
-              content = File.open(path, 'rb', &:read)
-              digest << Zlib.crc32(content).to_s # mtime not reliable
+              digest << digest(path)
             end
           digest << RuboCop::Version::STRING << RuboCop::AST::Version::STRING
           digest.hexdigest
         end
     end
 
+    def digest(path)
+      content = if path.end_with?(*DL_EXTENSIONS)
+                  # Shared libraries often contain timestamps of when
+                  # they were compiled and other non-stable data.
+                  File.basename(path)
+                else
+                  File.binread(path) # mtime not reliable
+                end
+      Zlib.crc32(content).to_s
+    end
+
     def rubocop_extra_features
-      lib_root = File.join(File.dirname(__FILE__), '..')
-      exe_root = File.join(lib_root, '..', 'exe')
+      @rubocop_extra_features ||= begin
+        lib_root = File.join(File.dirname(__FILE__), '..')
+        exe_root = File.join(lib_root, '..', 'exe')
 
-      # These are all the files we have `require`d plus everything in the
-      # exe directory. A change to any of them could affect the cop output
-      # so we include them in the cache hash.
-      source_files = $LOADED_FEATURES + Find.find(exe_root).to_a
-      source_files -= ResultCache.rubocop_required_features # Rely on gem versions
+        # Make sure to use an absolute path to prevent errors on Windows
+        # when traversing the relative paths with symlinks.
+        exe_root = File.absolute_path(exe_root)
 
-      source_files
+        # These are all the files we have `require`d plus everything in the
+        # exe directory. A change to any of them could affect the cop output
+        # so we include them in the cache hash.
+        source_files = $LOADED_FEATURES + Find.find(exe_root).to_a
+        source_files -= ResultCache.rubocop_required_features # Rely on gem versions
+
+        source_files
+      end
     end
 
     # Return a hash of the options given at invocation, minus the ones that have
@@ -212,22 +224,13 @@ module RuboCop
       options.to_s.gsub(/[^a-z]+/i, '_')
     end
 
-    # The external dependency checksums are cached per RuboCop team so that
-    # the checksums don't need to be recomputed for each file.
-    def team_checksum(team)
-      @checksum_by_team ||= {}.compare_by_identity
-      @checksum_by_team[team] ||= team.external_dependency_checksum
-    end
-
     # We combine team and options into a single "context" checksum to avoid
     # making file names that are too long for some filesystems to handle.
     # This context is for anything that's not (1) the RuboCop executable
     # checksum or (2) the inspected file checksum.
     def context_checksum(team, options)
-      Digest::SHA1.hexdigest([
-        team_checksum(team),
-        relevant_options_digest(options)
-      ].join)
+      keys = [team.external_dependency_checksum, relevant_options_digest(options)]
+      Digest::SHA1.hexdigest(keys.join)
     end
   end
 end

data/lib/rubocop/rspec/cop_helper.rb

@@ -6,11 +6,23 @@ require 'tempfile'
 module CopHelper
   extend RSpec::SharedContext
 
-  let(:ruby_version) { 2.4 }
+  let(:ruby_version) do
+    # The minimum version Prism can parse is 3.3.
+    ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : RuboCop::TargetRuby::DEFAULT_VERSION
+  end
+  let(:parser_engine) do
+    # The maximum version Parser can correctly parse is 3.3.
+    ruby_version >= 3.4 ? :parser_prism : ENV.fetch('PARSER_ENGINE', :parser_whitequark).to_sym
+  end
   let(:rails_version) { false }
 
-  def inspect_source_file(source)
-    Tempfile.open('tmp') { |f| inspect_source(source, f) }
+  before(:all) do
+    next if ENV['RUBOCOP_CORE_DEVELOPMENT']
+
+    plugins = Gem.loaded_specs.filter_map do |feature_name, feature_specification|
+      feature_name if feature_specification.metadata['default_lint_roller_plugin']
+    end
+    RuboCop::Plugin.integrate_plugins(RuboCop::Config.new, plugins)
   end
 
   def inspect_source(source, file = nil)
@@ -19,7 +31,7 @@ module CopHelper
     processed_source = parse_source(source, file)
     unless processed_source.valid_syntax?
       raise 'Error parsing example code: ' \
-        "#{processed_source.diagnostics.map(&:render).join("\n")}"
+            "#{processed_source.diagnostics.map(&:render).join("\n")}"
     end
 
     _investigate(cop, processed_source)
@@ -32,7 +44,32 @@ module CopHelper
       file = file.path
     end
 
-    RuboCop::ProcessedSource.new(source, ruby_version, file)
+    processed_source = RuboCop::ProcessedSource.new(
+      source, ruby_version, file, parser_engine: parser_engine
+    )
+    processed_source.config = configuration
+    processed_source.registry = registry
+    processed_source
+  end
+
+  def configuration
+    @configuration ||= if defined?(config)
+                         config
+                       else
+                         RuboCop::Config.new({}, "#{Dir.pwd}/.rubocop.yml")
+                       end
+  end
+
+  def registry
+    @registry ||= begin
+      keys = configuration.keys
+      cops =
+        keys.map { |directive| RuboCop::Cop::Registry.global.find_cops_by_directive(directive) }
+            .flatten
+      cops << cop_class if defined?(cop_class) && !cops.include?(cop_class)
+      cops.compact!
+      RuboCop::Cop::Registry.new(cops)
+    end
   end
 
   def autocorrect_source_file(source)
@@ -42,7 +79,7 @@ module CopHelper
   def autocorrect_source(source, file = nil)
     RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
     RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
-    cop.instance_variable_get(:@options)[:auto_correct] = true
+    cop.instance_variable_get(:@options)[:autocorrect] = true
     processed_source = parse_source(source, file)
     _investigate(cop, processed_source)
 
@@ -50,10 +87,10 @@ module CopHelper
   end
 
   def _investigate(cop, processed_source)
-    team = RuboCop::Cop::Team.new([cop], nil, raise_error: true)
+    team = RuboCop::Cop::Team.new([cop], configuration, raise_error: true)
     report = team.investigate(processed_source)
     @last_corrector = report.correctors.first || RuboCop::Cop::Corrector.new(processed_source)
-    report.offenses
+    report.offenses.reject(&:disabled?)
   end
 end
 

data/lib/rubocop/rspec/expect_offense.rb

@@ -6,7 +6,7 @@ module RuboCop
     #
     # This mixin makes it easier to specify strict offense expectations
     # in a declarative and visual fashion. Just type out the code that
-    # should generate a offense, annotate code by writing '^'s
+    # should generate an offense, annotate code by writing '^'s
     # underneath each character that should be highlighted, and follow
     # the carets with a string (separated by a space) that is the
     # message of the offense. You can include multiple offenses in
@@ -38,7 +38,7 @@ module RuboCop
     #       'Avoid chaining a method call on a do...end block.'
     #     )
     #
-    # Auto-correction can be tested using `expect_correction` after
+    # Autocorrection can be tested using `expect_correction` after
     # `expect_offense`.
     #
     # @example `expect_offense` and `expect_correction`
@@ -58,7 +58,7 @@ module RuboCop
     # that there were no offenses. The `expect_offense` method has
     # to do more work by parsing out lines that contain carets.
     #
-    # If the code produces an offense that could not be auto-corrected, you can
+    # If the code produces an offense that could not be autocorrected, you can
     # use `expect_no_corrections` after `expect_offense`.
     #
     # @example `expect_offense` and `expect_no_corrections`
@@ -72,9 +72,15 @@ module RuboCop
     #
     #   expect_no_corrections
     #
-    # If your code has variables of different lengths, you can use `%{foo}`,
-    # `^{foo}`, and `_{foo}` to format your template; you can also abbreviate
-    # offense messages with `[...]`:
+    # If your code has variables of different lengths, you can use the
+    # following markers to format your template by passing the variables as a
+    # keyword arguments:
+    #
+    # - `%{foo}`: Interpolates `foo`
+    # - `^{foo}`: Inserts `'^' * foo.size` for dynamic offense range length
+    # - `_{foo}`: Inserts `' ' * foo.size` for dynamic offense range indentation
+    #
+    # You can also abbreviate offense messages with `[...]`.
     #
     #   %w[raise fail].each do |keyword|
     #     expect_offense(<<~RUBY, keyword: keyword)
@@ -111,41 +117,43 @@ module RuboCop
         source
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      def expect_offense(source, file = nil, severity: nil, **replacements)
-        source = format_offense(source, **replacements)
-        RuboCop::Formatter::DisabledConfigFormatter
-          .config_to_allow_offenses = {}
-        RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
-        cop.instance_variable_get(:@options)[:auto_correct] = true
-
-        expected_annotations = AnnotatedSource.parse(source)
-
-        if expected_annotations.plain_source == source
-          raise 'Use `expect_no_offenses` to assert that no offenses are found'
-        end
-
-        @processed_source = parse_source(expected_annotations.plain_source,
-                                         file)
-
-        unless @processed_source.valid_syntax?
-          raise 'Error parsing example code: ' \
-            "#{@processed_source.diagnostics.map(&:render).join("\n")}"
-        end
+      # rubocop:disable Metrics/AbcSize
+      def expect_offense(source, file = nil, severity: nil, chomp: false, **replacements)
+        expected_annotations = parse_annotations(source, **replacements)
+        source = expected_annotations.plain_source
+        source = source.chomp if chomp
 
+        @processed_source = parse_processed_source(source, file)
         @offenses = _investigate(cop, @processed_source)
-        actual_annotations =
-          expected_annotations.with_offense_annotations(@offenses)
+        actual_annotations = expected_annotations.with_offense_annotations(@offenses)
 
         expect(actual_annotations).to eq(expected_annotations), ''
         expect(@offenses.map(&:severity).uniq).to eq([severity]) if severity
 
+        # Validate that all offenses have a range that formatters can display
+        expect do
+          @offenses.each { |offense| offense.location.source_line }
+        end.not_to raise_error, 'One of the offenses has a misconstructed range, for ' \
+                                'example if the offense is on line 1 and the source is empty'
+
         @offenses
       end
+      # rubocop:enable Metrics/AbcSize
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+      def expect_correction(correction, loop: true, source: nil)
+        if source
+          expected_annotations = parse_annotations(source, raise_error: false)
+          @processed_source = parse_processed_source(expected_annotations.plain_source)
+          _investigate(cop, @processed_source)
+        end
 
-      def expect_correction(correction, loop: true)
         raise '`expect_correction` must follow `expect_offense`' unless @processed_source
 
+        source = @processed_source.raw_source
+
+        raise 'Use `expect_no_corrections` if the code will not change' if correction == source
+
         iteration = 0
         new_source = loop do
           iteration += 1
@@ -154,47 +162,76 @@ module RuboCop
 
           break corrected_source unless loop
           break corrected_source if @last_corrector.empty?
-          break corrected_source if corrected_source == @processed_source.buffer.source
 
           if iteration > RuboCop::Runner::MAX_ITERATIONS
             raise RuboCop::Runner::InfiniteCorrectionLoop.new(@processed_source.path, [@offenses])
           end
 
           # Prepare for next loop
-          @processed_source = parse_source(corrected_source,
-                                           @processed_source.path)
+          @processed_source = parse_source(corrected_source, @processed_source.path)
           _investigate(cop, @processed_source)
         end
 
+        raise 'Expected correction but no corrections were made' if new_source == source
+
         expect(new_source).to eq(correction)
+        expect(@processed_source).to be_valid_syntax, 'Expected correction to be valid syntax'
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
 
       def expect_no_corrections
         raise '`expect_no_corrections` must follow `expect_offense`' unless @processed_source
 
         return if @last_corrector.empty?
 
-        # In order to print a nice diff, e.g. what source got corrected to,
-        # we need to run the actual corrections
-
+        # This is just here for a pretty diff if the source actually got changed
         new_source = @last_corrector.rewrite
-
         expect(new_source).to eq(@processed_source.buffer.source)
+
+        # There is an infinite loop if a corrector is present that did not make
+        # any changes. It will cause the same offense/correction on the next loop.
+        raise RuboCop::Runner::InfiniteCorrectionLoop.new(@processed_source.path, [@offenses])
       end
 
       def expect_no_offenses(source, file = nil)
         offenses = inspect_source(source, file)
 
-        expected_annotations = AnnotatedSource.parse(source)
-        actual_annotations =
-          expected_annotations.with_offense_annotations(offenses)
+        # Since source given `expect_no_offenses` does not have annotations, we do not need to parse
+        # for them, and can just build an `AnnotatedSource` object from the source lines.
+        # This also prevents treating source lines that begin with a caret as an annotation.
+        expected_annotations = AnnotatedSource.new(source.each_line.to_a, [])
+        actual_annotations = expected_annotations.with_offense_annotations(offenses)
         expect(actual_annotations.to_s).to eq(source)
       end
 
+      def parse_annotations(source, raise_error: true, **replacements)
+        set_formatter_options
+
+        source = format_offense(source, **replacements)
+        annotations = AnnotatedSource.parse(source)
+        return annotations unless raise_error && annotations.plain_source == source
+
+        raise 'Use `expect_no_offenses` to assert that no offenses are found'
+      end
+
+      def parse_processed_source(source, file = nil)
+        processed_source = parse_source(source, file)
+        return processed_source if processed_source.valid_syntax?
+
+        raise 'Error parsing example code: ' \
+              "#{processed_source.diagnostics.map(&:render).join("\n")}"
+      end
+
+      def set_formatter_options
+        RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
+        RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
+        cop.instance_variable_get(:@options)[:autocorrect] = true
+      end
+
       # Parsed representation of code annotated with the `^^^ Message` style
       class AnnotatedSource
-        ANNOTATION_PATTERN = /\A\s*(\^+|\^{}) /.freeze
+        # Ignore escaped carets, don't treat as annotations
+        ANNOTATION_PATTERN = /\A\s*((?<!\\)\^+|\^{}) ?/.freeze
         ABBREV = "[...]\n"
 
         # @param annotated_source [String] string passed to the matchers
@@ -231,9 +268,7 @@ module RuboCop
         end
 
         def ==(other)
-          other.is_a?(self.class) &&
-            other.lines == lines &&
-            match_annotations?(other)
+          other.is_a?(self.class) && other.lines == lines && match_annotations?(other)
         end
 
         # Dirty hack: expectations with [...] are rewritten when they match