rubocop 1.22.0 → 1.45.1

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

@@ -3,25 +3,25 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for rescuing `StandardError`. There are two supported
+      # Checks for rescuing `StandardError`. There are two supported
       # styles `implicit` and `explicit`. This cop will not register an offense
       # if any error other than `StandardError` is specified.
       #
-      # @example EnforcedStyle: implicit
-      #   # `implicit` will enforce using `rescue` instead of
-      #   # `rescue StandardError`.
+      # @example EnforcedStyle: explicit (default)
+      #   # `explicit` will enforce using `rescue StandardError`
+      #   # instead of `rescue`.
       #
       #   # bad
       #   begin
       #     foo
-      #   rescue StandardError
+      #   rescue
       #     bar
       #   end
       #
       #   # good
       #   begin
       #     foo
-      #   rescue
+      #   rescue StandardError
       #     bar
       #   end
       #
@@ -39,21 +39,21 @@ module RuboCop
       #     bar
       #   end
       #
-      # @example EnforcedStyle: explicit (default)
-      #   # `explicit` will enforce using `rescue StandardError`
-      #   # instead of `rescue`.
+      # @example EnforcedStyle: implicit
+      #   # `implicit` will enforce using `rescue` instead of
+      #   # `rescue StandardError`.
       #
       #   # bad
       #   begin
       #     foo
-      #   rescue
+      #   rescue StandardError
       #     bar
       #   end
       #
       #   # good
       #   begin
       #     foo
-      #   rescue StandardError
+      #   rescue
       #     bar
       #   end
       #
@@ -98,7 +98,7 @@ module RuboCop
               offense_for_implicit_enforced_style(node, error)
             end
           when :explicit
-            rescue_without_error_class?(node) { offense_for_exlicit_enforced_style(node) }
+            rescue_without_error_class?(node) { offense_for_explicit_enforced_style(node) }
           end
         end
 
@@ -115,7 +115,7 @@ module RuboCop
           end
         end
 
-        def offense_for_exlicit_enforced_style(node)
+        def offense_for_explicit_enforced_style(node)
           add_offense(node.loc.keyword, message: MSG_EXPLICIT) do |corrector|
             corrector.insert_after(node.loc.keyword, ' StandardError')
           end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces consistency between 'return nil' and 'return'.
+      # Enforces consistency between 'return nil' and 'return'.
       #
       # Supported styles are: return, return_nil.
       #

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

@@ -3,12 +3,11 @@
 module RuboCop
   module Cop
     module Style
-      # This cop transforms usages of a method call safeguarded by a non `nil`
+      # Transforms usages of a method call safeguarded by a non `nil`
       # check for the variable whose method is being called to
       # safe navigation (`&.`). If there is a method chain, all of the methods
       # in the chain need to be checked for safety, and all of the methods will
-      # 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.
+      # need to be changed to use safe navigation.
       #
       # The default for `ConvertCodeThatCanStartToReturnNil` is `false`.
       # When configured to `true`, this will
@@ -18,9 +17,13 @@ module RuboCop
       # `foo&.bar` can start returning `nil` as well as what the method
       # returns.
       #
+      # The default for `MaxChainLength` is `2`
+      # We have limited the cop to not register an offense for method chains
+      # that exceed this option is set.
+      #
       # @safety
       #   Autocorrection is unsafe because if a value is `false`, the resulting
-      #   code will have different behaviour or raise an error.
+      #   code will have different behavior or raise an error.
       #
       #   [source,ruby]
       #   ----
@@ -47,6 +50,11 @@ module RuboCop
       #   foo && foo.bar { |e| e.something }
       #   foo && foo.bar(param) { |e| e.something }
       #
+      #   foo ? foo.bar : nil
+      #   foo.nil? ? nil : foo.bar
+      #   !foo.nil? ? foo.bar : nil
+      #   !foo ? nil : foo.bar
+      #
       #   # good
       #   foo&.bar
       #   foo&.bar&.baz
@@ -77,11 +85,14 @@ module RuboCop
         include NilMethods
         include RangeHelp
         extend AutoCorrector
+        extend TargetRubyVersion
 
         MSG = 'Use safe navigation (`&.`) instead of checking if an object ' \
               'exists before calling the method.'
         LOGIC_JUMP_KEYWORDS = %i[break fail next raise return throw yield].freeze
 
+        minimum_target_ruby_version 2.3
+
         # if format: (if checked_variable body nil)
         # unless format: (if checked_variable nil body)
         # @!method modifier_if_safe_navigation_candidate(node)
@@ -99,6 +110,17 @@ module RuboCop
           }
         PATTERN
 
+        # @!method ternary_safe_navigation_candidate(node)
+        def_node_matcher :ternary_safe_navigation_candidate, <<~PATTERN
+          {
+            (if (send $_ {:nil? :!}) nil $_)
+
+            (if (send (send $_ :nil?) :!) $_ nil)
+
+            (if $_ $_ nil)
+          }
+        PATTERN
+
         # @!method not_nil_check?(node)
         def_node_matcher :not_nil_check?, '(send (send $_ :nil?) :!)'
 
@@ -112,13 +134,13 @@ module RuboCop
           check_node(node)
         end
 
+        private
+
         def check_node(node)
           checked_variable, receiver, method_chain, method = extract_parts(node)
-          return unless receiver == checked_variable
+          return if receiver != checked_variable || receiver.nil?
           return if use_var_only_in_unless_modifier?(node, checked_variable)
-          # method is already a method call so this is actually checking for a
-          # chain greater than 2
-          return if chain_size(method_chain, method) > 1
+          return if chain_length(method_chain, method) > max_chain_length
           return if unsafe_method_used?(method_chain, method)
           return if method_chain.method?(:empty?)
 
@@ -129,20 +151,26 @@ module RuboCop
           node.if_type? && node.unless? && !method_called?(variable)
         end
 
-        private
-
         def autocorrect(corrector, node)
-          body = node.node_parts[1]
+          body = extract_body(node)
           method_call = method_call(node)
 
           corrector.remove(begin_range(node, body))
           corrector.remove(end_range(node, body))
-          corrector.insert_before(method_call.loc.dot, '&')
+          corrector.insert_before(method_call.loc.dot, '&') unless method_call.safe_navigation?
           handle_comments(corrector, node, method_call)
 
           add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
         end
 
+        def extract_body(node)
+          if node.if_type? && node.ternary?
+            node.branches.find { |branch| !branch.nil_type? }
+          else
+            node.node_parts[1]
+          end
+        end
+
         def handle_comments(corrector, node, method_call)
           comments = comments(node)
           return if comments.empty?
@@ -170,7 +198,7 @@ module RuboCop
         end
 
         def allowed_if_condition?(node)
-          node.else? || node.elsif? || node.ternary?
+          node.else? || node.elsif?
         end
 
         def method_call(node)
@@ -188,7 +216,12 @@ module RuboCop
         end
 
         def extract_parts_from_if(node)
-          variable, receiver = modifier_if_safe_navigation_candidate(node)
+          variable, receiver =
+            if node.ternary?
+              ternary_safe_navigation_candidate(node)
+            else
+              modifier_if_safe_navigation_candidate(node)
+            end
 
           checked_variable, matching_receiver, method = extract_common_parts(receiver, variable)
 
@@ -218,19 +251,15 @@ module RuboCop
         def find_matching_receiver_invocation(method_chain, checked_variable)
           return nil unless method_chain
 
-          receiver = if method_chain.block_type?
-                       method_chain.send_node.receiver
-                     else
-                       method_chain.receiver
-                     end
+          receiver = method_chain.receiver
 
           return receiver if receiver == checked_variable
 
           find_matching_receiver_invocation(receiver, checked_variable)
         end
 
-        def chain_size(method_chain, method)
-          method.each_ancestor(:send).inject(0) do |total, ancestor|
+        def chain_length(method_chain, method)
+          method.each_ancestor(:send).inject(1) do |total, ancestor|
             break total + 1 if ancestor == method_chain
 
             total + 1
@@ -250,7 +279,9 @@ module RuboCop
         end
 
         def unsafe_method?(send_node)
-          negated?(send_node) || send_node.assignment? || !send_node.dot?
+          negated?(send_node) ||
+            send_node.assignment? ||
+            (!send_node.dot? && !send_node.safe_navigation?)
         end
 
         def negated?(send_node)
@@ -285,6 +316,10 @@ module RuboCop
             break if ancestor == method_chain
           end
         end
+
+        def max_chain_length
+          cop_config.fetch('MaxChainLength', 2)
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop is used to identify usages of `shuffle.first`,
+      # Identifies usages of `shuffle.first`,
       # `shuffle.last`, and `shuffle[]` and change them to use
       # `sample` instead.
       #
@@ -91,11 +91,12 @@ module RuboCop
           second.int_type? ? second.to_a.first : :unknown
         end
 
-        def range_size(range_node) # rubocop:todo Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def range_size(range_node)
           vals = range_node.to_a
-          return :unknown unless vals.all?(&:int_type?)
+          return :unknown unless vals.all? { |val| val.nil? || val.int_type? }
 
-          low, high = vals.map { |val| val.children[0] }
+          low, high = vals.map { |val| val.nil? ? 0 : val.children[0] }
           return :unknown unless low.zero? && high >= 0
 
           case range_node.type
@@ -105,6 +106,7 @@ module RuboCop
             (low..high).size
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def source_range(shuffle_node, node)
           Parser::Source::Range.new(shuffle_node.source_range.source_buffer,

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

@@ -3,9 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for places where an subset of an array
-      # is calculated based on a `Regexp` match, and suggests `grep` or
-      # `grep_v` instead.
+      # 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.
@@ -16,6 +22,10 @@ module RuboCop
       #   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/ }
@@ -39,7 +49,8 @@ module RuboCop
         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
+        OPPOSITE_REPLACEMENTS = { select: 'grep_v', find_all: 'grep_v', reject: 'grep' }.freeze
+        REGEXP_METHODS = %i[match? =~ !~].to_set.freeze
 
         # @!method regexp_match?(node)
         def_node_matcher :regexp_match?, <<~PATTERN
@@ -49,6 +60,21 @@ module RuboCop
           }
         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 env_const?(node)
+        def_node_matcher :env_const?, <<~PATTERN
+          (const {nil? cbase} :ENV)
+        PATTERN
+
         # @!method calls_lvar?(node, name)
         def_node_matcher :calls_lvar?, <<~PATTERN
           {
@@ -60,17 +86,28 @@ module RuboCop
 
         def on_send(node)
           return unless (block_node = node.block_node)
-          return if block_node.body.begin_type?
+          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)
-          register_offense(node, block_node, regexp)
+          opposite = opposite?(regexp_method_send_node)
+          regexp = find_regexp(regexp_method_send_node, block_node)
+
+          register_offense(node, block_node, regexp, opposite)
         end
 
         private
 
-        def register_offense(node, block_node, regexp)
-          replacement = REPLACEMENTS[node.method_name.to_sym]
+        def receiver_allowed?(node)
+          return false unless node
+
+          node.hash_type? || creates_hash?(node) || env_const?(node)
+        end
+
+        def register_offense(node, block_node, regexp, opposite)
+          method_name = node.method_name.to_sym
+          replacement = opposite ? OPPOSITE_REPLACEMENTS[method_name] : REPLACEMENTS[method_name]
           message = format(MSG, replacement: replacement, original_method: node.method_name)
 
           add_offense(block_node, message: message) do |corrector|
@@ -91,15 +128,24 @@ module RuboCop
           regexp_method_send_node
         end
 
-        def find_regexp(node)
+        def opposite?(regexp_method_send_node)
+          regexp_method_send_node.send_type? && regexp_method_send_node.method?(:!~)
+        end
+
+        def find_regexp(node, block)
           return node.child_nodes.first if node.match_with_lvasgn_type?
 
-          if node.receiver.lvar_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

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use the shorthand for self-assignment.
+      # Enforces the use the shorthand for self-assignment.
       #
       # @example
       #
@@ -42,7 +42,7 @@ module RuboCop
 
           if rhs.send_type?
             check_send_node(node, rhs, var_name, var_type)
-          elsif %i[and or].include?(rhs.type)
+          elsif rhs.operator_keyword?
             check_boolean_node(node, rhs, var_name, var_type)
           end
         end
@@ -76,7 +76,7 @@ module RuboCop
 
           if rhs.send_type?
             autocorrect_send_node(corrector, node, rhs)
-          elsif %i[and or].include?(rhs.type)
+          elsif rhs.operator_keyword?
             autocorrect_boolean_node(corrector, node, rhs)
           end
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for multiple expressions placed on the same line.
+      # Checks for multiple expressions placed on the same line.
       # It also checks for lines terminated with a semicolon.
       #
       # This cop has `AllowAsExpressionSeparator` configuration option.
@@ -37,13 +37,14 @@ module RuboCop
         end
 
         def on_new_investigation
-          return if processed_source.blank?
+          return if processed_source.blank? || !processed_source.raw_source.include?(';')
 
           check_for_line_terminator_or_opener
         end
 
         def on_begin(node)
           return if cop_config['AllowAsExpressionSeparator']
+          return unless node.source.include?(';')
 
           exprs = node.children
 
@@ -64,13 +65,17 @@ module RuboCop
           # Make the obvious check first
           return unless processed_source.raw_source.include?(';')
 
-          each_semicolon { |line, column| register_semicolon(line, column, false) }
+          each_semicolon do |line, column, token_before_semicolon|
+            register_semicolon(line, column, false, token_before_semicolon)
+          end
         end
 
         def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            yield line, tokens.last.column if tokens.last.semicolon?
-            yield line, tokens.first.column if tokens.first.semicolon?
+            semicolon_pos = semicolon_position(tokens)
+            after_expr_pos = semicolon_pos == -1 ? -2 : semicolon_pos
+
+            yield line, tokens[semicolon_pos].column, tokens[after_expr_pos] if semicolon_pos
           end
         end
 
@@ -78,13 +83,41 @@ module RuboCop
           processed_source.tokens.group_by(&:line)
         end
 
-        def register_semicolon(line, column, after_expression)
+        def semicolon_position(tokens)
+          if tokens.last.semicolon?
+            -1
+          elsif tokens.first.semicolon?
+            0
+          elsif exist_semicolon_before_right_curly_brace?(tokens)
+            -3
+          elsif exist_semicolon_after_left_curly_brace?(tokens)
+            2
+          end
+        end
+
+        def exist_semicolon_before_right_curly_brace?(tokens)
+          tokens[-2]&.right_curly_brace? && tokens[-3]&.semicolon?
+        end
+
+        def exist_semicolon_after_left_curly_brace?(tokens)
+          tokens[1]&.left_curly_brace? && tokens[2]&.semicolon?
+        end
+
+        def register_semicolon(line, column, after_expression, token_before_semicolon = nil)
           range = source_range(processed_source.buffer, line, column)
 
           add_offense(range) do |corrector|
             if after_expression
               corrector.replace(range, "\n")
             else
+              # Prevents becoming one range instance with subsequent line when endless range
+              # without parentheses.
+              # See: https://github.com/rubocop/rubocop/issues/10791
+              if token_before_semicolon&.regexp_dots?
+                range_node = find_range_node(token_before_semicolon)
+                corrector.wrap(range_node, '(', ')') if range_node
+              end
+
               corrector.remove(range)
             end
           end
@@ -103,6 +136,20 @@ module RuboCop
             yield Regexp.last_match.begin(0)
           end
         end
+
+        def find_range_node(token_before_semicolon)
+          range_nodes.detect do |range_node|
+            range_node.source_range.contains?(token_before_semicolon.pos)
+          end
+        end
+
+        def range_nodes
+          return @range_nodes if instance_variable_defined?(:@range_nodes)
+
+          ast = processed_source.ast
+          @range_nodes = ast.range_type? ? [ast] : []
+          @range_nodes.concat(ast.each_descendant(:irange, :erange).to_a)
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the use of the send method.
+      # Checks for the use of the send method.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of `fail` and `raise`.
+      # Checks for uses of `fail` and `raise`.
       #
       # @example EnforcedStyle: only_raise (default)
       #   # The `only_raise` style enforces the sole use of `raise`.
@@ -119,11 +119,6 @@ module RuboCop
         # @!method custom_fail_methods(node)
         def_node_search :custom_fail_methods, '{(def :fail ...) (defs _ :fail ...)}'
 
-        def on_new_investigation
-          ast = processed_source.ast
-          @custom_fail_defined = ast && custom_fail_methods(ast).any?
-        end
-
         def on_rescue(node)
           return unless style == :semantic
 
@@ -141,7 +136,7 @@ module RuboCop
           when :semantic
             check_send(:raise, node) unless ignored_node?(node)
           when :only_raise
-            return if @custom_fail_defined
+            return if custom_fail_defined?
 
             check_send(:fail, node)
           when :only_fail
@@ -151,6 +146,13 @@ module RuboCop
 
         private
 
+        def custom_fail_defined?
+          return @custom_fail_defined if defined?(@custom_fail_defined)
+
+          ast = processed_source.ast
+          @custom_fail_defined = ast && custom_fail_methods(ast).any?
+        end
+
         def message(method_name)
           case style
           when :semantic

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

@@ -44,15 +44,20 @@ module RuboCop
 
           expression = single_argument_dig?(node)
           return unless expression
+          return if expression.forwarded_args_type?
 
           receiver = node.receiver.source
           argument = expression.source
 
           message = format(MSG, receiver: receiver, argument: argument, original: node.source)
           add_offense(node, message: message) do |corrector|
+            next if part_of_ignored_node?(node)
+
             correct_access = "#{receiver}[#{argument}]"
             corrector.replace(node, correct_access)
           end
+
+          ignore_node(node)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks whether the block parameters of a single-line
+      # Checks whether the block parameters of a single-line
       # method accepting a block match the names specified via configuration.
       #
       # For instance one can configure `reduce`(`inject`) to use |a, e| as
@@ -33,13 +33,13 @@ module RuboCop
 
         MSG = 'Name `%<method>s` block params `|%<params>s|`.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless node.single_line?
 
           return unless eligible_method?(node)
           return unless eligible_arguments?(node)
 
-          method_name = node.send_node.method_name
+          method_name = node.method_name
           return if args_match?(method_name, node.arguments)
 
           preferred_block_arguments = build_preferred_arguments_map(node, target_args(method_name))
@@ -81,7 +81,7 @@ module RuboCop
         end
 
         def eligible_method?(node)
-          node.send_node.receiver && method_names.include?(node.send_node.method_name)
+          node.receiver && method_names.include?(node.method_name)
         end
 
         def methods