rubocop 0.71.0 → 0.75.1

data/lib/rubocop/cop/lint/ineffective_access_modifier.rb

@@ -53,7 +53,7 @@ module RuboCop
         ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` ' \
                                 'block'
 
-        def_node_search :private_class_methods, <<-PATTERN
+        def_node_search :private_class_methods, <<~PATTERN
           (send nil? :private_class_method $...)
         PATTERN
 

data/lib/rubocop/cop/lint/inherit_exception.rb

@@ -55,7 +55,7 @@ module RuboCop
           SystemExit
         ].freeze
 
-        def_node_matcher :class_new_call?, <<-PATTERN
+        def_node_matcher :class_new_call?, <<~PATTERN
           (send
             (const {cbase nil?} :Class) :new
             $(const {cbase nil?} _))

data/lib/rubocop/cop/lint/literal_in_interpolation.rb

@@ -17,21 +17,20 @@ module RuboCop
       #
       #   "result is 10"
       class LiteralInInterpolation < Cop
+        include Interpolation
         include RangeHelp
         include PercentLiteral
 
         MSG = 'Literal interpolation detected.'
         COMPOSITE = %i[array hash pair irange erange].freeze
 
-        def on_dstr(node)
-          node.each_child_node(:begin) do |begin_node|
-            final_node = begin_node.children.last
-            next unless final_node
-            next if special_keyword?(final_node)
-            next unless prints_as_self?(final_node)
+        def on_interpolation(begin_node)
+          final_node = begin_node.children.last
+          return unless final_node
+          return if special_keyword?(final_node)
+          return unless prints_as_self?(final_node)
 
-            add_offense(final_node)
-          end
+          add_offense(final_node)
         end
 
         def autocorrect(node)

data/lib/rubocop/cop/lint/multiple_compare.rb

@@ -24,7 +24,7 @@ module RuboCop
       class MultipleCompare < Cop
         MSG = 'Use the `&&` operator to compare multiple values.'
 
-        def_node_matcher :multiple_compare?, <<-PATTERN
+        def_node_matcher :multiple_compare?, <<~PATTERN
           (send (send _ {:< :> :<= :>=} $_) {:< :> :<= :>=} _)
         PATTERN
 

data/lib/rubocop/cop/lint/nested_method_definition.rb

@@ -87,15 +87,15 @@ module RuboCop
             class_or_module_or_struct_new_call?(child)
         end
 
-        def_node_matcher :eval_call?, <<-PATTERN
+        def_node_matcher :eval_call?, <<~PATTERN
           (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
-        def_node_matcher :exec_call?, <<-PATTERN
+        def_node_matcher :exec_call?, <<~PATTERN
           (block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
 
-        def_node_matcher :class_or_module_or_struct_new_call?, <<-PATTERN
+        def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
           (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
         PATTERN
       end

data/lib/rubocop/cop/lint/next_without_accumulator.rb

@@ -25,7 +25,7 @@ module RuboCop
       class NextWithoutAccumulator < Cop
         MSG = 'Use `next` with an accumulator argument in a `reduce`.'
 
-        def_node_matcher :on_body_of_reduce, <<-PATTERN
+        def_node_matcher :on_body_of_reduce, <<~PATTERN
           (block (send _recv {:reduce :inject} !sym) _blockargs $(begin ...))
         PATTERN
 

data/lib/rubocop/cop/lint/non_local_exit_from_iterator.rb

@@ -74,7 +74,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/lint/number_conversion.rb

@@ -31,17 +31,17 @@ module RuboCop
               '%<number_object>s.%<to_method>s, use stricter '\
               '%<corrected_method>s.'
 
-        def_node_matcher :to_method, <<-PATTERN
+        def_node_matcher :to_method, <<~PATTERN
           (send $_ ${:to_i :to_f :to_c})
         PATTERN
 
-        def_node_matcher :datetime?, <<-PATTERN
+        def_node_matcher :datetime?, <<~PATTERN
           (send (const {nil? (cbase)} {:Time :DateTime}) ...)
         PATTERN
 
         def on_send(node)
           to_method(node) do |receiver, to_method|
-            next if date_time_object?(receiver)
+            next if receiver.nil? || date_time_object?(receiver)
 
             message = format(
               MSG,
@@ -64,7 +64,7 @@ module RuboCop
 
         def date_time_object?(node)
           child = node
-          while child.send_type?
+          while child&.send_type?
             return true if datetime? child
 
             child = child.children[0]

data/lib/rubocop/cop/lint/rand_one.rb

@@ -24,7 +24,7 @@ module RuboCop
         MSG = '`%<method>s` always returns `0`. ' \
               'Perhaps you meant `rand(2)` or `rand`?'
 
-        def_node_matcher :rand_one?, <<-PATTERN
+        def_node_matcher :rand_one?, <<~PATTERN
           (send {(const nil? :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
         PATTERN
 

data/lib/rubocop/cop/lint/redundant_with_index.rb

@@ -32,7 +32,7 @@ module RuboCop
         MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'
         MSG_WITH_INDEX = 'Remove redundant `with_index`.'
 
-        def_node_matcher :redundant_with_index?, <<-PATTERN
+        def_node_matcher :redundant_with_index?, <<~PATTERN
           (block
             $(send
               _ {:each_with_index :with_index} ...)

data/lib/rubocop/cop/lint/redundant_with_object.rb

@@ -33,7 +33,7 @@ module RuboCop
 
         MSG_WITH_OBJECT = 'Remove redundant `with_object`.'
 
-        def_node_matcher :redundant_with_object?, <<-PATTERN
+        def_node_matcher :redundant_with_object?, <<~PATTERN
           (block
             $(send _ {:each_with_object :with_object}
               _)

data/lib/rubocop/cop/lint/safe_navigation_chain.rb

@@ -29,11 +29,11 @@ module RuboCop
         MSG = 'Do not chain ordinary method call' \
               ' after safe navigation operator.'
 
-        def_node_matcher :bad_method?, <<-PATTERN
-        {
-          (send $(csend ...) $_ ...)
-          (send $(block (csend ...) ...) $_ ...)
-        }
+        def_node_matcher :bad_method?, <<~PATTERN
+          {
+            (send $(csend ...) $_ ...)
+            (send $(block (csend ...) ...) $_ ...)
+          }
         PATTERN
 
         def on_send(node)

data/lib/rubocop/cop/lint/safe_navigation_with_empty.rb

@@ -23,7 +23,7 @@ module RuboCop
         MSG = 'Avoid calling `empty?` with the safe navigation operator ' \
           'in conditionals.'
 
-        def_node_matcher :safe_navigation_empty_in_conditional?, <<-PATTERN
+        def_node_matcher :safe_navigation_empty_in_conditional?, <<~PATTERN
           (if (csend (send ...) :empty?) ...)
         PATTERN
 

data/lib/rubocop/cop/lint/send_with_mixin_argument.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      #
+      # This cop checks for `send`, `public_send`, and `__send__` methods
+      # when using mix-in.
+      #
+      # `include` and `prepend` methods were private methods until Ruby 2.0,
+      # they were mixed-in via `send` method. This cop uses Ruby 2.1 or
+      # higher style that can be called by public methods.
+      # And `extend` method that was originally a public method is also targeted
+      # for style unification.
+      #
+      # @example
+      #   # bad
+      #   Foo.send(:include, Bar)
+      #   Foo.send(:prepend, Bar)
+      #   Foo.send(:extend, Bar)
+      #
+      #   # bad
+      #   Foo.public_send(:include, Bar)
+      #   Foo.public_send(:prepend, Bar)
+      #   Foo.public_send(:extend, Bar)
+      #
+      #   # bad
+      #   Foo.__send__(:include, Bar)
+      #   Foo.__send__(:prepend, Bar)
+      #   Foo.__send__(:extend, Bar)
+      #
+      #   # good
+      #   Foo.include Bar
+      #   Foo.prepend Bar
+      #   Foo.extend Bar
+      #
+      class SendWithMixinArgument < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<method>s %<module_name>s` instead of `%<bad_method>s`.'
+        MIXIN_METHODS = %i[include prepend extend].freeze
+
+        def_node_matcher :send_with_mixin_argument?, <<~PATTERN
+          (send
+            (const _ _) {:send :public_send :__send__}
+            ({sym str} $#mixin_method?)
+              $(const _ _))
+        PATTERN
+
+        def on_send(node)
+          send_with_mixin_argument?(node) do |method, module_name|
+            message = message(
+              method, module_name.source, bad_location(node).source
+            )
+
+            add_offense(node, location: bad_location(node), message: message)
+          end
+        end
+
+        def autocorrect(node)
+          send_with_mixin_argument?(node) do |method, module_name|
+            lambda do |corrector|
+              corrector.replace(
+                bad_location(node), "#{method} #{module_name.source}"
+              )
+            end
+          end
+        end
+
+        private
+
+        def bad_location(node)
+          loc = node.loc
+
+          range_between(loc.selector.begin_pos, loc.expression.end_pos)
+        end
+
+        def message(method, module_name, bad_method)
+          format(
+            MSG,
+            method: method, module_name: module_name, bad_method: bad_method
+          )
+        end
+
+        def mixin_method?(node)
+          MIXIN_METHODS.include?(node.to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/string_conversion_in_interpolation.rb

@@ -18,20 +18,20 @@ module RuboCop
       #
       #   "result is #{something}"
       class StringConversionInInterpolation < Cop
+        include Interpolation
+
         MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'
         MSG_SELF = 'Use `self` instead of `Object#to_s` in ' \
                    'interpolation.'
 
         def_node_matcher :to_s_without_args?, '(send _ :to_s)'
 
-        def on_dstr(node)
-          node.each_child_node(:begin) do |begin_node|
-            final_node = begin_node.children.last
+        def on_interpolation(begin_node)
+          final_node = begin_node.children.last
 
-            next unless to_s_without_args?(final_node)
+          return unless to_s_without_args?(final_node)
 
-            add_offense(final_node, location: :selector)
-          end
+          add_offense(final_node, location: :selector)
         end
 
         def autocorrect(node)

data/lib/rubocop/cop/lint/unified_integer.rb

@@ -20,7 +20,7 @@ module RuboCop
       class UnifiedInteger < Cop
         MSG = 'Use `Integer` instead of `%<klass>s`.'
 
-        def_node_matcher :fixnum_or_bignum_const, <<-PATTERN
+        def_node_matcher :fixnum_or_bignum_const, <<~PATTERN
           (:const {nil? (:cbase)} ${:Fixnum :Bignum})
         PATTERN
 

data/lib/rubocop/cop/lint/unneeded_cop_disable_directive.rb

@@ -155,7 +155,7 @@ module RuboCop
         end
 
         def all_disabled?(comment)
-          comment.text =~ /rubocop\s*:\s*disable\s+all\b/
+          comment.text =~ /rubocop\s*:\s*(?:disable|todo)\s+all\b/
         end
 
         def ignore_offense?(disabled_ranges, line_range)

data/lib/rubocop/cop/lint/unneeded_require_statement.rb

@@ -26,7 +26,7 @@ module RuboCop
 
         MSG = 'Remove unnecessary `require` statement.'
 
-        def_node_matcher :unnecessary_require_statement?, <<-PATTERN
+        def_node_matcher :unnecessary_require_statement?, <<~PATTERN
           (send nil? :require
             (str {"enumerator" "rational" "complex" "thread"}))
         PATTERN

data/lib/rubocop/cop/lint/unneeded_splat_expansion.rb

@@ -58,9 +58,14 @@ module RuboCop
         PERCENT_CAPITAL_I = '%I'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
-        def_node_matcher :array_new?, '$(send (const nil? :Array) :new ...)'
+        def_node_matcher :array_new?, <<~PATTERN
+          {
+            $(send (const nil? :Array) :new ...)
+            $(block (send (const nil? :Array) :new ...) ...)
+          }
+        PATTERN
 
-        def_node_matcher :literal_expansion, <<-PATTERN
+        def_node_matcher :literal_expansion, <<~PATTERN
           (splat {$({str dstr int float array} ...) (block $#array_new? ...) $#array_new?} ...)
         PATTERN
 

data/lib/rubocop/cop/lint/unreachable_code.rb

@@ -51,7 +51,7 @@ module RuboCop
 
         private
 
-        def_node_matcher :flow_command?, <<-PATTERN
+        def_node_matcher :flow_command?, <<~PATTERN
           {
             return next break retry redo
             (send

data/lib/rubocop/cop/lint/unused_block_argument.rb

@@ -6,9 +6,7 @@ module RuboCop
       # This cop checks for unused block arguments.
       #
       # @example
-      #
       #   # bad
-      #
       #   do_something do |used, unused|
       #     puts used
       #   end
@@ -21,10 +19,7 @@ module RuboCop
       #     puts :baz
       #   end
       #
-      # @example
-      #
-      #   #good
-      #
+      #   # good
       #   do_something do |used, _unused|
       #     puts used
       #   end
@@ -36,6 +31,27 @@ module RuboCop
       #   define_method(:foo) do |_bar|
       #     puts :baz
       #   end
+      #
+      # @example IgnoreEmptyBlocks: true (default)
+      #   # good
+      #   do_something { |unused| }
+      #
+      # @example IgnoreEmptyBlocks: false
+      #   # bad
+      #   do_something { |unused| }
+      #
+      # @example AllowUnusedKeywordArguments: false (default)
+      #   # bad
+      #   do_something do |unused: 42|
+      #     foo
+      #   end
+      #
+      # @example AllowUnusedKeywordArguments: true
+      #   # good
+      #   do_something do |unused: 42|
+      #     foo
+      #   end
+      #
       class UnusedBlockArgument < Cop
         include UnusedArgument
 

data/lib/rubocop/cop/lint/unused_method_argument.rb

@@ -6,20 +6,38 @@ module RuboCop
       # This cop checks for unused method arguments.
       #
       # @example
-      #
       #   # bad
-      #
       #   def some_method(used, unused, _unused_but_allowed)
       #     puts used
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   def some_method(used, _unused, _unused_but_allowed)
       #     puts used
       #   end
+      #
+      # @example AllowUnusedKeywordArguments: false (default)
+      #   # bad
+      #   def do_something(used, unused: 42)
+      #     used
+      #   end
+      #
+      # @example AllowUnusedKeywordArguments: true
+      #   # good
+      #   def do_something(used, unused: 42)
+      #     used
+      #   end
+      #
+      # @example IgnoreEmptyMethods: true (default)
+      #   # good
+      #   def do_something(unused)
+      #   end
+      #
+      # @example IgnoreEmptyMethods: false
+      #   # bad
+      #   def do_something(unused)
+      #   end
+      #
       class UnusedMethodArgument < Cop
         include UnusedArgument