rubocop 0.52.1 → 0.93.1

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

@@ -5,42 +5,87 @@ module RuboCop
     module Style
       # This cop checks for uses of rescue in its modifier form.
       #
+      # The cop to check `rescue` in its modifier form is added for following
+      # reasons:
+      #
+      # * The syntax of modifier form `rescue` can be misleading because it
+      #   might led us to believe that `rescue` handles the given exception
+      #   but it actually rescue all exceptions to return the given rescue
+      #   block. In this case, value returned by handle_error or
+      #   SomeException.
+      #
+      # * Modifier form `rescue` would rescue all the exceptions. It would
+      #   silently skip all exception or errors and handle the error.
+      #   Example: If `NoMethodError` is raised, modifier form rescue would
+      #   handle the exception.
+      #
       # @example
       #   # bad
       #   some_method rescue handle_error
       #
+      #   # bad
+      #   some_method rescue SomeException
+      #
       #   # good
       #   begin
       #     some_method
       #   rescue
       #     handle_error
       #   end
+      #
+      #   # good
+      #   begin
+      #     some_method
+      #   rescue SomeException
+      #     handle_error
+      #   end
       class RescueModifier < Cop
         include Alignment
         include RescueNode
 
-        MSG = 'Avoid using `rescue` in its modifier form.'.freeze
+        MSG = 'Avoid using `rescue` in its modifier form.'
 
         def on_resbody(node)
           return unless rescue_modifier?(node)
+
           add_offense(node.parent)
         end
 
         def autocorrect(node)
+          parenthesized = parenthesized?(node)
+          lambda do |corrector|
+            corrector.replace(node, corrected_block(node, parenthesized))
+            ParenthesesCorrector.correct(corrector, node.parent) if parenthesized
+          end
+        end
+
+        private
+
+        def parenthesized?(node)
+          node.parent && parentheses?(node.parent)
+        end
+
+        def corrected_block(node, parenthesized)
           operation, rescue_modifier, = *node
           *_, rescue_args = *rescue_modifier
 
-          indent = indentation(node)
-          correction =
-            "begin\n" \
-            "#{operation.source.gsub(/^/, indent)}" \
-            "\n#{offset(node)}rescue\n" \
-            "#{rescue_args.source.gsub(/^/, indent)}" \
-            "\n#{offset(node)}end"
+          node_indentation, node_offset = indentation_and_offset(node, parenthesized)
 
-          lambda do |corrector|
-            corrector.replace(node.source_range, correction)
+          "begin\n" \
+            "#{operation.source.gsub(/^/, node_indentation)}" \
+            "\n#{node_offset}rescue\n" \
+            "#{rescue_args.source.gsub(/^/, node_indentation)}" \
+            "\n#{node_offset}end"
+        end
+
+        def indentation_and_offset(node, parenthesized)
+          node_indentation = indentation(node)
+          node_offset = offset(node)
+          if parenthesized
+            node_indentation = node_indentation[0...-1]
+            node_offset = node_offset[0...-1]
           end
+          [node_indentation, node_offset]
         end
       end
     end

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

@@ -70,50 +70,56 @@ module RuboCop
       #   rescue StandardError, SecurityError
       #     bar
       #   end
-      class RescueStandardError < Cop
+      class RescueStandardError < Base
         include RescueNode
         include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
 
         MSG_IMPLICIT = 'Omit the error class when rescuing ' \
-          '`StandardError` by itself.'.freeze
+          '`StandardError` by itself.'
         MSG_EXPLICIT = 'Avoid rescuing without specifying ' \
-          'an error class.'.freeze
+          'an error class.'
 
-        def_node_matcher :rescue_without_error_class?, <<-PATTERN
+        def_node_matcher :rescue_without_error_class?, <<~PATTERN
           (resbody nil? _ _)
         PATTERN
 
-        def_node_matcher :rescue_standard_error?, <<-PATTERN
-          (resbody $(array (const nil? :StandardError)) _ _)
+        def_node_matcher :rescue_standard_error?, <<~PATTERN
+          (resbody $(array (const {nil? cbase} :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)
+              offense_for_implicit_enforced_style(node, error)
             end
           when :explicit
             rescue_without_error_class?(node) do
-              add_offense(node, location: :keyword, message: MSG_EXPLICIT)
+              offense_for_exlicit_enforced_style(node)
             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
+        private
+
+        def offense_for_implicit_enforced_style(node, error)
+          range = node.loc.keyword.join(error.loc.expression)
+
+          add_offense(range, message: MSG_IMPLICIT) do |corrector|
+            error = rescue_standard_error?(node)
+            range = range_between(node.loc.keyword.end_pos, error.loc.expression.end_pos)
+
+            corrector.remove(range)
+          end
+        end
+
+        def offense_for_exlicit_enforced_style(node)
+          add_offense(node.loc.keyword, message: MSG_EXPLICIT) do |corrector|
+            corrector.insert_after(node.loc.keyword, ' StandardError')
           end
         end
       end

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

@@ -28,11 +28,12 @@ module RuboCop
       #   def foo(arg)
       #     return nil if arg
       #   end
-      class ReturnNil < Cop
+      class ReturnNil < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
-        RETURN_MSG = 'Use `return` instead of `return nil`.'.freeze
-        RETURN_NIL_MSG = 'Use `return nil` instead of `return`.'.freeze
+        RETURN_MSG = 'Use `return` instead of `return nil`.'
+        RETURN_NIL_MSG = 'Use `return nil` instead of `return`.'
 
         def_node_matcher :return_node?, '(return)'
         def_node_matcher :return_nil_node?, '(return nil)'
@@ -54,13 +55,12 @@ module RuboCop
             return nil if chained_send?(send_node)
           end
 
-          add_offense(node) unless correct_style?(node)
-        end
+          return if correct_style?(node)
 
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node) do |corrector|
             corrected = style == :return ? 'return' : 'return nil'
-            corrector.replace(node.source_range, corrected)
+
+            corrector.replace(node, corrected)
           end
         end
 
@@ -80,7 +80,7 @@ module RuboCop
         end
 
         def_node_matcher :chained_send?, '(send !nil? ...)'
-        def_node_matcher :define_method?, <<-PATTERN
+        def_node_matcher :define_method?, <<~PATTERN
           (send _ {:define_method :define_singleton_method} _)
         PATTERN
       end

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

@@ -5,7 +5,10 @@ module RuboCop
     module Style
       # This cop transforms usages of a method call safeguarded by a non `nil`
       # check for the variable whose method is being called to
-      # safe navigation (`&.`).
+      # safe navigation (`&.`). If there is a method chain, all of the methods
+      # in the chain need to be checked for safety, and all of the methods will
+      # need to be changed to use safe navigation. We have limited the cop to
+      # not register an offense for method chains that exceed 2 methods.
       #
       # Configuration option: ConvertCodeThatCanStartToReturnNil
       # The default for this is `false`. When configured to `true`, this will
@@ -18,6 +21,7 @@ module RuboCop
       # @example
       #   # bad
       #   foo.bar if foo
+      #   foo.bar.baz if foo
       #   foo.bar(param1, param2) if foo
       #   foo.bar { |e| e.something } if foo
       #   foo.bar(param) { |e| e.something } if foo
@@ -27,34 +31,50 @@ module RuboCop
       #   foo.bar unless foo.nil?
       #
       #   foo && foo.bar
+      #   foo && foo.bar.baz
       #   foo && foo.bar(param1, param2)
       #   foo && foo.bar { |e| e.something }
       #   foo && foo.bar(param) { |e| e.something }
       #
       #   # good
       #   foo&.bar
+      #   foo&.bar&.baz
       #   foo&.bar(param1, param2)
       #   foo&.bar { |e| e.something }
       #   foo&.bar(param) { |e| e.something }
+      #   foo && foo.bar.baz.qux # method chain with more than 2 methods
+      #   foo && foo.nil? # method that `nil` responds to
       #
+      #   # Method calls that do not use `.`
+      #   foo && foo < bar
+      #   foo < bar if foo
+      #
+      #   # When checking `foo&.empty?` in a conditional, `foo` being `nil` will actually
+      #   # do the opposite of what the author intends.
+      #   foo && foo.empty?
+      #
+      #   # This could start returning `nil` as well as the return of the method
       #   foo.nil? || foo.bar
       #   !foo || foo.bar
       #
-      #   # Methods that `nil` will `respond_to?` should not be converted to
-      #   # use safe navigation
-      #   foo.to_i if foo
-      class SafeNavigation < Cop
-        extend TargetRubyVersion
+      #   # Methods that are used on assignment, arithmetic operation or
+      #   # comparison should not be converted to use safe navigation
+      #   foo.baz = bar if foo
+      #   foo.baz + bar if foo
+      #   foo.bar > 2 if foo
+      class SafeNavigation < Base
+        include NilMethods
+        include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use safe navigation (`&.`) instead of checking if an object ' \
-              'exists before calling the method.'.freeze
-        NIL_METHODS = nil.methods.freeze
-
-        minimum_target_ruby_version 2.3
+              'exists before calling the method.'
+        LOGIC_JUMP_KEYWORDS = %i[break fail next raise
+                                 return throw yield].freeze
 
         # if format: (if checked_variable body nil)
         # unless format: (if checked_variable nil body)
-        def_node_matcher :modifier_if_safe_navigation_candidate?, <<-PATTERN
+        def_node_matcher :modifier_if_safe_navigation_candidate, <<~PATTERN
           {
             (if {
                   (send $_ {:nil? :!})
@@ -72,6 +92,7 @@ module RuboCop
 
         def on_if(node)
           return if allowed_if_condition?(node)
+
           check_node(node)
         end
 
@@ -80,32 +101,62 @@ module RuboCop
         end
 
         def check_node(node)
-          return if target_ruby_version < 2.3
-          checked_variable, receiver, method = extract_parts(node)
+          checked_variable, receiver, method_chain, method = extract_parts(node)
           return unless receiver == checked_variable
-          return if unsafe_method?(method)
+          return if use_var_only_in_unless_modifier?(node, checked_variable)
+          # method is already a method call so this is actually checking for a
+          # chain greater than 2
+          return if chain_size(method_chain, method) > 1
+          return if unsafe_method_used?(method_chain, method)
+          return if method_chain.method?(:empty?)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
 
-          add_offense(node)
+        def use_var_only_in_unless_modifier?(node, variable)
+          node.if_type? && node.unless? && !method_called?(variable)
         end
 
-        def autocorrect(node)
-          _check, body, = node.node_parts
-          _checked_variable, matching_receiver, = extract_parts(node)
-          method_call, = matching_receiver.parent
+        private
 
-          lambda do |corrector|
-            corrector.remove(begin_range(node, body))
-            corrector.remove(end_range(node, body))
-            corrector.insert_before((method_call || body).loc.dot, '&')
-          end
+        def autocorrect(corrector, node)
+          body = node.node_parts[1]
+          method_call = method_call(node)
+
+          corrector.remove(begin_range(node, body))
+          corrector.remove(end_range(node, body))
+          corrector.insert_before(method_call.loc.dot, '&')
+          handle_comments(corrector, node, method_call)
+
+          add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
         end
 
-        private
+        def handle_comments(corrector, node, method_call)
+          comments = comments(node)
+          return if comments.empty?
+
+          corrector.insert_before(method_call,
+                                  "#{comments.map(&:text).join("\n")}\n")
+        end
+
+        def comments(node)
+          processed_source.each_comment_in_lines(
+            node.loc.first_line...
+            node.loc.last_line
+          ).to_a
+        end
 
         def allowed_if_condition?(node)
           node.else? || node.elsif? || node.ternary?
         end
 
+        def method_call(node)
+          _checked_variable, matching_receiver, = extract_parts(node)
+          matching_receiver.parent
+        end
+
         def extract_parts(node)
           case node.type
           when :if
@@ -116,10 +167,15 @@ module RuboCop
         end
 
         def extract_parts_from_if(node)
-          checked_variable, receiver =
-            modifier_if_safe_navigation_candidate?(node)
+          variable, receiver =
+            modifier_if_safe_navigation_candidate(node)
+
+          checked_variable, matching_receiver, method =
+            extract_common_parts(receiver, variable)
+
+          matching_receiver = nil if receiver && LOGIC_JUMP_KEYWORDS.include?(receiver.type)
 
-          extract_common_parts(receiver, checked_variable)
+          [checked_variable, matching_receiver, receiver, method]
         end
 
         def extract_parts_from_and(node)
@@ -129,59 +185,70 @@ module RuboCop
               not_nil_check?(checked_variable) || checked_variable
           end
 
-          extract_common_parts(rhs, checked_variable)
+          checked_variable, matching_receiver, method =
+            extract_common_parts(rhs, checked_variable)
+          [checked_variable, matching_receiver, rhs, method]
         end
 
-        def extract_common_parts(continuation, checked_variable)
+        def extract_common_parts(method_chain, checked_variable)
           matching_receiver =
-            find_matching_receiver_invocation(continuation, checked_variable)
+            find_matching_receiver_invocation(method_chain, 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
+        def find_matching_receiver_invocation(method_chain, checked_variable)
+          return nil unless method_chain
 
-          receiver = if node.block_type?
-                       node.send_node.receiver
+          receiver = if method_chain.block_type?
+                       method_chain.send_node.receiver
                      else
-                       node.receiver
+                       method_chain.receiver
                      end
 
-          if receiver == checked_variable
-            return nil if assignment_arithmetic_or_comparison?(node)
-
-            return receiver
-          end
+          return receiver if receiver == checked_variable
 
           find_matching_receiver_invocation(receiver, checked_variable)
         end
 
-        def assignment_arithmetic_or_comparison?(node)
-          node.assignment? ||
-            node.parent.arithmetic_operation? ||
-            comparison_node?(node.parent)
+        def chain_size(method_chain, method)
+          method.each_ancestor(:send).inject(0) do |total, ancestor|
+            break total + 1 if ancestor == method_chain
+
+            total + 1
+          end
         end
 
-        def comparison_node?(parent)
-          parent.send_type? && parent.comparison_method?
+        def unsafe_method_used?(method_chain, method)
+          return true if unsafe_method?(method)
+
+          method.each_ancestor(:send).any? do |ancestor|
+            break true unless config.for_cop('Lint/SafeNavigationChain')['Enabled']
+
+            break true if unsafe_method?(ancestor)
+            break true if nil_methods.include?(ancestor.method_name)
+            break false if ancestor == method_chain
+          end
         end
 
         def unsafe_method?(send_node)
-          NIL_METHODS.include?(send_node.method_name) ||
-            negated?(send_node) || !send_node.dot?
+          negated?(send_node) || send_node.assignment? || !send_node.dot?
         end
 
         def negated?(send_node)
-          if send_node.parent && send_node.parent.send_type?
+          if method_called?(send_node)
             negated?(send_node.parent)
           else
             send_node.send_type? && send_node.method?(:!)
           end
         end
 
+        def method_called?(send_node)
+          send_node&.parent&.send_type?
+        end
+
         def begin_range(node, method_call)
           range_between(node.loc.expression.begin_pos,
                         method_call.loc.expression.begin_pos)
@@ -191,6 +258,19 @@ module RuboCop
           range_between(method_call.loc.expression.end_pos,
                         node.loc.expression.end_pos)
         end
+
+        def add_safe_nav_to_all_methods_in_chain(corrector,
+                                                 start_method,
+                                                 method_chain)
+          start_method.each_ancestor do |ancestor|
+            break unless %i[send block].include?(ancestor.type)
+            next unless ancestor.send_type?
+
+            corrector.insert_before(ancestor.loc.dot, '&')
+
+            break if ancestor == method_chain
+          end
+        end
       end
     end
   end