rubocop 1.32.0 → 1.37.0

data/lib/rubocop/cop/lint/redundant_with_object.rb

@@ -31,19 +31,8 @@ module RuboCop
         extend AutoCorrector
 
         MSG_EACH_WITH_OBJECT = 'Use `each` instead of `each_with_object`.'
-
         MSG_WITH_OBJECT = 'Remove redundant `with_object`.'
 
-        # @!method redundant_with_object?(node)
-        def_node_matcher :redundant_with_object?, <<~PATTERN
-          (block
-            $(send _ {:each_with_object :with_object}
-              _)
-            (args
-              (arg _))
-            ...)
-        PATTERN
-
         def on_block(node)
           return unless (send = redundant_with_object?(node))
 
@@ -59,8 +48,20 @@ module RuboCop
           end
         end
 
+        alias on_numblock on_block
+
         private
 
+        # @!method redundant_with_object?(node)
+        def_node_matcher :redundant_with_object?, <<~PATTERN
+          {
+            (block
+              $(send _ {:each_with_object :with_object} _) (args (arg _)) ...)
+            (numblock
+              $(send _ {:each_with_object :with_object} _) 1 ...)
+          }
+        PATTERN
+
         def message(node)
           if node.method?(:each_with_object)
             MSG_EACH_WITH_OBJECT

data/lib/rubocop/cop/lint/require_parentheses.rb

@@ -46,7 +46,7 @@ module RuboCop
         private
 
         def check_ternary(ternary, node)
-          return unless ternary.condition.operator_keyword?
+          return if node.method?(:[]) || !ternary.condition.operator_keyword?
 
           range = range_between(node.source_range.begin_pos, ternary.condition.source_range.end_pos)
 

data/lib/rubocop/cop/lint/safe_navigation_chain.rb

@@ -31,6 +31,7 @@ module RuboCop
         minimum_target_ruby_version 2.3
 
         MSG = 'Do not chain ordinary method call after safe navigation operator.'
+        PLUS_MINUS_METHODS = %i[+@ -@].freeze
 
         # @!method bad_method?(node)
         def_node_matcher :bad_method?, <<~PATTERN
@@ -42,7 +43,7 @@ module RuboCop
 
         def on_send(node)
           bad_method?(node) do |safe_nav, method|
-            return if nil_methods.include?(method)
+            return if nil_methods.include?(method) || PLUS_MINUS_METHODS.include?(node.method_name)
 
             method_chain = method_chain(node)
             location =
@@ -71,7 +72,7 @@ module RuboCop
             else
               offense_range.source.dup
             end
-          source.prepend('.') unless send_node.dot?
+          source.prepend('.') unless source.start_with?('.')
           source.prepend('&')
         end
 

data/lib/rubocop/cop/lint/shadowed_exception.rb

@@ -7,6 +7,14 @@ module RuboCop
       # less specific exception being rescued before a more specific
       # exception is rescued.
       #
+      # An exception is considered shadowed if it is rescued after its
+      # ancestor is, or if it and its ancestor are both rescued in the
+      # same `rescue` statement. In both cases, the more specific rescue is
+      # unnecessary because it is covered by rescuing the less specific
+      # exception. (ie. `rescue Exception, StandardError` has the same behavior
+      # whether `StandardError` is included or not, because all ``StandardError``s
+      # are rescued by `rescue Exception`).
+      #
       # @example
       #
       #   # bad
@@ -19,6 +27,13 @@ module RuboCop
       #     handle_standard_error
       #   end
       #
+      #   # bad
+      #   begin
+      #     something
+      #   rescue Exception, StandardError
+      #     handle_error
+      #   end
+      #
       #   # good
       #
       #   begin
@@ -140,16 +155,6 @@ module RuboCop
           end
         end
 
-        # @param [RuboCop::AST::Node] rescue_group is a node of array_type
-        def rescued_exceptions(rescue_group)
-          klasses = *rescue_group
-          klasses.map do |klass|
-            next unless klass.const_type?
-
-            klass.source
-          end.compact
-        end
-
         def find_shadowing_rescue(rescues)
           rescued_groups = rescued_groups_for(rescues)
           rescued_groups.zip(rescues).each do |group, res|

data/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb

@@ -12,9 +12,12 @@ module RuboCop
       # because `Ractor` should not access outer variables.
       # eg. following style is encouraged:
       #
+      #   [source,ruby]
+      #   ----
       #   worker_id, pipe = env
       #   Ractor.new(worker_id, pipe) do |worker_id, pipe|
       #   end
+      #   ----
       #
       # @example
       #
@@ -64,12 +67,33 @@ module RuboCop
         end
 
         def same_conditions_node_different_branch?(variable, outer_local_variable)
-          variable_node = variable.scope.node.parent
+          variable_node = variable_node(variable)
           return false unless variable_node.conditional?
 
-          outer_local_variable_node = outer_local_variable.scope.node
+          outer_local_variable_node =
+            find_conditional_node_from_ascendant(outer_local_variable.declaration_node)
+          return true unless outer_local_variable_node
 
-          outer_local_variable_node.conditional? && variable_node == outer_local_variable_node
+          outer_local_variable_node.conditional? &&
+            (variable_node == outer_local_variable_node ||
+              variable_node == outer_local_variable_node.else_branch)
+        end
+
+        def variable_node(variable)
+          parent_node = variable.scope.node.parent
+
+          if parent_node.when_type?
+            parent_node.parent
+          else
+            parent_node
+          end
+        end
+
+        def find_conditional_node_from_ascendant(node)
+          return unless (parent = node.parent)
+          return parent if parent.conditional?
+
+          find_conditional_node_from_ascendant(parent)
         end
       end
     end

data/lib/rubocop/cop/lint/unreachable_loop.rb

@@ -9,7 +9,7 @@ module RuboCop
       # In rare cases where only one iteration (or at most one iteration) is intended behavior,
       # the code should be refactored to use `if` conditionals.
       #
-      # NOTE: Block methods that are used with `Enumerable`s are considered to be loops.
+      # NOTE: Block methods that are used with ``Enumerable``s are considered to be loops.
       #
       # `AllowedPatterns` can be used to match against the block receiver in order to allow
       # code that would otherwise be registered as an offense (eg. `times` used not in an
@@ -79,7 +79,7 @@ module RuboCop
       #   # bad
       #   2.times { raise ArgumentError }
       #
-      # @example AllowedPatterns: [/(exactly|at_least|at_most)\(\d+\)\.times/] (default)
+      # @example AllowedPatterns: ['(exactly|at_least|at_most)\(\d+\)\.times'] (default)
       #
       #   # good
       #   exactly(2).times { raise StandardError }
@@ -101,10 +101,14 @@ module RuboCop
           check(node) if loop_method?(node)
         end
 
+        def on_numblock(node)
+          check(node) if loop_method?(node)
+        end
+
         private
 
         def loop_method?(node)
-          return false unless node.block_type?
+          return false unless node.block_type? || node.numblock_type?
 
           send_node = node.send_node
           return false if matches_allowed_pattern?(send_node.source)
@@ -179,6 +183,8 @@ module RuboCop
 
         def preceded_by_continue_statement?(break_statement)
           break_statement.left_siblings.any? do |sibling|
+            # Numblocks have the arguments count as a number in the AST.
+            next if sibling.is_a?(Integer)
             next if sibling.loop_keyword? || loop_method?(sibling)
 
             sibling.each_descendant(*CONTINUE_KEYWORDS).any?

data/lib/rubocop/cop/lint/unused_method_argument.rb

@@ -68,6 +68,10 @@ module RuboCop
            (send nil? :fail ...)}
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Style::ExplicitBlockArgument]
+        end
+
         def self.joining_forces
           VariableForce
         end

data/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -31,8 +31,8 @@ module RuboCop
       #   # bad
       #   class Foo
       #     # The following is redundant (methods defined on the class'
-      #     # singleton class are not affected by the public modifier)
-      #     public
+      #     # singleton class are not affected by the private modifier)
+      #     private
       #
       #     def self.method3
       #     end
@@ -142,6 +142,8 @@ module RuboCop
           check_node(node.body)
         end
 
+        alias on_numblock on_block
+
         private
 
         def autocorrect(corrector, node)
@@ -157,17 +159,17 @@ module RuboCop
 
         # @!method dynamic_method_definition?(node)
         def_node_matcher :dynamic_method_definition?, <<~PATTERN
-          {(send nil? :define_method ...) (block (send nil? :define_method ...) ...)}
+          {(send nil? :define_method ...) ({block numblock} (send nil? :define_method ...) ...)}
         PATTERN
 
         # @!method class_or_instance_eval?(node)
         def_node_matcher :class_or_instance_eval?, <<~PATTERN
-          (block (send _ {:class_eval :instance_eval}) ...)
+          ({block numblock} (send _ {:class_eval :instance_eval}) ...)
         PATTERN
 
         # @!method class_or_module_or_struct_new_call?(node)
         def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
-          (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
+          ({block numblock} (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
         PATTERN
 
         def check_node(node)
@@ -277,7 +279,7 @@ module RuboCop
             matcher_name = "#{m}_block?".to_sym
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<~PATTERN
-                (block (send {nil? const} {:#{m}} ...) ...)
+                ({block numblock} (send {nil? const} {:#{m}} ...) ...)
               PATTERN
             end
 

data/lib/rubocop/cop/lint/useless_ruby2_keywords.rb

@@ -6,7 +6,7 @@ module RuboCop
       # Looks for `ruby2_keywords` calls for methods that do not need it.
       #
       # `ruby2_keywords` should only be called on methods that accept an argument splat
-      # (`*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
+      # (`\*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
       # a keyword splat (`**kwargs`).
       #
       # @example

data/lib/rubocop/cop/lint/void.rb

@@ -67,6 +67,8 @@ module RuboCop
           check_expression(node.body)
         end
 
+        alias on_numblock on_block
+
         def on_begin(node)
           check_begin(node)
         end

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

@@ -33,7 +33,9 @@ module RuboCop
       #      render 'pages/search/page'
       #    end
       #
-      # This cop also takes into account `IgnoredMethods` (defaults to `[]`)
+      # This cop also takes into account `AllowedMethods` (defaults to `[]`)
+      # And `AllowedPatterns` (defaults to `[]`)
+      #
       class AbcSize < Base
         include MethodComplexity
 

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

@@ -14,8 +14,8 @@ module RuboCop
       #
       #
       # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
-      # for backwards compatibility. Please use `IgnoredMethods` instead.
-      # By default, there are no methods to ignored.
+      # for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns`
+      # instead. By default, there are no methods to allowed.
       #
       # @example CountAsOne: ['array', 'heredoc']
       #
@@ -38,14 +38,13 @@ module RuboCop
       # NOTE: This cop does not apply for `Struct` definitions.
       class BlockLength < Base
         include CodeLength
-        include IgnoredMethods
-
-        ignored_methods deprecated_key: 'ExcludedMethods'
+        include AllowedMethods
+        include AllowedPattern
 
         LABEL = 'Block'
 
         def on_block(node)
-          return if ignored_method?(node.method_name)
+          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
           return if method_receiver_excluded?(node)
           return if node.class_constructor? || node.struct_constructor?
 
@@ -59,7 +58,7 @@ module RuboCop
           node_receiver = node.receiver&.source&.gsub(/\s+/, '')
           node_method = String(node.method_name)
 
-          ignored_methods.any? do |config|
+          allowed_methods.any? do |config|
             next unless config.is_a?(String)
 
             receiver, method = config.split('.')

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

@@ -4,16 +4,17 @@ module RuboCop
   module Cop
     module Metrics
       # Checks if the length of a method exceeds some maximum value.
-      # Comment lines can optionally be ignored.
+      # Comment lines can optionally be allowed.
       # The maximum allowed length is configurable.
       #
       # You can set literals you want to fold with `CountAsOne`.
       # Available are: 'array', 'hash', and 'heredoc'. Each literal
       # will be counted as one line regardless of its actual size.
       #
-      # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
-      # for backwards compatibility. Please use `IgnoredMethods` instead.
-      # By default, there are no methods to ignored.
+      # NOTE: The `ExcludedMethods` and `IgnoredMethods` configuration is
+      # deprecated and only kept for backwards compatibility.
+      # Please use `AllowedMethods` and `AllowedPatterns` instead.
+      # By default, there are no methods to allowed.
       #
       # @example CountAsOne: ['array', 'heredoc']
       #
@@ -35,14 +36,13 @@ module RuboCop
       #
       class MethodLength < Base
         include CodeLength
-        include IgnoredMethods
-
-        ignored_methods deprecated_key: 'ExcludedMethods'
+        include AllowedMethods
+        include AllowedPattern
 
         LABEL = 'Method'
 
         def on_def(node)
-          return if ignored_method?(node.method_name)
+          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
 
           check_code_length(node)
         end

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

@@ -12,10 +12,29 @@ module RuboCop
         allowed_methods.include?(name.to_s)
       end
 
+      # @deprecated Use allowed_method? instead
+      alias ignored_method? allowed_method?
+
       # @api public
       def allowed_methods
-        cop_config.fetch('AllowedMethods', [])
+        if cop_config_deprecated_values.any?(Regexp)
+          cop_config_allowed_methods
+        else
+          cop_config_allowed_methods + cop_config_deprecated_values
+        end
+      end
+
+      def cop_config_allowed_methods
+        @cop_config_allowed_methods ||= Array(cop_config.fetch('AllowedMethods', []))
+      end
+
+      def cop_config_deprecated_values
+        @cop_config_deprecated_values ||=
+          Array(cop_config.fetch('IgnoredMethods', [])) +
+          Array(cop_config.fetch('ExcludedMethods', []))
       end
     end
+    # @deprecated IgnoredMethods class has been replaced with AllowedMethods.
+    IgnoredMethods = AllowedMethods
   end
 end

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

@@ -30,7 +30,23 @@ module RuboCop
       def allowed_patterns
         # Since there could be a pattern specified in the default config, merge the two
         # arrays together.
-        Array(cop_config['AllowedPatterns']).concat(Array(cop_config['IgnoredPatterns']))
+        if cop_config_deprecated_methods_values.any?(Regexp)
+          cop_config_patterns_values + cop_config_deprecated_methods_values
+        else
+          cop_config_patterns_values
+        end
+      end
+
+      def cop_config_patterns_values
+        @cop_config_patterns_values ||=
+          Array(cop_config.fetch('AllowedPatterns', [])) +
+          Array(cop_config.fetch('IgnoredPatterns', []))
+      end
+
+      def cop_config_deprecated_methods_values
+        @cop_config_deprecated_methods_values ||=
+          Array(cop_config.fetch('IgnoredMethods', [])) +
+          Array(cop_config.fetch('ExcludedMethods', []))
       end
     end
 

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

@@ -220,7 +220,7 @@ module RuboCop
       def already_on_multiple_lines?(node)
         return node.first_line != node.arguments.last.last_line if node.def_type?
 
-        node.first_line != node.last_line
+        !node.single_line?
       end
     end
   end

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

@@ -12,10 +12,26 @@ module RuboCop
       end
 
       def contains_comments?(node)
+        comments_in_range(node).any?
+      end
+
+      def comments_in_range(node)
         start_line = node.source_range.line
         end_line = find_end_line(node)
 
-        processed_source.each_comment_in_lines(start_line...end_line).any?
+        processed_source.each_comment_in_lines(start_line...end_line)
+      end
+
+      def comments_contain_disables?(node, cop_name)
+        disabled_ranges = processed_source.disabled_line_ranges[cop_name]
+
+        return unless disabled_ranges
+
+        node_range = node.source_range.line...find_end_line(node)
+
+        disabled_ranges.any? do |disable_range|
+          disable_range.cover?(node_range) || node_range.cover?(disable_range)
+        end
       end
 
       private

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

@@ -6,7 +6,8 @@ module RuboCop
     #
     # IMPORTANT: RuboCop core depended on this module when it supported Rails department.
     # Rails department has been extracted to RuboCop Rails gem.
-    # This module is deprecated and will be removed by RuboCop 2.0.
+    #
+    # @deprecated This module is deprecated and will be removed by RuboCop 2.0.
     # It will not be updated to `RuboCop::Cop::Base` v1 API to maintain compatibility
     # with existing RuboCop Rails 2.8 or lower.
     #

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

@@ -69,6 +69,10 @@ module RuboCop
         end
       end
 
+      def leading_magic_comments
+        leading_comment_lines.map { |line| MagicComment.parse(line) }
+      end
+
       def leading_comment_lines
         first_non_comment_token = processed_source.tokens.find { |token| !token.comment? }
 

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

@@ -5,7 +5,22 @@ module RuboCop
     # This module checks for Ruby 3.1's hash value omission syntax.
     module HashShorthandSyntax
       OMIT_HASH_VALUE_MSG = 'Omit the hash value.'
-      EXPLICIT_HASH_VALUE_MSG = 'Explicit the hash value.'
+      EXPLICIT_HASH_VALUE_MSG = 'Include the hash value.'
+      DO_NOT_MIX_MSG_PREFIX = 'Do not mix explicit and implicit hash values.'
+      DO_NOT_MIX_OMIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{OMIT_HASH_VALUE_MSG}"
+      DO_NOT_MIX_EXPLICIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{EXPLICIT_HASH_VALUE_MSG}"
+
+      def on_hash_for_mixed_shorthand(hash_node)
+        return if ignore_mixed_hash_shorthand_syntax?(hash_node)
+
+        hash_value_type_breakdown = breakdown_value_types_of_hash(hash_node)
+
+        if hash_with_mixed_shorthand_syntax?(hash_value_type_breakdown)
+          mixed_shorthand_syntax_check(hash_value_type_breakdown)
+        else
+          no_mixed_shorthand_syntax_check(hash_value_type_breakdown)
+        end
+      end
 
       def on_pair(node)
         return if ignore_hash_shorthand_syntax?(node)
@@ -36,8 +51,14 @@ module RuboCop
         end
       end
 
+      def ignore_mixed_hash_shorthand_syntax?(hash_node)
+        target_ruby_version <= 3.0 || enforced_shorthand_syntax != 'consistent' ||
+          !hash_node.hash_type?
+      end
+
       def ignore_hash_shorthand_syntax?(pair_node)
         target_ruby_version <= 3.0 || enforced_shorthand_syntax == 'either' ||
+          enforced_shorthand_syntax == 'consistent' ||
           !pair_node.parent.hash_type?
       end
 
@@ -75,11 +96,68 @@ module RuboCop
       end
 
       def without_parentheses_call_expr_follows?(ancestor)
+        return false unless ancestor.respond_to?(:parenthesized?) && !ancestor.parenthesized?
+
         right_sibling = ancestor.right_sibling
-        right_sibling ||= ancestor.each_ancestor.find(&:assignment?)&.right_sibling
-        return false unless right_sibling
+        right_sibling ||= ancestor.each_ancestor.find do |node|
+          node.assignment? || node.send_type?
+        end&.right_sibling
+
+        !!right_sibling
+      end
 
-        ancestor.respond_to?(:parenthesized?) && !ancestor.parenthesized? && !!right_sibling
+      def breakdown_value_types_of_hash(hash_node)
+        hash_node.pairs.group_by do |pair_node|
+          if pair_node.value_omission?
+            :value_omitted
+          elsif require_hash_value?(pair_node.key.source, pair_node)
+            :value_needed
+          else
+            :value_omittable
+          end
+        end
+      end
+
+      def hash_with_mixed_shorthand_syntax?(hash_value_type_breakdown)
+        hash_value_type_breakdown.keys.size > 1
+      end
+
+      def hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
+        hash_value_type_breakdown[:value_needed]&.any?
+      end
+
+      def each_omitted_value_pair(hash_value_type_breakdown, &block)
+        hash_value_type_breakdown[:value_omitted]&.each(&block)
+      end
+
+      def each_omittable_value_pair(hash_value_type_breakdown, &block)
+        hash_value_type_breakdown[:value_omittable]&.each(&block)
+      end
+
+      def mixed_shorthand_syntax_check(hash_value_type_breakdown)
+        if hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
+          each_omitted_value_pair(hash_value_type_breakdown) do |pair_node|
+            hash_key_source = pair_node.key.source
+            replacement = "#{hash_key_source}: #{hash_key_source}"
+            register_offense(pair_node, DO_NOT_MIX_EXPLICIT_VALUE_MSG, replacement)
+          end
+        else
+          each_omittable_value_pair(hash_value_type_breakdown) do |pair_node|
+            hash_key_source = pair_node.key.source
+            replacement = "#{hash_key_source}:"
+            register_offense(pair_node, DO_NOT_MIX_OMIT_VALUE_MSG, replacement)
+          end
+        end
+      end
+
+      def no_mixed_shorthand_syntax_check(hash_value_type_breakdown)
+        return if hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
+
+        each_omittable_value_pair(hash_value_type_breakdown) do |pair_node|
+          hash_key_source = pair_node.key.source
+          replacement = "#{hash_key_source}:"
+          register_offense(pair_node, OMIT_HASH_VALUE_MSG, replacement)
+        end
       end
     end
   end

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

@@ -14,7 +14,7 @@ module RuboCop
         {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
       PATTERN
 
-      def on_block(node)
+      def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
         end
@@ -68,6 +68,8 @@ module RuboCop
         # `transform_values` if value transformation uses key.
         return if captures.transformation_uses_both_args?
 
+        return unless captures.use_transformed_argname?
+
         message = "Prefer `#{new_method_name}` over `#{match_desc}`."
         add_offense(node, message: message) do |corrector|
           correction = prepare_correction(node)
@@ -113,11 +115,7 @@ module RuboCop
       end
 
       # Internal helper class to hold match data
-      Captures = Struct.new(
-        :transformed_argname,
-        :transforming_body_expr,
-        :unchanged_body_expr
-      ) do
+      Captures = Struct.new(:transformed_argname, :transforming_body_expr, :unchanged_body_expr) do
         def noop_transformation?
           transforming_body_expr.lvar_type? &&
             transforming_body_expr.children == [transformed_argname]
@@ -126,6 +124,12 @@ module RuboCop
         def transformation_uses_both_args?
           transforming_body_expr.descendants.include?(unchanged_body_expr)
         end
+
+        def use_transformed_argname?
+          transforming_body_expr.each_descendant(:lvar).any? do |node|
+            node.source == transformed_argname.to_s
+          end
+        end
       end
 
       # Internal helper class to hold autocorrect data