rubocop 0.72.0 → 0.73.0

data/lib/rubocop/cop/security/open.rb

@@ -22,7 +22,7 @@ module RuboCop
       class Open < Cop
         MSG = 'The use of `Kernel#open` is a serious security risk.'
 
-        def_node_matcher :open?, <<-PATTERN
+        def_node_matcher :open?, <<~PATTERN
           (send nil? :open $!str ...)
         PATTERN
 

data/lib/rubocop/cop/security/yaml_load.rb

@@ -18,7 +18,7 @@ module RuboCop
       class YAMLLoad < Cop
         MSG = 'Prefer using `YAML.safe_load` over `YAML.load`.'
 
-        def_node_matcher :yaml_load, <<-PATTERN
+        def_node_matcher :yaml_load, <<~PATTERN
           (send (const {nil? cbase} :YAML) :load ...)
         PATTERN
 

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

@@ -138,7 +138,7 @@ module RuboCop
           end
         end
 
-        def_node_matcher :identifier, <<-PATTERN
+        def_node_matcher :identifier, <<~PATTERN
           (sym $_)
         PATTERN
       end

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

@@ -20,7 +20,7 @@ module RuboCop
       class ColonMethodCall < Cop
         MSG = 'Do not use `::` for method calls.'
 
-        def_node_matcher :java_type_node?, <<-PATTERN
+        def_node_matcher :java_type_node?, <<~PATTERN
           (send
             (const nil? :Java) _)
         PATTERN

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

@@ -223,7 +223,7 @@ module RuboCop
 
         # The shovel operator `<<` does not have its own type. It is a `send`
         # type.
-        def_node_matcher :assignment_type?, <<-PATTERN
+        def_node_matcher :assignment_type?, <<~PATTERN
           {
             #{ASSIGNMENT_TYPES.join(' ')}
             (send _recv {:[]= :<< :=~ :!~ :<=> #end_with_eq?} ...)

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

@@ -57,7 +57,7 @@ module RuboCop
           end
         end
 
-        def_node_matcher :visibility_declaration_for?, <<-PATTERN
+        def_node_matcher :visibility_declaration_for?, <<~PATTERN
           (send nil? {:public_constant :private_constant} ({sym str} %1))
         PATTERN
       end

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

@@ -45,15 +45,15 @@ module RuboCop
         CLASS_MSG = 'Prefer Time over DateTime.'
         COERCION_MSG = 'Do not use #to_datetime.'
 
-        def_node_matcher :date_time?, <<-PATTERN
+        def_node_matcher :date_time?, <<~PATTERN
           (send (const {nil? (cbase)} :DateTime) ...)
         PATTERN
 
-        def_node_matcher :historic_date?, <<-PATTERN
+        def_node_matcher :historic_date?, <<~PATTERN
           (send _ _ _ (const (const nil? :Date) _))
         PATTERN
 
-        def_node_matcher :to_datetime?, <<-PATTERN
+        def_node_matcher :to_datetime?, <<~PATTERN
           (send _ :to_datetime)
         PATTERN
 

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

@@ -20,7 +20,7 @@ module RuboCop
         MSG = 'Use `__dir__` to get an absolute path to the current ' \
               "file's directory."
 
-        def_node_matcher :dir_replacement?, <<-PATTERN
+        def_node_matcher :dir_replacement?, <<~PATTERN
           {(send (const nil? :File) :expand_path (send (const nil? :File) :dirname  #file_keyword?))
            (send (const nil? :File) :dirname     (send (const nil? :File) :realpath #file_keyword?))}
         PATTERN

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

@@ -53,7 +53,7 @@ module RuboCop
 
         MSG = 'Missing method documentation comment.'
 
-        def_node_matcher :module_function_node?, <<-PATTERN
+        def_node_matcher :module_function_node?, <<~PATTERN
           (send nil? :module_function ...)
         PATTERN
 

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/UnneededCopDisableDirective
+# rubocop:disable Style/DoubleCopDisableDirective
+
+module RuboCop
+  module Cop
+    module Style
+      # Detects double disable comments on one line. This is mostly to catch
+      # automatically generated comments that need to be regenerated.
+      #
+      # @example
+      #   # bad
+      #   def f # rubocop:disable Style/For # rubocop:disable Metrics/AbcSize
+      #   end
+      #
+      #   # good
+      #   # rubocop:disable Metrics/AbcSize
+      #   def f # rubocop:disable Style/For
+      #   end
+      #   # rubocop:enable Metrics/AbcSize
+      #
+      #   # if both fit on one line
+      #   def f # rubocop:disable Style/For, Metrics/AbcSize
+      #   end
+      #
+      class DoubleCopDisableDirective < Cop
+        # rubocop:enable Style/For, Style/DoubleCopDisableDirective
+        # rubocop:enable Lint/UnneededCopDisableDirective, Metrics/AbcSize
+        MSG = 'More than one disable comment on one line.'
+
+        def investigate(processed_source)
+          processed_source.comments.each do |comment|
+            next unless comment.text.scan('# rubocop:disable').size > 1
+
+            add_offense(comment)
+          end
+        end
+
+        def autocorrect(comment)
+          lambda do |corrector|
+            corrector.replace(comment.loc.expression,
+                              comment.text[/# rubocop:disable \S+/])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -49,7 +49,7 @@ module RuboCop
 
         private
 
-        def_node_matcher :offending_each_range, <<-PATTERN
+        def_node_matcher :offending_each_range, <<~PATTERN
           (block (send (begin (${irange erange} (int $_) (int $_))) :each) (args) ...)
         PATTERN
       end

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

@@ -22,7 +22,7 @@ module RuboCop
         MSG = 'Use `each_with_object` instead of `%<method>s`.'
         METHODS = %i[inject reduce].freeze
 
-        def_node_matcher :each_with_object_candidate?, <<-PATTERN
+        def_node_matcher :each_with_object_candidate?, <<~PATTERN
           (block $(send _ {:inject :reduce} _) $_ $_)
         PATTERN
 

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

@@ -37,7 +37,7 @@ module RuboCop
         MSG_INCORRECT_LINE = 'Use `%<expected>s` instead of `%<actual>s`, ' \
                              'as they are used by backtraces.'
 
-        def_node_matcher :eval_without_location?, <<-PATTERN
+        def_node_matcher :eval_without_location?, <<~PATTERN
           {
             (send nil? :eval ${str dstr})
             (send nil? :eval ${str dstr} _)
@@ -53,7 +53,7 @@ module RuboCop
           }
         PATTERN
 
-        def_node_matcher :line_with_offset?, <<-PATTERN
+        def_node_matcher :line_with_offset?, <<~PATTERN
           {
             (send #special_line_keyword? %1 (int %2))
             (send (int %2) %1 #special_line_keyword?)

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

@@ -18,7 +18,7 @@ module RuboCop
       class EvenOdd < Cop
         MSG = 'Replace with `Integer#%<method>s?`.'
 
-        def_node_matcher :even_odd_candidate?, <<-PATTERN
+        def_node_matcher :even_odd_candidate?, <<~PATTERN
           (send
             {(send $_ :% (int 2))
              (begin (send $_ :% (int 2)))}

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

@@ -51,21 +51,21 @@ module RuboCop
                            'instead of ' \
                            '`Pathname.new(__FILE__).parent.expand_path`.'
 
-        def_node_matcher :file_expand_path, <<-PATTERN
+        def_node_matcher :file_expand_path, <<~PATTERN
           (send
             (const nil? :File) :expand_path
             $_
             $_)
         PATTERN
 
-        def_node_matcher :pathname_parent_expand_path, <<-PATTERN
+        def_node_matcher :pathname_parent_expand_path, <<~PATTERN
           (send
             (send
               (send nil? :Pathname
                 $_) :parent) :expand_path)
         PATTERN
 
-        def_node_matcher :pathname_new_parent_expand_path, <<-PATTERN
+        def_node_matcher :pathname_new_parent_expand_path, <<~PATTERN
           (send
             (send
               (send

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

@@ -42,16 +42,16 @@ module RuboCop
       class FloatDivision < Cop
         include ConfigurableEnforcedStyle
 
-        def_node_matcher :right_coerce?, <<-PATTERN
+        def_node_matcher :right_coerce?, <<~PATTERN
           (send _ :/ (send _ :to_f))
         PATTERN
-        def_node_matcher :left_coerce?, <<-PATTERN
+        def_node_matcher :left_coerce?, <<~PATTERN
           (send (send _ :to_f) :/ _)
         PATTERN
-        def_node_matcher :both_coerce?, <<-PATTERN
+        def_node_matcher :both_coerce?, <<~PATTERN
           (send (send _ :to_f) :/ (send _ :to_f))
         PATTERN
-        def_node_matcher :any_coerce?, <<-PATTERN
+        def_node_matcher :any_coerce?, <<~PATTERN
           {(send _ :/ (send _ :to_f)) (send (send _ :to_f) :/ _)}
         PATTERN
 

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

@@ -40,15 +40,15 @@ module RuboCop
 
         MSG = 'Favor `%<prefer>s` over `%<current>s`.'
 
-        def_node_matcher :formatter, <<-PATTERN
-        {
-          (send nil? ${:sprintf :format} _ _ ...)
-          (send {str dstr} $:% ... )
-          (send !nil? $:% {array hash})
-        }
+        def_node_matcher :formatter, <<~PATTERN
+          {
+            (send nil? ${:sprintf :format} _ _ ...)
+            (send {str dstr} $:% ... )
+            (send !nil? $:% {array hash})
+          }
         PATTERN
 
-        def_node_matcher :variable_argument?, <<-PATTERN
+        def_node_matcher :variable_argument?, <<~PATTERN
           (send {str dstr} :% {send_type? lvar_type?})
         PATTERN
 

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

@@ -118,9 +118,9 @@ module RuboCop
 
         def alternative_style
           case style
-          when :hash_rockets then
+          when :hash_rockets
             :ruby19
-          when :ruby19, :ruby19_no_mixed_keys then
+          when :ruby19, :ruby19_no_mixed_keys
             :hash_rockets
           end
         end

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

@@ -47,7 +47,7 @@ module RuboCop
           [Style::Not]
         end
 
-        def_node_matcher :inverse_candidate?, <<-PATTERN
+        def_node_matcher :inverse_candidate?, <<~PATTERN
           {
             (send $(send $(...) $_ $...) :!)
             (send (block $(send $(...) $_) $...) :!)
@@ -55,7 +55,7 @@ module RuboCop
           }
         PATTERN
 
-        def_node_matcher :inverse_block?, <<-PATTERN
+        def_node_matcher :inverse_block?, <<~PATTERN
           (block $(send (...) $_) ... { $(send ... :!)
                                         $(send (...) {:!= :!~} ...)
                                         (begin ... $(send ... :!))

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,7 +44,7 @@ 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

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