rubocop 1.71.2 → 1.73.0

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/float_comparison.rb

@@ -81,21 +81,16 @@ module RuboCop
           (node.numeric_type? && node.value.zero?) || node.nil_type?
         end
 
-        # rubocop:disable Metrics/PerceivedComplexity
         def check_send(node)
           if node.arithmetic_operation?
             float?(node.receiver) || float?(node.first_argument)
           elsif FLOAT_RETURNING_METHODS.include?(node.method_name)
             true
           elsif node.receiver&.float_type?
-            if FLOAT_INSTANCE_METHODS.include?(node.method_name)
-              true
-            else
+            FLOAT_INSTANCE_METHODS.include?(node.method_name) ||
               check_numeric_returning_method(node)
-            end
           end
         end
-        # rubocop:enable Metrics/PerceivedComplexity
 
         def check_numeric_returning_method(node)
           return false unless node.receiver

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

@@ -7,7 +7,7 @@ module RuboCop
       # expected fields for format/sprintf/#% and what is actually
       # passed as arguments.
       #
-      # In addition it checks whether different formats are used in the same
+      # In addition, it checks whether different formats are used in the same
       # format string. Do not mix numbered, unnumbered, and named formats in
       # the same format string.
       #

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

@@ -34,27 +34,100 @@ module RuboCop
       #   end
       class LiteralAsCondition < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Literal `%<literal>s` appeared as a condition.'
         RESTRICT_ON_SEND = [:!].freeze
 
+        # rubocop:disable Metrics/AbcSize
+        def on_and(node)
+          if node.lhs.truthy_literal? && node.rhs.truthy_literal?
+            add_offense(node) do |corrector|
+              corrector.replace(node, 'true')
+            end
+          elsif node.lhs.truthy_literal?
+            add_offense(node.lhs) do |corrector|
+              corrector.replace(node, node.rhs.source)
+            end
+          elsif node.rhs.truthy_literal?
+            add_offense(node.rhs) do |corrector|
+              corrector.replace(node, node.lhs.source)
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
         def on_if(node)
-          check_for_literal(node)
+          cond = condition(node)
+
+          if node.unless?
+            correct_if_node(node, cond, true) if cond.falsey_literal?
+            correct_if_node(node, cond, false) if cond.truthy_literal?
+          else
+            correct_if_node(node, cond, true) if cond.truthy_literal?
+            correct_if_node(node, cond, false) if cond.falsey_literal?
+          end
         end
 
         def on_while(node)
-          return if condition(node).true_type?
+          return if node.condition.source == 'true'
 
-          check_for_literal(node)
+          if node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node.condition, 'true')
+            end
+          elsif node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.remove(node)
+            end
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def on_while_post(node)
+          return if node.condition.source == 'true'
+
+          if node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node, node.source.sub(node.condition.source, 'true'))
+            end
+          elsif node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
+            end
+          end
         end
-        alias on_while_post on_while
+        # rubocop:enable Metrics/AbcSize
 
         def on_until(node)
-          return if condition(node).false_type?
+          return if node.condition.source == 'false'
 
-          check_for_literal(node)
+          if node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node.condition, 'false')
+            end
+          elsif node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.remove(node)
+            end
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def on_until_post(node)
+          return if node.condition.source == 'false'
+
+          if node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node, node.source.sub(node.condition.source, 'false'))
+            end
+          elsif node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
+            end
+          end
         end
-        alias on_until_post on_until
+        # rubocop:enable Metrics/AbcSize
 
         def on_case(case_node)
           if case_node.condition
@@ -130,6 +203,8 @@ module RuboCop
 
         def handle_node(node)
           if node.literal?
+            return if node.parent.and_type?
+
             add_offense(node)
           elsif %i[send and or begin].include?(node.type)
             check_node(node)
@@ -159,6 +234,28 @@ module RuboCop
             when_node.conditions.last.source_range.end_pos
           )
         end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def correct_if_node(node, cond, result)
+          if result
+            add_offense(cond) do |corrector|
+              corrector.replace(node, node.if_branch.source)
+            end
+          elsif node.elsif_conditional?
+            add_offense(cond) do |corrector|
+              corrector.replace(node, "#{node.else_branch.source.sub('elsif', 'if')}\nend")
+            end
+          elsif node.else? || node.ternary?
+            add_offense(cond) do |corrector|
+              corrector.replace(node, node.else_branch.source)
+            end
+          else
+            add_offense(cond) do |corrector|
+              corrector.remove(node)
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
       end
     end
   end

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

@@ -79,7 +79,7 @@ module RuboCop
         end
 
         def range_pairs(expr)
-          RuboCop::Cop::Utils::RegexpRanges.new(expr).pairs
+          expr.expressions.filter_map { |e| [e.expressions[0], e.expressions[1]] if e.type == :set }
         end
 
         def unsafe_range?(range_start, range_end)

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

@@ -17,17 +17,12 @@ module RuboCop
       #   * 2.0+ ... `enumerator`
       #   * 2.1+ ... `thread`
       #   * 2.2+ ... Add `rational` and `complex` above
-      #   * 2.5+ ... Add `pp` above
       #   * 2.7+ ... Add `ruby2_keywords` above
       #   * 3.1+ ... Add `fiber` above
       #   * 3.2+ ... `set`
       #
       # This cop target those features.
       #
-      # @safety
-      #   This cop's autocorrection is unsafe because if `require 'pp'` is removed from one file,
-      #   `NameError` can be encountered when another file uses `PP.pp`.
-      #
       # @example
       #   # bad
       #   require 'unloaded_feature'
@@ -42,10 +37,6 @@ module RuboCop
         MSG = 'Remove unnecessary `require` statement.'
         RESTRICT_ON_SEND = %i[require].freeze
         RUBY_22_LOADED_FEATURES = %w[rational complex].freeze
-        PRETTY_PRINT_METHODS = %i[
-          pretty_inspect pretty_print pretty_print_cycle
-          pretty_print_inspect pretty_print_instance_variables
-        ].freeze
 
         # @!method redundant_require_statement?(node)
         def_node_matcher :redundant_require_statement?, <<~PATTERN
@@ -53,11 +44,6 @@ module RuboCop
             (str #redundant_feature?))
         PATTERN
 
-        # @!method pp_const?(node)
-        def_node_matcher :pp_const?, <<~PATTERN
-          (const {nil? cbase} :PP)
-        PATTERN
-
         def on_send(node)
           return unless redundant_require_statement?(node)
 
@@ -81,18 +67,11 @@ module RuboCop
           feature_name == 'enumerator' ||
             (target_ruby_version >= 2.1 && feature_name == 'thread') ||
             (target_ruby_version >= 2.2 && RUBY_22_LOADED_FEATURES.include?(feature_name)) ||
-            (target_ruby_version >= 2.5 && feature_name == 'pp' && !need_to_require_pp?) ||
             (target_ruby_version >= 2.7 && feature_name == 'ruby2_keywords') ||
             (target_ruby_version >= 3.1 && feature_name == 'fiber') ||
             (target_ruby_version >= 3.2 && feature_name == 'set')
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-        def need_to_require_pp?
-          processed_source.ast.each_descendant(:send).any? do |node|
-            pp_const?(node.receiver) || PRETTY_PRINT_METHODS.include?(node.method_name)
-          end
-        end
       end
     end
   end