rubocop 1.53.1 → 1.90.0

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

@@ -10,7 +10,7 @@ module RuboCop
           true
         end
 
-        def deltas_for_first_pair(first_pair, _node)
+        def deltas_for_first_pair(first_pair)
           {
             separator: separator_delta(first_pair),
             value: value_delta(first_pair)
@@ -81,13 +81,7 @@ module RuboCop
       class TableAlignment
         include ValueAlignment
 
-        def initialize
-          self.max_key_width = 0
-        end
-
-        def deltas_for_first_pair(first_pair, node)
-          self.max_key_width = node.keys.map { |key| key.source.length }.max
-
+        def deltas_for_first_pair(first_pair)
           separator_delta = separator_delta(first_pair, first_pair, 0)
           {
             separator: separator_delta,
@@ -97,30 +91,54 @@ module RuboCop
 
         private
 
-        attr_accessor :max_key_width
-
         def key_delta(first_pair, current_pair)
           first_pair.key_delta(current_pair)
         end
 
         def hash_rocket_delta(first_pair, current_pair)
-          first_pair.loc.column + max_key_width + 1 - current_pair.loc.operator.column
+          target_operator_column(first_pair) - current_pair.loc.operator.column
         end
 
         def value_delta(first_pair, current_pair)
-          correct_value_column = first_pair.key.loc.column +
-                                 current_pair.delimiter(true).length +
-                                 max_key_width
+          correct_value_column = target_operator_column(first_pair) +
+                                 max_delimiter_width(first_pair.parent) - 1
 
           current_pair.value_omission? ? 0 : correct_value_column - current_pair.value.loc.column
         end
+
+        # The column the separator should land on: the shared key margin
+        # plus the widest single-line key, or, if larger, a multiline key's
+        # own last-line end column. The latter can't be measured from a
+        # multiline key's (newline-including) source length, so it's a
+        # separate candidate rather than folded into `max_key_width`.
+        def target_operator_column(first_pair)
+          hash_node = first_pair.parent
+          candidates = multiline_key_end_columns(hash_node)
+
+          key_width = max_key_width(hash_node)
+          candidates << (first_pair.loc.column + key_width + 1) if key_width.positive?
+
+          candidates.max
+        end
+
+        def multiline_key_end_columns(hash_node)
+          hash_node.keys.reject(&:single_line?).map { |key| key.source_range.end.column + 1 }
+        end
+
+        def max_key_width(hash_node)
+          hash_node.keys.select(&:single_line?).map { |key| key.source.length }.max || 0
+        end
+
+        def max_delimiter_width(hash_node)
+          hash_node.pairs.map { |pair| pair.delimiter(true).length }.max
+        end
       end
 
       # Handles calculation of deltas when the enforced style is 'separator'.
       class SeparatorAlignment
         include ValueAlignment
 
-        def deltas_for_first_pair(*_nodes)
+        def deltas_for_first_pair(_first_pair)
           {}
         end
 

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

@@ -11,6 +11,24 @@ module RuboCop
       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}"
 
+      DefNode = Struct.new(:node) do
+        def selector
+          if node.loc?(: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
+
       def on_hash_for_mixed_shorthand(hash_node)
         return if ignore_mixed_hash_shorthand_syntax?(hash_node)
 
@@ -48,29 +66,33 @@ module RuboCop
 
       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))
-            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, '(')
-            corrector.insert_after(last_argument, ')') if node == last_argument.pairs.last
-          end
           corrector.replace(node, replacement)
+
+          next unless (def_node = def_node_that_require_parentheses(node))
+
+          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)
+          next if node.parent.braces?
+
+          corrector.replace(white_spaces, '(')
+          corrector.insert_after(last_argument, ')') if node == last_argument.pairs.last
         end
       end
 
       def ignore_mixed_hash_shorthand_syntax?(hash_node)
-        target_ruby_version <= 3.0 || enforced_shorthand_syntax != 'consistent' ||
+        target_ruby_version <= 3.0 ||
+          !%w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
           !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' ||
+          %w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
           !pair_node.parent.hash_type?
       end
 
@@ -82,7 +104,7 @@ module RuboCop
         return true if !node.key.sym_type? || require_hash_value_for_around_hash_literal?(node)
 
         hash_value = node.value
-        return true unless hash_value.send_type? || hash_value.lvar_type?
+        return true unless hash_value.type?(:send, :lvar)
 
         hash_key_source != hash_value.source || hash_key_source.end_with?('!', '?')
       end
@@ -95,7 +117,7 @@ module RuboCop
           use_modifier_form_without_parenthesized_method_call?(method_dispatch_node)
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def def_node_that_require_parentheses(node)
         last_pair = node.parent.pairs.last
         return unless last_pair.key.source == last_pair.value.source
@@ -103,17 +125,16 @@ module RuboCop
         return if dispatch_node.assignment_method?
         return if dispatch_node.parenthesized?
         return if dispatch_node.parent && parentheses?(dispatch_node.parent)
-        return if last_expression?(dispatch_node) && !method_dispatch_as_argument?(dispatch_node)
+        return if last_expression?(dispatch_node) && !requires_parentheses_context?(dispatch_node)
 
-        def_node = node.each_ancestor(:send, :csend, :super, :yield).first
+        def_node = node.each_ancestor(:call, :super, :yield).first
 
         DefNode.new(def_node) unless def_node && def_node.arguments.empty?
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       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 unless ancestor.type?(:call, :super, :yield)
         return if brackets?(ancestor)
 
         ancestor
@@ -142,11 +163,11 @@ module RuboCop
         !assignment_node.right_sibling
       end
 
-      def method_dispatch_as_argument?(method_dispatch_node)
-        parent = method_dispatch_node.parent
+      def requires_parentheses_context?(node)
+        parent = node.parent
         return false unless parent
 
-        parent.call_type? || parent.super_type? || parent.yield_type?
+        parent.type?(:call, :if, :super, :until, :while, :yield)
       end
 
       def breakdown_value_types_of_hash(hash_node)
@@ -169,6 +190,11 @@ module RuboCop
         hash_value_type_breakdown[:value_needed]&.any?
       end
 
+      def ignore_explicit_omissible_hash_shorthand_syntax?(hash_value_type_breakdown)
+        hash_value_type_breakdown.keys == [:value_omittable] &&
+          enforced_shorthand_syntax == 'either_consistent'
+      end
+
       def each_omitted_value_pair(hash_value_type_breakdown, &block)
         hash_value_type_breakdown[:value_omitted]&.each(&block)
       end
@@ -195,6 +221,7 @@ module RuboCop
 
       def no_mixed_shorthand_syntax_check(hash_value_type_breakdown)
         return if hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
+        return if ignore_explicit_omissible_hash_shorthand_syntax?(hash_value_type_breakdown)
 
         each_omittable_value_pair(hash_value_type_breakdown) do |pair_node|
           hash_key_source = pair_node.key.source
@@ -202,24 +229,6 @@ 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

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

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Style/HashExcept and Style/HashSlice cops.
+    # It registers an offense on methods with blocks that are equivalent
+    # to Hash#except or Hash#slice.
+    # rubocop:disable-next Metrics/ModuleLength
+    module HashSubset
+      include RangeHelp
+      extend NodePattern::Macros
+
+      RESTRICT_ON_SEND = %i[reject select filter].freeze
+
+      SUBSET_METHODS = %i[== != eql? include?].freeze
+      ACTIVE_SUPPORT_SUBSET_METHODS = (SUBSET_METHODS + %i[in? exclude?]).freeze
+
+      MSG = 'Use `%<prefer>s` instead.'
+
+      # @!method block_with_first_arg_check?(node)
+      def_node_matcher :block_with_first_arg_check?, <<~PATTERN
+        (block
+          (call _ _)
+          (args
+            $(arg _key)
+            $(arg _))
+          {
+            $(send
+              {(lvar _key) $_ _ | _ $_ (lvar _key)})
+            (send
+              $(send
+                {(lvar _key) $_ _ | _ $_ (lvar _key)}) :!)
+            })
+      PATTERN
+
+      def on_send(node)
+        offense_range, key_source = extract_offense(node)
+
+        return unless offense_range
+        return unless semantically_subset_method?(node)
+
+        preferred_method = "#{preferred_method_name}(#{key_source})"
+        add_offense(offense_range, message: format(MSG, prefer: preferred_method)) do |corrector|
+          corrector.replace(offense_range, preferred_method)
+        end
+      end
+      alias on_csend on_send
+
+      private
+
+      def semantically_subset_method?(node)
+        raise NotImplementedError
+      end
+
+      def preferred_method_name
+        raise NotImplementedError
+      end
+
+      def extract_offense(node)
+        block = node.parent
+        return unless extracts_hash_subset?(block)
+
+        except_key = except_key(block)
+        return if except_key.nil? || !safe_to_register_offense?(block, except_key)
+
+        [offense_range(node), except_key_source(except_key)]
+      end
+
+      def extracts_hash_subset?(block)
+        block_with_first_arg_check?(block) do |key_arg, value_arg, send_node, method|
+          # Only consider methods that have one argument
+          return false unless send_node.arguments.one?
+
+          return false unless supported_subset_method?(method)
+          return false if range_include?(send_node)
+
+          case method
+          when :include?, :exclude?
+            slices_key?(send_node, :first_argument, key_arg, value_arg)
+          when :in?
+            slices_key?(send_node, :receiver, key_arg, value_arg)
+          else
+            true
+          end
+        end
+      end
+
+      def slices_key?(send_node, method, key_arg, value_arg)
+        return false if using_value_variable?(send_node, value_arg)
+
+        node = method == :receiver ? send_node.receiver : send_node.first_argument
+        node.source == key_arg.source
+      end
+
+      def range_include?(send_node)
+        # When checking `include?`, `exclude?` and `in?` for offenses, if the receiver
+        # or first argument is a range, an offense should not be registered.
+        # ie. `(1..5).include?(k)` or `k.in?('a'..'z')`
+
+        return true if send_node.first_argument.range_type?
+
+        receiver = send_node.receiver
+        receiver = receiver.child_nodes.first while receiver.begin_type?
+        receiver.range_type?
+      end
+
+      def using_value_variable?(send_node, value_arg)
+        # If the receiver of `include?` or `exclude?`, or the first argument of `in?` is the
+        # hash value block argument, an offense should not be registered.
+        # ie. `v.include?(k)` or `k.in?(v)`
+        (send_node.receiver.lvar_type? && send_node.receiver.name == value_arg.name) ||
+          (send_node.first_argument.lvar_type? && send_node.first_argument.name == value_arg.name)
+      end
+
+      def supported_subset_method?(method)
+        if active_support_extensions_enabled?
+          ACTIVE_SUPPORT_SUBSET_METHODS.include?(method)
+        else
+          SUBSET_METHODS.include?(method)
+        end
+      end
+
+      def semantically_except_method?(node)
+        block = node.parent
+        body, negated = extract_body_if_negated(block.body)
+
+        if node.method?('reject')
+          body.method?('==') || body.method?('eql?') || included?(body, negated)
+        else
+          body.method?('!=') || not_included?(body, negated)
+        end
+      end
+
+      def semantically_slice_method?(node)
+        !semantically_except_method?(node)
+      end
+
+      def included?(body, negated)
+        if negated
+          body.method?('exclude?')
+        else
+          body.method?('include?') || body.method?('in?')
+        end
+      end
+
+      def not_included?(body, negated)
+        included?(body, !negated)
+      end
+
+      def safe_to_register_offense?(block, except_key)
+        body = block.body
+
+        if body.method?('==') || body.method?('!=')
+          except_key.type?(:sym, :str)
+        else
+          true
+        end
+      end
+
+      def extract_body_if_negated(body)
+        if body.method?('!')
+          [body.receiver, true]
+        else
+          [body, false]
+        end
+      end
+
+      def except_key_source(key)
+        if key.array_type?
+          key = if key.percent_literal?
+                  key.each_value.map { |v| decorate_source(v) }
+                else
+                  key.each_value.map(&:source)
+                end
+          return key.join(', ')
+        end
+
+        key.literal? ? key.source : "*#{key.source}"
+      end
+
+      def decorate_source(value)
+        return ":\"#{value.source}\"" if value.dsym_type?
+        return "\"#{value.source}\"" if value.dstr_type?
+        return ":#{value.source}" if value.sym_type?
+        # The element of a `%w` array can contain characters that are special
+        # inside a single-quoted string (e.g. a `'`), so escape them rather than
+        # wrapping the raw source.
+        return to_single_quoted(value.value) if value.str_type?
+
+        "'#{value.source}'"
+      end
+
+      def to_single_quoted(string)
+        "'#{string.gsub(/['\\]/) { |character| "\\#{character}" }}'"
+      end
+
+      def except_key(node)
+        key_arg = node.argument_list.first.source
+        body, = extract_body_if_negated(node.body)
+        lhs, _method_name, rhs = *body
+
+        lhs.source == key_arg ? rhs : lhs
+      end
+
+      def offense_range(node)
+        range_between(node.loc.selector.begin_pos, node.parent.loc.end.end_pos)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module HashTransformMethod
+      # Internal helper class to hold autocorrect data
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
+        def self.from_each_with_object(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_hash_brackets_map(node, match)
+          new(match, node.children.last, 'Hash['.length, ']'.length)
+        end
+
+        def self.from_map_to_h(node, match)
+          if node.parent&.block_type? && node.parent.send_node == node
+            strip_trailing_chars = 0
+          else
+            map_range = node.children.first.source_range
+            node_range = node.source_range
+            strip_trailing_chars = node_range.end_pos - map_range.end_pos
+          end
+
+          new(match, node.children.first, 0, strip_trailing_chars)
+        end
+
+        def self.from_to_h(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def strip_prefix_and_suffix(node, corrector)
+          expression = node.source_range
+          corrector.remove_leading(expression, leading)
+          corrector.remove_trailing(expression, trailing)
+        end
+
+        def set_new_method_name(new_method_name, corrector)
+          range = block_node.send_node.loc.selector
+          if (send_end = block_node.send_node.loc.end)
+            # If there are arguments (only true in the `each_with_object`
+            # case)
+            range = range.begin.join(send_end)
+          end
+          corrector.replace(range, new_method_name)
+        end
+
+        def set_new_arg_name(transformed_argname, corrector)
+          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
+        end
+
+        def set_new_body_expression(transforming_body_expr, corrector)
+          body_source = transforming_body_expr.source
+          if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
+            body_source = "{ #{body_source} }"
+          end
+
+          corrector.replace(block_node.body, body_source)
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'hash_transform_method/autocorrection'
+
 module RuboCop
   module Cop
     # Common functionality for Style/HashTransformKeys and
@@ -9,12 +11,34 @@ module RuboCop
 
       RESTRICT_ON_SEND = %i[[] to_h].freeze
 
-      # @!method array_receiver?(node)
-      def_node_matcher :array_receiver?, <<~PATTERN
-        {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
+      # Internal helper class to hold match data
+      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]
+        end
+
+        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
+
+      # @!method hash_receiver?(node)
+      def_node_matcher :hash_receiver?, <<~PATTERN
+        {(hash ...)
+         (send _ {:to_h :to_hash :merge :merge! :update :invert :except :tally} ...)
+         (block (send _ {:group_by :to_h :tally :transform_keys :transform_keys!
+                         :transform_values :transform_values!}) ...)
+         (block (send _ :each_with_object (hash)) ...)}
       PATTERN
 
-      def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+      def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
         end
@@ -70,6 +94,10 @@ module RuboCop
 
         return unless captures.use_transformed_argname?
 
+        # A splat transforming expression (e.g. `[k, *v]`) can't be used as a
+        # standalone block return value, so the rewrite would produce invalid Ruby.
+        return if captures.transforming_body_expr.splat_type?
+
         message = "Prefer `#{new_method_name}` over `#{match_desc}`."
         add_offense(node, message: message) do |corrector|
           correction = prepare_correction(node)
@@ -113,80 +141,6 @@ module RuboCop
         correction.set_new_arg_name(captures.transformed_argname, corrector)
         correction.set_new_body_expression(captures.transforming_body_expr, corrector)
       end
-
-      # Internal helper class to hold match data
-      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]
-        end
-
-        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
-      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
-        def self.from_each_with_object(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def self.from_hash_brackets_map(node, match)
-          new(match, node.children.last, 'Hash['.length, ']'.length)
-        end
-
-        def self.from_map_to_h(node, match)
-          if node.parent&.block_type? && node.parent.send_node == node
-            strip_trailing_chars = 0
-          else
-            map_range = node.children.first.source_range
-            node_range = node.source_range
-            strip_trailing_chars = node_range.end_pos - map_range.end_pos
-          end
-
-          new(match, node.children.first, 0, strip_trailing_chars)
-        end
-
-        def self.from_to_h(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def strip_prefix_and_suffix(node, corrector)
-          expression = node.source_range
-          corrector.remove_leading(expression, leading)
-          corrector.remove_trailing(expression, trailing)
-        end
-
-        def set_new_method_name(new_method_name, corrector)
-          range = block_node.send_node.loc.selector
-          if (send_end = block_node.send_node.loc.end)
-            # If there are arguments (only true in the `each_with_object`
-            # case)
-            range = range.begin.join(send_end)
-          end
-          corrector.replace(range, new_method_name)
-        end
-
-        def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
-        end
-
-        def set_new_body_expression(transforming_body_expr, corrector)
-          body_source = transforming_body_expr.source
-          if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
-            body_source = "{ #{body_source} }"
-          end
-
-          corrector.replace(block_node.body, body_source)
-        end
-      end
     end
   end
 end

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

@@ -26,11 +26,15 @@ module RuboCop
       end
 
       def delimiter_string(node)
-        node.source.match(OPENING_DELIMITER).captures[1]
+        return '' unless (match = node.source.match(OPENING_DELIMITER))
+
+        match.captures[1]
       end
 
       def heredoc_type(node)
-        node.source.match(OPENING_DELIMITER).captures[0]
+        return '' unless (match = node.source.match(OPENING_DELIMITER))
+
+        match.captures[0]
       end
     end
   end