rubocop 1.29.1 → 1.46.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks the style of children definitions at classes and
+      # Checks the style of children definitions at classes and
       # modules. Basically there are two different styles:
       #
       # @safety
@@ -31,6 +31,7 @@ module RuboCop
       #
       # The compact style is only forced for classes/modules with one child.
       class ClassAndModuleChildren < Base
+        include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
         extend AutoCorrector
@@ -59,7 +60,7 @@ module RuboCop
         end
 
         def nest_definition(corrector, node)
-          padding = ((' ' * indent_width) + leading_spaces(node)).to_s
+          padding = indentation(node) + leading_spaces(node)
           padding_for_trailing_end = padding.sub(' ' * node.loc.end.column, '')
 
           replace_namespace_keyword(corrector, node)
@@ -117,15 +118,11 @@ module RuboCop
         end
 
         def remove_end(corrector, body)
-          range = range_between(
-            body.loc.end.begin_pos - leading_spaces(body).size,
-            body.loc.end.end_pos + 1
-          )
-          corrector.remove(range)
-        end
+          remove_begin_pos = body.loc.end.begin_pos - leading_spaces(body).size
+          adjustment = processed_source.raw_source[remove_begin_pos] == ';' ? 0 : 1
+          range = range_between(remove_begin_pos, body.loc.end.end_pos + adjustment)
 
-        def configured_indentation_width
-          config.for_badge(Layout::IndentationWidth.badge).fetch('Width', 2)
+          corrector.remove(range)
         end
 
         def unindent(corrector, node)
@@ -141,10 +138,6 @@ module RuboCop
           node.source_range.source_line[/\A\s*/]
         end
 
-        def indent_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
-        end
-
         def check_style(node, body)
           return if node.identifier.children[0]&.cbase_type?
 
@@ -185,7 +178,7 @@ module RuboCop
         end
 
         def compact_node_name?(node)
-          /::/.match?(node.identifier.source)
+          node.identifier.source.include?('::')
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces consistent use of `Object#is_a?` or `Object#kind_of?`.
+      # Enforces consistent use of `Object#is_a?` or `Object#kind_of?`.
       #
       # @example EnforcedStyle: is_a? (default)
       #   # bad

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

@@ -3,8 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of `Object#instance_of?` instead of class comparison
+      # Enforces the use of `Object#instance_of?` instead of class comparison
       # for equality.
+      # `==`, `equal?`, and `eql?` methods are allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @example
       #   # bad
@@ -16,9 +18,50 @@ module RuboCop
       #   # good
       #   var.instance_of?(Date)
       #
+      # @example AllowedMethods: [] (default)
+      #   # good
+      #   var.instance_of?(Date)
+      #
+      #   # bad
+      #   var.class == Date
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #   var.class.name == 'Date'
+      #
+      # @example AllowedMethods: [`==`]
+      #   # good
+      #   var.instance_of?(Date)
+      #   var.class == Date
+      #   var.class.name == 'Date'
+      #
+      #   # bad
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #
+      # @example AllowedPatterns: [] (default)
+      #   # good
+      #   var.instance_of?(Date)
+      #
+      #   # bad
+      #   var.class == Date
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #   var.class.name == 'Date'
+      #
+      # @example AllowedPatterns: ['eq']
+      #   # good
+      #   var.instance_of?(Date)
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #
+      #   # bad
+      #   var.class == Date
+      #   var.class.name == 'Date'
+      #
       class ClassEqualityComparison < Base
         include RangeHelp
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
         MSG = 'Use `instance_of?(%<class_name>s)` instead of comparing classes.'
@@ -34,7 +77,9 @@ module RuboCop
 
         def on_send(node)
           def_node = node.each_ancestor(:def, :defs).first
-          return if def_node && ignored_method?(def_node.method_name)
+          return if def_node &&
+                    (allowed_method?(def_node.method_name) ||
+                    matches_allowed_pattern?(def_node.method_name))
 
           class_comparison_candidate?(node) do |receiver_node, class_node|
             range = offense_range(receiver_node, node)
@@ -52,10 +97,14 @@ module RuboCop
           if node.children.first.method?(:name)
             return class_node.receiver.source if class_node.receiver
 
-            class_node.source.delete('"').delete("'")
-          else
-            class_node.source
+            if class_node.str_type?
+              value = class_node.source.delete('"').delete("'")
+              value.prepend('::') if class_node.each_ancestor(:class, :module).any?
+              return value
+            end
           end
+
+          class_node.source
         end
 
         def offense_range(receiver_node, node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of the class/module name instead of
+      # Checks for uses of the class/module name instead of
       # self, when defining class/module methods.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces using `def self.method_name` or `class << self` to define class methods.
+      # Enforces using `def self.method_name` or `class << self` to define class methods.
       #
       # @example EnforcedStyle: def_self (default)
       #   # bad
@@ -70,7 +70,7 @@ module RuboCop
 
         def on_sclass(node)
           return unless def_self_style?
-          return unless node.identifier.source == 'self'
+          return unless node.identifier.self_type?
           return unless all_methods_public?(node)
 
           add_offense(node, message: MSG_SCLASS) do |corrector|
@@ -80,6 +80,7 @@ module RuboCop
 
         def on_defs(node)
           return if def_self_style?
+          return unless node.receiver.self_type?
 
           message = format(MSG, preferred: 'class << self')
           add_offense(node, message: message)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of class variables. Offenses
+      # Checks for uses of class variables. Offenses
       # are signaled only on assignment to class variables to
       # reduce the number of offenses that would be reported.
       #

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

@@ -3,12 +3,14 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where custom logic on rejection nils from arrays
+      # Checks for places where custom logic on rejection nils from arrays
       # and hashes can be replaced with `{Array,Hash}#{compact,compact!}`.
       #
       # @safety
       #   It is unsafe by default because false positives may occur in the
-      #   `nil` check of block arguments to the receiver object.
+      #   `nil` check of block arguments to the receiver object. Additionally,
+      #    we can't know the type of the receiver object for sure, which may
+      #    result in false positives as well.
       #
       #   For example, `[[1, 2], [3, nil]].reject { |first, second| second.nil? }`
       #   and `[[1, 2], [3, nil]].compact` are not compatible. This will work fine
@@ -36,8 +38,8 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
-
         RESTRICT_ON_SEND = %i[reject reject! select select!].freeze
+        TO_ENUM_METHODS = %i[to_enum lazy].freeze
 
         # @!method reject_method_with_block_pass?(node)
         def_node_matcher :reject_method_with_block_pass?, <<~PATTERN
@@ -69,6 +71,7 @@ module RuboCop
 
         def on_send(node)
           return unless (range = offense_range(node))
+          return if target_ruby_version <= 3.0 && to_enum_method?(node)
 
           good = good_method_name(node)
           message = format(MSG, good: good, bad: range.source)
@@ -94,6 +97,12 @@ module RuboCop
           end
         end
 
+        def to_enum_method?(node)
+          return false unless node.receiver.send_type?
+
+          TO_ENUM_METHODS.include?(node.receiver.method_name)
+        end
+
         def good_method_name(node)
           if node.bang_method?
             'compact!'
@@ -103,7 +112,7 @@ module RuboCop
         end
 
         def range(begin_pos_node, end_pos_node)
-          range_between(begin_pos_node.loc.selector.begin_pos, end_pos_node.loc.end.end_pos)
+          range_between(begin_pos_node.loc.selector.begin_pos, end_pos_node.loc.expression.end_pos)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of consistent method names
+      # Enforces the use of consistent method names
       # from the Enumerable module.
       #
       # You can customize the mapping from undesired method to desired method.
@@ -48,6 +48,8 @@ module RuboCop
           check_method_node(node.send_node)
         end
 
+        alias on_numblock on_block
+
         def on_send(node)
           return unless implicit_block?(node)
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for methods invoked via the :: operator instead
+      # Checks for methods invoked via the :: operator instead
       # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for class methods that are defined using the `::`
+      # Checks for class methods that are defined using the `::`
       # operator instead of the `.` operator.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where multiple consecutive loops over the same data
+      # Checks for places where multiple consecutive loops over the same data
       # can be combined into a single loop. It is very likely that combining them
       # will make the code more efficient and more concise.
       #
@@ -66,6 +66,8 @@ module RuboCop
           add_offense(node) if same_collection_looping?(node, node.left_sibling)
         end
 
+        alias on_numblock on_block
+
         def on_for(node)
           return unless node.parent&.begin_type?
 
@@ -82,7 +84,7 @@ module RuboCop
         end
 
         def same_collection_looping?(node, sibling)
-          sibling&.block_type? &&
+          (sibling&.block_type? || sibling&.numblock_type?) &&
             sibling.send_node.method?(node.method_name) &&
             sibling.receiver == node.receiver &&
             sibling.send_node.arguments == node.send_node.arguments

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces using `` or %x around command literals.
+      # Enforces using `` or %x around command literals.
       #
       # @example EnforcedStyle: backticks (default)
       #   # bad
@@ -148,7 +148,7 @@ module RuboCop
         end
 
         def contains_backtick?(node)
-          /`/.match?(node_body(node))
+          node_body(node).include?('`')
         end
 
         def node_body(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks that comment annotation keywords are written according
+      # Checks that comment annotation keywords are written according
       # to guidelines.
       #
       # Annotation keywords can be specified by overriding the cop's `Keywords`

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

@@ -3,18 +3,18 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for comments put on the same line as some keywords.
+      # Checks for comments put on the same line as some keywords.
       # These keywords are: `class`, `module`, `def`, `begin`, `end`.
       #
       # Note that some comments
       # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`)
       # are allowed.
       #
-      # Auto-correction removes comments from `end` keyword and keeps comments
+      # Autocorrection removes comments from `end` keyword and keeps comments
       # for `class`, `module`, `def` and `begin` above the keyword.
       #
       # @safety
-      #   Auto-correction is unsafe because it may remove a comment that is
+      #   Autocorrection is unsafe because it may remove a comment that is
       #   meaningful.
       #
       # @example
@@ -66,7 +66,7 @@ module RuboCop
 
         def register_offense(comment, matched_keyword)
           add_offense(comment, message: format(MSG, keyword: matched_keyword)) do |corrector|
-            range = range_with_surrounding_space(range: comment.loc.expression, newlines: false)
+            range = range_with_surrounding_space(comment.loc.expression, newlines: false)
             corrector.remove(range)
 
             unless matched_keyword == 'end'

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of `Comparable#clamp` instead of comparison by minimum and maximum.
+      #
+      # This cop supports autocorrection for `if/elsif/else` bad style only.
+      # Because `ArgumentError` occurs if the minimum and maximum of `clamp` arguments are reversed.
+      # When these are variables, it is not possible to determine which is the minimum and maximum:
+      #
+      # [source,ruby]
+      # ----
+      # [1, [2, 3].max].min # => 1
+      # 1.clamp(3, 1)       # => min argument must be smaller than max argument (ArgumentError)
+      # ----
+      #
+      # @example
+      #
+      #   # bad
+      #   [[x, low].max, high].min
+      #
+      #   # bad
+      #   if x < low
+      #     low
+      #   elsif high < x
+      #     high
+      #   else
+      #     x
+      #   end
+      #
+      #   # good
+      #   x.clamp(low, high)
+      #
+      class ComparableClamp < Base
+        include Alignment
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.4
+
+        MSG = 'Use `%<prefer>s` instead of `if/elsif/else`.'
+        MSG_MIN_MAX = 'Use `Comparable#clamp` instead.'
+        RESTRICT_ON_SEND = %i[min max].freeze
+
+        # @!method if_elsif_else_condition?(node)
+        def_node_matcher :if_elsif_else_condition?, <<~PATTERN
+          {
+            (if (send _x :< _min) _min (if (send _max :< _x) _max _x))
+            (if (send _min :> _x) _min (if (send _max :< _x) _max _x))
+            (if (send _x :< _min) _min (if (send _x :> _max) _max _x))
+            (if (send _min :> _x) _min (if (send _x :> _max) _max _x))
+            (if (send _max :< _x) _max (if (send _x :< _min) _min _x))
+            (if (send _x :> _max) _max (if (send _x :< _min) _min _x))
+            (if (send _max :< _x) _max (if (send _min :> _x) _min _x))
+            (if (send _x :> _max) _max (if (send _min :> _x) _min _x))
+          }
+        PATTERN
+
+        # @!method array_min_max?(node)
+        def_node_matcher :array_min_max?, <<~PATTERN
+          {
+            (send
+              (array
+                (send (array _ _) :max) _) :min)
+            (send
+              (array
+                _ (send (array _ _) :max)) :min)
+            (send
+              (array
+                (send (array _ _) :min) _) :max)
+            (send
+              (array
+                _ (send (array _ _) :min)) :max)
+          }
+        PATTERN
+
+        def on_if(node)
+          return unless if_elsif_else_condition?(node)
+
+          if_body, elsif_body, else_body = *node.branches
+
+          else_body_source = else_body.source
+
+          if min_condition?(node.condition, else_body_source)
+            min = if_body.source
+            max = elsif_body.source
+          else
+            min = elsif_body.source
+            max = if_body.source
+          end
+
+          prefer = "#{else_body_source}.clamp(#{min}, #{max})"
+
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            autocorrect(corrector, node, prefer)
+          end
+        end
+
+        def on_send(node)
+          return unless array_min_max?(node)
+
+          add_offense(node, message: MSG_MIN_MAX)
+        end
+
+        private
+
+        def autocorrect(corrector, node, prefer)
+          if node.elsif?
+            corrector.insert_before(node, "else\n")
+            corrector.replace(node, "#{indentation(node)}#{prefer}")
+          else
+            corrector.replace(node, prefer)
+          end
+        end
+
+        def min_condition?(if_condition, else_body)
+          lhs, op, rhs = *if_condition
+
+          (lhs.source == else_body && op == :<) || (rhs.source == else_body && op == :>)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of `Array#push(item)` instead of `Array#concat([item])`
+      # to avoid redundant array literals.
+      #
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if the receiver
+      #   is not an `Array` object.
+      #
+      # @example
+      #
+      #   # bad
+      #   list.concat([foo])
+      #   list.concat([bar, baz])
+      #   list.concat([qux, quux], [corge])
+      #
+      #   # good
+      #   list.push(foo)
+      #   list.push(bar, baz)
+      #   list.push(qux, quux, corge)
+      #
+      class ConcatArrayLiterals < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        MSG_FOR_PERCENT_LITERALS =
+          'Use `push` with elements as arguments without array brackets instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[concat].freeze
+
+        # rubocop:disable Metrics
+        def on_send(node)
+          return if node.arguments.empty?
+          return unless node.arguments.all?(&:array_type?)
+
+          offense = offense_range(node)
+          current = offense.source
+
+          if node.arguments.any?(&:percent_literal?)
+            if percent_literals_includes_only_basic_literals?(node)
+              prefer = preferred_method(node)
+              message = format(MSG, prefer: prefer, current: current)
+            else
+              message = format(MSG_FOR_PERCENT_LITERALS, current: current)
+            end
+          else
+            prefer = preferred_method(node)
+            message = format(MSG, prefer: prefer, current: current)
+          end
+
+          add_offense(offense, message: message) do |corrector|
+            corrector.replace(offense, prefer)
+          end
+        end
+        # rubocop:enable Metrics
+
+        private
+
+        def offense_range(node)
+          node.loc.selector.join(node.source_range.end)
+        end
+
+        def preferred_method(node)
+          new_arguments =
+            node.arguments.map do |arg|
+              if arg.percent_literal?
+                arg.children.map(&:value).map(&:inspect)
+              else
+                arg.children.map(&:source)
+              end
+            end.join(', ')
+
+          "push(#{new_arguments})"
+        end
+
+        def percent_literals_includes_only_basic_literals?(node)
+          node.arguments.select(&:percent_literal?).all? do |arg|
+            arg.children.all? { |child| child.str_type? || child.sym_type? }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -218,11 +218,9 @@ module RuboCop
         VARIABLE_ASSIGNMENT_TYPES = %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
         ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES + %i[and_asgn or_asgn op_asgn masgn].freeze
         LINE_LENGTH = 'Layout/LineLength'
-        INDENTATION_WIDTH = 'Layout/IndentationWidth'
         ENABLED = 'Enabled'
         MAX = 'Max'
         SINGLE_LINE_CONDITIONS_ONLY = 'SingleLineConditionsOnly'
-        WIDTH = 'Width'
 
         # The shovel operator `<<` does not have its own type. It is a `send`
         # type.
@@ -237,6 +235,7 @@ module RuboCop
         ASSIGNMENT_TYPES.each do |type|
           define_method "on_#{type}" do |node|
             return if part_of_ignored_node?(node)
+            return if node.parent&.shorthand_asgn?
 
             check_assignment_to_condition(node)
           end
@@ -394,7 +393,7 @@ module RuboCop
         end
 
         # If `Layout/LineLength` is enabled, we do not want to introduce an
-        # offense by auto-correcting this cop. Find the max configured line
+        # offense by autocorrecting this cop. Find the max configured line
         # length. Find the longest line of condition. Remove the assignment
         # from lines that contain the offending assignment because after
         # correcting, this will not be on the line anymore. Check if the length
@@ -427,10 +426,6 @@ module RuboCop
           config.for_cop(LINE_LENGTH)[MAX]
         end
 
-        def indentation_width
-          config.for_cop(INDENTATION_WIDTH)[WIDTH] || 2
-        end
-
         def single_line_conditions_only?
           cop_config[SINGLE_LINE_CONDITIONS_ONLY]
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks that constants defined in classes and modules have
+      # Checks that constants defined in classes and modules have
       # an explicit visibility declaration. By default, Ruby makes all class-
       # and module constants public, which litters the public API of the
       # class or module. Explicitly declaring a visibility makes intent more

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for consistent usage of the `DateTime` class over the
+      # Checks for consistent usage of the `DateTime` class over the
       # `Time` class. This cop is disabled by default since these classes,
       # although highly overlapping, have particularities that make them not
       # replaceable in certain situations when dealing with multiple timezones

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for parentheses in the definition of a method,
+      # Checks for parentheses in the definition of a method,
       # that does not take any arguments. Both instance and
       # class/singleton methods are checked.
       #