rubocop 1.53.1 → 1.90.0

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for manual counting patterns that can be replaced by `Enumerable#tally`.
+      #
+      # The cop detects the following patterns:
+      #
+      # - `each_with_object(Hash.new(0)) { |item, counts| counts[item] += 1 }`
+      # - `group_by(&:itself).transform_values(&:count)`
+      # - `group_by { |x| x }.transform_values(&:size)`
+      # - `group_by { |x| x }.transform_values { |v| v.length }`
+      #
+      # @safety
+      #   This cop is unsafe because it cannot guarantee that the receiver
+      #   is an `Enumerable` by static analysis, so the correction may
+      #   not be actually equivalent.
+      #
+      # @example
+      #   # bad
+      #   array.each_with_object(Hash.new(0)) { |item, counts| counts[item] += 1 }
+      #
+      #   # bad
+      #   array.group_by(&:itself).transform_values(&:count)
+      #
+      #   # bad
+      #   array.group_by { |item| item }.transform_values(&:size)
+      #
+      #   # bad
+      #   array.group_by { |item| item }.transform_values { |v| v.length }
+      #
+      #   # good
+      #   array.tally
+      #
+      class TallyMethod < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+        include RangeHelp
+
+        minimum_target_ruby_version 2.7
+
+        MSG_EACH_WITH_OBJECT = 'Use `tally` instead of `each_with_object`.'
+        MSG_GROUP_BY = 'Use `tally` instead of `group_by` and `transform_values`.'
+        RESTRICT_ON_SEND = %i[each_with_object transform_values].freeze
+        COUNTING_METHODS = %i[count size length].to_set.freeze
+
+        # Pattern 1: collection.each_with_object(Hash.new(0)) { |elem, hash| hash[elem] += 1 }
+        # @!method tally_each_with_object?(node)
+        def_node_matcher :tally_each_with_object?, <<~PATTERN
+          {
+            (block
+              (call _ :each_with_object
+                (send (const {nil? cbase} :Hash) :new (int 0)))
+              (args (arg _elem) (arg _hash))
+              (op_asgn
+                (send (lvar _hash) :[] (lvar _elem)) :+ (int 1)))
+            (numblock
+              (call _ :each_with_object
+                (send (const {nil? cbase} :Hash) :new (int 0)))
+              2
+              (op_asgn
+                (send (lvar :_2) :[] (lvar :_1)) :+ (int 1)))
+          }
+        PATTERN
+
+        # Pattern 2: collection.group_by(&:itself).transform_values(&:count/size/length)
+        # @!method tally_group_by_symbol?(node)
+        def_node_matcher :tally_group_by_symbol?, <<~PATTERN
+          (call
+            (call _ :group_by (block_pass (sym :itself)))
+            :transform_values
+            (block_pass (sym %COUNTING_METHODS)))
+        PATTERN
+
+        # Pattern 3: collection.group_by { |x| x }.transform_values(&:count/size/length)
+        # @!method tally_group_by_identity_block?(node)
+        def_node_matcher :tally_group_by_identity_block?, <<~PATTERN
+          (call
+            {
+              (block (call _ :group_by) (args (arg _x)) (lvar _x))
+              (numblock (call _ :group_by) 1 (lvar :_1))
+              (itblock (call _ :group_by) :it (lvar :it))
+            }
+            :transform_values
+            (block_pass (sym %COUNTING_METHODS)))
+        PATTERN
+
+        # Pattern 4: collection.group_by(&:itself).transform_values { |v| v.count/size/length }
+        #            collection.group_by { |x| x }.transform_values { |v| v.count/size/length }
+        # @!method tally_group_by_transform_block?(node)
+        def_node_matcher :tally_group_by_transform_block?, <<~PATTERN
+          {
+            (block
+              (call
+                {
+                  (call _ :group_by (block_pass (sym :itself)))
+                  (block (call _ :group_by) (args (arg _x)) (lvar _x))
+                  (numblock (call _ :group_by) 1 (lvar :_1))
+                  (itblock (call _ :group_by) :it (lvar :it))
+                }
+                :transform_values)
+              (args (arg _v))
+              (send (lvar _v) %COUNTING_METHODS))
+            (numblock
+              (call
+                {
+                  (call _ :group_by (block_pass (sym :itself)))
+                  (block (call _ :group_by) (args (arg _x)) (lvar _x))
+                  (numblock (call _ :group_by) 1 (lvar :_1))
+                  (itblock (call _ :group_by) :it (lvar :it))
+                }
+                :transform_values)
+              1
+              (send (lvar :_1) %COUNTING_METHODS))
+            (itblock
+              (call
+                {
+                  (call _ :group_by (block_pass (sym :itself)))
+                  (block (call _ :group_by) (args (arg _x)) (lvar _x))
+                  (numblock (call _ :group_by) 1 (lvar :_1))
+                  (itblock (call _ :group_by) :it (lvar :it))
+                }
+                :transform_values)
+              :it
+              (send (lvar :it) %COUNTING_METHODS))
+          }
+        PATTERN
+        def on_send(node)
+          if node.method?(:each_with_object)
+            check_each_with_object(node)
+          elsif node.method?(:transform_values)
+            check_transform_values(node)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_each_with_object(node)
+          block_node = node.block_node
+          return unless block_node
+          return unless tally_each_with_object?(block_node)
+
+          add_offense(node.loc.selector, message: MSG_EACH_WITH_OBJECT) do |corrector|
+            corrector.replace(replacement_range(node, block_node), 'tally')
+          end
+        end
+
+        def check_transform_values(node)
+          if tally_group_by_symbol?(node) || tally_group_by_identity_block?(node)
+            register_group_by_offense(node, node)
+          elsif (block_node = node.block_node) && tally_group_by_transform_block?(block_node)
+            register_group_by_offense(node, block_node)
+          end
+        end
+
+        def register_group_by_offense(transform_node, end_node)
+          group_by_node = group_by_send_node(transform_node)
+
+          add_offense(group_by_node.loc.selector, message: MSG_GROUP_BY) do |corrector|
+            corrector.replace(replacement_range(group_by_node, end_node), 'tally')
+          end
+        end
+
+        def group_by_send_node(transform_node)
+          receiver = transform_node.receiver
+          if receiver.type?(:any_block)
+            receiver.send_node
+          else
+            receiver
+          end
+        end
+
+        def replacement_range(start_node, end_node)
+          range_between(start_node.loc.selector.begin_pos, end_node.source_range.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -75,7 +75,7 @@ module RuboCop
 
           message = message(node)
 
-          add_offense(node.source_range, message: message) do |corrector|
+          add_offense(node, message: message) do |corrector|
             autocorrect(corrector, node)
           end
         end
@@ -113,6 +113,10 @@ module RuboCop
         def offense?(node)
           condition = node.condition
 
+          # A modifier `if`/`unless` requires the parentheses, e.g. `(a if b) ? x : y`,
+          # so removing them would change the meaning. Don't flag it.
+          return false if parenthesized_modifier_condition?(condition)
+
           if safe_assignment?(condition)
             !safe_assignment_allowed?
           else
@@ -171,9 +175,14 @@ module RuboCop
         end
 
         def unsafe_autocorrect?(condition)
-          condition.children.any? do |child|
-            unparenthesized_method_call?(child) || below_ternary_precedence?(child)
-          end
+          condition.children.any? { |child| below_ternary_precedence?(child) }
+        end
+
+        def parenthesized_modifier_condition?(condition)
+          return false unless condition.begin_type?
+
+          inner = condition.children.first
+          inner&.if_type? && inner.modifier_form?
         end
 
         def unparenthesized_method_call?(child)
@@ -192,7 +201,7 @@ module RuboCop
         # @!method method_name(node)
         def_node_matcher :method_name, <<~PATTERN
           {($:defined? _ ...)
-           (send {_ nil?} $_ _ ...)}
+           (call {_ nil?} $_ _ ...)}
         PATTERN
 
         def correct_parenthesized(corrector, condition)
@@ -203,16 +212,39 @@ module RuboCop
           # If we remove the parentheses, we need to add a space or we'll
           # generate invalid code.
           corrector.insert_after(condition.loc.end, ' ') unless whitespace_after?(condition)
+
+          if (send_node = condition.child_nodes.last) && node_args_need_parens?(send_node)
+            parenthesize_condition_arguments(corrector, send_node)
+          end
         end
 
         def correct_unparenthesized(corrector, condition)
           corrector.wrap(condition, '(', ')')
         end
 
+        def parenthesize_condition_arguments(corrector, send_node)
+          range_start = send_node.defined_type? ? send_node.loc.keyword : send_node.loc.selector
+          opening_range = range_start.end.join(send_node.first_argument.source_range.begin)
+
+          corrector.replace(opening_range, '(')
+          corrector.insert_after(send_node.last_argument, ')')
+        end
+
         def whitespace_after?(node)
           last_token = processed_source.last_token_of(node)
           last_token.space_after?
         end
+
+        def node_args_need_parens?(send_node)
+          return false unless node_with_args?(send_node)
+          return false if send_node.arguments.none? || send_node.parenthesized?
+
+          send_node.dot? || send_node.safe_navigation? || unparenthesized_method_call?(send_node)
+        end
+
+        def node_with_args?(node)
+          node.type?(:call, :defined?)
+        end
       end
     end
   end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `Time.new` without arguments, which is an implicit way
+      # to retrieve the current system time. Prefer the more explicit `Time.now`.
+      #
+      # @example
+      #   # bad
+      #   Time.new
+      #
+      #   # good
+      #   Time.now
+      #
+      #   # good - `Time.new` with arguments constructs a specific time
+      #   Time.new(2026, 8, 19)
+      #
+      class TimeNow < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `Time.now` over `Time.new` to retrieve the current time.'
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        # @!method time_new?(node)
+        def_node_matcher :time_new?, <<~PATTERN
+          (call (const {nil? cbase} :Time) :new)
+        PATTERN
+
+        def on_send(node)
+          return unless time_new?(node)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node.loc.selector.join(node.source_range.end), 'now')
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -3,11 +3,11 @@
 module RuboCop
   module Cop
     module Style
-      # Newcomers to ruby applications may write top-level methods,
+      # Newcomers to Ruby applications may write top-level methods,
       # when ideally they should be organized in appropriate classes or modules.
       # This cop looks for definitions of top-level methods and warns about them.
       #
-      # However for ruby scripts it is perfectly fine to use top-level methods.
+      # However, for Ruby scripts it is perfectly fine to use top-level methods.
       # Hence this cop is disabled by default.
       #
       # @example
@@ -64,6 +64,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -77,7 +78,7 @@ module RuboCop
 
         # @!method define_method_block?(node)
         def_node_matcher :define_method_block?, <<~PATTERN
-          ({block numblock} (send _ {:define_method} _) ...)
+          (any_block (send _ :define_method _) ...)
         PATTERN
       end
     end

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

@@ -7,12 +7,18 @@ module RuboCop
       # The supported styles are:
       #
       # * `consistent_comma`: Requires a comma after the last argument,
-      # for all parenthesized method calls with arguments.
+      # for all parenthesized multi-line method calls with arguments.
       # * `comma`: Requires a comma after the last argument, but only for
       # parenthesized method calls where each argument is on its own line.
+      # * `diff_comma`: Requires a comma after the last argument, but only
+      # when that argument is followed by an immediate newline, even if
+      # there is an inline comment on the same line.
       # * `no_comma`: Requires that there is no comma after the last
       # argument.
       #
+      # Regardless of style, trailing commas are not allowed in
+      # single-line method calls.
+      #
       # @example EnforcedStyleForMultiline: consistent_comma
       #   # bad
       #   method(1, 2,)
@@ -72,14 +78,62 @@ module RuboCop
       #     2,
       #   )
       #
+      # @example EnforcedStyleForMultiline: diff_comma
+      #   # bad
+      #   method(1, 2,)
+      #
+      #   # good
+      #   method(1, 2)
+      #
+      #   # good
+      #   method(
+      #     1, 2,
+      #     3,
+      #   )
+      #
+      #   # good
+      #   method(
+      #     1, 2, 3,
+      #   )
+      #
+      #   # good
+      #   method(
+      #     1,
+      #     2,
+      #   )
+      #
+      #   # bad
+      #   method(1, [
+      #     2,
+      #   ],)
+      #
+      #   # good
+      #   method(1, [
+      #     2,
+      #   ])
+      #
+      #   # bad
+      #   object[1, 2,
+      #          3, 4,]
+      #
+      #   # good
+      #   object[1, 2,
+      #          3, 4]
+      #
       # @example EnforcedStyleForMultiline: no_comma (default)
       #   # bad
       #   method(1, 2,)
       #
+      #   # bad
+      #   object[1, 2,]
+      #
       #   # good
       #   method(1, 2)
       #
       #   # good
+      #   object[1, 2]
+      #
+      #   # good
       #   method(
       #     1,
       #     2
@@ -93,7 +147,7 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless node.arguments? && node.parenthesized?
+          return unless node.arguments? && (node.parenthesized? || node.method?(:[]))
 
           check(node, node.arguments, 'parameter of %<article>s method call',
                 node.last_argument.source_range.end_pos,

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

@@ -6,12 +6,13 @@ module RuboCop
       # Checks for trailing comma in array literals.
       # The configuration options are:
       #
-      # * `consistent_comma`: Requires a comma after the
-      # last item of all non-empty, multiline array literals.
-      # * `comma`: Requires a comma after last item in an array,
-      # but only when each item is on its own line.
-      # * `no_comma`: Does not require a comma after the
-      # last item in an array
+      # * `consistent_comma`: Requires a comma after the last item of all non-empty, multiline array
+      # literals.
+      # * `comma`: Requires a comma after the last item in an array, but only when each item is on
+      # its own line.
+      # * `diff_comma`: Requires a comma after the last item in an array, but only when that item is
+      # followed by an immediate newline, even if there is an inline comment on the same line.
+      # * `no_comma`: Does not require a comma after the last item in an array
       #
       # @example EnforcedStyleForMultiline: consistent_comma
       #   # bad
@@ -37,6 +38,14 @@ module RuboCop
       #     2,
       #   ]
       #
+      #   # bad
+      #   a = [1, 2,
+      #        3, 4]
+      #
+      #   # good
+      #   a = [1, 2,
+      #        3, 4,]
+      #
       # @example EnforcedStyleForMultiline: comma
       #   # bad
       #   a = [1, 2,]
@@ -72,6 +81,38 @@ module RuboCop
       #     2,
       #   ]
       #
+      # @example EnforcedStyleForMultiline: diff_comma
+      #   # bad
+      #   a = [1, 2,]
+      #
+      #   # good
+      #   a = [1, 2]
+      #
+      #   # good
+      #   a = [
+      #     1, 2,
+      #     3,
+      #   ]
+      #
+      #   # good
+      #   a = [
+      #     1, 2, 3,
+      #   ]
+      #
+      #   # good
+      #   a = [
+      #     1,
+      #     2,
+      #   ]
+      #
+      #   # bad
+      #   a = [1, 2,
+      #        3, 4,]
+      #
+      #   # good
+      #   a = [1, 2,
+      #        3, 4]
+      #
       # @example EnforcedStyleForMultiline: no_comma (default)
       #   # bad
       #   a = [1, 2,]

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

@@ -64,7 +64,7 @@ module RuboCop
 
         MSG = 'Useless trailing comma present in block arguments.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           # lambda literal (`->`) never has block arguments.
           return if node.send_node.lambda_literal?
           return unless useless_trailing_comma?(node)
@@ -97,7 +97,7 @@ module RuboCop
           pipes = tokens.select { |token| token.type == :tPIPE }
           begin_pos, end_pos = pipes.map { |pipe| tokens.index(pipe) }
 
-          tokens[begin_pos + 1..end_pos - 1]
+          tokens[(begin_pos + 1)..(end_pos - 1)]
         end
       end
     end

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

@@ -6,12 +6,13 @@ module RuboCop
       # Checks for trailing comma in hash literals.
       # The configuration options are:
       #
-      # * `consistent_comma`: Requires a comma after the
-      # last item of all non-empty, multiline hash literals.
-      # * `comma`: Requires a comma after the last item in a hash,
-      # but only when each item is on its own line.
-      # * `no_comma`: Does not require a comma after the
-      # last item in a hash
+      # * `consistent_comma`: Requires a comma after the last item of all non-empty, multiline hash
+      # literals.
+      # * `comma`: Requires a comma after the last item in a hash, but only when each item is on its
+      # own line.
+      # * `diff_comma`: Requires a comma after the last item in a hash, but only when that item is
+      # followed by an immediate newline, even if there is an inline comment on the same line.
+      # * `no_comma`: Does not require a comma after the last item in a hash
       #
       # @example EnforcedStyleForMultiline: consistent_comma
       #
@@ -38,6 +39,14 @@ module RuboCop
       #     bar: 2,
       #   }
       #
+      #   # bad
+      #   a = { foo: 1, bar: 2,
+      #         baz: 3, qux: 4 }
+      #
+      #   # good
+      #   a = { foo: 1, bar: 2,
+      #         baz: 3, qux: 4, }
+      #
       # @example EnforcedStyleForMultiline: comma
       #
       #   # bad
@@ -74,6 +83,39 @@ module RuboCop
       #     bar: 2,
       #   }
       #
+      # @example EnforcedStyleForMultiline: diff_comma
+      #
+      #   # bad
+      #   a = { foo: 1, bar: 2, }
+      #
+      #   # good
+      #   a = { foo: 1, bar: 2 }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1, bar: 2,
+      #     qux: 3,
+      #   }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1, bar: 2, qux: 3,
+      #   }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1,
+      #     bar: 2,
+      #   }
+      #
+      #   # bad
+      #   a = { foo: 1, bar: 2,
+      #         baz: 3, qux: 4, }
+      #
+      #   # good
+      #   a = { foo: 1, bar: 2,
+      #         baz: 3, qux: 4 }
+      #
       # @example EnforcedStyleForMultiline: no_comma (default)
       #
       #   # bad

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

@@ -45,6 +45,7 @@ module RuboCop
             corrector.insert_before(node.loc.end, "\n#{' ' * node.loc.keyword.column}")
           end
         end
+        alias on_defs on_def
 
         private
 

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

@@ -7,26 +7,26 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   a, b, _ = foo()
-      #   a, b, _, = foo()
-      #   a, _, _ = foo()
-      #   a, _, _, = foo()
+      #   a, b, _ = foo
+      #   a, b, _, = foo
+      #   a, _, _ = foo
+      #   a, _, _, = foo
       #
       #   # good
-      #   a, b, = foo()
-      #   a, = foo()
-      #   *a, b, _ = foo()
+      #   a, b, = foo
+      #   a, = foo
+      #   *a, b, _ = foo
       #   # => We need to know to not include 2 variables in a
-      #   a, *b, _ = foo()
-      #   # => The correction `a, *b, = foo()` is a syntax error
+      #   a, *b, _ = foo
+      #   # => The correction `a, *b, = foo` is a syntax error
       #
       # @example AllowNamedUnderscoreVariables: true (default)
       #   # good
-      #   a, b, _something = foo()
+      #   a, b, _something = foo
       #
       # @example AllowNamedUnderscoreVariables: false
       #   # bad
-      #   a, b, _something = foo()
+      #   a, b, _something = foo
       #
       class TrailingUnderscoreVariable < Base
         include SurroundingSpace
@@ -94,7 +94,7 @@ module RuboCop
         end
 
         def unneeded_ranges(node)
-          node.masgn_type? ? (mlhs_node, = *node) : mlhs_node = node
+          mlhs_node = node.masgn_type? ? node.lhs : node
           variables = *mlhs_node
 
           main_offense = main_node_offense(node)
@@ -106,16 +106,14 @@ module RuboCop
         end
 
         def main_node_offense(node)
-          node.masgn_type? ? (mlhs_node, right = *node) : mlhs_node = node
-
+          mlhs_node = node.masgn_type? ? node.lhs : node
           variables = *mlhs_node
+
           first_offense = find_first_offense(variables)
 
           return unless first_offense
 
-          if unused_variables_only?(first_offense, variables)
-            return unused_range(node.type, mlhs_node, right)
-          end
+          return unused_range(node, mlhs_node) if unused_variables_only?(first_offense, variables)
 
           return range_for_parentheses(first_offense, mlhs_node) if Util.parentheses?(mlhs_node)
 
@@ -130,13 +128,14 @@ module RuboCop
           offense.source_range == variables.first.source_range
         end
 
-        def unused_range(node_type, mlhs_node, right)
+        def unused_range(node, mlhs_node)
           start_range = mlhs_node.source_range.begin_pos
 
-          end_range = case node_type
-                      when :masgn
-                        right.source_range.begin_pos
-                      when :mlhs
+          # `node` can be an `mlhs` when recursing into a nested destructuring
+          # group; only a `masgn` has a right-hand side to anchor against.
+          end_range = if node.masgn_type?
+                        node.rhs.source_range.begin_pos
+                      else
                         mlhs_node.source_range.end_pos
                       end