rubocop 1.39.0 → 1.44.1

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of `max` or `min` instead of comparison for greater or less.
+      #
+      # NOTE: It can be used if you want to present limit or threshold in Ruby 2.7+.
+      # That it is slow though. So autocorrection will apply generic `max` or `min`:
+      #
+      # [source,ruby]
+      # ----
+      # a.clamp(b..) # Same as `[a, b].max`
+      # a.clamp(..b) # Same as `[a, b].min`
+      # ----
+      #
+      # @safety
+      #   This cop is unsafe because even if a value has `<` or `>` method,
+      #   it is not necessarily `Comparable`.
+      #
+      # @example
+      #
+      #   # bad
+      #   a > b ? a : b
+      #   a >= b ? a : b
+      #
+      #   # good
+      #   [a, b].max
+      #
+      #   # bad
+      #   a < b ? a : b
+      #   a <= b ? a : b
+      #
+      #   # good
+      #   [a, b].min
+      #
+      class MinMaxComparison < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `%<prefer>s` instead.'
+        GRATER_OPERATORS = %i[> >=].freeze
+        LESS_OPERATORS = %i[< <=].freeze
+        COMPARISON_OPERATORS = GRATER_OPERATORS + LESS_OPERATORS
+
+        def on_if(node)
+          lhs, operator, rhs = *node.condition
+          return unless COMPARISON_OPERATORS.include?(operator)
+
+          if_branch = node.if_branch
+          else_branch = node.else_branch
+          preferred_method = preferred_method(operator, lhs, rhs, if_branch, else_branch)
+          return unless preferred_method
+
+          replacement = "[#{lhs.source}, #{rhs.source}].#{preferred_method}"
+
+          add_offense(node, message: format(MSG, prefer: replacement)) do |corrector|
+            autocorrect(corrector, node, replacement)
+          end
+        end
+
+        private
+
+        def preferred_method(operator, lhs, rhs, if_branch, else_branch)
+          if lhs == if_branch && rhs == else_branch
+            GRATER_OPERATORS.include?(operator) ? 'max' : 'min'
+          elsif lhs == else_branch && rhs == if_branch
+            LESS_OPERATORS.include?(operator) ? 'max' : 'min'
+          end
+        end
+
+        def autocorrect(corrector, node, replacement)
+          if node.elsif?
+            corrector.remove(range_between(node.parent.loc.else.begin_pos, node.loc.else.begin_pos))
+            corrector.replace(node.else_branch, replacement)
+          else
+            corrector.replace(node, replacement)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -99,6 +99,7 @@ module RuboCop
       class MissingElse < Base
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = '`%<type>s` condition requires an `else`-clause.'
         MSG_NIL = '`%<type>s` condition requires an `else`-clause with `nil` in it.'
@@ -126,7 +127,9 @@ module RuboCop
         def check(node)
           return if node.else?
 
-          add_offense(node, message: format(message_template, type: node.type))
+          add_offense(node, message: format(message_template, type: node.type)) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def message_template
@@ -140,6 +143,15 @@ module RuboCop
           end
         end
 
+        def autocorrect(corrector, node)
+          case empty_else_style
+          when :empty
+            corrector.insert_before(node.loc.end, 'else; nil; ')
+          when :nil
+            corrector.insert_before(node.loc.end, 'else; ')
+          end
+        end
+
         def if_style?
           style == :if
         end

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

@@ -40,10 +40,6 @@ module RuboCop
           [condition, indented_body, indented_end].join("\n")
         end
 
-        def configured_indentation_width
-          super || 2
-        end
-
         def indented_body(body, node)
           body_source = "#{offset(node)}#{body.source}"
           body_source.each_line.map do |line|

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

@@ -31,6 +31,7 @@ module RuboCop
       #     baz
       #   )
       class MultilineMemoization < Base
+        include Alignment
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
@@ -75,11 +76,10 @@ module RuboCop
         end
 
         def keyword_begin_str(node, node_buf)
-          indent = config.for_cop('Layout/IndentationWidth')['Width'] || 2
           if node_buf.source[node.loc.begin.end_pos] == "\n"
             'begin'
           else
-            "begin\n#{' ' * (node.loc.column + indent)}"
+            "begin\n#{' ' * (node.loc.column + configured_indentation_width)}"
           end
         end
 

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

@@ -103,11 +103,7 @@ module RuboCop
           if node.if_branch.nil?
             corrector.remove(range_by_whole_lines(node.loc.else, include_final_newline: true))
           else
-            if_range = if_range(node)
-            else_range = else_range(node)
-
-            corrector.replace(if_range, else_range.source)
-            corrector.replace(else_range, if_range.source)
+            corrector.swap(if_range(node), else_range(node))
           end
         end
 

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

@@ -44,7 +44,7 @@ module RuboCop
         PATTERN
 
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
-          return unless node.lambda? || node.proc?
+          return unless node.lambda_or_proc?
           return unless nil_return?(node.body)
 
           message = format(MSG, type: node.lambda? ? 'lambda' : 'proc')

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

@@ -31,6 +31,7 @@ module RuboCop
       #     baz
       #   end
       class OneLineConditional < Base
+        include Alignment
         include ConfigurableEnforcedStyle
         include OnNormalIfUnless
         extend AutoCorrector
@@ -57,7 +58,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           if always_multiline? || cannot_replace_to_ternary?(node)
-            IfThenCorrector.new(node, indentation: indentation_width).call(corrector)
+            IfThenCorrector.new(node, indentation: configured_indentation_width).call(corrector)
           else
             corrector.replace(node, ternary_correction(node))
           end
@@ -67,7 +68,7 @@ module RuboCop
           replaced_node = ternary_replacement(node)
 
           return replaced_node unless node.parent
-          return "(#{replaced_node})" if %i[and or].include?(node.parent.type)
+          return "(#{replaced_node})" if node.parent.operator_keyword?
           return "(#{replaced_node})" if node.parent.send_type? && node.parent.operator_method?
 
           replaced_node
@@ -116,10 +117,6 @@ module RuboCop
 
           node.respond_to?(:arguments?) && node.arguments? && !node.parenthesized_call?
         end
-
-        def indentation_width
-          @config.for_cop('Layout/IndentationWidth')['Width']
-        end
       end
     end
   end

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

@@ -28,7 +28,7 @@ module RuboCop
           return if node.receiver.const_type?
 
           _lhs, _op, rhs = *node
-          return if rhs.nil? || rhs.children.first
+          return if !rhs || method_call_with_parenthesized_arg?(rhs) || anonymous_forwarding?(rhs)
 
           add_offense(dot) do |corrector|
             wrap_in_parentheses_if_chained(corrector, node)
@@ -38,6 +38,20 @@ module RuboCop
 
         private
 
+        # Checks for an acceptable case of `foo.+(bar).baz`.
+        def method_call_with_parenthesized_arg?(argument)
+          return false unless argument.parent.parent&.send_type?
+
+          argument.children.first && argument.parent.parenthesized?
+        end
+
+        def anonymous_forwarding?(argument)
+          return true if argument.forwarded_args_type? || argument.forwarded_restarg_type?
+          return true if argument.hash_type? && argument.children.first&.forwarded_kwrestarg_type?
+
+          argument.block_pass_type? && argument.source == '&'
+        end
+
         def wrap_in_parentheses_if_chained(corrector, node)
           return unless node.parent&.call_type?
 

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

@@ -172,7 +172,9 @@ module RuboCop
         end
 
         def modifier_statement?(node)
-          node && %i[if while until].include?(node.type) && node.modifier_form?
+          return false unless node
+
+          node.basic_conditional? && node.modifier_form?
         end
 
         # An internal class for correcting parallel assignment

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

@@ -13,6 +13,7 @@ module RuboCop
       # ----
       # Methods:
       #   join: ''
+      #   sum: 0
       #   split: ' '
       #   chomp: "\n"
       #   chomp!: "\n"
@@ -33,6 +34,7 @@ module RuboCop
       #   # bad
       #   array.join('')
       #   [1, 2, 3].join("")
+      #   array.sum(0)
       #   string.split(" ")
       #   "first\nsecond".split(" ")
       #   string.chomp("\n")
@@ -42,6 +44,7 @@ module RuboCop
       #   # good
       #   array.join
       #   [1, 2, 3].join
+      #   array.sum
       #   string.split
       #   "first second".split
       #   string.chomp

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

@@ -86,10 +86,6 @@ module RuboCop
         def indented_else_node(expression, node)
           "else\n#{indentation(node)}#{expression}"
         end
-
-        def configured_indentation_width
-          super || 2
-        end
       end
     end
   end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Avoid redundant `::` prefix on constant.
+      #
+      # How Ruby searches constant is a bit complicated, and it can often be difficult to
+      # understand from the code whether the `::` is intended or not. Where `Module.nesting`
+      # is empty, there is no need to prepend `::`, so it would be nice to consistently
+      # avoid such meaningless `::` prefix to avoid confusion.
+      #
+      # NOTE: This cop is disabled if `Lint/ConstantResolution` cop is enabled to prevent
+      # conflicting rules. Because it respects user configurations that want to enable
+      # `Lint/ConstantResolution` cop which is disabled by default.
+      #
+      # @example
+      #   # bad
+      #   ::Const
+      #
+      #   # good
+      #   Const
+      #
+      #   # bad
+      #   class << self
+      #     ::Const
+      #   end
+      #
+      #   # good
+      #   class << self
+      #     Const
+      #   end
+      #
+      #   # good
+      #   class A
+      #     ::Const
+      #   end
+      #
+      #   # good
+      #   module A
+      #     ::Const
+      #   end
+      class RedundantConstantBase < Base
+        extend AutoCorrector
+
+        MSG = 'Remove redundant `::`.'
+
+        def on_cbase(node)
+          return if lint_constant_resolution_cop_enabled?
+          return unless bad?(node)
+
+          add_offense(node) do |corrector|
+            corrector.remove(node)
+          end
+        end
+
+        private
+
+        def lint_constant_resolution_cop_enabled?
+          lint_constant_resolution_config.fetch('Enabled', false)
+        end
+
+        def lint_constant_resolution_config
+          config.for_cop('Lint/ConstantResolution')
+        end
+
+        def bad?(node)
+          module_nesting_ancestors_of(node).none?
+        end
+
+        def module_nesting_ancestors_of(node)
+          node.each_ancestor(:class, :module).reject do |ancestor|
+            ancestor.class_type? && used_in_super_class_part?(node, class_node: ancestor)
+          end
+        end
+
+        def used_in_super_class_part?(node, class_node:)
+          class_node.parent_class&.each_descendant(:cbase)&.any? do |descendant|
+            descendant.equal?(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant uses of double splat hash braces.
+      #
+      # @example
+      #
+      #   # bad
+      #   do_something(**{foo: bar, baz: qux})
+      #
+      #   # good
+      #   do_something(foo: bar, baz: qux)
+      #
+      class RedundantDoubleSplatHashBraces < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant double splat and braces, use keyword arguments directly.'
+
+        def on_hash(node)
+          return if node.pairs.empty? || node.pairs.any?(&:hash_rocket?)
+          return unless (parent = node.parent)
+          return unless parent.kwsplat_type?
+
+          add_offense(parent) do |corrector|
+            corrector.remove(parent.loc.operator)
+            corrector.remove(opening_brace(node))
+            corrector.remove(closing_brace(node))
+          end
+        end
+
+        private
+
+        def opening_brace(node)
+          node.loc.begin.join(node.children.first.loc.expression.begin)
+        end
+
+        def closing_brace(node)
+          node.children.last.loc.expression.end.join(node.loc.end)
+        end
+      end
+    end
+  end
+end

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

@@ -77,7 +77,8 @@ module RuboCop
           # but it's not necessry to escape hyphen if it's the first or last character
           # within the character class. This method checks if that's the case.
           # e.g. "[0-9\\-]" or "[\\-0-9]" would return true
-          node.source[index] == '[' || node.source[index + 3] == ']'
+          contents_range(node).source[index - 1] == '[' ||
+            contents_range(node).source[index + 2] == ']'
         end
 
         def delimiter?(node, char)

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

@@ -53,6 +53,13 @@ module RuboCop
 
         MSG = 'Redundant `return` detected.'
         MULTI_RETURN_MSG = 'To return multiple values, use an array.'
+        RESTRICT_ON_SEND = %i[define_method define_singleton_method].freeze
+
+        def on_send(node)
+          return unless (parent = node.parent) && parent.block_type?
+
+          check_branch(parent.body)
+        end
 
         def on_def(node)
           check_branch(node.body)

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

@@ -184,7 +184,7 @@ module RuboCop
         end
 
         def arg_value(node)
-          arg_node(node).nil? ? nil : arg_node(node).node_parts.first
+          arg_node(node)&.node_parts&.first
         end
 
         # This gets the start of the accessor whether it has a dot

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

@@ -58,7 +58,7 @@ module RuboCop
         private
 
         def message(range)
-          format(MSG, char: range.source.chars.last)
+          format(MSG, char: range.source[-1])
         end
 
         def str_contents_range(node)
@@ -76,6 +76,7 @@ module RuboCop
           node.loc.to_hash.key?(:begin) && !node.loc.begin.nil?
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def allowed_escape?(node, range)
           escaped = range.source[(1..-1)]
 
@@ -88,13 +89,14 @@ module RuboCop
           # with different versions of Ruby so that e.g. /\d/ != /d/
           return true if /[\n\\[[:alnum:]]]/.match?(escaped[0])
 
-          return true if escaped[0] == ' ' && percent_array_literal?(node)
+          return true if escaped[0] == ' ' && (percent_array_literal?(node) || node.heredoc?)
 
           return true if disabling_interpolation?(range)
           return true if delimiter?(node, escaped[0])
 
           false
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def interpolation_not_enabled?(node)
           single_quoted?(node) ||
@@ -169,9 +171,10 @@ module RuboCop
           # Allow \#{foo}, \#$foo, \#@foo, and \#@@foo
           # for escaping local, global, instance and class variable interpolations
           return true if range.source.match?(/\A\\#[{$@]/)
-
           # Also allow #\{foo}, #\$foo, #\@foo and #\@@foo
           return true if range.adjust(begin_pos: -2).source.match?(/\A[^\\]#\\[{$@]/)
+          # For `\#\{foo} allow `\#` and warn `\{`
+          return true if range.adjust(end_pos: 1).source == '\\#\\{'
 
           false
         end

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Sort `require` and `require_relative` in alphabetical order.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it will obviously change the execution order.
+      #
+      # @example
+      #   # bad
+      #   require 'b'
+      #   require 'a'
+      #
+      #   # good
+      #   require 'a'
+      #   require 'b'
+      #
+      #   # bad
+      #   require_relative 'b'
+      #   require_relative 'a'
+      #
+      #   # good
+      #   require_relative 'a'
+      #   require_relative 'b'
+      #
+      #   # good (sorted within each section separated by a blank line)
+      #   require 'a'
+      #   require 'd'
+      #
+      #   require 'b'
+      #   require 'c'
+      #
+      #   # good
+      #   require 'b'
+      #   require_relative 'c'
+      #   require 'a'
+      #
+      #   # bad
+      #   require 'a'
+      #   require 'c' if foo
+      #   require 'b'
+      #
+      #   # good
+      #   require 'a'
+      #   require 'b'
+      #   require 'c' if foo
+      #
+      #   # bad
+      #   require 'c'
+      #   if foo
+      #     require 'd'
+      #     require 'b'
+      #   end
+      #   require 'a'
+      #
+      #   # good
+      #   require 'c'
+      #   if foo
+      #     require 'b'
+      #     require 'd'
+      #   end
+      #   require 'a'
+      #
+      class RequireOrder < Base
+        extend AutoCorrector
+
+        include RangeHelp
+
+        RESTRICT_ON_SEND = %i[require require_relative].freeze
+
+        MSG = 'Sort `%<name>s` in alphabetical order.'
+
+        # @!method if_inside_only_require(node)
+        def_node_matcher :if_inside_only_require, <<~PATTERN
+          {
+            (if _ _ $(send nil? {:require :require_relative} _))
+            (if _ $(send nil? {:require :require_relative} _) _)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless node.parent && node.arguments?
+          return if not_modifier_form?(node.parent)
+
+          previous_older_sibling = find_previous_older_sibling(node)
+          return unless previous_older_sibling
+
+          add_offense(node, message: format(MSG, name: node.method_name)) do |corrector|
+            corrector.swap(
+              range_with_comments_and_lines(previous_older_sibling),
+              range_with_comments_and_lines(node.parent.if_type? ? node.parent : node)
+            )
+          end
+        end
+
+        private
+
+        def not_modifier_form?(node)
+          node.if_type? && !node.modifier_form?
+        end
+
+        def find_previous_older_sibling(node) # rubocop:disable Metrics
+          search_node(node).left_siblings.reverse.find do |sibling|
+            next unless sibling.is_a?(AST::Node)
+
+            sibling = sibling_node(sibling)
+            break unless sibling&.send_type? && sibling&.method?(node.method_name)
+            break unless sibling.arguments? && !sibling.receiver
+            break unless in_same_section?(sibling, node)
+
+            node.first_argument.source < sibling.first_argument.source
+          end
+        end
+
+        def search_node(node)
+          node.parent.if_type? ? node.parent : node
+        end
+
+        def sibling_node(node)
+          return if not_modifier_form?(node)
+
+          node.if_type? ? if_inside_only_require(node) : node
+        end
+
+        def in_same_section?(node1, node2)
+          !node1.location.expression.with(
+            end_pos: node2.location.expression.end_pos
+          ).source.include?("\n\n")
+        end
+      end
+    end
+  end
+end