rubocop 1.40.0 → 1.41.1

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

@@ -128,6 +128,7 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def each_already_disabled(cop, line_ranges)
           line_ranges.each_cons(2) do |previous_range, range|
             next if ignore_offense?(range)
@@ -152,9 +153,10 @@ module RuboCop
                 cop
               end
 
-            yield comment, redundant
+            yield comment, redundant if redundant
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def find_redundant_cop(cop, range)
           cop_offenses = offenses_to_check.select { |offense| offense.cop_name == cop }

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

@@ -42,7 +42,7 @@ module RuboCop
         MSG = 'Unnecessary enabling of %<cop>s.'
 
         def on_new_investigation
-          return if processed_source.blank?
+          return if processed_source.blank? || !processed_source.raw_source.include?('enable')
 
           offenses = processed_source.comment_config.extra_enabled_comments
           offenses.each { |comment, cop_names| register_offense(comment, cop_names) }

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

@@ -45,13 +45,12 @@ module RuboCop
           bad_method?(node) do |safe_nav, method|
             return if nil_methods.include?(method) || PLUS_MINUS_METHODS.include?(node.method_name)
 
-            method_chain = method_chain(node)
             location =
               Parser::Source::Range.new(node.source_range.source_buffer,
                                         safe_nav.source_range.end_pos,
-                                        method_chain.source_range.end_pos)
+                                        node.source_range.end_pos)
             add_offense(location) do |corrector|
-              autocorrect(corrector, offense_range: location, send_node: method_chain)
+              autocorrect(corrector, offense_range: location, send_node: node)
             end
           end
         end
@@ -63,12 +62,12 @@ module RuboCop
         # @return [String]
         def add_safe_navigation_operator(offense_range:, send_node:)
           source =
-            if (brackets = find_brackets(send_node))
+            if brackets?(send_node)
               format(
                 '%<method_name>s(%<arguments>s)%<method_chain>s',
-                arguments: brackets.arguments.map(&:source).join(', '),
-                method_name: brackets.method_name,
-                method_chain: brackets.source_range.end.join(send_node.source_range.end).source
+                arguments: send_node.arguments.map(&:source).join(', '),
+                method_name: send_node.method_name,
+                method_chain: send_node.source_range.end.join(send_node.source_range.end).source
               )
             else
               offense_range.source
@@ -90,18 +89,8 @@ module RuboCop
           )
         end
 
-        def method_chain(node)
-          chain = node
-          chain = chain.parent if chain.send_type? && chain.parent&.call_type?
-          chain
-        end
-
-        def find_brackets(send_node)
-          return send_node if send_node.method?(:[]) || send_node.method?(:[]=)
-
-          send_node.descendants.detect do |node|
-            node.send_type? && (node.method?(:[]) || node.method?(:[]=))
-          end
+        def brackets?(send_node)
+          send_node.method?(:[]) || send_node.method?(:[]=)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Metrics
-      # Checks if the length a class exceeds some maximum value.
+      # Checks if the length of a class exceeds some maximum value.
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Metrics
-      # Checks if the length a module exceeds some maximum value.
+      # Checks if the length of a module exceeds some maximum value.
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       #

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

@@ -58,8 +58,8 @@ module RuboCop
           end
 
           def normalize_foldable_types(types)
-            types.concat(%i[str dstr]) if types.delete(:heredoc)
-            types.concat(%i[send csend]) if types.delete(:method_call)
+            types.push(:str, :dstr) if types.delete(:heredoc)
+            types.push(:send, :csend) if types.delete(:method_call)
             types
           end
 

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

@@ -28,7 +28,7 @@ module RuboCop
 
         each_bad_alignment(items, base_column) do |current|
           expr = current.source_range
-          if @current_offenses.any? { |o| within?(expr, o.location) }
+          if @current_offenses&.any? { |o| within?(expr, o.location) }
             # If this offense is within a line range that is already being
             # realigned by autocorrect, we report the offense without
             # autocorrecting it. Two rewrites in the same area by the same

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

@@ -7,11 +7,11 @@ module RuboCop
       SIGILS = '@$' # if a variable starts with a sigil it will be removed
 
       def allowed_identifier?(name)
-        allowed_identifiers.include?(name.to_s.delete(SIGILS))
+        !allowed_identifiers.empty? && allowed_identifiers.include?(name.to_s.delete(SIGILS))
       end
 
       def allowed_identifiers
-        cop_config.fetch('AllowedIdentifiers', [])
+        cop_config.fetch('AllowedIdentifiers') { [] }
       end
     end
   end

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

@@ -41,18 +41,25 @@ module RuboCop
       def split_comment(comment)
         # Sort keywords by reverse length so that if a keyword is in a phrase
         # but also on its own, both will match properly.
-        keywords_regex = Regexp.new(
-          Regexp.union(keywords.sort_by { |w| -w.length }).source,
-          Regexp::IGNORECASE
-        )
-        regex = /^(# ?)(\b#{keywords_regex}\b)(\s*:)?(\s+)?(\S+)?/i
-
         match = comment.text.match(regex)
         return false unless match
 
         match.captures
       end
 
+      KEYWORDS_REGEX_CACHE = {} # rubocop:disable Layout/ClassStructure, Style/MutableConstant
+      private_constant :KEYWORDS_REGEX_CACHE
+
+      def regex
+        KEYWORDS_REGEX_CACHE[keywords] ||= begin
+          keywords_regex = Regexp.new(
+            Regexp.union(keywords.sort_by { |w| -w.length }).source,
+            Regexp::IGNORECASE
+          )
+          /^(# ?)(\b#{keywords_regex}\b)(\s*:)?(\s+)?(\S+)?/i
+        end
+      end
+
       def keyword_appearance?
         keyword && (colon || space)
       end

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

@@ -20,19 +20,30 @@ module RuboCop
         style_detected(possibilities)
       end
 
+      SYMBOL_TO_STRING_CACHE = Hash.new do |hash, key|
+        hash[key] = key.to_s if key.is_a?(Symbol)
+      end
+      private_constant :SYMBOL_TO_STRING_CACHE
+
+      # rubocop:disable Metrics
       def style_detected(detected)
         return if no_acceptable_style?
 
-        # `detected` can be a single style or an Array of possible styles
-        # (if there is more than one which matches the observed code)
-        detected_as_strings = Array(detected).map(&:to_s)
+        # This logic is more complex than it needs to be
+        # to avoid allocating Arrays in the hot code path.
+        updated_list =
+          if detected_style
+            if detected_style.size == 1 && detected_style.include?(SYMBOL_TO_STRING_CACHE[detected])
+              detected_style
+            else
+              detected_as_strings = SYMBOL_TO_STRING_CACHE.values_at(*detected)
+              detected_style & detected_as_strings
+            end
+          else
+            # We haven't observed any specific style yet.
+            SYMBOL_TO_STRING_CACHE.values_at(*detected)
+          end
 
-        updated_list = if detected_style
-                         detected_style & detected_as_strings
-                       else
-                         # We haven't observed any specific style yet.
-                         detected_as_strings
-                       end
         if updated_list.empty?
           no_acceptable_style!
         else
@@ -40,6 +51,7 @@ module RuboCop
           config_to_allow_offenses[style_parameter_name] = updated_list.first
         end
       end
+      # rubocop:enable Metrics
 
       def no_acceptable_style?
         config_to_allow_offenses['Enabled'] == false

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

@@ -7,12 +7,12 @@ module RuboCop
     module FirstElementLineBreak
       private
 
-      def check_method_line_break(node, children)
+      def check_method_line_break(node, children, ignore_last: false)
         return if children.empty?
 
         return unless method_uses_parens?(node, children.first)
 
-        check_children_line_break(node, children)
+        check_children_line_break(node, children, ignore_last: ignore_last)
       end
 
       def method_uses_parens?(node, limit)
@@ -20,7 +20,7 @@ module RuboCop
         /\s*\(\s*$/.match?(source)
       end
 
-      def check_children_line_break(node, children, start = node)
+      def check_children_line_break(node, children, start = node, ignore_last: false)
         return if children.empty?
 
         line = start.first_line
@@ -28,8 +28,8 @@ module RuboCop
         min = first_by_line(children)
         return if line != min.first_line
 
-        max = last_by_line(children)
-        return if line == max.last_line
+        max_line = last_line(children, ignore_last: ignore_last)
+        return if line == max_line
 
         add_offense(min) { |corrector| EmptyLineCorrector.insert_before(corrector, min) }
       end
@@ -38,8 +38,12 @@ module RuboCop
         nodes.min_by(&:first_line)
       end
 
-      def last_by_line(nodes)
-        nodes.max_by(&:last_line)
+      def last_line(nodes, ignore_last:)
+        if ignore_last
+          nodes.map(&:first_line)
+        else
+          nodes.map(&:last_line)
+        end.max
       end
     end
   end

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

@@ -45,17 +45,21 @@ module RuboCop
 
       private
 
+      # rubocop:disable Metrics/AbcSize
       def register_offense(node, message, replacement)
         add_offense(node.value, message: message) do |corrector|
           if (def_node = def_node_that_require_parentheses(node))
             white_spaces = range_between(def_node.loc.selector.end_pos,
                                          def_node.first_argument.source_range.begin_pos)
             corrector.replace(white_spaces, '(')
-            corrector.insert_after(def_node.arguments.last, ')')
+
+            last_argument = def_node.arguments.last
+            corrector.insert_after(last_argument, ')') if node == last_argument.pairs.last
           end
           corrector.replace(node, replacement)
         end
       end
+      # rubocop:enable Metrics/AbcSize
 
       def ignore_mixed_hash_shorthand_syntax?(hash_node)
         target_ruby_version <= 3.0 || enforced_shorthand_syntax != 'consistent' ||

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

@@ -57,7 +57,14 @@ module RuboCop
       def indentation_difference(line)
         return 0 unless tab_indentation_width
 
-        (line.index(/[^\t]/) || 0) * (tab_indentation_width - 1)
+        index =
+          if line.match?(/^[^\t]/)
+            0
+          else
+            line.index(/[^\t]/) || 0
+          end
+
+        index * (tab_indentation_width - 1)
       end
 
       def extend_uri_end_position(line, end_position)

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

@@ -59,13 +59,15 @@ module RuboCop
       end
 
       def complexity(body)
-        body.each_node(:lvasgn, *self.class::COUNTED_NODES).reduce(1) do |score, node|
+        score = 1
+        body.each_node(:lvasgn, *self.class::COUNTED_NODES) do |node|
           if node.lvasgn_type?
             reset_on_lvasgn(node)
-            next score
+          else
+            score += complexity_score_for(node)
           end
-          score + complexity_score_for(node)
         end
+        score
       end
     end
   end

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

@@ -10,8 +10,8 @@ module RuboCop
     module MultilineElementLineBreaks
       private
 
-      def check_line_breaks(_node, children)
-        return if all_on_same_line?(children)
+      def check_line_breaks(_node, children, ignore_last: false)
+        return if all_on_same_line?(children, ignore_last: ignore_last)
 
         last_seen_line = -1
         children.each do |child|
@@ -23,9 +23,11 @@ module RuboCop
         end
       end
 
-      def all_on_same_line?(nodes)
+      def all_on_same_line?(nodes, ignore_last: false)
         return true if nodes.empty?
 
+        return same_line?(nodes.first, nodes.last) if ignore_last
+
         nodes.first.first_line == nodes.last.last_line
       end
     end

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

@@ -97,9 +97,7 @@ module RuboCop
       # @return [String]
       def whitespace_between(node)
         if node.children.length >= 2
-          node.source[
-            node.children[0].loc.expression.end_pos...node.children[1].loc.expression.begin_pos
-          ]
+          node.children[0].source_range.end.join(node.children[1].source_range.begin).source
         else
           ' '
         end
@@ -111,7 +109,7 @@ module RuboCop
       # @param [RuboCop::AST::ArrayNode] node
       # @return [String]
       def whitespace_leading(node)
-        node.source[node.loc.begin.end_pos...node.children[0].loc.expression.begin_pos]
+        node.loc.begin.end.join(node.children[0].source_range.begin).source
       end
 
       # Provides trailing whitespace for building a bracketed array.
@@ -120,7 +118,7 @@ module RuboCop
       # @param [RuboCop::AST::ArrayNode] node
       # @return [String]
       def whitespace_trailing(node)
-        node.source[node.children[-1].loc.expression.end_pos...node.loc.end.begin_pos]
+        node.children[-1].source_range.end.join(node.loc.end.begin).source
       end
     end
   end

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

@@ -7,6 +7,8 @@ module RuboCop
     module RequireLibrary
       extend NodePattern::Macros
 
+      RESTRICT_ON_SEND = [:require].freeze
+
       def ensure_required(corrector, node, library_name)
         node = node.parent while node.parent&.parent?
 

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

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     # Common functionality for checking `rescue` nodes.
     module RescueNode
-      def on_new_investigation
-        @modifier_locations = processed_source.tokens.select(&:rescue_modifier?).map(&:pos)
+      def modifier_locations
+        @modifier_locations ||= processed_source.tokens.select(&:rescue_modifier?).map!(&:pos)
       end
 
       private
@@ -13,7 +13,7 @@ module RuboCop
       def rescue_modifier?(node)
         return false unless node.respond_to?(:resbody_type?)
 
-        node.resbody_type? && @modifier_locations.include?(node.loc.keyword)
+        node.resbody_type? && modifier_locations.include?(node.loc.keyword)
       end
 
       # @deprecated Use ResbodyNode#exceptions instead

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

@@ -56,7 +56,7 @@ module RuboCop
 
       def if_body_source(if_body)
         if if_body.call_type? &&
-           if_body.last_argument&.hash_type? && if_body.last_argument.pairs.last.value_omission?
+           if_body.last_argument&.hash_type? && if_body.last_argument.pairs.last&.value_omission?
           "#{method_source(if_body)}(#{if_body.arguments.map(&:source).join(', ')})"
         else
           if_body.source

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

@@ -108,7 +108,7 @@ module RuboCop
           return if node.body.nil?
 
           node.body.each_descendant(:lvar, :lvasgn).any? do |lvar|
-            !lvar.parent.block_pass_type? && lvar.source == last_argument
+            !lvar.parent.block_pass_type? && lvar.node_parts[0].to_s == last_argument
           end
         end
 

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

@@ -30,6 +30,8 @@ module RuboCop
         MSG = 'Use CamelCase for classes and modules.'
 
         def on_class(node)
+          return unless node.loc.name.source.include?('_')
+
           allowed = /#{cop_config['AllowedNames'].join('|')}/
           name = node.loc.name.source.gsub(allowed, '')
           return unless /_/.match?(name)

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

@@ -207,7 +207,10 @@ module RuboCop
         end
 
         def scan_for_words(input)
-          mask_input(input).enum_for(:scan, @flagged_terms_regex).map do
+          masked_input = mask_input(input)
+          return EMPTY_ARRAY unless masked_input.match?(@flagged_terms_regex)
+
+          masked_input.enum_for(:scan, @flagged_terms_regex).map do
             match = Regexp.last_match
             WordLocation.new(match.to_s, match.offset(0).first)
           end

data/lib/rubocop/cop/registry.rb

@@ -28,6 +28,9 @@ module RuboCop
 
         @enrollment_queue = cops
         @options = options
+
+        @enabled_cache = {}.compare_by_identity
+        @disabled_cache = {}.compare_by_identity
       end
 
       def enlist(cop)
@@ -61,7 +64,7 @@ module RuboCop
 
       # @return [Boolean] Checks if given name is department
       def department?(name)
-        departments.include? name.to_sym
+        departments.include?(name.to_sym)
       end
 
       def contains_cop_matching?(names)
@@ -150,11 +153,11 @@ module RuboCop
       end
 
       def enabled(config)
-        select { |cop| enabled?(cop, config) }
+        @enabled_cache[config] ||= select { |cop| enabled?(cop, config) }
       end
 
       def disabled(config)
-        reject { |cop| enabled?(cop, config) }
+        @disabled_cache[config] ||= reject { |cop| enabled?(cop, config) }
       end
 
       def enabled?(cop, config)

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

@@ -7,6 +7,11 @@ module RuboCop
       # depending on configuration.
       # It also flags uses of `alias :symbol` rather than `alias bareword`.
       #
+      # However, it will always enforce `method_alias` when used `alias`
+      # in an instance method definition and in a singleton method definition.
+      # If used in a block, always enforce `alias_method`
+      # unless it is an `instance_eval` block.
+      #
       # @example EnforcedStyle: prefer_alias (default)
       #   # bad
       #   alias_method :bar, :foo
@@ -22,6 +27,7 @@ module RuboCop
       #
       #   # good
       #   alias_method :bar, :foo
+      #
       class Alias < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
@@ -71,7 +77,9 @@ module RuboCop
         end
 
         def alias_method_possible?(node)
-          scope_type(node) != :instance_eval && node.children.none?(&:gvar_type?)
+          scope_type(node) != :instance_eval &&
+            node.children.none?(&:gvar_type?) &&
+            node&.parent&.type != :def
         end
 
         def add_offense_for_args(node, &block)

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of `Array#push(item)` instead of `Array#concat([item])`
+      # to avoid redundant array literals.
+      #
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if the receiver
+      #   is not an `Array` object.
+      #
+      # @example
+      #
+      #   # bad
+      #   list.concat([foo])
+      #   list.concat([bar, baz])
+      #   list.concat([qux, quux], [corge])
+      #
+      #   # good
+      #   list.push(foo)
+      #   list.push(bar, baz)
+      #   list.push(qux, quux, corge)
+      #
+      class ConcatArrayLiterals < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        MSG_FOR_PERCENT_LITERALS =
+          'Use `push` with elements as arguments without array brackets instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[concat].freeze
+
+        def on_send(node)
+          return if node.arguments.empty?
+          return unless node.arguments.all?(&:array_type?)
+
+          offense = offense_range(node)
+          current = offense.source
+
+          if node.arguments.any?(&:percent_literal?)
+            message = format(MSG_FOR_PERCENT_LITERALS, current: current)
+          else
+            prefer = preferred_method(node)
+            message = format(MSG, prefer: prefer, current: current)
+          end
+
+          add_offense(offense, message: message) do |corrector|
+            corrector.replace(offense, prefer)
+          end
+        end
+
+        private
+
+        def offense_range(node)
+          node.loc.selector.join(node.source_range.end)
+        end
+
+        def preferred_method(node)
+          new_arguments = node.arguments.map { |arg| arg.children.map(&:source) }.join(', ')
+
+          "push(#{new_arguments})"
+        end
+      end
+    end
+  end
+end

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

@@ -86,6 +86,11 @@ module RuboCop
           (send nil? {:public_constant :private_constant} ({sym str} _))
         PATTERN
 
+        # @!method include_statement?(node)
+        def_node_matcher :include_statement?, <<~PATTERN
+          (send nil? {:include :extend :prepend} const)
+        PATTERN
+
         def on_class(node)
           return unless node.body
 
@@ -103,7 +108,7 @@ module RuboCop
           return if documentation_comment?(node)
           return if constant_allowed?(node)
           return if nodoc_self_or_outer_module?(node)
-          return if macro_only?(body)
+          return if include_statement_only?(body)
 
           range = range_between(node.loc.expression.begin_pos, node.loc.name.end_pos)
           message = format(MSG, type: node.type, identifier: identifier(node))
@@ -115,9 +120,10 @@ module RuboCop
             (compact_namespace?(node) && nodoc_comment?(outer_module(node).first))
         end
 
-        def macro_only?(body)
-          (body.respond_to?(:macro?) && body.macro?) ||
-            (body.respond_to?(:children) && body.children&.all? { |child| macro_only?(child) })
+        def include_statement_only?(body)
+          return true if include_statement?(body)
+
+          body.respond_to?(:children) && body.children.all? { |node| include_statement_only?(node) }
         end
 
         def namespace?(node)
@@ -176,7 +182,7 @@ module RuboCop
         end
 
         def qualify_const(node)
-          return if node.nil? || node.cbase_type?
+          return if node.nil? || node.cbase_type? || node.self_type? || node.send_type?
 
           [qualify_const(node.namespace), node.short_name].compact
         end

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

@@ -187,9 +187,9 @@ module RuboCop
           if_branch = node.if_branch
           else_branch = node.else_branch
 
-          if if_branch&.send_type? && if_branch.last_argument&.heredoc?
+          if if_branch&.send_type? && heredoc?(if_branch.last_argument)
             autocorrect_heredoc_argument(corrector, node, if_branch, else_branch, guard)
-          elsif else_branch&.send_type? && else_branch.last_argument&.heredoc?
+          elsif else_branch&.send_type? && heredoc?(else_branch.last_argument)
             autocorrect_heredoc_argument(corrector, node, else_branch, if_branch, guard)
           else
             corrector.remove(node.loc.end)
@@ -201,6 +201,10 @@ module RuboCop
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
+        def heredoc?(argument)
+          argument.respond_to?(:heredoc?) && argument.heredoc?
+        end
+
         def autocorrect_heredoc_argument(corrector, node, heredoc_branch, leave_branch, guard)
           remove_whole_lines(corrector, leave_branch.source_range)
           remove_whole_lines(corrector, node.loc.else)