rubocop 0.71.0 → 0.75.1

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

@@ -38,7 +38,7 @@ module RuboCop
 
         private
 
-        def_node_matcher :min_max_candidate, <<-PATTERN
+        def_node_matcher :min_max_candidate, <<~PATTERN
           ({array return} (send [$_receiver !nil?] :min) (send [$_receiver !nil?] :max))
         PATTERN
 

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

@@ -44,11 +44,15 @@ module RuboCop
         MSG = '`%<statement>s` is used at the top level. Use inside `class` ' \
               'or `module`.'
 
-        def_node_matcher :include_statement, <<-PATTERN
+        def_node_matcher :include_statement, <<~PATTERN
           (send nil? ${:include :extend :prepend}
             const)
         PATTERN
 
+        def_node_matcher :wrapped_macro_scope?, <<~PATTERN
+          {({sclass class module block} ... ({begin if} ...))}
+        PATTERN
+
         def on_send(node)
           include_statement(node) do |statement|
             return if node.argument? ||
@@ -62,7 +66,13 @@ module RuboCop
         private
 
         def accepted_include?(node)
-          node.parent && node.macro?
+          node.parent && (node.macro? || ascend_macro_scope?(node.parent))
+        end
+
+        def ascend_macro_scope?(ancestor)
+          return true if wrapped_macro_scope?(ancestor)
+
+          ancestor.parent && ascend_macro_scope?(ancestor.parent)
         end
 
         def belongs_to_class_or_module?(node)

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

@@ -73,7 +73,7 @@ module RuboCop
         end
 
         def keyword_begin_str(node, node_buf)
-          indent = config.for_cop('IndentationWidth')['Width'] || 2
+          indent = config.for_cop('Layout/IndentationWidth')['Width'] || 2
           if node_buf.source[node.loc.begin.end_pos] == "\n"
             'begin'
           else

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks uses of the `then` keyword
+      # in multi-line when statements.
+      #
+      # @example
+      #   # bad
+      #   case foo
+      #   when bar then
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when bar
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when bar then do_something
+      #   end
+      #
+      class MultilineWhenThen < Cop
+        include RangeHelp
+
+        MSG = 'Do not use `then` for multiline `when` statement.'
+
+        def on_when(node)
+          # Without `then`, there's no offense
+          return unless node.then?
+
+          # Single line usage of `then` is not an offense
+          return if !node.children.last.nil? && !node.multiline? && node.then?
+
+          # With more than one statements after then, there's not offense
+          return if node.children.last&.begin_type?
+
+          add_offense(node, location: :begin)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(
+              range_with_surrounding_space(
+                range: node.loc.begin, side: :left
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -30,7 +30,7 @@ module RuboCop
         private
 
         def_node_matcher :simple_double_comparison?, '(send $lvar :== $lvar)'
-        def_node_matcher :simple_comparison?, <<-PATTERN
+        def_node_matcher :simple_comparison?, <<~PATTERN
           {(send $lvar :== _)
            (send _ :== $lvar)}
         PATTERN

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

@@ -143,13 +143,13 @@ module RuboCop
           end
         end
 
-        def_node_matcher :splat_value, <<-PATTERN
+        def_node_matcher :splat_value, <<~PATTERN
           (array (splat $_))
         PATTERN
 
         # Some of these patterns may not actually return an immutable object,
         # but we want to consider them immutable for this cop.
-        def_node_matcher :operation_produces_immutable_object?, <<-PATTERN
+        def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
           {
             (const _ _)
             (send (const nil? :Struct) :new ...)
@@ -165,7 +165,7 @@ module RuboCop
           }
         PATTERN
 
-        def_node_matcher :range_enclosed_in_parentheses?, <<-PATTERN
+        def_node_matcher :range_enclosed_in_parentheses?, <<~PATTERN
           (begin ({irange erange} _ _))
         PATTERN
       end

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

@@ -73,12 +73,28 @@ module RuboCop
         end
 
         def right_hand_operand(node, left_hand_keyword)
-          expr = node.condition.source
-          expr = "(#{expr})" if requires_parens?(node.condition)
+          condition = node.condition
+
+          expr = if condition.send_type? && !condition.arguments.empty? &&
+                    !condition.operator_method?
+                   add_parentheses_to_method_arguments(condition)
+                 else
+                   condition.source
+                 end
+          expr = "(#{expr})" if requires_parens?(condition)
           expr = "!#{expr}" unless left_hand_keyword == node.keyword
           expr
         end
 
+        def add_parentheses_to_method_arguments(send_node)
+          expr = +''
+          expr << "#{send_node.receiver.source}." if send_node.receiver
+          expr << send_node.method_name.to_s
+          expr << "(#{send_node.arguments.map(&:source).join(', ')})"
+
+          expr
+        end
+
         def requires_parens?(node)
           node.or_type? ||
             !(RuboCop::AST::Node::COMPARISON_OPERATORS & node.children).empty?

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_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
 

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