rubocop 1.71.1 → 1.92.0

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

@@ -19,7 +19,7 @@ module RuboCop
 
       # @!method non_public_modifier?(node)
       def_node_matcher :non_public_modifier?, <<~PATTERN
-        (send nil? {:private :protected :private_class_method} ({def defs} ...))
+        (send nil? {:private :protected :private_class_method} (any_def ...))
       PATTERN
     end
   end

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

@@ -5,7 +5,7 @@ module RuboCop
     module Layout
       # Common functionality for checking if presence/absence of empty lines
       # around some kind of body matches the configuration.
-      module EmptyLinesAroundBody
+      module EmptyLinesAroundBody # rubocop:disable Metrics/ModuleLength
         extend NodePattern::Macros
         include ConfigurableEnforcedStyle
         include RangeHelp
@@ -14,6 +14,8 @@ module RuboCop
         MSG_MISSING = 'Empty line missing at %<kind>s body %<location>s.'
         MSG_DEFERRED = 'Empty line missing before first %<type>s definition'
 
+        LEADING_DOT_TYPES = %i[tDOT tANDDOT].to_set.freeze
+
         private
 
         # @!method constant_definition?(node)
@@ -21,7 +23,7 @@ module RuboCop
 
         # @!method empty_line_required?(node)
         def_node_matcher :empty_line_required?,
-                         '{def defs class module (send nil? {:private :protected :public})}'
+                         '{any_def class module (send nil? {:private :protected :public})}'
 
         def check(node, body, adjusted_first_line: nil)
           return if valid_body_style?(body)
@@ -29,6 +31,7 @@ module RuboCop
 
           first_line = adjusted_first_line || node.source_range.first_line
           last_line = node.source_range.last_line
+          return if first_line >= last_line
 
           case style
           when :empty_lines_except_namespace
@@ -99,12 +102,20 @@ module RuboCop
           return unless yield(processed_source.lines[line])
 
           offset = style == :empty_lines && msg.include?('end.') ? 2 : 1
+          return if style == :empty_lines && leading_dot_line?(line + offset)
+
           range = source_range(processed_source.buffer, line + offset, 0)
           add_offense(range, message: msg) do |corrector|
             EmptyLineCorrector.correct(corrector, [style, range])
           end
         end
 
+        def leading_dot_line?(line)
+          first_token = processed_source.sorted_tokens.find { |token| token.line == line }
+
+          LEADING_DOT_TYPES.include?(first_token&.type)
+        end
+
         def check_deferred_empty_line(body)
           node = first_empty_line_required_child(body)
           return unless node

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

@@ -19,8 +19,7 @@ module RuboCop
       def check_end_kw_alignment(node, align_ranges)
         return if ignored_node?(node)
 
-        end_loc = node.loc.end
-        return if accept_end_kw_alignment?(end_loc)
+        return unless (end_loc = node.loc.end)
 
         matching = matching_ranges(end_loc, align_ranges)
 
@@ -57,11 +56,6 @@ module RuboCop
         add_offense(end_loc, message: msg) { |corrector| autocorrect(corrector, node) }
       end
 
-      def accept_end_kw_alignment?(end_loc)
-        end_loc.nil? || # Discard modifier forms of if/while/until.
-          !/\A[ \t]*end/.match?(processed_source.lines[end_loc.line - 1])
-      end
-
       def style_parameter_name
         'EnforcedStyleAlignWith'
       end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking whether a method body can become the
+    # body of an endless method definition without changing its meaning.
+    module EndlessMethodBodyHelp
+      private
+
+      def endless_method_body?(body)
+        return false if body.type?(:begin, :kwbegin, :rescue, :ensure, :masgn)
+        return false if low_precedence_body?(body)
+        return false if ends_with_omitted_hash_value?(body) || ends_with_anonymous_argument?(body)
+        return false if body.assignment? && multiple_values?(assigned_value(body))
+
+        !command_disallowed_in_endless_body?(body)
+      end
+
+      # `def foo = bar and baz` parses as `(def foo = bar) and baz`.
+      def low_precedence_body?(body)
+        body.type?(:any_match_pattern, :while_post, :until_post) ||
+          (body.type?(:and, :or) && body.semantic_operator?) ||
+          (body.type?(:if, :while, :until) && body.modifier_form?)
+      end
+
+      # `foo = 1, 2` and `foo = *bar` assign an array without brackets.
+      def multiple_values?(node)
+        node.array_type? && !node.bracketed?
+      end
+
+      def ends_with_omitted_hash_value?(body)
+        body.each_descendant(:pair).any? do |pair|
+          pair.value_omission? && pair.source_range.end_pos == body.source_range.end_pos
+        end
+      end
+
+      def ends_with_anonymous_argument?(body)
+        forwarding = %i[forwarded_restarg forwarded_kwrestarg block_pass]
+
+        body.each_descendant(*forwarding).any? do |argument|
+          argument.source_range.end_pos == body.source_range.end_pos &&
+            (!argument.block_pass_type? || argument.children.first.nil?)
+        end
+      end
+
+      def command_disallowed_in_endless_body?(body)
+        return true if body.assignment? && command_call?(assigned_value(body))
+
+        body.each_node(:any_block).any? do |block|
+          block.keywords? && command_call?(block.send_node)
+        end
+      end
+
+      def assigned_value(node)
+        while node.assignment? || node.rescue_type?
+          node = node.rescue_type? ? node.body : node.children.last
+        end
+        node
+      end
+
+      def command_call?(node)
+        node = node.send_node if node.any_block_type?
+        return false unless node.type?(:call, :super, :yield)
+
+        node.arguments? && !node.parenthesized? && !node.operator_method? && !node.setter_method?
+      end
+    end
+  end
+end

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

@@ -5,20 +5,28 @@ module RuboCop
     # Common functionality for rewriting endless methods to normal method definitions
     module EndlessMethodRewriter
       def correct_to_multiline(corrector, node)
-        replacement = <<~RUBY.strip
-          def #{node.method_name}#{arguments(node)}
-            #{node.body.source}
-          end
-        RUBY
+        replacement = [
+          "def #{receiver(node)}#{node.method_name}#{arguments(node)}",
+          "#{indent(node, offset: configured_indentation_width)}#{node.body.source}",
+          "#{indent(node)}end"
+        ].join("\n")
 
         corrector.replace(node, replacement)
       end
 
       private
 
+      def receiver(node)
+        node.receiver ? "#{node.receiver.source}#{node.loc.operator.source}" : ''
+      end
+
       def arguments(node, missing = '')
         node.arguments.any? ? node.arguments.source : missing
       end
+
+      def configured_indentation_width
+        cop_config['IndentationWidth'] || config.for_cop('Layout/IndentationWidth')['Width'] || 2
+      end
     end
   end
 end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to forbid certain identifiers in a cop.
+    module ForbiddenIdentifiers
+      SIGILS = '@$' # if a variable starts with a sigil it will be removed
+
+      def forbidden_identifier?(name)
+        return false if forbidden_identifiers.empty?
+
+        forbidden_identifiers.include?(name.to_s.delete(SIGILS))
+      end
+
+      def forbidden_identifiers
+        cop_config.fetch('ForbiddenIdentifiers', [])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to forbid certain patterns in a cop.
+    module ForbiddenPattern
+      def forbidden_pattern?(name)
+        forbidden_pattern_regexps.any? { |pattern| pattern.match?(name) }
+      end
+
+      def forbidden_patterns
+        cop_config.fetch('ForbiddenPatterns', [])
+      end
+
+      def forbidden_pattern_regexps
+        @forbidden_pattern_regexps ||= forbidden_patterns.map { |pattern| Regexp.new(pattern) }
+      end
+    end
+  end
+end

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

@@ -6,7 +6,6 @@ module RuboCop
     module FrozenStringLiteral
       module_function
 
-      FROZEN_STRING_LITERAL_REGEXP = /#\s*frozen[-_]?string[-_]?literal:/i.freeze
       FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'
       FROZEN_STRING_LITERAL_TYPES_RUBY27 = %i[str dstr].freeze
 
@@ -90,7 +89,7 @@ module RuboCop
 
         if first_non_comment_token
           # `line` is 1-indexed so we need to subtract 1 to get the array index
-          processed_source.lines[0...first_non_comment_token.line - 1]
+          processed_source.lines[0...(first_non_comment_token.line - 1)]
         else
           processed_source.lines
         end

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

@@ -25,6 +25,28 @@ module RuboCop
           (args
             (arg $_)) ...)
       PATTERN
+
+      # @!method assignment_method_declarations(node)
+      def_node_search :assignment_method_declarations, <<~PATTERN
+        (send
+          (lvar {#match_block_variable_name? :_1 :it}) _ ...)
+      PATTERN
+
+      # @!method indexed_assignment_method_declarations(node)
+      def_node_search :indexed_assignment_method_declarations, <<~PATTERN
+        (send
+          (send (lvar {#match_block_variable_name? :_1 :it}) _)
+          :[]=
+          literal?
+          _
+        )
+      PATTERN
+
+      def match_block_variable_name?(receiver_name)
+        gem_specification(processed_source.ast) do |block_variable_name|
+          return block_variable_name == receiver_name
+        end
+      end
     end
   end
 end

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

@@ -10,7 +10,7 @@ module RuboCop
           true
         end
 
-        def deltas_for_first_pair(first_pair, _node)
+        def deltas_for_first_pair(first_pair)
           {
             separator: separator_delta(first_pair),
             value: value_delta(first_pair)
@@ -55,7 +55,7 @@ module RuboCop
       # Common functionality for checking alignment of hash values.
       module ValueAlignment
         def checkable_layout?(node)
-          !node.pairs_on_same_line? && !node.mixed_delimiters?
+          !node.pairs_on_same_line? && !node.mixed_delimiters? && alignable_values?(node)
         end
 
         def deltas(first_pair, current_pair)
@@ -68,6 +68,16 @@ module RuboCop
 
         private
 
+        def alignable_values?(node)
+          return false if node.pairs.first.value_omission?
+
+          node.pairs.none? { |pair| value_on_later_line?(pair) }
+        end
+
+        def value_on_later_line?(pair)
+          pair.value && pair.key.last_line != pair.value.first_line
+        end
+
         def separator_delta(first_pair, current_pair, key_delta)
           if current_pair.hash_rocket?
             hash_rocket_delta(first_pair, current_pair) - key_delta
@@ -81,13 +91,7 @@ module RuboCop
       class TableAlignment
         include ValueAlignment
 
-        def initialize
-          self.max_key_width = 0
-        end
-
-        def deltas_for_first_pair(first_pair, node)
-          self.max_key_width = node.keys.map { |key| key.source.length }.max
-
+        def deltas_for_first_pair(first_pair)
           separator_delta = separator_delta(first_pair, first_pair, 0)
           {
             separator: separator_delta,
@@ -97,33 +101,68 @@ module RuboCop
 
         private
 
-        attr_accessor :max_key_width
-
         def key_delta(first_pair, current_pair)
           first_pair.key_delta(current_pair)
         end
 
         def hash_rocket_delta(first_pair, current_pair)
-          first_pair.loc.column + max_key_width + 1 - current_pair.loc.operator.column
+          target_operator_column(first_pair) - current_pair.loc.operator.column
         end
 
         def value_delta(first_pair, current_pair)
-          correct_value_column = first_pair.key.loc.column +
-                                 current_pair.delimiter(true).length +
-                                 max_key_width
+          correct_value_column = target_operator_column(first_pair) +
+                                 max_delimiter_width(first_pair.parent) - 1
 
           current_pair.value_omission? ? 0 : correct_value_column - current_pair.value.loc.column
         end
+
+        # The column the separator should land on: the shared key margin
+        # plus the widest single-line key, or, if larger, a multiline key's
+        # own last-line end column. The latter can't be measured from a
+        # multiline key's (newline-including) source length, so it's a
+        # separate candidate rather than folded into `max_key_width`.
+        def target_operator_column(first_pair)
+          hash_node = first_pair.parent
+          candidates = multiline_key_end_columns(hash_node)
+
+          key_width = max_key_width(hash_node)
+          candidates << (first_pair.loc.column + key_width + 1) if key_width.positive?
+
+          candidates.max
+        end
+
+        def multiline_key_end_columns(hash_node)
+          hash_node.keys.reject(&:single_line?).map { |key| key.source_range.end.column + 1 }
+        end
+
+        def max_key_width(hash_node)
+          hash_node.keys.select(&:single_line?).map { |key| key.source.length }.max || 0
+        end
+
+        def max_delimiter_width(hash_node)
+          hash_node.pairs.map { |pair| pair.delimiter(true).length }.max
+        end
       end
 
       # Handles calculation of deltas when the enforced style is 'separator'.
       class SeparatorAlignment
         include ValueAlignment
 
-        def deltas_for_first_pair(*_nodes)
+        def deltas_for_first_pair(_first_pair)
           {}
         end
 
+        # Keys are right-aligned by the column their last line ends on.
+        # A key spanning several lines ends on a line other than the one it starts on,
+        # so moving its first line would never change that column and the correction
+        # would be repeated on every pass. Such pairs are left alone, and so is every pair
+        # when the first key spans several lines, since there is then no column to right-align to.
+        def deltas(first_pair, current_pair)
+          return {} if first_pair.key.multiline? || current_pair.key.multiline?
+
+          super
+        end
+
         private
 
         def key_delta(first_pair, current_pair)
@@ -135,7 +174,10 @@ module RuboCop
         end
 
         def value_delta(first_pair, current_pair)
-          current_pair.value_omission? ? 0 : first_pair.value_delta(current_pair)
+          return 0 if first_pair.equal?(current_pair) || current_pair.value_omission?
+
+          expected_value_column = first_pair.loc.operator.end.column + 1
+          expected_value_column - current_pair.value.loc.column
         end
       end
 

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

@@ -11,6 +11,33 @@ module RuboCop
       DO_NOT_MIX_OMIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{OMIT_HASH_VALUE_MSG}"
       DO_NOT_MIX_EXPLICIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{EXPLICIT_HASH_VALUE_MSG}"
 
+      # A keyword parameter can be named after a keyword, as in `def foo(if:)`,
+      # but the parameter can only be referenced by an omitted hash value,
+      # so `{ if: }` has no explicit form: `{ if: if }` is invalid Ruby.
+      KEYWORDS = %i[
+        __ENCODING__ __FILE__ __LINE__ BEGIN END alias and begin break case class def do
+        else elsif end ensure false for if in module next nil not or redo rescue retry
+        return self super then true undef unless until when while yield
+      ].to_set.freeze
+
+      DefNode = Struct.new(:node) do
+        def selector
+          if node.loc?(:selector)
+            node.loc.selector
+          else
+            node.loc.keyword
+          end
+        end
+
+        def first_argument
+          node.first_argument
+        end
+
+        def last_argument
+          node.last_argument
+        end
+      end
+
       def on_hash_for_mixed_shorthand(hash_node)
         return if ignore_mixed_hash_shorthand_syntax?(hash_node)
 
@@ -35,7 +62,7 @@ module RuboCop
           replacement = "#{hash_key_source}:"
           self.config_to_allow_offenses = { 'Enabled' => false }
         else
-          return unless node.value_omission?
+          return if !node.value_omission? || keyword_value?(node)
 
           message = EXPLICIT_HASH_VALUE_MSG
           replacement = "#{hash_key_source}: #{hash_key_source}"
@@ -69,13 +96,26 @@ module RuboCop
       def ignore_mixed_hash_shorthand_syntax?(hash_node)
         target_ruby_version <= 3.0 ||
           !%w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
-          !hash_node.hash_type?
+          !hash_node.hash_type? || hash_rockets_enforced?(hash_node)
       end
 
       def ignore_hash_shorthand_syntax?(pair_node)
         target_ruby_version <= 3.0 || enforced_shorthand_syntax == 'either' ||
           %w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
-          !pair_node.parent.hash_type?
+          !pair_node.parent.hash_type? || hash_rockets_enforced?(pair_node.parent)
+      end
+
+      def hash_rockets_enforced?(hash_node)
+        style == :hash_rockets || force_hash_rockets?(hash_node.pairs) ||
+          no_mixed_keys_enforces_hash_rockets?(hash_node.pairs)
+      end
+
+      def no_mixed_keys_enforces_hash_rockets?(pairs)
+        case style
+        when :no_mixed_keys then !sym_indices?(pairs) || pairs.first.delimiter == '=>'
+        when :ruby19_no_mixed_keys then !sym_indices?(pairs)
+        else false
+        end
       end
 
       def enforced_shorthand_syntax
@@ -99,7 +139,7 @@ module RuboCop
           use_modifier_form_without_parenthesized_method_call?(method_dispatch_node)
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def def_node_that_require_parentheses(node)
         last_pair = node.parent.pairs.last
         return unless last_pair.key.source == last_pair.value.source
@@ -107,13 +147,12 @@ module RuboCop
         return if dispatch_node.assignment_method?
         return if dispatch_node.parenthesized?
         return if dispatch_node.parent && parentheses?(dispatch_node.parent)
-        return if last_expression?(dispatch_node) && !method_dispatch_as_argument?(dispatch_node)
+        return if last_expression?(dispatch_node) && !requires_parentheses_context?(dispatch_node)
 
         def_node = node.each_ancestor(:call, :super, :yield).first
 
         DefNode.new(def_node) unless def_node && def_node.arguments.empty?
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       def find_ancestor_method_dispatch_node(node)
         return unless (ancestor = node.parent.parent)
@@ -146,11 +185,11 @@ module RuboCop
         !assignment_node.right_sibling
       end
 
-      def method_dispatch_as_argument?(method_dispatch_node)
-        parent = method_dispatch_node.parent
+      def requires_parentheses_context?(node)
+        parent = node.parent
         return false unless parent
 
-        parent.type?(:call, :super, :yield)
+        parent.type?(:call, :if, :super, :until, :while, :yield)
       end
 
       def breakdown_value_types_of_hash(hash_node)
@@ -189,6 +228,8 @@ module RuboCop
       def mixed_shorthand_syntax_check(hash_value_type_breakdown)
         if hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
           each_omitted_value_pair(hash_value_type_breakdown) do |pair_node|
+            next if keyword_value?(pair_node)
+
             hash_key_source = pair_node.key.source
             replacement = "#{hash_key_source}: #{hash_key_source}"
             register_offense(pair_node, DO_NOT_MIX_EXPLICIT_VALUE_MSG, replacement)
@@ -213,22 +254,8 @@ module RuboCop
         end
       end
 
-      DefNode = Struct.new(:node) do
-        def selector
-          if node.loc.respond_to?(:selector)
-            node.loc.selector
-          else
-            node.loc.keyword
-          end
-        end
-
-        def first_argument
-          node.first_argument
-        end
-
-        def last_argument
-          node.last_argument
-        end
+      def keyword_value?(pair_node)
+        KEYWORDS.include?(pair_node.key.value)
       end
     end
   end

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

@@ -5,7 +5,7 @@ module RuboCop
     # Common functionality for Style/HashExcept and Style/HashSlice cops.
     # It registers an offense on methods with blocks that are equivalent
     # to Hash#except or Hash#slice.
-    # rubocop:disable Metrics/ModuleLength
+    # rubocop:disable-next Metrics/ModuleLength
     module HashSubset
       include RangeHelp
       extend NodePattern::Macros
@@ -23,7 +23,7 @@ module RuboCop
           (call _ _)
           (args
             $(arg _key)
-            (arg _))
+            $(arg _))
           {
             $(send
               {(lvar _key) $_ _ | _ $_ (lvar _key)})
@@ -67,7 +67,7 @@ module RuboCop
       end
 
       def extracts_hash_subset?(block)
-        block_with_first_arg_check?(block) do |key_arg, send_node, method|
+        block_with_first_arg_check?(block) do |key_arg, value_arg, send_node, method|
           # Only consider methods that have one argument
           return false unless send_node.arguments.one?
 
@@ -76,15 +76,22 @@ module RuboCop
 
           case method
           when :include?, :exclude?
-            send_node.first_argument.source == key_arg.source
+            slices_key?(send_node, :first_argument, key_arg, value_arg)
           when :in?
-            send_node.receiver.source == key_arg.source
+            slices_key?(send_node, :receiver, key_arg, value_arg)
           else
             true
           end
         end
       end
 
+      def slices_key?(send_node, method, key_arg, value_arg)
+        return false if using_value_variable?(send_node, value_arg)
+
+        node = method == :receiver ? send_node.receiver : send_node.first_argument
+        node.source == key_arg.source
+      end
+
       def range_include?(send_node)
         # When checking `include?`, `exclude?` and `in?` for offenses, if the receiver
         # or first argument is a range, an offense should not be registered.
@@ -97,6 +104,14 @@ module RuboCop
         receiver.range_type?
       end
 
+      def using_value_variable?(send_node, value_arg)
+        # If the receiver of `include?` or `exclude?`, or the first argument of `in?` is the
+        # hash value block argument, an offense should not be registered.
+        # ie. `v.include?(k)` or `k.in?(v)`
+        (send_node.receiver.lvar_type? && send_node.receiver.name == value_arg.name) ||
+          (send_node.first_argument.lvar_type? && send_node.first_argument.name == value_arg.name)
+      end
+
       def supported_subset_method?(method)
         if active_support_extensions_enabled?
           ACTIVE_SUPPORT_SUBSET_METHODS.include?(method)
@@ -167,10 +182,18 @@ module RuboCop
         return ":\"#{value.source}\"" if value.dsym_type?
         return "\"#{value.source}\"" if value.dstr_type?
         return ":#{value.source}" if value.sym_type?
+        # The element of a `%w` array can contain characters that are special
+        # inside a single-quoted string (e.g. a `'`), so escape them rather than
+        # wrapping the raw source.
+        return to_single_quoted(value.value) if value.str_type?
 
         "'#{value.source}'"
       end
 
+      def to_single_quoted(string)
+        "'#{string.gsub(/['\\]/) { |character| "\\#{character}" }}'"
+      end
+
       def except_key(node)
         key_arg = node.argument_list.first.source
         body, = extract_body_if_negated(node.body)
@@ -183,6 +206,5 @@ module RuboCop
         range_between(node.loc.selector.begin_pos, node.parent.loc.end.end_pos)
       end
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end