rubocop 1.18.1 → 1.22.3

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where conditional branch makes redundant self-assignment.
+      #
+      # It only detects local variable because it may replace state of instance variable,
+      # class variable, and global variable that have state across methods with `nil`.
+      #
+      # @example
+      #
+      #   # bad
+      #   foo = condition ? bar : foo
+      #
+      #   # good
+      #   foo = bar if condition
+      #
+      #   # bad
+      #   foo = condition ? foo : bar
+      #
+      #   # good
+      #   foo = bar unless condition
+      #
+      class RedundantSelfAssignmentBranch < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the self-assignment branch.'
+
+        # @!method bad_method?(node)
+        def_node_matcher :bad_method?, <<~PATTERN
+          (send nil? :bad_method ...)
+        PATTERN
+
+        def on_lvasgn(node)
+          variable, expression = *node
+          return unless use_if_and_else_branch?(expression)
+
+          if_branch = expression.if_branch
+          else_branch = expression.else_branch
+          return if inconvertible_to_modifier?(if_branch, else_branch)
+
+          if self_assign?(variable, if_branch)
+            register_offense(expression, if_branch, else_branch, 'unless')
+          elsif self_assign?(variable, else_branch)
+            register_offense(expression, else_branch, if_branch, 'if')
+          end
+        end
+
+        private
+
+        def use_if_and_else_branch?(expression)
+          return false unless expression&.if_type?
+
+          !expression.ternary? || !expression.else?
+        end
+
+        def inconvertible_to_modifier?(if_branch, else_branch)
+          multiple_statements?(if_branch) || multiple_statements?(else_branch) ||
+            (else_branch.respond_to?(:elsif?) && else_branch.elsif?)
+        end
+
+        def multiple_statements?(branch)
+          branch && branch.children.compact.count > 1
+        end
+
+        def self_assign?(variable, branch)
+          variable.to_s == branch&.source
+        end
+
+        def register_offense(if_node, offense_branch, opposite_branch, keyword)
+          add_offense(offense_branch) do |corrector|
+            assignment_value = opposite_branch ? opposite_branch.source : 'nil'
+            replacement = "#{assignment_value} #{keyword} #{if_node.condition.source}"
+
+            corrector.replace(if_node, replacement)
+          end
+        end
+      end
+    end
+  end
+end

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
@@ -60,8 +87,8 @@ module RuboCop
         # @!method redundant_sort?(node)
         def_node_matcher :redundant_sort?, <<~MATCHER
           {
-            (send $(send _ $:sort ...) ${:last :first})
-            (send $(send _ $:sort ...) ${:[] :at :slice} {(int 0) (int -1)})
+            (send $(send _ $:sort) ${:last :first})
+            (send $(send _ $:sort) ${:[] :at :slice} {(int 0) (int -1)})
 
             (send $(send _ $:sort_by _) ${:last :first})
             (send $(send _ $:sort_by _) ${:[] :at :slice} {(int 0) (int -1)})
@@ -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

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for places where an subset of an Enumerable (array,
+      # range, set, etc.; see note below) is calculated based on a `Regexp`
+      # match, and suggests `grep` or `grep_v` instead.
+      #
+      # NOTE: Hashes do not behave as you may expect with `grep`, which
+      # means that `hash.grep` is not equivalent to `hash.select`. Although
+      # RuboCop is limited by static analysis, this cop attempts to avoid
+      # registering an offense when the receiver is a hash (hash literal,
+      # `Hash.new`, `Hash#[]`, or `to_h`/`to_hash`).
+      #
+      # NOTE: `grep` and `grep_v` were optimized when used without a block
+      # in Ruby 3.0, but may be slower in previous versions.
+      # See https://bugs.ruby-lang.org/issues/17030
+      #
+      # @safety
+      #   Autocorrection is marked as unsafe because `MatchData` will
+      #   not be created by `grep`, but may have previously been relied
+      #   upon after the `match?` or `=~` call.
+      #
+      #   Additionally, the cop cannot guarantee that the receiver of
+      #   `select` or `reject` is actually an array by static analysis,
+      #   so the correction may not be actually equivalent.
+      #
+      # @example
+      #   # bad (select or find_all)
+      #   array.select { |x| x.match? /regexp/ }
+      #   array.select { |x| /regexp/.match?(x) }
+      #   array.select { |x| x =~ /regexp/ }
+      #   array.select { |x| /regexp/ =~ x }
+      #
+      #   # bad (reject)
+      #   array.reject { |x| x.match? /regexp/ }
+      #   array.reject { |x| /regexp/.match?(x) }
+      #   array.reject { |x| x =~ /regexp/ }
+      #   array.reject { |x| /regexp/ =~ x }
+      #
+      #   # good
+      #   array.grep(regexp)
+      #   array.grep_v(regexp)
+      class SelectByRegexp < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Prefer `%<replacement>s` to `%<original_method>s` with a regexp match.'
+        RESTRICT_ON_SEND = %i[select find_all reject].freeze
+        REPLACEMENTS = { select: 'grep', find_all: 'grep', reject: 'grep_v' }.freeze
+        REGEXP_METHODS = %i[match? =~].to_set.freeze
+
+        # @!method regexp_match?(node)
+        def_node_matcher :regexp_match?, <<~PATTERN
+          {
+            (block send (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (numblock send $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+          }
+        PATTERN
+
+        # Returns true if a node appears to return a hash
+        # @!method creates_hash?(node)
+        def_node_matcher :creates_hash?, <<~PATTERN
+          {
+            (send (const _ :Hash) {:new :[]} ...)
+            (block (send (const _ :Hash) :new ...) ...)
+            (send _ { :to_h :to_hash } ...)
+          }
+        PATTERN
+
+        # @!method calls_lvar?(node, name)
+        def_node_matcher :calls_lvar?, <<~PATTERN
+          {
+            (send (lvar %1) ...)
+            (send ... (lvar %1))
+            (match-with-lvasgn regexp (lvar %1))
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (block_node = node.block_node)
+          return if block_node.body.begin_type?
+          return if receiver_allowed?(block_node.receiver)
+          return unless (regexp_method_send_node = extract_send_node(block_node))
+          return if match_predicate_without_receiver?(regexp_method_send_node)
+
+          regexp = find_regexp(regexp_method_send_node, block_node)
+          register_offense(node, block_node, regexp)
+        end
+
+        private
+
+        def receiver_allowed?(node)
+          return false unless node
+
+          node.hash_type? || creates_hash?(node)
+        end
+
+        def register_offense(node, block_node, regexp)
+          replacement = REPLACEMENTS[node.method_name.to_sym]
+          message = format(MSG, replacement: replacement, original_method: node.method_name)
+
+          add_offense(block_node, message: message) do |corrector|
+            # Only correct if it can be determined what the regexp is
+            if regexp
+              range = range_between(node.loc.selector.begin_pos, block_node.loc.end.end_pos)
+              corrector.replace(range, "#{replacement}(#{regexp.source})")
+            end
+          end
+        end
+
+        def extract_send_node(block_node)
+          return unless (block_arg_name, regexp_method_send_node = regexp_match?(block_node))
+
+          block_arg_name = :"_#{block_arg_name}" if block_node.numblock_type?
+          return unless calls_lvar?(regexp_method_send_node, block_arg_name)
+
+          regexp_method_send_node
+        end
+
+        def find_regexp(node, block)
+          return node.child_nodes.first if node.match_with_lvasgn_type?
+
+          if node.receiver.lvar_type? &&
+             (block.numblock_type? || node.receiver.source == block.arguments.first.source)
+            node.first_argument
+          elsif node.first_argument.lvar_type?
+            node.receiver
+          end
+        end
+
+        def match_predicate_without_receiver?(node)
+          node.send_type? && node.method?(:match?) && node.receiver.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -32,38 +32,29 @@ module RuboCop
 
         MSG = 'Do not use semicolons to terminate expressions.'
 
+        def self.autocorrect_incompatible_with
+          [Style::SingleLineMethods]
+        end
+
         def on_new_investigation
           return if processed_source.blank?
 
-          @processed_source = processed_source
-
           check_for_line_terminator_or_opener
         end
 
-        def on_begin(node) # rubocop:todo Metrics/CyclomaticComplexity
+        def on_begin(node)
           return if cop_config['AllowAsExpressionSeparator']
 
           exprs = node.children
 
           return if exprs.size < 2
 
-          # create a map matching lines to the number of expressions on them
-          exprs_lines = exprs.map(&:first_line)
-          lines = exprs_lines.group_by(&:itself)
-
-          lines.each do |line, expr_on_line|
+          expressions_per_line(exprs).each do |line, expr_on_line|
             # Every line with more than one expression on it is a
             # potential offense
             next unless expr_on_line.size > 1
 
-            # TODO: Find the correct position of the semicolon. We don't know
-            # if the first semicolon on the line is a separator of
-            # expressions. It's just a guess.
-            column = @processed_source[line - 1].index(';')
-
-            next unless column
-
-            convention_on(line, column, false)
+            find_semicolon_positions(line) { |pos| register_semicolon(line, pos, true) }
           end
         end
 
@@ -71,9 +62,9 @@ module RuboCop
 
         def check_for_line_terminator_or_opener
           # Make the obvious check first
-          return unless @processed_source.raw_source.include?(';')
+          return unless processed_source.raw_source.include?(';')
 
-          each_semicolon { |line, column| convention_on(line, column, true) }
+          each_semicolon { |line, column| register_semicolon(line, column, false) }
         end
 
         def each_semicolon
@@ -84,15 +75,32 @@ module RuboCop
         end
 
         def tokens_for_lines
-          @processed_source.tokens.group_by(&:line)
+          processed_source.tokens.group_by(&:line)
         end
 
-        def convention_on(line, column, autocorrect)
-          range = source_range(@processed_source.buffer, line, column)
-          # Don't attempt to autocorrect if semicolon is separating statements
-          # on the same line
+        def register_semicolon(line, column, after_expression)
+          range = source_range(processed_source.buffer, line, column)
+
           add_offense(range) do |corrector|
-            corrector.remove(range) if autocorrect
+            if after_expression
+              corrector.replace(range, "\n")
+            else
+              corrector.remove(range)
+            end
+          end
+        end
+
+        def expressions_per_line(exprs)
+          # create a map matching lines to the number of expressions on them
+          exprs_lines = exprs.map(&:first_line)
+          exprs_lines.group_by(&:itself)
+        end
+
+        def find_semicolon_positions(line)
+          # Scan for all the semicolons on the line
+          semicolons = processed_source[line - 1].enum_for(:scan, ';')
+          semicolons.each do
+            yield Regexp.last_match.begin(0)
           end
         end
       end

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

@@ -6,6 +6,11 @@ module RuboCop
       # Sometimes using dig method ends up with just a single
       # argument. In such cases, dig should be replaced with [].
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is an `Enumerable` or does not have a nonstandard implementation
+      #   of `dig`.
+      #
       # @example
       #   # bad
       #   { key: 'value' }.dig(:key)

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

@@ -109,7 +109,9 @@ module RuboCop
           # we remove any leading underscores before comparing.
           actual_args_no_underscores = actual_args.map { |arg| arg.to_s.sub(/^_+/, '') }
 
-          actual_args_no_underscores == target_args(method_name)
+          # Allow the arguments if the names match but not all are given
+          expected_args = target_args(method_name).first(actual_args_no_underscores.size)
+          actual_args_no_underscores == expected_args
         end
       end
     end

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

@@ -36,6 +36,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Avoid single-line method definitions.'
+        NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES = %i[return break next].freeze
 
         def on_def(node)
           return unless node.single_line?
@@ -62,29 +63,24 @@ module RuboCop
 
         def correct_to_endless?(body_node)
           return false if target_ruby_version < 3.0
-
-          endless_method_config = config.for_cop('Style/EndlessMethod')
-
-          return false unless endless_method_config['Enabled']
-          return false if endless_method_config['EnforcedStyle'] == 'disallow'
+          return false if disallow_endless_method_style?
           return false unless body_node
-          return false if body_node.parent.assignment_method?
+          return false if body_node.parent.assignment_method? ||
+                          NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)
 
           !(body_node.begin_type? || body_node.kwbegin_type?)
         end
 
         def correct_to_multiline(corrector, node)
-          each_part(node.body) do |part|
-            LineBreakCorrector.break_line_before(
-              range: part, node: node, corrector: corrector,
-              configured_width: configured_indentation_width
-            )
+          if (body = node.body) && body.begin_type? && body.parenthesized_call?
+            break_line_before(corrector, node, body)
+          else
+            each_part(body) do |part|
+              break_line_before(corrector, node, part)
+            end
           end
 
-          LineBreakCorrector.break_line_before(
-            range: node.loc.end, node: node, corrector: corrector,
-            indent_steps: 0, configured_width: configured_indentation_width
-          )
+          break_line_before(corrector, node, node.loc.end, indent_steps: 0)
 
           move_comment(node, corrector)
         end
@@ -98,6 +94,13 @@ module RuboCop
           corrector.replace(node, replacement)
         end
 
+        def break_line_before(corrector, node, range, indent_steps: 1)
+          LineBreakCorrector.break_line_before(
+            range: range, node: node, corrector: corrector,
+            configured_width: configured_indentation_width, indent_steps: indent_steps
+          )
+        end
+
         def each_part(body)
           return unless body
 
@@ -129,6 +132,13 @@ module RuboCop
         def require_parentheses?(method_body)
           method_body.send_type? && !method_body.arguments.empty? && !method_body.comparison_method?
         end
+
+        def disallow_endless_method_style?
+          endless_method_config = config.for_cop('Style/EndlessMethod')
+          return false unless endless_method_config['Enabled']
+
+          endless_method_config['EnforcedStyle'] == 'disallow'
+        end
       end
     end
   end

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

@@ -6,6 +6,19 @@ module RuboCop
       # This cop checks that arrays are sliced with endless ranges instead of
       # `ary[start..-1]` on Ruby 2.6+.
       #
+      # @safety
+      #   This cop is unsafe because `x..-1` and `x..` are only guaranteed to
+      #   be equivalent for `Array#[]`, and the cop cannot determine what class
+      #   the receiver is.
+      #
+      #   For example:
+      #   [source,ruby]
+      #   ----
+      #   sum = proc { |ary| ary.sum }
+      #   sum[-3..-1] # => -6
+      #   sum[-3..] # Hangs forever
+      #   ----
+      #
       # @example
       #   # bad
       #   items[1..-1]

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

@@ -38,6 +38,10 @@ module RuboCop
 
         MSG = 'Consider merging nested conditions into outer `%<conditional_type>s` conditions.'
 
+        def self.autocorrect_incompatible_with
+          [Style::NegatedIf, Style::NegatedUnless]
+        end
+
         def on_if(node)
           return if node.ternary? || node.else? || node.elsif?