rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# TEAM: backend_infra
+# WATCHERS: maxh
+
+module RuboCop
+  module Cop
+    # Common functionality for checking for a line break before each
+    # element in a multi-line collection.
+    module MultilineElementLineBreaks
+      private
+
+      def check_line_breaks(_node, children)
+        return if all_on_same_line?(children)
+
+        last_seen_line = -1
+        children.each do |child|
+          if last_seen_line >= child.first_line
+            add_offense(child)
+          else
+            last_seen_line = child.last_line
+          end
+        end
+      end
+
+      def all_on_same_line?(nodes)
+        return true if nodes.empty?
+
+        nodes.first.first_line == nodes.last.last_line
+      end
+    end
+  end
+end

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

@@ -4,14 +4,14 @@ module RuboCop
   module Cop
     # Common functionality for checking multiline method calls and binary
     # operations.
-    module MultilineExpressionIndentation
-      KEYWORD_ANCESTOR_TYPES  = [:for, :return, *Util::MODIFIER_NODES].freeze
+    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
-      ASSIGNMENT_RHS_TYPES    = [:send, *Util::ASGN_NODES].freeze
-      DEFAULT_MESSAGE_TAIL    = 'an expression'.freeze
-      ASSIGNMENT_MESSAGE_TAIL = 'an expression in an assignment'.freeze
-      KEYWORD_MESSAGE_TAIL    = 'a %s in %s `%s` statement'.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'
 
       def on_send(node)
         return if !node.receiver || node.method?(:[])
@@ -23,13 +23,15 @@ module RuboCop
         check(range, node, lhs, rhs)
       end
 
+      private
+
       # In a chain of method calls, we regard the top send node as the base
       # for indentation of all lines following the first. For example:
       # a.
       #   b c { block }.            <-- b is indented relative to a
       #   d                         <-- d is indented relative to a
       def left_hand_side(lhs)
-        lhs = lhs.parent while lhs.parent && lhs.parent.send_type?
+        lhs = lhs.parent while lhs.parent&.send_type?
         lhs
       end
 
@@ -53,8 +55,25 @@ module RuboCop
         end
       end
 
+      # The correct indentation of `node` is usually `IndentationWidth`, with
+      # one exception: prefix keywords.
+      #
+      # ```
+      # while foo &&  # Here, `while` is called a "prefix keyword"
+      #     bar       # This is called "special indentation"
+      #   baz
+      # end
+      # ```
+      #
+      # Note that *postfix conditionals* do *not* get "special indentation".
+      #
+      # ```
+      # next if foo &&
+      #   bar # normal indentation, not special
+      # ```
       def correct_indentation(node)
-        if kw_node_with_special_indentation(node)
+        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']
@@ -101,14 +120,18 @@ module RuboCop
       def keyword_message_tail(node)
         keyword = node.loc.keyword.source
         kind    = keyword == 'for' ? 'collection' : 'condition'
-        article = keyword =~ /^[iu]/ ? 'an' : 'a'
+        article = keyword.start_with?('i', 'u') ? 'an' : 'a'
 
-        format(KEYWORD_MESSAGE_TAIL, kind, article, keyword)
+        format(KEYWORD_MESSAGE_TAIL, kind: kind,
+                                     article: article,
+                                     keyword: keyword)
       end
 
       def kw_node_with_special_indentation(node)
         keyword_node =
           node.each_ancestor(*KEYWORD_ANCESTOR_TYPES).find do |ancestor|
+            next if ancestor.if_type? && ancestor.ternary?
+
             within_node?(node, indented_keyword_expression(ancestor))
           end
 
@@ -129,18 +152,18 @@ module RuboCop
         expression
       end
 
-      def argument_in_method_call(node, kind)
+      def argument_in_method_call(node, kind) # rubocop:todo Metrics/CyclomaticComplexity
         node.each_ancestor(:send, :block).find do |a|
           # If the node is inside a block, it makes no difference if that block
           # is an argument in a method call. It doesn't count.
           break false if a.block_type?
 
           next if a.setter_method?
+          next unless kind == :with_or_without_parentheses ||
+                      kind == :with_parentheses && parentheses?(a)
 
           a.arguments.any? do |arg|
-            within_node?(node, arg) && (kind == :with_or_without_parentheses ||
-                                        kind == :with_parentheses &&
-                                        parentheses?(node.parent))
+            within_node?(node, arg)
           end
         end
       end
@@ -167,7 +190,7 @@ module RuboCop
       def valid_rhs?(candidate, ancestor)
         if ancestor.send_type?
           valid_method_rhs_candidate?(candidate, ancestor)
-        elsif Util::ASGN_NODES.include?(ancestor.type)
+        elsif ancestor.assignment?
           valid_rhs_candidate?(candidate, assignment_rhs(ancestor))
         else
           false
@@ -215,6 +238,18 @@ module RuboCop
         node.source_range.begin_pos > ancestor.loc.begin.begin_pos &&
           node.source_range.end_pos < ancestor.loc.end.end_pos
       end
+
+      # Returns true if `node` is a conditional whose `body` and `condition`
+      # begin on the same line.
+      def postfix_conditional?(node)
+        node.if_type? && node.modifier_form?
+      end
+
+      def within_node?(inner, outer)
+        o = outer.is_a?(AST::Node) ? outer.source_range : outer
+        i = inner.is_a?(AST::Node) ? inner.source_range : inner
+        i.begin_pos >= o.begin_pos && i.end_pos <= o.end_pos
+      end
     end
   end
 end

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

@@ -3,10 +3,12 @@
 module RuboCop
   module Cop
     # Common functionality for checking the closing brace of a literal is
-    # either on the same line as the last contained elements, or a new line.
+    # either on the same line as the last contained elements or a new line.
     module MultilineLiteralBraceLayout
       include ConfigurableEnforcedStyle
 
+      private
+
       def check_brace_layout(node)
         return if ignored_literal?(node)
 
@@ -17,40 +19,18 @@ module RuboCop
         check(node)
       end
 
-      def autocorrect(node)
-        if closing_brace_on_same_line?(node)
-          lambda do |corrector|
-            corrector.insert_before(node.loc.end, "\n".freeze)
-          end
-        else
-          # When a comment immediately before the closing brace gets in the way
-          # of an easy correction, the offense is reported but not auto-
-          # corrected. The user must handle the delicate decision of where to
-          # put the comment.
-          return if new_line_needed_before_closing_brace?(node)
-
-          lambda do |corrector|
-            corrector.remove(range_with_surrounding_space(node.loc.end,
-                                                          :left))
-
-            corrector.insert_after(last_element_range_with_trailing_comma(node),
-                                   node.loc.end.source)
-          end
-        end
-      end
-
-      private
-
       # Returns true for the case
       #   [a,
       #    b # comment
       #   ].some_method
       def new_line_needed_before_closing_brace?(node)
-        return unless node.chained?
-
         last_element_line =
           last_element_range_with_trailing_comma(node).last_line
-        processed_source.comments.any? { |c| c.loc.line == last_element_line }
+
+        last_element_commented =
+          processed_source.comments.any? { |c| c.loc.line == last_element_line }
+
+        last_element_commented && (node.chained? || node.argument?)
       end
 
       def check(node)
@@ -91,31 +71,16 @@ module RuboCop
         end
       end
 
-      def ignored_literal?(node)
-        implicit_literal?(node) || empty_literal?(node) || node.single_line?
-      end
-
-      def implicit_literal?(node)
-        !node.loc.begin
-      end
-
       def empty_literal?(node)
         children(node).empty?
       end
 
-      def last_element_range_with_trailing_comma(node)
-        trailing_comma_range = last_element_trailing_comma_range(node)
-        if trailing_comma_range
-          children(node).last.source_range.join(trailing_comma_range)
-        else
-          children(node).last.source_range
-        end
+      def implicit_literal?(node)
+        !node.loc.begin
       end
 
-      def last_element_trailing_comma_range(node)
-        range = range_with_surrounding_space(children(node).last.source_range,
-                                             :right).end.resize(1)
-        range.source == ',' ? range : nil
+      def ignored_literal?(node)
+        implicit_literal?(node) || empty_literal?(node) || node.single_line?
       end
 
       def children(node)
@@ -125,13 +90,13 @@ module RuboCop
       # This method depends on the fact that we have guarded
       # against implicit and empty literals.
       def opening_brace_on_same_line?(node)
-        node.loc.begin.line == children(node).first.loc.first_line
+        node.loc.begin.line == children(node).first.first_line
       end
 
       # This method depends on the fact that we have guarded
       # against implicit and empty literals.
       def closing_brace_on_same_line?(node)
-        node.loc.end.line == children(node).last.loc.last_line
+        node.loc.end.line == children(node).last.last_line
       end
 
       # Starting with the parent node and recursively for the parent node's
@@ -163,7 +128,7 @@ module RuboCop
 
         if node.respond_to?(:loc) &&
            node.loc.respond_to?(:heredoc_end) &&
-           node.loc.heredoc_end.last_line >= parent.loc.last_line
+           node.loc.heredoc_end.last_line >= parent.last_line
           return true
         end
 

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

@@ -7,6 +7,11 @@ module RuboCop
     module NegativeConditional
       extend NodePattern::Macros
 
+      MSG = 'Favor `%<inverse>s` over `%<current>s` for ' \
+            'negative conditions.'
+
+      private
+
       def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
       def_node_matcher :empty_condition?, '(begin)'
 
@@ -22,22 +27,6 @@ module RuboCop
 
         add_offense(node)
       end
-
-      def negative_conditional_corrector(node)
-        condition = negated_condition(node)
-
-        lambda do |corrector|
-          corrector.replace(node.loc.keyword, node.inverse_keyword)
-          corrector.replace(condition.source_range,
-                            condition.children.first.source)
-        end
-      end
-
-      def negated_condition(node)
-        condition = node.condition
-        condition = condition.children.first while condition.begin_type?
-        condition
-      end
     end
   end
 end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module provides a list of methods that are:
+    # 1. In the NilClass by default
+    # 2. Added to NilClass by explicitly requiring any standard libraries
+    # 3. Cop's configuration parameter AllowedMethods.
+    module NilMethods
+      include AllowedMethods
+
+      private
+
+      def nil_methods
+        nil.methods + other_stdlib_methods + allowed_methods.map(&:to_sym)
+      end
+
+      def other_stdlib_methods
+        [:to_d]
+      end
+    end
+  end
+end

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

@@ -7,56 +7,54 @@ module RuboCop
     module OrderedGemNode
       private
 
+      def get_source_range(node, comments_as_separators)
+        unless comments_as_separators
+          first_comment = processed_source.ast_with_comments[node].first
+          return first_comment.loc.expression unless first_comment.nil?
+        end
+        node.source_range
+      end
+
+      def gem_canonical_name(name)
+        name = name.tr('-_', '') unless cop_config['ConsiderPunctuation']
+        name.downcase
+      end
+
       def case_insensitive_out_of_order?(string_a, string_b)
-        string_a.downcase < string_b.downcase
+        gem_canonical_name(string_a) < gem_canonical_name(string_b)
       end
 
       def consecutive_lines(previous, current)
-        first_line = get_source_range(current).first_line
+        first_line = get_source_range(
+          current,
+          treat_comments_as_separators
+        ).first_line
         previous.source_range.last_line == first_line - 1
       end
 
       def register_offense(previous, current)
-        message = format(self.class::MSG, gem_name(current), gem_name(previous))
+        message = format(
+          self.class::MSG,
+          previous: gem_name(current),
+          current: gem_name(previous)
+        )
         add_offense(current, message: message)
       end
 
       def gem_name(declaration_node)
-        declaration_node.first_argument.str_content
-      end
+        gem_node = declaration_node.first_argument
 
-      def autocorrect(node)
-        previous = previous_declaration(node)
-
-        current_range = declaration_with_comment(node)
-        previous_range = declaration_with_comment(previous)
-
-        lambda do |corrector|
-          swap_range(corrector, current_range, previous_range)
-        end
+        find_gem_name(gem_node)
       end
 
-      def declaration_with_comment(node)
-        buffer = processed_source.buffer
-        begin_pos = get_source_range(node).begin_pos
-        end_line = buffer.line_for_position(node.loc.expression.end_pos)
-        end_pos = buffer.line_range(end_line).end_pos
-        Parser::Source::Range.new(buffer, begin_pos, end_pos)
-      end
+      def find_gem_name(gem_node)
+        return gem_node.str_content if gem_node.str_type?
 
-      def swap_range(corrector, range1, range2)
-        src1 = range1.source
-        src2 = range2.source
-        corrector.replace(range1, src2)
-        corrector.replace(range2, src1)
+        find_gem_name(gem_node.receiver)
       end
 
-      def get_source_range(node)
-        unless cop_config['TreatCommentsAsGroupSeparators']
-          first_comment = processed_source.ast_with_comments[node].first
-          return first_comment.loc.expression unless first_comment.nil?
-        end
-        node.source_range
+      def treat_comments_as_separators
+        cop_config['TreatCommentsAsGroupSeparators']
       end
     end
   end

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

@@ -4,18 +4,12 @@ module RuboCop
   module Cop
     # Common functionality for handling parentheses.
     module Parentheses
+      private
+
       def parens_required?(node)
         range  = node.source_range
         source = range.source_buffer.source
-        source[range.begin_pos - 1] =~ /[a-z]/ ||
-          source[range.end_pos] =~ /[a-z]/
-      end
-
-      def autocorrect(node)
-        lambda do |corrector|
-          corrector.remove(node.loc.begin)
-          corrector.remove(node.loc.end)
-        end
+        /[a-z]/.match?(source[range.begin_pos - 1]) || /[a-z]/.match?(source[range.end_pos])
       end
     end
   end

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

@@ -26,7 +26,7 @@ module RuboCop
                       d.message.capitalize
                     end
 
-          add_offense(nil,
+          add_offense(find_offense_node_by(d),
                       location: d.location,
                       message: message,
                       severity: d.level)

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

@@ -14,8 +14,8 @@ module RuboCop
       def invalid_percent_array_context?(node)
         parent = node.parent
 
-        parent && parent.send_type? && parent.arguments.include?(node) &&
-          !parent.parenthesized? && parent.block_literal?
+        parent&.send_type? && parent.arguments.include?(node) &&
+          !parent.parenthesized? && parent&.block_literal?
       end
 
       def allowed_bracket_array?(node)

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

@@ -4,17 +4,19 @@ module RuboCop
   module Cop
     # Common functionality for handling percent literals.
     module PercentLiteral
-      PERCENT_LITERAL_TYPES = %w[% %i %I %q %Q %r %s %w %W %x].freeze
+      include RangeHelp
 
       private
 
       def percent_literal?(node)
         return unless (begin_source = begin_source(node))
+
         begin_source.start_with?('%')
       end
 
       def process(node, *types)
         return unless percent_literal?(node) && types.include?(type(node))
+
         on_percent_literal(node)
       end
 
@@ -31,70 +33,6 @@ module RuboCop
       def contents_range(node)
         range_between(node.loc.begin.end_pos, node.loc.end.begin_pos)
       end
-
-      # ['a', 'b', 'c'] => %w(a b c)
-      def correct_percent(node, char)
-        words = node.children
-        escape = words.any? { |w| needs_escaping?(w.children[0]) }
-        char = char.upcase if escape
-        delimiters = preferred_delimiters_for("%#{char}")
-        contents = autocorrect_words(words, escape, node.loc.line, delimiters)
-
-        lambda do |corrector|
-          corrector.replace(
-            node.source_range,
-            "%#{char}#{delimiters[0]}#{contents}#{delimiters[1]}"
-          )
-        end
-      end
-
-      def autocorrect_words(word_nodes, escape, base_line_number, delimiters)
-        previous_node_line_number = base_line_number
-        word_nodes.map do |node|
-          number_of_line_breaks = node.loc.line - previous_node_line_number
-          line_breaks = "\n" * number_of_line_breaks
-          previous_node_line_number = node.loc.line
-          content = node.children.first.to_s
-          content = escape ? escape_string(content) : content
-          delimiters.each do |delimiter|
-            content.gsub!(delimiter, "\\#{delimiter}")
-          end
-          line_breaks + content
-        end.join(' ')
-      end
-
-      def ensure_valid_preferred_delimiters
-        invalid = preferred_delimiters_config.keys -
-                  (PERCENT_LITERAL_TYPES + %w[default])
-        return if invalid.empty?
-
-        raise ArgumentError,
-              "Invalid preferred delimiter config key: #{invalid.join(', ')}"
-      end
-
-      def preferred_delimiters
-        @preferred_delimiters ||=
-          begin
-            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]
-            else
-              preferred_delimiters_config
-            end
-          end
-      end
-
-      def preferred_delimiters_config
-        @config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']
-      end
-
-      def preferred_delimiters_for(type)
-        preferred_delimiters[type].split(//)
-      end
     end
   end
 end