rubocop 1.84.2 → 1.87.0

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

@@ -9,9 +9,11 @@ module RuboCop
       # call to `transform_values` instead.
       #
       # @safety
-      #   This cop is unsafe, as it can produce false positives if we are
-      #   transforming an enumerable of key-value-like pairs that isn't actually
-      #   a hash, e.g.: `[[k1, v1], [k2, v2], ...]`
+      #   This cop identifies the receiver as a hash by checking for literal hash
+      #   syntax and common methods that are known to return hashes (e.g. `to_h`,
+      #   `merge`, `invert`, `group_by`, etc.). However, it is unsafe because it
+      #   is possible for a custom class to define one of these methods and return
+      #   something other than a hash.
       #
       # @example
       #   # bad
@@ -19,10 +21,18 @@ module RuboCop
       #   Hash[{a: 1, b: 2}.collect { |k, v| [k, foo(v)] }]
       #   {a: 1, b: 2}.map { |k, v| [k, v * v] }.to_h
       #   {a: 1, b: 2}.to_h { |k, v| [k, v * v] }
+      #   foo.to_h.each_with_object({}) { |(k, v), h| h[k] = foo(v) }
+      #   foo.merge(bar).map { |k, v| [k, v.to_s] }.to_h
       #
       #   # good
       #   {a: 1, b: 2}.transform_values { |v| foo(v) }
       #   {a: 1, b: 2}.transform_values { |v| v * v }
+      #   foo.to_h.transform_values { |v| foo(v) }
+      #   foo.merge(bar).transform_values { |v| v.to_s }
+      #
+      #   # Won't register an offense - receiver is not known to be a hash
+      #   foo.bar.each_with_object({}) { |(k, v), h| h[k] = v.to_s }
+      #   baz.map { |k, v| [k, v.to_s] }.to_h
       class HashTransformValues < Base
         include HashTransformMethod
         extend AutoCorrector
@@ -33,7 +43,7 @@ module RuboCop
         # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            (call !#array_receiver? :each_with_object (hash))
+            (call #hash_receiver? :each_with_object (hash))
             (args
               (mlhs
                 (arg _key)
@@ -48,7 +58,7 @@ module RuboCop
             (const _ :Hash)
             :[]
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg _key)
                 (arg $_))
@@ -59,7 +69,7 @@ module RuboCop
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           (call
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg _key)
                 (arg $_))
@@ -70,7 +80,7 @@ module RuboCop
         # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            (call !#array_receiver? :to_h)
+            (call #hash_receiver? :to_h)
             (args
               (arg _key)
               (arg $_))

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

@@ -64,7 +64,7 @@ module RuboCop
 
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_if(node)
           return if node.ternary? || node.unless?
 
@@ -72,6 +72,7 @@ module RuboCop
 
           return unless else_branch&.if_type? && else_branch.if?
           return if allow_if_modifier_in_else_branch?(else_branch)
+          return if comments_between_else_and_if?(node, else_branch)
 
           add_offense(else_branch.loc.keyword) do |corrector|
             next if part_of_ignored_node?(node)
@@ -80,12 +81,12 @@ module RuboCop
             ignore_node(node)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
         def autocorrect(corrector, node)
-          if then?(node)
+          if node.then?
             # If the nested `if` is a then node, correct it first,
             # then the next pass will use `correct_to_elsif_from_if_inside_else_form`
             IfThenCorrector.new(node, indentation: 0).call(corrector)
@@ -124,10 +125,6 @@ module RuboCop
           corrector.remove(range_by_whole_lines(find_end_range(node), include_final_newline: true))
         end
 
-        def then?(node)
-          node.loc.begin&.source == 'then'
-        end
-
         def find_end_range(node)
           end_range = node.loc.end
           return end_range if end_range
@@ -139,6 +136,18 @@ module RuboCop
           range_between(node.loc.keyword.begin_pos, condition.source_range.end_pos)
         end
 
+        def comments_between_else_and_if?(node, else_branch)
+          return false if else_branch.modifier_form?
+
+          else_end = node.loc.else.end_pos
+          if_begin = else_branch.loc.keyword.begin_pos
+
+          processed_source.comments.any? do |comment|
+            comment_pos = comment.source_range.begin_pos
+            comment_pos > else_end && comment_pos < if_begin
+          end
+        end
+
         def allow_if_modifier_in_else_branch?(else_branch)
           allow_if_modifier? && else_branch&.modifier_form?
         end

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

@@ -89,9 +89,9 @@ module RuboCop
           [Style::SoleNestedConditional]
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_if(node)
-          return if endless_method?(node.body)
+          return if endless_method?(node.body) || node.ancestors.any?(&:dstr_type?)
 
           condition = node.condition
           return if defined_nodes(condition).any? { |n| defined_argument_is_undefined?(node, n) } ||
@@ -101,12 +101,13 @@ module RuboCop
 
           add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
             next if part_of_ignored_node?(node)
+            next if another_modifier_if_on_same_line?(node)
 
             autocorrect(corrector, node)
             ignore_node(node)
           end
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
@@ -280,6 +281,16 @@ module RuboCop
           node.parent if node&.type?(:pair)
         end
 
+        def another_modifier_if_on_same_line?(node)
+          collection = find_containing_collection(node)
+          return false unless collection
+
+          line = node.source_range.line
+          collection.each_descendant(:if).any? do |sibling|
+            sibling != node && sibling.modifier_form? && sibling.source_range.line == line
+          end
+        end
+
         def non_simple_if_unless?(node)
           node.ternary? || node.elsif? || node.else?
         end

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

@@ -17,9 +17,9 @@ module RuboCop
         include OnNormalIfUnless
         extend AutoCorrector
 
-        MSG_IF_ELSE = 'Do not use `if %<expr>s;` - use `if/else` instead.'
-        MSG_NEWLINE = 'Do not use `if %<expr>s;` - use a newline instead.'
-        MSG_TERNARY = 'Do not use `if %<expr>s;` - use a ternary operator instead.'
+        MSG_IF_ELSE = 'Do not use `%<keyword>s %<expr>s;` - use `if/else` instead.'
+        MSG_NEWLINE = 'Do not use `%<keyword>s %<expr>s;` - use a newline instead.'
+        MSG_TERNARY = 'Do not use `%<keyword>s %<expr>s;` - use a ternary operator instead.'
 
         def on_normal_if_unless(node)
           return if node.parent&.if_type?
@@ -49,7 +49,7 @@ module RuboCop
                        MSG_TERNARY
                      end
 
-          format(template, expr: node.condition.source)
+          format(template, keyword: node.keyword, expr: node.condition.source)
         end
 
         def autocorrect(corrector, node)
@@ -71,7 +71,7 @@ module RuboCop
         end
 
         def use_return_with_argument?(node)
-          node.if_branch&.return_type? && node.if_branch&.arguments&.any?
+          node.branches.compact.any? { |branch| branch.return_type? && branch.arguments.any? }
         end
 
         def replacement(node)
@@ -80,6 +80,8 @@ module RuboCop
           then_code = node.if_branch ? build_expression(node.if_branch) : 'nil'
           else_code = node.else_branch ? build_expression(node.else_branch) : 'nil'
 
+          then_code, else_code = else_code, then_code if node.unless?
+
           "#{node.condition.source} ? #{then_code} : #{else_code}"
         end
 

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

@@ -3,7 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for trailing inline comments.
+      # Checks for trailing inline comments. Inline comments can
+      # make lines harder to read, especially when they are long.
+      # Placing comments on their own line above the code they
+      # describe is often clearer.
       #
       # @example
       #

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

@@ -48,8 +48,7 @@ module RuboCop
         private
 
         def allowed_addresses
-          allowed_addresses = cop_config['AllowedAddresses']
-          Array(allowed_addresses).map(&:downcase)
+          @allowed_addresses ||= Array(cop_config['AllowedAddresses']).map(&:downcase).freeze
         end
 
         def potential_ip?(str)

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

@@ -10,7 +10,7 @@ module RuboCop
       # Required capitalization can be set with the `DirectiveCapitalization` and
       # `ValueCapitalization` configuration keys.
       #
-      # NOTE: If one of these configuration is set to nil, any capitalization is allowed.
+      # NOTE: If one of these configurations is set to nil, any capitalization is allowed.
       #
       # @example EnforcedStyle: snake_case (default)
       #   # The `snake_case` style will enforce that the frozen string literal
@@ -176,7 +176,7 @@ module RuboCop
           if first_non_comment_token
             0...first_non_comment_token.line
           else
-            (0..)
+            0..
           end
         end
 
@@ -299,7 +299,7 @@ module RuboCop
         end
 
         def supported_capitalizations
-          cop_config['SupportedCapitalizations'].map(&:to_sym)
+          @supported_capitalizations ||= cop_config['SupportedCapitalizations'].map(&:to_sym).freeze
         end
       end
     end

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `map { |x| x.to_s }.join` and similar calls where the
+      # `map` is redundant because `Array#join` implicitly calls `#to_s` on
+      # each element.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot guarantee that the receiver
+      #   is an `Array` by static analysis. If the receiver does not have
+      #   an `Array#join`-compatible implementation (i.e. one that calls
+      #   `#to_s` on elements), the correction may change behavior.
+      #
+      # @example
+      #   # bad
+      #   array.map(&:to_s).join(', ')
+      #
+      #   # bad
+      #   array.map { |x| x.to_s }.join(', ')
+      #
+      #   # bad
+      #   array.collect(&:to_s).join
+      #
+      #   # good
+      #   array.join(', ')
+      #
+      #   # good
+      #   array.join
+      #
+      class MapJoin < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Remove redundant `%<method>s(&:to_s)` before `join`.'
+        RESTRICT_ON_SEND = %i[join].freeze
+
+        # map(&:to_s).join(...)
+        # @!method map_to_s_join?(node)
+        def_node_matcher :map_to_s_join?, <<~PATTERN
+          (call
+            $(call _ ${:map :collect} (block_pass (sym :to_s)))
+            :join ...)
+        PATTERN
+
+        # map { |x| x.to_s }.join(...)
+        # @!method map_to_s_block_join?(node)
+        def_node_matcher :map_to_s_block_join?, <<~PATTERN
+          (call
+            $(block
+              (call _ ${:map :collect})
+              (args (arg _x))
+              (send (lvar _x) :to_s))
+            :join ...)
+        PATTERN
+
+        # map { _1.to_s }.join(...)
+        # @!method map_to_s_numblock_join?(node)
+        def_node_matcher :map_to_s_numblock_join?, <<~PATTERN
+          (call
+            $(numblock
+              (call _ ${:map :collect})
+              1
+              (send (lvar :_1) :to_s))
+            :join ...)
+        PATTERN
+
+        # map { it.to_s }.join(...)
+        # @!method map_to_s_itblock_join?(node)
+        def_node_matcher :map_to_s_itblock_join?, <<~PATTERN
+          (call
+            $(itblock
+              (call _ ${:map :collect})
+              :it
+              (send (lvar :it) :to_s))
+            :join ...)
+        PATTERN
+
+        def on_send(node)
+          map_to_s_join?(node) { |m, n| register_offense(node, m, n) } ||
+            map_to_s_block_join?(node) { |m, n| register_offense(node, m, n) } ||
+            map_to_s_numblock_join?(node) { |m, n| register_offense(node, m, n) } ||
+            map_to_s_itblock_join?(node) { |m, n| register_offense(node, m, n) }
+        end
+        alias on_csend on_send
+
+        private
+
+        def register_offense(join_node, map_node, method_name)
+          map_send = map_node.any_block_type? ? map_node.send_node : map_node
+          message = format(MSG, method: method_name)
+
+          add_offense(map_send.loc.selector, message: message) do |corrector|
+            remove_map_call(corrector, join_node, map_node, map_send)
+          end
+        end
+
+        def remove_map_call(corrector, join_node, map_node, map_send)
+          receiver = map_send.receiver
+          if receiver
+            corrector.replace(removal_range(receiver, map_node, map_send), '')
+          else
+            corrector.replace(no_receiver_range(map_node, join_node), '')
+          end
+        end
+
+        def removal_range(receiver, map_node, map_send)
+          start_pos = if receiver.last_line < map_send.loc.dot.line
+                        receiver.source_range.end_pos
+                      else
+                        map_send.loc.dot.begin_pos
+                      end
+          range_between(start_pos, map_node.source_range.end_pos)
+        end
+
+        def no_receiver_range(map_node, join_node)
+          range_between(map_node.source_range.begin_pos, join_node.loc.dot.end_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb

@@ -33,16 +33,18 @@ module RuboCop
           end
 
           def included_macros_list
-            cop_config.fetch('IncludedMacros', []).map(&:to_sym)
+            @included_macros_list ||= cop_config.fetch('IncludedMacros', []).map(&:to_sym).freeze
           end
 
           def included_macro_patterns
-            cop_config.fetch('IncludedMacroPatterns', [])
+            @included_macro_patterns ||=
+              cop_config.fetch('IncludedMacroPatterns', [])
+                        .map { |pattern| Regexp.new(pattern) }.freeze
           end
 
           def matches_included_macro_pattern?(method_name)
             included_macro_patterns.any? do |pattern|
-              Regexp.new(pattern).match?(method_name.to_s)
+              pattern.match?(method_name.to_s)
             end
           end
 

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

@@ -6,7 +6,7 @@ module RuboCop
       # Enforces the use of `max` or `min` instead of comparison for greater or less.
       #
       # NOTE: It can be used if you want to present limit or threshold in Ruby 2.7+.
-      # That it is slow though. So autocorrection will apply generic `max` or `min`:
+      # It is slow though. So autocorrection will apply generic `max` or `min`:
       #
       # [source,ruby]
       # ----

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

@@ -13,6 +13,12 @@ module RuboCop
       # array, while `method_defined?` will do direct method lookup, which is much
       # faster and consumes less memory.
       #
+      # NOTE: `constants.include?` is not handled by this cop because
+      # `Module#const_defined?` has different lookup behavior than
+      # `Module#constants` - `const_defined?` searches up to `Object`
+      # (top-level constants like `String`, `Integer`, etc.) while
+      # `constants` does not, which can cause behavior changes after autocorrection.
+      #
       # @example
       #   # bad
       #   Array.instance_methods.include?(:size)
@@ -28,27 +34,17 @@ module RuboCop
       #
       #   # bad
       #   Array.class_variables.include?(:foo)
-      #   Array.constants.include?(:foo)
       #   Array.private_instance_methods.include?(:foo)
       #   Array.protected_instance_methods.include?(:foo)
       #   Array.public_instance_methods.include?(:foo)
-      #   Array.included_modules.include?(:foo)
       #
       #   # good
       #   Array.class_variable_defined?(:foo)
-      #   Array.const_defined?(:foo)
       #   Array.private_method_defined?(:foo)
       #   Array.protected_method_defined?(:foo)
       #   Array.public_method_defined?(:foo)
-      #   Array.include?(:foo)
-      #
-      # @example AllowedMethods: [included_modules]
-      #
-      #   # good
-      #   Array.included_modules.include?(:foo)
       #
       class ModuleMemberExistenceCheck < Base
-        include AllowedMethods
         extend AutoCorrector
 
         MSG = 'Use `%<replacement>s` instead.'
@@ -63,15 +59,13 @@ module RuboCop
 
         METHOD_REPLACEMENTS = {
           class_variables: :class_variable_defined?,
-          constants: :const_defined?,
-          included_modules: :include?,
           instance_methods: :method_defined?,
           private_instance_methods: :private_method_defined?,
           protected_instance_methods: :protected_method_defined?,
           public_instance_methods: :public_method_defined?
         }.freeze
 
-        METHODS_WITHOUT_INHERIT_PARAM = Set[:class_variables, :included_modules].freeze
+        METHODS_WITHOUT_INHERIT_PARAM = Set[:class_variables].freeze
         METHODS_WITH_INHERIT_PARAM =
           (METHOD_REPLACEMENTS.keys.to_set - METHODS_WITHOUT_INHERIT_PARAM).freeze
 
@@ -81,7 +75,6 @@ module RuboCop
           return unless (parent = node.parent)
           return unless module_member_inclusion?(parent)
           return unless simple_method_argument?(node) && simple_method_argument?(parent)
-          return if allowed_method?(node.method_name)
 
           offense_range = node.location.selector.join(parent.source_range.end)
           replacement = replacement_for(node, parent)

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of the `then` keyword in multi-line if statements.
+      # Checks for uses of the `then` keyword in multi-line `if` statements.
+      # In multi-line `if` statements, `then` is redundant because the newline
+      # already separates the condition from the body.
       #
       # @example
       #   # bad

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

@@ -125,7 +125,7 @@ module RuboCop
         MSG = 'Freeze mutable objects assigned to constants.'
 
         def on_casgn(node)
-          if node.expression.nil? # This is only the case for `CONST += ...` or similarg66
+          if node.expression.nil? # This is only the case for `CONST += ...` or similar
             parent = node.parent
             return unless parent.or_asgn_type? # We only care about `CONST ||= ...`
 

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

@@ -4,9 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Checks for comparison of something with nil using `==` and
-      # `nil?`.
-      #
-      # Supported styles are: predicate, comparison.
+      # `nil?`. Enforcing a consistent style (either the `nil?`
+      # predicate or `==` comparison) improves readability.
       #
       # @example EnforcedStyle: predicate (default)
       #

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

@@ -43,7 +43,7 @@ module RuboCop
           { ({return next break} nil) (nil) }
         PATTERN
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return unless node.lambda_or_proc?
           return unless nil_return?(node.body)
 

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

@@ -121,17 +121,11 @@ module RuboCop
         end
 
         def autocorrect_comparison(corrector, node)
-          expr = node.source
-
-          new_code = if include_semantic_changes?
-                       expr.sub(/\s*!=\s*nil/, '')
-                     else
-                       expr.sub(/^(\S*)\s*!=\s*nil/, '!\1.nil?')
-                     end
-
-          return if expr == new_code
-
-          corrector.replace(node, new_code)
+          if include_semantic_changes?
+            corrector.replace(node, node.receiver.source)
+          else
+            corrector.replace(node, "!#{node.receiver.source}.nil?")
+          end
         end
 
         def autocorrect_non_nil(corrector, node, inner_node)

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

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Checks for uses of the keyword `not` instead of `!`.
+      # The `not` keyword has lower precedence than `!`, which can
+      # lead to surprising behavior and often requires parentheses.
       #
       # @example
       #

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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Checks for big numeric literals without `_` between groups
-      # of digits in them.
+      # of digits in them. Underscores make large numbers easier to
+      # read by visually separating groups of digits.
       #
       # Additional allowed patterns can be added by adding regexps to
       # the `AllowedPatterns` configuration. All regexps are treated
@@ -116,7 +117,7 @@ module RuboCop
         end
 
         def allowed_numbers
-          cop_config.fetch('AllowedNumbers', []).map(&:to_s)
+          @allowed_numbers ||= cop_config.fetch('AllowedNumbers', []).map(&:to_s).freeze
         end
 
         def allowed_patterns