rubocop 1.36.0 → 1.39.0

data/lib/rubocop/cop/style/redundant_regexp_character_class.rb

@@ -74,7 +74,7 @@ module RuboCop
 
           non_redundant =
             whitespace_in_free_space_mode?(node, class_elem) ||
-            backslash_b?(class_elem) ||
+            backslash_b?(class_elem) || backslash_zero?(class_elem) ||
             requires_escape_outside_char_class?(class_elem)
 
           !non_redundant
@@ -104,6 +104,13 @@ module RuboCop
           elem == '\b'
         end
 
+        def backslash_zero?(elem)
+          # See https://github.com/rubocop/rubocop/issues/11067 for details - in short "\0" != "0" -
+          # the former means an Unicode code point `"\u0000"`, the latter a number character `"0"`.
+          # Similarly "\032" means "\u001A". Other numbers starting with "\0" can also be mentioned.
+          elem == '\0'
+        end
+
         def requires_escape_outside_char_class?(elem)
           REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS.include?(elem)
         end

data/lib/rubocop/cop/style/redundant_regexp_escape.rb

@@ -44,7 +44,7 @@ module RuboCop
 
         def on_regexp(node)
           each_escape(node) do |char, index, within_character_class|
-            next if allowed_escape?(node, char, within_character_class)
+            next if allowed_escape?(node, char, index, within_character_class)
 
             location = escape_range_at_index(node, index)
 
@@ -56,7 +56,7 @@ module RuboCop
 
         private
 
-        def allowed_escape?(node, char, within_character_class)
+        def allowed_escape?(node, char, index, within_character_class)
           # Strictly speaking a few single-letter metachars are currently
           # unnecessary to "escape", e.g. i, E, F, but enumerating them is
           # rather difficult, and their behavior could change over time with
@@ -65,12 +65,21 @@ module RuboCop
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
 
           if within_character_class
-            ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
+            ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char) &&
+              !char_class_begins_or_ends_with_escaped_hyphen?(node, index)
           else
             ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
           end
         end
 
+        def char_class_begins_or_ends_with_escaped_hyphen?(node, index)
+          # The hyphen character is allowed to be escaped within a character class
+          # but it's not necessry to escape hyphen if it's the first or last character
+          # within the character class. This method checks if that's the case.
+          # e.g. "[0-9\\-]" or "[\\-0-9]" would return true
+          node.source[index] == '[' || node.source[index + 3] == ']'
+        end
+
         def delimiter?(node, char)
           delimiters = [node.loc.begin.source[-1], node.loc.end.source[0]]
 

data/lib/rubocop/cop/style/redundant_string_escape.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant escapes in string literals.
+      #
+      # @example
+      #   # bad - no need to escape # without following {/$/@
+      #   "\#foo"
+      #
+      #   # bad - no need to escape single quotes inside double quoted string
+      #   "\'foo\'"
+      #
+      #   # bad - heredocs are also checked for unnecessary escapes
+      #   <<~STR
+      #     \#foo \"foo\"
+      #   STR
+      #
+      #   # good
+      #   "#foo"
+      #
+      #   # good
+      #   "\#{no_interpolation}"
+      #
+      #   # good
+      #   "'foo'"
+      #
+      #   # good
+      #   "foo\
+      #   bar"
+      #
+      #   # good
+      #   <<~STR
+      #     #foo "foo"
+      #   STR
+      class RedundantStringEscape < Base
+        include MatchRange
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Redundant escape of %<char>s inside string literal.'
+
+        def on_str(node)
+          return if node.parent&.regexp_type? || node.parent&.xstr_type? || node.character_literal?
+
+          str_contents_range = str_contents_range(node)
+
+          each_match_range(str_contents_range, /(\\.)/) do |range|
+            next if allowed_escape?(node, range.resize(3))
+
+            add_offense(range) do |corrector|
+              corrector.remove_leading(range, 1)
+            end
+          end
+        end
+
+        private
+
+        def message(range)
+          format(MSG, char: range.source.chars.last)
+        end
+
+        def str_contents_range(node)
+          if heredoc?(node)
+            node.loc.heredoc_body
+          elsif begin_loc_present?(node)
+            contents_range(node)
+          else
+            node.loc.expression
+          end
+        end
+
+        def begin_loc_present?(node)
+          # e.g. a __FILE__ literal has no begin loc so we can't query if it's nil
+          node.loc.to_hash.key?(:begin) && !node.loc.begin.nil?
+        end
+
+        def allowed_escape?(node, range)
+          escaped = range.source[(1..-1)]
+
+          # Inside a single-quoted string, escapes (except \\ and \') do not have special meaning,
+          # and so are not redundant, as they are a literal backslash.
+          return true if interpolation_not_enabled?(node)
+
+          # Strictly speaking a few single-letter chars are currently unnecessary to "escape", e.g.
+          # d, but enumerating them is rather difficult, and their behavior could change over time
+          # with different versions of Ruby so that e.g. /\d/ != /d/
+          return true if /[\n\\[[:alnum:]]]/.match?(escaped[0])
+
+          return true if escaped[0] == ' ' && percent_array_literal?(node)
+
+          return true if disabling_interpolation?(range)
+          return true if delimiter?(node, escaped[0])
+
+          false
+        end
+
+        def interpolation_not_enabled?(node)
+          single_quoted?(node) ||
+            percent_w_literal?(node) ||
+            percent_q_literal?(node) ||
+            heredoc_with_disabled_interpolation?(node)
+        end
+
+        def single_quoted?(node)
+          delimiter?(node, "'")
+        end
+
+        def percent_q_literal?(node)
+          if literal_in_interpolated_or_multiline_string?(node)
+            percent_q_literal?(node.parent)
+          else
+            node.source.start_with?('%q')
+          end
+        end
+
+        def array_literal?(node, prefix)
+          if literal_in_interpolated_or_multiline_string?(node)
+            array_literal?(node.parent, prefix)
+          else
+            node.parent&.array_type? && node.parent.source.start_with?(prefix)
+          end
+        end
+
+        def percent_w_literal?(node)
+          array_literal?(node, '%w')
+        end
+
+        def percent_w_upper_literal?(node)
+          array_literal?(node, '%W')
+        end
+
+        def percent_array_literal?(node)
+          (percent_w_literal?(node) || percent_w_upper_literal?(node))
+        end
+
+        def heredoc_with_disabled_interpolation?(node)
+          if heredoc?(node)
+            node.loc.expression.source.end_with?("'")
+          elsif node.parent&.dstr_type?
+            heredoc_with_disabled_interpolation?(node.parent)
+          else
+            false
+          end
+        end
+
+        def heredoc?(node)
+          (node.str_type? || node.dstr_type?) && node.heredoc?
+        end
+
+        def delimiter?(node, char)
+          return false if heredoc?(node)
+
+          if literal_in_interpolated_or_multiline_string?(node) || percent_array_literal?(node)
+            return delimiter?(node.parent, char)
+          end
+
+          delimiters = [node.loc.begin.source[-1], node.loc.end.source[0]]
+
+          delimiters.include?(char)
+        end
+
+        def literal_in_interpolated_or_multiline_string?(node)
+          node.str_type? && !begin_loc_present?(node) && node.parent&.dstr_type?
+        end
+
+        def disabling_interpolation?(range)
+          # Allow \#{foo}, \#$foo, \#@foo, and \#@@foo
+          # for escaping local, global, instance and class variable interpolations
+          return true if range.source.match?(/\A\\#[{$@]/)
+
+          # Also allow #\{foo}, #\$foo, #\@foo and #\@@foo
+          return true if range.adjust(begin_pos: -2).source.match?(/\A[^\\]#\\[{$@]/)
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/rescue_modifier.rb

@@ -9,7 +9,7 @@ module RuboCop
       # reasons:
       #
       # * The syntax of modifier form `rescue` can be misleading because it
-      #   might led us to believe that `rescue` handles the given exception
+      #   might lead us to believe that `rescue` handles the given exception
       #   but it actually rescue all exceptions to return the given rescue
       #   block. In this case, value returned by handle_error or
       #   SomeException.

data/lib/rubocop/cop/style/static_class.rb

@@ -44,18 +44,49 @@ module RuboCop
       #   end
       #
       class StaticClass < Base
+        include RangeHelp
         include VisibilityHelp
+        extend AutoCorrector
 
         MSG = 'Prefer modules to classes with only class methods.'
 
         def on_class(class_node)
           return if class_node.parent_class
+          return unless class_convertible_to_module?(class_node)
 
-          add_offense(class_node) if class_convertible_to_module?(class_node)
+          add_offense(class_node) do |corrector|
+            autocorrect(corrector, class_node)
+          end
         end
 
         private
 
+        def autocorrect(corrector, class_node)
+          corrector.replace(class_node.loc.keyword, 'module')
+          corrector.insert_after(class_node.loc.name, "\nmodule_function\n")
+
+          class_elements(class_node).each do |node|
+            if node.defs_type?
+              autocorrect_def(corrector, node)
+            elsif node.sclass_type?
+              autocorrect_sclass(corrector, node)
+            end
+          end
+        end
+
+        def autocorrect_def(corrector, node)
+          corrector.remove(
+            range_between(node.receiver.source_range.begin_pos, node.loc.name.begin_pos)
+          )
+        end
+
+        def autocorrect_sclass(corrector, node)
+          corrector.remove(
+            range_between(node.loc.keyword.begin_pos, node.identifier.source_range.end_pos)
+          )
+          corrector.remove(node.loc.end)
+        end
+
         def class_convertible_to_module?(class_node)
           nodes = class_elements(class_node)
           return false if nodes.empty?

data/lib/rubocop/cop/style/symbol_array.rb

@@ -65,6 +65,8 @@ module RuboCop
         end
 
         def build_bracketed_array(node)
+          return '[]' if node.children.empty?
+
           syms = node.children.map do |c|
             if c.dsym_type?
               string_literal = to_string_literal(c.source)

data/lib/rubocop/cop/style/symbol_proc.rb

@@ -82,7 +82,7 @@ module RuboCop
       #   # bad
       #   something.map { |s| s.upcase }
       #
-      # @example AllowedPatterns: [/map/] (default)
+      # @example AllowedPatterns: ['map'] (default)
       #   # good
       #   something.map { |s| s.upcase }
       #

data/lib/rubocop/cop/style/word_array.rb

@@ -83,6 +83,8 @@ module RuboCop
         end
 
         def build_bracketed_array(node)
+          return '[]' if node.children.empty?
+
           words = node.children.map do |word|
             if word.dstr_type?
               string_literal = to_string_literal(word.source)

data/lib/rubocop/cop/team.rb

@@ -40,10 +40,9 @@ module RuboCop
 
       # @return [Array<Cop::Cop>]
       def self.mobilize_cops(cop_classes, config, options = {})
-        cop_classes = Registry.new(cop_classes.to_a) unless cop_classes.is_a?(Registry)
-        only = options.fetch(:only, [])
-        safe = options.fetch(:safe, false)
-        cop_classes.enabled(config, only, only_safe: safe).map do |cop_class|
+        cop_classes = Registry.new(cop_classes.to_a, options) unless cop_classes.is_a?(Registry)
+
+        cop_classes.enabled(config).map do |cop_class|
           cop_class.new(config, options)
         end
       end

data/lib/rubocop/cop/util.rb

@@ -122,7 +122,7 @@ module RuboCop
           string.inspect
         else
           # In a single-quoted strings, double quotes don't need to be escaped
-          "'#{string.gsub('\"', '"').gsub('\\') { '\\\\' }}'"
+          "'#{string.gsub('\\') { '\\\\' }.gsub('\"', '"')}'"
         end
       end
 

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

@@ -109,7 +109,7 @@ module RuboCop
         end
 
         def accessible_variables
-          scope_stack.reverse_each.each_with_object([]) do |scope, variables|
+          scope_stack.reverse_each.with_object([]) do |scope, variables|
             variables.concat(scope.variables.values)
             break variables unless scope.node.block_type?
           end

data/lib/rubocop/cops_documentation_generator.rb

@@ -185,7 +185,8 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   def to_table(header, content)
     table = ['|===', "| #{header.join(' | ')}\n\n"].join("\n")
     marked_contents = content.map do |plain_content|
-      plain_content.map { |c| "| #{c}" }.join("\n")
+      # Escape `|` with backslash to prevent the regexp `|` is not used as a table separator.
+      plain_content.map { |c| "| #{c.gsub(/\|/, '\|')}" }.join("\n")
     end
     table << marked_contents.join("\n\n")
     table << "\n|===\n"

data/lib/rubocop/ext/processed_source.rb

@@ -4,6 +4,8 @@ module RuboCop
   module Ext
     # Extensions to AST::ProcessedSource for our cached comment_config
     module ProcessedSource
+      attr_accessor :registry, :config
+
       def comment_config
         @comment_config ||= CommentConfig.new(self)
       end

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -70,7 +70,9 @@ module RuboCop
 
         command += ' --auto-gen-only-exclude' if @options[:auto_gen_only_exclude]
 
-        if @exclude_limit_option
+        if no_exclude_limit?
+          command += ' --no-exclude-limit'
+        elsif @exclude_limit_option
           command += format(' --exclude-limit %<limit>d', limit: Integer(@exclude_limit_option))
         end
         command += ' --no-offense-counts' unless show_offense_counts?
@@ -187,7 +189,7 @@ module RuboCop
         return unless cfg.empty?
 
         offending_files = @files_with_offenses[cop_name].sort
-        if offending_files.count > @exclude_limit
+        if !no_exclude_limit? && offending_files.count > @exclude_limit
           output_buffer.puts '  Enabled: false'
         else
           output_exclude_list(output_buffer, offending_files, cop_name)
@@ -245,6 +247,10 @@ module RuboCop
       def safe_autocorrect?(config)
         config.fetch('Safe', true) && config.fetch('SafeAutoCorrect', true)
       end
+
+      def no_exclude_limit?
+        @options[:no_exclude_limit] == false
+      end
     end
   end
 end

data/lib/rubocop/formatter/offense_count_formatter.rb

@@ -12,13 +12,14 @@ module RuboCop
     # 26  LineLength
     # 3   OneLineConditional
     # --
-    # 29  Total
+    # 29  Total in 5 files
     class OffenseCountFormatter < BaseFormatter
       attr_reader :offense_counts
 
       def started(target_files)
         super
         @offense_counts = Hash.new(0)
+        @offending_files_count = 0
         @style_guide_links = {}
 
         return unless output.tty?
@@ -43,26 +44,28 @@ module RuboCop
         if options[:display_style_guide]
           offenses.each { |o| @style_guide_links[o.cop_name] ||= o.message[/ \(http\S+\)\Z/] }
         end
+        @offending_files_count += 1 unless offenses.empty?
         @progressbar.increment if instance_variable_defined?(:@progressbar)
       end
 
       def finished(_inspected_files)
-        report_summary(@offense_counts)
+        report_summary(@offense_counts, @offending_files_count)
       end
 
       # rubocop:disable Metrics/AbcSize
-      def report_summary(offense_counts)
+      def report_summary(offense_counts, offending_files_count)
         per_cop_counts = ordered_offense_counts(offense_counts)
         total_count = total_offense_count(offense_counts)
 
         output.puts
 
+        column_width = total_count.to_s.length + 2
         per_cop_counts.each do |cop_name, count|
-          output.puts "#{count.to_s.ljust(total_count.to_s.length + 2)}#{cop_name}" \
+          output.puts "#{count.to_s.ljust(column_width)}#{cop_name}" \
                       "#{@style_guide_links[cop_name]}\n"
         end
         output.puts '--'
-        output.puts "#{total_count}  Total"
+        output.puts "#{total_count}  Total in #{offending_files_count} files"
 
         output.puts
       end

data/lib/rubocop/formatter/worst_offenders_formatter.rb

@@ -12,7 +12,7 @@ module RuboCop
     # 26  this/file/is/really/bad.rb
     # 3   just/ok.rb
     # --
-    # 29  Total
+    # 29  Total in 2 files
     class WorstOffendersFormatter < BaseFormatter
       attr_reader :offense_counts
 
@@ -36,14 +36,17 @@ module RuboCop
       def report_summary(offense_counts)
         per_file_counts = ordered_offense_counts(offense_counts)
         total_count = total_offense_count(offense_counts)
+        file_count = per_file_counts.size
 
         output.puts
 
+        column_width = total_count.to_s.length + 2
         per_file_counts.each do |file_name, count|
-          output.puts "#{count.to_s.ljust(total_count.to_s.length + 2)}#{file_name}\n"
+          output.puts "#{count.to_s.ljust(column_width)}#{file_name}\n"
         end
+
         output.puts '--'
-        output.puts "#{total_count}  Total"
+        output.puts "#{total_count}  Total in #{file_count} files"
 
         output.puts
       end

data/lib/rubocop/options.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require 'optparse'
-require 'shellwords'
+require_relative 'arguments_env'
+require_relative 'arguments_file'
 
 module RuboCop
   class IncorrectCopNameError < StandardError; end
@@ -24,7 +25,10 @@ module RuboCop
     end
 
     def parse(command_line_args)
+      args_from_file = ArgumentsFile.read_as_arguments
+      args_from_env = ArgumentsEnv.read_as_arguments
       args = args_from_file.concat(args_from_env).concat(command_line_args)
+
       define_options.parse!(args)
 
       @validator.validate_compatibility
@@ -45,18 +49,6 @@ module RuboCop
 
     private
 
-    def args_from_file
-      if File.exist?('.rubocop') && !File.directory?('.rubocop')
-        File.read('.rubocop').shellsplit
-      else
-        []
-      end
-    end
-
-    def args_from_env
-      Shellwords.split(ENV.fetch('RUBOCOP_OPTS', ''))
-    end
-
     def define_options
       OptionParser.new do |opts|
         opts.banner = rainbow.wrap('Usage: rubocop [options] [file1, file2, ...]').bright
@@ -73,7 +65,7 @@ module RuboCop
     end
 
     def add_check_options(opts) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      section(opts, 'Basic Options') do
+      section(opts, 'Basic Options') do # rubocop:disable Metrics/BlockLength
         option(opts, '-l', '--lint') do
           @options[:only] ||= []
           @options[:only] << 'Lint'
@@ -98,6 +90,7 @@ module RuboCop
         option(opts, '--force-default-config')
         option(opts, '-s', '--stdin FILE')
         option(opts, '-P', '--[no-]parallel')
+        option(opts, '--raise-cop-error')
         add_severity_option(opts)
       end
     end
@@ -169,6 +162,7 @@ module RuboCop
         end
 
         option(opts, '--exclude-limit COUNT') { @validator.validate_exclude_limit_option }
+        option(opts, '--no-exclude-limit')
 
         option(opts, '--[no-]offense-counts')
         option(opts, '--[no-]auto-gen-only-exclude')
@@ -400,6 +394,12 @@ module RuboCop
     end
 
     def validate_autocorrect
+      if @options.key?(:safe_autocorrect) && @options.key?(:autocorrect_all)
+        message = Rainbow(<<~MESSAGE).red
+          Error: Both safe and unsafe autocorrect options are specified, use only one.
+        MESSAGE
+        raise OptionArgumentError, message
+      end
       return if @options.key?(:autocorrect)
       return unless @options.key?(:disable_uncorrectable)
 
@@ -497,6 +497,7 @@ module RuboCop
       disable_uncorrectable:            ['Used with --autocorrect to annotate any',
                                          'offenses that do not support autocorrect',
                                          'with `rubocop:todo` comments.'],
+      no_exclude_limit:                 ['Do not set the limit for how many files to exclude.'],
       force_exclusion:                  ['Any files excluded by `Exclude` in configuration',
                                          'files will be excluded, even if given explicitly',
                                          'as arguments.'],
@@ -589,7 +590,10 @@ module RuboCop
       restart_server:                   'Restart server process.',
       start_server:                     'Start server process.',
       stop_server:                      'Stop server process.',
-      server_status:                    'Show server status.'
+      server_status:                    'Show server status.',
+      raise_cop_error:                  ['Raise cop-related errors with cause and location.',
+                                         'This is used to prevent cops from failing silently.',
+                                         'Default is false.']
     }.freeze
   end
 end

data/lib/rubocop/rspec/cop_helper.rb

@@ -28,7 +28,27 @@ module CopHelper
       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
+      cops = configuration.keys.map { |cop| RuboCop::Cop::Registry.global.find_by_cop_name(cop) }
+      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)

data/lib/rubocop/rspec/shared_contexts.rb

@@ -2,7 +2,7 @@
 
 require 'tmpdir'
 
-RSpec.shared_context 'isolated environment' do
+RSpec.shared_context 'isolated environment' do # rubocop:disable Metrics/BlockLength
   around do |example|
     Dir.mktmpdir do |tmpdir|
       original_home = Dir.home
@@ -36,6 +36,19 @@ RSpec.shared_context 'isolated environment' do
       end
     end
   end
+
+  if RuboCop.const_defined?(:Server)
+    around do |example|
+      RuboCop::Server::Cache.cache_root_path = nil
+      RuboCop::Server::Cache.instance_variable_set(:@project_dir_cache_key, nil)
+      begin
+        example.run
+      ensure
+        RuboCop::Server::Cache.cache_root_path = nil
+        RuboCop::Server::Cache.instance_variable_set(:@project_dir_cache_key, nil)
+      end
+    end
+  end
 end
 
 RSpec.shared_context 'maintain registry' do