rubocop 0.70.0 → 0.75.0

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

@@ -120,15 +120,15 @@ module RuboCop
           end
         end
 
-        def_node_matcher :predicate, <<-PATTERN
+        def_node_matcher :predicate, <<~PATTERN
           (send $(...) ${:zero? :positive? :negative?})
         PATTERN
 
-        def_node_matcher :comparison, <<-PATTERN
+        def_node_matcher :comparison, <<~PATTERN
           (send [$(...) !gvar_type?] ${:== :> :<} (int 0))
         PATTERN
 
-        def_node_matcher :inverted_comparison, <<-PATTERN
+        def_node_matcher :inverted_comparison, <<~PATTERN
           (send (int 0) ${:== :> :<} [$(...) !gvar_type?])
         PATTERN
       end

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

@@ -22,7 +22,7 @@ module RuboCop
       class OptionHash < Cop
         MSG = 'Prefer keyword arguments to options hashes.'
 
-        def_node_matcher :option_hash, <<-PATTERN
+        def_node_matcher :option_hash, <<~PATTERN
           (args ... $(optarg [#suspicious_name? _] (hash)))
         PATTERN
 

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

@@ -29,7 +29,7 @@ module RuboCop
       class OrAssignment < Cop
         MSG = 'Use the double pipe equals operator `||=` instead.'
 
-        def_node_matcher :ternary_assignment?, <<-PATTERN
+        def_node_matcher :ternary_assignment?, <<~PATTERN
           ({lvasgn ivasgn cvasgn gvasgn} _var
             (if
               ({lvar ivar cvar gvar} _var)
@@ -37,7 +37,7 @@ module RuboCop
               _))
         PATTERN
 
-        def_node_matcher :unless_assignment?, <<-PATTERN
+        def_node_matcher :unless_assignment?, <<~PATTERN
           (if
             ({lvar ivar cvar gvar} _var) nil?
             ({lvasgn ivasgn cvasgn gvasgn} _var
@@ -81,7 +81,12 @@ module RuboCop
         end
 
         def take_variable_and_default_from_unless(node)
-          variable, default = *node.if_branch
+          if node.if_branch
+            variable, default = *node.if_branch
+          else
+            variable, default = *node.else_branch
+          end
+
           [variable, default]
         end
       end

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

@@ -6,6 +6,11 @@ module RuboCop
       # This cop checks for the presence of superfluous parentheses around the
       # condition of if/unless/while/until.
       #
+      # `AllowSafeAssignment` option for safe assignment.
+      # By safe assignment we mean putting parentheses around
+      # an assignment to indicate "I know I'm using an assignment
+      # as a condition. It's not a mistake."
+      #
       # @example
       #   # bad
       #   x += 1 while (x < 10)
@@ -23,6 +28,14 @@ module RuboCop
       #   elsif x < 3
       #   end
       #
+      # @example AllowSafeAssignment: true (default)
+      #   # good
+      #   foo unless (bar = baz)
+      #
+      # @example AllowSafeAssignment: false
+      #   # bad
+      #   foo unless (bar = baz)
+      #
       # @example AllowInMultilineConditions: false (default)
       #   # bad
       #   if (x > 10 &&
@@ -39,6 +52,7 @@ module RuboCop
       #   if (x > 10 &&
       #      y > 10)
       #   end
+      #
       class ParenthesesAroundCondition < Cop
         include SafeAssignment
         include Parentheses
@@ -60,7 +74,7 @@ module RuboCop
 
         private
 
-        def_node_matcher :control_op_condition, <<-PATTERN
+        def_node_matcher :control_op_condition, <<~PATTERN
           (begin $_ ...)
         PATTERN
 

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

@@ -27,7 +27,7 @@ module RuboCop
         MSG = 'Prefer ranges when generating random numbers instead of ' \
           'integers with offsets.'
 
-        def_node_matcher :integer_op_rand?, <<-PATTERN
+        def_node_matcher :integer_op_rand?, <<~PATTERN
           (send
             int {:+ :-}
             (send
@@ -36,7 +36,7 @@ module RuboCop
               {int irange erange}))
         PATTERN
 
-        def_node_matcher :rand_op_integer?, <<-PATTERN
+        def_node_matcher :rand_op_integer?, <<~PATTERN
           (send
             (send
               {nil? (const nil? :Random) (const nil? :Kernel)}
@@ -46,7 +46,7 @@ module RuboCop
             int)
         PATTERN
 
-        def_node_matcher :rand_modified?, <<-PATTERN
+        def_node_matcher :rand_modified?, <<~PATTERN
           (send
             (send
               {nil? (const nil? :Random) (const nil? :Kernel)}
@@ -80,7 +80,7 @@ module RuboCop
 
         private
 
-        def_node_matcher :random_call, <<-PATTERN
+        def_node_matcher :random_call, <<~PATTERN
           {(send (send $_ _ $_) ...)
            (send _ _ (send $_ _ $_))}
         PATTERN
@@ -128,7 +128,7 @@ module RuboCop
           end
         end
 
-        def_node_matcher :namespace, <<-PATTERN
+        def_node_matcher :namespace, <<~PATTERN
           {$nil? (const nil? $_)}
         PATTERN
 
@@ -149,7 +149,7 @@ module RuboCop
           end
         end
 
-        def_node_matcher :to_int, <<-PATTERN
+        def_node_matcher :to_int, <<~PATTERN
           (int $_)
         PATTERN
       end

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

@@ -53,11 +53,11 @@ module RuboCop
           format(MSG, msg: msg)
         end
 
-        def_node_matcher :redundant_condition?, <<-RUBY
+        def_node_matcher :redundant_condition?, <<~RUBY
           (if (send _ {:#{COMPARISON_OPERATORS.join(' :')}} _) true false)
         RUBY
 
-        def_node_matcher :redundant_condition_inverted?, <<-RUBY
+        def_node_matcher :redundant_condition_inverted?, <<~RUBY
           (if (send _ {:#{COMPARISON_OPERATORS.join(' :')}} _) false true)
         RUBY
 

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

@@ -47,11 +47,11 @@ module RuboCop
           end
         end
 
-        def_node_matcher :exploded?, <<-PATTERN
+        def_node_matcher :exploded?, <<~PATTERN
           (send nil? ${:raise :fail} (const nil? :RuntimeError) $_)
         PATTERN
 
-        def_node_matcher :compact?, <<-PATTERN
+        def_node_matcher :compact?, <<~PATTERN
           (send nil? {:raise :fail} $(send (const nil? :RuntimeError) :new $_))
         PATTERN
       end

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

@@ -51,7 +51,7 @@ module RuboCop
           end
         end
 
-        def_node_matcher :operation_produces_immutable_object?, <<-PATTERN
+        def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
           {
             (begin (send {float int} {:+ :- :* :** :/ :% :<<} _))
             (begin (send !(str _) {:+ :- :* :** :/ :%} {float int}))

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

@@ -40,7 +40,7 @@ module RuboCop
 
         def parens_allowed?(node)
           empty_parentheses?(node) ||
-            hash_literal_as_first_arg?(node) ||
+            first_arg_begins_with_hash_literal?(node) ||
             rescue?(node) ||
             allowed_expression?(node)
         end
@@ -76,12 +76,21 @@ module RuboCop
           node.children.empty?
         end
 
-        def hash_literal_as_first_arg?(node)
-          # Don't flag `method ({key: value})`
-          node.children.first.hash_type? && first_argument?(node) &&
+        def first_arg_begins_with_hash_literal?(node)
+          # Don't flag `method ({key: value})` or `method ({key: value}.method)`
+          method_chain_begins_with_hash_literal?(node.children.first) &&
+            first_argument?(node) &&
             !parentheses?(node.parent)
         end
 
+        def method_chain_begins_with_hash_literal?(node)
+          return false if node.nil?
+          return true if node.hash_type?
+          return false unless node.send_type?
+
+          method_chain_begins_with_hash_literal?(node.children.first)
+        end
+
         def check(begin_node)
           node = begin_node.children.first
           if keyword_with_redundant_parentheses?(node)
@@ -203,11 +212,11 @@ module RuboCop
           first_send_argument?(node) || first_super_argument?(node)
         end
 
-        def_node_matcher :first_send_argument?, <<-PATTERN
+        def_node_matcher :first_send_argument?, <<~PATTERN
           ^(send _ _ equal?(%0) ...)
         PATTERN
 
-        def_node_matcher :first_super_argument?, <<-PATTERN
+        def_node_matcher :first_super_argument?, <<~PATTERN
           ^(super equal?(%0) ...)
         PATTERN
 

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

@@ -83,9 +83,16 @@ module RuboCop
           on_argument(node)
         end
 
+        def on_masgn(node)
+          lhs, rhs = *node
+          lhs.children.each do |child|
+            add_lhs_to_local_variables_scopes(rhs, child.to_a.first)
+          end
+        end
+
         def on_lvasgn(node)
           lhs, rhs = *node
-          @local_variables_scopes[rhs] << lhs
+          add_lhs_to_local_variables_scopes(rhs, lhs)
         end
 
         def on_send(node)
@@ -148,6 +155,16 @@ module RuboCop
 
           @allowed_send_nodes << node
         end
+
+        def add_lhs_to_local_variables_scopes(rhs, lhs)
+          if rhs&.send_type? && !rhs.arguments.empty?
+            rhs.arguments.each do |argument|
+              @local_variables_scopes[argument] << lhs
+            end
+          else
+            @local_variables_scopes[rhs] << lhs
+          end
+        end
       end
     end
   end

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

@@ -20,7 +20,7 @@ module RuboCop
 
         MSG = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'
 
-        def_node_matcher :redundant_sort_by, <<-PATTERN
+        def_node_matcher :redundant_sort_by, <<~PATTERN
           (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
         PATTERN
 

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

@@ -5,16 +5,40 @@ module RuboCop
     module Style
       # This cop checks for uses of rescue in its modifier form.
       #
+      # The cop to check `rescue` in its modifier form is added for following
+      # reasons:
+      #
+      # * The syntax of modifier form `rescue` can be misleading because it
+      #   might led us to believe that `rescue` handles the given exception
+      #   but it actually rescue all exceptions to return the given rescue
+      #   block. In this case, value returned by handle_error or
+      #   SomeException.
+      #
+      # * Modifier form `rescue` would rescue all the exceptions. It would
+      #   silently skip all exception or errors and handle the error.
+      #   Example: If `NoMethodError` is raised, modifier form rescue would
+      #   handle the exception.
+      #
       # @example
       #   # bad
       #   some_method rescue handle_error
       #
+      #   # bad
+      #   some_method rescue SomeException
+      #
       #   # good
       #   begin
       #     some_method
       #   rescue
       #     handle_error
       #   end
+      #
+      #   # good
+      #   begin
+      #     some_method
+      #   rescue SomeException
+      #     handle_error
+      #   end
       class RescueModifier < Cop
         include Alignment
         include RescueNode

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

@@ -80,11 +80,11 @@ module RuboCop
         MSG_EXPLICIT = 'Avoid rescuing without specifying ' \
           'an error class.'
 
-        def_node_matcher :rescue_without_error_class?, <<-PATTERN
+        def_node_matcher :rescue_without_error_class?, <<~PATTERN
           (resbody nil? _ _)
         PATTERN
 
-        def_node_matcher :rescue_standard_error?, <<-PATTERN
+        def_node_matcher :rescue_standard_error?, <<~PATTERN
           (resbody $(array (const nil? :StandardError)) _ _)
         PATTERN
 

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

@@ -80,7 +80,7 @@ module RuboCop
         end
 
         def_node_matcher :chained_send?, '(send !nil? ...)'
-        def_node_matcher :define_method?, <<-PATTERN
+        def_node_matcher :define_method?, <<~PATTERN
           (send _ {:define_method :define_singleton_method} _)
         PATTERN
       end

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

@@ -69,7 +69,7 @@ module RuboCop
 
         # 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? :!})
@@ -120,6 +120,7 @@ module RuboCop
             corrector.remove(begin_range(node, body))
             corrector.remove(end_range(node, body))
             corrector.insert_before(method_call.loc.dot, '&')
+            handle_comments(corrector, method_call)
 
             add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
           end
@@ -127,6 +128,14 @@ module RuboCop
 
         private
 
+        def handle_comments(corrector, method_call)
+          return if processed_source.comments.empty?
+
+          comments = processed_source.comments.map(&:text).join("\n")
+          corrector.insert_before(method_call.loc.expression,
+                                  comments + "\n")
+        end
+
         def allowed_if_condition?(node)
           node.else? || node.elsif? || node.ternary?
         end
@@ -224,7 +233,7 @@ module RuboCop
         end
 
         def method_called?(send_node)
-          send_node.parent&.send_type?
+          send_node&.parent&.send_type?
         end
 
         def begin_range(node, method_call)

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

@@ -30,7 +30,7 @@ module RuboCop
       class Sample < Cop
         MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'
 
-        def_node_matcher :sample_candidate?, <<-PATTERN
+        def_node_matcher :sample_candidate?, <<~PATTERN
           (send $(send _ :shuffle $...) ${:first :last :[] :at :slice} $...)
         PATTERN
 

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

@@ -13,10 +13,17 @@ module RuboCop
       #   def @table.columns; super; end
       #
       #   # good
-      #   def no_op; end
       #   def self.resource_class=(klass); end
       #   def @table.columns; end
       #
+      # @example AllowIfMethodIsEmpty: true (default)
+      #   # good
+      #   def no_op; end
+      #
+      # @example AllowIfMethodIsEmpty: false
+      #   # bad
+      #   def no_op; end
+      #
       class SingleLineMethods < Cop
         include Alignment
 

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

@@ -20,7 +20,7 @@ module RuboCop
         MSG =
           'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
 
-        def_node_matcher :stderr_puts?, <<-PATTERN
+        def_node_matcher :stderr_puts?, <<~PATTERN
           (send
             {(gvar #stderr_gvar?) (const nil? :STDERR)}
             :puts $_

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

@@ -15,11 +15,11 @@ module RuboCop
       class StringHashKeys < Cop
         MSG = 'Prefer symbols instead of strings as hash keys.'
 
-        def_node_matcher :string_hash_key?, <<-PATTERN
+        def_node_matcher :string_hash_key?, <<~PATTERN
           (pair (str _) _)
         PATTERN
 
-        def_node_matcher :receive_environments_method?, <<-PATTERN
+        def_node_matcher :receive_environments_method?, <<~PATTERN
           {
             ^^(send (const {nil? cbase} :IO) :popen ...)
             ^^(send (const {nil? cbase} :Open3)