rubocop 0.52.1 → 0.53.0

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

@@ -138,7 +138,7 @@ module RuboCop
              else elsif end ensure false for if in module
              next nil not or redo rescue retry return self
              super then true undef unless until when while
-             yield].include?(method_name)
+             yield __FILE__ __LINE__ __ENCODING__].include?(method_name)
         end
 
         def allow_self(node)

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

@@ -73,6 +73,7 @@ module RuboCop
       class RescueStandardError < Cop
         include RescueNode
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         MSG_IMPLICIT = 'Omit the error class when rescuing ' \
           '`StandardError` by itself.'.freeze

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,28 +31,40 @@ 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
 
@@ -81,9 +97,12 @@ module RuboCop
 
         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)
+          # 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
@@ -96,7 +115,9 @@ module RuboCop
           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, '&')
+
+            add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
           end
         end
 
@@ -116,10 +137,12 @@ module RuboCop
         end
 
         def extract_parts_from_if(node)
-          checked_variable, receiver =
+          variable, receiver =
             modifier_if_safe_navigation_candidate?(node)
 
-          extract_common_parts(receiver, checked_variable)
+          checked_variable, matching_receiver, method =
+            extract_common_parts(receiver, variable)
+          [checked_variable, matching_receiver, receiver, method]
         end
 
         def extract_parts_from_and(node)
@@ -129,49 +152,56 @@ 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|
+            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)
-          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)
@@ -191,6 +221,18 @@ 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?
+            break if ancestor == method_chain
+
+            corrector.insert_before(ancestor.loc.dot, '&')
+          end
+        end
       end
     end
   end

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

@@ -16,10 +16,12 @@ module RuboCop
       #   bar = 2
       #   baz = 3
       class Semicolon < Cop
+        include RangeHelp
+
         MSG = 'Do not use semicolons to terminate expressions.'.freeze
 
         def investigate(processed_source)
-          return unless processed_source.ast
+          return if processed_source.blank?
           @processed_source = processed_source
 
           check_for_line_terminator_or_opener

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

@@ -31,17 +31,20 @@ module RuboCop
         alias on_defs on_def
 
         def autocorrect(node)
-          body = node.body
-
           lambda do |corrector|
-            each_part(body) do |part|
-              break_line_before(part, node, corrector, 1)
+            each_part(node.body) do |part|
+              LineBreakCorrector.break_line_before(
+                range: part, node: node, corrector: corrector,
+                configured_width: configured_indentation_width
+              )
             end
 
-            break_line_before(node.loc.end, node, corrector, 0)
+            LineBreakCorrector.break_line_before(
+              range: node.loc.end, node: node, corrector: corrector,
+              indent_steps: 0, configured_width: configured_indentation_width
+            )
 
-            eol_comment = end_of_line_comment(node.source_range.line)
-            move_comment(eol_comment, node, corrector) if eol_comment
+            move_comment(node, corrector)
           end
         end
 
@@ -51,10 +54,6 @@ module RuboCop
           cop_config['AllowIfMethodIsEmpty']
         end
 
-        def end_of_line_comment(line)
-          processed_source.comments.find { |c| c.loc.line == line }
-        end
-
         def each_part(body)
           return unless body
 
@@ -65,20 +64,12 @@ module RuboCop
           end
         end
 
-        def break_line_before(range, node, corrector, indent_steps)
-          corrector.insert_before(
-            range,
-            "\n" + ' ' * (node.loc.keyword.column +
-                          indent_steps * configured_indentation_width)
+        def move_comment(node, corrector)
+          LineBreakCorrector.move_comment(
+            eol_comment: end_of_line_comment(node.source_range.line),
+            node: node, corrector: corrector
           )
         end
-
-        def move_comment(eol_comment, node, corrector)
-          text = eol_comment.loc.expression.source
-          corrector.insert_before(node.source_range,
-                                  text + "\n" + (' ' * node.loc.keyword.column))
-          corrector.remove(eol_comment.loc.expression)
-        end
       end
     end
   end

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

@@ -15,6 +15,8 @@ module RuboCop
       #   warn('hello')
       #
       class StderrPuts < Cop
+        include RangeHelp
+
         MSG = 'Use `warn` instead of `$stderr.puts` to allow such output ' \
               'to be disabled.'.freeze
 

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

@@ -19,8 +19,20 @@ module RuboCop
           (pair (str _) _)
         PATTERN
 
+        def_node_matcher :receive_environments_method?, <<-PATTERN
+          {
+            ^^(send (const {nil? cbase} :IO) :popen ...)
+            ^^(send (const {nil? cbase} :Open3)
+                {:capture2 :capture2e :capture3 :popen2 :popen2e :popen3} ...)
+            ^^^(send (const {nil? cbase} :Open3)
+                {:pipeline :pipeline_r :pipeline_rw :pipeline_start :pipeline_w} ...)
+            ^^(send {nil? (const {nil? cbase} :Kernel)} {:spawn :system} ...)
+          }
+        PATTERN
+
         def on_pair(node)
           return unless string_hash_key?(node)
+          return if receive_environments_method?(node)
           add_offense(node.key)
         end
 

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

@@ -76,7 +76,7 @@ module RuboCop
           styles.map(&:source).uniq
         end
 
-        def message(*)
+        def message(_node)
           if style == :single_quotes
             "Prefer single-quoted strings when you don't need string " \
             'interpolation or special symbols.'

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

@@ -29,7 +29,7 @@ module RuboCop
 
         private
 
-        def message(*)
+        def message(_node)
           # single_quotes -> single-quoted
           kind = style.to_s.sub(/_(.*)s/, '-\1d')
 

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

@@ -75,6 +75,35 @@ module RuboCop
             corrector.replace(node.source_range, "[#{syms.join(', ')}]")
           end
         end
+
+        def to_symbol_literal(string)
+          if symbol_without_quote?(string)
+            ":#{string}"
+          else
+            ":#{to_string_literal(string)}"
+          end
+        end
+
+        def symbol_without_quote?(string)
+          special_gvars = %w[
+            $! $" $$ $& $' $* $+ $, $/ $; $: $. $< $= $> $? $@ $\\ $_ $` $~ $0
+            $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w
+          ]
+          redefinable_operators = %w(
+            | ^ & <=> == === =~ > >= < <= << >>
+            + - * / % ** ~ +@ -@ [] []= ` ! != !~
+          )
+
+          # method name
+          string =~ /\A[a-zA-Z_]\w*[!?]?\z/ ||
+            # instance / class variable
+            string =~ /\A\@\@?[a-zA-Z_]\w*\z/ ||
+            # global variable
+            string =~ /\A\$[1-9]\d*\z/ ||
+            string =~ /\A\$[a-zA-Z_]\w*\z/ ||
+            special_gvars.include?(string) ||
+            redefinable_operators.include?(string)
+        end
       end
     end
   end

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

@@ -12,6 +12,8 @@ module RuboCop
       #   # good
       #   something.map(&:upcase)
       class SymbolProc < Cop
+        include RangeHelp
+
         MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` ' \
               'instead of a block.'.freeze
         SUPER_TYPES = %i[super zsuper].freeze

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing code after the class definition.
+      #
+      # @example
+      #   # bad
+      #   class Foo; def foo; end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def foo; end
+      #   end
+      #
+      class TrailingBodyOnClass < Cop
+        include Alignment
+        include TrailingBody
+
+        MSG = 'Place the first line of class body on its own line.'.freeze
+
+        def on_class(node)
+          return unless trailing_body?(node)
+
+          add_offense(node, location: first_part_of(node.to_a.last))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            LineBreakCorrector.correct_trailing_body(
+              configured_width: configured_indentation_width,
+              corrector: corrector,
+              node: node,
+              processed_source: processed_source
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -26,6 +26,7 @@ module RuboCop
       #
       class TrailingBodyOnMethodDefinition < Cop
         include Alignment
+        include TrailingBody
 
         MSG = "Place the first line of a multi-line method definition's " \
               'body on its own line.'.freeze
@@ -39,60 +40,12 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            break_line_before_body(node, corrector)
-            move_comment(node, corrector)
-            remove_semicolon(corrector)
-          end
-        end
-
-        private
-
-        def trailing_body?(node)
-          node.body && node.multiline? && on_def_line?(node)
-        end
-
-        def on_def_line?(node)
-          node.source_range.first_line == node.body.source_range.first_line
-        end
-
-        def break_line_before_body(node, corrector)
-          corrector.insert_before(
-            first_part_of(node.body),
-            "\n" + ' ' * (node.loc.keyword.column +
-                          configured_indentation_width)
-          )
-        end
-
-        def first_part_of(body)
-          if body.begin_type?
-            body.children.first.source_range
-          else
-            body.source_range
-          end
-        end
-
-        def move_comment(node, corrector)
-          eol_comment = end_of_line_comment(node.source_range.line)
-          return unless eol_comment
-
-          text = eol_comment.loc.expression.source
-          corrector.insert_before(node.source_range,
-                                  text + "\n" + (' ' * node.loc.keyword.column))
-          corrector.remove(eol_comment.loc.expression)
-        end
-
-        def end_of_line_comment(line)
-          processed_source.comments.find { |c| c.loc.line == line }
-        end
-
-        def remove_semicolon(corrector)
-          return unless semicolon
-          corrector.remove(semicolon.pos)
-        end
-
-        def semicolon
-          @semicolon ||= processed_source.tokens.find do |token|
-            token.line == 1 && token.semicolon?
+            LineBreakCorrector.correct_trailing_body(
+              configured_width: configured_indentation_width,
+              corrector: corrector,
+              node: node,
+              processed_source: processed_source
+            )
           end
         end
       end