rubocop 0.51.0 → 0.52.0

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

@@ -5,50 +5,49 @@ module RuboCop
     module Style
       # This cop checks for redundant uses of `self`.
       #
-      # `self` is only needed when:
+      # The usage of `self` is only needed when:
       #
       # * Sending a message to same object with zero arguments in
       #   presence of a method name clash with an argument or a local
       #   variable.
       #
-      #   Note, with using explicit self you can only send messages
-      #   with public or protected scope, you cannot send private
-      #   messages this way.
+      # * Calling an attribute writer to prevent an local variable assignment.
       #
-      #   Example:
+      # Note, with using explicit self you can only send messages with public or
+      # protected scope, you cannot send private messages this way.
       #
-      #   def bar
-      #     :baz
-      #   end
+      # Note we allow uses of `self` with operators because it would be awkward
+      # otherwise.
+      #
+      # @example
       #
+      #   # bad
       #   def foo(bar)
-      #     self.bar # resolves name clash with argument
+      #     self.baz
       #   end
       #
-      #   def foo2
-      #     bar = 1
-      #     self.bar # resolves name clash with local variable
+      #   # good
+      #   def foo(bar)
+      #     self.bar  # Resolves name clash with the argument.
       #   end
       #
-      #   %w[x y z].select do |bar|
-      #     self.bar == bar # resolves name clash with argument of a block
+      #   def foo
+      #     bar = 1
+      #     self.bar  # Resolves name clash with the local variable.
       #   end
       #
-      # * Calling an attribute writer to prevent an local variable assignment
-      #
-      #   attr_writer :bar
-      #
       #   def foo
-      #     self.bar= 1 # Make sure above attr writer is called
+      #     %w[x y z].select do |bar|
+      #       self.bar == bar  # Resolves name clash with argument of the block.
+      #     end
       #   end
-      #
-      # Special cases:
-      #
-      # We allow uses of `self` with operators because it would be awkward
-      # otherwise.
       class RedundantSelf < Cop
         MSG = 'Redundant `self` detected.'.freeze
 
+        def self.autocorrect_incompatible_with
+          [ColonMethodCall]
+        end
+
         def initialize(config = nil, options = nil)
           super
           @allowed_send_nodes = []
@@ -101,8 +100,6 @@ module RuboCop
           add_scope(node, @local_variables_scopes[node])
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             corrector.remove(node.receiver.source_range)
@@ -110,6 +107,8 @@ module RuboCop
           end
         end
 
+        private
+
         def add_scope(node, local_variables = [])
           node.descendants.each do |child_node|
             @local_variables_scopes[child_node] = local_variables

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

@@ -5,28 +5,81 @@ module RuboCop
     module Style
       # This cop enforces using // or %r around regular expressions.
       #
-      # @example
-      #   # Good if EnforcedStyle is slashes or mixed, bad if percent_r.
+      # @example EnforcedStyle: slashes (default)
+      #   # bad
+      #   snake_case = %r{^[\dA-Z_]+$}
+      #
+      #   # bad
+      #   regex = %r{
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   }x
+      #
+      #   # good
       #   snake_case = /^[\dA-Z_]+$/
       #
-      #   # Good if EnforcedStyle is percent_r, bad if slashes or mixed.
+      #   # good
+      #   regex = /
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   /x
+      #
+      # @example EnforcedStyle: percent_r
+      #   # bad
+      #   snake_case = /^[\dA-Z_]+$/
+      #
+      #   # bad
+      #   regex = /
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   /x
+      #
+      #   # good
+      #   snake_case = %r{^[\dA-Z_]+$}
+      #
+      #   # good
+      #   regex = %r{
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   }x
+      #
+      # @example EnforcedStyle: mixed
+      #   # bad
       #   snake_case = %r{^[\dA-Z_]+$}
       #
-      #   # Good if EnforcedStyle is slashes, bad if percent_r or mixed.
+      #   # bad
       #   regex = /
       #     foo
       #     (bar)
       #     (baz)
       #   /x
       #
-      #   # Good if EnforcedStyle is percent_r or mixed, bad if slashes.
+      #   # good
+      #   snake_case = /^[\dA-Z_]+$/
+      #
+      #   # good
       #   regex = %r{
       #     foo
       #     (bar)
       #     (baz)
       #   }x
       #
-      #   # Bad unless AllowInnerSlashes is true.
+      # @example AllowInnerSlashes: false (default)
+      #   # If `false`, the cop will always recommend using `%r` if one or more
+      #   # slashes are found in the regexp string.
+      #
+      #   # bad
+      #   x =~ /home\//
+      #
+      #   # good
+      #   x =~ %r{home/}
+      #
+      # @example AllowInnerSlashes: true
+      #   # good
       #   x =~ /home\//
       class RegexpLiteral < Cop
         include ConfigurableEnforcedStyle
@@ -42,6 +95,21 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          return if contains_slash?(node)
+
+          replacement = if slash_literal?(node)
+                          ['%r', ''].zip(preferred_delimiters).map(&:join)
+                        else
+                          %w[/ /]
+                        end
+
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, replacement.first)
+            corrector.replace(node.loc.end, replacement.last)
+          end
+        end
+
         private
 
         def check_slash_literal(node)
@@ -101,21 +169,6 @@ module RuboCop
           config.for_cop('Style/PercentLiteralDelimiters') \
             ['PreferredDelimiters']['%r'].split(//)
         end
-
-        def autocorrect(node)
-          return if contains_slash?(node)
-
-          replacement = if slash_literal?(node)
-                          ['%r', ''].zip(preferred_delimiters).map(&:join)
-                        else
-                          %w[/ /]
-                        end
-
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, replacement.first)
-            corrector.replace(node.loc.end, replacement.last)
-          end
-        end
       end
     end
   end

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

@@ -4,6 +4,17 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for uses of rescue in its modifier form.
+      #
+      # @example
+      #   # bad
+      #   some_method rescue handle_error
+      #
+      #   # good
+      #   begin
+      #     some_method
+      #   rescue
+      #     handle_error
+      #   end
       class RescueModifier < Cop
         include AutocorrectAlignment
         include RescueNode

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for rescuing `StandardError`. There are two supported
+      # styles `implicit` and `explicit`. This cop will not register an offense
+      # if any error other than `StandardError` is specified.
+      #
+      # @example EnforcedStyle: implicit
+      #   # `implicit` will enforce using `rescue` instead of
+      #   # `rescue StandardError`.
+      #
+      #   # bad
+      #   begin
+      #     foo
+      #   rescue StandardError
+      #     bar
+      #   end
+      #
+      #   # good
+      #   begin
+      #     foo
+      #   rescue
+      #     bar
+      #   end
+      #
+      #   # good
+      #   begin
+      #     foo
+      #   rescue OtherError
+      #     bar
+      #   end
+      #
+      #   # good
+      #   begin
+      #     foo
+      #   rescue StandardError, SecurityError
+      #     bar
+      #   end
+      #
+      # @example EnforcedStyle: explicit (default)
+      #   # `explicit` will enforce using `rescue StandardError`
+      #   # instead of `rescue`.
+      #
+      #   # bad
+      #   begin
+      #     foo
+      #   rescue
+      #     bar
+      #   end
+      #
+      #   # good
+      #   begin
+      #     foo
+      #   rescue StandardError
+      #     bar
+      #   end
+      #
+      #   # good
+      #   begin
+      #     foo
+      #   rescue OtherError
+      #     bar
+      #   end
+      #
+      #   # good
+      #   begin
+      #     foo
+      #   rescue StandardError, SecurityError
+      #     bar
+      #   end
+      class RescueStandardError < Cop
+        include RescueNode
+        include ConfigurableEnforcedStyle
+
+        MSG_IMPLICIT = 'Omit the error class when rescuing ' \
+          '`StandardError` by itself.'.freeze
+        MSG_EXPLICIT = 'Avoid rescuing without specifying ' \
+          'an error class.'.freeze
+
+        def_node_matcher :rescue_without_error_class?, <<-PATTERN
+          (resbody nil? _ _)
+        PATTERN
+
+        def_node_matcher :rescue_standard_error?, <<-PATTERN
+          (resbody $(array (const nil? :StandardError)) _ _)
+        PATTERN
+
+        def on_resbody(node)
+          return if rescue_modifier?(node)
+          case style
+          when :implicit
+            rescue_standard_error?(node) do |error|
+              add_offense(node,
+                          location: node.loc.keyword.join(error.loc.expression),
+                          message: MSG_IMPLICIT)
+            end
+          when :explicit
+            rescue_without_error_class?(node) do
+              add_offense(node, location: :keyword, message: MSG_EXPLICIT)
+            end
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            case style
+            when :implicit
+              error = rescue_standard_error?(node)
+              range = range_between(node.loc.keyword.end_pos,
+                                    error.loc.expression.end_pos)
+              corrector.remove(range)
+            when :explicit
+              corrector.insert_after(node.loc.keyword, ' StandardError')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,10 +7,7 @@ module RuboCop
       #
       # Supported styles are: return, return_nil.
       #
-      # @example
-      #
-      #   # EnforcedStyle: return (default)
-      #
+      # @example EnforcedStyle: return (default)
       #   # bad
       #   def foo(arg)
       #     return nil if arg
@@ -21,8 +18,7 @@ module RuboCop
       #     return if arg
       #   end
       #
-      #   # EnforcedStyle: return_nil
-      #
+      # @example EnforcedStyle: return_nil
       #   # bad
       #   def foo(arg)
       #     return if arg
@@ -61,8 +57,6 @@ module RuboCop
           add_offense(node) unless correct_style?(node)
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             corrected = style == :return ? 'return' : 'return nil'
@@ -70,6 +64,8 @@ module RuboCop
           end
         end
 
+        private
+
         def message(_node)
           style == :return ? RETURN_MSG : RETURN_NIL_MSG
         end

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

@@ -150,18 +150,36 @@ module RuboCop
                        node.receiver
                      end
 
-          return receiver if receiver == checked_variable
+          if receiver == checked_variable
+            return nil if assignment_arithmetic_or_comparison?(node)
+
+            return receiver
+          end
 
           find_matching_receiver_invocation(receiver, checked_variable)
         end
 
+        def assignment_arithmetic_or_comparison?(node)
+          node.assignment? ||
+            node.parent.arithmetic_operation? ||
+            comparison_node?(node.parent)
+        end
+
+        def comparison_node?(parent)
+          parent.send_type? && parent.comparison_method?
+        end
+
         def unsafe_method?(send_node)
           NIL_METHODS.include?(send_node.method_name) ||
             negated?(send_node) || !send_node.dot?
         end
 
         def negated?(send_node)
-          send_node.parent.send_type? && send_node.parent.method?(:!)
+          if send_node.parent && send_node.parent.send_type?
+            negated?(send_node.parent)
+          else
+            send_node.send_type? && send_node.method?(:!)
+          end
         end
 
         def begin_range(node, method_call)

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

@@ -13,7 +13,7 @@ module RuboCop
       #   # good
       #   x += 1
       class SelfAssignment < Cop
-        MSG = 'Use self-assignment shorthand `%s=`.'.freeze
+        MSG = 'Use self-assignment shorthand `%<method>s=`.'.freeze
         OPS = %i[+ - * ** / | &].freeze
 
         def self.autocorrect_incompatible_with
@@ -32,6 +32,16 @@ module RuboCop
           check(node, :cvar)
         end
 
+        def autocorrect(node)
+          _var_name, rhs = *node
+
+          if rhs.send_type?
+            autocorrect_send_node(node, rhs)
+          elsif %i[and or].include?(rhs.type)
+            autocorrect_boolean_node(node, rhs)
+          end
+        end
+
         private
 
         def check(node, var_type)
@@ -52,7 +62,7 @@ module RuboCop
           target_node = s(var_type, var_name)
           return unless receiver == target_node
 
-          add_offense(node, message: format(MSG, method_name))
+          add_offense(node, message: format(MSG, method: method_name))
         end
 
         def check_boolean_node(node, rhs, var_name, var_type)
@@ -62,17 +72,7 @@ module RuboCop
           return unless first_operand == target_node
 
           operator = rhs.loc.operator.source
-          add_offense(node, message: format(MSG, operator))
-        end
-
-        def autocorrect(node)
-          _var_name, rhs = *node
-
-          if rhs.send_type?
-            autocorrect_send_node(node, rhs)
-          elsif %i[and or].include?(rhs.type)
-            autocorrect_boolean_node(node, rhs)
-          end
+          add_offense(node, message: format(MSG, method: operator))
         end
 
         def autocorrect_send_node(node, rhs)