rubocop 1.9.1 → 1.22.3

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/send.rb

@@ -14,8 +14,7 @@ module RuboCop
       #   Foo.__send__(:bar)
       #   quuz.public_send(:fred)
       class Send < Base
-        MSG = 'Prefer `Object#__send__` or `Object#public_send` to ' \
-              '`send`.'
+        MSG = 'Prefer `Object#__send__` or `Object#public_send` to `send`.'
         RESTRICT_ON_SEND = %i[send].freeze
 
         def on_send(node)

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

@@ -109,14 +109,15 @@ module RuboCop
         extend AutoCorrector
 
         FAIL_MSG = 'Use `fail` instead of `raise` to signal exceptions.'
-        RAISE_MSG = 'Use `raise` instead of `fail` to ' \
-                    'rethrow exceptions.'
+        RAISE_MSG = 'Use `raise` instead of `fail` to rethrow exceptions.'
 
         RESTRICT_ON_SEND = %i[raise fail].freeze
 
+        # @!method kernel_call?(node, name)
         def_node_matcher :kernel_call?, '(send (const {nil? cbase} :Kernel) %1 ...)'
-        def_node_search :custom_fail_methods,
-                        '{(def :fail ...) (defs _ :fail ...)}'
+
+        # @!method custom_fail_methods(node)
+        def_node_search :custom_fail_methods, '{(def :fail ...) (defs _ :fail ...)}'
 
         def on_new_investigation
           ast = processed_source.ast
@@ -201,9 +202,7 @@ module RuboCop
         end
 
         def allow(method_name, node)
-          each_command_or_kernel_call(method_name, node) do |send_node|
-            ignore_node(send_node)
-          end
+          each_command_or_kernel_call(method_name, node) { |send_node| ignore_node(send_node) }
         end
 
         def each_command_or_kernel_call(method_name, node)

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)
@@ -29,6 +34,7 @@ module RuboCop
         MSG = 'Use `%<receiver>s[%<argument>s]` instead of `%<original>s`.'
         RESTRICT_ON_SEND = %i[dig].freeze
 
+        # @!method single_argument_dig?(node)
         def_node_matcher :single_argument_dig?, <<~PATTERN
           (send _ :dig $!splat)
         PATTERN
@@ -42,8 +48,7 @@ module RuboCop
           receiver = node.receiver.source
           argument = expression.source
 
-          message = format(MSG, receiver: receiver, argument: argument,
-                                original: node.source)
+          message = format(MSG, receiver: receiver, argument: argument, original: node.source)
           add_offense(node, message: message) do |corrector|
             correct_access = "#{receiver}[#{argument}]"
             corrector.replace(node, correct_access)

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

@@ -81,8 +81,7 @@ module RuboCop
         end
 
         def eligible_method?(node)
-          node.send_node.receiver &&
-            method_names.include?(node.send_node.method_name)
+          node.send_node.receiver && method_names.include?(node.send_node.method_name)
         end
 
         def methods
@@ -108,11 +107,11 @@ module RuboCop
 
           # Prepending an underscore to mark an unused parameter is allowed, so
           # we remove any leading underscores before comparing.
-          actual_args_no_underscores = actual_args.map do |arg|
-            arg.to_s.sub(/^_+/, '')
-          end
+          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,15 +36,14 @@ 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?
           return if node.endless?
           return if allow_empty? && !node.body
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
         alias on_defs on_def
 
@@ -64,38 +63,44 @@ 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? ||
+                          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
 
         def correct_to_endless(corrector, node)
+          self_receiver = node.self_receiver? ? 'self.' : ''
           arguments = node.arguments.any? ? node.arguments.source : '()'
-          replacement = "def #{node.method_name}#{arguments} = #{node.body.source}"
+          body_source = method_body_source(node.body)
+          replacement = "def #{self_receiver}#{node.method_name}#{arguments} = #{body_source}"
+
           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
 
@@ -112,6 +117,28 @@ module RuboCop
             node: node, corrector: corrector
           )
         end
+
+        def method_body_source(method_body)
+          if require_parentheses?(method_body)
+            arguments_source = method_body.arguments.map(&:source).join(', ')
+            body_source = "#{method_body.method_name}(#{arguments_source})"
+
+            method_body.receiver ? "#{method_body.receiver.source}.#{body_source}" : body_source
+          else
+            method_body.source
+          end
+        end
+
+        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]
@@ -21,6 +34,7 @@ module RuboCop
         MSG = 'Prefer ary[n..] over ary[n..-1].'
         RESTRICT_ON_SEND = %i[[]].freeze
 
+        # @!method range_till_minus_one?(node)
         def_node_matcher :range_till_minus_one?, '(irange !nil? (int -1))'
 
         def on_send(node)

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

@@ -36,13 +36,17 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Consider merging nested conditions into '\
-              'outer `%<conditional_type>s` conditions.'
+        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?
 
           if_branch = node.if_branch
+          return if use_variable_assignment_in_condition?(node.condition, if_branch)
           return unless offending_branch?(if_branch)
 
           message = format(MSG, conditional_type: node.keyword)
@@ -53,6 +57,21 @@ module RuboCop
 
         private
 
+        def use_variable_assignment_in_condition?(condition, if_branch)
+          assigned_variables = assigned_variables(condition)
+
+          assigned_variables && if_branch&.if_type? &&
+            assigned_variables.include?(if_branch.condition.source)
+        end
+
+        def assigned_variables(condition)
+          assigned_variables = condition.assignment? ? [condition.children.first.to_s] : []
+
+          assigned_variables + condition.descendants.select(&:assignment?).map do |node|
+            node.children.first.to_s
+          end
+        end
+
         def offending_branch?(branch)
           return false unless branch
 
@@ -65,10 +84,7 @@ module RuboCop
         def autocorrect(corrector, node, if_branch)
           corrector.wrap(node.condition, '(', ')') if node.condition.or_type?
 
-          if node.unless?
-            corrector.replace(node.loc.keyword, 'if')
-            corrector.insert_before(node.condition, '!')
-          end
+          correct_from_unless_to_if(corrector, node) if node.unless?
 
           and_operator = if_branch.unless? ? ' && !' : ' && '
           if if_branch.modifier_form?
@@ -79,6 +95,17 @@ module RuboCop
           end
         end
 
+        def correct_from_unless_to_if(corrector, node)
+          corrector.replace(node.loc.keyword, 'if')
+
+          condition = node.condition
+          if condition.send_type? && condition.comparison_method? && !condition.parenthesized?
+            corrector.wrap(node.condition, '!(', ')')
+          else
+            corrector.insert_before(node.condition, '!')
+          end
+        end
+
         def correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
           outer_condition = node.condition
           correct_outer_condition(corrector, outer_condition)
@@ -121,7 +148,8 @@ module RuboCop
         end
 
         def requrie_parentheses?(condition)
-          condition.send_type? && !condition.arguments.empty? && !condition.parenthesized?
+          condition.send_type? && !condition.arguments.empty? && !condition.parenthesized? &&
+            !condition.comparison_method?
         end
 
         def arguments_range(node)

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,13 +59,15 @@ module RuboCop
       #
       class SpecialGlobalVars < Base
         include ConfigurableEnforcedStyle
+        include RangeHelp
+        include RequireLibrary
         extend AutoCorrector
 
         MSG_BOTH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
-        'module (don\'t forget to require it) or `%<regular>s` over ' \
-        '`%<global>s`.'
+                   'module (don\'t forget to require it) or `%<regular>s` over ' \
+                   '`%<global>s`.'
         MSG_ENGLISH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
-        'module (don\'t forget to require it) over `%<global>s`.'
+                      'module (don\'t forget to require it) over `%<global>s`.'
         MSG_REGULAR = 'Prefer `%<prefer>s` over `%<global>s`.'
 
         ENGLISH_VARS = { # rubocop:disable Style/MutableConstant
@@ -80,25 +91,17 @@ module RuboCop
           :$* => %i[$ARGV ARGV]
         }
 
-        PERL_VARS =
-          Hash[ENGLISH_VARS.flat_map { |k, vs| vs.map { |v| [v, [k]] } }]
+        PERL_VARS = ENGLISH_VARS.flat_map { |k, vs| vs.map { |v| [v, [k]] } }.to_h
 
-        ENGLISH_VARS.merge!(
-          Hash[ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }]
-        )
-        PERL_VARS.merge!(
-          Hash[PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }]
-        )
+        ENGLISH_VARS.merge!(ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h)
+        PERL_VARS.merge!(PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h)
         ENGLISH_VARS.each_value(&:freeze).freeze
         PERL_VARS.each_value(&:freeze).freeze
 
         # 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
+        NON_ENGLISH_VARS = Set.new(%i[$LOAD_PATH $LOADED_FEATURES $PROGRAM_NAME ARGV]).freeze
+
+        LIBRARY_NAME = 'English'
 
         def on_gvar(node)
           global_var, = *node
@@ -120,15 +123,15 @@ module RuboCop
           if style == :use_english_names
             format_english_message(global_var)
           else
-            format(MSG_REGULAR,
-                   prefer: preferred_names(global_var).first,
-                   global: global_var)
+            format(MSG_REGULAR, prefer: preferred_names(global_var).first, global: global_var)
           end
         end
 
         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
 
@@ -184,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/stabby_lambda_parentheses.rb

@@ -24,8 +24,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'
-        MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments ' \
-                         'with parentheses.'
+        MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments with parentheses.'
         def on_send(node)
           return unless stabby_lambda_with_args?(node)
           return unless redundant_parentheses?(node) || missing_parentheses?(node)