rubocop 0.72.0 → 0.76.0

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

@@ -9,7 +9,7 @@ module RuboCop
       #
       # In the default style (require_parentheses), macro methods are ignored.
       # Additional methods can be added to the `IgnoredMethods`
-      # or `IgnoredMethodPatterns` list. These options are
+      # or `IgnoredPatterns` list. These options are
       # valid only in the default style. Macros can be included by
       # either setting `IgnoreMacros` to false or adding specific macros to
       # the `IncludedMacros` list.
@@ -17,7 +17,7 @@ module RuboCop
       # Precedence of options is all follows:
       #
       # 1. `IgnoredMethods`
-      # 2. `IgnoredMethodPatterns`
+      # 2. `IgnoredPatterns`
       # 3. `IncludedMacros`
       #
       # eg. If a method is listed in both
@@ -61,23 +61,9 @@ module RuboCop
       #   # okay with `puts` listed in `IgnoredMethods`
       #   puts 'test'
       #
-      #   # okay with `^assert` listed in `IgnoredMethodPatterns`
+      #   # okay with `^assert` listed in `IgnoredPatterns`
       #   assert_equal 'test', x
       #
-      #   # IgnoreMacros: true (default)
-      #
-      #   # good
-      #   class Foo
-      #     bar :baz
-      #   end
-      #
-      #   # IgnoreMacros: false
-      #
-      #   # bad
-      #   class Foo
-      #     bar :baz
-      #   end
-      #
       # @example EnforcedStyle: omit_parentheses
       #
       #   # bad
@@ -92,7 +78,21 @@ module RuboCop
       #   # good
       #   foo.enforce strict: true
       #
-      #   # AllowParenthesesInMultilineCall: false (default)
+      # @example IgnoreMacros: true (default)
+      #
+      #   # good
+      #   class Foo
+      #     bar :baz
+      #   end
+      #
+      # @example IgnoreMacros: false
+      #
+      #   # bad
+      #   class Foo
+      #     bar :baz
+      #   end
+      #
+      # @example AllowParenthesesInMultilineCall: false (default)
       #
       #   # bad
       #   foo.enforce(
@@ -103,7 +103,7 @@ module RuboCop
       #   foo.enforce \
       #     strict: true
       #
-      #   # AllowParenthesesInMultilineCall: true
+      # @example AllowParenthesesInMultilineCall: true
       #
       #   # good
       #   foo.enforce(
@@ -114,7 +114,7 @@ module RuboCop
       #   foo.enforce \
       #     strict: true
       #
-      #   # AllowParenthesesInChaining: false (default)
+      # @example AllowParenthesesInChaining: false (default)
       #
       #   # bad
       #   foo().bar(1)
@@ -122,7 +122,7 @@ module RuboCop
       #   # good
       #   foo().bar 1
       #
-      #   # AllowParenthesesInChaining: true
+      # @example AllowParenthesesInChaining: true
       #
       #   # good
       #   foo().bar(1)
@@ -130,7 +130,7 @@ module RuboCop
       #   # good
       #   foo().bar 1
       #
-      #   # AllowParenthesesInCamelCaseMethod: false (default)
+      # @example AllowParenthesesInCamelCaseMethod: false (default)
       #
       #   # bad
       #   Array(1)
@@ -138,7 +138,7 @@ module RuboCop
       #   # good
       #   Array 1
       #
-      #   # AllowParenthesesInCamelCaseMethod: true
+      # @example AllowParenthesesInCamelCaseMethod: true
       #
       #   # good
       #   Array(1)
@@ -148,7 +148,7 @@ module RuboCop
       class MethodCallWithArgsParentheses < Cop
         include ConfigurableEnforcedStyle
         include IgnoredMethods
-        include IgnoredMethodPatterns
+        include IgnoredPattern
 
         TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
 
@@ -186,7 +186,7 @@ module RuboCop
 
         def add_offense_for_require_parentheses(node)
           return if ignored_method?(node.method_name)
-          return if ignored_method_pattern?(node.method_name)
+          return if matches_ignored_pattern?(node.method_name)
           return if eligible_for_parentheses_omission?(node)
           return unless node.arguments? && !node.parenthesized?
 

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

@@ -113,22 +113,30 @@ module RuboCop
           lambda do |corrector|
             if node.args_type?
               # offense is registered on args node when parentheses are unwanted
-              corrector.replace(node.loc.begin, ' ')
-              corrector.remove(node.loc.end)
+              correct_arguments(node, corrector)
             else
-              args_expr = node.arguments.source_range
-              args_with_space = range_with_surrounding_space(range: args_expr,
-                                                             side: :left)
-              just_space = range_between(args_with_space.begin_pos,
-                                         args_expr.begin_pos)
-              corrector.replace(just_space, '(')
-              corrector.insert_after(args_expr, ')')
+              correct_definition(node, corrector)
             end
           end
         end
 
         private
 
+        def correct_arguments(arg_node, corrector)
+          corrector.replace(arg_node.loc.begin, ' ')
+          corrector.remove(arg_node.loc.end)
+        end
+
+        def correct_definition(def_node, corrector)
+          arguments_range = def_node.arguments.source_range
+          args_with_space = range_with_surrounding_space(range: arguments_range,
+                                                         side: :left)
+          leading_space = range_between(args_with_space.begin_pos,
+                                        arguments_range.begin_pos)
+          corrector.replace(leading_space, '(')
+          corrector.insert_after(arguments_range, ')')
+        end
+
         def require_parentheses?(args)
           style == :require_parentheses ||
             (style == :require_no_parentheses_except_multiline &&

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, newlines: false
+              )
+            )
+          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

@@ -49,11 +49,13 @@ module RuboCop
                                 node.parent.condition.source_range.end_pos)
 
           lambda do |corrector|
-            corrector.replace(range, new_expression(node.parent, node))
+            corrector.replace(range, new_expression(node))
           end
         end
 
-        def new_expression(outer_node, inner_node)
+        def new_expression(inner_node)
+          outer_node = inner_node.parent
+
           operator = replacement_operator(outer_node.keyword)
           lh_operand = left_hand_operand(outer_node, operator)
           rh_operand = right_hand_operand(inner_node, outer_node.keyword)
@@ -73,12 +75,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/non_nil_check.rb

@@ -5,27 +5,39 @@ module RuboCop
     module Style
       # This cop checks for non-nil checks, which are usually redundant.
       #
-      # @example
+      # With `IncludeSemanticChanges` set to `false` by default, this cop
+      # does not report offenses for `!x.nil?` and does no changes that might
+      # change behavior.
+      #
+      # With `IncludeSemanticChanges` set to `true`, this cop reports offenses
+      # for `!x.nil?` and autocorrects that and `x != nil` to solely `x`, which
+      # is **usually** OK, but might change behavior.
       #
+      # @example
       #   # bad
       #   if x != nil
       #   end
       #
-      #   # good (when not allowing semantic changes)
-      #   # bad (when allowing semantic changes)
-      #   if !x.nil?
-      #   end
-      #
-      #   # good (when allowing semantic changes)
+      #   # good
       #   if x
       #   end
       #
-      # Non-nil checks are allowed if they are the final nodes of predicate.
-      #
+      #   # Non-nil checks are allowed if they are the final nodes of predicate.
       #   # good
       #   def signed_in?
       #     !current_user.nil?
       #   end
+      #
+      # @example IncludeSemanticChanges: false (default)
+      #   # good
+      #   if !x.nil?
+      #   end
+      #
+      # @example IncludeSemanticChanges: true
+      #   # bad
+      #   if !x.nil?
+      #   end
+      #
       class NonNilCheck < Cop
         def_node_matcher :not_equal_to_nil?, '(send _ :!= nil)'
         def_node_matcher :unless_check?, '(if (send _ :nil?) ...)'

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