rubocop 0.76.0 → 1.50.0

data/lib/rubocop/path_util.rb

@@ -3,44 +3,62 @@
 module RuboCop
   # Common methods and behaviors for dealing with paths.
   module PathUtil
-    module_function
+    class << self
+      attr_accessor :relative_paths_cache
+    end
+    self.relative_paths_cache = Hash.new { |hash, key| hash[key] = {} }
 
-    def relative_path(path, base_dir = PathUtil.pwd)
-      # Optimization for the common case where path begins with the base
-      # dir. Just cut off the first part.
-      if path.start_with?(base_dir)
-        base_dir_length = base_dir.length
-        result_length = path.length - base_dir_length - 1
-        return path[base_dir_length + 1, result_length]
-      end
+    module_function
 
-      path_name = Pathname.new(File.expand_path(path))
-      begin
-        path_name.relative_path_from(Pathname.new(base_dir)).to_s
-      rescue ArgumentError
-        path
-      end
+    def relative_path(path, base_dir = Dir.pwd)
+      PathUtil.relative_paths_cache[base_dir][path] ||=
+        # Optimization for the common case where path begins with the base
+        # dir. Just cut off the first part.
+        if path.start_with?(base_dir)
+          base_dir_length = base_dir.length
+          result_length = path.length - base_dir_length - 1
+          path[base_dir_length + 1, result_length]
+        else
+          path_name = Pathname.new(File.expand_path(path))
+          begin
+            path_name.relative_path_from(Pathname.new(base_dir)).to_s
+          rescue ArgumentError
+            path
+          end
+        end
     end
 
+    SMART_PATH_CACHE = {} # rubocop:disable Style/MutableConstant
+    private_constant :SMART_PATH_CACHE
+
     def smart_path(path)
-      # Ideally, we calculate this relative to the project root.
-      base_dir = PathUtil.pwd
+      SMART_PATH_CACHE[path] ||= begin
+        # Ideally, we calculate this relative to the project root.
+        base_dir = Dir.pwd
 
-      if path.start_with? base_dir
-        relative_path(path, base_dir)
-      else
-        path
+        if path.start_with? base_dir
+          relative_path(path, base_dir)
+        else
+          path
+        end
       end
     end
 
+    # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
     def match_path?(pattern, path)
       case pattern
       when String
-        File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB) ||
-          hidden_file_in_not_hidden_dir?(pattern, path)
+        matches =
+          if pattern == path
+            true
+          elsif glob?(pattern)
+            File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+          end
+
+        matches || hidden_file_in_not_hidden_dir?(pattern, path)
       when Regexp
         begin
-          path =~ pattern
+          pattern.match?(path)
         rescue ArgumentError => e
           return false if e.message.start_with?('invalid byte sequence')
 
@@ -48,38 +66,46 @@ module RuboCop
         end
       end
     end
+    # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
     # Returns true for an absolute Unix or Windows path.
     def absolute?(path)
-      path =~ %r{\A([A-Z]:)?/}i
+      %r{\A([A-Z]:)?/}i.match?(path)
     end
 
-    def self.pwd
-      @pwd ||= Dir.pwd
+    # Returns true for a glob
+    def glob?(path)
+      path.match?(/[*{\[?]/)
     end
 
-    def self.reset_pwd
-      @pwd = nil
+    def hidden_file_in_not_hidden_dir?(pattern, path)
+      hidden_file?(path) &&
+        File.fnmatch?(
+          pattern, path,
+          File::FNM_PATHNAME | File::FNM_EXTGLOB | File::FNM_DOTMATCH
+        ) &&
+        !hidden_dir?(path)
     end
 
-    def self.chdir(dir, &block)
-      reset_pwd
-      Dir.chdir(dir, &block)
-    ensure
-      reset_pwd
+    def hidden_file?(path)
+      maybe_hidden_file?(path) && File.basename(path).start_with?('.')
     end
 
-    def hidden_file_in_not_hidden_dir?(pattern, path)
-      File.fnmatch?(
-        pattern, path,
-        File::FNM_PATHNAME | File::FNM_EXTGLOB | File::FNM_DOTMATCH
-      ) && File.basename(path).start_with?('.') && !hidden_dir?(path)
+    HIDDEN_FILE_PATTERN = "#{File::SEPARATOR}."
+
+    # Loose check to reduce memory allocations
+    def maybe_hidden_file?(path)
+      return false unless path.include?(HIDDEN_FILE_PATTERN)
+
+      separator_index = path.rindex(File::SEPARATOR)
+      return false unless separator_index
+
+      dot_index = path.index('.', separator_index + 1)
+      dot_index == separator_index + 1
     end
 
     def hidden_dir?(path)
-      File.dirname(path).split(File::SEPARATOR).any? do |dir|
-        dir.start_with?('.')
-      end
+      File.dirname(path).split(File::SEPARATOR).any? { |dir| dir.start_with?('.') }
     end
   end
 end

data/lib/rubocop/platform.rb

@@ -5,7 +5,7 @@ module RuboCop
   # on.
   module Platform
     def self.windows?
-      RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/
+      /cygwin|mswin|mingw|bccwin|wince|emx/.match?(RbConfig::CONFIG['host_os'])
     end
   end
 end

data/lib/rubocop/rake_task.rb

@@ -8,23 +8,21 @@ module RuboCop
   #
   # require 'rubocop/rake_task'
   # RuboCop::RakeTask.new
-  class RakeTask < Rake::TaskLib
-    attr_accessor :name
-    attr_accessor :verbose
-    attr_accessor :fail_on_error
-    attr_accessor :patterns
-    attr_accessor :formatters
-    attr_accessor :requires
-    attr_accessor :options
+  #
+  # Use global Rake namespace here to avoid namespace issues with custom
+  # rubocop-rake tasks
+  class RakeTask < ::Rake::TaskLib
+    attr_accessor :name, :verbose, :fail_on_error, :patterns, :formatters, :requires, :options
 
     def initialize(name = :rubocop, *args, &task_block)
+      super()
       setup_ivars(name)
 
       desc 'Run RuboCop' unless ::Rake.application.last_description
 
       task(name, *args) do |_, task_args|
         RakeFileUtils.verbose(verbose) do
-          yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
+          yield(*[self, task_args].slice(0, task_block.arity)) if task_block
           run_cli(verbose, full_options)
         end
       end
@@ -34,8 +32,17 @@ module RuboCop
 
     private
 
+    def perform(option)
+      options = full_options.unshift(option)
+      # `parallel` will automatically be removed from the options internally.
+      # This is a nice to have to suppress the warning message
+      # about --parallel and --autocorrect not being compatible.
+      options.delete('--parallel')
+      run_cli(verbose, options)
+    end
+
     def run_cli(verbose, options)
-      # We lazy-load rubocop so that the task doesn't dramatically impact the
+      # We lazy-load RuboCop so that the task doesn't dramatically impact the
       # load time of your Rakefile.
       require 'rubocop'
 
@@ -62,15 +69,35 @@ module RuboCop
       @formatters = []
     end
 
-    def setup_subtasks(name, *args, &task_block)
+    def setup_subtasks(name, *args, &task_block) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       namespace(name) do
-        desc 'Auto-correct RuboCop offenses'
+        # rubocop:todo Naming/InclusiveLanguage
+        task(:auto_correct, *args) do
+          require 'rainbow'
+          warn Rainbow(
+            'rubocop:auto_correct task is deprecated; ' \
+            'use rubocop:autocorrect task or rubocop:autocorrect_all task instead.'
+          ).yellow
+          RakeFileUtils.verbose(verbose) do
+            yield(*[self, task_args].slice(0, task_block.arity)) if task_block
+            perform('--autocorrect')
+          end
+        end
+        # rubocop:enable Naming/InclusiveLanguage
+
+        desc "Autocorrect RuboCop offenses (only when it's safe)."
+        task(:autocorrect, *args) do |_, task_args|
+          RakeFileUtils.verbose(verbose) do
+            yield(*[self, task_args].slice(0, task_block.arity)) if task_block
+            perform('--autocorrect')
+          end
+        end
 
-        task(:auto_correct, *args) do |_, task_args|
+        desc 'Autocorrect RuboCop offenses (safe and unsafe).'
+        task(:autocorrect_all, *args) do |_, task_args|
           RakeFileUtils.verbose(verbose) do
-            yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
-            options = full_options.unshift('--auto-correct')
-            run_cli(verbose, options)
+            yield(*[self, task_args].slice(0, task_block.arity)) if task_block
+            perform('--autocorrect-all')
           end
         end
       end

data/lib/rubocop/remote_config.rb

@@ -5,6 +5,7 @@ require 'time'
 
 module RuboCop
   # Common methods and behaviors for dealing with remote config files.
+  # @api private
   class RemoteConfig
     attr_reader :uri
 
@@ -22,9 +23,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
@@ -32,7 +31,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
 
@@ -45,20 +44,17 @@ 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)
 
-      if cache_path_exists?
-        request['If-Modified-Since'] = File.stat(cache_path).mtime.rfc2822
-      end
+      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
     end
@@ -73,8 +69,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
@@ -98,9 +93,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

@@ -1,15 +1,25 @@
 # frozen_string_literal: true
 
 require 'digest/sha1'
-require 'find'
 require 'etc'
+require 'find'
+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
@@ -29,20 +39,22 @@ module RuboCop
     end
 
     class << self
+      # @api private
+      attr_accessor :rubocop_required_features
+
+      ResultCache.rubocop_required_features = []
+
       private
 
       def requires_file_removal?(file_count, config_store)
-        file_count > 1 &&
-          file_count > config_store.for('.').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)
         # 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
-        if verbose
-          puts "Removing the #{remove_count} oldest files from #{cache_root}"
-        end
+        remove_count = (files.length / 2) + 1
+        puts "Removing the #{remove_count} oldest files from #{cache_root}" if verbose
         sorted = files.sort_by { |path| File.mtime(path) }
         remove_files(sorted, dirs, remove_count)
       rescue Errno::ENOENT
@@ -62,29 +74,32 @@ module RuboCop
     end
 
     def self.cache_root(config_store)
-      root = config_store.for('.').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')
+      CacheConfig.root_dir do
+        config_store.for_pwd.for_all_cops['CacheRootDirectory']
+      end
     end
 
     def self.allow_symlinks_in_cache_location?(config_store)
-      config_store.for('.').for_all_cops['AllowSymlinksInCacheRootDirectory']
+      config_store.for_pwd.for_all_cops['AllowSymlinksInCacheRootDirectory']
     end
 
-    def initialize(file, options, config_store, cache_root = nil)
+    attr :path
+
+    def initialize(file, team, options, config_store, cache_root = nil)
+      cache_root ||= File.join(options[:cache_root], 'rubocop_cache') if options[:cache_root]
       cache_root ||= ResultCache.cache_root(config_store)
       @allow_symlinks_in_cache_location =
         ResultCache.allow_symlinks_in_cache_location?(config_store)
-      @path = File.join(cache_root, rubocop_checksum,
-                        relevant_options_digest(options),
+      @path = File.join(cache_root,
+                        rubocop_checksum,
+                        context_checksum(team, options),
                         file_checksum(file, config_store))
       @cached_data = CachedData.new(file)
+      @debug = options[:debug]
+    end
+
+    def debug?
+      @debug
     end
 
     def valid?
@@ -92,7 +107,8 @@ module RuboCop
     end
 
     def load
-      @cached_data.from_json(IO.read(@path, encoding: Encoding::UTF_8))
+      puts "Loading cache from #{@path}" if debug?
+      @cached_data.from_json(File.read(@path, encoding: Encoding::UTF_8))
     end
 
     def save(offenses)
@@ -101,8 +117,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
 
@@ -143,9 +158,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).signature}"
-      )
+      digester.update("#{file}#{mode}#{config_store.for_file(file).signature}")
       digester.file(file)
       digester.hexdigest
     rescue Errno::ENOENT
@@ -158,34 +171,67 @@ 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
-          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
-          sources = source_files
-                    .select { |path| File.file?(path) }
-                    .sort
-                    .map { |path| IO.read(path, encoding: Encoding::UTF_8) }
-          Digest::SHA1.hexdigest(sources.join)
+          digest = Digest::SHA1.new
+          rubocop_extra_features
+            .select { |path| File.file?(path) }
+            .sort!
+            .each do |path|
+              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')
+
+      # 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
+
     # Return a hash of the options given at invocation, minus the ones that have
     # no effect on which offenses and disabled line ranges are found, and thus
     # don't affect caching.
     def relevant_options_digest(options)
       options = options.reject { |key, _| NON_CHANGING.include?(key) }
-      options = options.to_s.gsub(/[^a-z]+/i, '_')
-      # We must avoid making file names too long for some filesystems to handle
-      # If they are short, we can leave them human-readable
-      options.length <= 32 ? options : Digest::SHA1.hexdigest(options)
+      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)
     end
   end
 end

data/lib/rubocop/rspec/cop_helper.rb

@@ -6,30 +6,52 @@ require 'tempfile'
 module CopHelper
   extend RSpec::SharedContext
 
-  let(:ruby_version) { 2.3 }
+  let(:ruby_version) { 2.6 }
   let(:rails_version) { false }
 
-  def inspect_source_file(source)
-    Tempfile.open('tmp') { |f| inspect_source(source, f) }
-  end
-
   def inspect_source(source, file = nil)
     RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
     RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
     processed_source = parse_source(source, file)
-    raise 'Error parsing example code' unless processed_source.valid_syntax?
+    unless processed_source.valid_syntax?
+      raise 'Error parsing example code: ' \
+            "#{processed_source.diagnostics.map(&:render).join("\n")}"
+    end
 
     _investigate(cop, processed_source)
   end
 
   def parse_source(source, file = nil)
-    if file&.respond_to?(:write)
+    if file.respond_to?(:write)
       file.write(source)
       file.rewind
       file = file.path
     end
 
-    RuboCop::ProcessedSource.new(source, ruby_version, file)
+    processed_source = RuboCop::ProcessedSource.new(source, ruby_version, file)
+    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)
@@ -39,41 +61,18 @@ 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)
 
-    corrector =
-      RuboCop::Cop::Corrector.new(processed_source.buffer, cop.corrections)
-    corrector.rewrite
-  end
-
-  def autocorrect_source_with_loop(source, file = nil)
-    cnt = 0
-    loop do
-      cop.instance_variable_set(:@corrections, [])
-      new_source = autocorrect_source(source, file)
-      return new_source if new_source == source
-
-      source = new_source
-      cnt += 1
-      if cnt > RuboCop::Runner::MAX_ITERATIONS
-        raise RuboCop::Runner::InfiniteCorrectionLoop.new(file, [])
-      end
-    end
+    @last_corrector.rewrite
   end
 
   def _investigate(cop, processed_source)
-    forces = RuboCop::Cop::Force.all.each_with_object([]) do |klass, instances|
-      next unless cop.join_force?(klass)
-
-      instances << klass.new([cop])
-    end
-
-    commissioner =
-      RuboCop::Cop::Commissioner.new([cop], forces, raise_error: true)
-    commissioner.investigate(processed_source)
-    commissioner
+    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.reject(&:disabled?)
   end
 end