rubocop 0.51.0 → 0.87.0

data/lib/rubocop/platform.rb

@@ -5,7 +5,7 @@ module RuboCop
   # on.
   module Platform
     def self.windows?
-      RUBY_PLATFORM =~ /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,14 +8,11 @@ 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)
       setup_ivars(name)
@@ -69,7 +66,8 @@ module RuboCop
         task(:auto_correct, *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')
+            options = full_options.unshift('--auto-correct-all')
+            options.delete('--parallel')
             run_cli(verbose, options)
           end
         end

data/lib/rubocop/remote_config.rb

@@ -21,7 +21,8 @@ module RuboCop
       request do |response|
         next if response.is_a?(Net::HTTPNotModified)
         next if response.is_a?(SocketError)
-        open cache_path, 'w' do |io|
+
+        File.open cache_path, 'w' do |io|
           io.write response.body
         end
       end
@@ -41,16 +42,23 @@ module RuboCop
       raise ArgumentError, 'HTTP redirect too deep' if limit.zero?
 
       http = Net::HTTP.new(uri.hostname, uri.port)
-      http.use_ssl = true if uri.instance_of? URI::HTTPS
+      http.use_ssl = uri.instance_of?(URI::HTTPS)
 
-      request = Net::HTTP::Get.new(uri.request_uri)
-      if cache_path_exists?
-        request['If-Modified-Since'] = File.stat(cache_path).mtime.rfc2822
+      generate_request(uri) do |request|
+        begin
+          handle_response(http.request(request), limit, &block)
+        rescue SocketError => e
+          handle_response(e, limit, &block)
+        end
       end
+    end
 
-      handle_response(http.request(request), limit, &block)
-    rescue SocketError => err
-      handle_response(err, limit, &block)
+    def generate_request(uri)
+      request = Net::HTTP::Get.new(uri.request_uri)
+
+      request['If-Modified-Since'] = File.stat(cache_path).mtime.rfc2822 if cache_path_exists?
+
+      yield request
     end
 
     def handle_response(response, limit, &block)
@@ -60,7 +68,13 @@ module RuboCop
       when Net::HTTPRedirection
         request(URI.parse(response['location']), limit - 1, &block)
       else
-        response.error!
+        begin
+          response.error!
+        rescue StandardError => e
+          message = "#{e.message} while downloading remote config"\
+            " file #{uri}"
+          raise e, message
+        end
       end
     end
 

data/lib/rubocop/result_cache.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require 'digest/md5'
+require 'digest/sha1'
 require 'find'
 require 'etc'
 
 module RuboCop
   # Provides functionality for caching rubocop runs.
   class ResultCache
-    NON_CHANGING = %i[color format formatters out debug fail_level
+    NON_CHANGING = %i[color format formatters out debug fail_level auto_correct
                       cache fail_fast stdin parallel].freeze
 
     # Remove old files so that the cache doesn't grow too big. When the
@@ -18,6 +18,7 @@ module RuboCop
     # there's parallel execution and the cache is shared.
     def self.cleanup(config_store, verbose, cache_root = nil)
       return if inhibit_cleanup # OPTIMIZE: For faster testing
+
       cache_root ||= cache_root(config_store)
       return unless File.exist?(cache_root)
 
@@ -32,16 +33,14 @@ module RuboCop
 
       def requires_file_removal?(file_count, config_store)
         file_count > 1 &&
-          file_count > config_store.for('.').for_all_cops['MaxFilesInCache']
+          file_count > config_store.for_dir('.').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
+        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
@@ -61,7 +60,7 @@ module RuboCop
     end
 
     def self.cache_root(config_store)
-      root = config_store.for('.').for_all_cops['CacheRootDirectory']
+      root = config_store.for_dir('.').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.
@@ -73,15 +72,16 @@ module RuboCop
     end
 
     def self.allow_symlinks_in_cache_location?(config_store)
-      config_store.for('.').for_all_cops['AllowSymlinksInCacheRootDirectory']
+      config_store.for_dir('.').for_all_cops['AllowSymlinksInCacheRootDirectory']
     end
 
-    def initialize(file, options, config_store, cache_root = nil)
+    def initialize(file, team, options, config_store, cache_root = nil)
       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)
     end
@@ -96,7 +96,15 @@ module RuboCop
 
     def save(offenses)
       dir = File.dirname(@path)
-      FileUtils.mkdir_p(dir)
+
+      begin
+        FileUtils.mkdir_p(dir)
+      rescue Errno::EACCES, Errno::EROFS => e
+        warn "Couldn't create cache directory. Continuing without cache."\
+             "\n  #{e.message}"
+        return
+      end
+
       preliminary_path = "#{@path}_#{rand(1_000_000_000)}"
       # RuboCop must be in control of where its cached data is stored. A
       # symbolic link anywhere in the cache directory tree can be an
@@ -132,9 +140,13 @@ module RuboCop
     end
 
     def file_checksum(file, config_store)
-      Digest::MD5.hexdigest(Dir.pwd + file + IO.read(file) +
-                            File.stat(file).mode.to_s +
-                            config_store.for(file).to_s)
+      digester = Digest::SHA1.new
+      mode = File.stat(file).mode
+      digester.update(
+        "#{file}#{mode}#{config_store.for_file(file).signature}"
+      )
+      digester.file(file)
+      digester.hexdigest
     rescue Errno::ENOENT
       # Spurious files that come and go should not cause a crash, at least not
       # here.
@@ -150,17 +162,17 @@ module RuboCop
       ResultCache.source_checksum ||=
         begin
           lib_root = File.join(File.dirname(__FILE__), '..')
-          bin_root = File.join(lib_root, '..', 'bin')
+          exe_root = File.join(lib_root, '..', 'exe')
 
           # These are all the files we have `require`d plus everything in the
-          # bin directory. A change to any of them could affect the cop output
+          # 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(bin_root).to_a
+          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::MD5.hexdigest(sources.join)
+          Digest::SHA1.hexdigest(sources.join)
         end
     end
 
@@ -169,10 +181,25 @@ module RuboCop
     # 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::MD5.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 ||= {}
+      @checksum_by_team[team.object_id] ||= 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,33 +6,24 @@ require 'tempfile'
 module CopHelper
   extend RSpec::SharedContext
 
-  let(:ruby_version) { 2.2 }
-  let(:enabled_rails) { false }
+  let(:ruby_version) { 2.4 }
   let(:rails_version) { false }
 
   def inspect_source_file(source)
     Tempfile.open('tmp') { |f| inspect_source(source, f) }
   end
 
-  def inspect_gemfile(source)
-    inspect_source(source, 'Gemfile')
-  end
-
   def inspect_source(source, file = nil)
-    if source.is_a?(Array) && source.size == 1
-      raise "Don't use an array for a single line of code: #{source}"
-    end
     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?
+
     _investigate(cop, processed_source)
   end
 
   def parse_source(source, file = nil)
-    source = source.join($RS) if source.is_a?(Array)
-
-    if file && file.respond_to?(:write)
+    if file&.respond_to?(:write)
       file.write(source)
       file.rewind
       file = file.path
@@ -46,34 +37,20 @@ module CopHelper
   end
 
   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
     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)
-    loop do
-      cop.instance_variable_set(:@corrections, [])
-      new_source = autocorrect_source(source, file)
-      return new_source if new_source == source
-      source = new_source
-    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], nil, raise_error: true)
+    report = team.investigate(processed_source)
+    @last_corrector = report.correctors.first || RuboCop::Cop::Corrector.new(processed_source)
+    report.offenses
   end
 end
 
@@ -92,7 +69,3 @@ module RuboCop
     end
   end
 end
-
-RSpec.configure do |config|
-  config.include CopHelper
-end

data/lib/rubocop/rspec/expect_offense.rb

@@ -5,7 +5,7 @@ module RuboCop
     # Mixin for `expect_offense` and `expect_no_offenses`
     #
     # This mixin makes it easier to specify strict offense expectations
-    # and a declarative and visual fashion. Just type out the code that
+    # in a declarative and visual fashion. Just type out the code that
     # should generate a 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
@@ -14,7 +14,7 @@ module RuboCop
     #
     # @example Usage
     #
-    #     expect_offense(<<-RUBY.strip_indent)
+    #     expect_offense(<<~RUBY)
     #       a do
     #         b
     #       end.c
@@ -23,7 +23,7 @@ module RuboCop
     #
     # @example Equivalent assertion without `expect_offense`
     #
-    #     inspect_source(<<-RUBY.strip_indent)
+    #     inspect_source(<<~RUBY)
     #       a do
     #         b
     #       end.c
@@ -38,34 +38,146 @@ module RuboCop
     #       'Avoid chaining a method call on a do...end block.'
     #     )
     #
+    # Auto-correction can be tested using `expect_correction` after
+    # `expect_offense`.
+    #
+    # @example `expect_offense` and `expect_correction`
+    #
+    #   expect_offense(<<~RUBY)
+    #     x % 2 == 0
+    #     ^^^^^^^^^^ Replace with `Integer#even?`.
+    #   RUBY
+    #
+    #   expect_correction(<<~RUBY)
+    #     x.even?
+    #   RUBY
+    #
     # If you do not want to specify an offense then use the
     # companion method `expect_no_offenses`. This method is a much
     # simpler assertion since it just inspects the source and checks
-    # that there were no offenses. The `expect_offenses` method has
+    # 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
+    # use `expect_no_corrections` after `expect_offense`.
+    #
+    # @example `expect_offense` and `expect_no_corrections`
+    #
+    #   expect_offense(<<~RUBY)
+    #     a do
+    #       b
+    #     end.c
+    #     ^^^^^ Avoid chaining a method call on a do...end block.
+    #   RUBY
+    #
+    #   expect_no_corrections
+    #
+    # If your code has variables of different lengths, you can use `%{foo}`,
+    # `^{foo}`, and `_{foo}` to format your template:
+    #
+    #   %w[raise fail].each do |keyword|
+    #     expect_offense(<<~RUBY, keyword: keyword)
+    #       %{keyword}(RuntimeError, msg)
+    #       ^{keyword}^^^^^^^^^^^^^^^^^^^ Redundant `RuntimeError` argument can be removed.
+    #     RUBY
+    #
+    #   %w[has_one has_many].each do |type|
+    #     expect_offense(<<~RUBY, type: type)
+    #       class Book
+    #         %{type} :chapter, foreign_key: 'book_id'
+    #         _{type}           ^^^^^^^^^^^^^^^^^^^^^^ Specifying the default value is redundant.
+    #       end
+    #     RUBY
+    #   end
     module ExpectOffense
-      def expect_offense(source, file = nil)
+      def format_offense(source, **replacements)
+        replacements.each do |keyword, value|
+          source = source.gsub("%{#{keyword}}", value)
+                         .gsub("^{#{keyword}}", '^' * value.size)
+                         .gsub("_{#{keyword}}", ' ' * value.size)
+        end
+        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'
+          raise 'Use `expect_no_offenses` to assert that no offenses are found'
         end
 
-        inspect_source(expected_annotations.plain_source, file)
+        @processed_source = parse_source(expected_annotations.plain_source,
+                                         file)
+
+        raise 'Error parsing example code' unless @processed_source.valid_syntax?
+
+        offenses = _investigate(cop, @processed_source)
         actual_annotations =
-          expected_annotations.with_offense_annotations(cop.offenses)
+          expected_annotations.with_offense_annotations(offenses)
+
         expect(actual_annotations.to_s).to eq(expected_annotations.to_s)
+        expect(offenses.map(&:severity).uniq).to eq([severity]) if severity
+      end
+
+      def expect_correction(correction, loop: true)
+        raise '`expect_correction` must follow `expect_offense`' unless @processed_source
+
+        iteration = 0
+        new_source = loop do
+          iteration += 1
+
+          corrected_source = @last_corrector.rewrite
+
+          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, [])
+          end
+
+          # Prepare for next loop
+          @processed_source = parse_source(corrected_source,
+                                           @processed_source.path)
+          _investigate(cop, @processed_source)
+        end
+
+        expect(new_source).to eq(correction)
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      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
+
+        new_source = @last_corrector.rewrite
+
+        expect(new_source).to eq(@processed_source.buffer.source)
       end
 
       def expect_no_offenses(source, file = nil)
-        inspect_source(source, file)
+        offenses = inspect_source(source, file)
 
-        expect(cop.offenses).to be_empty
+        expected_annotations = AnnotatedSource.parse(source)
+        actual_annotations =
+          expected_annotations.with_offense_annotations(offenses)
+        expect(actual_annotations.to_s).to eq(source)
       end
 
       # Parsed representation of code annotated with the `^^^ Message` style
       class AnnotatedSource
-        ANNOTATION_PATTERN = /\A\s*\^+ /
+        ANNOTATION_PATTERN = /\A\s*\^+ /.freeze
 
         # @param annotated_source [String] string passed to the matchers
         #
@@ -78,7 +190,7 @@ module RuboCop
           annotations = []
 
           annotated_source.each_line do |source_line|
-            if source_line =~ ANNOTATION_PATTERN
+            if ANNOTATION_PATTERN.match?(source_line)
               annotations << [source.size, source_line]
             else
               source << source_line

data/lib/rubocop/rspec/host_environment_simulation_helper.rb

@@ -10,7 +10,7 @@ module HostEnvironmentSimulatorHelper
       pid = ::Process.fork do
         # Need to write coverage result under different name
         if defined?(SimpleCov)
-          SimpleCov.coverage_dir "coverage/ignored_results_#{Process.pid}"
+          SimpleCov.command_name "rspec-fork-#{Process.pid}"
           SimpleCov.pid = Process.pid
         end
 
@@ -26,7 +26,3 @@ module HostEnvironmentSimulatorHelper
     end
   end
 end
-
-RSpec.configure do |config|
-  config.include HostEnvironmentSimulatorHelper
-end