rubocop 0.49.1 → 0.52.0

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
@@ -12,7 +23,7 @@ module RuboCop
 
         def on_resbody(node)
           return unless rescue_modifier?(node)
-          add_offense(node.parent, :expression)
+          add_offense(node.parent)
         end
 
         def autocorrect(node)

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces consistency between 'return nil' and 'return'.
+      #
+      # Supported styles are: return, return_nil.
+      #
+      # @example EnforcedStyle: return (default)
+      #   # bad
+      #   def foo(arg)
+      #     return nil if arg
+      #   end
+      #
+      #   # good
+      #   def foo(arg)
+      #     return if arg
+      #   end
+      #
+      # @example EnforcedStyle: return_nil
+      #   # bad
+      #   def foo(arg)
+      #     return if arg
+      #   end
+      #
+      #   # good
+      #   def foo(arg)
+      #     return nil if arg
+      #   end
+      class ReturnNil < Cop
+        include ConfigurableEnforcedStyle
+
+        RETURN_MSG = 'Use `return` instead of `return nil`.'.freeze
+        RETURN_NIL_MSG = 'Use `return nil` instead of `return`.'.freeze
+
+        def_node_matcher :return_node?, '(return)'
+        def_node_matcher :return_nil_node?, '(return nil)'
+
+        def on_return(node)
+          # Check Lint/NonLocalExitFromIterator first before this cop
+          node.each_ancestor(:block, :def, :defs) do |n|
+            break if scoped_node?(n)
+
+            send_node, args_node, _body_node = *n
+
+            # if a proc is passed to `Module#define_method` or
+            # `Object#define_singleton_method`, `return` will not cause a
+            # non-local exit error
+            break if define_method?(send_node)
+
+            next if args_node.children.empty?
+
+            return nil if chained_send?(send_node)
+          end
+
+          add_offense(node) unless correct_style?(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrected = style == :return ? 'return' : 'return nil'
+            corrector.replace(node.source_range, corrected)
+          end
+        end
+
+        private
+
+        def message(_node)
+          style == :return ? RETURN_MSG : RETURN_NIL_MSG
+        end
+
+        def correct_style?(node)
+          style == :return && !return_nil_node?(node) ||
+            style == :return_nil && !return_node?(node)
+        end
+
+        def scoped_node?(node)
+          node.def_type? || node.defs_type? || node.lambda?
+        end
+
+        def_node_matcher :chained_send?, '(send !nil? ...)'
+        def_node_matcher :define_method?, <<-PATTERN
+          (send _ {:define_method :define_singleton_method} _)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -52,29 +52,26 @@ module RuboCop
 
         minimum_target_ruby_version 2.3
 
-        def_node_matcher :safe_navigation_candidate, <<-PATTERN
+        # if format: (if checked_variable body nil)
+        # unless format: (if checked_variable nil body)
+        def_node_matcher :modifier_if_safe_navigation_candidate?, <<-PATTERN
           {
-            (if
-              {(send (send $_ :nil?) :!) $_}
-              {(send $_ $_ ...) (block (send $_ $_ ...) ...)}
-            ...)
-            (if
-              (send $_ {:nil? :!}) nil
-              {(send $_ $_ ...) (block (send $_ $_ ...) ...)}
-            ...)
+            (if {
+                  (send $_ {:nil? :!})
+                  $_
+                } nil? $_)
+
+            (if {
+                  (send (send $_ :nil?) :!)
+                  $_
+                } $_ nil?)
           }
         PATTERN
 
-        def_node_matcher :candidate_that_may_introduce_nil, <<-PATTERN
-          (and
-            {(send (send $_ :nil?) :!) $_}
-            {(send $_ $_ ...) (block (send $_ $_ ...) ...)}
-          ...)
-        PATTERN
+        def_node_matcher :not_nil_check?, '(send (send $_ :nil?) :!)'
 
         def on_if(node)
-          return if node.ternary?
-
+          return if allowed_if_condition?(node)
           check_node(node)
         end
 
@@ -82,62 +79,117 @@ module RuboCop
           check_node(node)
         end
 
-        def on_or(node)
-          check_node(node)
-        end
-
         def check_node(node)
           return if target_ruby_version < 2.3
-          return if allowed_if_condition?(node)
           checked_variable, receiver, method = extract_parts(node)
           return unless receiver == checked_variable
-          return if NIL_METHODS.include?(method)
-          return unless method =~ /\w+[=!?]?/
+          return if unsafe_method?(method)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
+        def autocorrect(node)
+          _check, body, = node.node_parts
+          _checked_variable, matching_receiver, = extract_parts(node)
+          method_call, = matching_receiver.parent
+
+          lambda do |corrector|
+            corrector.remove(begin_range(node, body))
+            corrector.remove(end_range(node, body))
+            corrector.insert_before((method_call || body).loc.dot, '&')
+          end
+        end
+
+        private
+
         def allowed_if_condition?(node)
-          node.if_type? && (node.else? || node.elsif?)
+          node.else? || node.elsif? || node.ternary?
         end
 
         def extract_parts(node)
-          if cop_config['ConvertCodeThatCanStartToReturnNil']
-            safe_navigation_candidate(node) ||
-              candidate_that_may_introduce_nil(node)
-          else
-            safe_navigation_candidate(node)
+          case node.type
+          when :if
+            extract_parts_from_if(node)
+          when :and
+            extract_parts_from_and(node)
           end
         end
 
-        def autocorrect(node)
-          if node.if_type?
-            _check, body, = *node.node_parts
-          else
-            _check, body = *node
+        def extract_parts_from_if(node)
+          checked_variable, receiver =
+            modifier_if_safe_navigation_candidate?(node)
+
+          extract_common_parts(receiver, checked_variable)
+        end
+
+        def extract_parts_from_and(node)
+          checked_variable, rhs = *node
+          if cop_config['ConvertCodeThatCanStartToReturnNil']
+            checked_variable =
+              not_nil_check?(checked_variable) || checked_variable
           end
 
-          method_call, = *body if body.block_type?
+          extract_common_parts(rhs, checked_variable)
+        end
 
-          lambda do |corrector|
-            corrector.remove(begin_range(node, body))
-            corrector.remove(end_range(node, body))
-            corrector.insert_before((method_call || body).loc.dot, '&')
+        def extract_common_parts(continuation, checked_variable)
+          matching_receiver =
+            find_matching_receiver_invocation(continuation, checked_variable)
+
+          method = matching_receiver.parent if matching_receiver
+
+          [checked_variable, matching_receiver, method]
+        end
+
+        def find_matching_receiver_invocation(node, checked_variable)
+          return nil unless node
+
+          receiver = if node.block_type?
+                       node.send_node.receiver
+                     else
+                       node.receiver
+                     end
+
+          if receiver == checked_variable
+            return nil if assignment_arithmetic_or_comparison?(node)
+
+            return receiver
           end
+
+          find_matching_receiver_invocation(receiver, checked_variable)
         end
 
-        private
+        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)
+          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)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    node.loc.expression.begin_pos,
-                                    method_call.loc.expression.begin_pos)
+          range_between(node.loc.expression.begin_pos,
+                        method_call.loc.expression.begin_pos)
         end
 
         def end_range(node, method_call)
-          Parser::Source::Range.new(node.loc.expression,
-                                    method_call.loc.expression.end_pos,
-                                    node.loc.expression.end_pos)
+          range_between(method_call.loc.expression.end_pos,
+                        node.loc.expression.end_pos)
         end
       end
     end

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, :expression, 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, :expression, 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)