rubocop 1.42.0 → 1.45.1

data/lib/rubocop/cop/metrics/parameter_lists.rb

@@ -9,6 +9,20 @@ module RuboCop
       # Keyword arguments can optionally be excluded from the total count,
       # as they add less complexity than positional or optional parameters.
       #
+      # Any number of arguments for `initialize` method inside a block of
+      # `Struct.new` and `Data.define` like this is always allowed:
+      #
+      # [source,ruby]
+      # ----
+      # Struct.new(:one, :two, :three, :four, :five, keyword_init: true) do
+      #   def initialize(one:, two:, three:, four:, five:)
+      #   end
+      # end
+      # ----
+      #
+      # This is because checking the number of arguments of the `initialize` method
+      # does not make sense.
+      #
       # NOTE: Explicit block argument `&block` is not counted to prevent
       # erroneous change that is avoided by making block argument implicit.
       #
@@ -63,6 +77,16 @@ module RuboCop
         NAMED_KEYWORD_TYPES = %i[kwoptarg kwarg].freeze
         private_constant :NAMED_KEYWORD_TYPES
 
+        # @!method struct_new_or_data_define_block?(node)
+        def_node_matcher :struct_new_or_data_define_block?, <<~PATTERN
+          (block
+            {
+              (send (const {nil? cbase} :Struct) :new ...)
+              (send (const {nil? cbase} :Data) :define ...)
+            }
+            (args) ...)
+        PATTERN
+
         def on_def(node)
           optargs = node.arguments.select(&:optarg_type?)
           return if optargs.count <= max_optional_parameters
@@ -78,6 +102,9 @@ module RuboCop
         alias on_defs on_def
 
         def on_args(node)
+          parent = node.parent
+          return if parent.method?(:initialize) && struct_new_or_data_define_block?(parent.parent)
+
           count = args_count(node)
           return unless count > max_params
 

data/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb

@@ -25,10 +25,7 @@ module RuboCop
           # > http://c2.com/cgi/wiki?AbcMetric
           CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
 
-          # TODO: move to rubocop-ast
-          ARGUMENT_TYPES = %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg].freeze
-
-          private_constant :BRANCH_NODES, :CONDITION_NODES, :ARGUMENT_TYPES
+          private_constant :BRANCH_NODES, :CONDITION_NODES
 
           def self.calculate(node, discount_repeated_attributes: false)
             new(node, discount_repeated_attributes: discount_repeated_attributes).calculate
@@ -129,7 +126,7 @@ module RuboCop
           end
 
           def argument?(node)
-            ARGUMENT_TYPES.include?(node.type) && capturing_variable?(node.children.first)
+            node.argument_type? && capturing_variable?(node.children.first)
           end
 
           def condition?(node)

data/lib/rubocop/cop/mixin/alignment.rb

@@ -12,7 +12,7 @@ module RuboCop
       attr_reader :column_delta
 
       def configured_indentation_width
-        cop_config['IndentationWidth'] || config.for_cop('Layout/IndentationWidth')['Width']
+        cop_config['IndentationWidth'] || config.for_cop('Layout/IndentationWidth')['Width'] || 2
       end
 
       def indentation(node)

data/lib/rubocop/cop/mixin/allowed_methods.rb

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     # This module encapsulates the ability to allow certain methods when
-    # parsing.
+    # parsing. Even if the code is in offense, if it contains methods
+    # that are allowed. This module is equivalent to the IgnoredMethods module,
+    # which will be deprecated in RuboCop 2.0.
     module AllowedMethods
       private
 

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -62,10 +62,12 @@ module RuboCop
       # Returns the end line of a node, which might be a comment and not part of the AST
       # End line is considered either the line at which another node starts, or
       # the line at which the parent node ends.
-      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def find_end_line(node)
-        if node.if_type? && node.loc.else
+        if node.if_type? && node.else?
           node.loc.else.line
+        elsif node.if_type? && node.ternary?
+          node.else_branch.loc.line
         elsif (next_sibling = node.right_sibling)
           next_sibling.loc.line
         elsif (parent = node.parent)
@@ -74,7 +76,7 @@ module RuboCop
           node.loc.end.line
         end
       end
-      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     end
   end
 end

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -3,6 +3,7 @@
 module RuboCop
   module Cop
     # This module checks for Ruby 3.1's hash value omission syntax.
+    # rubocop:disable Metrics/ModuleLength
     module HashShorthandSyntax
       OMIT_HASH_VALUE_MSG = 'Omit the hash value.'
       EXPLICIT_HASH_VALUE_MSG = 'Include the hash value.'
@@ -45,21 +46,22 @@ module RuboCop
 
       private
 
-      # rubocop:disable Metrics/AbcSize
-      def register_offense(node, message, replacement)
+      def register_offense(node, message, replacement) # rubocop:disable Metrics/AbcSize
         add_offense(node.value, message: message) do |corrector|
           if (def_node = def_node_that_require_parentheses(node))
-            white_spaces = range_between(def_node.loc.selector.end_pos,
+            last_argument = def_node.last_argument
+            if last_argument.nil? || !last_argument.hash_type?
+              next corrector.replace(node, replacement)
+            end
+
+            white_spaces = range_between(def_node.selector.end_pos,
                                          def_node.first_argument.source_range.begin_pos)
             corrector.replace(white_spaces, '(')
-
-            last_argument = def_node.arguments.last
             corrector.insert_after(last_argument, ')') if node == last_argument.pairs.last
           end
           corrector.replace(node, replacement)
         end
       end
-      # rubocop:enable Metrics/AbcSize
 
       def ignore_mixed_hash_shorthand_syntax?(hash_node)
         target_ruby_version <= 3.0 || enforced_shorthand_syntax != 'consistent' ||
@@ -86,25 +88,37 @@ module RuboCop
       end
 
       def require_hash_value_for_around_hash_literal?(node)
-        return false unless (send_node = find_ancestor_send_node(node))
+        return false unless (method_dispatch_node = find_ancestor_method_dispatch_node(node))
 
-        !node.parent.braces? && !use_element_of_hash_literal_as_receiver?(send_node, node.parent) &&
-          use_modifier_form_without_parenthesized_method_call?(send_node)
+        !node.parent.braces? &&
+          !use_element_of_hash_literal_as_receiver?(method_dispatch_node, node.parent) &&
+          use_modifier_form_without_parenthesized_method_call?(method_dispatch_node)
       end
 
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def def_node_that_require_parentheses(node)
-        return unless (send_node = find_ancestor_send_node(node))
-        return unless without_parentheses_call_expr_follows?(send_node)
+        last_pair = node.parent.pairs.last
+        return unless last_pair.key.source == last_pair.value.source
+        return unless (dispatch_node = find_ancestor_method_dispatch_node(node))
+        return if node.respond_to?(:parenthesized?) && !node.parenthesized?
+        return unless last_expression?(dispatch_node) || method_dispatch_as_argument?(dispatch_node)
 
-        def_node = node.each_ancestor(:send, :csend).first
+        def_node = node.each_ancestor(:send, :csend, :super, :yield).first
 
-        def_node unless def_node && def_node.arguments.empty?
+        DefNode.new(def_node) unless def_node && def_node.arguments.empty?
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-      def find_ancestor_send_node(node)
-        ancestor = node.parent.parent
+      def find_ancestor_method_dispatch_node(node)
+        return unless (ancestor = node.parent.parent)
+        return unless ancestor.call_type? || ancestor.super_type? || ancestor.yield_type?
+        return if brackets?(ancestor)
+
+        ancestor
+      end
 
-        ancestor if ancestor&.call_type? && !ancestor&.method?(:[])
+      def brackets?(method_dispatch_node)
+        method_dispatch_node.method?(:[]) || method_dispatch_node.method?(:[]=)
       end
 
       def use_element_of_hash_literal_as_receiver?(ancestor, parent)
@@ -118,15 +132,16 @@ module RuboCop
         ancestor.ancestors.any? { |node| node.respond_to?(:modifier_form?) && node.modifier_form? }
       end
 
-      def without_parentheses_call_expr_follows?(ancestor)
-        return false unless ancestor.respond_to?(:parenthesized?) && !ancestor.parenthesized?
+      def last_expression?(ancestor)
+        ancestor.right_sibling ||
+          ancestor.each_ancestor.find { |node| node.assignment? || node.send_type? }&.right_sibling
+      end
 
-        right_sibling = ancestor.right_sibling
-        right_sibling ||= ancestor.each_ancestor.find do |node|
-          node.assignment? || node.send_type?
-        end&.right_sibling
+      def method_dispatch_as_argument?(method_dispatch_node)
+        parent = method_dispatch_node.parent
+        return false unless parent
 
-        !!right_sibling
+        parent.call_type? || parent.super_type? || parent.yield_type?
       end
 
       def breakdown_value_types_of_hash(hash_node)
@@ -182,6 +197,25 @@ module RuboCop
           register_offense(pair_node, OMIT_HASH_VALUE_MSG, replacement)
         end
       end
+
+      DefNode = Struct.new(:node) do
+        def selector
+          if node.loc.respond_to?(:selector)
+            node.loc.selector
+          else
+            node.loc.keyword
+          end
+        end
+
+        def first_argument
+          node.first_argument
+        end
+
+        def last_argument
+          node.last_argument
+        end
+      end
     end
   end
+  # rubocop:enable Metrics/ModuleLength
 end

data/lib/rubocop/cop/mixin/line_length_help.rb

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     # Help methods for determining if a line is too long.
     module LineLengthHelp
+      include Alignment
+
       private
 
       def ignore_cop_directives?
@@ -85,7 +87,7 @@ module RuboCop
 
       def tab_indentation_width
         config.for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
-          config.for_cop('Layout/IndentationWidth')['Width']
+          configured_indentation_width
       end
 
       def uri_regexp

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -5,6 +5,7 @@ module RuboCop
     # Common functionality for modifier cops.
     module StatementModifier
       include LineLengthHelp
+      include RangeHelp
 
       private
 

data/lib/rubocop/cop/mixin/surrounding_space.rb

@@ -107,9 +107,9 @@ module RuboCop
         end
       end
 
-      def empty_brackets?(left_bracket_token, right_bracket_token)
-        left_index = processed_source.tokens.index(left_bracket_token)
-        right_index = processed_source.tokens.index(right_bracket_token)
+      def empty_brackets?(left_bracket_token, right_bracket_token, tokens: processed_source.tokens)
+        left_index = tokens.index(left_bracket_token)
+        right_index = tokens.index(right_bracket_token)
         right_index && left_index == right_index - 1
       end
 

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -132,7 +132,7 @@ module RuboCop
 
       def avoid_comma(kind, comma_begin_pos, extra_info)
         range = range_between(comma_begin_pos, comma_begin_pos + 1)
-        article = /array/.match?(kind) ? 'an' : 'a'
+        article = kind.include?('array') ? 'an' : 'a'
         msg = format(
           MSG,
           command: 'Avoid',

data/lib/rubocop/cop/naming/block_forwarding.rb

@@ -47,6 +47,10 @@ module RuboCop
 
         MSG = 'Use %<style>s block forwarding.'
 
+        def self.autocorrect_incompatible_with
+          [Lint::AmbiguousOperator]
+        end
+
         def on_def(node)
           return if node.arguments.empty?
 

data/lib/rubocop/cop/naming/class_and_module_camel_case.rb

@@ -34,7 +34,7 @@ module RuboCop
 
           allowed = /#{cop_config['AllowedNames'].join('|')}/
           name = node.loc.name.source.gsub(allowed, '')
-          return unless /_/.match?(name)
+          return unless name.include?('_')
 
           add_offense(node.loc.name)
         end

data/lib/rubocop/cop/registry.rb

@@ -41,6 +41,11 @@ module RuboCop
         @global = new
       end
 
+      def self.qualified_cop?(name)
+        badge = Badge.parse(name)
+        global.qualify_badge(badge).first == badge
+      end
+
       attr_reader :options
 
       def initialize(cops = [], options = {})
@@ -158,6 +163,13 @@ module RuboCop
           'RedundantCopDisableDirective'
       end
 
+      def qualify_badge(badge)
+        clear_enrollment_queue
+        @departments
+          .map { |department, _| badge.with_department(department) }
+          .select { |potential_badge| registered?(potential_badge) }
+      end
+
       # @return [Hash{String => Array<Class>}]
       def to_h
         clear_enrollment_queue
@@ -282,13 +294,6 @@ module RuboCop
         self.class.new(cops)
       end
 
-      def qualify_badge(badge)
-        clear_enrollment_queue
-        @departments
-          .map { |department, _| badge.with_department(department) }
-          .select { |potential_badge| registered?(potential_badge) }
-      end
-
       def resolve_badge(given_badge, real_badge, source_path)
         unless given_badge.match?(real_badge)
           path = PathUtil.smart_path(source_path)

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

@@ -115,9 +115,7 @@ module RuboCop
             def_node = find_corresponding_def_node(node)
             return unless def_node
 
-            remove_node(corrector, def_node)
-            remove_node(corrector, node)
-            insert_def(corrector, node, def_node.source)
+            replace_def(corrector, node, def_node)
           when :inline
             remove_node(corrector, node)
             select_grouped_def_nodes(node).each do |grouped_def_node|
@@ -131,7 +129,8 @@ module RuboCop
         end
 
         def offense?(node)
-          (group_style? && access_modifier_is_inlined?(node)) ||
+          (group_style? && access_modifier_is_inlined?(node) &&
+            !right_siblings_same_inline_method?(node)) ||
             (inline_style? && access_modifier_is_not_inlined?(node))
         end
 
@@ -151,6 +150,12 @@ module RuboCop
           !access_modifier_is_inlined?(node)
         end
 
+        def right_siblings_same_inline_method?(node)
+          node.right_siblings.any? do |sibling|
+            sibling.send_type? && sibling.method?(node.method_name) && !sibling.arguments.empty?
+          end
+        end
+
         def message(range)
           access_modifier = range.source
 
@@ -173,7 +178,9 @@ module RuboCop
         end
 
         def find_argument_less_modifier_node(node)
-          node.parent.each_child_node(:send).find do |child|
+          return unless (parent = node.parent)
+
+          parent.each_child_node(:send).find do |child|
             child.method?(node.method_name) && child.arguments.empty?
           end
         end
@@ -184,17 +191,21 @@ module RuboCop
           end.select(&:def_type?)
         end
 
-        def insert_def(corrector, node, source)
-          source = [*processed_source.ast_with_comments[node].map(&:text), source].join("\n")
+        def replace_def(corrector, node, def_node)
+          source = def_source(node, def_node)
           argument_less_modifier_node = find_argument_less_modifier_node(node)
           if argument_less_modifier_node
             corrector.insert_after(argument_less_modifier_node, "\n\n#{source}")
+          elsif (ancestor = node.each_ancestor(:block, :class, :module).first)
+
+            corrector.insert_before(ancestor.loc.end, "#{node.method_name}\n\n#{source}\n")
           else
-            corrector.insert_before(
-              node.each_ancestor(:block, :class, :module).first.location.end,
-              "#{node.method_name}\n\n#{source}\n"
-            )
+            corrector.replace(node, "#{node.method_name}\n\n#{source}")
+            return
           end
+
+          remove_node(corrector, def_node)
+          remove_node(corrector, node)
         end
 
         def insert_inline_modifier(corrector, node, modifier_name)
@@ -204,6 +215,10 @@ module RuboCop
         def remove_node(corrector, node)
           corrector.remove(range_with_comments_and_lines(node))
         end
+
+        def def_source(node, def_node)
+          [*processed_source.ast_with_comments[node].map(&:text), def_node.source].join("\n")
+        end
       end
     end
   end

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

@@ -84,6 +84,7 @@ module RuboCop
         def on_def(node)
           return unless node.body
           return unless (rest_args_name, args = use_rest_arguments?(node.arguments))
+          return if args.any?(&:default?)
 
           node.each_descendant(:send) do |send_node|
             kwargs_name, block_name = extract_argument_names_from(args)

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

@@ -299,8 +299,8 @@ module RuboCop
 
         def move_comment_before_block(corrector, comment, block_node, closing_brace)
           range = block_node.chained? ? end_of_chain(block_node.parent).source_range : closing_brace
-          comment_range = range_between(range.end_pos, comment.loc.expression.end_pos)
-          corrector.remove(range_with_surrounding_space(comment_range, side: :right))
+          corrector.remove(range_with_surrounding_space(comment.loc.expression, side: :right))
+          remove_trailing_whitespace(corrector, range, comment)
           corrector.insert_after(range, "\n")
 
           corrector.insert_before(block_node, "#{comment.text}\n")
@@ -313,6 +313,12 @@ module RuboCop
           end_of_chain(node.parent)
         end
 
+        def remove_trailing_whitespace(corrector, range, comment)
+          range_of_trailing = range.end.join(comment.loc.expression.begin)
+
+          corrector.remove(range_of_trailing) if range_of_trailing.source.match?(/\A\s+\z/)
+        end
+
         def with_block?(node)
           node.respond_to?(:block_node) && node.block_node
         end

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

@@ -31,6 +31,7 @@ module RuboCop
       #
       # The compact style is only forced for classes/modules with one child.
       class ClassAndModuleChildren < Base
+        include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
         extend AutoCorrector
@@ -59,7 +60,7 @@ module RuboCop
         end
 
         def nest_definition(corrector, node)
-          padding = ((' ' * indent_width) + leading_spaces(node)).to_s
+          padding = indentation(node) + leading_spaces(node)
           padding_for_trailing_end = padding.sub(' ' * node.loc.end.column, '')
 
           replace_namespace_keyword(corrector, node)
@@ -124,10 +125,6 @@ module RuboCop
           corrector.remove(range)
         end
 
-        def configured_indentation_width
-          config.for_badge(Layout::IndentationWidth.badge).fetch('Width', 2)
-        end
-
         def unindent(corrector, node)
           return if node.body.children.last.nil?
 
@@ -141,10 +138,6 @@ module RuboCop
           node.source_range.source_line[/\A\s*/]
         end
 
-        def indent_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
-        end
-
         def check_style(node, body)
           return if node.identifier.children[0]&.cbase_type?
 
@@ -185,7 +178,7 @@ module RuboCop
         end
 
         def compact_node_name?(node)
-          /::/.match?(node.identifier.source)
+          node.identifier.source.include?('::')
         end
       end
     end

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

@@ -148,7 +148,7 @@ module RuboCop
         end
 
         def contains_backtick?(node)
-          /`/.match?(node_body(node))
+          node_body(node).include?('`')
         end
 
         def node_body(node)

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of `Comparable#clamp` instead of comparison by minimum and maximum.
+      #
+      # This cop supports autocorrection for `if/elsif/else` bad style only.
+      # Because `ArgumentError` occurs if the minimum and maximum of `clamp` arguments are reversed.
+      # When these are variables, it is not possible to determine which is the minimum and maximum:
+      #
+      # [source,ruby]
+      # ----
+      # [1, [2, 3].max].min # => 1
+      # 1.clamp(3, 1)       # => min argument must be smaller than max argument (ArgumentError)
+      # ----
+      #
+      # @example
+      #
+      #   # bad
+      #   [[x, low].max, high].min
+      #
+      #   # bad
+      #   if x < low
+      #     low
+      #   elsif high < x
+      #     high
+      #   else
+      #     x
+      #   end
+      #
+      #   # good
+      #   x.clamp(low, high)
+      #
+      class ComparableClamp < Base
+        include Alignment
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.4
+
+        MSG = 'Use `%<prefer>s` instead of `if/elsif/else`.'
+        MSG_MIN_MAX = 'Use `Comparable#clamp` instead.'
+        RESTRICT_ON_SEND = %i[min max].freeze
+
+        # @!method if_elsif_else_condition?(node)
+        def_node_matcher :if_elsif_else_condition?, <<~PATTERN
+          {
+            (if (send _x :< _min) _min (if (send _max :< _x) _max _x))
+            (if (send _min :> _x) _min (if (send _max :< _x) _max _x))
+            (if (send _x :< _min) _min (if (send _x :> _max) _max _x))
+            (if (send _min :> _x) _min (if (send _x :> _max) _max _x))
+            (if (send _max :< _x) _max (if (send _x :< _min) _min _x))
+            (if (send _x :> _max) _max (if (send _x :< _min) _min _x))
+            (if (send _max :< _x) _max (if (send _min :> _x) _min _x))
+            (if (send _x :> _max) _max (if (send _min :> _x) _min _x))
+          }
+        PATTERN
+
+        # @!method array_min_max?(node)
+        def_node_matcher :array_min_max?, <<~PATTERN
+          {
+            (send
+              (array
+                (send (array _ _) :max) _) :min)
+            (send
+              (array
+                _ (send (array _ _) :max)) :min)
+            (send
+              (array
+                (send (array _ _) :min) _) :max)
+            (send
+              (array
+                _ (send (array _ _) :min)) :max)
+          }
+        PATTERN
+
+        def on_if(node)
+          return unless if_elsif_else_condition?(node)
+
+          if_body, elsif_body, else_body = *node.branches
+
+          else_body_source = else_body.source
+
+          if min_condition?(node.condition, else_body_source)
+            min = if_body.source
+            max = elsif_body.source
+          else
+            min = elsif_body.source
+            max = if_body.source
+          end
+
+          prefer = "#{else_body_source}.clamp(#{min}, #{max})"
+
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            autocorrect(corrector, node, prefer)
+          end
+        end
+
+        def on_send(node)
+          return unless array_min_max?(node)
+
+          add_offense(node, message: MSG_MIN_MAX)
+        end
+
+        private
+
+        def autocorrect(corrector, node, prefer)
+          if node.elsif?
+            corrector.insert_before(node, "else\n")
+            corrector.replace(node, "#{indentation(node)}#{prefer}")
+          else
+            corrector.replace(node, prefer)
+          end
+        end
+
+        def min_condition?(if_condition, else_body)
+          lhs, op, rhs = *if_condition
+
+          (lhs.source == else_body && op == :<) || (rhs.source == else_body && op == :>)
+        end
+      end
+    end
+  end
+end