rbhint 0.85.1.rc2 → 0.87.1.rc1

data/lib/rubocop/cop/utils/format_string.rb

@@ -41,8 +41,7 @@ module RuboCop
         #
         # @see https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-format
         class FormatSequence
-          attr_reader :begin_pos, :end_pos
-          attr_reader :flags, :width, :precision, :name, :type
+          attr_reader :begin_pos, :end_pos, :flags, :width, :precision, :name, :type
 
           def initialize(match)
             @source = match[0]

data/lib/rubocop/cop/variable_force/variable.rb

@@ -42,10 +42,10 @@ module RuboCop
         def reference!(node)
           reference = Reference.new(node, @scope)
           @references << reference
-          consumed_branches = Set.new
+          consumed_branches = nil
 
           @assignments.reverse_each do |assignment|
-            next if consumed_branches.include?(assignment.branch)
+            next if consumed_branches&.include?(assignment.branch)
 
             assignment.reference!(node) unless assignment.run_exclusively_with?(reference)
 
@@ -58,7 +58,9 @@ module RuboCop
 
             break if !assignment.branch || assignment.branch == reference.branch
 
-            consumed_branches << assignment.branch unless assignment.branch.may_run_incompletely?
+            unless assignment.branch.may_run_incompletely?
+              (consumed_branches ||= Set.new) << assignment.branch
+            end
           end
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity

data/lib/rubocop/file_finder.rb

@@ -20,12 +20,12 @@ module RuboCop
       end
     end
 
-    def find_files_upwards(filename, start_dir)
-      files = []
+    def find_last_file_upwards(filename, start_dir)
+      last_file = nil
       traverse_files_upwards(filename, start_dir) do |file|
-        files << file
+        last_file = file
       end
-      files
+      last_file
     end
 
     private

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -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/name_similarity.rb

@@ -22,9 +22,7 @@ module RuboCop
       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)
@@ -54,21 +54,6 @@ module RuboCop
       %r{\A([A-Z]:)?/}i.match?(path)
     end
 
-    def self.pwd
-      @pwd ||= Dir.pwd
-    end
-
-    def self.reset_pwd
-      @pwd = nil
-    end
-
-    def self.chdir(dir, &block)
-      reset_pwd
-      Dir.chdir(dir, &block)
-    ensure
-      reset_pwd
-    end
-
     def hidden_file_in_not_hidden_dir?(pattern, path)
       File.fnmatch?(
         pattern, path,

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,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

@@ -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

@@ -73,25 +73,37 @@ module RuboCop
     #   expect_no_corrections
     #
     # If your code has variables of different lengths, you can use `%{foo}`,
-    # `^{foo}`, and `_{foo}` to format your template:
+    # `^{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 value is redundant.
+    #         _{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)
@@ -100,7 +112,7 @@ module RuboCop
       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 = {}
@@ -118,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)
@@ -132,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
@@ -145,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)
@@ -160,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
         #
@@ -217,6 +224,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
@@ -249,6 +277,7 @@ module RuboCop
 
           reconstructed.join
         end
+        alias inspect to_s
 
         # Return the plain source code without annotations
         #
@@ -267,6 +296,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
@@ -274,7 +304,7 @@ module RuboCop
           self.class.new(lines, offense_annotations)
         end
 
-        private
+        protected
 
         attr_reader :lines, :annotations
       end

data/lib/rubocop/rspec/shared_contexts.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'tmpdir'
-require 'fileutils'
 
 RSpec.shared_context 'isolated environment', :isolated_environment do
   around do |example|
@@ -25,7 +24,7 @@ RSpec.shared_context 'isolated environment', :isolated_environment do
         working_dir = File.join(tmpdir, 'work')
         Dir.mkdir(working_dir)
 
-        RuboCop::PathUtil.chdir(working_dir) do
+        Dir.chdir(working_dir) do
           example.run
         end
       ensure
@@ -45,11 +44,11 @@ RSpec.shared_context 'config', :config do # rubocop:disable Metrics/BlockLength
   let(:source) { 'code = {some: :ruby}' }
 
   let(:cop_class) do
-    if described_class.is_a?(Class) && described_class < RuboCop::Cop::Cop
-      described_class
-    else
-      RuboCop::Cop::Cop
+    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) { {} }
@@ -95,8 +94,9 @@ RSpec.shared_context 'config', :config do # rubocop:disable Metrics/BlockLength
   end
 
   let(:cop) do
-    cop_class.new(config, cop_options)
-             .tap { |cop| cop.processed_source = processed_source }
+    cop_class.new(config, cop_options).tap do |cop|
+      cop.send :begin_investigation, processed_source
+    end
   end
 end