rubocop 1.50.2 → 1.62.1

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to allow certain receivers in a cop.
+    module AllowedReceivers
+      def allowed_receiver?(receiver)
+        receiver_name = receiver_name(receiver)
+
+        allowed_receivers.include?(receiver_name)
+      end
+
+      def receiver_name(receiver)
+        if receiver.receiver && !receiver.receiver.const_type?
+          return receiver_name(receiver.receiver)
+        end
+
+        if receiver.send_type?
+          if receiver.receiver
+            "#{receiver_name(receiver.receiver)}.#{receiver.method_name}"
+          else
+            receiver.method_name.to_s
+          end
+        else
+          receiver.source
+        end
+      end
+
+      def allowed_receivers
+        cop_config.fetch('AllowedReceivers', [])
+      end
+    end
+  end
+end

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

@@ -218,7 +218,7 @@ module RuboCop
 
       # @api private
       def already_on_multiple_lines?(node)
-        return node.first_line != node.arguments.last.last_line if node.def_type?
+        return node.first_line != node.last_argument.last_line if node.def_type?
 
         !node.single_line?
       end

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

@@ -25,7 +25,7 @@ module RuboCop
       def comments_contain_disables?(node, cop_name)
         disabled_ranges = processed_source.disabled_line_ranges[cop_name]
 
-        return unless disabled_ranges
+        return false unless disabled_ranges
 
         node_range = node.source_range.line...find_end_line(node)
 
@@ -62,21 +62,29 @@ module RuboCop
       # Returns the end line of a node, which might be a comment and not part of the AST
       # End line is considered either the line at which another node starts, or
       # the line at which the parent node ends.
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def find_end_line(node)
-        if node.if_type? && node.else?
-          node.loc.else.line
-        elsif node.if_type? && node.ternary?
-          node.else_branch.loc.line
+        if node.if_type?
+          if node.else?
+            node.loc.else.line
+          elsif node.ternary?
+            node.else_branch.loc.line
+          elsif node.elsif?
+            node.each_ancestor(:if).find(&:if?).loc.end.line
+          end
+        elsif node.block_type? || node.numblock_type?
+          node.loc.end.line
         elsif (next_sibling = node.right_sibling) && next_sibling.is_a?(AST::Node)
           next_sibling.loc.line
         elsif (parent = node.parent)
-          parent.loc.respond_to?(:end) && parent.loc.end ? parent.loc.end.line : parent.loc.line
-        else
-          node.loc.end.line
-        end
+          if parent.loc.respond_to?(:end) && parent.loc.end
+            parent.loc.end.line
+          else
+            parent.loc.line
+          end
+        end || node.loc.end.line
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     end
   end
 end

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

@@ -18,6 +18,7 @@ module RuboCop
         alternative_styles.each do |alternative|
           return unexpected_style_detected(alternative) if valid_name?(node, name, alternative)
         end
+        unrecognized_style_detected
       end
 
       def valid_name?(node, name, given_style = style)

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} ({def defs} ...))
+        (send nil? {:private :protected :private_class_method} ({def defs} ...))
       PATTERN
     end
   end

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

@@ -67,7 +67,7 @@ module RuboCop
       end
 
       def variable_alignment?(whole_expression, rhs, end_alignment_style)
-        return if end_alignment_style == :keyword
+        return false if end_alignment_style == :keyword
 
         !line_break_before_keyword?(whole_expression, rhs)
       end

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

@@ -48,18 +48,21 @@ module RuboCop
 
       def register_offense(node, message, replacement) # rubocop:disable Metrics/AbcSize
         add_offense(node.value, message: message) do |corrector|
-          if (def_node = def_node_that_require_parentheses(node))
-            last_argument = def_node.last_argument
-            if last_argument.nil? || !last_argument.hash_type?
-              next corrector.replace(node, replacement)
-            end
-
-            white_spaces = range_between(def_node.selector.end_pos,
-                                         def_node.first_argument.source_range.begin_pos)
-            corrector.replace(white_spaces, '(')
-            corrector.insert_after(last_argument, ')') if node == last_argument.pairs.last
-          end
           corrector.replace(node, replacement)
+
+          next unless (def_node = def_node_that_require_parentheses(node))
+
+          last_argument = def_node.last_argument
+          if last_argument.nil? || !last_argument.hash_type?
+            next corrector.replace(node, replacement)
+          end
+
+          white_spaces = range_between(def_node.selector.end_pos,
+                                       def_node.first_argument.source_range.begin_pos)
+          next if node.parent.braces?
+
+          corrector.replace(white_spaces, '(')
+          corrector.insert_after(last_argument, ')') if node == last_argument.pairs.last
         end
       end
 

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

@@ -26,11 +26,15 @@ module RuboCop
       end
 
       def delimiter_string(node)
-        node.source.match(OPENING_DELIMITER).captures[1]
+        return '' unless (match = node.source.match(OPENING_DELIMITER))
+
+        match.captures[1]
       end
 
       def heredoc_type(node)
-        node.source.match(OPENING_DELIMITER).captures[0]
+        return '' unless (match = node.source.match(OPENING_DELIMITER))
+
+        match.captures[0]
       end
     end
   end

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

@@ -20,16 +20,17 @@ module RuboCop
         range = offending_range(node, lhs, rhs, style)
         check(range, node, lhs, rhs)
       end
+      alias on_csend on_send
 
       private
 
-      # In a chain of method calls, we regard the top send node as the base
+      # In a chain of method calls, we regard the top call node as the base
       # for indentation of all lines following the first. For example:
       # a.
       #   b c { block }.            <-- b is indented relative to a
       #   d                         <-- d is indented relative to a
       def left_hand_side(lhs)
-        while lhs.parent&.send_type? && lhs.parent.loc.dot && !lhs.parent.assignment_method?
+        while lhs.parent&.call_type? && lhs.parent.loc.dot && !lhs.parent.assignment_method?
           lhs = lhs.parent
         end
         lhs
@@ -188,7 +189,7 @@ module RuboCop
         case node.type
         when :casgn   then _scope, _lhs, rhs = *node
         when :op_asgn then _lhs, _op, rhs = *node
-        when :send    then rhs = node.last_argument
+        when :send, :csend then rhs = node.last_argument
         else               _lhs, rhs = *node
         end
         rhs

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

@@ -9,7 +9,7 @@ module RuboCop
       private
 
       def percent_literal?(node)
-        return unless (begin_source = begin_source(node))
+        return false unless (begin_source = begin_source(node))
 
         begin_source.start_with?('%')
       end

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

@@ -75,21 +75,19 @@ module RuboCop
       end
 
       def aligned_token?(range, line)
-        aligned_words?(range, line) ||
-          aligned_char?(range, line) ||
-          aligned_assignment?(range, line)
+        aligned_words?(range, line) || aligned_assignment?(range, line)
       end
 
       def aligned_operator?(range, line)
-        (aligned_identical?(range, line) || aligned_assignment?(range, line))
+        aligned_identical?(range, line) || aligned_assignment?(range, line)
       end
 
       def aligned_words?(range, line)
-        /\s\S/.match?(line[range.column - 1, 2])
-      end
+        left_edge = range.column
+        return true if /\s\S/.match?(line[left_edge - 1, 2])
 
-      def aligned_char?(range, line)
-        line[range.column] == range.source[0]
+        token = range.source
+        token == line[left_edge, token.length]
       end
 
       def aligned_assignment?(range, line)

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

@@ -36,7 +36,7 @@ module RuboCop
       end
 
       def allowed_type?(token)
-        %i[tRPAREN tRBRACK tPIPE].include?(token.type)
+        %i[tRPAREN tRBRACK tPIPE tSTRING_DEND].include?(token.type)
       end
 
       def space_forbidden_before_rcurly?

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

@@ -36,7 +36,7 @@ module RuboCop
       end
 
       def space_required_after?(token)
-        token.left_curly_brace? && space_required_after_lcurly?
+        (token.left_curly_brace? || token.type == :tLAMBEG) && space_required_after_lcurly?
       end
 
       def space_required_after_lcurly?

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

@@ -30,8 +30,10 @@ module RuboCop
       private
 
       def inside_interpolation?(node)
-        # A :begin node inside a :dstr node is an interpolation.
-        node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
+        # A :begin node inside a :dstr, :dsym, or :regexp node is an interpolation.
+        node.ancestors
+            .drop_while { |a| !a.begin_type? }
+            .any? { |a| a.dstr_type? || a.dsym_type? || a.regexp_type? }
       end
     end
   end

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

@@ -106,7 +106,7 @@ module RuboCop
       end
 
       def elements(node)
-        return node.children unless %i[csend send].include?(node.type)
+        return node.children unless node.call_type?
 
         node.arguments.flat_map do |argument|
           # For each argument, if it is a multi-line hash without braces,

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

@@ -48,24 +48,32 @@ module RuboCop
         MSG = 'Use %<style>s block forwarding.'
 
         def self.autocorrect_incompatible_with
-          [Lint::AmbiguousOperator]
+          [Lint::AmbiguousOperator, Style::ArgumentsForwarding]
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_def(node)
           return if node.arguments.empty?
 
-          last_argument = node.arguments.last
+          last_argument = node.last_argument
           return if expected_block_forwarding_style?(node, last_argument)
 
-          register_offense(last_argument, node)
-
+          invalid_syntax = false
           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
 
+            if block_pass_node.each_ancestor(:block, :numblock).any?
+              invalid_syntax = true
+              next
+            end
+
             register_offense(block_pass_node, node)
           end
+
+          register_offense(last_argument, node) unless invalid_syntax
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
         alias on_defs on_def
 
         private
@@ -109,7 +117,7 @@ module RuboCop
         end
 
         def use_block_argument_as_local_variable?(node, last_argument)
-          return if node.body.nil?
+          return false if node.body.nil?
 
           node.body.each_descendant(:lvar, :lvasgn).any? do |lvar|
             !lvar.parent.block_pass_type? && lvar.node_parts[0].to_s == last_argument

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

@@ -61,8 +61,7 @@ module RuboCop
         end
 
         def allowed_method_call_on_rhs?(node)
-          node&.send_type? &&
-            (node.receiver.nil? || !literal_receiver?(node))
+          node&.send_type? && (node.receiver.nil? || !literal_receiver?(node))
         end
 
         # @!method literal_receiver?(node)
@@ -76,7 +75,7 @@ module RuboCop
         end
 
         def contains_constant?(node)
-          node.branches.any?(&:const_type?)
+          node.branches.compact.any?(&:const_type?)
         end
       end
     end

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

@@ -136,7 +136,7 @@ module RuboCop
         end
 
         def filename_good?(basename)
-          basename = basename.sub(/^\./, '')
+          basename = basename.delete_prefix('.')
           basename = basename.sub(/\.[^.]+$/, '')
           # special handling for Action Pack Variants file names like
           # some_file.xlsx+mobile.axlsx

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

@@ -31,7 +31,9 @@ module RuboCop
         def on_heredoc(node)
           return if meaningful_delimiters?(node)
 
-          add_offense(node.loc.heredoc_end)
+          range = node.children.empty? ? node : node.loc.heredoc_end
+
+          add_offense(range)
         end
 
         private

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

@@ -17,7 +17,8 @@ module RuboCop
       # @safety
       #   This cop relies on the pattern `@instance_var ||= ...`,
       #   but this is sometimes used for other purposes than memoization
-      #   so this cop is considered unsafe.
+      #   so this cop is considered unsafe. Also, its autocorrection is unsafe
+      #   because it may conflict with instance variable names already in use.
       #
       # @example EnforcedStyleForLeadingUnderscores: disallowed (default)
       #   # bad
@@ -145,6 +146,8 @@ module RuboCop
       #     @_foo ||= calculate_expensive_thing
       #   end
       class MemoizedInstanceVariableName < Base
+        extend AutoCorrector
+
         include ConfigurableEnforcedStyle
 
         MSG = 'Memoized variable `%<var>s` does not match ' \
@@ -163,6 +166,7 @@ module RuboCop
         PATTERN
 
         # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
         def on_or_asgn(node)
           lhs, _value = *node
           return unless lhs.ivasgn_type?
@@ -175,14 +179,18 @@ module RuboCop
 
           return if matches?(method_name, lhs)
 
+          suggested_var = suggested_var(method_name)
           msg = format(
             message(lhs.children.first.to_s),
             var: lhs.children.first.to_s,
-            suggested_var: suggested_var(method_name),
+            suggested_var: suggested_var,
             method: method_name
           )
-          add_offense(lhs, message: msg)
+          add_offense(lhs, message: msg) do |corrector|
+            corrector.replace(lhs.loc.name, "@#{suggested_var}")
+          end
         end
+        # rubocop:enable Metrics/MethodLength
         # rubocop:enable Metrics/AbcSize
 
         # @!method defined_memoized?(node, ivar)
@@ -195,25 +203,32 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def on_defined?(node)
-          arg = node.arguments.first
-          return unless arg.ivar_type?
+          arg = node.first_argument
+          return false unless arg.ivar_type?
 
           method_node, method_name = find_definition(node)
-          return unless method_node
+          return false unless method_node
 
           var_name = arg.children.first
           defined_memoized?(method_node.body, var_name) do |defined_ivar, return_ivar, ivar_assign|
-            return if matches?(method_name, ivar_assign)
+            return false if matches?(method_name, ivar_assign)
 
+            suggested_var = suggested_var(method_name)
             msg = format(
               message(var_name.to_s),
               var: var_name.to_s,
-              suggested_var: suggested_var(method_name),
+              suggested_var: suggested_var,
               method: method_name
             )
-            add_offense(defined_ivar, message: msg)
-            add_offense(return_ivar, message: msg)
-            add_offense(ivar_assign.loc.name, message: msg)
+            add_offense(defined_ivar, message: msg) do |corrector|
+              corrector.replace(defined_ivar, "@#{suggested_var}")
+            end
+            add_offense(return_ivar, message: msg) do |corrector|
+              corrector.replace(return_ivar, "@#{suggested_var}")
+            end
+            add_offense(ivar_assign.loc.name, message: msg) do |corrector|
+              corrector.replace(ivar_assign.loc.name, "@#{suggested_var}")
+            end
           end
         end
         # rubocop:enable Metrics/AbcSize, Metrics/MethodLength

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

@@ -99,7 +99,7 @@ module RuboCop
           !(method_name.start_with?(prefix) && # cheap check to avoid allocating Regexp
               method_name.match?(/^#{prefix}[^0-9]/)) ||
             method_name == expected_name(method_name, prefix) ||
-            method_name.end_with?('=') || # rubocop:todo InternalAffairs/MethodNameEndWith
+            method_name.end_with?('=') ||
             allowed_method?(method_name)
         end
 
@@ -109,7 +109,7 @@ module RuboCop
                      else
                        method_name.dup
                      end
-          new_name << '?' unless method_name.end_with?('?') # rubocop:todo InternalAffairs/MethodNameEndWith
+          new_name << '?' unless method_name.end_with?('?')
           new_name
         end
 

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

@@ -82,9 +82,7 @@ module RuboCop
           message = message(node)
 
           add_offense(range, message: message) do |corrector|
-            corrector.replace(range, preferred_name)
-
-            correct_node(corrector, node.body, offending_name, preferred_name)
+            autocorrect(corrector, node, range, offending_name, preferred_name)
           end
         end
 
@@ -95,6 +93,16 @@ module RuboCop
           variable.source_range
         end
 
+        def autocorrect(corrector, node, range, offending_name, preferred_name)
+          corrector.replace(range, preferred_name)
+          correct_node(corrector, node.body, offending_name, preferred_name)
+          return unless (kwbegin_node = node.parent.each_ancestor(:kwbegin).first)
+
+          kwbegin_node.right_siblings.each do |child_node|
+            correct_node(corrector, child_node, offending_name, preferred_name)
+          end
+        end
+
         def variable_name_matches?(node, name)
           if node.masgn_type?
             node.each_descendant(:lvasgn).any? do |lvasgn_node|

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

@@ -20,9 +20,14 @@ module RuboCop
       #   # good
       #   fooBar = 1
       #
+      # @example AllowedIdentifiers: ['fooBar']
+      #   # good (with EnforcedStyle: snake_case)
+      #   fooBar = 1
+      #
       # @example AllowedPatterns: ['_v\d+\z']
-      #   # good
+      #   # good (with EnforcedStyle: camelCase)
       #   :release_v1
+      #
       class VariableName < Base
         include AllowedIdentifiers
         include ConfigurableNaming

data/lib/rubocop/cop/registry.rb

@@ -300,7 +300,7 @@ module RuboCop
         unless given_badge.match?(real_badge)
           path = PathUtil.smart_path(source_path)
           warn "#{path}: #{given_badge} has the wrong namespace - " \
-               "should be #{real_badge.department}"
+               "replace it with #{given_badge.with_department(real_badge.department)}"
         end
 
         real_badge.to_s

data/lib/rubocop/cop/security/open.rb

@@ -23,6 +23,7 @@ module RuboCop
       #   # bad
       #   open(something)
       #   open("| #{something}")
+      #   open("| foo")
       #   URI.open(something)
       #
       #   # good
@@ -32,7 +33,6 @@ module RuboCop
       #
       #   # good (literal strings)
       #   open("foo.text")
-      #   open("| foo")
       #   URI.open("http://example.com")
       class Open < Base
         MSG = 'The use of `%<receiver>sopen` is a serious security risk.'
@@ -40,7 +40,7 @@ module RuboCop
 
         # @!method open?(node)
         def_node_matcher :open?, <<~PATTERN
-          (send ${nil? (const {nil? cbase} :URI)} :open $!str ...)
+          (send ${nil? (const {nil? cbase} :URI)} :open $_ ...)
         PATTERN
 
         def on_send(node)

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

@@ -168,12 +168,12 @@ module RuboCop
 
         def find_corresponding_def_node(node)
           if access_modifier_with_symbol?(node)
-            method_name = node.arguments.first.value
+            method_name = node.first_argument.value
             node.parent.each_child_node(:def).find do |child|
               child.method?(method_name)
             end
           else
-            node.arguments.first
+            node.first_argument
           end
         end
 

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

@@ -92,6 +92,7 @@ module RuboCop
           comment_line?(processed_source[node.first_line - 2])
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def groupable_accessor?(node)
           return true unless (previous_expression = node.left_siblings.last)
 
@@ -104,8 +105,11 @@ module RuboCop
 
           return true unless previous_expression.send_type?
 
-          previous_expression.attribute_accessor? || previous_expression.access_modifier?
+          previous_expression.attribute_accessor? ||
+            previous_expression.access_modifier? ||
+            node.first_line - previous_expression.last_line > 1 # there is a space between nodes
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def class_send_elements(class_node)
           class_def = class_node.body
@@ -162,7 +166,7 @@ module RuboCop
               *processed_source.ast_with_comments[arg].map(&:text),
               "#{node.method_name} #{arg.source}"
             ]
-            if arg == node.arguments.first
+            if arg == node.first_argument
               lines
             else
               indent = ' ' * node.loc.column

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

@@ -122,7 +122,7 @@ module RuboCop
         end
 
         def bareword?(sym_node)
-          !sym_node.source.start_with?(':')
+          !sym_node.source.start_with?(':') || sym_node.dsym_type?
         end
 
         def correct_alias_method_to_alias(corrector, send_node)
@@ -134,9 +134,7 @@ module RuboCop
 
         def correct_alias_to_alias_method(corrector, node)
           replacement =
-            'alias_method ' \
-            ":#{identifier(node.new_identifier)}, " \
-            ":#{identifier(node.old_identifier)}"
+            "alias_method #{identifier(node.new_identifier)}, #{identifier(node.old_identifier)}"
 
           corrector.replace(node, replacement)
         end
@@ -146,10 +144,13 @@ module RuboCop
           corrector.replace(node.old_identifier, node.old_identifier.source[1..])
         end
 
-        # @!method identifier(node)
-        def_node_matcher :identifier, <<~PATTERN
-          (sym $_)
-        PATTERN
+        def identifier(node)
+          if node.sym_type?
+            ":#{node.children.first}"
+          else
+            node.source
+          end
+        end
       end
     end
   end