rubocop 0.51.0 → 0.87.0

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,45 @@ 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
+      #
+      #   # 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
+      #   # 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
-        extend TargetRubyVersion
+        include NilMethods
+        include RangeHelp
 
         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 +87,7 @@ module RuboCop
 
         def on_if(node)
           return if allowed_if_condition?(node)
+
           check_node(node)
         end
 
@@ -80,32 +96,61 @@ 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)
 
           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
+          body = node.node_parts[1]
+          method_call = method_call(node)
 
           lambda do |corrector|
             corrector.remove(begin_range(node, body))
             corrector.remove(end_range(node, body))
-            corrector.insert_before((method_call || body).loc.dot, '&')
+            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)
+          comments = comments(node)
+          return if comments.empty?
+
+          corrector.insert_before(method_call,
+                                  "#{comments.map(&:text).join("\n")}\n")
+        end
+
+        def comments(node)
+          processed_source.comments.select do |comment|
+            comment.loc.first_line > node.loc.first_line &&
+              comment.loc.last_line < node.loc.last_line
+          end
+        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 +161,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,25 +179,27 @@ 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
 
           return receiver if receiver == checked_variable
@@ -155,13 +207,40 @@ module RuboCop
           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|
+            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)
-          send_node.parent.send_type? && send_node.parent.method?(:!)
+          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)
@@ -173,6 +252,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

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
@@ -25,10 +28,10 @@ module RuboCop
       #   [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
+        MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'
 
-        def_node_matcher :sample_candidate?, <<-PATTERN
-          (send $(send _ :shuffle $...) ${:first :last :[]} $...)
+        def_node_matcher :sample_candidate?, <<~PATTERN
+          (send $(send _ :shuffle $...) ${:first :last :[] :at :slice} $...)
         PATTERN
 
         def on_send(node)
@@ -57,7 +60,7 @@ module RuboCop
           case method
           when :first, :last
             true
-          when :[]
+          when :[], :at, :slice
             sample_size(method_args) != :unknown
           else
             false
@@ -74,11 +77,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 +88,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 +130,7 @@ module RuboCop
           case method
           when :first, :last
             extract_source(method_args)
-          when :[]
+          when :[], :slice
             sample_size(method_args)
           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=`.'
         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)
@@ -88,7 +88,7 @@ module RuboCop
         def apply_autocorrect(node, rhs, operator, new_rhs)
           lambda do |corrector|
             corrector.insert_before(node.loc.operator, operator)
-            corrector.replace(rhs.source_range, new_rhs.source)
+            corrector.replace(rhs, new_rhs.source)
           end
         end
       end

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

@@ -5,37 +5,73 @@ module RuboCop
     module Style
       # This cop checks for multiple expressions placed on the same line.
       # It also checks for lines terminated with a semicolon.
+      #
+      # This cop has `AllowAsExpressionSeparator` configuration option.
+      # It allows `;` to separate several expressions on the same line.
+      #
+      # @example
+      #   # bad
+      #   foo = 1; bar = 2;
+      #   baz = 3;
+      #
+      #   # good
+      #   foo = 1
+      #   bar = 2
+      #   baz = 3
+      #
+      # @example AllowAsExpressionSeparator: false (default)
+      #   # bad
+      #   foo = 1; bar = 2
+      #
+      # @example AllowAsExpressionSeparator: true
+      #   # good
+      #   foo = 1; bar = 2
       class Semicolon < Cop
-        MSG = 'Do not use semicolons to terminate expressions.'.freeze
+        include RangeHelp
+
+        MSG = 'Do not use semicolons to terminate expressions.'
 
         def investigate(processed_source)
-          return unless processed_source.ast
+          return if processed_source.blank?
+
           @processed_source = processed_source
 
           check_for_line_terminator_or_opener
         end
 
-        def on_begin(node)
+        def on_begin(node) # rubocop:todo Metrics/CyclomaticComplexity
           return if cop_config['AllowAsExpressionSeparator']
+
           exprs = node.children
 
           return if exprs.size < 2
 
           # create a map matching lines to the number of expressions on them
-          exprs_lines = exprs.map { |e| e.source_range.line }
-          lines = exprs_lines.group_by { |i| i }
+          exprs_lines = exprs.map(&:first_line)
+          lines = exprs_lines.group_by(&:itself)
 
-          # every line with more than 1 expression on it is an offense
           lines.each do |line, expr_on_line|
+            # Every line with more than one expression on it is a
+            # potential offense
             next unless expr_on_line.size > 1
+
             # TODO: Find the correct position of the semicolon. We don't know
             # if the first semicolon on the line is a separator of
             # expressions. It's just a guess.
             column = @processed_source[line - 1].index(';')
+
+            next unless column
+
             convention_on(line, column, false)
           end
         end
 
+        def autocorrect(range)
+          return unless range
+
+          ->(corrector) { corrector.remove(range) }
+        end
+
         private
 
         def check_for_line_terminator_or_opener
@@ -44,13 +80,13 @@ module RuboCop
 
         def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            yield line, tokens.last.pos.column if tokens.last.type == :tSEMI
-            yield line, tokens.first.pos.column if tokens.first.type == :tSEMI
+            yield line, tokens.last.column if tokens.last.semicolon?
+            yield line, tokens.first.column if tokens.first.semicolon?
           end
         end
 
         def tokens_for_lines
-          @processed_source.tokens.group_by { |token| token.pos.line }
+          @processed_source.tokens.group_by(&:line)
         end
 
         def convention_on(line, column, autocorrect)
@@ -59,11 +95,6 @@ module RuboCop
           # on the same line
           add_offense(autocorrect ? range : nil, location: range)
         end
-
-        def autocorrect(range)
-          return unless range
-          ->(corrector) { corrector.remove(range) }
-        end
       end
     end
   end

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

@@ -4,17 +4,27 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for the use of the send method.
+      #
+      # @example
+      #   # bad
+      #   Foo.send(:bar)
+      #   quuz.send(:fred)
+      #
+      #   # good
+      #   Foo.__send__(:bar)
+      #   quuz.public_send(:fred)
       class Send < Cop
         MSG = 'Prefer `Object#__send__` or `Object#public_send` to ' \
-              '`send`.'.freeze
+              '`send`.'
 
-        def_node_matcher :sending?, '(send _ :send ...)'
+        def_node_matcher :sending?, '({send csend} _ :send ...)'
 
         def on_send(node)
           return unless sending?(node) && node.arguments?
 
           add_offense(node, location: :selector)
         end
+        alias on_csend on_send
       end
     end
   end

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

@@ -4,14 +4,114 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for uses of `fail` and `raise`.
+      #
+      # @example EnforcedStyle: only_raise (default)
+      #   # The `only_raise` style enforces the sole use of `raise`.
+      #   # bad
+      #   begin
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   Kernel.fail
+      #
+      #   # good
+      #   begin
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   Kernel.raise
+      #
+      # @example EnforcedStyle: only_fail
+      #   # The `only_fail` style enforces the sole use of `fail`.
+      #   # bad
+      #   begin
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   Kernel.raise
+      #
+      #   # good
+      #   begin
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   Kernel.fail
+      #
+      # @example EnforcedStyle: semantic
+      #   # The `semantic` style enforces the use of `fail` to signal an
+      #   # exception, then will use `raise` to trigger an offense after
+      #   # it has been rescued.
+      #   # bad
+      #   begin
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     # Error thrown
+      #   rescue Exception
+      #     fail
+      #   end
+      #
+      #   Kernel.fail
+      #   Kernel.raise
+      #
+      #   # good
+      #   begin
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     fail
+      #   rescue Exception
+      #     raise 'Preferably with descriptive message'
+      #   end
+      #
+      #   explicit_receiver.fail
+      #   explicit_receiver.raise
       class SignalException < Cop
         include ConfigurableEnforcedStyle
 
-        FAIL_MSG = 'Use `fail` instead of `raise` to signal exceptions.'.freeze
+        FAIL_MSG = 'Use `fail` instead of `raise` to signal exceptions.'
         RAISE_MSG = 'Use `raise` instead of `fail` to ' \
-                    'rethrow exceptions.'.freeze
+                    'rethrow exceptions.'
 
-        def_node_matcher :kernel_call?, '(send (const nil? :Kernel) %1 ...)'
+        def_node_matcher :kernel_call?, '(send (const {nil? cbase} :Kernel) %1 ...)'
         def_node_search :custom_fail_methods,
                         '{(def :fail ...) (defs _ :fail ...)}'
 
@@ -38,6 +138,7 @@ module RuboCop
             check_send(:raise, node) unless ignored_node?(node)
           when :only_raise
             return if @custom_fail_defined
+
             check_send(:fail, node)
           when :only_fail
             check_send(:raise, node)