rubocop 0.93.1 → 1.79.2

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

@@ -15,7 +15,12 @@ module RuboCop
         parent = node.parent
 
         parent&.send_type? && parent.arguments.include?(node) &&
-          !parent.parenthesized? && parent&.block_literal?
+          !parent.parenthesized? && parent.block_literal?
+      end
+
+      # Override to determine values that are invalid in a percent array
+      def invalid_percent_array_contents?(_node)
+        false
       end
 
       def allowed_bracket_array?(node)
@@ -23,10 +28,6 @@ module RuboCop
           invalid_percent_array_context?(node)
       end
 
-      def message(_node)
-        style == :percent ? self.class::PERCENT_MSG : self.class::ARRAY_MSG
-      end
-
       def comments_in_array?(node)
         line_span = node.source_range.first_line...node.source_range.last_line
         processed_source.each_comment_in_lines(line_span).any?
@@ -35,13 +36,34 @@ module RuboCop
       def check_percent_array(node)
         array_style_detected(:percent, node.values.size)
 
-        return unless style == :brackets
+        brackets_required = invalid_percent_array_contents?(node)
+        return unless style == :brackets || brackets_required
+
+        # If in percent style but brackets are required due to
+        # string content, the file should be excluded in auto-gen-config
+        no_acceptable_style! if brackets_required
 
-        add_offense(node) do |corrector|
-          correct_bracketed(corrector, node)
+        bracketed_array = build_bracketed_array(node)
+        message = build_message_for_bracketed_array(bracketed_array)
+
+        add_offense(node, message: message) do |corrector|
+          corrector.replace(node, bracketed_array)
         end
       end
 
+      # @param [String] preferred_array_code
+      # @return [String]
+      def build_message_for_bracketed_array(preferred_array_code)
+        format(
+          self.class::ARRAY_MSG,
+          prefer: if preferred_array_code.include?("\n")
+                    'an array literal `[...]`'
+                  else
+                    "`#{preferred_array_code}`"
+                  end
+        )
+      end
+
       def check_bracketed_array(node, literal_prefix)
         return if allowed_bracket_array?(node)
 
@@ -49,11 +71,55 @@ module RuboCop
 
         return unless style == :percent
 
-        add_offense(node) do |corrector|
+        add_offense(node, message: self.class::PERCENT_MSG) do |corrector|
           percent_literal_corrector = PercentLiteralCorrector.new(@config, @preferred_delimiters)
           percent_literal_corrector.correct(corrector, node, literal_prefix)
         end
       end
+
+      # @param [RuboCop::AST::ArrayNode] node
+      # @param [Array<String>] elements
+      # @return [String]
+      def build_bracketed_array_with_appropriate_whitespace(elements:, node:)
+        [
+          '[',
+          whitespace_leading(node),
+          elements.join(",#{whitespace_between(node)}"),
+          whitespace_trailing(node),
+          ']'
+        ].join
+      end
+
+      # Provides whitespace between elements for building a bracketed array.
+      #   %w[  a   b   c    ]
+      #         ^^^
+      # @param [RuboCop::AST::ArrayNode] node
+      # @return [String]
+      def whitespace_between(node)
+        if node.children.length >= 2
+          node.children[0].source_range.end.join(node.children[1].source_range.begin).source
+        else
+          ' '
+        end
+      end
+
+      # Provides leading whitespace for building a bracketed array.
+      #   %w[  a   b   c    ]
+      #      ^^
+      # @param [RuboCop::AST::ArrayNode] node
+      # @return [String]
+      def whitespace_leading(node)
+        node.loc.begin.end.join(node.children[0].source_range.begin).source
+      end
+
+      # Provides trailing whitespace for building a bracketed array.
+      #   %w[  a   b   c    ]
+      #                 ^^^^
+      # @param [RuboCop::AST::ArrayNode] node
+      # @return [String]
+      def whitespace_trailing(node)
+        node.children[-1].source_range.end.join(node.loc.end.begin).source
+      end
     end
   end
 end

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
@@ -21,18 +21,12 @@ module RuboCop
       end
 
       def begin_source(node)
-        node.loc.begin.source if node.loc.respond_to?(:begin) && node.loc.begin
+        node.loc.begin.source if node.loc?(:begin)
       end
 
       def type(node)
         node.loc.begin.source[0..-2]
       end
-
-      # A range containing only the contents of the percent literal (e.g. in
-      # %i{1 2 3} this will be the range covering '1 2 3' only)
-      def contents_range(node)
-        range_between(node.loc.begin.end_pos, node.loc.end.begin_pos)
-      end
     end
   end
 end

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

@@ -4,7 +4,12 @@ module RuboCop
   module Cop
     # Common functionality for checking whether an AST node/token is aligned
     # with something on a preceding or following line
+    # rubocop:disable Metrics/ModuleLength
     module PrecedingFollowingAlignment
+      # Tokens that end with an `=`, as well as `<<`, that can be aligned together:
+      # `=`, `==`, `===`, `!=`, `<=`, `>=`, `<<` and operator assignment (`+=`, etc).
+      ASSIGNMENT_OR_COMPARISON_TOKENS = %i[tEQL tEQ tEQQ tNEQ tLEQ tGEQ tOP_ASGN tLSHFT].freeze
+
       private
 
       def allow_for_alignment?
@@ -19,16 +24,20 @@ module RuboCop
         aligned_with_adjacent_line?(range, method(:aligned_operator?))
       end
 
-      def aligned_with_preceding_assignment(token)
+      # Allows alignment with a preceding operator that ends with an `=`,
+      # including assignment and comparison operators.
+      def aligned_with_preceding_equals_operator(token)
         preceding_line_range = token.line.downto(1)
 
-        aligned_with_assignment(token, preceding_line_range)
+        aligned_with_equals_sign(token, preceding_line_range)
       end
 
-      def aligned_with_subsequent_assignment(token)
+      # Allows alignment with a subsequent operator that ends with an `=`,
+      # including assignment and comparison operators.
+      def aligned_with_subsequent_equals_operator(token)
         subsequent_line_range = token.line.upto(processed_source.lines.length)
 
-        aligned_with_assignment(token, subsequent_line_range)
+        aligned_with_equals_sign(token, subsequent_line_range)
       end
 
       def aligned_with_adjacent_line?(range, predicate)
@@ -50,9 +59,7 @@ module RuboCop
       end
 
       def aligned_with_any_line?(line_ranges, range, indent = nil, &predicate)
-        line_ranges.any? do |line_nos|
-          aligned_with_line?(line_nos, range, indent, &predicate)
-        end
+        line_ranges.any? { |line_nos| aligned_with_line?(line_nos, range, indent, &predicate) }
       end
 
       def aligned_with_line?(line_nos, range, indent = nil)
@@ -64,7 +71,7 @@ module RuboCop
           next unless index
           next if indent && indent != index
 
-          return yield(range, line)
+          return yield(range, line, lineno + 1)
         end
         false
       end
@@ -76,50 +83,70 @@ module RuboCop
           end.map(&:line)
       end
 
-      def aligned_token?(range, line)
-        aligned_words?(range, line) ||
-          aligned_char?(range, line) ||
-          aligned_assignment?(range, line)
+      def aligned_token?(range, line, lineno)
+        aligned_words?(range, line) || aligned_equals_operator?(range, lineno)
       end
 
-      def aligned_operator?(range, line)
-        (aligned_identical?(range, line) || aligned_assignment?(range, line))
+      def aligned_operator?(range, line, lineno)
+        aligned_identical?(range, line) || aligned_equals_operator?(range, lineno)
       end
 
       def aligned_words?(range, line)
-        /\s\S/.match?(line[range.column - 1, 2])
+        left_edge = range.column
+        return true if /\s\S/.match?(line[left_edge - 1, 2])
+
+        token = range.source
+        token == line[left_edge, token.length]
+      end
+
+      def aligned_equals_operator?(range, lineno)
+        # Check that the operator is aligned with a previous assignment or comparison operator
+        # ie. an equals sign, an operator assignment (eg. `+=`), a comparison (`==`, `<=`, etc.).
+        # Since append operators (`<<`) are a type of assignment, they are allowed as well,
+        # despite not ending with a literal equals character.
+        line_range = processed_source.buffer.line_range(lineno)
+        return false unless line_range
+
+        # Find the specific token to avoid matching up to operators inside strings
+        operator_token = processed_source.tokens_within(line_range).detect do |token|
+          ASSIGNMENT_OR_COMPARISON_TOKENS.include?(token.type)
+        end
+
+        aligned_with_preceding_equals?(range, operator_token) ||
+          aligned_with_append_operator?(range, operator_token)
       end
 
-      def aligned_char?(range, line)
-        line[range.column] == range.source[0]
+      def aligned_with_preceding_equals?(range, token)
+        return false unless token
+
+        range.source[-1] == '=' && range.last_column == token.pos.last_column
       end
 
-      def aligned_assignment?(range, line)
-        range.source[-1] == '=' && line[range.last_column - 1] == '='
+      def aligned_with_append_operator?(range, token)
+        return false unless token
+
+        ((range.source == '<<' && token.equal_sign?) ||
+          (range.source[-1] == '=' && token.type == :tLSHFT)) &&
+          token && range.last_column == token.pos.last_column
       end
 
       def aligned_identical?(range, line)
         range.source == line[range.column, range.size]
       end
 
-      def aligned_with_assignment(token, line_range)
-        token_line_indent    = processed_source
-                               .line_indentation(token.line)
+      def aligned_with_equals_sign(token, line_range)
+        token_line_indent    = processed_source.line_indentation(token.line)
         assignment_lines     = relevant_assignment_lines(line_range)
         relevant_line_number = assignment_lines[1]
 
         return :none unless relevant_line_number
 
-        relevant_indent = processed_source
-                          .line_indentation(relevant_line_number)
+        relevant_indent = processed_source.line_indentation(relevant_line_number)
 
         return :none if relevant_indent < token_line_indent
+        return :none unless processed_source.lines[relevant_line_number - 1]
 
-        assignment_line = processed_source.lines[relevant_line_number - 1]
-
-        return :none unless assignment_line
-
-        aligned_assignment?(token.pos, assignment_line) ? :yes : :no
+        aligned_equals_operator?(token.pos, relevant_line_number) ? :yes : :no
       end
 
       def assignment_lines
@@ -130,10 +157,14 @@ module RuboCop
         @assignment_tokens ||= begin
           tokens = processed_source.tokens.select(&:equal_sign?)
 
-          # we don't want to operate on equals signs which are part of an
-          #   optarg in a method definition
-          # e.g.: def method(optarg = default_val); end
-          tokens = remove_optarg_equals(tokens, processed_source)
+          # We don't want to operate on equals signs which are part of an `optarg` in a
+          # method definition, or the separator of an endless method definition.
+          # For example (the equals sign to ignore is highlighted with ^):
+          #     def method(optarg = default_val); end
+          #                       ^
+          #     def method = foo
+          #                ^
+          tokens = remove_equals_in_def(tokens, processed_source)
 
           # Only attempt to align the first = on each line
           Set.new(tokens.uniq(&:line))
@@ -144,8 +175,7 @@ module RuboCop
       # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength
       def relevant_assignment_lines(line_range)
         result                        = []
-        original_line_indent          = processed_source
-                                        .line_indentation(line_range.first)
+        original_line_indent          = processed_source.line_indentation(line_range.first)
         relevant_line_indent_at_level = true
 
         line_range.each do |line_number|
@@ -161,8 +191,7 @@ module RuboCop
                                    current_line_indent == original_line_indent
 
           unless blank_line
-            relevant_line_indent_at_level = \
-              current_line_indent == original_line_indent
+            relevant_line_indent_at_level = current_line_indent == original_line_indent
           end
         end
 
@@ -171,11 +200,20 @@ module RuboCop
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
       # rubocop:enable Metrics/PerceivedComplexity, Metrics/MethodLength
 
-      def remove_optarg_equals(asgn_tokens, processed_source)
-        optargs    = processed_source.ast.each_node(:optarg)
-        optarg_eql = optargs.map { |o| o.loc.operator.begin_pos }.to_set
-        asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
+      def remove_equals_in_def(asgn_tokens, processed_source)
+        nodes = processed_source.ast.each_node(:optarg, :def)
+        eqls_to_ignore = nodes.with_object([]) do |node, arr|
+          loc = if node.def_type?
+                  node.loc.assignment if node.endless?
+                else
+                  node.loc.operator
+                end
+          arr << loc.begin_pos if loc
+        end
+
+        asgn_tokens.reject { |t| eqls_to_ignore.include?(t.begin_pos) }
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

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

@@ -15,18 +15,16 @@ module RuboCop
       end
 
       def delimiters
-        preferred_delimiters[type].split(//)
+        preferred_delimiters[type].chars
       end
 
       private
 
       def ensure_valid_preferred_delimiters
-        invalid = preferred_delimiters_config.keys -
-                  (PERCENT_LITERAL_TYPES + %w[default])
+        invalid = preferred_delimiters_config.keys - (PERCENT_LITERAL_TYPES + %w[default])
         return if invalid.empty?
 
-        raise ArgumentError,
-              "Invalid preferred delimiter config key: #{invalid.join(', ')}"
+        raise ArgumentError, "Invalid preferred delimiter config key: #{invalid.join(', ')}"
       end
 
       def preferred_delimiters
@@ -35,10 +33,9 @@ module RuboCop
             ensure_valid_preferred_delimiters
 
             if preferred_delimiters_config.key?('default')
-              Hash[PERCENT_LITERAL_TYPES.map do |type|
-                [type, preferred_delimiters_config[type] ||
-                  preferred_delimiters_config['default']]
-              end]
+              PERCENT_LITERAL_TYPES.to_h do |type|
+                [type, preferred_delimiters_config[type] || preferred_delimiters_config['default']]
+              end
             else
               preferred_delimiters_config
             end

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

@@ -4,9 +4,10 @@ module RuboCop
   module Cop
     # Methods that calculate and return Parser::Source::Ranges
     module RangeHelp
-      private
-
       BYTE_ORDER_MARK = 0xfeff # The Unicode codepoint
+      NOT_GIVEN = Module.new
+
+      private
 
       def source_range(source_buffer, line_number, column, length = 1)
         if column.is_a?(Range)
@@ -27,6 +28,24 @@ module RuboCop
         Parser::Source::Range.new(source_buffer, begin_pos, end_pos)
       end
 
+      # A range containing only the contents of a literal with delimiters (e.g. in
+      # `%i{1 2 3}` this will be the range covering `1 2 3` only).
+      def contents_range(node)
+        range_between(node.loc.begin.end_pos, node.loc.end.begin_pos)
+      end
+
+      # A range containing the first to the last argument
+      # of a method call or method definition.
+      # def foo(a, b:)
+      #         ^^^^^
+      # bar(1, 2, 3, &blk)
+      #     ^^^^^^^^^^^^^
+      # baz { |x, y:, z:| }
+      #        ^^^^^^^^^
+      def arguments_range(node)
+        node.first_argument.source_range.join(node.last_argument.source_range)
+      end
+
       def range_between(start_pos, end_pos)
         Parser::Source::Range.new(processed_source.buffer, start_pos, end_pos)
       end
@@ -45,37 +64,30 @@ module RuboCop
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
-      def range_with_surrounding_space(range:, side: :both,
-                                       newlines: true, whitespace: false,
-                                       continuations: false)
-        buffer = @processed_source.buffer
+      def range_with_surrounding_space(range_positional = NOT_GIVEN, # rubocop:disable Metrics/ParameterLists
+                                       range: NOT_GIVEN, side: :both, newlines: true,
+                                       whitespace: false, continuations: false,
+                                       buffer: @processed_source.buffer)
+        range = range_positional unless range_positional == NOT_GIVEN
+
         src = buffer.source
 
         go_left, go_right = directions(side)
 
         begin_pos = range.begin_pos
-        if go_left
-          begin_pos =
-            final_pos(src, begin_pos, -1, continuations, newlines, whitespace)
-        end
+        begin_pos = final_pos(src, begin_pos, -1, continuations, newlines, whitespace) if go_left
         end_pos = range.end_pos
-        if go_right
-          end_pos =
-            final_pos(src, end_pos, 1, continuations, newlines, whitespace)
-        end
+        end_pos = final_pos(src, end_pos, 1, continuations, newlines, whitespace) if go_right
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
-      def range_by_whole_lines(range, include_final_newline: false)
-        buffer = @processed_source.buffer
-
+      def range_by_whole_lines(range, include_final_newline: false,
+                               buffer: @processed_source.buffer)
         last_line = buffer.source_line(range.last_line)
         end_offset = last_line.length - range.last_column
         end_offset += 1 if include_final_newline
 
-        range
-          .adjust(begin_pos: -range.column, end_pos: end_offset)
-          .intersect(buffer.source_range)
+        range.adjust(begin_pos: -range.column, end_pos: end_offset).intersect(buffer.source_range)
       end
 
       def column_offset_between(base_range, range)
@@ -89,8 +101,7 @@ module RuboCop
       # line, in which case 1 is subtracted from the column value. This gives
       # the column as it appears when viewing the file in an editor.
       def effective_column(range)
-        if range.line == 1 &&
-           @processed_source.raw_source.codepoints.first == BYTE_ORDER_MARK
+        if range.line == 1 && @processed_source.raw_source.codepoints.first == BYTE_ORDER_MARK
           range.column - 1
         else
           range.column
@@ -126,6 +137,24 @@ module RuboCop
         pos += size * step while condition && src[pos + offset, size] == needle
         pos.negative? ? 0 : pos
       end
+
+      def range_with_comments_and_lines(node)
+        range_by_whole_lines(range_with_comments(node), include_final_newline: true)
+      end
+
+      def range_with_comments(node)
+        ranges = [node, *@processed_source.ast_with_comments[node]].map(&:source_range)
+        ranges.reduce do |result, range|
+          add_range(result, range)
+        end
+      end
+
+      def add_range(range1, range2)
+        range1.with(
+          begin_pos: [range1.begin_pos, range2.begin_pos].min,
+          end_pos: [range1.end_pos, range2.end_pos].max
+        )
+      end
     end
   end
 end

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

@@ -8,6 +8,7 @@ module RuboCop
 
       private
 
+      # @!method rational_literal?(node)
       def_node_matcher :rational_literal?, <<~PATTERN
         (send
           (int _) :/

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Ensure a require statement is present for a standard library determined
+    # by variable library_name
+    module RequireLibrary
+      extend NodePattern::Macros
+
+      RESTRICT_ON_SEND = [:require].freeze
+
+      def ensure_required(corrector, node, library_name)
+        node = node.parent while node.parent&.parent?
+
+        if node.parent&.begin_type?
+          return if @required_libs.include?(library_name)
+
+          remove_subsequent_requires(corrector, node, library_name)
+        end
+
+        RequireLibraryCorrector.correct(corrector, node, library_name)
+      end
+
+      def remove_subsequent_requires(corrector, node, library_name)
+        node.right_siblings.each do |sibling|
+          next unless require_library_name?(sibling, library_name)
+
+          range = range_by_whole_lines(sibling.source_range, include_final_newline: true)
+          corrector.remove(range)
+        end
+      end
+
+      def on_send(node)
+        return if node.parent&.parent?
+
+        name = require_any_library?(node)
+        return if name.nil?
+
+        @required_libs.add(name)
+      end
+
+      private
+
+      def on_new_investigation
+        # Holds the required files at top-level
+        @required_libs = Set.new
+        super
+      end
+
+      # @!method require_any_library?(node)
+      def_node_matcher :require_any_library?, <<~PATTERN
+        (send {(const {nil? cbase} :Kernel) nil?} :require (str $_))
+      PATTERN
+
+      # @!method require_library_name?(node, library_name)
+      def_node_matcher :require_library_name?, <<~PATTERN
+        (send {(const {nil? cbase} :Kernel) nil?} :require (str %1))
+      PATTERN
+    end
+  end
+end

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

@@ -4,22 +4,24 @@ module RuboCop
   module Cop
     # Common functionality for checking `rescue` nodes.
     module RescueNode
-      def on_new_investigation
-        @modifier_locations = processed_source
-                              .tokens
-                              .select(&:rescue_modifier?)
-                              .map(&:pos)
+      def modifier_locations
+        @modifier_locations ||= processed_source.tokens.select(&:rescue_modifier?).map!(&:pos)
       end
 
       private
 
       def rescue_modifier?(node)
-        node&.resbody_type? &&
-          @modifier_locations.include?(node.loc.keyword)
+        return false unless node.respond_to?(:resbody_type?)
+
+        node.resbody_type? && modifier_locations.include?(node.loc.keyword)
       end
 
       # @deprecated Use ResbodyNode#exceptions instead
       def rescued_exceptions(resbody)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `rescued_exceptions` is deprecated. Use `ResbodyNode#exceptions` instead.
+        WARNING
+
         rescue_group, = *resbody
         if rescue_group
           rescue_group.values

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

@@ -10,10 +10,14 @@ module RuboCop
 
       private
 
+      # @!method empty_condition?(node)
       def_node_matcher :empty_condition?, '(begin)'
-      def_node_matcher :setter_method?, '[(send ...) setter_method?]'
-      def_node_matcher :safe_assignment?,
-                       '(begin {equals_asgn? #setter_method?})'
+
+      # @!method setter_method?(node)
+      def_node_matcher :setter_method?, '[(call ...) setter_method?]'
+
+      # @!method safe_assignment?(node)
+      def_node_matcher :safe_assignment?, '(begin {equals_asgn? #setter_method?})'
 
       def safe_assignment_allowed?
         cop_config['AllowSafeAssignment']

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

@@ -28,17 +28,15 @@ module RuboCop
       end
 
       def space_missing?(token1, token2)
-        token1.line == token2.line &&
-          token2.column == token1.column + offset
+        same_line?(token1, token2) && token2.column == token1.column + offset
       end
 
       def space_required_before?(token)
-        !(allowed_type?(token) ||
-          (token.right_curly_brace? && space_forbidden_before_rcurly?))
+        !(allowed_type?(token) || (token.right_curly_brace? && space_forbidden_before_rcurly?))
       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?