rubocop 1.20.0 → 1.22.2

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

@@ -58,18 +58,17 @@ module RuboCop
 
           case int
           when /^\d+$/
-            return unless (self.min_digits = int.size + 1)
-
-            register_offense(node)
+            register_offense(node) { self.min_digits = int.size + 1 }
           when /\d{4}/, short_group_regex
-            return unless (self.config_to_allow_offenses = { 'Enabled' => false })
-
-            register_offense(node)
+            register_offense(node) { self.config_to_allow_offenses = { 'Enabled' => false } }
           end
         end
 
-        def register_offense(node)
-          add_offense(node) { |corrector| corrector.replace(node, format_number(node)) }
+        def register_offense(node, &_block)
+          add_offense(node) do |corrector|
+            yield
+            corrector.replace(node, format_number(node))
+          end
         end
 
         def short_group_regex

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

@@ -16,6 +16,11 @@ module RuboCop
       # populated with objects which can be compared with integers, but are
       # not themselves `Integer` polymorphic.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   defines the predicates or can be compared to a number, which may lead
+      #   to a false positive for non-standard classes.
+      #
       # @example EnforcedStyle: predicate (default)
       #   # bad
       #

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

@@ -6,6 +6,10 @@ module RuboCop
       # This cop checks for optional arguments to methods
       # that do not come at the end of the argument list.
       #
+      # @safety
+      #   This cop is unsafe because changing a method signature will
+      #   implicitly change behaviour.
+      #
       # @example
       #   # bad
       #   def foo(a = 1, b, c)

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

@@ -7,6 +7,10 @@ module RuboCop
       # boolean arguments when defining methods. `respond_to_missing?` method is allowed by default.
       # These are customizable with `AllowedMethods` option.
       #
+      # @safety
+      #   This cop is unsafe because changing a method signature will
+      #   implicitly change behaviour.
+      #
       # @example
       #   # bad
       #   def some_method(bar = false)
@@ -33,8 +37,8 @@ module RuboCop
       class OptionalBooleanParameter < Base
         include AllowedMethods
 
-        MSG = 'Use keyword arguments when defining method with boolean argument.'
-        BOOLEAN_TYPES = %i[true false].freeze
+        MSG = 'Prefer keyword arguments for arguments with a boolean default value; ' \
+              'use `%<replacement>s` instead of `%<original>s`.'
 
         def on_def(node)
           return if allowed_method?(node.method_name)
@@ -42,11 +46,17 @@ module RuboCop
           node.arguments.each do |arg|
             next unless arg.optarg_type?
 
-            _name, value = *arg
-            add_offense(arg) if BOOLEAN_TYPES.include?(value.type)
+            add_offense(arg, message: format_message(arg)) if arg.default_value.boolean_type?
           end
         end
         alias on_defs on_def
+
+        private
+
+        def format_message(argument)
+          source = argument.source
+          format(MSG, original: source, replacement: source.sub(/\s+=/, ':'))
+        end
       end
     end
   end

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

@@ -153,7 +153,7 @@ module RuboCop
 
           def dependency?(lhs, rhs)
             uses_var?(rhs, var_name(lhs)) ||
-              lhs.send_type? && lhs.assignment_method? && accesses?(rhs, lhs)
+              (lhs.send_type? && lhs.assignment_method? && accesses?(rhs, lhs))
           end
 
           # `lhs` is an assignment method call like `obj.attr=` or `ary[idx]=`.

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

@@ -53,8 +53,8 @@ module RuboCop
         end
 
         def correct_literal_style?(node)
-          style == :lower_case_q && type(node) == '%q' ||
-            style == :upper_case_q && type(node) == '%Q'
+          (style == :lower_case_q && type(node) == '%q') ||
+            (style == :upper_case_q && type(node) == '%Q')
         end
 
         def message(_range)

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

@@ -3,10 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # This cop (by default) checks for uses of methods Hash#has_key? and
-      # Hash#has_value? where it enforces Hash#key? and Hash#value?
-      # It is configurable to enforce the inverse, using `verbose` method
-      # names also.
+      # This cop checks for uses of methods `Hash#has_key?` and
+      # `Hash#has_value?`, and suggests using `Hash#key?` and `Hash#value?` instead.
+      #
+      # It is configurable to enforce the verbose method names, by using the
+      # `EnforcedStyle: verbose` configuration.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash` or responds to the replacement methods.
       #
       # @example EnforcedStyle: short (default)
       #  # bad

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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Checks if the quotes used for quoted symbols match the configured defaults.
-      # By default uses the same configuration as `Style/StringLiterals`.
+      # By default uses the same configuration as `Style/StringLiterals`; if that
+      # cop is not enabled, the default `EnforcedStyle` is `single_quotes`.
       #
       # String interpolation is always kept in double quotes.
       #
@@ -75,11 +76,14 @@ module RuboCop
         end
 
         def correct_quotes(str)
-          if style == :single_quotes
-            to_string_literal(str)
-          else
-            str.inspect
-          end
+          correction = if style == :single_quotes
+                         to_string_literal(str)
+                       else
+                         str.gsub("\\'", "'").inspect
+                       end
+
+          # The conversion process doubles escaped slashes, so they have to be reverted
+          correction.gsub('\\\\', '\\')
         end
 
         def style

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

@@ -141,7 +141,7 @@ module RuboCop
         end
 
         def requires_parens?(parent)
-          parent.and_type? || parent.or_type? || parent.if_type? && parent.ternary?
+          parent.and_type? || parent.or_type? || (parent.if_type? && parent.ternary?)
         end
       end
     end

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

@@ -5,22 +5,29 @@ module RuboCop
     module Style
       # This cop checks for a redundant argument passed to certain methods.
       #
-      # Limitations:
-      #
-      # 1. This cop matches for method names only and hence cannot tell apart
-      #    methods with same name in different classes.
-      # 2. This cop is limited to methods with single parameter.
-      # 3. This cop is unsafe if certain special global variables (e.g. `$;`, `$/`) are set.
-      #    That depends on the nature of the target methods, of course.
+      # NOTE: This cop is limited to methods with single parameter.
       #
       # Method names and their redundant arguments can be configured like this:
       #
+      # [source,yaml]
+      # ----
       # Methods:
       #   join: ''
       #   split: ' '
       #   chomp: "\n"
       #   chomp!: "\n"
       #   foo: 2
+      # ----
+      #
+      # @safety
+      #   This cop is unsafe because of the following limitations:
+      #
+      #   1. This cop matches by method names only and hence cannot tell apart
+      #      methods with same name in different classes.
+      #   2. This cop may be unsafe if certain special global variables (e.g. `$;`, `$/`) are set.
+      #      That depends on the nature of the target methods, of course. For example, the default
+      #      argument to join is `$OUTPUT_FIELD_SEPARATOR` (or `$,`) rather than `''`, and if that
+      #      global is changed, `''` is no longer a redundant argument.
       #
       # @example
       #   # bad
@@ -51,8 +58,11 @@ module RuboCop
           return if node.arguments.count != 1
           return unless redundant_argument?(node)
 
-          add_offense(node, message: format(MSG, arg: node.arguments.first.source)) do |corrector|
-            corrector.remove(argument_range(node))
+          offense_range = argument_range(node)
+          message = format(MSG, arg: node.arguments.first.source)
+
+          add_offense(offense_range, message: message) do |corrector|
+            corrector.remove(offense_range)
           end
         end
 

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

@@ -120,11 +120,10 @@ module RuboCop
         end
 
         def require_parentheses?(node)
-          node.basic_conditional? &&
-            node.modifier_form? ||
+          (node.basic_conditional? && node.modifier_form?) ||
             node.range_type? ||
             node.rescue_type? ||
-            node.respond_to?(:semantic_operator?) && node.semantic_operator?
+            (node.respond_to?(:semantic_operator?) && node.semantic_operator?)
         end
 
         def without_argument_parentheses_method?(node)

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

@@ -9,6 +9,10 @@ module RuboCop
       # In such cases `fetch(key, value)` method is faster
       # than `fetch(key) { value }`.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   does not have a different implementation of `fetch`.
+      #
       # @example SafeForConstants: false (default)
       #   # bad
       #   hash.fetch(:key) { 5 }

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

@@ -25,6 +25,7 @@ module RuboCop
       #   require_relative '../foo.so'
       #
       class RedundantFileExtensionInRequire < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Redundant `.rb` file extension detected.'
@@ -39,13 +40,21 @@ module RuboCop
           require_call?(node) do |name_node|
             return unless name_node.value.end_with?('.rb')
 
-            add_offense(name_node) do |corrector|
-              correction = name_node.value.delete_suffix('.rb')
+            extension_range = extension_range(name_node)
 
-              corrector.replace(name_node, "'#{correction}'")
+            add_offense(extension_range) do |corrector|
+              corrector.remove(extension_range)
             end
           end
         end
+
+        private
+
+        def extension_range(name_node)
+          end_of_path_string = name_node.source_range.end_pos
+
+          range_between(end_of_path_string - 4, end_of_path_string - 1)
+        end
       end
     end
   end

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

@@ -59,7 +59,6 @@ module RuboCop
             (begin (send {float int} {:+ :- :* :** :/ :% :<<} _))
             (begin (send !{(str _) array} {:+ :- :* :** :/ :%} {float int}))
             (begin (send _ {:== :=== :!= :<= :>= :< :>} _))
-            (send (const {nil? cbase} :ENV) :[] _)
             (send _ {:count :length :size} ...)
             (block (send _ {:count :length :size} ...) ...)
           }

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

@@ -56,7 +56,7 @@ module RuboCop
           first_child = node.children.first
 
           variable_interpolation?(first_child) ||
-            first_child.send_type? && !first_child.operator_method?
+            (first_child.send_type? && !first_child.operator_method?)
         end
 
         def interpolation?(node)

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

@@ -65,9 +65,8 @@ module RuboCop
         end
 
         def allowed_percent_q?(node)
-          node.source.start_with?(PERCENT_Q) && acceptable_q?(node) ||
-            node.source.start_with?(PERCENT_CAPITAL_Q) &&
-              acceptable_capital_q?(node)
+          (node.source.start_with?(PERCENT_Q) && acceptable_q?(node)) ||
+            (node.source.start_with?(PERCENT_CAPITAL_Q) && acceptable_capital_q?(node))
         end
 
         def message(node)

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

@@ -100,6 +100,10 @@ module RuboCop
           add_lhs_to_local_variables_scopes(rhs, lhs)
         end
 
+        def on_in_pattern(node)
+          add_match_var_scopes(node)
+        end
+
         def on_send(node)
           return unless node.self_receiver? && regular_method_call?(node)
           return if node.parent&.mlhs_type?
@@ -185,6 +189,12 @@ module RuboCop
             add_lhs_to_local_variables_scopes(rhs, child.to_a.first)
           end
         end
+
+        def add_match_var_scopes(in_pattern_node)
+          in_pattern_node.each_descendant(:match_var) do |match_var_node|
+            @local_variables_scopes[in_pattern_node] << match_var_node.children.first
+          end
+        end
       end
     end
   end

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

@@ -6,9 +6,10 @@ module RuboCop
       # This cop checks for places where redundant assignments are made for in place
       # modification methods.
       #
-      # This cop is marked as unsafe, because it can produce false positives for
-      # user defined methods having one of the expected names, but not modifying
-      # its receiver in place.
+      # @safety
+      #   This cop is unsafe, because it can produce false positives for
+      #   user defined methods having one of the expected names, but not modifying
+      #   its receiver in place.
       #
       # @example
       #   # bad

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

@@ -58,7 +58,7 @@ module RuboCop
 
         def inconvertible_to_modifier?(if_branch, else_branch)
           multiple_statements?(if_branch) || multiple_statements?(else_branch) ||
-            else_branch.respond_to?(:elsif?) && else_branch.elsif?
+            (else_branch.respond_to?(:elsif?) && else_branch.elsif?)
         end
 
         def multiple_statements?(branch)

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

@@ -12,6 +12,33 @@ module RuboCop
       # `Enumerable#max_by` can replace `Enumerable#sort_by` calls
       # after which only the first or last element is used.
       #
+      # @safety
+      #   This cop is unsafe, because `sort...last` and `max` may not return the
+      #   same element in all cases.
+      #
+      #   In an enumerable where there are multiple elements where `a <=> b == 0`,
+      #   or where the transformation done by the `sort_by` block has the
+      #   same result, `sort.last` and `max` (or `sort_by.last` and `max_by`)
+      #   will return different elements. `sort.last` will return the last
+      #   element but `max` will return the first element.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #     class MyString < String; end
+      #     strings = [MyString.new('test'), 'test']
+      #     strings.sort.last.class   #=> String
+      #     strings.max.class         #=> MyString
+      #   ----
+      #
+      #   [source,ruby]
+      #   ----
+      #     words = %w(dog horse mouse)
+      #     words.sort_by { |word| word.length }.last   #=> 'mouse'
+      #     words.max_by { |word| word.length }         #=> 'horse'
+      #   ----
+      #
       # @example
       #   # bad
       #   [2, 1, 3].sort.first
@@ -75,33 +102,39 @@ module RuboCop
         MATCHER
 
         def on_send(node)
-          if (sort_node, sorter, accessor = redundant_sort?(node.parent))
-            ancestor = node.parent
-          elsif (sort_node, sorter, accessor = redundant_sort?(node.parent&.parent))
-            ancestor = node.parent.parent
-          else
-            return
-          end
+          ancestor, sort_node, sorter, accessor =
+            find_redundant_sort(node.parent, node.parent&.parent)
+          return unless ancestor
 
-          message = message(ancestor, sorter, accessor)
+          register_offense(ancestor, sort_node, sorter, accessor)
+        end
+
+        private
 
-          add_offense(offense_range(sort_node, ancestor), message: message) do |corrector|
-            autocorrect(corrector, ancestor, sort_node, sorter, accessor)
+        def find_redundant_sort(*nodes)
+          nodes.each do |node|
+            if (sort_node, sorter, accessor = redundant_sort?(node))
+              return [node, sort_node, sorter, accessor]
+            end
           end
+
+          nil
         end
 
-        private
+        def register_offense(node, sort_node, sorter, accessor)
+          message = message(node, sorter, accessor)
 
-        def autocorrect(corrector, node, sort_node, sorter, accessor)
-          # Remove accessor, e.g. `first` or `[-1]`.
-          corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
+          add_offense(offense_range(sort_node, node), message: message) do |corrector|
+            # Remove accessor, e.g. `first` or `[-1]`.
+            corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
 
-          # Replace "sort" or "sort_by" with the appropriate min/max method.
-          corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
+            # Replace "sort" or "sort_by" with the appropriate min/max method.
+            corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
+          end
         end
 
-        def offense_range(sort_node, ancestor)
-          range_between(sort_node.loc.selector.begin_pos, ancestor.loc.expression.end_pos)
+        def offense_range(sort_node, node)
+          range_between(sort_node.loc.selector.begin_pos, node.loc.expression.end_pos)
         end
 
         def message(node, sorter, accessor)

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

@@ -107,7 +107,7 @@ module RuboCop
         private
 
         def allowed_slash_literal?(node)
-          style == :slashes && !contains_disallowed_slash?(node) || allowed_mixed_slash?(node)
+          (style == :slashes && !contains_disallowed_slash?(node)) || allowed_mixed_slash?(node)
         end
 
         def allowed_mixed_slash?(node)
@@ -115,13 +115,13 @@ module RuboCop
         end
 
         def allowed_percent_r_literal?(node)
-          style == :slashes && contains_disallowed_slash?(node) ||
+          (style == :slashes && contains_disallowed_slash?(node)) ||
             style == :percent_r ||
             allowed_mixed_percent_r?(node) || allowed_omit_parentheses_with_percent_r_literal?(node)
         end
 
         def allowed_mixed_percent_r?(node)
-          style == :mixed && node.multiline? || contains_disallowed_slash?(node)
+          (style == :mixed && node.multiline?) || contains_disallowed_slash?(node)
         end
 
         def contains_disallowed_slash?(node)

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

@@ -74,7 +74,8 @@ module RuboCop
         end
 
         def correct_style?(node)
-          style == :return && !return_nil_node?(node) || style == :return_nil && !return_node?(node)
+          (style == :return && !return_nil_node?(node)) ||
+            (style == :return_nil && !return_node?(node))
         end
 
         def scoped_node?(node)

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

@@ -10,14 +10,25 @@ module RuboCop
       # need to be changed to use safe navigation. We have limited the cop to
       # not register an offense for method chains that exceed 2 methods.
       #
-      # Configuration option: ConvertCodeThatCanStartToReturnNil
-      # The default for this is `false`. When configured to `true`, this will
+      # The default for `ConvertCodeThatCanStartToReturnNil` is `false`.
+      # When configured to `true`, this will
       # check for code in the format `!foo.nil? && foo.bar`. As it is written,
       # the return of this code is limited to `false` and whatever the return
       # of the method is. If this is converted to safe navigation,
       # `foo&.bar` can start returning `nil` as well as what the method
       # returns.
       #
+      # @safety
+      #   Autocorrection is unsafe because if a value is `false`, the resulting
+      #   code will have different behaviour or raise an error.
+      #
+      #   [source,ruby]
+      #   ----
+      #   x = false
+      #   x && x.foo  # return false
+      #   x&.foo      # raises NoMethodError
+      #   ----
+      #
       # @example
       #   # bad
       #   foo.bar if foo