rubocop 1.34.1 → 1.54.0

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

@@ -30,7 +30,7 @@ module RuboCop
         private
 
         def first_offense_range(comment)
-          expression    = comment.loc.expression
+          expression    = comment.source_range
           first_offense = first_non_ascii_chars(comment.text)
 
           start_position = expression.begin_pos + comment.text.index(first_offense)

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

@@ -24,7 +24,7 @@ module RuboCop
         def on_send(node)
           return unless node.command?(:attr) && node.arguments?
           # check only for method definitions in class/module body
-          return if node.parent && !node.parent.class_type? && !class_eval?(node.parent)
+          return if allowed_context?(node)
 
           message = message(node)
           add_offense(node.loc.selector, message: message) do |corrector|
@@ -34,6 +34,16 @@ module RuboCop
 
         private
 
+        def allowed_context?(node)
+          return false unless (class_node = node.each_ancestor(:class, :block).first)
+
+          (!class_node.class_type? && !class_eval?(class_node)) || define_attr_method?(class_node)
+        end
+
+        def define_attr_method?(node)
+          node.each_descendant(:def).any? { |def_node| def_node.method?(:attr) }
+        end
+
         def autocorrect(corrector, node)
           attr_name, setter = *node.arguments
 

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

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      #
-      # This cop checks for BEGIN blocks.
+      # Checks for BEGIN blocks.
       #
       # @example
       #   # bad

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

@@ -55,7 +55,7 @@ module RuboCop
         def after_class(class_node)
           @macros_to_rewrite[class_node].each do |macro|
             node = macro.node
-            range = range_by_whole_lines(node.loc.expression, include_final_newline: true)
+            range = range_by_whole_lines(node.source_range, include_final_newline: true)
 
             correct(range) do |corrector|
               if macro.writer?

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

@@ -32,10 +32,10 @@ module RuboCop
               eq_begin, eq_end, contents = parts(comment)
 
               corrector.remove(eq_begin)
-              unless contents.length.zero?
+              unless contents.empty?
                 corrector.replace(
                   contents,
-                  contents.source.gsub(/\A/, '# ').gsub(/\n\n/, "\n#\n").gsub(/\n(?=[^#])/, "\n# ")
+                  contents.source.gsub(/\A/, '# ').gsub("\n\n", "\n#\n").gsub(/\n(?=[^#])/, "\n# ")
                 )
               end
               corrector.remove(eq_end)
@@ -46,7 +46,7 @@ module RuboCop
         private
 
         def parts(comment)
-          expr = comment.loc.expression
+          expr = comment.source_range
           eq_begin = expr.resize(BEGIN_LENGTH)
           eq_end = eq_end_part(comment, expr)
           contents = range_between(eq_begin.end_pos, eq_end.begin_pos)

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

@@ -157,7 +157,7 @@ module RuboCop
       #     process(something)
       #   }
       #
-      # @example AllowedPatterns: [/map/]
+      # @example AllowedPatterns: ['map']
       #
       #   # good
       #   things.map { |thing|
@@ -299,8 +299,8 @@ module RuboCop
 
         def move_comment_before_block(corrector, comment, block_node, closing_brace)
           range = block_node.chained? ? end_of_chain(block_node.parent).source_range : closing_brace
-          comment_range = range_between(range.end_pos, comment.loc.expression.end_pos)
-          corrector.remove(range_with_surrounding_space(comment_range, side: :right))
+          corrector.remove(range_with_surrounding_space(comment.source_range, side: :right))
+          remove_trailing_whitespace(corrector, range, comment)
           corrector.insert_after(range, "\n")
 
           corrector.insert_before(block_node, "#{comment.text}\n")
@@ -313,6 +313,12 @@ module RuboCop
           end_of_chain(node.parent)
         end
 
+        def remove_trailing_whitespace(corrector, range, comment)
+          range_of_trailing = range.end.join(comment.source_range.begin)
+
+          corrector.remove(range_of_trailing) if range_of_trailing.source.match?(/\A\s+\z/)
+        end
+
         def with_block?(node)
           node.respond_to?(:block_node) && node.block_node
         end
@@ -336,6 +342,7 @@ module RuboCop
         end
 
         def proper_block_style?(node)
+          return true if require_braces?(node)
           return special_method_proper_block_style?(node) if special_method?(node.method_name)
 
           case style
@@ -346,6 +353,14 @@ module RuboCop
           end
         end
 
+        def require_braces?(node)
+          return false unless node.braces?
+
+          node.each_ancestor(:send).any? do |send|
+            send.arithmetic_operation? && node.source_range.end_pos < send.loc.selector.begin_pos
+          end
+        end
+
         def special_method?(method_name)
           allowed_method?(method_name) ||
             matches_allowed_pattern?(method_name) ||
@@ -396,7 +411,7 @@ module RuboCop
         end
 
         def correction_would_break_code?(node)
-          return unless node.keywords?
+          return false unless node.keywords?
 
           node.send_node.arguments? && !node.send_node.parenthesized?
         end
@@ -418,19 +433,19 @@ module RuboCop
         end
 
         def return_value_used?(node)
-          return unless node.parent
+          return false unless node.parent
 
           # If there are parentheses around the block, check if that
           # is being used.
           if node.parent.begin_type?
             return_value_used?(node.parent)
           else
-            node.parent.assignment? || node.parent.send_type?
+            node.parent.assignment? || node.parent.call_type?
           end
         end
 
         def return_value_of_scope?(node)
-          return unless node.parent
+          return false unless node.parent
 
           conditional?(node.parent) || array_or_range?(node.parent) ||
             node.parent.children.last == node

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

@@ -7,6 +7,9 @@ module RuboCop
       #
       # If `AllowOnConstant` option is enabled, the cop will ignore violations when the receiver of
       # the case equality operator is a constant.
+
+      # If `AllowOnSelfClass` option is enabled, the cop will ignore violations when the receiver of
+      # the case equality operator is `self.class`. Note intermediate variables are not accepted.
       #
       # @example
       #   # bad
@@ -26,6 +29,14 @@ module RuboCop
       #   # good
       #   Array === something
       #
+      # @example AllowOnSelfClass: false (default)
+      #   # bad
+      #   self.class === something
+      #
+      # @example AllowOnSelfClass: true
+      #   # good
+      #   self.class === something
+      #
       class CaseEquality < Base
         extend AutoCorrector
 
@@ -33,7 +44,10 @@ module RuboCop
         RESTRICT_ON_SEND = %i[===].freeze
 
         # @!method case_equality?(node)
-        def_node_matcher :case_equality?, '(send $#const? :=== $_)'
+        def_node_matcher :case_equality?, '(send $#offending_receiver? :=== $_)'
+
+        # @!method self_class?(node)
+        def_node_matcher :self_class?, '(send (self) :class)'
 
         def on_send(node)
           case_equality?(node) do |lhs, rhs|
@@ -48,12 +62,11 @@ module RuboCop
 
         private
 
-        def const?(node)
-          if cop_config.fetch('AllowOnConstant', false)
-            !node&.const_type?
-          else
-            true
-          end
+        def offending_receiver?(node)
+          return false if node&.const_type? && cop_config.fetch('AllowOnConstant', false)
+          return false if self_class?(node) && cop_config.fetch('AllowOnSelfClass', false)
+
+          true
         end
 
         def replacement(lhs, rhs)
@@ -66,12 +79,29 @@ module RuboCop
             #
             # So here is noop.
           when :begin
-            child = lhs.children.first
-            "#{lhs.source}.include?(#{rhs.source})" if child&.range_type?
+            begin_replacement(lhs, rhs)
           when :const
-            "#{rhs.source}.is_a?(#{lhs.source})"
+            const_replacement(lhs, rhs)
+          when :send
+            send_replacement(lhs, rhs)
           end
         end
+
+        def begin_replacement(lhs, rhs)
+          return unless lhs.children.first&.range_type?
+
+          "#{lhs.source}.include?(#{rhs.source})"
+        end
+
+        def const_replacement(lhs, rhs)
+          "#{rhs.source}.is_a?(#{lhs.source})"
+        end
+
+        def send_replacement(lhs, rhs)
+          return unless self_class?(lhs)
+
+          "#{rhs.source}.is_a?(#{lhs.source})"
+        end
       end
     end
   end

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

@@ -11,12 +11,14 @@ module RuboCop
       #   so if the original conditional used a different equality operator, the
       #   behavior may be different.
       #
-      # @example
+      # @example MinBranchesCount: 3 (default)
       #   # bad
       #   if status == :active
       #     perform_action
       #   elsif status == :inactive || status == :hibernating
       #     check_timeout
+      #   elsif status == :invalid
+      #     report_invalid
       #   else
       #     final_action
       #   end
@@ -27,12 +29,27 @@ module RuboCop
       #     perform_action
       #   when :inactive, :hibernating
       #     check_timeout
+      #   when :invalid
+      #     report_invalid
+      #   else
+      #     final_action
+      #   end
+      #
+      # @example MinBranchesCount: 4
+      #   # good
+      #   if status == :active
+      #     perform_action
+      #   elsif status == :inactive || status == :hibernating
+      #     check_timeout
+      #   elsif status == :invalid
+      #     report_invalid
       #   else
       #     final_action
       #   end
       #
       class CaseLikeIf < Base
         include RangeHelp
+        include MinBranchesCount
         extend AutoCorrector
 
         MSG = 'Convert `if-elsif` to `case-when`.'
@@ -78,7 +95,7 @@ module RuboCop
 
         def should_check?(node)
           !node.unless? && !node.elsif? && !node.modifier_form? && !node.ternary? &&
-            node.elsif_conditional?
+            node.elsif_conditional? && min_branches_count?(node)
         end
 
         # rubocop:disable Metrics/MethodLength
@@ -239,7 +256,7 @@ module RuboCop
         end
 
         def correction_range(node)
-          range_between(node.parent.loc.keyword.begin_pos, node.loc.expression.end_pos)
+          range_between(node.parent.loc.keyword.begin_pos, node.source_range.end_pos)
         end
 
         # Named captures work with `=~` (if regexp is on lhs) and with `match` (both sides)

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

@@ -29,7 +29,7 @@ module RuboCop
 
         def offense?(node)
           # we don't register an offense for things like ?\C-\M-d
-          node.loc.begin.is?('?') && node.source.size.between?(2, 3)
+          node.character_literal? && node.source.size.between?(2, 3)
         end
 
         def autocorrect(corrector, node)

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

@@ -11,7 +11,7 @@ module RuboCop
       #
       #   Moving from compact to nested children requires knowledge of whether the
       #   outer parent is a module or a class. Moving from nested to compact requires
-      #   verification that the outer parent is defined elsewhere. Rubocop does not
+      #   verification that the outer parent is defined elsewhere. RuboCop does not
       #   have the knowledge to perform either operation safely and thus requires
       #   manual oversight.
       #
@@ -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)
@@ -124,10 +125,6 @@ module RuboCop
           corrector.remove(range)
         end
 
-        def configured_indentation_width
-          config.for_badge(Layout::IndentationWidth.badge).fetch('Width', 2)
-        end
-
         def unindent(corrector, node)
           return if node.body.children.last.nil?
 
@@ -141,12 +138,8 @@ 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?
+          return if node.identifier.namespace&.cbase_type?
 
           if style == :nested
             check_nested_style(node)
@@ -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_equality_comparison.rb

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # Enforces the use of `Object#instance_of?` instead of class comparison
       # for equality.
-      # `==`, `equal?`, and `eql?` methods are allowed by default.
+      # `==`, `equal?`, and `eql?` custom method definitions are allowed by default.
       # These are customizable with `AllowedMethods` option.
       #
       # @example
@@ -18,45 +18,31 @@ module RuboCop
       #   # good
       #   var.instance_of?(Date)
       #
-      # @example AllowedMethods: [] (default)
+      # @example AllowedMethods: ['==', 'equal?', 'eql?'] (default)
       #   # good
-      #   var.instance_of?(Date)
+      #   def ==(other)
+      #     self.class == other.class && name == other.name
+      #   end
       #
-      #   # bad
-      #   var.class == Date
-      #   var.class.equal?(Date)
-      #   var.class.eql?(Date)
-      #   var.class.name == 'Date'
+      #   def equal?(other)
+      #     self.class.equal?(other.class) && name.equal?(other.name)
+      #   end
       #
-      # @example AllowedMethods: [`==`]
-      #   # good
-      #   var.instance_of?(Date)
-      #   var.class == Date
-      #   var.class.name == 'Date'
-      #
-      #   # bad
-      #   var.class.equal?(Date)
-      #   var.class.eql?(Date)
+      #   def eql?(other)
+      #     self.class.eql?(other.class) && name.eql?(other.name)
+      #   end
       #
       # @example AllowedPatterns: [] (default)
-      #   # good
-      #   var.instance_of?(Date)
-      #
       #   # bad
-      #   var.class == Date
-      #   var.class.equal?(Date)
-      #   var.class.eql?(Date)
-      #   var.class.name == 'Date'
+      #   def eq(other)
+      #     self.class.eq(other.class) && name.eq(other.name)
+      #   end
       #
-      # @example AllowedPatterns: [`/eq/`]
+      # @example AllowedPatterns: ['eq']
       #   # good
-      #   var.instance_of?(Date)
-      #   var.class.equal?(Date)
-      #   var.class.eql?(Date)
-      #
-      #   # bad
-      #   var.class == Date
-      #   var.class.name == 'Date'
+      #   def eq(other)
+      #     self.class.eq(other.class) && name.eq(other.name)
+      #   end
       #
       class ClassEqualityComparison < Base
         include RangeHelp
@@ -64,14 +50,15 @@ module RuboCop
         include AllowedPattern
         extend AutoCorrector
 
-        MSG = 'Use `instance_of?(%<class_name>s)` instead of comparing classes.'
+        MSG = 'Use `instance_of?%<class_argument>s` instead of comparing classes.'
 
         RESTRICT_ON_SEND = %i[== equal? eql?].freeze
+        CLASS_NAME_METHODS = %i[name to_s inspect].freeze
 
         # @!method class_comparison_candidate?(node)
         def_node_matcher :class_comparison_candidate?, <<~PATTERN
           (send
-            {$(send _ :class) (send $(send _ :class) :name)}
+            {$(send _ :class) (send $(send _ :class) #class_name_method?)}
             {:== :equal? :eql?} $_)
         PATTERN
 
@@ -83,10 +70,12 @@ module RuboCop
 
           class_comparison_candidate?(node) do |receiver_node, class_node|
             range = offense_range(receiver_node, node)
-            class_name = class_name(class_node, node)
+            class_argument = (class_name = class_name(class_node, node)) ? "(#{class_name})" : ''
+
+            add_offense(range, message: format(MSG, class_argument: class_argument)) do |corrector|
+              next unless class_name
 
-            add_offense(range, message: format(MSG, class_name: class_name)) do |corrector|
-              corrector.replace(range, "instance_of?(#{class_name})")
+              corrector.replace(range, "instance_of?#{class_argument}")
             end
           end
         end
@@ -94,15 +83,39 @@ module RuboCop
         private
 
         def class_name(class_node, node)
-          if node.children.first.method?(:name)
-            return class_node.receiver.source if class_node.receiver
-
-            value = class_node.source.delete('"').delete("'")
-            value.prepend('::') if class_node.each_ancestor(:class, :module).any?
-            value
-          else
-            class_node.source
+          if class_name_method?(node.children.first.method_name)
+            if (receiver = class_node.receiver) && class_name_method?(class_node.method_name)
+              return receiver.source
+            end
+
+            if class_node.str_type?
+              value = trim_string_quotes(class_node)
+              value.prepend('::') if require_cbase?(class_node)
+              return value
+            elsif unable_to_determine_type?(class_node)
+              # When a variable or return value of a method is used, it returns nil
+              # because the type is not known and cannot be suggested.
+              return
+            end
           end
+
+          class_node.source
+        end
+
+        def class_name_method?(method_name)
+          CLASS_NAME_METHODS.include?(method_name)
+        end
+
+        def require_cbase?(class_node)
+          class_node.each_ancestor(:class, :module).any?
+        end
+
+        def unable_to_determine_type?(class_node)
+          class_node.variable? || class_node.call_type?
+        end
+
+        def trim_string_quotes(class_node)
+          class_node.source.delete('"').delete("'")
         end
 
         def offense_range(receiver_node, node)

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

@@ -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/collection_compact.rb

@@ -8,7 +8,9 @@ module RuboCop
       #
       # @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
@@ -17,7 +19,9 @@ module RuboCop
       # @example
       #   # bad
       #   array.reject(&:nil?)
+      #   array.delete_if(&:nil?)
       #   array.reject { |e| e.nil? }
+      #   array.delete_if { |e| e.nil? }
       #   array.select { |e| !e.nil? }
       #
       #   # good
@@ -31,17 +35,25 @@ module RuboCop
       #   # good
       #   hash.compact!
       #
+      # @example AllowedReceivers: ['params']
+      #   # good
+      #   params.reject(&:nil?)
+      #
       class CollectionCompact < Base
+        include AllowedReceivers
         include RangeHelp
         extend AutoCorrector
+        extend TargetRubyVersion
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+        RESTRICT_ON_SEND = %i[reject delete_if reject! select select!].freeze
+        TO_ENUM_METHODS = %i[to_enum lazy].freeze
 
-        RESTRICT_ON_SEND = %i[reject reject! select select!].freeze
+        minimum_target_ruby_version 2.4
 
         # @!method reject_method_with_block_pass?(node)
         def_node_matcher :reject_method_with_block_pass?, <<~PATTERN
-          (send !nil? {:reject :reject!}
+          (send !nil? {:reject :delete_if :reject!}
             (block_pass
               (sym :nil?)))
         PATTERN
@@ -50,7 +62,7 @@ module RuboCop
         def_node_matcher :reject_method?, <<~PATTERN
           (block
             (send
-              !nil? {:reject :reject!})
+              !nil? {:reject :delete_if :reject!})
             $(args ...)
             (send
               $(lvar _) :nil?))
@@ -69,6 +81,10 @@ module RuboCop
 
         def on_send(node)
           return unless (range = offense_range(node))
+          return if allowed_receiver?(node.receiver)
+          if (target_ruby_version <= 3.0 || node.method?(:delete_if)) && to_enum_method?(node)
+            return
+          end
 
           good = good_method_name(node)
           message = format(MSG, good: good, bad: range.source)
@@ -94,6 +110,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 +125,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.source_range.end_pos)
         end
       end
     end

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

@@ -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,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for methods invoked via the :: operator instead
-      # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
+      # Checks for methods invoked via the `::` operator instead
+      # of the `.` operator (like `FileUtils::rmdir` instead of `FileUtils.rmdir`).
       #
       # @example
       #   # bad