rubocop 0.87.0 → 0.90.0

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

@@ -23,9 +23,13 @@ module RuboCop
         MSG_2 = 'Redundant `RuntimeError.new` call can be replaced with ' \
                 'just the message.'
 
+        RAISE_METHODS = %i[raise fail].freeze
+
         # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and
         # `raise RuntimeError.new('message')` to `raise 'message'`.
         def on_send(node)
+          return unless RAISE_METHODS.include?(node.method_name)
+
           fix_exploded(node) || fix_compact(node)
         end
 

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

@@ -31,9 +31,10 @@ module RuboCop
       #   # good
       #   ENV.fetch(:key, VALUE)
       #
-      class RedundantFetchBlock < Cop
+      class RedundantFetchBlock < Base
         include FrozenStringLiteral
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
 
@@ -52,17 +53,7 @@ module RuboCop
             good = build_good_method(send, body)
             bad = build_bad_method(send, body)
 
-            add_offense(
-              node,
-              location: range,
-              message: format(MSG, good: good, bad: bad)
-            )
-          end
-        end
-
-        def autocorrect(node)
-          redundant_fetch_block_candidate?(node) do |send, body|
-            lambda do |corrector|
+            add_offense(range, message: format(MSG, good: good, bad: bad)) do |corrector|
               receiver, _, key = send.children
               default_value = body ? body.source : 'nil'
 

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the presence of superfluous `.rb` extension in
+      # the filename provided to `require` and `require_relative`.
+      #
+      # Note: If the extension is omitted, Ruby tries adding '.rb', '.so',
+      #       and so on to the name until found. If the file named cannot be found,
+      #       a `LoadError` will be raised.
+      #       There is an edge case where `foo.so` file is loaded instead of a `LoadError`
+      #       if `foo.so` file exists when `require 'foo.rb'` will be changed to `require 'foo'`,
+      #       but that seems harmless.
+      #
+      # @example
+      #   # bad
+      #   require 'foo.rb'
+      #   require_relative '../foo.rb'
+      #
+      #   # good
+      #   require 'foo'
+      #   require 'foo.so'
+      #   require_relative '../foo'
+      #   require_relative '../foo.so'
+      #
+      class RedundantFileExtensionInRequire < Base
+        extend AutoCorrector
+
+        MSG = 'Redundant `.rb` file extension detected.'
+
+        def_node_matcher :require_call?, <<~PATTERN
+          (send nil? {:require :require_relative} $str_type?)
+        PATTERN
+
+        def on_send(node)
+          require_call?(node) do |name_node|
+            return unless name_node.value.end_with?('.rb')
+
+            add_offense(name_node) do |corrector|
+              correction = name_node.value.sub(/\.rb\z/, '')
+
+              corrector.replace(name_node, "'#{correction}'")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -11,7 +11,8 @@ module RuboCop
       #
       #   # good
       #   CONST = 1
-      class RedundantFreeze < Cop
+      class RedundantFreeze < Base
+        extend AutoCorrector
         include FrozenStringLiteral
 
         MSG = 'Do not freeze immutable objects, as freezing them has no ' \
@@ -22,11 +23,7 @@ module RuboCop
                         (immutable_literal?(node.receiver) ||
                          operation_produces_immutable_object?(node.receiver))
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node) do |corrector|
             corrector.remove(node.loc.dot)
             corrector.remove(node.loc.selector)
           end

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

@@ -15,8 +15,9 @@ module RuboCop
       #
       #   # good if @var is already a String
       #   @var
-      class RedundantInterpolation < Cop
+      class RedundantInterpolation < Base
         include PercentLiteral
+        extend AutoCorrector
 
         MSG = 'Prefer `to_s` over string interpolation.'
 
@@ -25,18 +26,18 @@ module RuboCop
         end
 
         def on_dstr(node)
-          add_offense(node) if single_interpolation?(node)
-        end
-
-        def autocorrect(node)
-          embedded_node = node.children.first
-
-          if variable_interpolation?(embedded_node)
-            autocorrect_variable_interpolation(embedded_node, node)
-          elsif single_variable_interpolation?(embedded_node)
-            autocorrect_single_variable_interpolation(embedded_node, node)
-          else
-            autocorrect_other(embedded_node, node)
+          return unless single_interpolation?(node)
+
+          add_offense(node) do |corrector|
+            embedded_node = node.children.first
+
+            if variable_interpolation?(embedded_node)
+              autocorrect_variable_interpolation(corrector, embedded_node, node)
+            elsif single_variable_interpolation?(embedded_node)
+              autocorrect_single_variable_interpolation(corrector, embedded_node, node)
+            else
+              autocorrect_other(corrector, embedded_node, node)
+            end
           end
         end
 
@@ -70,27 +71,27 @@ module RuboCop
             percent_literal?(node.parent)
         end
 
-        def autocorrect_variable_interpolation(embedded_node, node)
+        def autocorrect_variable_interpolation(corrector, embedded_node, node)
           replacement = "#{embedded_node.loc.expression.source}.to_s"
-          ->(corrector) { corrector.replace(node, replacement) }
+
+          corrector.replace(node, replacement)
         end
 
-        def autocorrect_single_variable_interpolation(embedded_node, node)
+        def autocorrect_single_variable_interpolation(corrector, embedded_node, node)
           variable_loc = embedded_node.children.first.loc
           replacement = "#{variable_loc.expression.source}.to_s"
-          ->(corrector) { corrector.replace(node, replacement) }
+
+          corrector.replace(node, replacement)
         end
 
-        def autocorrect_other(embedded_node, node)
+        def autocorrect_other(corrector, embedded_node, node)
           loc = node.loc
           embedded_loc = embedded_node.loc
 
-          lambda do |corrector|
-            corrector.replace(loc.begin, '')
-            corrector.replace(loc.end, '')
-            corrector.replace(embedded_loc.begin, '(')
-            corrector.replace(embedded_loc.end, ').to_s')
-          end
+          corrector.replace(loc.begin, '')
+          corrector.replace(loc.end, '')
+          corrector.replace(embedded_loc.begin, '(')
+          corrector.replace(embedded_loc.end, ').to_s')
         end
       end
     end

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} :[] ...)'
@@ -32,10 +33,6 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          ParenthesesCorrector.correct(node)
-        end
-
         private
 
         def parens_allowed?(node)
@@ -115,15 +112,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)

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

@@ -21,9 +21,10 @@ module RuboCop
       #
       #   # good
       #   r = /[ab]/
-      class RedundantRegexpCharacterClass < Cop
+      class RedundantRegexpCharacterClass < Base
         include MatchRange
         include RegexpLiteralHelp
+        extend AutoCorrector
 
         MSG_REDUNDANT_CHARACTER_CLASS = 'Redundant single-element character class, ' \
         '`%<char_class>s` can be replaced with `%<element>s`.'
@@ -48,33 +49,25 @@ module RuboCop
             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)
           end
         end
 
-        private
-
         def without_character_class(loc)
           loc.source[1..-2]
         end

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

@@ -32,13 +32,14 @@ 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 +47,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
@@ -83,8 +74,8 @@ module RuboCop
 
         def delimiter?(node, char)
           delimiters = [
-            node.loc.begin.source.chars.last,
-            node.loc.end.source.chars.first
+            node.loc.begin.source[-1],
+            node.loc.end.source[0]
           ]
 
           delimiters.include?(char)
@@ -92,18 +83,18 @@ module RuboCop
 
         def each_escape(node)
           pattern_source(node).each_char.with_index.reduce(
-            [nil, false]
-          ) do |(previous, within_character_class), (current, index)|
+            [nil, 0]
+          ) do |(previous, char_class_depth), (current, index)|
             if previous == '\\'
-              yield [current, index - 1, within_character_class]
+              yield [current, index - 1, !char_class_depth.zero?]
 
-              [nil, within_character_class]
-            elsif previous == '[' && current != ':'
-              [current, true]
-            elsif previous != ':' && current == ']'
-              [current, false]
+              [nil, char_class_depth]
+            elsif previous == '['
+              [current, char_class_depth + 1]
+            elsif current == ']'
+              [current, char_class_depth - 1]
             else
-              [current, within_character_class]
+              [current, char_class_depth]
             end
           end
         end

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

@@ -57,7 +57,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
@@ -123,7 +123,7 @@ module RuboCop
         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! to_ary
+          to_hash 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