rubocop 1.9.1 → 1.13.0

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

@@ -31,9 +31,7 @@ module RuboCop
         max = last_by_line(children)
         return if line == max.last_line
 
-        add_offense(min) do |corrector|
-          EmptyLineCorrector.insert_before(corrector, min)
-        end
+        add_offense(min) { |corrector| EmptyLineCorrector.insert_before(corrector, min) }
       end
 
       def first_by_line(nodes)

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

@@ -11,9 +11,7 @@ module RuboCop
       FROZEN_STRING_LITERAL_TYPES = %i[str dstr].freeze
 
       def frozen_string_literal_comment_exists?
-        leading_comment_lines.any? do |line|
-          MagicComment.parse(line).valid_literal_value?
-        end
+        leading_comment_lines.any? { |line| MagicComment.parse(line).valid_literal_value? }
       end
 
       private
@@ -34,9 +32,7 @@ module RuboCop
         # And the above `ruby_version >= 3.1` is undecided whether it will be
         # Ruby 3.1, 3.2, 4.0 or others.
         # See https://bugs.ruby-lang.org/issues/8976#note-41 for details.
-        leading_comment_lines.any? do |line|
-          MagicComment.parse(line).frozen_string_literal?
-        end
+        leading_comment_lines.any? { |line| MagicComment.parse(line).frozen_string_literal? }
       end
 
       def frozen_string_literal_specified?
@@ -46,9 +42,7 @@ module RuboCop
       end
 
       def leading_comment_lines
-        first_non_comment_token = processed_source.tokens.find do |token|
-          !token.comment?
-        end
+        first_non_comment_token = processed_source.tokens.find { |token| !token.comment? }
 
         if first_non_comment_token
           # `line` is 1-indexed so we need to subtract 1 to get the array index

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

@@ -60,10 +60,8 @@ module RuboCop
 
         def deltas(first_pair, current_pair)
           key_delta = key_delta(first_pair, current_pair)
-          separator_delta = separator_delta(first_pair, current_pair,
-                                            key_delta)
-          value_delta = value_delta(first_pair, current_pair) -
-                        key_delta - separator_delta
+          separator_delta = separator_delta(first_pair, current_pair, key_delta)
+          value_delta = value_delta(first_pair, current_pair) - key_delta - separator_delta
 
           { key: key_delta, separator: separator_delta, value: value_delta }
         end
@@ -106,8 +104,7 @@ module RuboCop
         end
 
         def hash_rocket_delta(first_pair, current_pair)
-          first_pair.loc.column + max_key_width + 1 -
-            current_pair.loc.operator.column
+          first_pair.loc.column + max_key_width + 1 - current_pair.loc.operator.column
         end
 
         def value_delta(first_pair, current_pair)

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

@@ -4,11 +4,12 @@ module RuboCop
   module Cop
     # Common functionality for Style/HashTransformKeys and
     # Style/HashTransformValues
-    module HashTransformMethod # rubocop:disable Metrics/ModuleLength
+    module HashTransformMethod
       extend NodePattern::Macros
 
       RESTRICT_ON_SEND = %i[[] to_h].freeze
 
+      # @!method array_receiver?(node)
       def_node_matcher :array_receiver?, <<~PATTERN
         {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
       PATTERN
@@ -20,24 +21,18 @@ module RuboCop
 
         return if target_ruby_version < 2.6
 
-        on_bad_to_h(node) do |*match|
-          handle_possible_offense(node, match, 'to_h {...}')
-        end
+        on_bad_to_h(node) { |*match| handle_possible_offense(node, match, 'to_h {...}') }
       end
 
       def on_send(node)
         on_bad_hash_brackets_map(node) do |*match|
           handle_possible_offense(node, match, 'Hash[_.map {...}]')
         end
-        on_bad_map_to_h(node) do |*match|
-          handle_possible_offense(node, match, 'map {...}.to_h')
-        end
+        on_bad_map_to_h(node) { |*match| handle_possible_offense(node, match, 'map {...}.to_h') }
       end
 
       def on_csend(node)
-        on_bad_map_to_h(node) do |*match|
-          handle_possible_offense(node, match, 'map {...}.to_h')
-        end
+        on_bad_map_to_h(node) { |*match| handle_possible_offense(node, match, 'map {...}.to_h') }
       end
 
       private
@@ -114,10 +109,7 @@ module RuboCop
 
         captures = extract_captures(correction.match)
         correction.set_new_arg_name(captures.transformed_argname, corrector)
-        correction.set_new_body_expression(
-          captures.transforming_body_expr,
-          corrector
-        )
+        correction.set_new_body_expression(captures.transforming_body_expr, corrector)
       end
 
       # Internal helper class to hold match data
@@ -179,17 +171,11 @@ module RuboCop
         end
 
         def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(
-            block_node.arguments.loc.expression,
-            "|#{transformed_argname}|"
-          )
+          corrector.replace(block_node.arguments.loc.expression, "|#{transformed_argname}|")
         end
 
         def set_new_body_expression(transforming_body_expr, corrector)
-          corrector.replace(
-            block_node.body,
-            transforming_body_expr.loc.expression.source
-          )
+          corrector.replace(block_node.body, transforming_body_expr.loc.expression.source)
         end
       end
     end

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

@@ -15,9 +15,7 @@ module RuboCop
       alias on_regexp on_dstr
 
       def on_node_with_interpolations(node)
-        node.each_child_node(:begin) do |begin_node|
-          on_interpolation(begin_node)
-        end
+        node.each_child_node(:begin) { |begin_node| on_interpolation(begin_node) }
       end
 
       # @!method on_interpolation(begin_node)

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

@@ -16,7 +16,7 @@ module RuboCop
 
         return false unless comment
 
-        comment.text.match?(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
+        !!DirectiveComment.new(comment).match_captures
       end
 
       def allow_uri?
@@ -24,9 +24,7 @@ module RuboCop
       end
 
       def allowed_uri_position?(line, uri_range)
-        uri_range.begin < max_line_length &&
-          (uri_range.end == line_length(line) ||
-           uri_range.end == line_length(line) - 1)
+        uri_range.begin < max_line_length && uri_range.end == line_length(line)
       end
 
       def line_length(line)
@@ -40,8 +38,15 @@ module RuboCop
         begin_position, end_position = last_uri_match.offset(0).map do |pos|
           pos + indentation_difference(line)
         end
-        return nil if begin_position < max_line_length &&
-                      end_position < max_line_length
+
+        # Extend the end position until the start of the next word, if any.
+        # This allows for URIs that are wrapped in quotes or parens to be handled properly
+        # while not allowing additional words to be added after the URL.
+        if (match = line[end_position..line_length(line)]&.match(/^\S+(?=\s|$)/))
+          end_position += match.offset(0).last
+        end
+
+        return nil if begin_position < max_line_length && end_position < max_line_length
 
         begin_position...end_position
       end
@@ -67,8 +72,7 @@ module RuboCop
 
       def uri_regexp
         @uri_regexp ||=
-          URI::DEFAULT_PARSER
-          .make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
+          URI::DEFAULT_PARSER.make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
       end
 
       def valid_uri?(uri_ish_string)
@@ -79,8 +83,7 @@ module RuboCop
       end
 
       def line_length_without_directive(line)
-        before_comment, = line.split(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-        before_comment.rstrip.length
+        DirectiveComment.before_comment(line).rstrip.length
       end
     end
   end

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

@@ -11,15 +11,12 @@ module RuboCop
       # Return a new `Range` covering the first matching group number for each
       # match of `regex` inside `range`
       def each_match_range(range, regex)
-        range.source.scan(regex) do
-          yield match_range(range, Regexp.last_match)
-        end
+        range.source.scan(regex) { yield match_range(range, Regexp.last_match) }
       end
 
       # For a `match` inside `range`, return a new `Range` covering the match
       def match_range(range, match)
-        range_between(range.begin_pos + match.begin(1),
-                      range.begin_pos + match.end(1))
+        range_between(range.begin_pos + match.begin(1), range.begin_pos + match.end(1))
       end
     end
   end

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

@@ -36,6 +36,7 @@ module RuboCop
 
       private
 
+      # @!method define_method?(node)
       def_node_matcher :define_method?, <<~PATTERN
         (block
          (send nil? :define_method ({sym str} $_))
@@ -59,9 +60,7 @@ module RuboCop
                      abc_vector: abc_vector,
                      max: max)
 
-        add_offense(node, message: msg) do
-          self.max = complexity.ceil
-        end
+        add_offense(node, message: msg) { self.max = complexity.ceil }
       end
 
       def complexity(body)

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

@@ -18,8 +18,7 @@ module RuboCop
             default = default_cop_config['PreferredMethods']
             merged = cop_config['PreferredMethods']
             overrides = merged.values - default.values
-            merged.reject { |key, _| overrides.include?(key) }
-                  .map { |k, v| [k.to_sym, v] }.to_h
+            merged.reject { |key, _| overrides.include?(key) }.transform_keys(&:to_sym)
           end
       end
 

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

@@ -28,8 +28,7 @@ module RuboCop
         expected_column = base_column(left_brace, left_parenthesis) +
                           configured_indentation_width + offset
         @column_delta = expected_column - actual_column
-        styles =
-          detected_styles(actual_column, offset, left_parenthesis, left_brace)
+        styles = detected_styles(actual_column, offset, left_parenthesis, left_brace)
 
         if @column_delta.zero?
           check_expected_style(styles)
@@ -77,7 +76,9 @@ module RuboCop
       def incorrect_style_detected(styles, first, left_parenthesis)
         msg = message(base_description(left_parenthesis))
 
-        add_offense(first, message: msg) do
+        add_offense(first, message: msg) do |corrector|
+          autocorrect(corrector, first)
+
           ambiguous_style_detected(*styles)
         end
       end

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

@@ -16,9 +16,7 @@ module RuboCop
         last_seen_line = -1
         children.each do |child|
           if last_seen_line >= child.first_line
-            add_offense(child) do |corrector|
-              EmptyLineCorrector.insert_before(corrector, child)
-            end
+            add_offense(child) { |corrector| EmptyLineCorrector.insert_before(corrector, child) }
           else
             last_seen_line = child.last_line
           end

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

@@ -6,12 +6,10 @@ module RuboCop
     # operations.
     module MultilineExpressionIndentation # rubocop:disable Metrics/ModuleLength
       KEYWORD_ANCESTOR_TYPES  = %i[for if while until return].freeze
-      UNALIGNED_RHS_TYPES     = %i[if while until for return
-                                   array kwbegin].freeze
+      UNALIGNED_RHS_TYPES     = %i[if while until for return array kwbegin].freeze
       DEFAULT_MESSAGE_TAIL    = 'an expression'
       ASSIGNMENT_MESSAGE_TAIL = 'an expression in an assignment'
-      KEYWORD_MESSAGE_TAIL    = 'a %<kind>s in %<article>s `%<keyword>s` ' \
-                                'statement'
+      KEYWORD_MESSAGE_TAIL    = 'a %<kind>s in %<article>s `%<keyword>s` statement'
 
       def on_send(node)
         return if !node.receiver || node.method?(:[])
@@ -35,26 +33,6 @@ module RuboCop
         lhs
       end
 
-      def right_hand_side(send_node)
-        if send_node.operator_method? && send_node.arguments?
-          send_node.first_argument.source_range # not used for method calls
-        else
-          regular_method_right_hand_side(send_node)
-        end
-      end
-
-      def regular_method_right_hand_side(send_node)
-        dot = send_node.loc.dot
-        selector = send_node.loc.selector
-        if send_node.dot? && selector && dot.line == selector.line
-          dot.join(selector)
-        elsif selector
-          selector
-        elsif send_node.implicit_call?
-          dot.join(send_node.loc.begin)
-        end
-      end
-
       # The correct indentation of `node` is usually `IndentationWidth`, with
       # one exception: prefix keywords.
       #
@@ -75,8 +53,7 @@ module RuboCop
         kw_node = kw_node_with_special_indentation(node)
         if kw_node && !postfix_conditional?(kw_node)
           # This cop could have its own IndentationWidth configuration
-          configured_indentation_width +
-            @config.for_cop('Layout/IndentationWidth')['Width']
+          configured_indentation_width + @config.for_cop('Layout/IndentationWidth')['Width']
         else
           configured_indentation_width
         end
@@ -91,9 +68,10 @@ module RuboCop
       end
 
       def incorrect_style_detected(range, node, lhs, rhs)
-        add_offense(range, location: range, message: message(node, lhs, rhs)) do
-          if supported_styles.size > 2 ||
-             offending_range(node, lhs, rhs, alternative_style)
+        add_offense(range, message: message(node, lhs, rhs)) do |corrector|
+          autocorrect(corrector, range)
+
+          if supported_styles.size > 2 || offending_range(node, lhs, rhs, alternative_style)
             unrecognized_style_detected
           else
             opposite_style_detected
@@ -110,9 +88,7 @@ module RuboCop
           return keyword_message_tail(ancestor)
         end
 
-        part_of_assignment_rhs(node, rhs) do |_node|
-          return ASSIGNMENT_MESSAGE_TAIL
-        end
+        part_of_assignment_rhs(node, rhs) { |_node| return ASSIGNMENT_MESSAGE_TAIL }
 
         DEFAULT_MESSAGE_TAIL
       end
@@ -122,9 +98,7 @@ module RuboCop
         kind    = keyword == 'for' ? 'collection' : 'condition'
         article = keyword.start_with?('i', 'u') ? 'an' : 'a'
 
-        format(KEYWORD_MESSAGE_TAIL, kind: kind,
-                                     article: article,
-                                     keyword: keyword)
+        format(KEYWORD_MESSAGE_TAIL, kind: kind, article: article, keyword: keyword)
       end
 
       def kw_node_with_special_indentation(node)
@@ -162,9 +136,7 @@ module RuboCop
           next unless kind == :with_or_without_parentheses ||
                       kind == :with_parentheses && parentheses?(a)
 
-          a.arguments.any? do |arg|
-            within_node?(node, arg)
-          end
+          a.arguments.any? { |arg| within_node?(node, arg) }
         end
       end
 
@@ -199,8 +171,7 @@ module RuboCop
 
       # The []= operator and setters (a.b = c) are parsed as :send nodes.
       def valid_method_rhs_candidate?(candidate, node)
-        node.setter_method? &&
-          valid_rhs_candidate?(candidate, node.last_argument)
+        node.setter_method? && valid_rhs_candidate?(candidate, node.last_argument)
       end
 
       def valid_rhs_candidate?(candidate, node)

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

@@ -24,8 +24,7 @@ module RuboCop
       #    b # comment
       #   ].some_method
       def new_line_needed_before_closing_brace?(node)
-        last_element_line =
-          last_element_range_with_trailing_comma(node).last_line
+        last_element_line = last_element_range_with_trailing_comma(node).last_line
 
         last_element_commented = processed_source.comment_at_line(last_element_line)
 

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

@@ -7,12 +7,14 @@ module RuboCop
     module NegativeConditional
       extend NodePattern::Macros
 
-      MSG = 'Favor `%<inverse>s` over `%<current>s` for ' \
-            'negative conditions.'
+      MSG = 'Favor `%<inverse>s` over `%<current>s` for negative conditions.'
 
       private
 
+      # @!method single_negative?(node)
       def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
+
+      # @!method empty_condition?(node)
       def_node_matcher :empty_condition?, '(begin)'
 
       def check_negative_conditional(node, message:, &block)

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

@@ -25,10 +25,7 @@ module RuboCop
       end
 
       def consecutive_lines(previous, current)
-        first_line = get_source_range(
-          current,
-          treat_comments_as_separators
-        ).first_line
+        first_line = get_source_range(current, treat_comments_as_separators).first_line
         previous.source_range.last_line == first_line - 1
       end
 

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

@@ -37,9 +37,7 @@ module RuboCop
 
         return unless style == :brackets
 
-        add_offense(node) do |corrector|
-          correct_bracketed(corrector, node)
-        end
+        add_offense(node) { |corrector| correct_bracketed(corrector, node) }
       end
 
       def check_bracketed_array(node, literal_prefix)