rubocop 0.49.1 → 0.50.0

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

@@ -48,33 +48,30 @@ module RuboCop
 
         MSG = 'Use safe navigation (`&.`) instead of checking if an object ' \
               'exists before calling the method.'.freeze
-        NIL_METHODS = nil.methods.freeze
+        NIL_METHODS = nil.methods.map(&:to_s).freeze
 
         minimum_target_ruby_version 2.3
 
-        def_node_matcher :safe_navigation_candidate, <<-PATTERN
+        # 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 (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
+        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,51 +79,91 @@ 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)
           return unless receiver == checked_variable
-          return if NIL_METHODS.include?(method)
-          return unless method =~ /\w+[=!?]?/
+          return if unsafe_method?(method)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          _check, body, = node.node_parts
+          _checked_variable, matching_receiver, = extract_parts(node)
+          method_call, = matching_receiver.parent
 
-          add_offense(node, :expression)
+          lambda do |corrector|
+            corrector.remove(begin_range(node, body))
+            corrector.remove(end_range(node, body))
+            corrector.insert_before((method_call || body).loc.dot, '&')
+          end
         end
 
+        private
+
         def allowed_if_condition?(node)
-          node.if_type? && (node.else? || node.elsif?)
+          node.else? || node.elsif? || node.ternary?
         end
 
         def extract_parts(node)
-          if cop_config['ConvertCodeThatCanStartToReturnNil']
-            safe_navigation_candidate(node) ||
-              candidate_that_may_introduce_nil(node)
-          else
-            safe_navigation_candidate(node)
+          case node.type
+          when :if
+            extract_parts_from_if(node)
+          when :and
+            extract_parts_from_and(node)
           end
         end
 
-        def autocorrect(node)
-          if node.if_type?
-            _check, body, = *node.node_parts
-          else
-            _check, body = *node
+        def extract_parts_from_if(node)
+          checked_variable, receiver =
+            modifier_if_safe_navigation_candidate?(node)
+
+          matching_receiver =
+            find_matching_receiver_invocation(receiver, checked_variable)
+
+          if matching_receiver
+            method = matching_receiver.parent.loc.selector.source
           end
 
-          method_call, = *body if body.block_type?
+          [checked_variable, matching_receiver, method]
+        end
 
-          lambda do |corrector|
-            corrector.remove(begin_range(node, body))
-            corrector.remove(end_range(node, body))
-            corrector.insert_before((method_call || body).loc.dot, '&')
+        def extract_parts_from_and(node)
+          checked_variable, rhs = *node
+          if cop_config['ConvertCodeThatCanStartToReturnNil']
+            checked_variable =
+              not_nil_check?(checked_variable) || checked_variable
+          end
+
+          matching_receiver =
+            find_matching_receiver_invocation(rhs, checked_variable)
+
+          if matching_receiver
+            method = matching_receiver.parent.loc.selector.source
           end
+
+          [checked_variable, matching_receiver, method]
         end
 
-        private
+        def find_matching_receiver_invocation(node, checked_variable)
+          return nil if node.nil?
+
+          if node.block_type?
+            method_call, = *node
+            receiver, _method = *method_call
+          elsif node.send_type?
+            receiver, _method = *node
+          end
+
+          return receiver if receiver == checked_variable
+
+          find_matching_receiver_invocation(receiver, checked_variable)
+        end
+
+        def unsafe_method?(method)
+          NIL_METHODS.include?(method) || method !~ /\w+[=!?]?/
+        end
 
         def begin_range(node, method_call)
           Parser::Source::Range.new(node.loc.expression.source_buffer,

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

@@ -14,20 +14,12 @@ module RuboCop
         def on_block(node)
           return unless node.single_line?
 
-          send_node = node.send_node
+          return unless eligible_method?(node)
+          return unless eligible_arguments?(node)
 
-          return unless send_node.receiver
-          return unless method_names.include?(send_node.method_name)
+          return if args_match?(node.send_node.method_name, node.arguments)
 
-          return unless node.arguments?
-
-          arguments = node.arguments.to_a
-
-          # discard cases with argument destructuring
-          return true unless arguments.all?(&:arg_type?)
-          return if args_match?(send_node.method_name, arguments)
-
-          add_offense(node.arguments, :expression)
+          add_offense(node.arguments)
         end
 
         private
@@ -39,6 +31,15 @@ module RuboCop
           format(MSG, method_name, arguments)
         end
 
+        def eligible_arguments?(node)
+          node.arguments? && node.arguments.to_a.all?(&:arg_type?)
+        end
+
+        def eligible_method?(node)
+          node.send_node.receiver &&
+            method_names.include?(node.send_node.method_name)
+        end
+
         def methods
           cop_config['Methods']
         end
@@ -58,7 +59,7 @@ module RuboCop
         end
 
         def args_match?(method_name, args)
-          actual_args = args.flat_map(&:to_a)
+          actual_args = args.to_a.flat_map(&:to_a)
 
           # Prepending an underscore to mark an unused parameter is allowed, so
           # we remove any leading underscores before comparing.

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

@@ -7,29 +7,25 @@ module RuboCop
       # It can optionally accept single-line methods with no body.
       class SingleLineMethods < Cop
         include AutocorrectAlignment
-        include OnMethodDef
 
         MSG = 'Avoid single-line method definitions.'.freeze
 
-        def allow_empty?
-          cop_config['AllowIfMethodIsEmpty']
+        def on_def(node)
+          return unless node.single_line?
+          return if allow_empty? && !node.body
+
+          add_offense(node)
         end
+        alias on_defs on_def
 
         private
 
-        def on_method_def(node, _method_name, _args, body)
-          start_line = node.loc.keyword.line
-          end_line = node.loc.end.line
-
-          empty_body = body.nil?
-          return unless start_line == end_line && !(allow_empty? && empty_body)
-
-          @body = body
-          add_offense(node, :expression)
+        def allow_empty?
+          cop_config['AllowIfMethodIsEmpty']
         end
 
         def autocorrect(node)
-          body = @body
+          body = node.body
 
           lambda do |corrector|
             each_part(body) do |part|

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

@@ -47,8 +47,8 @@ module RuboCop
         PERL_VARS.merge!(
           Hash[PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }]
         )
-        ENGLISH_VARS.each { |_, v| v.freeze }.freeze
-        PERL_VARS.each { |_, v| v.freeze }.freeze
+        ENGLISH_VARS.each_value(&:freeze).freeze
+        PERL_VARS.each_value(&:freeze).freeze
 
         # Anything *not* in this set is provided by the English library.
         NON_ENGLISH_VARS = Set.new(%i[
@@ -67,7 +67,7 @@ module RuboCop
             correct_style_detected
           else
             opposite_style_detected
-            add_offense(node, :expression)
+            add_offense(node)
           end
         end
 

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

@@ -27,19 +27,11 @@ module RuboCop
         ARROW = '->'.freeze
 
         def on_send(node)
-          return unless arrow_lambda_with_args?(node)
+          return unless stabby_lambda_with_args?(node)
+          return unless redundant_parentheses?(node) ||
+                        missing_parentheses?(node)
 
-          if style == :require_parentheses
-            if parentheses?(node)
-              correct_style_detected
-            else
-              missing_parentheses(node)
-            end
-          elsif parentheses?(node)
-            unwanted_parentheses(node)
-          else
-            correct_style_detected
-          end
+          add_offense(node.parent.arguments)
         end
 
         def autocorrect(node)
@@ -52,21 +44,21 @@ module RuboCop
 
         private
 
-        def missing_parentheses(node)
-          add_offense(node_args(node), :expression, MSG_REQUIRE) do
-            opposite_style_detected
-          end
+        def missing_parentheses?(node)
+          style == :require_parentheses && !parentheses?(node)
         end
 
-        def unwanted_parentheses(node)
-          add_offense(node_args(node), :expression, MSG_NO_REQUIRE) do
-            opposite_style_detected
-          end
+        def redundant_parentheses?(node)
+          style == :require_no_parentheses && parentheses?(node)
+        end
+
+        def message(_node)
+          style == :require_parentheses ? MSG_REQUIRE : MSG_NO_REQUIRE
         end
 
         def missing_parentheses_corrector(node)
           lambda do |corrector|
-            args_loc = node_args(node).source_range
+            args_loc = node.parent.arguments.source_range
 
             corrector.insert_before(args_loc, '(')
             corrector.insert_after(args_loc, ')')
@@ -75,37 +67,23 @@ module RuboCop
 
         def unwanted_parentheses_corrector(node)
           lambda do |corrector|
-            args_loc = node_args(node).loc
+            args_loc = node.parent.arguments.loc
 
             corrector.replace(args_loc.begin, '')
             corrector.remove(args_loc.end)
           end
         end
 
-        def arrow_lambda_with_args?(node)
-          lambda_node?(node) && arrow_form?(node) && args?(node)
-        end
-
-        def lambda_node?(node)
-          receiver, call = *node
-          !receiver && call == :lambda
+        def stabby_lambda_with_args?(node)
+          node.command?(:lambda) && arrow_form?(node) && node.parent.arguments?
         end
 
         def arrow_form?(node)
           node.loc.selector.source == ARROW
         end
 
-        def node_args(node)
-          _call, args, _body = *node.parent
-          args
-        end
-
-        def args?(node)
-          !node_args(node).children.empty?
-        end
-
         def parentheses?(node)
-          node_args(node).loc.begin
+          node.parent.arguments.loc.begin
         end
       end
     end

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

@@ -3,7 +3,28 @@
 module RuboCop
   module Cop
     module Style
-      # Checks if uses of quotes match the configured preference.
+      # This cop checks that quotes inside the string interpolation
+      # match the configured preference.
+      #
+      # @example
+      #
+      #   # EnforcedStyle: single_quotes
+      #
+      #   # bad
+      #   result = "Tests #{success ? "PASS" : "FAIL"}"
+      #
+      #   # good
+      #   result = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #
+      # @example
+      #
+      #   # EnforcedStyle: double_quotes
+      #
+      #   # bad
+      #   result = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #
+      #   # good
+      #   result = "Tests #{success ? "PASS" : "FAIL"}"
       class StringLiteralsInInterpolation < Cop
         include ConfigurableEnforcedStyle
         include StringLiteralsHelp

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

@@ -19,7 +19,7 @@ module RuboCop
           _name, superclass, _body = *node
           return unless struct_constructor?(superclass)
 
-          add_offense(node, superclass.source_range, MSG)
+          add_offense(node, superclass.source_range)
         end
 
         def_node_matcher :struct_constructor?, <<-PATTERN

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

@@ -37,6 +37,7 @@ module RuboCop
         include ArraySyntax
         include ConfigurableEnforcedStyle
         include PercentLiteral
+        include PercentArray
         extend TargetRubyVersion
 
         minimum_target_ruby_version 2.0
@@ -50,12 +51,16 @@ module RuboCop
 
         def on_array(node)
           if bracketed_array_of?(:sym, node)
+            return if symbols_contain_spaces?(node)
+
             check_bracketed_array(node)
           elsif node.percent_literal?(:symbol)
             check_percent_array(node)
           end
         end
 
+        private
+
         def autocorrect(node)
           if style == :percent
             correct_percent(node, 'i')
@@ -64,31 +69,6 @@ module RuboCop
           end
         end
 
-        private
-
-        def check_bracketed_array(node)
-          return if comments_in_array?(node) ||
-                    symbols_contain_spaces?(node) ||
-                    below_array_length?(node)
-
-          array_style_detected(:brackets, node.values.size)
-          add_offense(node, :expression, PERCENT_MSG) if style == :percent
-        end
-
-        def check_percent_array(node)
-          array_style_detected(:percent, node.values.size)
-          add_offense(node, :expression, ARRAY_MSG) if style == :brackets
-        end
-
-        def comments_in_array?(node)
-          comments = processed_source.comments
-          array_range = node.source_range.to_a
-
-          comments.any? do |comment|
-            !(comment.loc.expression.to_a & array_range).empty?
-          end
-        end
-
         def symbols_contain_spaces?(node)
           node.children.any? do |sym|
             content, = *sym