rubocop 1.19.0 → 1.40.0

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ClassLength
 module RuboCop
   module Cop
     module Style
@@ -9,7 +10,7 @@ module RuboCop
       # Methods that can be either procedural or functional and cannot be
       # categorised from their usage alone is ignored.
       # `lambda`, `proc`, and `it` are their defaults.
-      # Additional methods can be added to the `IgnoredMethods`.
+      # Additional methods can be added to the `AllowedMethods`.
       #
       # @example EnforcedStyle: line_count_based (default)
       #   # bad - single line block
@@ -65,7 +66,7 @@ module RuboCop
       #     x
       #   }.inspect
       #
-      #   # The AllowBracesOnProceduralOneLiners option is ignored unless the
+      #   # The AllowBracesOnProceduralOneLiners option is allowed unless the
       #   # EnforcedStyle is set to `semantic`. If so:
       #
       #   # If the AllowBracesOnProceduralOneLiners option is unspecified, or
@@ -115,7 +116,7 @@ module RuboCop
       #
       #   # Methods listed in the BracesRequiredMethods list, such as 'sig'
       #   # in this example, will require `{...}` braces. This option takes
-      #   # precedence over all other configurations except IgnoredMethods.
+      #   # precedence over all other configurations except AllowedMethods.
       #
       #   # bad
       #   sig do
@@ -137,7 +138,7 @@ module RuboCop
       #     puts foo
       #   end
       #
-      # @example IgnoredMethods: ['lambda', 'proc', 'it' ] (default)
+      # @example AllowedMethods: ['lambda', 'proc', 'it' ] (default)
       #
       #   # good
       #   foo = lambda do |x|
@@ -148,9 +149,26 @@ module RuboCop
       #     x * 100
       #   end
       #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   things.map { |thing|
+      #     something = thing.some_method
+      #     process(something)
+      #   }
+      #
+      # @example AllowedPatterns: ['map']
+      #
+      #   # good
+      #   things.map { |thing|
+      #     something = thing.some_method
+      #     process(something)
+      #   }
+      #
       class BlockDelimiters < Base
         include ConfigurableEnforcedStyle
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         include RangeHelp
         extend AutoCorrector
 
@@ -183,6 +201,8 @@ module RuboCop
           end
         end
 
+        alias on_numblock on_block
+
         private
 
         def autocorrect(corrector, node)
@@ -191,7 +211,7 @@ module RuboCop
           if node.braces?
             replace_braces_with_do_end(corrector, node.loc)
           else
-            replace_do_end_with_braces(corrector, node.loc)
+            replace_do_end_with_braces(corrector, node)
           end
         end
 
@@ -256,7 +276,8 @@ module RuboCop
           corrector.replace(e, 'end')
         end
 
-        def replace_do_end_with_braces(corrector, loc)
+        def replace_do_end_with_braces(corrector, node)
+          loc = node.loc
           b = loc.begin
           e = loc.end
 
@@ -264,6 +285,8 @@ module RuboCop
 
           corrector.replace(b, '{')
           corrector.replace(e, '}')
+
+          corrector.wrap(node.body, "begin\n", "\nend") if begin_required?(node)
         end
 
         def whitespace_before?(range)
@@ -275,17 +298,28 @@ module RuboCop
         end
 
         def move_comment_before_block(corrector, comment, block_node, closing_brace)
-          range = range_between(closing_brace.end_pos, comment.loc.expression.end_pos)
-
-          corrector.remove(range_with_surrounding_space(range: range, side: :right))
-          corrector.insert_after(closing_brace, "\n")
+          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.insert_after(range, "\n")
 
           corrector.insert_before(block_node, "#{comment.text}\n")
         end
 
+        def end_of_chain(node)
+          return end_of_chain(node.block_node) if with_block?(node)
+          return node unless node.chained?
+
+          end_of_chain(node.parent)
+        end
+
+        def with_block?(node)
+          node.respond_to?(:block_node) && node.block_node
+        end
+
         def get_blocks(node, &block)
           case node.type
-          when :block
+          when :block, :numblock
             yield node
           when :send
             get_blocks(node.receiver, &block) if node.receiver
@@ -313,12 +347,14 @@ module RuboCop
         end
 
         def special_method?(method_name)
-          ignored_method?(method_name) || braces_required_method?(method_name)
+          allowed_method?(method_name) ||
+            matches_allowed_pattern?(method_name) ||
+            braces_required_method?(method_name)
         end
 
         def special_method_proper_block_style?(node)
           method_name = node.method_name
-          return true if ignored_method?(method_name)
+          return true if allowed_method?(method_name) || matches_allowed_pattern?(method_name)
           return node.braces? if braces_required_method?(method_name)
         end
 
@@ -389,7 +425,7 @@ module RuboCop
           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
 
@@ -407,7 +443,14 @@ module RuboCop
         def array_or_range?(node)
           node.array_type? || node.range_type?
         end
+
+        def begin_required?(block_node)
+          # If the block contains `rescue` or `ensure`, it needs to be wrapped in
+          # `begin`...`end` when changing `do-end` to `{}`.
+          block_node.each_child_node(:rescue, :ensure).any? && !block_node.single_line?
+        end
       end
     end
   end
 end
+# rubocop:enable Metrics/ClassLength

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

@@ -3,11 +3,16 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of the case equality operator(===).
+      # Checks for uses of the case equality operator(===).
+      #
+      # 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
-      #   Array === something
       #   (1..100) === 7
       #   /something/ === some_string
       #
@@ -16,18 +21,21 @@ module RuboCop
       #   (1..100).include?(7)
       #   /something/.match?(some_string)
       #
-      # @example AllowOnConstant
-      #   # Style/CaseEquality:
-      #   #   AllowOnConstant: true
-      #
+      # @example AllowOnConstant: false (default)
       #   # bad
-      #   (1..100) === 7
-      #   /something/ === some_string
+      #   Array === something
       #
+      # @example AllowOnConstant: true
       #   # good
       #   Array === something
-      #   (1..100).include?(7)
-      #   /something/.match?(some_string)
+      #
+      # @example AllowOnSelfClass: false (default)
+      #   # bad
+      #   self.class === something
+      #
+      # @example AllowOnSelfClass: true
+      #   # good
+      #   self.class === something
       #
       class CaseEquality < Base
         extend AutoCorrector
@@ -36,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|
@@ -51,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)
@@ -69,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

@@ -3,9 +3,14 @@
 module RuboCop
   module Cop
     module Style
-      # This cop identifies places where `if-elsif` constructions
+      # Identifies places where `if-elsif` constructions
       # can be replaced with `case-when`.
       #
+      # @safety
+      #   This cop is unsafe. `case` statements use `===` for equality,
+      #   so if the original conditional used a different equality operator, the
+      #   behavior may be different.
+      #
       # @example
       #   # bad
       #   if status == :active

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

@@ -4,6 +4,12 @@ module RuboCop
   module Cop
     module Style
       # Checks for uses of the character literal ?x.
+      # Starting with Ruby 1.9 character literals are
+      # essentially one-character strings, so this syntax
+      # is mostly redundant at this point.
+      #
+      # ? character literal can be used to express meta and control character.
+      # That's a good use case of ? literal so it doesn't count it as an offense.
       #
       # @example
       #   # bad
@@ -12,8 +18,9 @@ module RuboCop
       #   # good
       #   'x'
       #
-      #   # good
+      #   # good - control & meta escapes
       #   ?\C-\M-d
+      #   "\C-\M-d" # same as above
       class CharacterLiteral < Base
         include StringHelp
         extend AutoCorrector
@@ -22,11 +29,11 @@ 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)
-          string = node.source[1..-1]
+          string = node.source[1..]
 
           # special character like \n
           # or ' which needs to use "" or be escaped.

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

@@ -3,9 +3,18 @@
 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
+      #   Autocorrection is unsafe.
+      #
+      #   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
+      #   have the knowledge to perform either operation safely and thus requires
+      #   manual oversight.
+      #
       # @example EnforcedStyle: nested (default)
       #   # good
       #   # have each child on its own line
@@ -108,10 +117,10 @@ 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
-          )
+          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)
+
           corrector.remove(range)
         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,17 +3,22 @@
 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!}`.
       #
-      # It is marked as unsafe by default because false positives may occur in the
-      # nil check of block arguments to the receiver object.
-      # For example, `[[1, 2], [3, nil]].reject { |first, second| second.nil? }`
-      # and `[[1, 2], [3, nil]].compact` are not compatible. This will work fine
-      # when the receiver is a hash object.
+      # @safety
+      #   It is unsafe by default because false positives may occur in the
+      #   `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
+      #   when the receiver is a hash object.
       #
       # @example
       #   # bad
+      #   array.reject(&:nil?)
       #   array.reject { |e| e.nil? }
       #   array.select { |e| !e.nil? }
       #
@@ -21,6 +26,7 @@ module RuboCop
       #   array.compact
       #
       #   # bad
+      #   hash.reject!(&:nil?)
       #   hash.reject! { |k, v| v.nil? }
       #   hash.select! { |k, v| !v.nil? }
       #
@@ -32,14 +38,21 @@ 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
+          (send !nil? {:reject :reject!}
+            (block_pass
+              (sym :nil?)))
+        PATTERN
 
         # @!method reject_method?(node)
         def_node_matcher :reject_method?, <<~PATTERN
           (block
             (send
-              _ ${:reject :reject!})
+              !nil? {:reject :reject!})
             $(args ...)
             (send
               $(lvar _) :nil?))
@@ -49,7 +62,7 @@ module RuboCop
         def_node_matcher :select_method?, <<~PATTERN
           (block
             (send
-              _ ${:select :select!})
+              !nil? {:select :select!})
             $(args ...)
             (send
               (send
@@ -57,16 +70,10 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          block_node = node.parent
-          return unless block_node&.block_type?
+          return unless (range = offense_range(node))
+          return if target_ruby_version <= 3.0 && to_enum_method?(node)
 
-          return unless (method_name, args, receiver =
-                           reject_method?(block_node) || select_method?(block_node))
-
-          return unless args.last.source == receiver.source
-
-          range = offense_range(node, block_node)
-          good = good_method_name(method_name)
+          good = good_method_name(node)
           message = format(MSG, good: good, bad: range.source)
 
           add_offense(range, message: message) { |corrector| corrector.replace(range, good) }
@@ -74,16 +81,38 @@ module RuboCop
 
         private
 
-        def good_method_name(method_name)
-          if method_name.to_s.end_with?('!')
+        def offense_range(node)
+          if reject_method_with_block_pass?(node)
+            range(node, node)
+          else
+            block_node = node.parent
+
+            return unless block_node&.block_type?
+            unless (args, receiver = reject_method?(block_node) || select_method?(block_node))
+              return
+            end
+            return unless args.last.source == receiver.source
+
+            range(node, block_node)
+          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!'
           else
             'compact'
           end
         end
 
-        def offense_range(send_node, block_node)
-          range_between(send_node.loc.selector.begin_pos, block_node.loc.end.end_pos)
+        def range(begin_pos_node, end_pos_node)
+          range_between(begin_pos_node.loc.selector.begin_pos, end_pos_node.loc.expression.end_pos)
         end
       end
     end