rubocop 1.71.2 → 1.73.2

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that node types are checked against their group when all types of a
+      # group are checked.
+      #
+      # @example
+      #   # bad
+      #   node.type?(:irange, :erange)
+      #
+      #   # good
+      #   node.range_type?
+      #
+      #   # bad
+      #   node.type?(:irange, :erange, :send, :csend)
+      #
+      #   # good
+      #   node.type?(:range, :call)
+      #
+      class NodeTypeGroup < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `:%<group>s` instead of individually listing group types.'
+
+        RESTRICT_ON_SEND = %i[type? each_ancestor each_child_node each_descendant each_node].freeze
+
+        def on_send(node)
+          return unless node.receiver
+
+          symbol_args = node.arguments.select(&:sym_type?)
+          return if symbol_args.none?
+
+          NodePatternGroups::NODE_GROUPS.each do |group_name, group_types|
+            next unless group_satisfied?(group_types, symbol_args)
+
+            offense_range = arguments_range(node)
+            add_offense(offense_range, message: format(MSG, group: group_name)) do |corrector|
+              autocorrect(corrector, node, symbol_args, group_name, group_types)
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def arguments_range(node)
+          range_between(
+            node.first_argument.source_range.begin_pos,
+            node.last_argument.source_range.end_pos
+          )
+        end
+
+        def group_satisfied?(group_types, symbol_args)
+          group_types.all? { |type| symbol_args.any? { |arg| arg.value == type } }
+        end
+
+        def autocorrect(corrector, node, symbol_args, group_name, group_types)
+          if node.method?(:type?) && node.arguments.count == group_types.count
+            autocorrect_to_explicit_predicate(corrector, node, group_name)
+          else
+            autocorrect_keep_method(corrector, symbol_args, group_name, group_types)
+          end
+        end
+
+        def autocorrect_to_explicit_predicate(corrector, node, group_name)
+          corrector.replace(node.selector, "#{group_name}_type?")
+          corrector.remove(arguments_range(node))
+        end
+
+        def autocorrect_keep_method(corrector, symbol_args, group_name, group_types)
+          first_replaced = false
+          symbol_args.each do |arg|
+            next unless group_types.include?(arg.value)
+
+            if first_replaced
+              range = range_with_surrounding_space(arg.source_range)
+              range = range_with_surrounding_comma(range, :left)
+              corrector.remove(range)
+            else
+              first_replaced = true
+              corrector.replace(arg, ":#{group_name}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'lint_roller'
+
+module RuboCop
+  module InternalAffairs
+    # A Plugin for `InternalAffairs` department, which has internal cops.
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: 'rubocop-internal_affairs',
+          version: Version::STRING,
+          homepage: 'https://github.com/rubocop/rubocop/tree/master/lib/rubocop/cop/internal_affairs',
+          description: 'A collection of RuboCop cops to check for internal affairs.'
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        require_relative '../internal_affairs'
+
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: Pathname.new(__dir__).join('../../../../config/internal_affairs.yml')
+        )
+      end
+    end
+  end
+end

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

@@ -17,7 +17,13 @@ module RuboCop
               'in `config/default.yml`.'
         CONFIG_PATH = find_file_upwards('config/default.yml', Dir.pwd)
         CONFIG = if CONFIG_PATH
-                   ConfigLoader.load_yaml_configuration(CONFIG_PATH)
+                   begin
+                     original_debug = ConfigLoader.debug
+                     ConfigLoader.debug = false
+                     ConfigLoader.load_yaml_configuration(CONFIG_PATH)
+                   ensure
+                     ConfigLoader.debug = original_debug
+                   end
                  else
                    {}
                  end

data/lib/rubocop/cop/internal_affairs.rb

@@ -8,6 +8,7 @@ require_relative 'internal_affairs/example_description'
 require_relative 'internal_affairs/example_heredoc_delimiter'
 require_relative 'internal_affairs/inherit_deprecated_cop_class'
 require_relative 'internal_affairs/lambda_or_proc'
+require_relative 'internal_affairs/location_exists'
 require_relative 'internal_affairs/location_expression'
 require_relative 'internal_affairs/location_line_equality_comparison'
 require_relative 'internal_affairs/method_name_end_with'
@@ -16,6 +17,7 @@ require_relative 'internal_affairs/node_destructuring'
 require_relative 'internal_affairs/node_first_or_last_argument'
 require_relative 'internal_affairs/node_matcher_directive'
 require_relative 'internal_affairs/node_pattern_groups'
+require_relative 'internal_affairs/node_type_group'
 require_relative 'internal_affairs/node_type_multiple_predicates'
 require_relative 'internal_affairs/node_type_predicate'
 require_relative 'internal_affairs/numblock_handler'
@@ -36,19 +38,3 @@ require_relative 'internal_affairs/style_detected_api_use'
 require_relative 'internal_affairs/undefined_config'
 require_relative 'internal_affairs/useless_message_assertion'
 require_relative 'internal_affairs/useless_restrict_on_send'
-
-module RuboCop
-  # Patch in the InternalAffairs specific config values
-  module InternalAffairs
-    def self.inject!
-      path = File.join(ConfigLoader::RUBOCOP_HOME, 'config', 'internal_affairs.yml')
-      hash = ConfigLoader.load_yaml_configuration(path)
-      config = Config.new(hash, path)
-      puts "configuration from #{path}" if ConfigLoader.debug?
-      config = ConfigLoader.merge_with_default(config, path)
-      ConfigLoader.instance_variable_set(:@default_configuration, config)
-    end
-  end
-end
-
-RuboCop::InternalAffairs.inject!

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

@@ -73,6 +73,8 @@ module RuboCop
         # @!method block_end_align_target?(node, child)
         def_node_matcher :block_end_align_target?, <<~PATTERN
           {assignment?
+           def
+           defs
            splat
            and
            or

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

@@ -155,10 +155,10 @@ module RuboCop
         end
 
         def all_elements_aligned?(elements)
-          elements.flat_map do |e|
-            if e.hash_type?
-              e.each_child_node.map { |child| child.loc.column }
-            else
+          if elements.first.hash_type?
+            elements.first.each_child_node.map { |child| child.loc.column }
+          else
+            elements.flat_map do |e|
               e.loc.column
             end
           end.uniq.count == 1

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

@@ -49,7 +49,7 @@ module RuboCop
         end
 
         def on_rescue(node)
-          return unless node.loc.respond_to?(:else) && node.loc.else
+          return unless node.loc?(:else)
 
           check_alignment(base_range_of_rescue(node), node.loc.else)
         end

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

@@ -189,7 +189,7 @@ module RuboCop
         end
 
         def offense_location(node)
-          if node.loc.respond_to?(:end) && node.loc.end
+          if node.loc?(:end)
             node.loc.end
           else
             node

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

@@ -93,7 +93,7 @@ module RuboCop
           add_offense(node, message: message) do |corrector|
             line = range_by_whole_lines(node.source_range)
 
-            corrector.insert_before(line, "\n") unless previous_line_empty?(node.first_line)
+            corrector.insert_before(line, "\n") if should_insert_line_before?(node)
 
             correct_next_line_if_denied_style(corrector, node, line)
           end
@@ -122,6 +122,8 @@ module RuboCop
         end
 
         def correct_next_line_if_denied_style(corrector, node, line)
+          return unless should_insert_line_after?(node)
+
           case style
           when :around
             corrector.insert_after(line, "\n") unless next_line_empty?(node.last_line)
@@ -205,6 +207,29 @@ module RuboCop
             format(MSG_BEFORE_FOR_ONLY_BEFORE, modifier: modifier)
           end
         end
+
+        def should_insert_line_before?(node)
+          return false if previous_line_empty?(node.first_line)
+          return true unless inside_block?(node) && no_empty_lines_around_block_body?
+          return true unless node.parent.begin_type?
+
+          node.parent.children.first != node
+        end
+
+        def should_insert_line_after?(node)
+          return true unless inside_block?(node) && no_empty_lines_around_block_body?
+
+          node.parent.children.last != node
+        end
+
+        def inside_block?(node)
+          node.parent.block_type? || (node.parent.begin_type? && node.parent.parent&.block_type?)
+        end
+
+        def no_empty_lines_around_block_body?
+          config.for_enabled_cop('Layout/EmptyLinesAroundBlockBody')['EnforcedStyle'] ==
+            'no_empty_lines'
+        end
       end
     end
   end

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

@@ -27,9 +27,14 @@ module RuboCop
         KIND = 'method'
 
         def on_def(node)
-          first_line = node.arguments.source_range&.last_line
+          if node.endless?
+            return unless offending_endless_method?(node)
 
-          check(node, node.body, adjusted_first_line: first_line)
+            register_offense_for_endless_method(node)
+          else
+            first_line = node.arguments.source_range&.last_line
+            check(node, node.body, adjusted_first_line: first_line)
+          end
         end
         alias on_defs on_def
 
@@ -38,6 +43,21 @@ module RuboCop
         def style
           :no_empty_lines
         end
+
+        def offending_endless_method?(node)
+          node.body.first_line > node.loc.assignment.line + 1 &&
+            processed_source.lines[node.loc.assignment.line].empty?
+        end
+
+        def register_offense_for_endless_method(node)
+          range = processed_source.buffer.line_range(node.loc.assignment.line + 1).resize(1)
+
+          msg = message(MSG_EXTRA, 'beginning')
+
+          add_offense(range, message: msg) do |corrector|
+            corrector.remove(range)
+          end
+        end
       end
     end
   end

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

@@ -162,7 +162,7 @@ module RuboCop
 
         def end_keyword_before_closing_parenthesis?(parenthesized_send_node)
           parenthesized_send_node.ancestors.any? do |ancestor|
-            ancestor.loc.respond_to?(:end) && ancestor.loc.end&.source == 'end'
+            ancestor.loc_is?(:end, 'end')
           end
         end
 

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

@@ -209,7 +209,7 @@ module RuboCop
         # are not bisected.
         # If the string contains spaces, use them to determine a place for a clean break;
         # otherwise, the string will be broken at the line length limit.
-        def breakable_string_range(node) # rubocop:disable Metrics/AbcSize
+        def breakable_string_range(node)
           source_range = node.source_range
           relevant_substr = largest_possible_string(node)
 
@@ -221,13 +221,13 @@ module RuboCop
             adjustment = max - source_range.last_column - 3
             return if adjustment.abs > source_range.size
 
-            source_range.adjust(end_pos: max - source_range.last_column - 3)
+            source_range.adjust(end_pos: adjustment)
           end
         end
 
         def breakable_dstr_begin_position(node)
           source_range = node.source_range
-          source_range.begin_pos if source_range.begin_pos < max && source_range.end_pos >= max
+          source_range.begin_pos if source_range.column < max && source_range.last_column >= max
         end
 
         def breakable_range_by_line_index

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

@@ -216,7 +216,7 @@ module RuboCop
 
         def get_dot_right_above(node)
           node.each_ancestor.find do |a|
-            dot = a.loc.respond_to?(:dot) && a.loc.dot
+            dot = a.loc.dot if a.loc?(:dot)
             next unless dot
 
             dot.line == node.loc.dot.line - 1 && dot.column == node.loc.dot.column
@@ -239,7 +239,7 @@ module RuboCop
           node = node.receiver while node.receiver
           # ascend to first call which has a dot
           node = node.parent
-          node = node.parent until node.loc.respond_to?(:dot) && node.loc.dot
+          node = node.parent until node.loc?(:dot)
 
           node
         end

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

@@ -51,7 +51,7 @@ module RuboCop
         alias on_csend on_send
 
         def on_const(node)
-          return unless node.loc.respond_to?(:double_colon) && node.loc.double_colon
+          return unless node.loc?(:double_colon)
 
           check_space_after_double_colon(node)
         end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/RedundantCopDisableDirective
+# rubocop:disable Style/DoubleCopDisableDirective
+module RuboCop
+  module Cop
+    module Lint
+      # Checks that `# rubocop:enable ...` and `# rubocop:disable ...` statements
+      # are strictly formatted.
+      #
+      # A comment can be added to the directive by prefixing it with `--`.
+      #
+      # @example
+      #   # bad
+      #   # rubocop:disable Layout/LineLength Style/Encoding
+      #   #                                  ^ missing comma
+      #
+      #   # bad
+      #   # rubocop:disable
+      #
+      #   # bad
+      #   # rubocop:disable Layout/LineLength # rubocop:disable Style/Encoding
+      #
+      #   # bad
+      #   # rubocop:wrongmode Layout/LineLength
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength, Style/Encoding
+      #
+      #   # good
+      #   # rubocop:disable all
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength -- This is a good comment.
+      #
+      class CopDirectiveSyntax < Base
+        COMMON_MSG = 'Malformed directive comment detected.'
+
+        MISSING_MODE_NAME_MSG = 'The mode name is missing.'
+        INVALID_MODE_NAME_MSG = 'The mode name must be one of `enable`, `disable`, or `todo`.'
+        MISSING_COP_NAME_MSG = 'The cop name is missing.'
+        MALFORMED_COP_NAMES_MSG = 'Cop names must be separated by commas. ' \
+                                  'Comment in the directive must start with `--`.'
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            directive_comment = DirectiveComment.new(comment)
+            next unless directive_comment.start_with_marker?
+            next unless directive_comment.malformed?
+
+            message = offense_message(directive_comment)
+            add_offense(comment, message: message)
+          end
+        end
+
+        private
+
+        # rubocop:disable Metrics/MethodLength
+        def offense_message(directive_comment)
+          comment = directive_comment.comment
+          after_marker = comment.text.sub(DirectiveComment::DIRECTIVE_MARKER_REGEXP, '')
+          mode = after_marker.split(' ', 2).first
+          additional_msg = if mode.nil?
+                             MISSING_MODE_NAME_MSG
+                           elsif !DirectiveComment::AVAILABLE_MODES.include?(mode)
+                             INVALID_MODE_NAME_MSG
+                           elsif directive_comment.missing_cop_name?
+                             MISSING_COP_NAME_MSG
+                           else
+                             MALFORMED_COP_NAMES_MSG
+                           end
+
+          "#{COMMON_MSG} #{additional_msg}"
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+    end
+  end
+end
+# rubocop:enable Lint/RedundantCopDisableDirective
+# rubocop:enable Style/DoubleCopDisableDirective

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

@@ -54,14 +54,12 @@ module RuboCop
           # if a method definition is inside an if, it is very likely
           # that a different definition is used depending on platform, etc.
           return if node.each_ancestor.any?(&:if_type?)
-          return if possible_dsl?(node)
 
           found_instance_method(node, node.method_name)
         end
 
         def on_defs(node)
           return if node.each_ancestor.any?(&:if_type?)
-          return if possible_dsl?(node)
 
           if node.receiver.const_type?
             _, const_name = *node.receiver
@@ -79,7 +77,6 @@ module RuboCop
         def on_alias(node)
           return unless (name = method_alias?(node))
           return if node.ancestors.any?(&:if_type?)
-          return if possible_dsl?(node)
 
           found_instance_method(node, name)
         end
@@ -94,7 +91,6 @@ module RuboCop
         def on_send(node)
           if (name = alias_method?(node))
             return if node.ancestors.any?(&:if_type?)
-            return if possible_dsl?(node)
 
             found_instance_method(node, name)
           elsif (attr = node.attribute_accessor?)
@@ -237,16 +233,6 @@ module RuboCop
           end
         end
 
-        def possible_dsl?(node)
-          # DSL methods may evaluate a block in the context of a newly created
-          # class or module
-          # Assume that if a method definition is inside any block call which
-          # we can't identify, it could be a DSL
-          node.each_ancestor(:block).any? do |ancestor|
-            !ancestor.method?(:class_eval) && !ancestor.class_constructor?
-          end
-        end
-
         def source_location(node)
           range = node.source_range
           path = smart_path(range.source_buffer.name)

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

@@ -7,11 +7,6 @@ module RuboCop
       #
       # NOTE: empty `else` branches are handled by `Style/EmptyElse`.
       #
-      # @safety
-      #   Autocorrection for this cop is not safe. The conditions for empty branches that
-      #   the autocorrection removes may have side effects, or the logic in subsequent
-      #   branches may change due to the removal of a previous condition.
-      #
       # @example
       #   # bad
       #   if condition
@@ -41,6 +36,13 @@ module RuboCop
       #   if condition
       #     do_something
       #   elsif other_condition
+      #     nil
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     do_something
+      #   elsif other_condition
       #     do_something_else
       #   end
       #
@@ -63,11 +65,9 @@ module RuboCop
       class EmptyConditionalBody < Base
         extend AutoCorrector
         include CommentsHelp
-        include RangeHelp
 
         MSG = 'Avoid `%<keyword>s` branches without a body.'
 
-        # rubocop:disable Metrics/AbcSize
         def on_if(node)
           return if node.body || same_line?(node.loc.begin, node.loc.end)
           return if cop_config['AllowComments'] && contains_comments?(node)
@@ -75,12 +75,11 @@ module RuboCop
           range = offense_range(node)
 
           add_offense(range, message: format(MSG, keyword: node.keyword)) do |corrector|
-            next if node.parent&.call_type?
+            next unless can_simplify_conditional?(node)
 
-            autocorrect(corrector, node)
+            flip_orphaned_else(corrector, node)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -92,53 +91,23 @@ module RuboCop
           end
         end
 
-        def autocorrect(corrector, node)
-          remove_comments(corrector, node)
-          remove_empty_branch(corrector, node)
-          correct_other_branches(corrector, node)
-        end
-
-        def remove_comments(corrector, node)
-          comments_in_range(node).each do |comment|
-            range = range_by_whole_lines(comment.source_range, include_final_newline: true)
-            corrector.remove(range)
-          end
+        def can_simplify_conditional?(node)
+          node.else_branch && node.loc.else.source == 'else'
         end
 
-        # rubocop:disable Metrics/AbcSize
         def remove_empty_branch(corrector, node)
           range = if empty_if_branch?(node) && else_branch?(node)
                     branch_range(node)
-                  elsif same_line?(node, else_kw_loc = node.loc.else)
-                    node.source_range.begin.join(else_kw_loc.begin)
-                  elsif node.parent&.loc.respond_to?(:end) &&
-                        same_line?(node, end_loc = node.parent.loc.end)
-                    node.source_range.begin.join(end_loc.begin)
                   else
                     deletion_range(branch_range(node))
                   end
 
           corrector.remove(range)
         end
-        # rubocop:enable Metrics/AbcSize
-
-        def correct_other_branches(corrector, node)
-          return unless require_other_branches_correction?(node)
-
-          if node.else_branch&.if_type? && !node.else_branch.modifier_form?
-            # Replace an orphaned `elsif` with `if`
-            corrector.replace(node.else_branch.loc.keyword, 'if')
-          else
-            # Flip orphaned `else`
-            corrector.replace(node.loc.else, "#{node.inverse_keyword} #{node.condition.source}")
-          end
-        end
-
-        def require_other_branches_correction?(node)
-          return false unless node.if_type? && node.else?
-          return false if !empty_if_branch?(node) && node.elsif?
 
-          !empty_elsif_branch?(node)
+        def flip_orphaned_else(corrector, node)
+          corrector.replace(node.loc.else, "#{node.inverse_keyword} #{node.condition.source}")
+          remove_empty_branch(corrector, node)
         end
 
         def empty_if_branch?(node)
@@ -149,36 +118,17 @@ module RuboCop
           if_branch.if_type? && !if_branch.body
         end
 
-        def empty_elsif_branch?(node)
-          return false unless (else_branch = node.else_branch)
-
-          else_branch.if_type? && !else_branch.body
-        end
-
         def else_branch?(node)
           node.else_branch && !node.else_branch.if_type?
         end
 
-        # rubocop:disable Metrics/AbcSize
         def branch_range(node)
           if empty_if_branch?(node) && else_branch?(node)
             node.source_range.with(end_pos: node.loc.else.begin_pos)
           elsif node.loc.else
             node.source_range.with(end_pos: node.condition.source_range.end_pos)
-          elsif all_branches_body_missing?(node)
-            if_node = node.ancestors.detect(&:if?)
-            node.source_range.join(if_node.loc.end.end)
-          else
-            node.source_range
           end
         end
-        # rubocop:enable Metrics/AbcSize
-
-        def all_branches_body_missing?(node)
-          return false unless node.parent&.if_type?
-
-          node.parent.branches.compact.empty?
-        end
 
         def deletion_range(range)
           # Collect a range between the start of the `if` node and the next relevant node,

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

@@ -156,12 +156,6 @@ module RuboCop
 
           overridden_kwargs
         end
-
-        def arguments_range(node)
-          arguments = node.arguments
-
-          range_between(arguments.first.source_range.begin_pos, arguments.last.source_range.end_pos)
-        end
       end
     end
   end