rubocop 0.72.0 → 0.76.0

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/{unneeded_capital_w.rb → redundant_capital_w.rb}

@@ -14,7 +14,7 @@ module RuboCop
       #   %w/swim run bike/
       #   %w[shirt pants shoes]
       #   %W(apple #{fruit} grape)
-      class UnneededCapitalW < Cop
+      class RedundantCapitalW < Cop
         include PercentLiteral
 
         MSG = 'Do not use `%W` unless interpolation is needed. ' \

data/lib/rubocop/cop/style/{unneeded_condition.rb → redundant_condition.rb}

@@ -30,11 +30,11 @@ module RuboCop
       #     c
       #   end
       #
-      class UnneededCondition < Cop
+      class RedundantCondition < Cop
         include RangeHelp
 
         MSG = 'Use double pipes `||` instead.'
-        UNNEEDED_CONDITION = 'This condition is not needed.'
+        REDUNDANT_CONDITION = 'This condition is not needed.'
 
         def on_if(node)
           return if node.elsif_conditional?
@@ -61,7 +61,7 @@ module RuboCop
 
         def message(node)
           if node.modifier_form? || !node.else_branch
-            UNNEEDED_CONDITION
+            REDUNDANT_CONDITION
           else
             MSG
           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/{unneeded_interpolation.rb → redundant_interpolation.rb}

@@ -15,7 +15,7 @@ module RuboCop
       #
       #   # good if @var is already a String
       #   @var
-      class UnneededInterpolation < Cop
+      class RedundantInterpolation < Cop
         include PercentLiteral
 
         MSG = 'Prefer `to_s` over string interpolation.'

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/{unneeded_percent_q.rb → redundant_percent_q.rb}

@@ -17,7 +17,7 @@ module RuboCop
       #   time = "8 o'clock"
       #   question = '"What did you say?"'
       #
-      class UnneededPercentQ < Cop
+      class RedundantPercentQ < Cop
         MSG = 'Use `%<q_type>s` only for strings that contain both ' \
               'single quotes and double quotes%<extra>s.'
         DYNAMIC_MSG = ', or for dynamic strings that contain ' \

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

@@ -35,6 +35,18 @@ module RuboCop
       #     end
       #   end
       #
+      # @example AllowMultipleReturnValues: false (default)
+      #   # bad
+      #   def test
+      #     return x, y
+      #   end
+      #
+      # @example AllowMultipleReturnValues: true
+      #   # good
+      #   def test
+      #     return x, y
+      #   end
+      #
       class RedundantReturn < Cop
         include RangeHelp
 
@@ -48,27 +60,38 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node) # rubocop:disable Metrics/MethodLength
+        def autocorrect(node)
           lambda do |corrector|
-            unless arguments?(node.children)
-              corrector.replace(node.source_range, 'nil')
-              next
+            if node.arguments?
+              correct_with_arguments(node, corrector)
+            else
+              correct_without_arguments(node, corrector)
             end
-
-            return_value, = *node
-            if node.children.size > 1
-              add_brackets(corrector, node)
-            elsif return_value.hash_type?
-              add_braces(corrector, return_value) unless return_value.braces?
-            end
-            return_kw = range_with_surrounding_space(range: node.loc.keyword,
-                                                     side: :right)
-            corrector.remove(return_kw)
           end
         end
 
         private
 
+        def correct_without_arguments(return_node, corrector)
+          corrector.replace(return_node.source_range, 'nil')
+        end
+
+        def correct_with_arguments(return_node, corrector)
+          if return_node.arguments.size > 1
+            add_brackets(corrector, return_node)
+          elsif hash_without_braces?(return_node.first_argument)
+            add_braces(corrector, return_node.first_argument)
+          end
+
+          keyword = range_with_surrounding_space(range: return_node.loc.keyword,
+                                                 side: :right)
+          corrector.remove(keyword)
+        end
+
+        def hash_without_braces?(node)
+          node.hash_type? && !node.braces?
+        end
+
         def add_brackets(corrector, node)
           kids = node.children.map(&:source_range)
           corrector.insert_before(kids.first, '[')
@@ -81,13 +104,6 @@ module RuboCop
           corrector.insert_after(kids.last, '}')
         end
 
-        def arguments?(args)
-          return false if args.empty?
-          return true if args.size > 1
-
-          !args.first.begin_type? || !args.first.children.empty?
-        end
-
         # rubocop:disable Metrics/CyclomaticComplexity
         def check_branch(node)
           return unless node

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/{unneeded_sort.rb → redundant_sort.rb}

@@ -49,13 +49,13 @@ module RuboCop
       #   # good
       #   arr.max_by(&:foo)
       #
-      class UnneededSort < Cop
+      class RedundantSort < Cop
         include RangeHelp
 
         MSG = 'Use `%<suggestion>s` instead of '\
               '`%<sorter>s...%<accessor_source>s`.'
 
-        def_node_matcher :unneeded_sort?, <<-MATCHER
+        def_node_matcher :redundant_sort?, <<~MATCHER
           {
             (send $(send _ $:sort ...) ${:last :first})
             (send $(send _ $:sort ...) ${:[] :at :slice} {(int 0) (int -1)})
@@ -72,7 +72,7 @@ module RuboCop
         MATCHER
 
         def on_send(node)
-          unneeded_sort?(node) do |sort_node, sorter, accessor|
+          redundant_sort?(node) do |sort_node, sorter, accessor|
             range = range_between(
               sort_node.loc.selector.begin_pos,
               node.loc.expression.end_pos
@@ -87,7 +87,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          sort_node, sorter, accessor = unneeded_sort?(node)
+          sort_node, sorter, accessor = redundant_sort?(node)
 
           lambda do |corrector|
             # Remove accessor, e.g. `first` or `[-1]`.

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