rubocop 0.70.0 → 0.75.0

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/uri_escape_unescape.rb

@@ -45,7 +45,7 @@ module RuboCop
               'Instead, use %<replacements>s depending on your specific use ' \
               'case.'
 
-        def_node_matcher :uri_escape_unescape?, <<-PATTERN
+        def_node_matcher :uri_escape_unescape?, <<~PATTERN
           (send
             (const ${nil? cbase} :URI) ${:escape :encode :unescape :decode}
             ...)

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

@@ -18,13 +18,13 @@ module RuboCop
               'be used. Instead, use `%<top_level>sURI::DEFAULT_PARSER.' \
               'make_regexp%<arg>s`.'
 
-        def_node_matcher :uri_regexp_with_argument?, <<-PATTERN
+        def_node_matcher :uri_regexp_with_argument?, <<~PATTERN
           (send
             (const ${nil? cbase} :URI) :regexp
             (str $_))
         PATTERN
 
-        def_node_matcher :uri_regexp_without_argument?, <<-PATTERN
+        def_node_matcher :uri_regexp_without_argument?, <<~PATTERN
           (send
             (const ${nil? cbase} :URI) :regexp)
         PATTERN

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

@@ -113,19 +113,19 @@ module RuboCop
 
         private
 
-        def_node_matcher :static_method_definition?, <<-PATTERN
+        def_node_matcher :static_method_definition?, <<~PATTERN
           {def (send nil? {:attr :attr_reader :attr_writer :attr_accessor} ...)}
         PATTERN
 
-        def_node_matcher :dynamic_method_definition?, <<-PATTERN
+        def_node_matcher :dynamic_method_definition?, <<~PATTERN
           {(send nil? :define_method ...) (block (send nil? :define_method ...) ...)}
         PATTERN
 
-        def_node_matcher :class_or_instance_eval?, <<-PATTERN
+        def_node_matcher :class_or_instance_eval?, <<~PATTERN
           (block (send _ {:class_eval :instance_eval}) ...)
         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
 
@@ -202,7 +202,7 @@ module RuboCop
           cop_config.fetch('MethodCreatingMethods', []).any? do |m|
             matcher_name = "#{m}_method?".to_sym
             unless respond_to?(matcher_name)
-              self.class.def_node_matcher matcher_name, <<-PATTERN
+              self.class.def_node_matcher matcher_name, <<~PATTERN
                 {def (send nil? :#{m} ...)}
               PATTERN
             end
@@ -226,7 +226,7 @@ module RuboCop
           cop_config.fetch('ContextCreatingMethods', []).any? do |m|
             matcher_name = "#{m}_block?".to_sym
             unless respond_to?(matcher_name)
-              self.class.def_node_matcher matcher_name, <<-PATTERN
+              self.class.def_node_matcher matcher_name, <<~PATTERN
                 (block (send {nil? const} {:#{m}} ...) ...)
               PATTERN
             end

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

@@ -49,7 +49,7 @@ module RuboCop
 
         private
 
-        def_node_matcher :setter_call_to_local_variable?, <<-PATTERN
+        def_node_matcher :setter_call_to_local_variable?, <<~PATTERN
           [(send (lvar _) ...) setter_method?]
         PATTERN
 

data/lib/rubocop/cop/message_annotator.rb

@@ -9,11 +9,11 @@ module RuboCop
     #
     # @example
     #   RuboCop::Cop::MessageAnnotator.new(
-    #     config, cop_config, @options
-    #   ).annotate('message', 'Cop/CopName')
+    #     config, cop_name, cop_config, @options
+    #   ).annotate('message')
     #  #=> 'Cop/CopName: message (http://example.org/styleguide)'
     class MessageAnnotator
-      attr_reader :options, :config, :cop_config
+      attr_reader :options, :config, :cop_name, :cop_config
 
       @style_guide_urls = {}
 
@@ -29,6 +29,7 @@ module RuboCop
       #     :ExtraDetails [Boolean] Include cop details
       #     :DisplayCopNames [Boolean] Include cop name
       #
+      # @param [String] cop_name for specific cop name
       # @param [Hash] cop_config configs for specific cop, from config#for_cop
       # @option cop_config [String] :StyleGuide Extension of base styleguide URL
       # @option cop_config [String] :Reference Full reference URL
@@ -43,8 +44,9 @@ module RuboCop
       #   Include debug output
       # @option options [Boolean] :display_cop_names
       #   Include cop name
-      def initialize(config, cop_config, options)
+      def initialize(config, cop_name, cop_config, options)
         @config = config
+        @cop_name = cop_name
         @cop_config = cop_config || {}
         @options = options
       end
@@ -53,8 +55,8 @@ module RuboCop
       # based on params passed into initializer
       #
       # @return [String] annotated message
-      def annotate(message, name)
-        message = "#{name}: #{message}" if display_cop_names?
+      def annotate(message)
+        message = "#{cop_name}: #{message}" if display_cop_names?
         message += " #{details}" if extra_details? && details
         if display_style_guide?
           links = urls.join(', ')
@@ -74,7 +76,7 @@ module RuboCop
         return nil if url.nil? || url.empty?
 
         self.class.style_guide_urls[url] ||= begin
-          base_url = config.for_all_cops['StyleGuideBaseURL']
+          base_url = style_guide_base_url
           if base_url.nil? || base_url.empty?
             url
           else
@@ -83,6 +85,13 @@ module RuboCop
         end
       end
 
+      def style_guide_base_url
+        department_name = cop_name.split('/').first
+
+        config.for_department(department_name)['StyleGuideBaseURL'] ||
+          config.for_all_cops['StyleGuideBaseURL']
+      end
+
       def display_style_guide?
         (options[:display_style_guide] ||
          config.for_all_cops['DisplayStyleGuide']) &&