rubocop 0.48.1 → 1.16.0

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

@@ -0,0 +1,94 @@
+# 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 < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        RETURN_MSG = 'Use `return` instead of `return nil`.'
+        RETURN_NIL_MSG = 'Use `return nil` instead of `return`.'
+
+        # @!method return_node?(node)
+        def_node_matcher :return_node?, '(return)'
+
+        # @!method return_nil_node?(node)
+        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
+
+          return if correct_style?(node)
+
+          add_offense(node) do |corrector|
+            corrected = style == :return ? 'return' : 'return nil'
+
+            corrector.replace(node, 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
+
+        # @!method chained_send?(node)
+        def_node_matcher :chained_send?, '(send !nil? ...)'
+
+        # @!method define_method?(node)
+        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

@@ -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,53 +31,68 @@ 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
 
-        def_node_matcher :safe_navigation_candidate, <<-PATTERN
+        # if format: (if checked_variable body nil)
+        # unless format: (if checked_variable nil body)
+        # @!method modifier_if_safe_navigation_candidate(node)
+        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
+        # @!method not_nil_check?(node)
+        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 +101,178 @@ 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)
+          checked_variable, receiver, method_chain, method = extract_parts(node)
           return unless receiver == checked_variable
-          return if NIL_METHODS.include?(method)
-          return unless method =~ /\w+[=!?]?/
+          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) { |corrector| autocorrect(corrector, node) }
+        end
 
-          add_offense(node, :expression)
+        def use_var_only_in_unless_modifier?(node, variable)
+          node.if_type? && node.unless? && !method_called?(variable)
+        end
+
+        private
+
+        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
+
+        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)
+          relevant_comment_ranges(node).each.with_object([]) do |range, comments|
+            comments.concat(processed_source.each_comment_in_lines(range).to_a)
+          end
+        end
+
+        def relevant_comment_ranges(node)
+          # Get source lines ranges inside the if node that aren't inside an inner node
+          # Comments inside an inner node should remain attached to that node, and not
+          # moved.
+          begin_pos = node.loc.first_line
+          end_pos = node.loc.last_line
+
+          node.child_nodes.each.with_object([]) do |child, ranges|
+            ranges << (begin_pos...child.loc.first_line)
+            begin_pos = child.loc.last_line
+          end << (begin_pos...end_pos)
         end
 
         def allowed_if_condition?(node)
-          node.if_type? && (node.else? || node.elsif?)
+          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
+            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)
+
+          matching_receiver = nil if receiver && LOGIC_JUMP_KEYWORDS.include?(receiver.type)
+
+          [checked_variable, matching_receiver, receiver, method]
+        end
+
+        def extract_parts_from_and(node)
+          checked_variable, rhs = *node
           if cop_config['ConvertCodeThatCanStartToReturnNil']
-            safe_navigation_candidate(node) ||
-              candidate_that_may_introduce_nil(node)
-          else
-            safe_navigation_candidate(node)
+            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 autocorrect(node)
-          if node.if_type?
-            _check, body, = *node.node_parts
-          else
-            _check, body = *node
+        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
 
-          method_call, = *body if body.block_type?
+        def unsafe_method_used?(method_chain, method)
+          return true if unsafe_method?(method)
 
-          lambda do |corrector|
-            corrector.remove(begin_range(node, body))
-            corrector.remove(end_range(node, body))
-            corrector.insert_before((method_call || body).loc.dot, '&')
+          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
 
-        private
+        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)
-          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
+
+        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

data/lib/rubocop/cop/{performance → style}/sample.rb

@@ -2,15 +2,18 @@
 
 module RuboCop
   module Cop
-    module Performance
-      # This cop is used to identify usages of `shuffle.first`, `shuffle.last`
-      # and `shuffle[]` and change them to use `sample` instead.
+    module Style
+      # This cop is used to identify usages of `shuffle.first`,
+      # `shuffle.last`, and `shuffle[]` and change them to use
+      # `sample` instead.
       #
       # @example
       #   # bad
       #   [1, 2, 3].shuffle.first
       #   [1, 2, 3].shuffle.first(2)
       #   [1, 2, 3].shuffle.last
+      #   [2, 1, 3].shuffle.at(0)
+      #   [2, 1, 3].shuffle.slice(0)
       #   [1, 2, 3].shuffle[2]
       #   [1, 2, 3].shuffle[0, 2]    # sample(2) will do the same
       #   [1, 2, 3].shuffle[0..2]    # sample(3) will do the same
@@ -24,30 +27,29 @@ module RuboCop
       #   [1, 2, 3].shuffle[1..3]    # sample(3) might return a longer Array
       #   [1, 2, 3].shuffle[foo, bar]
       #   [1, 2, 3].shuffle(random: Random.new)
-      class Sample < Cop
-        MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'.freeze
+      class Sample < Base
+        extend AutoCorrector
 
-        def_node_matcher :sample_candidate?, <<-PATTERN
-          (send $(send _ :shuffle $...) ${:first :last :[]} $...)
+        MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'
+        RESTRICT_ON_SEND = %i[first last [] at slice].freeze
+
+        # @!method sample_candidate?(node)
+        def_node_matcher :sample_candidate?, <<~PATTERN
+          (send $(send _ :shuffle $...) ${:#{RESTRICT_ON_SEND.join(' :')}} $...)
         PATTERN
 
         def on_send(node)
-          sample_candidate?(node) do |shuffle, shuffle_arg, method, method_args|
+          sample_candidate?(node) do |shuffle_node, shuffle_arg, method, method_args|
             return unless offensive?(method, method_args)
 
-            range = source_range(shuffle, node)
+            range = source_range(shuffle_node, node)
             message = message(shuffle_arg, method, method_args, range)
-            add_offense(node, range, message)
-          end
-        end
 
-        def autocorrect(node)
-          shuffle_node, shuffle_arg, method, method_args =
-            sample_candidate?(node)
-
-          lambda do |corrector|
-            corrector.replace(source_range(shuffle_node, node),
-                              correction(shuffle_arg, method, method_args))
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(
+                source_range(shuffle_node, node), correction(shuffle_arg, method, method_args)
+              )
+            end
           end
         end
 
@@ -57,7 +59,7 @@ module RuboCop
           case method
           when :first, :last
             true
-          when :[]
+          when :[], :at, :slice
             sample_size(method_args) != :unknown
           else
             false
@@ -74,11 +76,10 @@ module RuboCop
         end
 
         def sample_size_for_one_arg(arg)
-          case arg.type
-          when :erange, :irange
+          if arg.range_type?
             range_size(arg)
-          when :int
-            arg.to_a.first.zero? ? nil : :unknown
+          elsif arg.int_type?
+            [0, -1].include?(arg.to_a.first) ? nil : :unknown
           else
             :unknown
           end
@@ -86,12 +87,14 @@ module RuboCop
 
         def sample_size_for_two_args(first, second)
           return :unknown unless first.int_type? && first.to_a.first.zero?
+
           second.int_type? ? second.to_a.first : :unknown
         end
 
-        def range_size(range_node)
+        def range_size(range_node) # rubocop:todo Metrics/CyclomaticComplexity
           vals = range_node.to_a
           return :unknown unless vals.all?(&:int_type?)
+
           low, high = vals.map { |val| val.children[0] }
           return :unknown unless low.zero? && high >= 0
 
@@ -126,7 +129,7 @@ module RuboCop
           case method
           when :first, :last
             extract_source(method_args)
-          when :[]
+          when :[], :slice
             sample_size(method_args)
           end
         end