rubocop 0.42.0 → 0.43.0

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

@@ -72,15 +72,15 @@ module RuboCop
         def on_method_def(_node, _method_name, _args, body)
           return unless body
 
-          if body.type == :return
+          if body.return_type?
             check_return_node(body)
-          elsif body.type == :begin
+          elsif body.begin_type?
             expressions = *body
             last_expr = expressions.last
 
-            if last_expr && last_expr.type == :return
-              check_return_node(last_expr)
-            end
+            return unless last_expr && last_expr.return_type?
+
+            check_return_node(last_expr)
           end
         end
 

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

@@ -49,7 +49,7 @@ module RuboCop
         def initialize(config = nil, options = nil)
           super
           @allowed_send_nodes = []
-          @local_variables = []
+          @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }
         end
 
         # Assignment of self.x
@@ -68,12 +68,12 @@ module RuboCop
 
         # Using self.x to distinguish from local variable x
 
-        def on_def(_node)
-          @local_variables = []
+        def on_def(node)
+          add_scope(node)
         end
 
-        def on_defs(_node)
-          @local_variables = []
+        def on_defs(node)
+          add_scope(node)
         end
 
         def on_args(node)
@@ -86,7 +86,7 @@ module RuboCop
 
         def on_lvasgn(node)
           lhs, _rhs = *node
-          @local_variables << lhs
+          @local_variables_scopes[node] << lhs
         end
 
         # Detect offenses
@@ -97,8 +97,7 @@ module RuboCop
           return unless regular_method_call?(node)
 
           return if @allowed_send_nodes.include?(node) ||
-                    @local_variables.include?(method_name)
-
+                    @local_variables_scopes[node].include?(method_name)
           add_offense(node, :expression)
         end
 
@@ -112,6 +111,13 @@ module RuboCop
 
         private
 
+        def add_scope(node)
+          local_variables = []
+          node.descendants.each do |child_node|
+            @local_variables_scopes[child_node] = local_variables
+          end
+        end
+
         def regular_method_call?(node)
           _receiver, method_name, *_args = *node
 
@@ -123,7 +129,7 @@ module RuboCop
 
         def on_argument(node)
           name, = *node
-          @local_variables << name
+          @local_variables_scopes[node] << name
         end
 
         def keyword?(method_name)
@@ -139,10 +145,13 @@ module RuboCop
         end
 
         def allow_self(node)
-          return unless node.type == :send
+          return unless node.send_type?
 
           receiver, _method_name, *_args = *node
-          @allowed_send_nodes << node if receiver && receiver.type == :self
+
+          return unless receiver && receiver.self_type?
+
+          @allowed_send_nodes << node
         end
       end
     end

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

@@ -46,23 +46,30 @@ module RuboCop
         private
 
         def check_slash_literal(node)
-          return if style == :slashes && !contains_disallowed_slash?(node)
-          return if style == :mixed &&
-                    node.single_line? &&
-                    !contains_disallowed_slash?(node)
+          return if allowed_slash_literal?(node)
 
           add_offense(node, :expression, MSG_USE_PERCENT_R)
         end
 
         def check_percent_r_literal(node)
-          return if style == :slashes && contains_disallowed_slash?(node)
-          return if style == :percent_r
-          return if style == :mixed && node.multiline?
-          return if style == :mixed && contains_disallowed_slash?(node)
+          return if allowed_percent_r_literal?(node)
 
           add_offense(node, :expression, MSG_USE_SLASHES)
         end
 
+        def allowed_slash_literal?(node)
+          style == :slashes && !contains_disallowed_slash?(node) ||
+            style == :mixed && node.single_line? &&
+              !contains_disallowed_slash?(node)
+        end
+
+        def allowed_percent_r_literal?(node)
+          style == :slashes && contains_disallowed_slash?(node) ||
+            style == :percent_r ||
+            style == :mixed && node.multiline? ||
+            style == :mixed && contains_disallowed_slash?(node)
+        end
+
         def contains_disallowed_slash?(node)
           !allow_inner_slashes? && contains_slash?(node)
         end
@@ -76,8 +83,7 @@ module RuboCop
         end
 
         def node_body(node)
-          string_parts = node.children.select { |child| child.type == :str }
-          string_parts.map(&:source).join
+          node.each_child_node(:str).map(&:source).join
         end
 
         def slash_literal?(node)

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

@@ -42,12 +42,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          source_buffer = node.loc.keyword.source_buffer
-          begin_pos = node.loc.keyword.begin_pos
-          current_column = node.loc.keyword.column
-          whitespace = Parser::Source::Range.new(source_buffer,
-                                                 begin_pos - current_column,
-                                                 begin_pos)
+          whitespace = whitespace_range(node)
           return false unless whitespace.source.strip.empty?
 
           new_column = ancestor_node(node).loc.end.column
@@ -76,6 +71,13 @@ module RuboCop
           @modifier_locations.include?(node.loc.keyword)
         end
 
+        def whitespace_range(node)
+          begin_pos = node.loc.keyword.begin_pos
+          current_column = node.loc.keyword.column
+
+          range_between(begin_pos - current_column, begin_pos)
+        end
+
         def ancestor_node(node)
           node.each_ancestor(:kwbegin, :def, :defs, :class, :module).first
         end

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

@@ -0,0 +1,125 @@
+# encoding: utf-8
+# 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 (`&.`).
+      #
+      # @example
+      #   # bad
+      #   foo.bar 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(param1, param2)
+      #   foo && foo.bar { |e| e.something }
+      #   foo && foo.bar(param) { |e| e.something }
+      #
+      #   foo.nil? || foo.bar
+      #   !foo || foo.bar
+      #
+      #   # good
+      #   foo&.bar
+      #   foo&.bar(param1, param2)
+      #   foo&.bar { |e| e.something }
+      #   foo&.bar(param) { |e| e.something }
+      #
+      #   # Methods that `nil` will `respond_to?` should not be converted to
+      #   # use safe navigation
+      #   foo.to_i if foo
+      class SafeNavigation < Cop
+        MSG = 'Use safe navigation (`&.`) instead of checking if an object ' \
+              'exists before calling the method.'.freeze
+        NIL_METHODS = nil.methods.freeze
+
+        def_node_matcher :safe_navigation_candidate, <<-PATTERN
+          {
+            (if
+              {(send (send $_ :nil?) :!) $_}
+              {(send $_ $_ ...) (block (send $_ $_ ...) ...)}
+            ...)
+            (if
+              (send $_ {:nil? :!}) nil
+              {(send $_ $_ ...) (block (send $_ $_ ...) ...)}
+            ...)
+            (and
+              {(send (send $_ :nil?) :!) $_}
+              {(send $_ $_ ...) (block (send $_ $_ ...) ...)}
+            ...)
+            (or
+              (send $_ {:nil? :!})
+              {(send $_ $_ ...) (block (send $_ $_ ...) ...)}
+            ...)
+          }
+        PATTERN
+
+        def on_if(node)
+          check_node(node)
+        end
+
+        def on_and(node)
+          check_node(node)
+        end
+
+        def on_or(node)
+          check_node(node)
+        end
+
+        def check_node(node)
+          return if target_ruby_version < 2.3
+          checked_variable, receiver, method = safe_navigation_candidate(node)
+          return unless receiver == checked_variable
+          return if NIL_METHODS.include?(method)
+          return unless method =~ /\w+[=!?]?/
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.loc.respond_to?(:keyword) && node.loc.keyword.is?('unless')
+              _variable_check, _else, method_call = *node
+            else
+              _variable_check, method_call = *node
+            end
+
+            if method_call.block_type?
+              method, = *method_call
+              corrector.insert_before(method.loc.dot, '&')
+            else
+              corrector.insert_before(method_call.loc.dot, '&')
+            end
+
+            corrector.remove(range(node, method_call))
+          end
+        end
+
+        private
+
+        def range(node, method_call)
+          source_buffer = node.loc.expression.source_buffer
+          node_expression = node.loc.expression
+          method_expression = method_call.loc.expression
+
+          if node.and_type? || node.or_type?
+            Parser::Source::Range.new(source_buffer,
+                                      node_expression.begin_pos,
+                                      method_expression.begin_pos)
+          else
+            Parser::Source::Range.new(source_buffer,
+                                      method_expression.end_pos,
+                                      node_expression.end_pos)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -35,7 +35,7 @@ module RuboCop
           var_name, rhs = *node
           return unless rhs
 
-          if rhs.type == :send
+          if rhs.send_type?
             check_send_node(node, rhs, var_name, var_type)
           elsif [:and, :or].include?(rhs.type)
             check_boolean_node(node, rhs, var_name, var_type)
@@ -65,7 +65,7 @@ module RuboCop
         def autocorrect(node)
           _var_name, rhs = *node
 
-          if rhs.type == :send
+          if rhs.send_type?
             autocorrect_send_node(node, rhs)
           elsif [:and, :or].include?(rhs.type)
             autocorrect_boolean_node(node, rhs)

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

@@ -40,21 +40,20 @@ module RuboCop
         private
 
         def check_for_line_terminator_or_opener
-          tokens_for_lines = @processed_source.tokens.group_by do |token|
-            token.pos.line
-          end
+          each_semicolon { |line, column| convention_on(line, column, true) }
+        end
 
+        def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            if tokens.last.type == :tSEMI
-              convention_on(line, tokens.last.pos.column, true)
-            end
-
-            if tokens.first.type == :tSEMI
-              convention_on(line, tokens.first.pos.column, true)
-            end
+            yield line, tokens.last.pos.column if tokens.last.type == :tSEMI
+            yield line, tokens.first.pos.column if tokens.first.type == :tSEMI
           end
         end
 
+        def tokens_for_lines
+          @processed_source.tokens.group_by { |token| token.pos.line }
+        end
+
         def convention_on(line, column, autocorrect)
           range = source_range(@processed_source.buffer, line, column)
           # Don't attempt to autocorrect if semicolon is separating statements

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

@@ -84,11 +84,9 @@ module RuboCop
         end
 
         def check_send(method_name, node)
-          return unless node
+          return unless node && command_or_kernel_call?(method_name, node)
 
-          if command_or_kernel_call?(method_name, node)
-            add_offense(node, :selector, message(method_name))
-          end
+          add_offense(node, :selector, message(method_name))
         end
 
         def command_or_kernel_call?(name, node)

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

@@ -25,7 +25,7 @@ module RuboCop
 
           return if args.empty?
           # discard cases with argument destructuring
-          return true unless args.all? { |n| n.type == :arg }
+          return true unless args.all?(&:arg_type?)
           return if args_match?(method_name, args)
 
           add_offense(args_node, :expression, message(method_name))

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

@@ -31,26 +31,33 @@ module RuboCop
 
         def autocorrect(node)
           body = @body
-          eol_comment = processed_source.comments.find do |c|
-            c.loc.line == node.source_range.line
-          end
+
           lambda do |corrector|
-            if body
-              if body.type == :begin
-                body.children.each do |part|
-                  break_line_before(part.source_range, node, corrector, 1)
-                end
-              else
-                break_line_before(body.source_range, node, corrector, 1)
-              end
+            each_part(body) do |part|
+              break_line_before(part, node, corrector, 1)
             end
 
             break_line_before(node.loc.end, node, corrector, 0)
 
+            eol_comment = end_of_line_comment(node.source_range.line)
             move_comment(eol_comment, node, corrector) if eol_comment
           end
         end
 
+        def end_of_line_comment(line)
+          processed_source.comments.find { |c| c.loc.line == line }
+        end
+
+        def each_part(body)
+          return unless body
+
+          if body.begin_type?
+            body.each_child_node { |part| yield part.source_range }
+          else
+            yield body.source_range
+          end
+        end
+
         def break_line_before(range, node, corrector, indent_steps)
           corrector.insert_before(
             range,

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

@@ -22,9 +22,8 @@ module RuboCop
         def on_method_def(_node, _method_name, args, _body)
           return unless args.loc.begin && args.loc.begin.is?('(')
           expr = args.source_range
-          pos_before_left_paren = Parser::Source::Range.new(expr.source_buffer,
-                                                            expr.begin_pos - 1,
-                                                            expr.begin_pos)
+          pos_before_left_paren = range_between(expr.begin_pos - 1,
+                                                expr.begin_pos)
           return unless pos_before_left_paren.source =~ /\s/
 
           add_offense(pos_before_left_paren, pos_before_left_paren)

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

@@ -16,9 +16,9 @@ module RuboCop
         MSG = 'Do not leave space between `!` and its argument.'.freeze
 
         def on_send(node)
-          if node.keyword_bang? && whitespace_after_bang_op?(node)
-            add_offense(node, :expression)
-          end
+          return unless node.keyword_bang? && whitespace_after_bang_op?(node)
+
+          add_offense(node, :expression)
         end
 
         def whitespace_after_bang_op?(node)
@@ -29,9 +29,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             receiver, _method_name, *_args = *node
-            space_range =
-              Parser::Source::Range.new(node.loc.selector.source_buffer,
-                                        node.loc.selector.end_pos,
+            space_range = range_between(node.loc.selector.end_pos,
                                         receiver.source_range.begin_pos)
             corrector.remove(space_range)
           end