rubocop 1.18.1 → 1.22.3

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

@@ -5,9 +5,18 @@ module RuboCop
     module Style
       #
       # This cop looks for uses of Perl-style global variables.
+      # Correcting to global variables in the 'English' library
+      # will add a require statement to the top of the file if
+      # enabled by RequireEnglish config.
+      #
+      # @safety
+      #   Autocorrection is marked as unsafe because if `RequireEnglish` is not
+      #   true, replacing perl-style variables with english variables will break.
       #
       # @example EnforcedStyle: use_english_names (default)
       #   # good
+      #   require 'English' # or this could be in another file.
+      #
       #   puts $LOAD_PATH
       #   puts $LOADED_FEATURES
       #   puts $PROGRAM_NAME
@@ -50,6 +59,8 @@ module RuboCop
       #
       class SpecialGlobalVars < Base
         include ConfigurableEnforcedStyle
+        include RangeHelp
+        include RequireLibrary
         extend AutoCorrector
 
         MSG_BOTH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
@@ -90,6 +101,8 @@ module RuboCop
         # Anything *not* in this set is provided by the English library.
         NON_ENGLISH_VARS = Set.new(%i[$LOAD_PATH $LOADED_FEATURES $PROGRAM_NAME ARGV]).freeze
 
+        LIBRARY_NAME = 'English'
+
         def on_gvar(node)
           global_var, = *node
 
@@ -117,6 +130,8 @@ module RuboCop
         def autocorrect(corrector, node, global_var)
           node = node.parent while node.parent&.begin_type? && node.parent.children.one?
 
+          ensure_required(corrector, node, LIBRARY_NAME) if should_require_english?(global_var)
+
           corrector.replace(node, replacement(node, global_var))
         end
 
@@ -172,6 +187,16 @@ module RuboCop
 
           "{#{preferred_name}}"
         end
+
+        def add_require_english?
+          cop_config['RequireEnglish']
+        end
+
+        def should_require_english?(global_var)
+          style == :use_english_names &&
+            add_require_english? &&
+            !NON_ENGLISH_VARS.include?(preferred_names(global_var).first)
+        end
       end
     end
   end

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

@@ -7,9 +7,10 @@ module RuboCop
       # replaced with a module. Classes should be used only when it makes sense to create
       # instances out of them.
       #
-      # This cop is marked as unsafe, because it is possible that this class is a parent
-      # for some other subclass, monkey-patched with instance methods or
-      # a dummy instance is instantiated from it somewhere.
+      # @safety
+      #   This cop is unsafe, because it is possible that this class is a parent
+      #   for some other subclass, monkey-patched with instance methods or
+      #   a dummy instance is instantiated from it somewhere.
       #
       # @example
       #   # bad
@@ -60,8 +61,7 @@ module RuboCop
           return false if nodes.empty?
 
           nodes.all? do |node|
-            node_visibility(node) == :public &&
-              node.defs_type? ||
+            (node_visibility(node) == :public && node.defs_type?) ||
               sclass_convertible_to_module?(node) ||
               node.equals_asgn? ||
               extend_call?(node)

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

@@ -5,8 +5,10 @@ module RuboCop
     module Style
       # Checks for uses of `String#split` with empty string or regexp literal argument.
       #
-      # This cop is marked as unsafe. But probably it's quite unlikely that some other class would
-      # define a `split` method that takes exactly the same arguments.
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is actually a string. If another class has a `split` method with
+      #   different behaviour, it would be registered as a false positive.
       #
       # @example
       #   # bad

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

@@ -23,6 +23,10 @@ module RuboCop
       # This is useful when the receiver is some expression that returns string like `Pathname`
       # instead of a string literal.
       #
+      # @safety
+      #   This cop is unsafe in `aggressive` mode, as it cannot be guaranteed that
+      #   the receiver is actually a string, which can result in a false positive.
+      #
       # @example Mode: aggressive (default)
       #   # bad
       #   email_with_name = user.name + ' <' + user.email + '>'
@@ -93,7 +97,7 @@ module RuboCop
 
         def offensive_for_mode?(receiver_node)
           mode = cop_config['Mode'].to_sym
-          mode == :aggressive || mode == :conservative && receiver_node.str_type?
+          mode == :aggressive || (mode == :conservative && receiver_node.str_type?)
         end
 
         def line_end_concatenation?(node)

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

@@ -6,6 +6,10 @@ module RuboCop
       # This cop checks for the use of strings as keys in hashes. The use of
       # symbols is preferred instead.
       #
+      # @safety
+      #   This cop is unsafe because while symbols are preferred for hash keys,
+      #   there are instances when string keys are required.
+      #
       # @example
       #   # bad
       #   { 'one' => 1, 'two' => 2, 'three' => 3 }

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

@@ -5,6 +5,10 @@ module RuboCop
     module Style
       # This cop checks for inheritance from Struct.new.
       #
+      # @safety
+      #   Auto-correction is unsafe because it will change the inheritance
+      #   tree (e.g. return value of `Module#ancestors`) of the constant.
+      #
       # @example
       #   # bad
       #   class Person < Struct.new(:first_name, :last_name)

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

@@ -4,8 +4,10 @@ module RuboCop
   module Cop
     module Style
       # This cop enforces the use of shorthand-style swapping of 2 variables.
-      # Its autocorrection is marked as unsafe, because it can erroneously remove
-      # the temporary variable which is used later.
+      #
+      # @safety
+      #   Autocorrection is unsafe, because the temporary variable used to
+      #   swap variables will be removed, but may be referred to elsewhere.
       #
       # @example
       #   # bad

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

@@ -35,7 +35,7 @@ module RuboCop
         extend AutoCorrector
 
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'
-        ARRAY_MSG = 'Use `[]` for an array of symbols.'
+        ARRAY_MSG = 'Use `%<prefer>s` for an array of symbols.'
 
         class << self
           attr_accessor :largest_brackets
@@ -60,7 +60,7 @@ module RuboCop
           end
         end
 
-        def correct_bracketed(corrector, node)
+        def build_bracketed_array(node)
           syms = node.children.map do |c|
             if c.dsym_type?
               string_literal = to_string_literal(c.source)
@@ -71,7 +71,7 @@ module RuboCop
             end
           end
 
-          corrector.replace(node, "[#{syms.join(', ')}]")
+          "[#{syms.join(', ')}]"
         end
 
         def to_symbol_literal(string)

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

@@ -8,6 +8,32 @@ module RuboCop
       # If you prefer a style that allows block for method with arguments,
       # please set `true` to `AllowMethodsWithArguments`.
       #
+      # @safety
+      #   This cop is unsafe because `proc`s and blocks work differently
+      #   when additional arguments are passed in. A block will silently
+      #   ignore additional arguments, but a `proc` will raise
+      #   an `ArgumentError`.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class Foo
+      #     def bar
+      #       :bar
+      #     end
+      #   end
+      #
+      #   def call(options = {}, &block)
+      #     block.call(Foo.new, options)
+      #   end
+      #
+      #   call { |x| x.bar }
+      #   #=> :bar
+      #   call(&:bar)
+      #   # ArgumentError: wrong number of arguments (given 1, expected 0)
+      #   ----
+      #
       # @example
       #   # bad
       #   something.map { |s| s.upcase }

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

@@ -8,6 +8,25 @@ module RuboCop
       # that comma to be present. Blocks with more than one argument never
       # require a trailing comma.
       #
+      # @safety
+      #   This cop is unsafe because a trailing comma can indicate there are
+      #   more parameters that are not used.
+      #
+      #   For example:
+      #   [source,ruby]
+      #   ----
+      #   # with a trailing comma
+      #   {foo: 1, bar: 2, baz: 3}.map {|key,| key }
+      #   #=> [:foo, :bar, :baz]
+      #
+      #   # without a trailing comma
+      #   {foo: 1, bar: 2, baz: 3}.map {|key| key }
+      #   #=> [[:foo, 1], [:bar, 2], [:baz, 3]]
+      #   ----
+      #
+      #   This can be fixed by replacing the trailing comma with a placeholder
+      #   argument (such as `|key, _value|`).
+      #
       # @example
       #   # bad
       #   add { |foo, bar,| foo + bar }

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

@@ -192,7 +192,7 @@ module RuboCop
 
         def allowed_method_name?(node)
           allowed_method_names.include?(node.method_name) ||
-            exact_name_match? && !names_match?(node)
+            (exact_name_match? && !names_match?(node))
         end
 
         def allowed_writer?(method_name)

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

@@ -9,6 +9,9 @@ module RuboCop
       # Alternatively, it can check for uses of the %w() syntax, in projects
       # which do not want to include that syntax.
       #
+      # NOTE: When using the `percent` style, %w() arrays containing a space
+      # will be registered as offenses.
+      #
       # Configuration option: MinSize
       # If set, arrays with fewer elements than this value will not trigger the
       # cop. For example, a `MinSize` of `3` will not enforce a style on an
@@ -21,12 +24,18 @@ module RuboCop
       #   # bad
       #   ['foo', 'bar', 'baz']
       #
+      #   # bad (contains spaces)
+      #   %w[foo\ bar baz\ quux]
+      #
       # @example EnforcedStyle: brackets
       #   # good
       #   ['foo', 'bar', 'baz']
       #
       #   # bad
       #   %w[foo bar baz]
+      #
+      #   # good (contains spaces)
+      #   ['foo bar', 'baz quux']
       class WordArray < Base
         include ArrayMinSize
         include ArraySyntax
@@ -35,7 +44,7 @@ module RuboCop
         extend AutoCorrector
 
         PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'
-        ARRAY_MSG = 'Use `[]` for an array of words.'
+        ARRAY_MSG = 'Use `%<prefer>s` for an array of words.'
 
         class << self
           attr_accessor :largest_brackets
@@ -53,18 +62,27 @@ module RuboCop
 
         private
 
-        def complex_content?(strings)
+        def complex_content?(strings, complex_regex: word_regex)
           strings.any? do |s|
+            next unless s.str_content
+
             string = s.str_content.dup.force_encoding(::Encoding::UTF_8)
-            !string.valid_encoding? || !word_regex.match?(string) || / /.match?(string)
+            !string.valid_encoding? ||
+              (complex_regex && !complex_regex.match?(string)) ||
+              / /.match?(string)
           end
         end
 
+        def invalid_percent_array_contents?(node)
+          # Disallow %w() arrays that contain invalid encoding or spaces
+          complex_content?(node.values, complex_regex: false)
+        end
+
         def word_regex
           Regexp.new(cop_config['WordRegex'])
         end
 
-        def correct_bracketed(corrector, node)
+        def build_bracketed_array(node)
           words = node.children.map do |word|
             if word.dstr_type?
               string_literal = to_string_literal(word.source)
@@ -75,7 +93,7 @@ module RuboCop
             end
           end
 
-          corrector.replace(node, "[#{words.join(', ')}]")
+          "[#{words.join(', ')}]"
         end
       end
     end

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

@@ -7,6 +7,26 @@ module RuboCop
       # i.e. comparison operations where the order of expression is reversed.
       # eg. `5 == x`
       #
+      # @safety
+      #   This cop is unsafe because comparison operators can be defined
+      #   differently on different classes, and are not guaranteed to
+      #   have the same result if reversed.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class MyKlass
+      #     def ==(other)
+      #       true
+      #     end
+      #   end
+      #
+      #   obj = MyKlass.new
+      #   obj == 'string'   #=> true
+      #   'string' == obj   #=> false
+      #   ----
+      #
       # @example EnforcedStyle: forbid_for_all_comparison_operators (default)
       #   # bad
       #   99 == foo
@@ -58,14 +78,11 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Reverse the order of the operands `%<source>s`.'
-
         REVERSE_COMPARISON = { '<' => '>', '<=' => '>=', '>' => '<', '>=' => '<=' }.freeze
-
         EQUALITY_OPERATORS = %i[== !=].freeze
-
         NONCOMMUTATIVE_OPERATORS = %i[===].freeze
-
         PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
+        RESTRICT_ON_SEND = RuboCop::AST::Node::COMPARISON_OPERATORS
 
         # @!method file_constant_equal_program_name?(node)
         def_node_matcher :file_constant_equal_program_name?, <<~PATTERN
@@ -74,7 +91,7 @@ module RuboCop
 
         def on_send(node)
           return unless yoda_compatible_condition?(node)
-          return if equality_only? && non_equality_operator?(node) ||
+          return if (equality_only? && non_equality_operator?(node)) ||
                     file_constant_equal_program_name?(node)
 
           valid_yoda?(node) || add_offense(node) do |corrector|
@@ -102,8 +119,8 @@ module RuboCop
           lhs = node.receiver
           rhs = node.first_argument
 
-          return true if lhs.literal? && rhs.literal? ||
-                         !lhs.literal? && !rhs.literal? ||
+          return true if (lhs.literal? && rhs.literal?) ||
+                         (!lhs.literal? && !rhs.literal?) ||
                          interpolation?(lhs)
 
           enforce_yoda? ? lhs.literal? : rhs.literal?

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

@@ -9,6 +9,12 @@ module RuboCop
       # receiver.length < 1 and receiver.size == 0 that can be
       # replaced by receiver.empty? and !receiver.empty?.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   has an `empty?` method that is defined in terms of `length`. If there
+      #   is a non-standard class that redefines `length` or `empty?`, the cop
+      #   may register a false positive.
+      #
       # @example
       #   # bad
       #   [1, 2, 3].length == 0

data/lib/rubocop/cop/util.rb

@@ -46,8 +46,13 @@ module RuboCop
 
       def args_begin(node)
         loc = node.loc
-        selector =
-          node.super_type? || node.yield_type? ? loc.keyword : loc.selector
+        selector = if node.super_type? || node.yield_type?
+                     loc.keyword
+                   elsif node.def_type? || node.defs_type?
+                     loc.name
+                   else
+                     loc.selector
+                   end
         selector.end.resize(1)
       end
 
@@ -108,7 +113,8 @@ module RuboCop
         if needs_escaping?(string) && compatible_external_encoding_for?(string)
           string.inspect
         else
-          "'#{string.gsub('\\') { '\\\\' }}'"
+          # In a single-quoted strings, double quotes don't need to be escaped
+          "'#{string.gsub('\"', '"').gsub('\\') { '\\\\' }}'"
         end
       end
 
@@ -120,12 +126,22 @@ module RuboCop
         StringInterpreter.interpret(string)
       end
 
+      def line(node_or_range)
+        if node_or_range.respond_to?(:line)
+          node_or_range.line
+        elsif node_or_range.respond_to?(:loc)
+          node_or_range.loc.line
+        end
+      end
+
       def same_line?(node1, node2)
-        node1.respond_to?(:loc) && node2.respond_to?(:loc) && node1.loc.line == node2.loc.line
+        line1 = line(node1)
+        line2 = line(node2)
+        line1 && line2 && line1 == line2
       end
 
-      def indent(node)
-        ' ' * node.loc.column
+      def indent(node, offset: 0)
+        ' ' * (node.loc.column + offset)
       end
 
       def to_supported_styles(enforced_style)

data/lib/rubocop/cops_documentation_generator.rb

@@ -33,11 +33,12 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     cops.with_department(department).sort!
   end
 
-  def cops_body(cop, description, examples_objects, pars)
+  def cops_body(cop, description, examples_objects, safety_objects, pars) # rubocop:disable Metrics/AbcSize
     content = h2(cop.cop_name)
     content << required_ruby_version(cop)
     content << properties(cop)
     content << "#{description}\n"
+    content << safety_object(safety_objects) if safety_objects.any? { |s| !s.text.blank? }
     content << examples(examples_objects) if examples_objects.count.positive?
     content << configurations(pars)
     content << references(cop)
@@ -52,6 +53,16 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     end
   end
 
+  def safety_object(safety_object_objects)
+    safety_object_objects.each_with_object(h3('Safety').dup) do |safety_object, content|
+      next if safety_object.text.blank?
+
+      content << "\n" unless content.end_with?("\n\n")
+      content << safety_object.text
+      content << "\n"
+    end
+  end
+
   def required_ruby_version(cop)
     return '' unless cop.respond_to?(:required_minimum_ruby_version)
 
@@ -61,8 +72,8 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   # rubocop:disable Metrics/MethodLength
   def properties(cop)
     header = [
-      'Enabled by default', 'Safe', 'Supports autocorrection', 'VersionAdded',
-      'VersionChanged'
+      'Enabled by default', 'Safe', 'Supports autocorrection', 'Version Added',
+      'Version Changed'
     ]
     autocorrect = if cop.support_autocorrect?
                     "Yes#{' (Unsafe)' unless cop.new(config).safe_autocorrect?}"
@@ -217,12 +228,13 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     ]
     pars = cop_config.reject { |k| non_display_keys.include? k }
     description = 'No documentation'
-    examples_object = []
+    examples_object = safety_object = []
     cop_code(cop) do |code_object|
       description = code_object.docstring unless code_object.docstring.blank?
       examples_object = code_object.tags('example')
+      safety_object = code_object.tags('safety')
     end
-    cops_body(cop, description, examples_object, pars)
+    cops_body(cop, description, examples_object, safety_object, pars)
   end
 
   def cop_code(cop)

data/lib/rubocop/formatter/git_hub_actions_formatter.rb

@@ -33,7 +33,7 @@ module RuboCop
         output.printf(
           "\n::%<severity>s file=%<file>s,line=%<line>d,col=%<column>d::%<message>s\n",
           severity: github_severity(offense),
-          file: file,
+          file: PathUtil.smart_path(file),
           line: offense.line,
           column: offense.real_column,
           message: github_escape(offense.message)

data/lib/rubocop/magic_comment.rb

@@ -7,6 +7,11 @@ module RuboCop
   class MagicComment
     # @see https://git.io/vMC1C IRB's pattern for matching magic comment tokens
     TOKEN = /[[:alnum:]\-_]+/.freeze
+    KEYWORDS = {
+      encoding: '(?:en)?coding',
+      frozen_string_literal: 'frozen[_-]string[_-]literal',
+      shareable_constant_value: 'shareable[_-]constant[_-]value'
+    }.freeze
 
     # Detect magic comment format and pass it to the appropriate wrapper.
     #
@@ -15,8 +20,8 @@ module RuboCop
     # @return [RuboCop::MagicComment]
     def self.parse(comment)
       case comment
-      when EmacsComment::FORMAT then EmacsComment.new(comment)
-      when VimComment::FORMAT   then VimComment.new(comment)
+      when EmacsComment::REGEXP then EmacsComment.new(comment)
+      when VimComment::REGEXP   then VimComment.new(comment)
       else
         SimpleComment.new(comment)
       end
@@ -30,6 +35,10 @@ module RuboCop
       frozen_string_literal_specified? || encoding_specified? || shareable_constant_value_specified?
     end
 
+    def valid?
+      @comment.start_with?('#') && any?
+    end
+
     # Does the magic comment enable the frozen string literal feature.
     #
     # Test whether the frozen string literal value is `true`. Cannot
@@ -111,6 +120,18 @@ module RuboCop
     #
     # @abstract
     class EditorComment < MagicComment
+      def encoding
+        match(self.class::KEYWORDS[:encoding])
+      end
+
+      # Rewrite the comment without a given token type
+      def without(type)
+        remaining = tokens.grep_v(/\A#{self.class::KEYWORDS[type.to_sym]}/)
+        return '' if remaining.empty?
+
+        self.class::FORMAT % remaining.join(self.class::SEPARATOR)
+      end
+
       private
 
       # Find a token starting with the provided keyword and extract its value.
@@ -135,7 +156,7 @@ module RuboCop
       #
       # @return [Array<String>]
       def tokens
-        extract(self.class::FORMAT).split(self.class::SEPARATOR).map(&:strip)
+        extract(self.class::REGEXP).split(self.class::SEPARATOR).map(&:strip)
       end
     end
 
@@ -151,22 +172,19 @@ module RuboCop
     # @see https://www.gnu.org/software/emacs/manual/html_node/emacs/Specify-Coding.html
     # @see https://git.io/vMCXh Emacs handling in Ruby's parse.y
     class EmacsComment < EditorComment
-      FORMAT    = /-\*-(.+)-\*-/.freeze
+      REGEXP    = /-\*-(.+)-\*-/.freeze
+      FORMAT    = '# -*- %s -*-'
       SEPARATOR = ';'
       OPERATOR  = ':'
 
-      def encoding
-        match('(?:en)?coding')
-      end
-
       private
 
       def extract_frozen_string_literal
-        match('frozen[_-]string[_-]literal')
+        match(KEYWORDS[:frozen_string_literal])
       end
 
       def extract_shareable_constant_value
-        match('shareable[_-]constant[_-]values')
+        match(KEYWORDS[:shareable_constant_value])
       end
     end
 
@@ -179,9 +197,11 @@ module RuboCop
     #
     #   comment.encoding # => 'ascii-8bit'
     class VimComment < EditorComment
-      FORMAT    = /#\s*vim:\s*(.+)/.freeze
+      REGEXP    = /#\s*vim:\s*(.+)/.freeze
+      FORMAT    = '# vim: %s'
       SEPARATOR = ', '
       OPERATOR  = '='
+      KEYWORDS = MagicComment::KEYWORDS.merge(encoding: 'fileencoding').freeze
 
       # For some reason the fileencoding keyword only works if there
       # is at least one other token included in the string. For example
@@ -193,7 +213,7 @@ module RuboCop
       #      # vim: foo=bar, fileencoding=ascii-8bit
       #
       def encoding
-        match('fileencoding') if tokens.size > 1
+        super if tokens.size > 1
       end
 
       # Vim comments cannot specify frozen string literal behavior.
@@ -219,7 +239,16 @@ module RuboCop
     class SimpleComment < MagicComment
       # Match `encoding` or `coding`
       def encoding
-        extract(/\A\s*\#.*\b(?:en)?coding: (#{TOKEN})/io)
+        extract(/\A\s*\#.*\b#{KEYWORDS[:encoding]}: (#{TOKEN})/io)
+      end
+
+      # Rewrite the comment without a given token type
+      def without(type)
+        if @comment.match?(/\A#\s*#{self.class::KEYWORDS[type.to_sym]}/)
+          ''
+        else
+          @comment
+        end
       end
 
       private
@@ -232,11 +261,11 @@ module RuboCop
       # Case-insensitive and dashes/underscores are acceptable.
       # @see https://git.io/vM7Mg
       def extract_frozen_string_literal
-        extract(/\A\s*#\s*frozen[_-]string[_-]literal:\s*(#{TOKEN})\s*\z/io)
+        extract(/\A\s*#\s*#{KEYWORDS[:frozen_string_literal]}:\s*(#{TOKEN})\s*\z/io)
       end
 
       def extract_shareable_constant_value
-        extract(/\A\s*#\s*shareable[_-]constant[_-]value:\s*(#{TOKEN})\s*\z/io)
+        extract(/\A\s*#\s*#{KEYWORDS[:shareable_constant_value]}:\s*(#{TOKEN})\s*\z/io)
       end
     end
   end