rubocop 0.75.1

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    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.'
+
+        def on_resbody(node)
+          return unless rescue_modifier?(node)
+
+          add_offense(node.parent)
+        end
+
+        def autocorrect(node)
+          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"
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, correction)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+# 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
+        include RangeHelp
+
+        MSG_IMPLICIT = 'Omit the error class when rescuing ' \
+          '`StandardError` by itself.'
+        MSG_EXPLICIT = 'Avoid rescuing without specifying ' \
+          'an error class.'
+
+        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`.'
+        RETURN_NIL_MSG = 'Use `return nil` instead of `return`.'
+
+        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

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    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 (`&.`). 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
+      # check for code in the format `!foo.nil? && foo.bar`. As it is written,
+      # the return of this code is limited to `false` and whatever the return
+      # of the method is. If this is converted to safe navigation,
+      # `foo&.bar` can start returning `nil` as well as what the method
+      # returns.
+      #
+      # @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
+      #
+      #   foo.bar if !foo.nil?
+      #   foo.bar unless !foo
+      #   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
+      #
+      #   # This could start returning `nil` as well as the return of the method
+      #   foo.nil? || foo.bar
+      #   !foo || foo.bar
+      #
+      #   # 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 < Cop
+        include NilMethods
+        include RangeHelp
+
+        MSG = 'Use safe navigation (`&.`) instead of checking if an object ' \
+              '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
+          {
+            (if {
+                  (send $_ {:nil? :!})
+                  $_
+                } nil? $_)
+
+            (if {
+                  (send (send $_ :nil?) :!)
+                  $_
+                } $_ nil?)
+          }
+        PATTERN
+
+        def_node_matcher :not_nil_check?, '(send (send $_ :nil?) :!)'
+
+        def on_if(node)
+          return if allowed_if_condition?(node)
+
+          check_node(node)
+        end
+
+        def on_and(node)
+          check_node(node)
+        end
+
+        def check_node(node)
+          checked_variable, receiver, method_chain, method = extract_parts(node)
+          return unless receiver == checked_variable
+          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)
+
+          add_offense(node)
+        end
+
+        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
+
+          lambda do |corrector|
+            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
+        end
+
+        private
+
+        def handle_comments(corrector, node, method_call)
+          return if processed_source.comments.empty?
+
+          corrector.insert_before(method_call.loc.expression,
+                                  "#{comments(node).join("\n")}\n")
+        end
+
+        def comments(node)
+          comments = processed_source.comments.select do |comment|
+            comment.loc.first_line >= node.loc.first_line &&
+              comment.loc.last_line <= node.loc.last_line
+          end
+
+          comments.map(&:text)
+        end
+
+        def allowed_if_condition?(node)
+          node.else? || node.elsif? || node.ternary?
+        end
+
+        def extract_parts(node)
+          case node.type
+          when :if
+            extract_parts_from_if(node)
+          when :and
+            extract_parts_from_and(node)
+          end
+        end
+
+        def extract_parts_from_if(node)
+          variable, receiver =
+            modifier_if_safe_navigation_candidate(node)
+
+          checked_variable, matching_receiver, method =
+            extract_common_parts(receiver, variable)
+
+          if receiver && LOGIC_JUMP_KEYWORDS.include?(receiver.type)
+            matching_receiver = nil
+          end
+
+          [checked_variable, matching_receiver, receiver, method]
+        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
+
+          checked_variable, matching_receiver, method =
+            extract_common_parts(rhs, checked_variable)
+          [checked_variable, matching_receiver, rhs, method]
+        end
+
+        def extract_common_parts(method_chain, checked_variable)
+          matching_receiver =
+            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(method_chain, checked_variable)
+          return nil unless method_chain
+
+          receiver = if method_chain.block_type?
+                       method_chain.send_node.receiver
+                     else
+                       method_chain.receiver
+                     end
+
+          return receiver if receiver == checked_variable
+
+          find_matching_receiver_invocation(receiver, checked_variable)
+        end
+
+        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 unsafe_method_used?(method_chain, method)
+          return true if unsafe_method?(method)
+
+          method.each_ancestor(:send).any? do |ancestor|
+            unless config.for_cop('Lint/SafeNavigationChain')['Enabled']
+              break true
+            end
+
+            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)
+          negated?(send_node) || send_node.assignment? || !send_node.dot?
+        end
+
+        def negated?(send_node)
+          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)
+        end
+
+        def end_range(node, method_call)
+          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
+end