rubocop 1.57.1 → 1.81.7

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

@@ -7,6 +7,9 @@ module RuboCop
       # can be combined into a single loop. It is very likely that combining them
       # will make the code more efficient and more concise.
       #
+      # NOTE: Autocorrection is not applied when the block variable names differ in separate loops,
+      # as it is impossible to determine which variable name should be prioritized.
+      #
       # @safety
       #   The cop is unsafe, because the first loop might modify state that the
       #   second loop depends on; these two aren't combinable.
@@ -59,10 +62,9 @@ module RuboCop
       class CombinableLoops < Base
         extend AutoCorrector
 
-        include RangeHelp
-
         MSG = 'Combine this loop with the previous loop.'
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_block(node)
           return unless node.parent&.begin_type?
           return unless collection_looping_method?(node)
@@ -70,11 +72,15 @@ module RuboCop
           return unless node.body && node.left_sibling.body
 
           add_offense(node) do |corrector|
+            next unless node.arguments == node.left_sibling.arguments
+
             combine_with_left_sibling(corrector, node)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_for(node)
           return unless node.parent&.begin_type?
@@ -93,7 +99,7 @@ module RuboCop
         end
 
         def same_collection_looping_block?(node, sibling)
-          return false if sibling.nil? || (!sibling.block_type? && !sibling.numblock_type?)
+          return false if sibling.nil? || !sibling.any_block_type?
 
           sibling.method?(node.method_name) &&
             sibling.receiver == node.receiver &&
@@ -105,11 +111,19 @@ module RuboCop
         end
 
         def combine_with_left_sibling(corrector, node)
-          corrector.replace(
-            node.left_sibling.body,
-            "#{node.left_sibling.body.source}\n#{node.body.source}"
-          )
-          corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
+          corrector.remove(node.left_sibling.body.source_range.end.join(node.left_sibling.loc.end))
+          corrector.remove(node.source_range.begin.join(node.body.source_range.begin))
+
+          correct_end_of_block(corrector, node)
+        end
+
+        def correct_end_of_block(corrector, node)
+          return unless node.left_sibling.respond_to?(:braces?)
+          return if node.right_sibling&.any_block_type?
+
+          end_of_block = node.left_sibling.braces? ? '}' : ' end'
+          corrector.remove(node.loc.end)
+          corrector.insert_before(node.source_range.end, end_of_block)
         end
       end
     end

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

@@ -173,7 +173,7 @@ module RuboCop
         end
 
         def preferred_delimiters_config
-          config.for_cop('Style/PercentLiteralDelimiters') ['PreferredDelimiters']
+          config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']
         end
       end
     end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../../directive_comment'
+
 module RuboCop
   module Cop
     module Style
@@ -7,8 +9,8 @@ module RuboCop
       # These keywords are: `class`, `module`, `def`, `begin`, `end`.
       #
       # Note that some comments
-      # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`)
-      # are allowed.
+      # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`),
+      # RBS::Inline annotation, and Steep annotation (`steep:ignore`) are allowed.
       #
       # Autocorrection removes comments from `end` keyword and keeps comments
       # for `class`, `module`, `def` and `begin` above the keyword.
@@ -49,11 +51,17 @@ module RuboCop
         KEYWORDS = %w[begin class def end module].freeze
         KEYWORD_REGEXES = KEYWORDS.map { |w| /^\s*#{w}\s/ }.freeze
 
-        ALLOWED_COMMENTS = %w[:nodoc: :yields: rubocop:disable rubocop:todo].freeze
-        ALLOWED_COMMENT_REGEXES = ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ }.freeze
+        ALLOWED_COMMENTS = %w[:nodoc: :yields:].freeze
+        ALLOWED_COMMENT_REGEXES = (ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ } +
+                                   [DirectiveComment::DIRECTIVE_COMMENT_REGEXP]).freeze
 
         REGEXP = /(?<keyword>\S+).*#/.freeze
 
+        SUBCLASS_DEFINITION = /\A\s*class\s+(\w|::)+\s*<\s*(\w|::)+/.freeze
+        METHOD_OR_END_DEFINITIONS = /\A\s*(def\s|end)/.freeze
+
+        STEEP_REGEXP = /#\ssteep:ignore(\s|\z)/.freeze
+
         def on_new_investigation
           processed_source.comments.each do |comment|
             next unless offensive?(comment) && (match = source_line(comment).match(REGEXP))
@@ -79,6 +87,9 @@ module RuboCop
 
         def offensive?(comment)
           line = source_line(comment)
+          return false if rbs_inline_annotation?(line, comment)
+          return false if steep_annotation?(comment)
+
           KEYWORD_REGEXES.any? { |r| r.match?(line) } &&
             ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
         end
@@ -86,6 +97,21 @@ module RuboCop
         def source_line(comment)
           comment.source_range.source_line
         end
+
+        def rbs_inline_annotation?(line, comment)
+          case line
+          when SUBCLASS_DEFINITION
+            comment.text.start_with?(/#\[.+\]/)
+          when METHOD_OR_END_DEFINITIONS
+            comment.text.start_with?('#:')
+          else
+            false
+          end
+        end
+
+        def steep_annotation?(comment)
+          comment.text.match?(STEEP_REGEXP)
+        end
       end
     end
   end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for logical comparison which can be replaced with `Comparable#between?`.
+      #
+      # NOTE: `Comparable#between?` is on average slightly slower than logical comparison,
+      # although the difference generally isn't observable. If you require maximum
+      # performance, consider using logical comparison.
+      #
+      # @safety
+      #   This cop is unsafe because the receiver may not respond to `between?`.
+      #
+      # @example
+      #
+      #   # bad
+      #   x >= min && x <= max
+      #
+      #   # bad
+      #   x <= max && x >= min
+      #
+      #   # good
+      #   x.between?(min, max)
+      #
+      class ComparableBetween < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `%<prefer>s` over logical comparison.'
+
+        # @!method logical_comparison_between_by_min_first?(node)
+        def_node_matcher :logical_comparison_between_by_min_first?, <<~PATTERN
+          (and
+            (send
+              {$_value :>= $_min | $_min :<= $_value})
+            (send
+              {$_value :<= $_max | $_max :>= $_value}))
+        PATTERN
+
+        # @!method logical_comparison_between_by_max_first?(node)
+        def_node_matcher :logical_comparison_between_by_max_first?, <<~PATTERN
+          (and
+            (send
+              {$_value :<= $_max | $_max :>= $_value})
+            (send
+              {$_value :>= $_min | $_min :<= $_value}))
+        PATTERN
+
+        def on_and(node)
+          logical_comparison_between_by_min_first?(node) do |*args|
+            min_and_value, max_and_value = args.each_slice(2).to_a
+
+            register_offense(node, min_and_value, max_and_value)
+          end
+
+          logical_comparison_between_by_max_first?(node) do |*args|
+            max_and_value, min_and_value = args.each_slice(2).to_a
+
+            register_offense(node, min_and_value, max_and_value)
+          end
+        end
+
+        private
+
+        def register_offense(node, min_and_value, max_and_value)
+          value = (min_and_value & max_and_value).first
+          min = min_and_value.find { _1 != value } || value
+          max = max_and_value.find { _1 != value } || value
+
+          prefer = "#{value.source}.between?(#{min.source}, #{max.source})"
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -63,6 +63,7 @@ module RuboCop
           end
         end
         # rubocop:enable Metrics
+        alias on_csend on_send
 
         private
 
@@ -85,7 +86,7 @@ module RuboCop
 
         def percent_literals_includes_only_basic_literals?(node)
           node.arguments.select(&:percent_literal?).all? do |arg|
-            arg.children.all? { |child| child.str_type? || child.sym_type? }
+            arg.children.all? { |child| child.type?(:str, :sym) }
           end
         end
       end

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

@@ -33,24 +33,20 @@ module RuboCop
           branch.begin_type? ? Array(branch).last : branch
         end
 
-        # rubocop:disable Metrics/AbcSize
         def lhs(node)
           case node.type
           when :send
             lhs_for_send(node)
-          when :op_asgn
-            "#{node.children[0].source} #{node.children[1]}= "
-          when :and_asgn, :or_asgn
-            "#{node.children[0].source} #{node.loc.operator.source} "
+          when :op_asgn, :and_asgn, :or_asgn
+            "#{node.assignment_node.source} #{node.operator}= "
           when :casgn
             lhs_for_casgn(node)
           when *ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES
-            "#{node.children[0]} = "
+            "#{node.name} = "
           else
             node.source
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def indent(cop, source)
           conf = cop.config.for_cop(END_ALIGNMENT)
@@ -73,7 +69,7 @@ module RuboCop
           elsif_branches << node.if_branch
 
           else_branch = node.else_branch
-          if else_branch&.if_type? && else_branch&.elsif?
+          if else_branch&.if_type? && else_branch.elsif?
             expand_elsif(else_branch, elsif_branches)
           else
             elsif_branches << else_branch
@@ -94,11 +90,12 @@ module RuboCop
         end
 
         def lhs_for_casgn(node)
-          namespace = node.children[0]
-          if namespace.nil? || namespace.cbase_type?
-            "#{namespace&.source}#{node.children[1]} = "
+          if node.namespace.nil?
+            "#{node.name} = "
+          elsif node.namespace.cbase_type?
+            "::#{node.name} = "
           else
-            "#{namespace.source}::#{node.children[1]} = "
+            "#{node.namespace.const_name}::#{node.name} = "
           end
         end
 
@@ -110,13 +107,13 @@ module RuboCop
           parent = node.parent
           return true unless parent
 
-          !(parent.mlhs_type? || parent.resbody_type?)
+          !parent.type?(:mlhs, :resbody)
         end
       end
 
-      # Check for `if` and `case` statements where each branch is used for
-      # assignment to the same variable when using the return of the
-      # condition can be used instead.
+      # Checks for `if` and `case` statements where each branch is used for
+      # both the assignment and comparison of the same variable
+      # when using the return of the condition can be used instead.
       #
       # @example EnforcedStyle: assign_to_condition (default)
       #   # bad
@@ -210,11 +207,10 @@ module RuboCop
       class ConditionalAssignment < Base
         include ConditionalAssignmentHelper
         include ConfigurableEnforcedStyle
-        include IgnoredNode
         extend AutoCorrector
 
         MSG = 'Use the return of the conditional for variable assignment and comparison.'
-        ASSIGN_TO_CONDITION_MSG = 'Assign variables inside of conditionals'
+        ASSIGN_TO_CONDITION_MSG = 'Assign variables inside of conditionals.'
         VARIABLE_ASSIGNMENT_TYPES = %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
         ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES + %i[and_asgn or_asgn op_asgn masgn].freeze
         LINE_LENGTH = 'Layout/LineLength'
@@ -233,7 +229,7 @@ module RuboCop
         PATTERN
 
         ASSIGNMENT_TYPES.each do |type|
-          define_method "on_#{type}" do |node|
+          define_method :"on_#{type}" do |node|
             return if part_of_ignored_node?(node)
             return if node.parent&.shorthand_asgn?
 
@@ -313,22 +309,25 @@ module RuboCop
         end
 
         def allowed_single_line?(branches)
-          single_line_conditions_only? && branches.any?(&:begin_type?)
+          single_line_conditions_only? && branches.compact.any?(&:begin_type?)
         end
 
         def assignment_node(node)
-          *_variable, assignment = *node
+          assignment = node.send_type? ? node.last_argument : node.expression
+          return unless assignment
 
           # ignore pseudo-assignments without rhs in for nodes
           return if node.parent&.for_type?
 
-          assignment, = *assignment if assignment.begin_type? && assignment.children.one?
+          if assignment.begin_type? && assignment.children.one?
+            assignment = assignment.children.first
+          end
 
           assignment
         end
 
         def move_assignment_outside_condition(corrector, node)
-          if node.case_type? || node.case_match_type?
+          if node.type?(:case, :case_match)
             CaseCorrector.correct(corrector, self, node)
           elsif node.ternary?
             TernaryCorrector.correct(corrector, node)
@@ -338,11 +337,11 @@ module RuboCop
         end
 
         def move_assignment_inside_condition(corrector, node)
-          *_assignment, condition = *node
+          condition = node.send_type? ? node.last_argument : node.expression
 
           if ternary_condition?(condition)
             TernaryCorrector.move_assignment_inside_condition(corrector, node)
-          elsif condition.case_type? || condition.case_match_type?
+          elsif condition.type?(:case, :case_match)
             CaseCorrector.move_assignment_inside_condition(corrector, node)
           elsif condition.if_type?
             IfCorrector.move_assignment_inside_condition(corrector, node)
@@ -438,31 +437,47 @@ module RuboCop
       # Helper module to provide common methods to ConditionalAssignment
       # correctors
       module ConditionalCorrectorHelper
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         def remove_whitespace_in_branches(corrector, branch, condition, column)
           branch.each_node do |child|
             next if child.source_range.nil?
+            next if child.parent.dstr_type?
 
             white_space = white_space_range(child, column)
-            corrector.remove(white_space) if white_space.source.strip.empty?
+            corrector.remove(white_space) if white_space
           end
 
-          [condition.loc.else, condition.loc.end].each do |loc|
-            corrector.remove_preceding(loc, loc.column - column)
+          if condition.loc.else && !same_line?(condition.else_branch, condition)
+            corrector.remove_preceding(condition.loc.else, condition.loc.else.column - column)
           end
+
+          return unless condition.loc.end && !same_line?(
+            condition.branches.last.parent.else_branch, condition.loc.end
+          )
+
+          corrector.remove_preceding(condition.loc.end, condition.loc.end.column - column)
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+        def same_line?(node1, node2)
+          RuboCop::Cop::Util.same_line?(node1, node2)
         end
 
         def white_space_range(node, column)
           expression = node.source_range
-          begin_pos = expression.begin_pos - (expression.column - column - 2)
+          end_pos = expression.begin_pos
+          begin_pos = end_pos - (expression.column - column - 2)
+
+          return nil if begin_pos > end_pos
 
-          Parser::Source::Range.new(expression.source_buffer, begin_pos, expression.begin_pos)
+          white_space = Parser::Source::Range.new(expression.source_buffer, begin_pos, end_pos)
+          white_space if white_space.source.strip.empty?
         end
 
         def assignment(node)
-          *_, condition = *node
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    node.source_range.begin_pos,
-                                    condition.source_range.begin_pos)
+          condition = node.send_type? ? node.last_argument : node.expression
+
+          node.source_range.begin.join(condition.source_range.begin)
         end
 
         def correct_if_branches(corrector, cop, node)
@@ -507,7 +522,7 @@ module RuboCop
           end
 
           def move_assignment_inside_condition(corrector, node)
-            *_var, rhs = *node
+            rhs = node.send_type? ? node.last_argument : node.expression
             if_branch, else_branch = extract_branches(node)
             assignment = assignment(node)
 
@@ -534,12 +549,12 @@ module RuboCop
           end
 
           def element_assignment?(node)
-            node.send_type? && node.method_name != :[]=
+            node.send_type? && !node.method?(:[]=)
           end
 
           def extract_branches(node)
-            *_var, rhs = *node
-            condition, = *rhs if rhs.begin_type? && rhs.children.one?
+            rhs = node.send_type? ? node.last_argument : node.expression
+            condition = rhs.children.first if rhs.begin_type? && rhs.children.one?
             _condition, if_branch, else_branch = *(condition || rhs)
 
             [if_branch, else_branch]
@@ -568,7 +583,7 @@ module RuboCop
 
           def move_assignment_inside_condition(corrector, node)
             column = node.source_range.column
-            *_var, condition = *node
+            condition = node.send_type? ? node.last_argument : node.expression
             assignment = assignment(node)
 
             corrector.remove(assignment)
@@ -596,6 +611,8 @@ module RuboCop
 
             return unless (branch_else = branch.parent.loc.else)
 
+            return if same_line?(branch_else, condition)
+
             corrector.remove_preceding(branch_else, branch_else.column - column)
           end
         end
@@ -619,7 +636,7 @@ module RuboCop
 
           def move_assignment_inside_condition(corrector, node)
             column = node.source_range.column
-            *_var, condition = *node
+            condition = node.send_type? ? node.last_argument : node.expression
             assignment = assignment(node)
 
             corrector.remove(assignment)

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

@@ -48,13 +48,17 @@ module RuboCop
         MSG = 'Explicitly make `%<constant_name>s` public or private using ' \
               'either `#public_constant` or `#private_constant`.'
 
+        # @!method visibility_declaration_for(node)
+        def_node_matcher :visibility_declaration_for, <<~PATTERN
+          (send nil? {:public_constant :private_constant} $...)
+        PATTERN
+
         def on_casgn(node)
           return unless class_or_module_scope?(node)
           return if visibility_declaration?(node)
           return if ignore_modules? && module?(node)
 
-          message = message(node)
-          add_offense(node, message: message)
+          add_offense(node, message: format(MSG, constant_name: node.name))
         end
 
         private
@@ -64,13 +68,7 @@ module RuboCop
         end
 
         def module?(node)
-          node.children.last.class_constructor?
-        end
-
-        def message(node)
-          _namespace, constant_name, _value = *node
-
-          format(MSG, constant_name: constant_name)
+          node.expression.class_constructor?
         end
 
         def class_or_module_scope?(node)
@@ -84,22 +82,20 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/AbcSize
         def visibility_declaration?(node)
-          _namespace, constant_name, _value = *node
-
           node.parent.each_child_node(:send).any? do |child|
-            visibility_declaration_for?(child, constant_name)
-          end
-        end
+            next false unless (arguments = visibility_declaration_for(child))
 
-        # @!method visibility_declaration_for?(node, const_name)
-        def_node_matcher :visibility_declaration_for?, <<~PATTERN
-          (send nil? {:public_constant :private_constant} ({sym str} #match_name?(%1)))
-        PATTERN
+            arguments = arguments.first.children.first.to_a if arguments.first&.splat_type?
+            constant_values = arguments.map do |argument|
+              argument.value.to_sym if argument.respond_to?(:value)
+            end
 
-        def match_name?(name, constant_name)
-          name.to_sym == constant_name.to_sym
+            constant_values.include?(node.name)
+          end
         end
+        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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

@@ -28,18 +28,27 @@ module RuboCop
         def on_new_investigation
           return if notice.empty? || notice_found?(processed_source)
 
-          add_offense(offense_range, message: format(MSG, notice: notice)) do |corrector|
-            verify_autocorrect_notice!
-
-            token = insert_notice_before(processed_source)
-            range = token.nil? ? range_between(0, 0) : token.pos
-
-            corrector.insert_before(range, "#{autocorrect_notice}\n")
+          verify_autocorrect_notice!
+          message = format(MSG, notice: notice)
+          if processed_source.blank?
+            add_global_offense(message)
+          else
+            offense_range = source_range(processed_source.buffer, 1, 0)
+            add_offense(offense_range, message: message) do |corrector|
+              autocorrect(corrector)
+            end
           end
         end
 
         private
 
+        def autocorrect(corrector)
+          token = insert_notice_before(processed_source)
+          range = token.nil? ? range_between(0, 0) : token.pos
+
+          corrector.insert_before(range, "#{autocorrect_notice}\n")
+        end
+
         def notice
           cop_config['Notice']
         end
@@ -48,17 +57,16 @@ module RuboCop
           cop_config['AutocorrectNotice']
         end
 
-        def offense_range
-          source_range(processed_source.buffer, 1, 0)
-        end
-
         def verify_autocorrect_notice!
-          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
+          if autocorrect_notice.nil? || autocorrect_notice.empty?
+            raise Warning, "#{cop_name}: #{AUTOCORRECT_EMPTY_WARNING}"
+          end
 
           regex = Regexp.new(notice)
-          return if autocorrect_notice&.match?(regex)
+          return if autocorrect_notice.gsub(/^# */, '').match?(regex)
 
-          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must match Notice /#{notice}/"
+          message = "AutocorrectNotice '#{autocorrect_notice}' must match Notice /#{notice}/"
+          raise Warning, "#{cop_name}: #{message}"
         end
 
         def insert_notice_before(processed_source)
@@ -72,26 +80,28 @@ module RuboCop
           return false if token_index >= processed_source.tokens.size
 
           token = processed_source.tokens[token_index]
-          token.comment? && /^#!.*$/.match?(token.text)
+          token.comment? && /\A#!.*\z/.match?(token.text)
         end
 
         def encoding_token?(processed_source, token_index)
           return false if token_index >= processed_source.tokens.size
 
           token = processed_source.tokens[token_index]
-          token.comment? && /^#.*coding\s?[:=]\s?(?:UTF|utf)-8/.match?(token.text)
+          token.comment? && /\A#.*coding\s?[:=]\s?(?:UTF|utf)-8/.match?(token.text)
         end
 
         def notice_found?(processed_source)
-          notice_found = false
-          notice_regexp = Regexp.new(notice)
+          notice_regexp = Regexp.new(notice.lines.map(&:strip).join)
+          multiline_notice = +''
           processed_source.tokens.each do |token|
             break unless token.comment?
 
-            notice_found = notice_regexp.match?(token.text)
-            break if notice_found
+            multiline_notice << token.text.sub(/\A# */, '')
+
+            break if notice_regexp.match?(token.text)
           end
-          notice_found
+
+          multiline_notice.match?(notice_regexp)
         end
       end
     end