rubocop 1.22.2 → 1.24.1

data/lib/rubocop/cop/generator.rb

@@ -150,7 +150,7 @@ module RuboCop
             1. Modify the description of #{badge} in config/default.yml
             2. Implement your new cop in the generated file!
             3. Commit your new cop with a message such as
-               e.g. "Add new `#{badge}` cop."
+               e.g. "Add new `#{badge}` cop"
             4. Run `bundle exec rake changelog:new` to generate a changelog entry
                for your new cop.
         TODO

data/lib/rubocop/cop/internal_affairs/redundant_method_dispatch_node.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for redundant `send_node` method dispatch node.
+      #
+      # @example
+      #
+      #   # bad
+      #   node.send_node.method_name
+      #
+      #   # good
+      #   node.method_name
+      #
+      #   # bad
+      #   node.send_node.receiver
+      #
+      #   # good
+      #   node.receiver
+      #
+      class RedundantMethodDispatchNode < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `send_node`.'
+        RESTRICT_ON_SEND = %i[method_name receiver].freeze
+
+        # @!method dispatch_method(node)
+        def_node_matcher :dispatch_method, <<~PATTERN
+          (send $(send _ :send_node) _)
+        PATTERN
+
+        def on_send(node)
+          return unless (dispatch_node = dispatch_method(node))
+          return unless (dot = dispatch_node.loc.dot)
+
+          range = range_between(dot.begin_pos, dispatch_node.loc.selector.end_pos)
+
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/undefined_config.rb

@@ -14,7 +14,9 @@ module RuboCop
 
         # @!method cop_class_def(node)
         def_node_search :cop_class_def, <<~PATTERN
-          (class _ (const _ {:Base :Cop}) ...)
+          (class _
+            (const {nil? (const nil? :Cop) (const (const {cbase nil?} :RuboCop) :Cop)}
+              {:Base :Cop}) ...)
         PATTERN
 
         # @!method cop_config_accessor?(node)

data/lib/rubocop/cop/internal_affairs.rb

@@ -13,6 +13,7 @@ require_relative 'internal_affairs/redundant_described_class_as_subject'
 require_relative 'internal_affairs/redundant_let_rubocop_config_new'
 require_relative 'internal_affairs/redundant_location_argument'
 require_relative 'internal_affairs/redundant_message_argument'
+require_relative 'internal_affairs/redundant_method_dispatch_node'
 require_relative 'internal_affairs/style_detected_api_use'
 require_relative 'internal_affairs/undefined_config'
 require_relative 'internal_affairs/useless_message_assertion'

data/lib/rubocop/cop/layout/block_alignment.rb

@@ -101,11 +101,11 @@ module RuboCop
         def block_end_align_target(node)
           lineage = [node, *node.ancestors]
 
-          target = lineage.each_cons(2) do |current, parent|
-            break current if end_align_target?(current, parent)
+          lineage.each_cons(2) do |current, parent|
+            return current if end_align_target?(current, parent)
           end
 
-          target || lineage.last
+          lineage.last
         end
 
         def end_align_target?(node, parent)

data/lib/rubocop/cop/layout/comment_indentation.rb

@@ -32,6 +32,19 @@ module RuboCop
       #     true
       #   end
       #
+      # @example AllowForAlignment: false (default)
+      #   # bad
+      #   a = 1 # A really long comment
+      #         # spanning two lines.
+      #
+      #   # good
+      #   # A really long comment spanning one line.
+      #   a = 1
+      #
+      # @example AllowForAlignment: true
+      #   # good
+      #   a = 1 # A really long comment
+      #         # spanning two lines.
       class CommentIndentation < Base
         include Alignment
         extend AutoCorrector
@@ -40,7 +53,7 @@ module RuboCop
               'instead of %<correct_comment_indentation>d).'
 
         def on_new_investigation
-          processed_source.comments.each { |comment| check(comment) }
+          processed_source.comments.each_with_index { |comment, ix| check(comment, ix) }
         end
 
         private
@@ -76,7 +89,7 @@ module RuboCop
           AlignmentCorrector.correct(corrector, processed_source, comment, @column_delta)
         end
 
-        def check(comment)
+        def check(comment, comment_index)
           return unless own_line_comment?(comment)
 
           next_line = line_after_comment(comment)
@@ -94,11 +107,27 @@ module RuboCop
             return if column == correct_comment_indentation
           end
 
+          return if correctly_aligned_with_preceding_comment?(comment_index, column)
+
           add_offense(comment, message: message(column, correct_comment_indentation)) do |corrector|
             autocorrect(corrector, comment)
           end
         end
 
+        # Returns true if:
+        # a) the cop is configured to allow extra indentation for alignment, and
+        # b) the currently inspected comment is aligned with the nearest preceding end-of-line
+        #    comment.
+        def correctly_aligned_with_preceding_comment?(comment_index, column)
+          return false unless cop_config['AllowForAlignment']
+
+          processed_source.comments[0...comment_index].reverse_each do |other_comment|
+            return other_comment.loc.column == column unless own_line_comment?(other_comment)
+          end
+
+          false
+        end
+
         def message(column, correct_comment_indentation)
           format(MSG, column: column, correct_comment_indentation: correct_comment_indentation)
         end

data/lib/rubocop/cop/layout/dot_position.rb

@@ -27,6 +27,10 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
+        def self.autocorrect_incompatible_with
+          [Style::RedundantSelf]
+        end
+
         def on_send(node)
           return unless node.dot? || ampersand_dot?(node)
 
@@ -70,7 +74,7 @@ module RuboCop
         def proper_dot_position?(node)
           selector_range = selector_range(node)
 
-          return true if same_line?(selector_range, selector_range(node.receiver))
+          return true if same_line?(selector_range, end_range(node.receiver))
 
           selector_line = selector_range.line
           receiver_line = receiver_end_line(node.receiver)
@@ -119,6 +123,10 @@ module RuboCop
           (node.str_type? || node.dstr_type?) && node.heredoc?
         end
 
+        def end_range(node)
+          node.source_range.end
+        end
+
         def selector_range(node)
           return node unless node.call_type?
 

data/lib/rubocop/cop/layout/empty_line_between_defs.rb

@@ -77,13 +77,34 @@ module RuboCop
       #   def b
       #   end
       #
-      # @example AllowAdjacentOneLineDefs: true
+      # @example AllowAdjacentOneLineDefs: true (default)
       #
       #   # good
       #   class ErrorA < BaseError; end
       #   class ErrorB < BaseError; end
       #   class ErrorC < BaseError; end
       #
+      #   # good
+      #   class ErrorA < BaseError; end
+      #
+      #   class ErrorB < BaseError; end
+      #
+      #   class ErrorC < BaseError; end
+      #
+      # @example AllowAdjacentOneLineDefs: false
+      #
+      #   # bad
+      #   class ErrorA < BaseError; end
+      #   class ErrorB < BaseError; end
+      #   class ErrorC < BaseError; end
+      #
+      #   # good
+      #   class ErrorA < BaseError; end
+      #
+      #   class ErrorB < BaseError; end
+      #
+      #   class ErrorC < BaseError; end
+      #
       class EmptyLineBetweenDefs < Base
         include RangeHelp
         extend AutoCorrector

data/lib/rubocop/cop/layout/hash_alignment.rb

@@ -313,7 +313,7 @@ module RuboCop
           # just give each lambda the same reference and they would all get the
           # last value of each. A local variable fixes the problem.
 
-          if node.value
+          if node.value && node.respond_to?(:value_omission?) && !node.value_omission?
             correct_key_value(corrector, delta, node.key.source_range,
                               node.value.source_range,
                               node.loc.operator)

data/lib/rubocop/cop/layout/space_after_colon.rb

@@ -19,7 +19,7 @@ module RuboCop
         MSG = 'Space missing after colon.'
 
         def on_pair(node)
-          return unless node.colon?
+          return if !node.colon? || node.value_omission?
 
           colon = node.loc.operator
 

data/lib/rubocop/cop/layout/space_before_first_arg.rb

@@ -28,6 +28,10 @@ module RuboCop
 
         MSG = 'Put one space between the method name and the first argument.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           return unless regular_method_call_with_arguments?(node)
 

data/lib/rubocop/cop/layout/space_in_lambda_literal.rb

@@ -30,15 +30,17 @@ module RuboCop
         def on_send(node)
           return unless arrow_lambda_with_args?(node)
 
-          lambda_node = range_of_offense(node)
-
           if style == :require_space && !space_after_arrow?(node)
+            lambda_node = range_of_offense(node)
+
             add_offense(lambda_node, message: MSG_REQUIRE_SPACE) do |corrector|
-              corrector.insert_before(node.parent.children[1], ' ')
+              corrector.insert_before(lambda_arguments(node), ' ')
             end
           elsif style == :require_no_space && space_after_arrow?(node)
-            add_offense(lambda_node, message: MSG_REQUIRE_NO_SPACE) do |corrector|
-              corrector.remove(space_after_arrow(node))
+            space = space_after_arrow(node)
+
+            add_offense(space, message: MSG_REQUIRE_NO_SPACE) do |corrector|
+              corrector.remove(space)
             end
           end
         end
@@ -66,6 +68,10 @@ module RuboCop
             node.parent.arguments.loc.expression.end_pos
           )
         end
+
+        def lambda_arguments(node)
+          node.parent.children[1]
+        end
       end
     end
   end

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

@@ -8,7 +8,7 @@ module RuboCop
       # Ranges have quite low precedence, which leads to unexpected behaviour when
       # using a range with other operators. This cop avoids that by making ranges
       # explicit by requiring parenthesis around complex range boundaries (anything
-      # that is not a basic literal: numerics, strings, symbols, etc.).
+      # that is not a literal: numerics, strings, symbols, etc.).
       #
       # This cop can be configured with `RequireParenthesesForMethodChains` in order to
       # specify whether method chains (including `self.foo`) should be wrapped in parens
@@ -81,7 +81,7 @@ module RuboCop
 
         def acceptable?(node)
           node.begin_type? ||
-            node.basic_literal? ||
+            node.literal? ||
             node.variable? || node.const_type? || node.self_type? ||
             (node.call_type? && acceptable_call?(node))
         end

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

@@ -92,7 +92,7 @@ module RuboCop
         private
 
         def method_name(node)
-          node.ancestors.find(&:block_type?).send_node.method_name
+          node.ancestors.find(&:block_type?).method_name
         end
       end
     end

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

@@ -12,6 +12,7 @@ module RuboCop
       #   File.exists?(some_path)
       #   Dir.exists?(some_path)
       #   iterator?
+      #   ENV.freeze # Calling `Env.freeze` raises `TypeError` since Ruby 2.7.
       #   Socket.gethostbyname(host)
       #   Socket.gethostbyaddr(host)
       #
@@ -22,6 +23,7 @@ module RuboCop
       #   File.exist?(some_path)
       #   Dir.exist?(some_path)
       #   block_given?
+      #   ENV # `ENV.freeze` cannot prohibit changes to environment variables.
       #   Addrinfo.getaddrinfo(nodename, service)
       #   Addrinfo.tcp(host, port).getnameinfo
       class DeprecatedClassMethods < Base
@@ -106,6 +108,9 @@ module RuboCop
 
           DeprecatedClassMethod.new(:iterator?) => Replacement.new(:block_given?),
 
+          DeprecatedClassMethod.new(:freeze, class_constant: :ENV) =>
+            Replacement.new(nil, class_constant: :ENV),
+
           DeprecatedClassMethod.new(:gethostbyaddr, class_constant: :Socket, correctable: false) =>
             Replacement.new(:getnameinfo, class_constant: :Addrinfo, instance_method: true),
 
@@ -120,11 +125,18 @@ module RuboCop
 
         def on_send(node)
           check(node) do |deprecated|
-            message = format(MSG, current: deprecated, prefer: replacement(deprecated))
+            prefer = replacement(deprecated)
+            message = format(MSG, current: deprecated, prefer: prefer)
+            current_method = node.loc.selector
+
+            add_offense(current_method, message: message) do |corrector|
+              next unless deprecated.correctable?
 
-            add_offense(node.loc.selector, message: message) do |corrector|
-              if deprecated.correctable?
-                corrector.replace(node.loc.selector, replacement(deprecated).method)
+              if (preferred_method = prefer.method)
+                corrector.replace(current_method, preferred_method)
+              else
+                corrector.remove(node.loc.dot)
+                corrector.remove(current_method)
               end
             end
           end

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

@@ -42,11 +42,12 @@ module RuboCop
           #        Maybe further investigation of RuboCop AST will lead to an essential solution.
           return unless node.loc
 
-          constant = node.absolute? ? constant_name(node, node.short_name.to_s) : node.source
+          constant = node.absolute? ? constant_name(node, node.short_name) : node.source
           return unless (deprecated_constant = deprecated_constants[constant])
 
           alternative = deprecated_constant['Alternative']
           version = deprecated_constant['DeprecatedVersion']
+          return if target_ruby_version < version.to_f
 
           add_offense(node, message: message(alternative, node.source, version)) do |corrector|
             corrector.replace(node, alternative)
@@ -56,7 +57,7 @@ module RuboCop
         private
 
         def constant_name(node, nested_constant_name)
-          return nested_constant_name unless node.namespace.const_type?
+          return nested_constant_name.to_s unless node.namespace.const_type?
 
           constant_name(node.namespace, "#{node.namespace.short_name}::#{nested_constant_name}")
         end

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

@@ -55,8 +55,14 @@ module RuboCop
             ...)
         PATTERN
 
+        # @!method digest_const?(node)
+        def_node_matcher :digest_const?, <<~PATTERN
+          (const _ :Digest)
+        PATTERN
+
         def on_send(node)
           return if node.arguments.any? { |arg| arg.variable? || arg.send_type? || arg.const_type? }
+          return if digest_const?(node.receiver)
           return unless algorithm_const(node)
 
           message = message(node)

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

@@ -27,7 +27,7 @@ module RuboCop
 
         # @!method each_with_object?(node)
         def_node_matcher :each_with_object?, <<~PATTERN
-          ({send csend} _ :each_with_object $_)
+          (call _ :each_with_object $_)
         PATTERN
 
         def on_send(node)

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

@@ -20,6 +20,10 @@ module RuboCop
       #   # good
       #   io.wait_writable(timeout)
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because `NoMethodError` occurs
+      #   if `require 'io/wait'` is not called.
+      #
       class IncompatibleIoSelectWithFiberScheduler < Base
         extend AutoCorrector
 

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

@@ -30,6 +30,7 @@ module RuboCop
       #   '10'.to_i
       #   '10.2'.to_f
       #   '10'.to_c
+      #   '1/3'.to_r
       #   ['1', '2', '3'].map(&:to_i)
       #   foo.try(:to_f)
       #   bar.send(:to_c)
@@ -39,6 +40,7 @@ module RuboCop
       #   Integer('10', 10)
       #   Float('10.2')
       #   Complex('10')
+      #   Rational('1/3')
       #   ['1', '2', '3'].map { |i| Integer(i, 10) }
       #   foo.try { |i| Float(i) }
       #   bar.send { |i| Complex(i) }
@@ -59,13 +61,14 @@ module RuboCop
         CONVERSION_METHOD_CLASS_MAPPING = {
           to_i: "#{Integer.name}(%<number_object>s, 10)",
           to_f: "#{Float.name}(%<number_object>s)",
-          to_c: "#{Complex.name}(%<number_object>s)"
+          to_c: "#{Complex.name}(%<number_object>s)",
+          to_r: "#{Rational.name}(%<number_object>s)"
         }.freeze
         MSG = 'Replace unsafe number conversion with number '\
               'class parsing, instead of using '\
               '`%<current>s`, use stricter '\
               '`%<corrected_method>s`.'
-        CONVERSION_METHODS = %i[Integer Float Complex to_i to_f to_c].freeze
+        CONVERSION_METHODS = %i[Integer Float Complex Rational to_i to_f to_c to_r].freeze
         METHODS = CONVERSION_METHOD_CLASS_MAPPING.keys.map(&:inspect).join(' ')
 
         # @!method to_method(node)

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

@@ -41,7 +41,11 @@ module RuboCop
           end
 
           node.operator_method? || node.setter_method? || chained_calls?(node) ||
-            operator_keyword?(node) || node.first_argument.hash_type?
+            valid_first_argument?(node.first_argument)
+        end
+
+        def valid_first_argument?(first_arg)
+          first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg)
         end
 
         def first_argument_starts_with_left_parenthesis?(node)
@@ -53,9 +57,8 @@ module RuboCop
           first_argument.send_type? && (node.children.last&.children&.count || 0) > 1
         end
 
-        def operator_keyword?(node)
-          first_argument = node.first_argument
-          first_argument.operator_keyword?
+        def ternary_expression?(node)
+          node.if_type? && node.ternary?
         end
 
         def spaces_before_left_parenthesis(node)

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop 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
+      # a keyword splat (`**kwargs`).
+      #
+      # @example
+      #   # good (splat argument without keyword arguments)
+      #   ruby2_keywords def foo(*args); end
+      #
+      #   # bad (no arguments)
+      #   ruby2_keywords def foo; end
+      #
+      #   # good
+      #   def foo; end
+      #
+      #   # bad (positional argument)
+      #   ruby2_keywords def foo(arg); end
+      #
+      #   # good
+      #   def foo(arg); end
+      #
+      #   # bad (double splatted argument)
+      #   ruby2_keywords def foo(**args); end
+      #
+      #   # good
+      #   def foo(**args); end
+      #
+      #   # bad (keyword arguments)
+      #   ruby2_keywords def foo(i:, j:); end
+      #
+      #   # good
+      #   def foo(i:, j:); end
+      #
+      #   # bad (splat argument with keyword arguments)
+      #   ruby2_keywords def foo(*args, i:, j:); end
+      #
+      #   # good
+      #   def foo(*args, i:, j:); end
+      #
+      #   # bad (splat argument with double splat)
+      #   ruby2_keywords def foo(*args, **kwargs); end
+      #
+      #   # good
+      #   def foo(*args, **kwargs); end
+      #
+      #   # bad (ruby2_keywords given a symbol)
+      #   def foo; end
+      #   ruby2_keywords :foo
+      #
+      #   # good
+      #   def foo; end
+      #
+      #   # bad (ruby2_keywords with dynamic method)
+      #   define_method(:foo) { |arg| }
+      #   ruby2_keywords :foo
+      #
+      #   # good
+      #   define_method(:foo) { |arg| }
+      #
+      class UselessRuby2Keywords < Base
+        MSG = '`ruby2_keywords` is unnecessary for method `%<method_name>s`.'
+        RESTRICT_ON_SEND = %i[ruby2_keywords].freeze
+
+        # Looks for statically or dynamically defined methods with a given name
+        # @!method method_definition(node, method_name)
+        def_node_matcher :method_definition, <<~PATTERN
+          {
+            (def %1 ...)
+            ({block numblock} (send _ :define_method (sym %1)) ...)
+          }
+        PATTERN
+
+        def on_send(node)
+          if node.first_argument.def_type?
+            inspect_def(node, node.first_argument)
+          elsif node.first_argument.sym_type?
+            inspect_sym(node, node.first_argument)
+          end
+        end
+
+        private
+
+        def inspect_def(node, def_node)
+          return if allowed_arguments(def_node.arguments)
+
+          add_offense(node.loc.selector, message: format(MSG, method_name: def_node.method_name))
+        end
+
+        def inspect_sym(node, sym_node)
+          return unless node.parent
+
+          method_name = sym_node.value
+          definition = node.parent.each_child_node.detect { |n| method_definition(n, method_name) }
+
+          return unless definition
+          return if allowed_arguments(definition.arguments)
+
+          add_offense(node, message: format(MSG, method_name: method_name))
+        end
+
+        # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments
+        def allowed_arguments(arguments)
+          return false if arguments.empty?
+
+          arguments.each_child_node(:restarg).any? &&
+            arguments.each_child_node(:kwarg, :kwoptarg, :kwrestarg).none?
+        end
+      end
+    end
+  end
+end

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

@@ -50,6 +50,7 @@ module RuboCop
 
           check_code_length(node)
         end
+        alias on_numblock on_block
 
         private
 

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

@@ -46,15 +46,6 @@ module RuboCop
           1
         end
 
-        def block_method(node)
-          case node.type
-          when :block
-            node.method_name
-          when :block_pass
-            node.parent.method_name
-          end
-        end
-
         def count_block?(block)
           KNOWN_ITERATING_METHODS.include? block.method_name
         end

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

@@ -52,6 +52,7 @@ module RuboCop
 
           check_code_length(node)
         end
+        alias on_numblock on_block
 
         private
 

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

@@ -44,7 +44,7 @@ module RuboCop
 
         # @!method module_definition?(node)
         def_node_matcher :module_definition?, <<~PATTERN
-          (casgn nil? _ (block (send (const {nil? cbase} :Module) :new) ...))
+          (casgn nil? _ ({block numblock} (send (const {nil? cbase} :Module) :new) ...))
         PATTERN
 
         def message(length, max_length)

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

@@ -10,7 +10,7 @@ module RuboCop
       # as they add less complexity than positional or optional parameters.
       #
       # NOTE: Explicit block argument `&block` is not counted to prevent
-      #       erroneous change that is avoided by making block argument implicit.
+      # erroneous change that is avoided by making block argument implicit.
       #
       # @example Max: 3
       #   # good