rubocop 0.85.1 → 0.89.0

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -74,7 +74,7 @@ module RuboCop
       end
 
       def timestamp
-        @options[:no_auto_gen_timestamp] ? '' : "on #{Time.now} "
+        @options[:no_auto_gen_timestamp] ? '' : "on #{Time.now.utc} "
       end
 
       def output_offenses
@@ -115,7 +115,7 @@ module RuboCop
         output_buffer.puts "# Offense count: #{offense_count}" if @show_offense_counts
 
         cop_class = Cop::Cop.registry.find_by_cop_name(cop_name)
-        output_buffer.puts '# Cop supports --auto-correct.' if cop_class&.new&.support_autocorrect?
+        output_buffer.puts '# Cop supports --auto-correct.' if cop_class&.support_autocorrect?
 
         default_cfg = default_config(cop_name)
         return unless default_cfg

data/lib/rubocop/formatter/formatter_set.rb

@@ -35,6 +35,7 @@ module RuboCop
       end
 
       def initialize(options = {})
+        super()
         @options = options # CLI options
       end
 
@@ -82,7 +83,7 @@ module RuboCop
 
       def builtin_formatter_class(specified_key)
         matching_keys = BUILTIN_FORMATTERS_FOR_KEYS.keys.select do |key|
-          key =~ /^\[#{specified_key}\]/ || specified_key == key.delete('[]')
+          /^\[#{specified_key}\]/.match?(key) || specified_key == key.delete('[]')
         end
 
         raise %(No formatter for "#{specified_key}") if matching_keys.empty?

data/lib/rubocop/name_similarity.rb

@@ -12,13 +12,17 @@ module RuboCop
     end
 
     def find_similar_names(target_name, names)
+      # DidYouMean::SpellChecker is not available in all versions of Ruby, and
+      # even on versions where it *is* available (>= 2.3), it is not always
+      # required correctly. So we do a feature check first.
+      # See: https://github.com/rubocop-hq/rubocop/issues/7979
+      return [] unless defined?(DidYouMean::SpellChecker)
+
       names = names.dup
       names.delete(target_name)
 
       spell_checker = DidYouMean::SpellChecker.new(dictionary: names)
-      similar_names = spell_checker.correct(target_name)
-
-      similar_names
+      spell_checker.correct(target_name)
     end
   end
 end

data/lib/rubocop/options.rb

@@ -163,7 +163,7 @@ module RuboCop
       end
     end
 
-    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
     def add_boolean_flags(opts)
       option(opts, '-F', '--fail-fast')
       option(opts, '-C', '--cache FLAG')
@@ -171,7 +171,16 @@ module RuboCop
       option(opts, '-D', '--[no-]display-cop-names')
       option(opts, '-E', '--extra-details')
       option(opts, '-S', '--display-style-guide')
-      option(opts, '-a', '--auto-correct')
+      option(opts, '-a', '--auto-correct') do
+        @options[:safe_auto_correct] = true
+      end
+      option(opts, '--safe-auto-correct') do
+        warn '--safe-auto-correct is deprecated; use --auto-correct'
+        @options[:safe_auto_correct] = @options[:auto_correct] = true
+      end
+      option(opts, '-A', '--auto-correct-all') do
+        @options[:auto_correct] = true
+      end
       option(opts, '--disable-pending-cops')
       option(opts, '--enable-pending-cops')
       option(opts, '--ignore-disable-comments')
@@ -184,7 +193,7 @@ module RuboCop
       option(opts, '-V', '--verbose-version')
       option(opts, '-P', '--parallel')
     end
-    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
     def add_aliases(opts)
       option(opts, '-l', '--lint') do
@@ -196,9 +205,6 @@ module RuboCop
         @options[:only] << 'Layout'
         @options[:auto_correct] = true
       end
-      option(opts, '--safe-auto-correct') do
-        @options[:auto_correct] = true
-      end
     end
 
     def add_list_options(opts)
@@ -465,8 +471,9 @@ module RuboCop
       lint:                             'Run only lint cops.',
       safe:                             'Run only safe cops.',
       list_target_files:                'List all files RuboCop will inspect.',
-      auto_correct:                     'Auto-correct offenses.',
-      safe_auto_correct:                'Run auto-correct only when it\'s safe.',
+      auto_correct:                     'Auto-correct offenses (only when it\'s safe).',
+      safe_auto_correct:                '(same, deprecated)',
+      auto_correct_all:                 'Auto-correct offenses (safe and unsafe)',
       fix_layout:                       'Run only layout cops, with auto-correct on.',
       color:                            'Force color output on or off.',
       version:                          'Display version.',

data/lib/rubocop/path_util.rb

@@ -5,7 +5,7 @@ module RuboCop
   module PathUtil
     module_function
 
-    def relative_path(path, base_dir = PathUtil.pwd)
+    def relative_path(path, base_dir = Dir.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)
@@ -24,7 +24,7 @@ module RuboCop
 
     def smart_path(path)
       # Ideally, we calculate this relative to the project root.
-      base_dir = PathUtil.pwd
+      base_dir = Dir.pwd
 
       if path.start_with? base_dir
         relative_path(path, base_dir)
@@ -40,7 +40,7 @@ module RuboCop
           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')
 
@@ -51,29 +51,29 @@ module RuboCop
 
     # 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
+    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.reset_pwd
-      @pwd = nil
+    def hidden_file?(path)
+      maybe_hidden_file?(path) && File.basename(path).start_with?('.')
     end
 
-    def self.chdir(dir, &block)
-      reset_pwd
-      Dir.chdir(dir, &block)
-    ensure
-      reset_pwd
-    end
+    # Loose check to reduce memory allocations
+    def maybe_hidden_file?(path)
+      separator_index = path.rindex(File::SEPARATOR)
+      return false unless separator_index
 
-    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)
+      dot_index = path.index('.', separator_index + 1)
+      dot_index == separator_index + 1
     end
 
     def hidden_dir?(path)

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,16 +8,14 @@ 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
@@ -69,7 +67,7 @@ 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

data/lib/rubocop/result_cache.rb

@@ -33,7 +33,7 @@ module RuboCop
 
       def requires_file_removal?(file_count, config_store)
         file_count > 1 &&
-          file_count > config_store.for_dir('.').for_all_cops['MaxFilesInCache']
+          file_count > config_store.for_pwd.for_all_cops['MaxFilesInCache']
       end
 
       def remove_oldest_files(files, dirs, cache_root, verbose)
@@ -60,7 +60,7 @@ module RuboCop
     end
 
     def self.cache_root(config_store)
-      root = config_store.for_dir('.').for_all_cops['CacheRootDirectory']
+      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.
@@ -72,7 +72,7 @@ module RuboCop
     end
 
     def self.allow_symlinks_in_cache_location?(config_store)
-      config_store.for_dir('.').for_all_cops['AllowSymlinksInCacheRootDirectory']
+      config_store.for_pwd.for_all_cops['AllowSymlinksInCacheRootDirectory']
     end
 
     def initialize(file, team, options, config_store, cache_root = nil)
@@ -158,6 +158,7 @@ module RuboCop
     end
 
     # The checksum of the rubocop program running the inspection.
+    # rubocop:disable Metrics/AbcSize
     def rubocop_checksum
       ResultCache.source_checksum ||=
         begin
@@ -168,13 +169,16 @@ module RuboCop
           # 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
+          source_files
+            .select { |path| File.file?(path) }
+            .sort!
+            .each { |path| digest << File.mtime(path).to_s }
+          digest.hexdigest
         end
     end
+    # rubocop:enable Metrics/AbcSize
 
     # 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

data/lib/rubocop/rspec/cop_helper.rb

@@ -43,14 +43,14 @@ module CopHelper
     processed_source = parse_source(source, file)
     _investigate(cop, processed_source)
 
-    corrector =
-      RuboCop::Cop::Corrector.new(processed_source.buffer, cop.corrections)
-    corrector.rewrite
+    @last_corrector.rewrite
   end
 
   def _investigate(cop, processed_source)
     team = RuboCop::Cop::Team.new([cop], nil, raise_error: true)
-    team.inspect_file(processed_source)
+    report = team.investigate(processed_source)
+    @last_corrector = report.correctors.first || RuboCop::Cop::Corrector.new(processed_source)
+    report.offenses
   end
 end
 

data/lib/rubocop/rspec/expect_offense.rb

@@ -72,25 +72,47 @@ module RuboCop
     #
     #   expect_no_corrections
     #
-    # If your code has variables of different lengths, you can use `%{foo}`
-    # and `^{foo}` to format your template:
+    # 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 `[...]`:
     #
     #   %w[raise fail].each do |keyword|
     #     expect_offense(<<~RUBY, keyword: keyword)
     #       %{keyword}(RuntimeError, msg)
-    #       ^{keyword}^^^^^^^^^^^^^^^^^^^ Redundant `RuntimeError` argument can be removed.
+    #       ^{keyword}^^^^^^^^^^^^^^^^^^^ Redundant `RuntimeError` argument [...]
     #     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 [...]
+    #       end
+    #     RUBY
+    #   end
+    #
+    # If you need to specify an offense on a blank line, use the empty `^{}` marker:
+    #
+    # @example `^{}` empty line offense
+    #
+    #   expect_offense(<<~RUBY)
+    #
+    #     ^{} Missing frozen string literal comment.
+    #     puts 1
+    #   RUBY
     module ExpectOffense
       def format_offense(source, **replacements)
         replacements.each do |keyword, value|
+          value = value.to_s
           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, **replacements)
+      def expect_offense(source, file = nil, severity: nil, **replacements)
         source = format_offense(source, **replacements)
         RuboCop::Formatter::DisabledConfigFormatter
           .config_to_allow_offenses = {}
@@ -108,11 +130,12 @@ module RuboCop
 
         raise 'Error parsing example code' unless @processed_source.valid_syntax?
 
-        _investigate(cop, @processed_source)
+        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(actual_annotations).to eq(expected_annotations), ''
+        expect(offenses.map(&:severity).uniq).to eq([severity]) if severity
       end
 
       def expect_correction(correction, loop: true)
@@ -122,12 +145,10 @@ module RuboCop
         new_source = loop do
           iteration += 1
 
-          corrector =
-            RuboCop::Cop::Corrector.new(@processed_source.buffer, cop.corrections)
-          corrected_source = corrector.rewrite
+          corrected_source = @last_corrector.rewrite
 
           break corrected_source unless loop
-          break corrected_source if cop.corrections.empty?
+          break corrected_source if @last_corrector.empty?
           break corrected_source if corrected_source == @processed_source.buffer.source
 
           if iteration > RuboCop::Runner::MAX_ITERATIONS
@@ -135,9 +156,6 @@ module RuboCop
           end
 
           # Prepare for next loop
-          cop.instance_variable_set(:@corrections, [])
-          # Cache invalidation. This is bad!
-          cop.instance_variable_set(:@token_table, nil)
           @processed_source = parse_source(corrected_source,
                                            @processed_source.path)
           _investigate(cop, @processed_source)
@@ -150,30 +168,29 @@ module RuboCop
       def expect_no_corrections
         raise '`expect_no_corrections` must follow `expect_offense`' unless @processed_source
 
-        return if cop.corrections.empty?
+        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
 
-        corrector =
-          RuboCop::Cop::Corrector.new(@processed_source.buffer, cop.corrections)
-        new_source = corrector.rewrite
+        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)
 
         expected_annotations = AnnotatedSource.parse(source)
         actual_annotations =
-          expected_annotations.with_offense_annotations(cop.offenses)
+          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*\^+ /.freeze
+        ANNOTATION_PATTERN = /\A\s*(\^+|\^{}) /.freeze
+        ABBREV = "[...]\n"
 
         # @param annotated_source [String] string passed to the matchers
         #
@@ -192,6 +209,7 @@ module RuboCop
               source << source_line
             end
           end
+          annotations.each { |a| a[0] = 1 } if source.empty?
 
           new(source, annotations)
         end
@@ -207,6 +225,27 @@ module RuboCop
           @annotations = annotations.sort.freeze
         end
 
+        def ==(other)
+          other.is_a?(self.class) &&
+            other.lines == lines &&
+            match_annotations?(other)
+        end
+
+        # Dirty hack: expectations with [...] are rewritten when they match
+        # This way the diff is clean.
+        def match_annotations?(other)
+          annotations.zip(other.annotations) do |(_actual_line, actual_annotation),
+                                                 (_expected_line, expected_annotation)|
+            if expected_annotation&.end_with?(ABBREV)
+              if actual_annotation.start_with?(expected_annotation[0...-ABBREV.length])
+                expected_annotation.replace(actual_annotation)
+              end
+            end
+          end
+
+          annotations == other.annotations
+        end
+
         # Construct annotated source string (like what we parse)
         #
         # Reconstruct a deterministic annotated source string. This is
@@ -239,6 +278,7 @@ module RuboCop
 
           reconstructed.join
         end
+        alias inspect to_s
 
         # Return the plain source code without annotations
         #
@@ -257,6 +297,7 @@ module RuboCop
             offenses.map do |offense|
               indent     = ' ' * offense.column
               carets     = '^' * offense.column_length
+              carets     = '^{}' if offense.column_length.zero?
 
               [offense.line, "#{indent}#{carets} #{offense.message}\n"]
             end
@@ -264,7 +305,7 @@ module RuboCop
           self.class.new(lines, offense_annotations)
         end
 
-        private
+        protected
 
         attr_reader :lines, :annotations
       end