rubocop 0.89.1 → 0.93.0

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

@@ -13,8 +13,9 @@ module RuboCop
       #   # good
       #   x if y.z.nil?
       #
-      class RedundantParentheses < Cop
+      class RedundantParentheses < Base
         include Parentheses
+        extend AutoCorrector
 
         def_node_matcher :square_brackets?,
                          '(send {(send _recv _msg) str array hash} :[] ...)'
@@ -25,17 +26,11 @@ module RuboCop
                          '^^(block (send _ _ equal?(%0) ...) ...)'
 
         def on_begin(node)
-          return if !parentheses?(node) || parens_allowed?(node)
-          return if node.parent && (node.parent.while_post_type? ||
-                                    node.parent.until_post_type?)
+          return if !parentheses?(node) || parens_allowed?(node) || ignore_syntax?(node)
 
           check(node)
         end
 
-        def autocorrect(node)
-          ParenthesesCorrector.correct(node)
-        end
-
         private
 
         def parens_allowed?(node)
@@ -45,6 +40,13 @@ module RuboCop
             allowed_expression?(node)
         end
 
+        def ignore_syntax?(node)
+          return false unless (parent = node.parent)
+
+          parent.while_post_type? || parent.until_post_type? ||
+            like_method_argument_parentheses?(parent)
+        end
+
         def allowed_expression?(node)
           allowed_ancestor?(node) ||
             allowed_method_call?(node) ||
@@ -71,6 +73,10 @@ module RuboCop
           !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
         end
 
+        def like_method_argument_parentheses?(node)
+          node.send_type? && node.arguments.size == 1 && !node.arithmetic_operation?
+        end
+
         def empty_parentheses?(node)
           # Don't flag `()`
           node.children.empty?
@@ -115,15 +121,16 @@ module RuboCop
 
           node = node.children.first while suspect_unary?(node)
 
-          if node.send_type?
-            return unless method_call_with_redundant_parentheses?(node)
-          end
+          return if node.send_type? &&
+                    !method_call_with_redundant_parentheses?(node)
 
           offense(begin_node, 'an unary operation')
         end
 
         def offense(node, msg)
-          add_offense(node, message: "Don't use parentheses around #{msg}.")
+          add_offense(node, message: "Don't use parentheses around #{msg}.") do |corrector|
+            ParenthesesCorrector.correct(corrector, node)
+          end
         end
 
         def suspect_unary?(node)
@@ -168,10 +175,9 @@ module RuboCop
         def raised_to_power_negative_numeric?(begin_node, node)
           return false unless node.numeric_type?
 
-          siblings = begin_node.parent&.children
-          return false if siblings.nil?
+          next_sibling = begin_node.right_sibling
+          return false unless next_sibling
 
-          next_sibling = siblings[begin_node.sibling_index + 1]
           base_value = node.children.first
 
           base_value.negative? && next_sibling == :**

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

@@ -17,7 +17,9 @@ module RuboCop
       #   time = "8 o'clock"
       #   question = '"What did you say?"'
       #
-      class RedundantPercentQ < Cop
+      class RedundantPercentQ < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<q_type>s` only for strings that contain both ' \
               'single quotes and double quotes%<extra>s.'
         DYNAMIC_MSG = ', or for dynamic strings that contain ' \
@@ -45,22 +47,18 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          delimiter =
-            /^%Q[^"]+$|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, delimiter)
-            corrector.replace(node.loc.end, delimiter)
-          end
-        end
-
         private
 
         def check(node)
           return unless start_with_percent_q_variant?(node)
           return if interpolated_quotes?(node) || allowed_percent_q?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            delimiter = /^%Q[^"]+$|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
+
+            corrector.replace(node.loc.begin, delimiter)
+            corrector.replace(node.loc.end, delimiter)
+          end
         end
 
         def interpolated_quotes?(node)

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

@@ -21,68 +21,76 @@ module RuboCop
       #
       #   # good
       #   r = /[ab]/
-      class RedundantRegexpCharacterClass < Cop
-        include MatchRange
-        include RegexpLiteralHelp
+      class RedundantRegexpCharacterClass < Base
+        extend AutoCorrector
 
+        REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS = '.*+?{}()|$'.chars.freeze
         MSG_REDUNDANT_CHARACTER_CLASS = 'Redundant single-element character class, ' \
         '`%<char_class>s` can be replaced with `%<element>s`.'
 
-        PATTERN = /
-          (
-            (?<!\\)           # No \-prefix (i.e. not escaped)
-            \[                # Literal [
-            (?!\#\{)          # Not (the start of) an interpolation
-            (?:               # Either...
-             \\[^b] |         # Any escaped character except b (which would change behaviour)
-             [^.*+?{}()|$] |  # or one that doesn't require escaping outside the character class
-             \\[upP]\{[^}]+\} # or a unicode code-point or property
-            )
-            (?<!\\)           # No \-prefix (i.e. not escaped)
-            \]                # Literal ]
-          )
-        /x.freeze
-
         def on_regexp(node)
           each_redundant_character_class(node) do |loc|
-            next if whitespace_in_free_space_mode?(node, loc)
-
             add_offense(
-              node,
-              location: loc,
-              message: format(
+              loc, message: format(
                 MSG_REDUNDANT_CHARACTER_CLASS,
                 char_class: loc.source,
                 element: without_character_class(loc)
               )
-            )
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            each_redundant_character_class(node) do |loc|
+            ) do |corrector|
               corrector.replace(loc, without_character_class(loc))
             end
           end
         end
 
+        private
+
         def each_redundant_character_class(node)
-          pattern_source(node).scan(PATTERN) do
-            yield match_range(node.loc.begin.end, Regexp.last_match)
+          each_single_element_character_class(node) do |char_class|
+            next unless redundant_single_element_character_class?(node, char_class)
+
+            yield node.loc.begin.adjust(begin_pos: 1 + char_class.ts, end_pos: char_class.te)
           end
         end
 
-        private
+        def each_single_element_character_class(node)
+          node.parsed_tree&.each_expression do |expr|
+            next if expr.type != :set || expr.expressions.size != 1
+            next if expr.negative?
+            next if %i[set posixclass nonposixclass].include?(expr.expressions.first.type)
+
+            yield expr
+          end
+        end
+
+        def redundant_single_element_character_class?(node, char_class)
+          class_elem = char_class.expressions.first.text
+
+          non_redundant =
+            whitespace_in_free_space_mode?(node, class_elem) ||
+            backslash_b?(class_elem) ||
+            requires_escape_outside_char_class?(class_elem)
+
+          !non_redundant
+        end
 
         def without_character_class(loc)
           loc.source[1..-2]
         end
 
-        def whitespace_in_free_space_mode?(node, loc)
-          return false unless freespace_mode_regexp?(node)
+        def whitespace_in_free_space_mode?(node, elem)
+          return false unless node.extended?
+
+          /\s/.match?(elem)
+        end
+
+        def backslash_b?(elem)
+          # \b's behaviour is different inside and outside of a character class, matching word
+          # boundaries outside but backspace (0x08) when inside.
+          elem == '\b'
+        end
 
-          /\[\s\]/.match?(loc.source)
+        def requires_escape_outside_char_class?(elem)
+          REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS.include?(elem)
         end
       end
     end

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

@@ -32,13 +32,13 @@ module RuboCop
       #
       #   # good
       #   /[+\-]\d/
-      class RedundantRegexpEscape < Cop
+      class RedundantRegexpEscape < Base
         include RangeHelp
-        include RegexpLiteralHelp
+        extend AutoCorrector
 
         MSG_REDUNDANT_ESCAPE = 'Redundant escape inside regexp literal'
 
-        ALLOWED_ALWAYS_ESCAPES = ' []^\\#'.chars.freeze
+        ALLOWED_ALWAYS_ESCAPES = " \n[]^\\#".chars.freeze
         ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = '-'.chars.freeze
         ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = '.*+?{}()|$'.chars.freeze
 
@@ -46,19 +46,9 @@ module RuboCop
           each_escape(node) do |char, index, within_character_class|
             next if allowed_escape?(node, char, within_character_class)
 
-            add_offense(
-              node,
-              location: escape_range_at_index(node, index),
-              message: MSG_REDUNDANT_ESCAPE
-            )
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            each_escape(node) do |char, index, within_character_class|
-              next if allowed_escape?(node, char, within_character_class)
+            location = escape_range_at_index(node, index)
 
+            add_offense(location, message: MSG_REDUNDANT_ESCAPE) do |corrector|
               corrector.remove_leading(escape_range_at_index(node, index), 1)
             end
           end
@@ -68,9 +58,9 @@ module RuboCop
 
         def allowed_escape?(node, char, within_character_class)
           # Strictly speaking a few single-letter metachars are currently
-          # unnecessary to "escape", e.g. g, i, E, F, but enumerating them is
+          # unnecessary to "escape", e.g. i, E, F, but enumerating them is
           # rather difficult, and their behaviour could change over time with
-          # different versions of Ruby so that e.g. /\g/ != /g/
+          # different versions of Ruby so that e.g. /\i/ != /i/
           return true if /[[:alnum:]]/.match?(char)
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
 
@@ -91,19 +81,13 @@ module RuboCop
         end
 
         def each_escape(node)
-          pattern_source(node).each_char.with_index.reduce(
-            [nil, 0]
-          ) do |(previous, char_class_depth), (current, index)|
-            if previous == '\\'
-              yield [current, index - 1, !char_class_depth.zero?]
-
-              [nil, char_class_depth]
-            elsif previous == '['
-              [current, char_class_depth + 1]
-            elsif current == ']'
-              [current, char_class_depth - 1]
+          node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
+            yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape
+
+            if expr.type == :set
+              char_class_depth + (event == :enter ? 1 : -1)
             else
-              [current, char_class_depth]
+              char_class_depth
             end
           end
         end

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

@@ -47,8 +47,9 @@ module RuboCop
       #     return x, y
       #   end
       #
-      class RedundantReturn < Cop
+      class RedundantReturn < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Redundant `return` detected.'
         MULTI_RETURN_MSG = 'To return multiple values, use an array.'
@@ -58,16 +59,6 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if node.arguments?
-              correct_with_arguments(node, corrector)
-            else
-              correct_without_arguments(node, corrector)
-            end
-          end
-        end
-
         private
 
         def correct_without_arguments(return_node, corrector)
@@ -108,8 +99,8 @@ module RuboCop
           when :return then check_return_node(node)
           when :case   then check_case_node(node)
           when :if     then check_if_node(node)
-          when :rescue, :resbody
-            check_rescue_node(node)
+          when :rescue then check_rescue_node(node)
+          when :resbody then check_resbody_node(node)
           when :ensure then check_ensure_node(node)
           when :begin, :kwbegin
             check_begin_node(node)
@@ -121,7 +112,13 @@ module RuboCop
           return if cop_config['AllowMultipleReturnValues'] &&
                     node.children.size > 1
 
-          add_offense(node, location: :keyword)
+          add_offense(node.loc.keyword, message: message(node)) do |corrector|
+            if node.arguments?
+              correct_with_arguments(node, corrector)
+            else
+              correct_without_arguments(node, corrector)
+            end
+          end
         end
 
         def check_case_node(node)
@@ -137,9 +134,12 @@ module RuboCop
         end
 
         def check_rescue_node(node)
-          node.child_nodes.each do |child_node|
-            check_branch(child_node)
-          end
+          node.branches.each { |branch| check_branch(branch) }
+          check_branch(node.body) unless node.else?
+        end
+
+        def check_resbody_node(node)
+          check_branch(node.body)
         end
 
         def check_ensure_node(node)

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

@@ -41,7 +41,9 @@ module RuboCop
       #       self.bar == bar  # Resolves name clash with argument of the block.
       #     end
       #   end
-      class RedundantSelf < Cop
+      class RedundantSelf < Base
+        extend AutoCorrector
+
         MSG = 'Redundant `self` detected.'
         KERNEL_METHODS = Kernel.methods(false)
         KEYWORDS = %i[alias and begin break case class def defined? do
@@ -57,7 +59,7 @@ module RuboCop
         def initialize(config = nil, options = nil)
           super
           @allowed_send_nodes = []
-          @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }
+          @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }.compare_by_identity
         end
 
         # Assignment of self.x
@@ -106,24 +108,20 @@ module RuboCop
 
           return if allowed_send_node?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            corrector.remove(node.receiver)
+            corrector.remove(node.loc.dot)
+          end
         end
 
         def on_block(node)
           add_scope(node, @local_variables_scopes[node])
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.receiver)
-            corrector.remove(node.loc.dot)
-          end
-        end
-
         private
 
         def add_scope(node, local_variables = [])
-          node.descendants.each do |child_node|
+          node.each_descendant do |child_node|
             @local_variables_scopes[child_node] = local_variables
           end
         end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where redundant assignments are made for in place
+      # modification methods.
+      #
+      # This cop is marked as unsafe, because it can produce false positives for
+      # user defined methods having one of the expected names, but not modifying
+      # its receiver in place.
+      #
+      # @example
+      #   # bad
+      #   args = args.concat(ary)
+      #   hash = hash.merge!(other)
+      #
+      #   # good
+      #   args.concat(foo)
+      #   args += foo
+      #   hash.merge!(other)
+      #
+      #   # bad
+      #   self.foo = foo.concat(ary)
+      #
+      #   # good
+      #   foo.concat(ary)
+      #   self.foo += ary
+      #
+      class RedundantSelfAssignment < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Redundant self assignment detected. '\
+              'Method `%<method_name>s` modifies its receiver in place.'
+
+        METHODS_RETURNING_SELF = %i[
+          append clear collect! compare_by_identity concat delete_if
+          fill initialize_copy insert keep_if map! merge! prepend push
+          rehash replace reverse! rotate! shuffle! sort! sort_by!
+          transform_keys! transform_values! unshift update
+        ].to_set.freeze
+
+        ASSIGNMENT_TYPE_TO_RECEIVER_TYPE = {
+          lvasgn: :lvar,
+          ivasgn: :ivar,
+          cvasgn: :cvar,
+          gvasgn: :gvar
+        }.freeze
+
+        def on_lvasgn(node)
+          lhs, rhs = *node
+          receiver, method_name, = *rhs
+          return unless receiver && method_returning_self?(method_name)
+
+          receiver_type = ASSIGNMENT_TYPE_TO_RECEIVER_TYPE[node.type]
+          return unless receiver.type == receiver_type && receiver.children.first == lhs
+
+          message = format(MSG, method_name: method_name)
+          add_offense(node.loc.operator, message: message) do |corrector|
+            corrector.replace(node, rhs.source)
+          end
+        end
+        alias on_ivasgn on_lvasgn
+        alias on_cvasgn on_lvasgn
+        alias on_gvasgn on_lvasgn
+
+        def on_send(node)
+          # TODO: replace with #end_with? after supporting only ruby >= 2.7
+          return unless node.method_name.match?(/=$/)
+          return unless redundant_assignment?(node)
+
+          message = format(MSG, method_name: node.first_argument.method_name)
+          add_offense(node.loc.operator, message: message) do |corrector|
+            corrector.remove(correction_range(node))
+          end
+        end
+
+        private
+
+        def method_returning_self?(method_name)
+          METHODS_RETURNING_SELF.include?(method_name)
+        end
+
+        def_node_matcher :redundant_self_assignment?, <<~PATTERN
+          (send
+            (self) _
+            (send
+              (send
+                {(self) nil?} %1) #method_returning_self?
+              ...))
+        PATTERN
+
+        def_node_matcher :redundant_nonself_assignment?, <<~PATTERN
+          (send
+            %1 _
+            (send
+              (send
+                %1 %2) #method_returning_self?
+              ...))
+        PATTERN
+
+        def redundant_assignment?(node)
+          receiver_name = node.method_name.to_s[0...-1].to_sym
+
+          redundant_self_assignment?(node, receiver_name) ||
+            redundant_nonself_assignment?(node, node.receiver, receiver_name)
+        end
+
+        def correction_range(node)
+          range_between(node.source_range.begin_pos, node.first_argument.source_range.begin_pos)
+        end
+      end
+    end
+  end
+end