rubocop 0.50.0 → 0.51.0

data/lib/rubocop/cop/performance/caller.rb

@@ -26,8 +26,8 @@ module RuboCop
 
         def_node_matcher :slow_caller?, <<-PATTERN
           {
-            (send nil {:caller :caller_locations})
-            (send nil {:caller :caller_locations} int)
+            (send nil? {:caller :caller_locations})
+            (send nil? {:caller :caller_locations} int)
           }
         PATTERN
 

data/lib/rubocop/cop/performance/case_when_splat.rb

@@ -68,7 +68,7 @@ module RuboCop
             range = condition.parent.loc.keyword.join(condition.source_range)
             variable, = *condition
             message = variable.array_type? ? ARRAY_MSG : MSG
-            add_offense(condition.parent, range, message)
+            add_offense(condition.parent, location: range, message: message)
           end
         end
 

data/lib/rubocop/cop/performance/casecmp.rb

@@ -40,7 +40,7 @@ module RuboCop
 
           inefficient_comparison(node) do |range, is_other_part, *methods|
             ignore_node(node) if is_other_part
-            add_offense(node, range, format(MSG, *methods))
+            add_offense(node, location: range, message: format(MSG, *methods))
           end
         end
 

data/lib/rubocop/cop/performance/compare_with_block.rb

@@ -46,8 +46,12 @@ module RuboCop
             replaceable_body?(body, var_a, var_b) do |method, args_a, args_b|
               return unless slow_compare?(method, args_a, args_b)
               range = compare_range(send, node)
-              add_offense(node, range,
-                          message(send, method, var_a, var_b, args_a))
+
+              add_offense(
+                node,
+                location: range,
+                message: message(send, method, var_a, var_b, args_a)
+              )
             end
           end
         end

data/lib/rubocop/cop/performance/count.rb

@@ -59,7 +59,9 @@ module RuboCop
               selector_node.loc.selector.begin_pos
             end
 
-            add_offense(node, range, format(MSG, selector, counter))
+            add_offense(node,
+                        location: range,
+                        message: format(MSG, selector, counter))
           end
         end
 

data/lib/rubocop/cop/performance/detect.rb

@@ -84,10 +84,10 @@ module RuboCop
           range = receiver.loc.selector.join(node.loc.selector)
 
           message = second_method == :last ? REVERSE_MSG : MSG
-          add_offense(node, range, format(message,
-                                          preferred_method,
-                                          first_method,
-                                          second_method))
+          formatted_message = format(message, preferred_method, first_method,
+                                     second_method)
+
+          add_offense(node, location: range, message: formatted_message)
         end
 
         def preferred_method

data/lib/rubocop/cop/performance/double_start_end_with.rb

@@ -68,15 +68,12 @@ module RuboCop
         end
 
         def add_offense_for_double_call(node, receiver, method, combined_args)
-          add_offense(node,
-                      :expression,
-                      format(
-                        MSG,
-                        receiver: receiver.source,
-                        method: method,
-                        combined_args: combined_args,
-                        original_code: node.source
-                      ))
+          msg = format(MSG, receiver: receiver.source,
+                            method: method,
+                            combined_args: combined_args,
+                            original_code: node.source)
+
+          add_offense(node, message: msg)
         end
 
         def check_for_active_support_aliases?

data/lib/rubocop/cop/performance/end_with.rb

@@ -19,7 +19,7 @@ module RuboCop
         SINGLE_QUOTE = "'".freeze
 
         def_node_matcher :redundant_regex?, <<-PATTERN
-          {(send $!nil {:match :=~} (regexp (str $#literal_at_end?) (regopt)))
+          {(send $!nil? {:match :=~} (regexp (str $#literal_at_end?) (regopt)))
            (send (regexp (str $#literal_at_end?) (regopt)) {:match :=~} $_)}
         PATTERN
 

data/lib/rubocop/cop/performance/flat_map.rb

@@ -65,7 +65,9 @@ module RuboCop
           range = range_between(map_node.loc.selector.begin_pos,
                                 node.loc.expression.end_pos)
 
-          add_offense(node, range, format(message, first_method, flatten))
+          add_offense(node,
+                      location: range,
+                      message: format(message, first_method, flatten))
         end
       end
     end

data/lib/rubocop/cop/performance/hash_each_methods.rb

@@ -3,7 +3,11 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop checks for uses of `each_key` & `each_value` Hash methods.
+      # This cop checks for uses of `each_key` and `each_value` Hash methods.
+      #
+      # Note: If you have an array of two-element arrays, you can put
+      #   parentheses around the block arguments to indicate that you're not
+      #   working with a hash, and supress RuboCop offenses.
       #
       # @example
       #   # bad
@@ -21,7 +25,7 @@ module RuboCop
         MSG = 'Use `%s` instead of `%s`.'.freeze
 
         def_node_matcher :plain_each, <<-PATTERN
-          (block $(send _ :each) (args (arg $_k) (arg $_v)) ...)
+          (block $(send !(send _ :to_a) :each) (args (arg $_k) (arg $_v)) ...)
         PATTERN
 
         def_node_matcher :kv_each, <<-PATTERN
@@ -39,21 +43,20 @@ module RuboCop
           plain_each(node) do |target, k, v|
             return if @args[k] && @args[v]
             used = @args[k] ? :key : :value
+
             add_offense(
-              target, plain_range(target), format(message,
-                                                  "each_#{used}",
-                                                  :each)
+              target,
+              location: plain_range(target),
+              message: format(message, "each_#{used}", :each)
             )
           end
         end
 
         def register_kv_offense(node)
           kv_each(node) do |target, method|
-            add_offense(
-              target, kv_range(target), format(message,
-                                               "each_#{method[0..-2]}",
-                                               "#{method}.each")
-            )
+            msg = format(message, "each_#{method[0..-2]}", "#{method}.each")
+
+            add_offense(target, location: kv_range(target), message: msg)
           end
         end
 

data/lib/rubocop/cop/performance/lstrip_rstrip.rb

@@ -25,7 +25,9 @@ module RuboCop
           lstrip_rstrip(node) do |first_send, method_one, method_two|
             range = range_between(first_send.loc.selector.begin_pos,
                                   node.source_range.end_pos)
-            add_offense(node, range, format(MSG, method_one, method_two))
+            add_offense(node,
+                        location: range,
+                        message: format(MSG, method_one, method_two))
           end
         end
 

data/lib/rubocop/cop/performance/range_include.rb

@@ -29,7 +29,7 @@ module RuboCop
         def on_send(node)
           return unless range_include(node)
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)

data/lib/rubocop/cop/performance/redundant_block_call.rb

@@ -47,7 +47,7 @@ module RuboCop
             next unless body
 
             calls_to_report(argname, body).each do |blockcall|
-              add_offense(blockcall, :expression, format(MSG, argname))
+              add_offense(blockcall, message: format(MSG, argname))
             end
           end
         end

data/lib/rubocop/cop/performance/redundant_match.rb

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop identifies use of `Regexp#match` or `String#match` in a context
-      # where the integral return value of `=~` would do just as well.
+      # This cop identifies the use of `Regexp#match` or `String#match`, which
+      # returns `#<MatchData>`/`nil`. The return value of `=~` is an integral
+      # index/`nil` and is more performant.
       #
       # @example
       #   @bad
@@ -14,8 +15,8 @@ module RuboCop
       #   end
       #
       #   @good
-      #   method(str.match(/regex/))
-      #   return regex.match('str')
+      #   method(str =~ /regex/)
+      #   return value unless regex =~ 'str'
       class RedundantMatch < Cop
         MSG = 'Use `=~` in places where the `MatchData` returned by ' \
               '`#match` will not be used.'.freeze
@@ -24,7 +25,7 @@ module RuboCop
         # a string or regexp literal on one side or the other
         def_node_matcher :match_call?, <<-PATTERN
           {(send {str regexp} :match _)
-           (send !nil :match {str regexp})}
+           (send !nil? :match {str regexp})}
         PATTERN
 
         def_node_matcher :only_truthiness_matters?, <<-PATTERN

data/lib/rubocop/cop/performance/redundant_merge.rb

@@ -15,7 +15,7 @@ module RuboCop
         MSG = 'Use `%s` instead of `%s`.'.freeze
 
         def_node_matcher :redundant_merge_candidate, <<-PATTERN
-          (send $!nil :merge! [(hash $...) !kwsplat_type?])
+          (send $!nil? :merge! [(hash $...) !kwsplat_type?])
         PATTERN
 
         def_node_matcher :modifier_flow_control?, <<-PATTERN

data/lib/rubocop/cop/performance/redundant_sort_by.rb

@@ -25,7 +25,10 @@ module RuboCop
         def on_block(node)
           redundant_sort_by(node) do |send, var_name|
             range = sort_by_range(send, node)
-            add_offense(node, range, format(MSG, var_name, var_name))
+
+            add_offense(node,
+                        location: range,
+                        message: format(MSG, var_name, var_name))
           end
         end
 

data/lib/rubocop/cop/performance/regexp_match.rb

@@ -74,11 +74,11 @@ module RuboCop
         PATTERN
 
         def_node_matcher :match_operator?, <<-PATTERN
-          (send !nil :=~ !nil)
+          (send !nil? :=~ !nil?)
         PATTERN
 
         def_node_matcher :match_threequals?, <<-PATTERN
-          (send (regexp (str _) {(regopt) (regopt _)}) :=== !nil)
+          (send (regexp (str _) {(regopt) (regopt _)}) :=== !nil?)
         PATTERN
 
         def match_with_lvasgn?(node)
@@ -101,8 +101,8 @@ module RuboCop
 
         def_node_search :last_matches, <<-PATTERN
           {
-            (send (const nil :Regexp) :last_match)
-            (send (const nil :Regexp) :last_match _)
+            (send (const nil? :Regexp) :last_match)
+            (send (const nil? :Regexp) :last_match _)
             ({back_ref nth_ref} _)
             (gvar #match_gvar?)
           }

data/lib/rubocop/cop/performance/reverse_each.rb

@@ -27,7 +27,7 @@ module RuboCop
 
             range = range_between(location_of_reverse, end_location)
 
-            add_offense(node, range)
+            add_offense(node, location: range)
           end
         end
 

data/lib/rubocop/cop/performance/sample.rb

@@ -37,7 +37,7 @@ module RuboCop
 
             range = source_range(shuffle, node)
             message = message(shuffle_arg, method, method_args, range)
-            add_offense(node, range, message)
+            add_offense(node, location: range, message: message)
           end
         end
 

data/lib/rubocop/cop/performance/size.rb

@@ -29,7 +29,7 @@ module RuboCop
         def on_send(node)
           return unless eligible_node?(node)
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
 
         private

data/lib/rubocop/cop/performance/start_with.rb

@@ -19,7 +19,7 @@ module RuboCop
         SINGLE_QUOTE = "'".freeze
 
         def_node_matcher :redundant_regex?, <<-PATTERN
-          {(send $!nil {:match :=~} (regexp (str $#literal_at_start?) (regopt)))
+          {(send $!nil? {:match :=~} (regexp (str $#literal_at_start?) (regopt)))
            (send (regexp (str $#literal_at_start?) (regopt)) {:match :=~} $_)}
         PATTERN
 

data/lib/rubocop/cop/performance/string_replacement.rb

@@ -28,7 +28,7 @@ module RuboCop
 
         def_node_matcher :string_replacement?, <<-PATTERN
           (send _ {:gsub :gsub!}
-                    ${regexp str (send (const nil :Regexp) {:new :compile} _)}
+                    ${regexp str (send (const nil? :Regexp) {:new :compile} _)}
                     $str)
         PATTERN
 
@@ -101,7 +101,7 @@ module RuboCop
           second_source, = *second_param
           message = message(node, first_source, second_source)
 
-          add_offense(node, range(node), message)
+          add_offense(node, location: range(node), message: message)
         end
 
         def first_source(first_param)

data/lib/rubocop/cop/performance/times_map.rb

@@ -35,7 +35,7 @@ module RuboCop
 
         def check(node)
           times_map_call(node) do |map_or_collect, count|
-            add_offense(node, :expression, message(map_or_collect, count))
+            add_offense(node, message: message(map_or_collect, count))
           end
         end
 
@@ -51,8 +51,8 @@ module RuboCop
         end
 
         def_node_matcher :times_map_call, <<-PATTERN
-          {(block $(send (send $!nil :times) {:map :collect}) ...)
-           $(send (send $!nil :times) {:map :collect} (block_pass ...))}
+          {(block $(send (send $!nil? :times) {:map :collect}) ...)
+           $(send (send $!nil? :times) {:map :collect} (block_pass ...))}
         PATTERN
 
         def autocorrect(node)

data/lib/rubocop/cop/performance/unfreeze_string.rb

@@ -36,8 +36,8 @@ module RuboCop
 
         def_node_matcher :string_new?, <<-PATTERN
           {
-            (send (const nil :String) :new {str dstr})
-            (send (const nil :String) :new)
+            (send (const nil? :String) :new {str dstr})
+            (send (const nil? :String) :new)
           }
         PATTERN
 

data/lib/rubocop/cop/performance/uri_default_parser.rb

@@ -20,7 +20,7 @@ module RuboCop
         def_node_matcher :uri_parser_new?, <<-PATTERN
           (send
             (const
-              (const ${nil cbase} :URI) :Parser) :new)
+              (const ${nil? cbase} :URI) :Parser) :new)
         PATTERN
 
         def on_send(node)
@@ -28,7 +28,7 @@ module RuboCop
             double_colon = captured_value ? '::' : ''
             message = format(MSG, double_colon, double_colon)
 
-            add_offense(node, :expression, message)
+            add_offense(node, message: message)
           end
         end
 

data/lib/rubocop/cop/rails/action_filter.rb

@@ -70,7 +70,7 @@ module RuboCop
         def check_method_node(node)
           return unless bad_methods.include?(node.method_name)
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
 
         def message(node)

data/lib/rubocop/cop/rails/active_support_aliases.rb

@@ -58,8 +58,7 @@ module RuboCop
         def register_offense(node, method_name)
           add_offense(
             node,
-            :expression,
-            format(MSG, ALIASES[method_name][:original], method_name)
+            message: format(MSG, ALIASES[method_name][:original], method_name)
           )
         end
       end

data/lib/rubocop/cop/rails/application_job.rb

@@ -23,7 +23,7 @@ module RuboCop
 
         MSG = 'Jobs should subclass `ApplicationJob`.'.freeze
         SUPERCLASS = 'ApplicationJob'.freeze
-        BASE_PATTERN = '(const (const nil :ActiveJob) :Base)'.freeze
+        BASE_PATTERN = '(const (const nil? :ActiveJob) :Base)'.freeze
 
         include RuboCop::Cop::EnforceSuperclass
       end

data/lib/rubocop/cop/rails/application_record.rb

@@ -23,7 +23,7 @@ module RuboCop
 
         MSG = 'Models should subclass `ApplicationRecord`.'.freeze
         SUPERCLASS = 'ApplicationRecord'.freeze
-        BASE_PATTERN = '(const (const nil :ActiveRecord) :Base)'.freeze
+        BASE_PATTERN = '(const (const nil? :ActiveRecord) :Base)'.freeze
 
         include RuboCop::Cop::EnforceSuperclass
       end

data/lib/rubocop/cop/rails/blank.rb

@@ -38,17 +38,21 @@ module RuboCop
       #       something
       #     end
       class Blank < Cop
-        MSG_NIL_OR_EMPTY = 'Use `%s.blank?` instead of `%s`.'.freeze
+        MSG_NIL_OR_EMPTY = 'Use `%s` instead of `%s`.'.freeze
         MSG_NOT_PRESENT = 'Use `%s` instead of `%s`.'.freeze
-        MSG_UNLESS_PRESENT = 'Use `if %s.blank?` instead of `%s`.'.freeze
+        MSG_UNLESS_PRESENT = 'Use `if %s` instead of `%s`.'.freeze
 
+        # `(send nil $_)` is not actually a valid match for an offense. Nodes
+        # that have a single method call on the left hand side
+        # (`bar || foo.empty?`) will blow up when checking
+        # `(send (:nil) :== $_)`.
         def_node_matcher :nil_or_empty?, <<-PATTERN
           (or
               {
                 (send $_ :!)
                 (send $_ :nil?)
-                (send $_ :== (:nil))
-                (send (:nil) :== $_)
+                (send $_ :== nil)
+                (send nil :== $_)
               }
               {
                 (send $_ :empty?)
@@ -60,7 +64,7 @@ module RuboCop
         def_node_matcher :not_present?, '(send (send $_ :present?) :!)'
 
         def_node_matcher :unless_present?, <<-PATTERN
-          (:if $(send $_ :present?) {nil (...)} ...)
+          (:if $(send $_ :present?) {nil? (...)} ...)
         PATTERN
 
         def on_send(node)
@@ -68,23 +72,22 @@ module RuboCop
 
           not_present?(node) do |receiver|
             add_offense(node,
-                        :expression,
-                        format(MSG_NOT_PRESENT,
-                               replacement(receiver),
-                               node.source))
+                        message: format(MSG_NOT_PRESENT,
+                                        replacement(receiver),
+                                        node.source))
           end
         end
 
         def on_or(node)
           return unless cop_config['NilOrEmpty']
-          return unless node.lhs.receiver && node.rhs.receiver
 
           nil_or_empty?(node) do |variable1, variable2|
             return unless variable1 == variable2
 
             add_offense(node,
-                        :expression,
-                        format(MSG_NIL_OR_EMPTY, variable1.source, node.source))
+                        message: format(MSG_NIL_OR_EMPTY,
+                                        replacement(variable1),
+                                        node.source))
           end
         end
 
@@ -96,10 +99,10 @@ module RuboCop
             range = unless_condition(node, method_call)
 
             add_offense(node,
-                        range,
-                        format(MSG_UNLESS_PRESENT,
-                               receiver.source,
-                               range.source))
+                        location: range,
+                        message: format(MSG_UNLESS_PRESENT,
+                                        replacement(receiver),
+                                        range.source))
           end
         end
 
@@ -107,7 +110,7 @@ module RuboCop
           lambda do |corrector|
             method_call, variable1 = unless_present?(node)
 
-            if method_call && variable1
+            if method_call
               corrector.replace(node.loc.keyword, 'if')
               range = method_call.loc.expression
             else