rubocop 1.23.0 → 1.25.1

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)
 

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

@@ -81,7 +81,7 @@ module RuboCop
 
           locations.each do |loc|
             line = loc.line
-            next if line == line_of_def_or_kwbegin
+            next if line == line_of_def_or_kwbegin || last_rescue_and_end_on_same_line(body)
 
             keyword = loc.source
             # below the keyword
@@ -91,6 +91,10 @@ module RuboCop
           end
         end
 
+        def last_rescue_and_end_on_same_line(body)
+          body.rescue_type? && body.resbody_branches.last.loc.line == body.parent.loc.end.line
+        end
+
         def message(location, keyword)
           format(MSG, location: location, keyword: keyword)
         end

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

@@ -222,11 +222,16 @@ module RuboCop
                               node.pairs.any? &&
                               node.parent&.call_type?
 
+          left_sibling = argument_before_hash(node)
           parent_loc = node.parent.loc
-          selector = parent_loc.selector || parent_loc.expression
+          selector = left_sibling || parent_loc.selector || parent_loc.expression
           same_line?(selector, node.pairs.first)
         end
 
+        def argument_before_hash(hash_node)
+          hash_node.left_sibling.respond_to?(:loc) ? hash_node.left_sibling : nil
+        end
+
         def reset!
           self.offenses_by = {}
           self.column_deltas = Hash.new { |hash, key| hash[key] = {} }
@@ -313,7 +318,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/rescue_ensure_alignment.rb

@@ -143,7 +143,7 @@ module RuboCop
             return true
           end
 
-          do_keyword_line == selector.line && rescue_keyword_column == selector.column
+          do_keyword_line == selector&.line && rescue_keyword_column == selector.column
         end
 
         def aligned_with_leading_dot?(do_keyword_line, send_node_loc, rescue_keyword_column)

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/lint/ambiguous_regexp_literal.rb

@@ -30,7 +30,11 @@ module RuboCop
 
         def on_new_investigation
           processed_source.diagnostics.each do |diagnostic|
-            next unless diagnostic.reason == :ambiguous_literal
+            if target_ruby_version >= 3.0
+              next unless diagnostic.reason == :ambiguous_regexp
+            else
+              next unless diagnostic.reason == :ambiguous_literal
+            end
 
             offense_node = find_offense_node_by(diagnostic)
 

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_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
 
@@ -29,11 +33,12 @@ module RuboCop
         # @!method io_select(node)
         def_node_matcher :io_select, <<~PATTERN
           (send
-            (const {nil? cbase} :IO) :select $_ $_ {(array) nil} $...)
+            (const {nil? cbase} :IO) :select $...)
         PATTERN
 
         def on_send(node)
-          return unless (read, write, timeout = io_select(node))
+          read, write, _excepts, timeout = *io_select(node)
+          return unless read
           return unless scheduler_compatible?(read, write) || scheduler_compatible?(write, read)
 
           preferred = preferred_method(read, write, timeout)
@@ -47,13 +52,13 @@ module RuboCop
         private
 
         def scheduler_compatible?(io1, io2)
-          return false unless io1.array_type? && io1.values.size == 1
+          return false unless io1&.array_type? && io1.values.size == 1
 
-          io2.array_type? ? io2.values.empty? : io2.nil_type?
+          io2&.array_type? ? io2.values.empty? : (io2.nil? || io2.nil_type?)
         end
 
         def preferred_method(read, write, timeout)
-          timeout_argument = timeout.empty? ? '' : "(#{timeout[0].source})"
+          timeout_argument = timeout.nil? ? '' : "(#{timeout.source})"
 
           if read.array_type? && read.values[0]
             "#{read.values[0].source}.wait_readable#{timeout_argument}"

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/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/utils/code_length_calculator.rb

@@ -135,7 +135,7 @@ module RuboCop
 
           def extract_body(node)
             case node.type
-            when :class, :module, :block, :def, :defs
+            when :class, :module, :block, :numblock, :def, :defs
               node.body
             when :casgn
               _scope, _name, value = *node

data/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb

@@ -59,7 +59,7 @@ module RuboCop
 
           # @!method attribute_call?(node)
           def_node_matcher :attribute_call?, <<~PATTERN
-            ( {csend send} _receiver _method # and no parameters
+            (call _receiver _method # and no parameters
             )
           PATTERN
 

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

@@ -13,6 +13,11 @@ module RuboCop
     # @api private
     module EnforceSuperclass
       def self.included(base)
+        warn Rainbow(
+          '`RuboCop::Cop::EnforceSuperclass` is deprecated and will be removed in RuboCop 2.0. ' \
+          'Please upgrade to RuboCop Rails 2.9 or newer to continue.'
+        ).yellow
+
         # @!method class_definition(node)
         base.def_node_matcher :class_definition, <<~PATTERN
           (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)

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

@@ -43,7 +43,7 @@ module RuboCop
         end
 
         def value_delta(pair)
-          return 0 if pair.value_on_new_line?
+          return 0 if pair.value_on_new_line? || pair.value_omission?
 
           correct_value_column = pair.loc.operator.end.column + 1
           actual_value_column = pair.value.loc.column
@@ -111,7 +111,8 @@ module RuboCop
           correct_value_column = first_pair.key.loc.column +
                                  current_pair.delimiter(true).length +
                                  max_key_width
-          correct_value_column - current_pair.value.loc.column
+
+          current_pair.value_omission? ? 0 : correct_value_column - current_pair.value.loc.column
         end
       end
 
@@ -134,7 +135,7 @@ module RuboCop
         end
 
         def value_delta(first_pair, current_pair)
-          first_pair.value_delta(current_pair)
+          current_pair.value_omission? ? 0 : first_pair.value_delta(current_pair)
         end
       end
 

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module checks for Ruby 3.1's hash value omission syntax.
+    module HashShorthandSyntax
+      OMIT_HASH_VALUE_MSG = 'Omit the hash value.'
+      EXPLICIT_HASH_VALUE_MSG = 'Explicit the hash value.'
+
+      def on_pair(node)
+        return if ignore_hash_shorthand_syntax?(node)
+
+        hash_key_source = node.key.source
+
+        if enforced_shorthand_syntax == 'always'
+          return if node.value_omission? || require_hash_value?(hash_key_source, node)
+
+          message = OMIT_HASH_VALUE_MSG
+          replacement = "#{hash_key_source}:"
+        else
+          return unless node.value_omission?
+
+          message = EXPLICIT_HASH_VALUE_MSG
+          replacement = "#{hash_key_source}: #{hash_key_source}"
+        end
+
+        add_offense(node.value, message: message) do |corrector|
+          corrector.replace(node, replacement)
+        end
+      end
+
+      private
+
+      def ignore_hash_shorthand_syntax?(pair_node)
+        target_ruby_version <= 3.0 || enforced_shorthand_syntax == 'either' ||
+          !pair_node.parent.hash_type?
+      end
+
+      def enforced_shorthand_syntax
+        cop_config.fetch('EnforcedShorthandSyntax', 'always')
+      end
+
+      def require_hash_value?(hash_key_source, node)
+        return true if require_hash_value_for_around_hash_literal?(node)
+
+        hash_value = node.value
+        return true unless hash_value.send_type? || hash_value.lvar_type?
+
+        hash_key_source != hash_value.source || hash_key_source.end_with?('!', '?')
+      end
+
+      def require_hash_value_for_around_hash_literal?(node)
+        return false unless (ancestor = node.parent.parent)
+        return false if ancestor.send_type? && ancestor.method?(:[])
+
+        !node.parent.braces? && !use_element_of_hash_literal_as_receiver?(ancestor, node.parent) &&
+          (use_modifier_form_without_parenthesized_method_call?(ancestor) ||
+           without_parentheses_call_expr_follows?(ancestor))
+      end
+
+      def use_element_of_hash_literal_as_receiver?(ancestor, parent)
+        # `{value:}.do_something` is a valid syntax.
+        ancestor.send_type? && ancestor.receiver == parent
+      end
+
+      def use_modifier_form_without_parenthesized_method_call?(ancestor)
+        return false if ancestor.respond_to?(:parenthesized?) && ancestor.parenthesized?
+        return false unless (parent = ancestor.parent)
+
+        parent.respond_to?(:modifier_form?) && parent.modifier_form?
+      end
+
+      def without_parentheses_call_expr_follows?(ancestor)
+        right_sibling = ancestor.right_sibling
+        right_sibling ||= ancestor.each_ancestor.find(&:assignment?)&.right_sibling
+        return false unless right_sibling
+
+        ancestor.respond_to?(:parenthesized?) && !ancestor.parenthesized? && !!right_sibling
+      end
+    end
+  end
+end

data/lib/rubocop/cop/naming/block_forwarding.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # In Ruby 3.1, anonymous block forwarding has been added.
+      #
+      # This cop identifies places where `do_something(&block)` can be replaced
+      # by `do_something(&)`.
+      #
+      # It also supports the opposite style by alternative `explicit` option.
+      # You can specify the block variable name for auto-correction with `BlockForwardingName`.
+      # The default variable name is `block`. If the name is already in use, it will not be
+      # auto-corrected.
+      #
+      # @example EnforcedStyle: anonymous (default)
+      #
+      #   # bad
+      #   def foo(&block)
+      #     bar(&block)
+      #   end
+      #
+      #   # good
+      #   def foo(&)
+      #     bar(&)
+      #   end
+      #
+      # @example EnforcedStyle: explicit
+      #
+      #   # bad
+      #   def foo(&)
+      #     bar(&)
+      #   end
+      #
+      #   # good
+      #   def foo(&block)
+      #     bar(&block)
+      #   end
+      #
+      class BlockForwarding < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 3.1
+
+        MSG = 'Use %<style>s block forwarding.'
+
+        def on_def(node)
+          return if node.arguments.empty?
+
+          last_argument = node.arguments.last
+          return if expected_block_forwarding_style?(node, last_argument)
+
+          register_offense(last_argument, node)
+
+          node.each_descendant(:block_pass) do |block_pass_node|
+            next if block_pass_node.children.first&.sym_type? ||
+                    last_argument.source != block_pass_node.source
+
+            register_offense(block_pass_node, node)
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        def expected_block_forwarding_style?(node, last_argument)
+          if style == :anonymous
+            !explicit_block_argument?(last_argument) ||
+              use_kwarg_in_method_definition?(node) ||
+              use_block_argument_as_local_variable?(node, last_argument.source[1..-1])
+          else
+            !anonymous_block_argument?(last_argument)
+          end
+        end
+
+        def use_kwarg_in_method_definition?(node)
+          node.arguments.each_descendant(:kwarg, :kwoptarg).any?
+        end
+
+        def anonymous_block_argument?(node)
+          node.blockarg_type? && node.name.nil?
+        end
+
+        def explicit_block_argument?(node)
+          node.blockarg_type? && !node.name.nil?
+        end
+
+        def register_offense(block_argument, node)
+          add_offense(block_argument, message: format(MSG, style: style)) do |corrector|
+            if style == :anonymous
+              corrector.replace(block_argument, '&')
+
+              arguments = block_argument.parent
+
+              add_parentheses(arguments, corrector) unless arguments.parenthesized_call?
+            else
+              unless use_block_argument_as_local_variable?(node, block_forwarding_name)
+                corrector.replace(block_argument, "&#{block_forwarding_name}")
+              end
+            end
+          end
+        end
+
+        def use_block_argument_as_local_variable?(node, last_argument)
+          return if node.body.nil?
+
+          node.body.each_descendant(:lvar).any? do |lvar|
+            !lvar.parent.block_pass_type? && lvar.source == last_argument
+          end
+        end
+
+        def block_forwarding_name
+          cop_config.fetch('BlockForwardingName', 'block')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/naming/method_parameter_name.rb

@@ -26,7 +26,7 @@ module RuboCop
       #     num1 * num2
       #   end
       #
-      #   # With `MinArgNameLength` set to number greater than 1
+      #   # With `MinNameLength` set to number greater than 1
       #   def baz(a, b, c)
       #     do_stuff(a, b, c)
       #   end