rubocop 1.84.2 → 1.85.0

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies places where `max_by { ... }`, `min_by { ... }`, or
+      # `minmax_by { ... }` can be replaced by `max`, `min`, or `minmax`.
+      #
+      # @example
+      #   # bad
+      #   array.max_by { |x| x }
+      #   array.min_by { |x| x }
+      #   array.minmax_by { |x| x }
+      #
+      #   # good
+      #   array.max
+      #   array.min
+      #   array.minmax
+      class RedundantMinMaxBy < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_BLOCK = 'Use `%<replacement>s` instead of `%<original>s { |%<var>s| %<var>s }`.'
+        MSG_NUMBLOCK = 'Use `%<replacement>s` instead of `%<original>s { _1 }`.'
+        MSG_ITBLOCK = 'Use `%<replacement>s` instead of `%<original>s { it }`.'
+
+        REPLACEMENTS = { max_by: 'max', min_by: 'min', minmax_by: 'minmax' }.freeze
+
+        def on_block(node)
+          redundant_minmax_by_block(node) do |send, var_name|
+            register_offense(send, node, message_block(send, var_name))
+          end
+        end
+
+        def on_numblock(node)
+          redundant_minmax_by_numblock(node) do |send|
+            register_offense(send, node, message_numblock(send))
+          end
+        end
+
+        def on_itblock(node)
+          redundant_minmax_by_itblock(node) do |send|
+            register_offense(send, node, message_itblock(send))
+          end
+        end
+
+        private
+
+        # @!method redundant_minmax_by_block(node)
+        def_node_matcher :redundant_minmax_by_block, <<~PATTERN
+          (block $(call _ {:max_by :min_by :minmax_by}) (args (arg $_x)) (lvar _x))
+        PATTERN
+
+        # @!method redundant_minmax_by_numblock(node)
+        def_node_matcher :redundant_minmax_by_numblock, <<~PATTERN
+          (numblock $(call _ {:max_by :min_by :minmax_by}) 1 (lvar :_1))
+        PATTERN
+
+        # @!method redundant_minmax_by_itblock(node)
+        def_node_matcher :redundant_minmax_by_itblock, <<~PATTERN
+          (itblock $(call _ {:max_by :min_by :minmax_by}) _ (lvar :it))
+        PATTERN
+
+        def register_offense(send, node, message)
+          range = offense_range(send, node)
+
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, REPLACEMENTS[send.method_name])
+          end
+        end
+
+        def offense_range(send, node)
+          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
+        end
+
+        def message_block(send, var_name)
+          method = send.method_name
+          format(MSG_BLOCK, replacement: REPLACEMENTS[method], original: method, var: var_name)
+        end
+
+        def message_numblock(send)
+          method = send.method_name
+          format(MSG_NUMBLOCK, replacement: REPLACEMENTS[method], original: method)
+        end
+
+        def message_itblock(send)
+          method = send.method_name
+          format(MSG_ITBLOCK, replacement: REPLACEMENTS[method], original: method)
+        end
+      end
+    end
+  end
+end

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

@@ -155,6 +155,9 @@ module RuboCop
           return 'a literal' if node.literal? && disallowed_literal?(begin_node, node)
           return 'a variable' if node.variable?
           return 'a constant' if node.const_type?
+          if begin_node.parent&.any_block_type? && begin_node.parent.body == begin_node
+            return 'block body'
+          end
           if node.assignment? && (begin_node.parent.nil? || begin_node.parent.begin_type?)
             return 'an assignment'
           end
@@ -308,10 +311,10 @@ module RuboCop
         end
 
         def singular_parenthesized_parent?(begin_node)
-          return true unless begin_node.parent
-          return false if begin_node.parent.type?(:splat, :kwsplat)
+          return true unless (parent = begin_node.parent)
+          return false if parent.type?(:splat, :kwsplat)
 
-          parentheses?(begin_node) && begin_node.parent.children.one?
+          parent.children.one?
         end
 
         def only_begin_arg?(args)

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for redundant `return` expressions.
+      # Checks for redundant `return` expressions. Ruby methods
+      # implicitly return the value of the last evaluated expression,
+      # so an explicit `return` at the end of a method body is unnecessary.
       #
       # @example
       #   # These bad cases should be extended to handle methods whose body is

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant `keyword_init` option for `Struct.new`.
+      #
+      # Since Ruby 3.2, `keyword_init` in `Struct.new` defaults to `nil` behavior.
+      # Therefore, this cop detects and autocorrects redundant `keyword_init: nil`
+      # and `keyword_init: true` in `Struct.new`.
+      #
+      # @safety
+      #   This autocorrect is unsafe because when the value of `keyword_init` changes
+      #   from `true` to `nil`, the return value of `Struct#keyword_init?` changes.
+      #
+      # @example
+      #
+      #   # bad
+      #   Struct.new(:foo, keyword_init: nil)
+      #   Struct.new(:foo, keyword_init: true)
+      #
+      #   # good
+      #   Struct.new(:foo)
+      #
+      class RedundantStructKeywordInit < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Remove the redundant `keyword_init: %<value>s`.'
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        minimum_target_ruby_version 3.2
+
+        # @!method struct_new?(node)
+        def_node_matcher :struct_new?, <<~PATTERN
+          (call (const {nil? cbase} :Struct) :new ...)
+        PATTERN
+
+        # @!method keyword_init?(node)
+        def_node_matcher :keyword_init?, <<~PATTERN
+          {#redundant_keyword_init? #keyword_init_false?}
+        PATTERN
+
+        # @!method redundant_keyword_init?(node)
+        def_node_matcher :redundant_keyword_init?, <<~PATTERN
+          (pair (sym :keyword_init) {(true) (nil)})
+        PATTERN
+
+        # @!method keyword_init_false?(node)
+        def_node_matcher :keyword_init_false?, <<~PATTERN
+          (pair (sym :keyword_init) (false))
+        PATTERN
+
+        def on_send(node)
+          return if !struct_new?(node) || node.arguments.none? || !node.last_argument.hash_type?
+
+          keyword_init_nodes = select_keyword_init_nodes(node)
+          return if keyword_init_nodes.any? { |node| keyword_init_false?(node) }
+
+          redundant_keyword_init_nodes = select_redundant_keyword_init_nodes(keyword_init_nodes)
+
+          redundant_keyword_init_nodes.each do |redundant_keyword_init|
+            register_offense(redundant_keyword_init)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def select_keyword_init_nodes(node)
+          node.last_argument.pairs.select do |pair|
+            keyword_init?(pair)
+          end
+        end
+
+        def select_redundant_keyword_init_nodes(keyword_init_nodes)
+          keyword_init_nodes.select do |keyword_init_node|
+            redundant_keyword_init?(keyword_init_node)
+          end
+        end
+
+        def register_offense(keyword_init)
+          message = format(MSG, value: keyword_init.value.source)
+
+          add_offense(keyword_init, message: message) do |corrector|
+            range = range(keyword_init)
+
+            corrector.remove(range)
+          end
+        end
+
+        def range(redundant_keyword_init)
+          if redundant_keyword_init.parent.left_siblings.last.is_a?(AST::Node)
+            beginning_of_range = redundant_keyword_init.parent.left_siblings.last.source_range.end
+
+            beginning_of_range.join(redundant_keyword_init.source_range.end)
+          else
+            redundant_keyword_init
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Looks for places where a subset of an Enumerable (array,
+      # range, set, etc.; see note below) is calculated based on a class type
+      # check, 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`).
+      #
+      # @safety
+      #   Autocorrection is marked as unsafe because the cop cannot guarantee
+      #   that the receiver 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.is_a?(Foo) }
+      #   array.select { |x| x.kind_of?(Foo) }
+      #
+      #   # bad (reject)
+      #   array.reject { |x| x.is_a?(Foo) }
+      #
+      #   # bad (negative form)
+      #   array.reject { |x| !x.is_a?(Foo) }
+      #
+      #   # good
+      #   array.grep(Foo)
+      #   array.grep_v(Foo)
+      class SelectByKind < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Prefer `%<replacement>s` to `%<original_method>s` with a kind check.'
+        RESTRICT_ON_SEND = %i[select filter find_all reject].freeze
+        SELECT_METHODS = %i[select filter find_all].freeze
+        CLASS_CHECK_METHODS = %i[is_a? kind_of?].to_set.freeze
+
+        # @!method class_check?(node)
+        def_node_matcher :class_check?, <<~PATTERN
+          {
+            (block call (args (arg $_)) ${(send (lvar _) %CLASS_CHECK_METHODS _)})
+            (block call (args (arg $_)) ${(send (send (lvar _) %CLASS_CHECK_METHODS _) :!)})
+            (numblock call $1 ${(send (lvar _) %CLASS_CHECK_METHODS _)})
+            (numblock call $1 ${(send (send (lvar _) %CLASS_CHECK_METHODS _) :!)})
+            (itblock call $_ ${(send (lvar _) %CLASS_CHECK_METHODS _)})
+            (itblock call $_ ${(send (send (lvar _) %CLASS_CHECK_METHODS _) :!)})
+          }
+        PATTERN
+
+        # Returns true if a node appears to return a hash
+        # @!method creates_hash?(node)
+        def_node_matcher :creates_hash?, <<~PATTERN
+          {
+            (call (const _ :Hash) {:new :[]} ...)
+            (block (call (const _ :Hash) :new ...) ...)
+            (call _ { :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
+          (send (lvar %1) %CLASS_CHECK_METHODS _)
+        PATTERN
+
+        # @!method negated_calls_lvar?(node, name)
+        def_node_matcher :negated_calls_lvar?, <<~PATTERN
+          (send (send (lvar %1) %CLASS_CHECK_METHODS _) :!)
+        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 (class_check_send_node = extract_send_node(block_node))
+
+          replacement = replacement(class_check_send_node, node)
+          class_constant = find_class_constant(class_check_send_node)
+
+          register_offense(node, block_node, class_constant, replacement)
+        end
+        alias on_csend on_send
+
+        private
+
+        def receiver_allowed?(node)
+          return false unless node
+
+          node.hash_type? || creates_hash?(node) || env_const?(node)
+        end
+
+        def replacement(class_check_send_node, node)
+          negated = negated?(class_check_send_node)
+
+          method_name = node.method_name
+
+          if SELECT_METHODS.include?(method_name)
+            negated ? 'grep_v' : 'grep'
+          else # reject
+            negated ? 'grep' : 'grep_v'
+          end
+        end
+
+        def register_offense(node, block_node, class_constant, replacement)
+          message = format(MSG, replacement: replacement, original_method: node.method_name)
+
+          add_offense(block_node, message: message) do |corrector|
+            if class_constant
+              range = range_between(node.loc.selector.begin_pos, block_node.loc.end.end_pos)
+              corrector.replace(range, "#{replacement}(#{class_constant.source})")
+            end
+          end
+        end
+
+        def extract_send_node(block_node)
+          return unless (block_arg_name, class_check_send_node = class_check?(block_node))
+
+          block_arg_name = :"_#{block_arg_name}" if block_node.numblock_type?
+          block_arg_name = :it if block_node.type?(:itblock)
+
+          inner_node = unwrap_negation(class_check_send_node)
+
+          if calls_lvar?(inner_node, block_arg_name) ||
+             negated_calls_lvar?(class_check_send_node, block_arg_name)
+            class_check_send_node
+          end
+        end
+
+        def negated?(class_check_send_node)
+          class_check_send_node.send_type? && class_check_send_node.method?(:!)
+        end
+
+        def unwrap_negation(node)
+          if node.send_type? && node.method?(:!)
+            node.receiver
+          else
+            node
+          end
+        end
+
+        def find_class_constant(node)
+          inner_node = unwrap_negation(node)
+          inner_node.first_argument if inner_node.send_type?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Looks for places where a subset of an Enumerable (array,
+      # range, set, etc.; see note below) is calculated based on a range
+      # check, 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`).
+      #
+      # @safety
+      #   Autocorrection is marked as unsafe because the cop cannot guarantee
+      #   that the receiver 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.between?(1, 10) }
+      #   array.select { |x| (1..10).cover?(x) }
+      #   array.select { |x| (1..10).include?(x) }
+      #
+      #   # bad (reject)
+      #   array.reject { |x| x.between?(1, 10) }
+      #
+      #   # bad (find or detect)
+      #   array.find { |x| x.between?(1, 10) }
+      #   array.detect { |x| (1..10).cover?(x) }
+      #
+      #   # bad (negative form)
+      #   array.reject { |x| !x.between?(1, 10) }
+      #   array.find { |x| !(1..10).cover?(x) }
+      #
+      #   # good
+      #   array.grep(1..10)
+      #   array.grep_v(1..10)
+      #   array.grep(1..10).first
+      #   array.grep_v(1..10).first
+      class SelectByRange < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Prefer `%<replacement>s` to `%<original_method>s` with a range check.'
+        RESTRICT_ON_SEND = %i[select filter find_all reject find detect].freeze
+        SELECT_METHODS = %i[select filter find_all].freeze
+        FIND_METHODS = %i[find detect].freeze
+
+        # @!method range_check?(node)
+        # Matches: x.between?(min, max) or (min..max).cover?(x) or (min..max).include?(x)
+        def_node_matcher :range_check?, <<~PATTERN
+          {
+            (block call (args (arg $_)) ${(send (lvar _) :between? _ _)})
+            (block call (args (arg $_)) ${(send {range (begin range)} {:cover? :include?} (lvar _))})
+            (block call (args (arg $_)) ${(send (send (lvar _) :between? _ _) :!)})
+            (block call (args (arg $_)) ${(send (send {range (begin range)} {:cover? :include?} (lvar _)) :!)})
+            (block call (args (arg $_)) ${(send (begin (send (lvar _) :between? _ _)) :!)})
+            (block call (args (arg $_)) ${(send (begin (send {range (begin range)} {:cover? :include?} (lvar _))) :!)})
+            (numblock call $1 ${(send (lvar _) :between? _ _)})
+            (numblock call $1 ${(send {range (begin range)} {:cover? :include?} (lvar _))})
+            (numblock call $1 ${(send (send (lvar _) :between? _ _) :!)})
+            (numblock call $1 ${(send (send {range (begin range)} {:cover? :include?} (lvar _)) :!)})
+            (numblock call $1 ${(send (begin (send (lvar _) :between? _ _)) :!)})
+            (numblock call $1 ${(send (begin (send {range (begin range)} {:cover? :include?} (lvar _))) :!)})
+            (itblock call $_ ${(send (lvar _) :between? _ _)})
+            (itblock call $_ ${(send {range (begin range)} {:cover? :include?} (lvar _))})
+            (itblock call $_ ${(send (send (lvar _) :between? _ _) :!)})
+            (itblock call $_ ${(send (send {range (begin range)} {:cover? :include?} (lvar _)) :!)})
+            (itblock call $_ ${(send (begin (send (lvar _) :between? _ _)) :!)})
+            (itblock call $_ ${(send (begin (send {range (begin range)} {:cover? :include?} (lvar _))) :!)})
+          }
+        PATTERN
+
+        # Returns true if a node appears to return a hash
+        # @!method creates_hash?(node)
+        def_node_matcher :creates_hash?, <<~PATTERN
+          {
+            (call (const _ :Hash) {:new :[]} ...)
+            (block (call (const _ :Hash) :new ...) ...)
+            (call _ { :to_h :to_hash } ...)
+          }
+        PATTERN
+
+        # @!method env_const?(node)
+        def_node_matcher :env_const?, <<~PATTERN
+          (const {nil? cbase} :ENV)
+        PATTERN
+
+        # @!method between_call?(node, name)
+        def_node_matcher :between_call?, <<~PATTERN
+          (send (lvar %1) :between? _ _)
+        PATTERN
+
+        # @!method range_cover_call?(node, name)
+        def_node_matcher :range_cover_call?, <<~PATTERN
+          (send {range (begin range)} {:cover? :include?} (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 (range_check_send_node = extract_send_node(block_node))
+
+          replacement = replacement(range_check_send_node, node)
+          range_literal = find_range(range_check_send_node)
+
+          register_offense(node, block_node, range_literal, replacement)
+        end
+        alias on_csend on_send
+
+        private
+
+        def receiver_allowed?(node)
+          return false unless node
+
+          node.hash_type? || creates_hash?(node) || env_const?(node)
+        end
+
+        def replacement(range_check_send_node, node)
+          negated = negated?(range_check_send_node)
+          method_name = node.method_name
+
+          if SELECT_METHODS.include?(method_name)
+            negated ? 'grep_v' : 'grep'
+          elsif FIND_METHODS.include?(method_name)
+            negated ? 'grep_v(...).first' : 'grep(...).first'
+          else # reject
+            negated ? 'grep' : 'grep_v'
+          end
+        end
+
+        def register_offense(node, block_node, range_literal, replacement)
+          message = format(MSG, replacement: replacement, original_method: node.method_name)
+
+          add_offense(block_node, message: message) do |corrector|
+            if range_literal
+              range = range_between(node.loc.selector.begin_pos, block_node.loc.end.end_pos)
+              grep_method = replacement.include?('grep_v') ? 'grep_v' : 'grep'
+              suffix = replacement.include?('.first') ? '.first' : ''
+              corrector.replace(range, "#{grep_method}(#{range_literal})#{suffix}")
+            end
+          end
+        end
+
+        def extract_send_node(block_node)
+          return unless (block_arg_name, range_check_send_node = range_check?(block_node))
+
+          block_arg_name = :"_#{block_arg_name}" if block_node.numblock_type?
+          block_arg_name = :it if block_node.type?(:itblock)
+
+          inner_node = unwrap_negation(range_check_send_node)
+
+          range_check_send_node if calls_lvar_in_range_check?(inner_node, block_arg_name)
+        end
+
+        def calls_lvar_in_range_check?(node, block_arg_name)
+          between_call?(node, block_arg_name) || range_cover_call?(node, block_arg_name)
+        end
+
+        def negated?(range_check_send_node)
+          range_check_send_node.send_type? && range_check_send_node.method?(:!)
+        end
+
+        def unwrap_negation(node)
+          if node.send_type? && node.method?(:!)
+            receiver = node.receiver
+            receiver = receiver.children.first if receiver.begin_type?
+            receiver
+          else
+            node
+          end
+        end
+
+        def find_range(node)
+          inner = unwrap_negation(node)
+
+          if inner.method?(:between?)
+            # x.between?(min, max) -> min..max
+            min = inner.first_argument.source
+            max = inner.arguments[1].source
+            "#{min}..#{max}"
+          else
+            # (min..max).cover?(x) or (min..max).include?(x)
+            receiver = inner.receiver
+            # Unwrap begin node from parentheses
+            receiver = receiver.children.first if receiver.begin_type?
+            receiver.source
+          end
+        end
+      end
+    end
+  end
+end