rubocop 0.52.1 → 0.93.1

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

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

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

@@ -12,7 +12,7 @@ module RuboCop
 
       def min_body_length
         length = cop_config['MinBodyLength'] || 1
-        return length if length.is_a?(Integer) && length > 0
+        return length if length.is_a?(Integer) && length.positive?
 
         raise 'MinBodyLength needs to be a positive integer!'
       end

data/lib/rubocop/cop/mixin/{array_hash_indentation.rb → multiline_element_indentation.rb}

@@ -2,8 +2,9 @@
 
 module RuboCop
   module Cop
-    # Common code for indenting literal arrays and hashes.
-    module ArrayHashIndentation
+    # Common code for indenting the first elements in multiline
+    # array literals, hash literals, and method definitions.
+    module MultilineElementIndentation
       private
 
       def each_argument_node(node, type)

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

@@ -0,0 +1,35 @@
+# 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) do |corrector|
+              EmptyLineCorrector.insert_before(corrector, child)
+            end
+          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

@@ -5,14 +5,13 @@ module RuboCop
     # Common functionality for checking multiline method calls and binary
     # operations.
     module MultilineExpressionIndentation # rubocop:disable Metrics/ModuleLength
-      KEYWORD_ANCESTOR_TYPES  = [:for, :return, *Util::MODIFIER_NODES].freeze
+      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
+      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'.freeze
+                                'statement'
 
       def on_send(node)
         return if !node.receiver || node.method?(:[])
@@ -32,7 +31,7 @@ module RuboCop
       #   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
 
@@ -56,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']
@@ -104,7 +120,7 @@ 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: kind,
                                      article: article,
@@ -115,6 +131,7 @@ module RuboCop
         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
 
@@ -135,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
@@ -173,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
@@ -221,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,7 +3,7 @@
 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
 
@@ -24,11 +24,12 @@ module RuboCop
       #    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.comment_at_line(last_element_line)
+
+        last_element_commented && (node.chained? || node.argument?)
       end
 
       def check(node)
@@ -42,30 +43,32 @@ module RuboCop
       def check_new_line(node)
         return unless closing_brace_on_same_line?(node)
 
-        add_offense(node,
-                    location: :end,
-                    message: self.class::ALWAYS_NEW_LINE_MESSAGE)
+        add_offense(node.loc.end, message: self.class::ALWAYS_NEW_LINE_MESSAGE) do |corrector|
+          MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+        end
       end
 
       def check_same_line(node)
         return if closing_brace_on_same_line?(node)
 
-        add_offense(node,
-                    location: :end,
-                    message: self.class::ALWAYS_SAME_LINE_MESSAGE)
+        add_offense(node.loc.end, message: self.class::ALWAYS_SAME_LINE_MESSAGE) do |corrector|
+          MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+        end
       end
 
       def check_symmetrical(node)
         if opening_brace_on_same_line?(node)
           return if closing_brace_on_same_line?(node)
 
-          add_offense(node, location: :end,
-                            message: self.class::SAME_LINE_MESSAGE)
+          add_offense(node.loc.end, message: self.class::SAME_LINE_MESSAGE) do |corrector|
+            MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+          end
         else
           return unless closing_brace_on_same_line?(node)
 
-          add_offense(node, location: :end,
-                            message: self.class::NEW_LINE_MESSAGE)
+          add_offense(node.loc.end, message: self.class::NEW_LINE_MESSAGE) do |corrector|
+            MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+          end
         end
       end
 

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

@@ -8,14 +8,14 @@ module RuboCop
       extend NodePattern::Macros
 
       MSG = 'Favor `%<inverse>s` over `%<current>s` for ' \
-            'negative conditions.'.freeze
+            'negative conditions.'
 
       private
 
       def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
       def_node_matcher :empty_condition?, '(begin)'
 
-      def check_negative_conditional(node)
+      def check_negative_conditional(node, message:, &block)
         condition = node.condition
 
         return if empty_condition?(condition)
@@ -25,7 +25,7 @@ module RuboCop
         return unless single_negative?(condition)
         return if node.if_type? && node.else?
 
-        add_offense(node)
+        add_offense(node, message: message, &block)
       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

@@ -15,8 +15,13 @@ module RuboCop
         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)
@@ -37,7 +42,15 @@ module RuboCop
       end
 
       def gem_name(declaration_node)
-        declaration_node.first_argument.str_content
+        gem_node = declaration_node.first_argument
+
+        find_gem_name(gem_node)
+      end
+
+      def find_gem_name(gem_node)
+        return gem_node.str_content if gem_node.str_type?
+
+        find_gem_name(gem_node.receiver)
       end
 
       def treat_comments_as_separators

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

@@ -9,8 +9,7 @@ module RuboCop
       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]/
+        /[a-z]/.match?(source[range.begin_pos - 1]) || /[a-z]/.match?(source[range.end_pos])
       end
     end
   end

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)
@@ -28,24 +28,31 @@ module RuboCop
       end
 
       def comments_in_array?(node)
-        comments = processed_source.comments
-        array_range = node.source_range.to_a
-
-        comments.any? do |comment|
-          !(comment.loc.expression.to_a & array_range).empty?
-        end
+        line_span = node.source_range.first_line...node.source_range.last_line
+        processed_source.each_comment_in_lines(line_span).any?
       end
 
       def check_percent_array(node)
         array_style_detected(:percent, node.values.size)
-        add_offense(node) if style == :brackets
+
+        return unless style == :brackets
+
+        add_offense(node) do |corrector|
+          correct_bracketed(corrector, node)
+        end
       end
 
-      def check_bracketed_array(node)
+      def check_bracketed_array(node, literal_prefix)
         return if allowed_bracket_array?(node)
 
         array_style_detected(:brackets, node.values.size)
-        add_offense(node) if style == :percent
+
+        return unless style == :percent
+
+        add_offense(node) do |corrector|
+          percent_literal_corrector = PercentLiteralCorrector.new(@config, @preferred_delimiters)
+          percent_literal_corrector.correct(corrector, node, literal_prefix)
+        end
       end
     end
   end

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.first_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.first_line - previous_node_line_number
-          line_breaks = "\n" * number_of_line_breaks
-          previous_node_line_number = node.first_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