rubocop 1.57.1 → 1.81.6

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

@@ -49,12 +49,12 @@ module RuboCop
       class DateTime < Base
         extend AutoCorrector
 
-        CLASS_MSG = 'Prefer Time over DateTime.'
-        COERCION_MSG = 'Do not use #to_datetime.'
+        CLASS_MSG = 'Prefer `Time` over `DateTime`.'
+        COERCION_MSG = 'Do not use `#to_datetime`.'
 
         # @!method date_time?(node)
         def_node_matcher :date_time?, <<~PATTERN
-          (send (const {nil? (cbase)} :DateTime) ...)
+          (call (const {nil? (cbase)} :DateTime) ...)
         PATTERN
 
         # @!method historic_date?(node)
@@ -64,7 +64,7 @@ module RuboCop
 
         # @!method to_datetime?(node)
         def_node_matcher :to_datetime?, <<~PATTERN
-          (send _ :to_datetime)
+          (call _ :to_datetime)
         PATTERN
 
         def on_send(node)
@@ -75,6 +75,7 @@ module RuboCop
 
           add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
         end
+        alias on_csend on_send
 
         private
 

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

@@ -25,10 +25,9 @@ module RuboCop
       #   # good
       #   def foo = do_something
       #
-      #   # good (without parentheses it's a syntax error)
+      #   # good - without parentheses it's a syntax error
       #   def foo() do_something end
-      #
-      # @example
+      #   def foo()=do_something
       #
       #   # bad
       #   def Baz.foo()
@@ -40,19 +39,31 @@ module RuboCop
       #     do_something
       #   end
       class DefWithParentheses < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = "Omit the parentheses in defs when the method doesn't accept any arguments."
 
         def on_def(node)
-          return if node.single_line? && !node.endless?
-          return unless !node.arguments? && (node_arguments = node.arguments.source_range)
+          return unless !node.arguments? && (arguments_range = node.arguments.source_range)
+          return if parentheses_required?(node, arguments_range)
 
-          add_offense(node_arguments) do |corrector|
-            corrector.remove(node_arguments)
+          add_offense(arguments_range) do |corrector|
+            corrector.remove(arguments_range)
           end
         end
         alias on_defs on_def
+
+        private
+
+        def parentheses_required?(node, arguments_range)
+          return true if node.single_line? && !node.endless?
+
+          end_pos = arguments_range.end.end_pos
+          token_after_argument = range_between(end_pos, end_pos + 1).source
+
+          token_after_argument == '='
+        end
       end
     end
   end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for chained `dig` calls that can be collapsed into a single `dig`.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is an `Enumerable` or does not have a nonstandard implementation
+      #   of `dig`.
+      #
+      # @example
+      #   # bad
+      #   x.dig(:foo).dig(:bar).dig(:baz)
+      #   x.dig(:foo, :bar).dig(:baz)
+      #   x.dig(:foo, :bar)&.dig(:baz)
+      #
+      #   # good
+      #   x.dig(:foo, :bar, :baz)
+      #
+      #   # good - `dig`s cannot be combined
+      #   x.dig(:foo).bar.dig(:baz)
+      #
+      class DigChain < Base
+        extend AutoCorrector
+        include CommentsHelp
+        include DigHelp
+
+        MSG = 'Use `%<replacement>s` instead of chaining.'
+        RESTRICT_ON_SEND = %i[dig].freeze
+
+        def on_send(node)
+          return if ignored_node?(node)
+          return unless node.loc.dot
+          return unless dig?(node)
+
+          range, arguments = inspect_chain(node)
+          return if invalid_arguments?(arguments)
+          return unless range
+
+          register_offense(node, range, arguments)
+        end
+        alias on_csend on_send
+
+        private
+
+        # Walk up the method chain while the receiver is `dig` with arguments.
+        def inspect_chain(node)
+          arguments = node.arguments.dup
+          end_range = node.source_range.end
+
+          while dig?(node = node.receiver)
+            begin_range = node.loc.selector
+            arguments.unshift(*node.arguments)
+            ignore_node(node)
+          end
+
+          return unless begin_range
+
+          [begin_range.join(end_range), arguments]
+        end
+
+        def invalid_arguments?(arguments)
+          # If any of the arguments are arguments forwarding (`...`), it can only be the
+          # first argument, or else the resulting code will have a syntax error.
+
+          return false unless arguments&.any?
+
+          forwarded_args_index = arguments.index(&:forwarded_args_type?)
+          forwarded_args_index && forwarded_args_index < (arguments.size - 1)
+        end
+
+        def register_offense(node, range, arguments)
+          arguments = arguments.map(&:source).join(', ')
+          replacement = "dig(#{arguments})"
+
+          add_offense(range, message: format(MSG, replacement: replacement)) do |corrector|
+            corrector.replace(range, replacement)
+
+            comments_in_range(node).reverse_each do |comment|
+              corrector.insert_before(node, "#{comment.source}\n")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -29,36 +29,36 @@ module RuboCop
       #   end
       #
       #   # allowed
-      #     # Class without body
+      #   # Class without body
+      #   class Person
+      #   end
+      #
+      #   # Namespace - A namespace can be a class or a module
+      #   # Containing a class
+      #   module Namespace
+      #     # Description/Explanation of Person class
       #     class Person
+      #       # ...
       #     end
+      #   end
       #
-      #     # Namespace - A namespace can be a class or a module
-      #     # Containing a class
-      #     module Namespace
-      #       # Description/Explanation of Person class
-      #       class Person
-      #         # ...
-      #       end
+      #   # Containing constant visibility declaration
+      #   module Namespace
+      #     class Private
       #     end
       #
-      #     # Containing constant visibility declaration
-      #     module Namespace
-      #       class Private
-      #       end
-      #
-      #       private_constant :Private
-      #     end
+      #     private_constant :Private
+      #   end
       #
-      #     # Containing constant definition
-      #     module Namespace
-      #       Public = Class.new
-      #     end
+      #   # Containing constant definition
+      #   module Namespace
+      #     Public = Class.new
+      #   end
       #
-      #     # Macro calls
-      #     module Namespace
-      #       extend Foo
-      #     end
+      #   # Macro calls
+      #   module Namespace
+      #     extend Foo
+      #   end
       #
       # @example AllowedConstants: ['ClassMethods']
       #
@@ -67,7 +67,7 @@ module RuboCop
       #      module ClassMethods
       #        # ...
       #      end
-      #     end
+      #    end
       #
       class Documentation < Base
         include DocumentationComment
@@ -186,7 +186,7 @@ module RuboCop
         def qualify_const(node)
           return if node.nil?
 
-          if node.cbase_type? || node.self_type? || node.call_type? || node.variable?
+          if node.type?(:cbase, :self, :call) || node.variable?
             node.source
           else
             [qualify_const(node.namespace), node.short_name].compact

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

@@ -95,6 +95,17 @@ module RuboCop
       #     end
       #   end
       #
+      # @example AllowedMethods: ['method_missing', 'respond_to_missing?']
+      #
+      #    # good
+      #    class Foo
+      #      def method_missing(name, *args)
+      #      end
+      #
+      #      def respond_to_missing?(symbol, include_private)
+      #      end
+      #    end
+      #
       class DocumentationMethod < Base
         include DocumentationComment
         include DefNode
@@ -119,6 +130,7 @@ module RuboCop
         def check(node)
           return if non_public?(node) && !require_for_non_public_methods?
           return if documentation_comment?(node)
+          return if method_allowed?(node)
 
           add_offense(node)
         end
@@ -126,6 +138,14 @@ module RuboCop
         def require_for_non_public_methods?
           cop_config['RequireForNonPublicMethods']
         end
+
+        def method_allowed?(node)
+          allowed_methods.include?(node.method_name)
+        end
+
+        def allowed_methods
+          @allowed_methods ||= cop_config.fetch('AllowedMethods', []).map(&:to_sym)
+        end
       end
     end
   end

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

@@ -93,23 +93,23 @@ module RuboCop
 
           if conditional_node
             double_negative_condition_return_value?(node, last_child, conditional_node)
-          elsif last_child.pair_type? || last_child.hash_type? || last_child.parent.array_type?
+          elsif last_child.type?(:pair, :hash) || last_child.parent.array_type?
             false
           else
-            last_child.last_line <= node.last_line
+            last_child.first_line <= node.first_line
           end
         end
 
         def find_def_node_from_ascendant(node)
           return unless (parent = node.parent)
-          return parent if parent.def_type? || parent.defs_type?
+          return parent if parent.any_def_type?
           return node.parent.child_nodes.first if define_method?(parent)
 
           find_def_node_from_ascendant(node.parent)
         end
 
         def define_method?(node)
-          return false unless node.block_type?
+          return false unless node.any_block_type?
 
           child = node.child_nodes.first
           return false unless child.send_type?
@@ -147,7 +147,7 @@ module RuboCop
         def find_parent_not_enumerable(node)
           return unless (parent = node.parent)
 
-          if parent.pair_type? || parent.hash_type? || parent.array_type?
+          if parent.type?(:pair, :hash, :array)
             find_parent_not_enumerable(parent)
           else
             parent

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Checks for loops which iterate a constant number of times,
-      # using a Range literal and `#each`. This can be done more readably using
+      # using a `Range` literal and `#each`. This can be done more readably using
       # `Integer#times`.
       #
       # This check only applies if the block takes no parameters.
@@ -16,7 +16,6 @@ module RuboCop
       #   # good
       #   5.times { }
       #
-      # @example
       #   # bad
       #   (0...10).each {}
       #
@@ -32,30 +31,29 @@ module RuboCop
 
           send_node = node.send_node
 
-          range = send_node.receiver.source_range.join(send_node.loc.selector)
-
-          add_offense(range) do |corrector|
+          add_offense(send_node) do |corrector|
             range_type, min, max = each_range(node)
 
             max += 1 if range_type == :irange
 
-            corrector.replace(node.send_node, "#{max - min}.times")
+            corrector.replace(send_node, "#{max - min}.times")
           end
         end
 
         private
 
         def offending?(node)
+          return false unless node.arguments.empty?
+
           each_range_with_zero_origin?(node) || each_range_without_block_argument?(node)
         end
 
         # @!method each_range(node)
         def_node_matcher :each_range, <<~PATTERN
           (block
-            (send
+            (call
               (begin
-                (${irange erange}
-                  (int $_) (int $_)))
+                ($range (int $_) (int $_)))
               :each)
             (args ...)
             ...)
@@ -64,10 +62,9 @@ module RuboCop
         # @!method each_range_with_zero_origin?(node)
         def_node_matcher :each_range_with_zero_origin?, <<~PATTERN
           (block
-            (send
+            (call
               (begin
-                ({irange erange}
-                  (int 0) (int _)))
+                (range (int 0) (int _)))
               :each)
             (args ...)
             ...)
@@ -76,10 +73,9 @@ module RuboCop
         # @!method each_range_without_block_argument?(node)
         def_node_matcher :each_range_without_block_argument?, <<~PATTERN
           (block
-            (send
+            (call
               (begin
-                ({irange erange}
-                  (int _) (int _)))
+                (range (int _) (int _)))
               :each)
             (args)
             ...)

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

@@ -58,12 +58,12 @@ module RuboCop
 
         # @!method each_with_object_block_candidate?(node)
         def_node_matcher :each_with_object_block_candidate?, <<~PATTERN
-          (block $(send _ {:inject :reduce} _) $_ $_)
+          (block $(call _ {:inject :reduce} _) $(args _ _) $_)
         PATTERN
 
         # @!method each_with_object_numblock_candidate?(node)
         def_node_matcher :each_with_object_numblock_candidate?, <<~PATTERN
-          (numblock $(send _ {:inject :reduce} _) 2 $_)
+          (numblock $(call _ {:inject :reduce} _) 2 $_)
         PATTERN
 
         def autocorrect_block(corrector, node, return_value)
@@ -71,8 +71,7 @@ module RuboCop
 
           first_arg, second_arg = *node.arguments
 
-          corrector.replace(first_arg, second_arg.source)
-          corrector.replace(second_arg, first_arg.source)
+          corrector.swap(first_arg, second_arg)
 
           if return_value_occupies_whole_line?(return_value)
             corrector.remove(whole_line_expression(return_value))

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

@@ -131,6 +131,8 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Redundant `else`-clause.'
+        NIL_STYLES = %i[nil both].freeze
+        EMPTY_STYLES = %i[empty both].freeze
 
         def on_normal_if_unless(node)
           check(node)
@@ -143,18 +145,18 @@ module RuboCop
         private
 
         def check(node)
-          return if cop_config['AllowComments'] && comment_in_else?(node.loc)
+          return if cop_config['AllowComments'] && comment_in_else?(node)
 
           empty_check(node) if empty_style?
           nil_check(node) if nil_style?
         end
 
         def nil_style?
-          style == :nil || style == :both
+          NIL_STYLES.include?(style)
         end
 
         def empty_style?
-          style == :empty || style == :both
+          EMPTY_STYLES.include?(style)
         end
 
         def empty_check(node)
@@ -171,16 +173,17 @@ module RuboCop
 
         def autocorrect(corrector, node)
           return false if autocorrect_forbidden?(node.type.to_s)
-          return false if comment_in_else?(node.loc)
+          return false if comment_in_else?(node)
 
           end_pos = base_node(node).loc.end.begin_pos
           corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
         end
 
-        def comment_in_else?(loc)
-          return false if loc.else.nil? || loc.end.nil?
+        def comment_in_else?(node)
+          node = node.parent while node.if_type? && node.elsif?
+          return false unless node.else?
 
-          processed_source.contains_comment?(loc.else.join(loc.end))
+          processed_source.contains_comment?(node.loc.else.join(node.source_range.end))
         end
 
         def base_node(node)

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

@@ -36,6 +36,7 @@ module RuboCop
       class EmptyHeredoc < Base
         include Heredoc
         include RangeHelp
+        include StringLiteralsHelp
         extend AutoCorrector
 
         MSG = 'Use an empty string literal instead of heredoc.'
@@ -53,20 +54,6 @@ module RuboCop
             corrector.remove(range_by_whole_lines(heredoc_end, include_final_newline: true))
           end
         end
-
-        private
-
-        def preferred_string_literal
-          enforce_double_quotes? ? '""' : "''"
-        end
-
-        def enforce_double_quotes?
-          string_literals_config['EnforcedStyle'] == 'double_quotes'
-        end
-
-        def string_literals_config
-          config.for_cop('Style/StringLiterals')
-        end
       end
     end
   end

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

@@ -6,10 +6,16 @@ module RuboCop
       # Checks for the use of a method, the result of which
       # would be a literal, like an empty array, hash, or string.
       #
+      # NOTE: When frozen string literals are enabled, `String.new`
+      # isn't corrected to an empty string since the former is
+      # mutable and the latter would be frozen.
+      #
       # @example
       #   # bad
       #   a = Array.new
+      #   a = Array[]
       #   h = Hash.new
+      #   h = Hash[]
       #   s = String.new
       #
       #   # good
@@ -19,16 +25,17 @@ module RuboCop
       class EmptyLiteral < Base
         include FrozenStringLiteral
         include RangeHelp
+        include StringLiteralsHelp
         extend AutoCorrector
 
-        ARR_MSG = 'Use array literal `[]` instead of `Array.new`.'
-        HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'
+        ARR_MSG = 'Use array literal `[]` instead of `%<current>s`.'
+        HASH_MSG = 'Use hash literal `{}` instead of `%<current>s`.'
         STR_MSG = 'Use string literal `%<prefer>s` instead of `String.new`.'
 
-        RESTRICT_ON_SEND = %i[new].freeze
+        RESTRICT_ON_SEND = %i[new [] Array Hash].freeze
 
         # @!method array_node(node)
-        def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new)'
+        def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new (array)?)'
 
         # @!method hash_node(node)
         def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new)'
@@ -47,6 +54,22 @@ module RuboCop
           }
         PATTERN
 
+        # @!method array_with_index(node)
+        def_node_matcher :array_with_index, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Array) :[])
+            (send nil? :Array (array))
+          }
+        PATTERN
+
+        # @!method hash_with_index(node)
+        def_node_matcher :hash_with_index, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Hash) :[])
+            (send nil? :Hash (array))
+          }
+        PATTERN
+
         def on_send(node)
           return unless (message = offense_message(node))
 
@@ -59,31 +82,19 @@ module RuboCop
 
         def offense_message(node)
           if offense_array_node?(node)
-            ARR_MSG
+            format(ARR_MSG, current: node.source)
           elsif offense_hash_node?(node)
-            HASH_MSG
+            format(HASH_MSG, current: node.source)
           elsif str_node(node) && !frozen_strings?
             format(STR_MSG, prefer: preferred_string_literal)
           end
         end
 
-        def preferred_string_literal
-          enforce_double_quotes? ? '""' : "''"
-        end
-
-        def enforce_double_quotes?
-          string_literals_config['EnforcedStyle'] == 'double_quotes'
-        end
-
-        def string_literals_config
-          config.for_cop('Style/StringLiterals')
-        end
-
         def first_argument_unparenthesized?(node)
           parent = node.parent
           return false unless parent && %i[send super zsuper].include?(parent.type)
 
-          node.equal?(parent.arguments.first) && !parentheses?(node.parent)
+          node.equal?(parent.first_argument) && !parentheses?(node.parent)
         end
 
         def replacement_range(node)
@@ -100,12 +111,12 @@ module RuboCop
         end
 
         def offense_array_node?(node)
-          array_node(node) && !array_with_block(node.parent)
+          (array_node(node) && !array_with_block(node.parent)) || array_with_index(node)
         end
 
         def offense_hash_node?(node)
           # If Hash.new takes a block, it can't be changed to {}.
-          hash_node(node) && !hash_with_block(node.parent)
+          (hash_node(node) && !hash_with_block(node.parent)) || hash_with_index(node)
         end
 
         def correction(node)
@@ -129,8 +140,10 @@ module RuboCop
         def frozen_strings?
           return true if frozen_string_literals_enabled?
 
-          frozen_string_cop_enabled = config.for_cop('Style/FrozenStringLiteral')['Enabled']
-          frozen_string_cop_enabled && !frozen_string_literals_disabled?
+          frozen_string_cop_enabled = config.cop_enabled?('Style/FrozenStringLiteralComment')
+          frozen_string_cop_enabled &&
+            !frozen_string_literals_disabled? &&
+            string_literals_frozen_by_default?.nil?
         end
       end
     end

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

@@ -109,7 +109,7 @@ module RuboCop
         end
 
         def max_line_length
-          return unless config.for_cop('Layout/LineLength')['Enabled']
+          return unless config.cop_enabled?('Layout/LineLength')
 
           config.for_cop('Layout/LineLength')['Max']
         end