rubocop 0.49.1 → 0.52.0

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

@@ -3,40 +3,41 @@
 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
+      #   # bad
       #   do_something if str.match(/regex/)
       #   while regex.match('str')
       #     do_something
       #   end
       #
-      #   @good
-      #   method(str.match(/regex/))
-      #   return regex.match('str')
+      #   # good
+      #   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
 
         # 'match' is a fairly generic name, so we don't flag it unless we see
         # a string or regexp literal on one side or the other
-        def_node_matcher :match_call?, <<-END
+        def_node_matcher :match_call?, <<-PATTERN
           {(send {str regexp} :match _)
-           (send !nil :match {str regexp})}
-        END
+           (send !nil? :match {str regexp})}
+        PATTERN
 
-        def_node_matcher :only_truthiness_matters?, <<-END
+        def_node_matcher :only_truthiness_matters?, <<-PATTERN
           ^({if while until case while_post until_post} equal?(%0) ...)
-        END
+        PATTERN
 
         def on_send(node)
           return unless match_call?(node) &&
                         (!node.value_used? || only_truthiness_matters?(node)) &&
                         !(node.parent && node.parent.block_type?)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)

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

@@ -11,31 +11,29 @@ module RuboCop
       #   hash.merge!({'key' => 'value'})
       #   hash.merge!(a: 1, b: 2)
       class RedundantMerge < Cop
-        AREF_ASGN = '%s[%s] = %s'.freeze
-        MSG = 'Use `%s` instead of `%s`.'.freeze
+        AREF_ASGN = '%<receiver>s[%<key>s] = %<value>s'.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
 
-        def_node_matcher :redundant_merge, '(send $_ :merge! (hash $...))'
-        def_node_matcher :modifier_flow_control?, <<-END
+        def_node_matcher :redundant_merge_candidate, <<-PATTERN
+          (send $!nil? :merge! [(hash $...) !kwsplat_type?])
+        PATTERN
+
+        def_node_matcher :modifier_flow_control?, <<-PATTERN
           [{if while until} modifier_form?]
-        END
+        PATTERN
 
         def on_send(node)
-          each_redundant_merge(node) do |receiver, pairs|
-            return if pairs.any?(&:kwsplat_type?)
-
-            assignments = to_assignments(receiver, pairs).join('; ')
-            message = format(MSG, assignments, node.source)
-            add_offense(node, :expression, message)
+          each_redundant_merge(node) do |redundant_merge_node|
+            add_offense(redundant_merge_node)
           end
         end
 
         def autocorrect(node)
-          redundant_merge(node) do |receiver, pairs|
+          redundant_merge_candidate(node) do |receiver, pairs|
             new_source = to_assignments(receiver, pairs).join("\n")
 
-            parent = node.parent
-            if parent && pairs.size > 1
-              correct_multiple_elements(node, parent, new_source)
+            if node.parent && pairs.size > 1
+              correct_multiple_elements(node, node.parent, new_source)
             else
               correct_single_element(node, new_source)
             end
@@ -44,18 +42,36 @@ module RuboCop
 
         private
 
+        def message(node)
+          redundant_merge_candidate(node) do |receiver, pairs|
+            assignments = to_assignments(receiver, pairs).join('; ')
+
+            format(MSG, prefer: assignments, current: node.source)
+          end
+        end
+
         def each_redundant_merge(node)
-          redundant_merge(node) do |receiver, pairs|
-            next unless receiver
-            next if node.value_used? &&
-                    !EachWithObjectInspector.new(node, receiver).value_used?
-            next if pairs.size > 1 && !receiver.pure?
-            next if pairs.size > max_key_value_pairs
-
-            yield receiver, pairs
+          redundant_merge_candidate(node) do |receiver, pairs|
+            next if non_redundant_merge?(node, receiver, pairs)
+
+            yield node
           end
         end
 
+        def non_redundant_merge?(node, receiver, pairs)
+          non_redundant_pairs?(receiver, pairs) ||
+            non_redundant_value_used?(receiver, node)
+        end
+
+        def non_redundant_pairs?(receiver, pairs)
+          pairs.size > 1 && !receiver.pure? || pairs.size > max_key_value_pairs
+        end
+
+        def non_redundant_value_used?(receiver, node)
+          node.value_used? &&
+            !EachWithObjectInspector.new(node, receiver).value_used?
+        end
+
         def correct_multiple_elements(node, parent, new_source)
           if modifier_flow_control?(parent)
             new_source = rewrite_with_modifier(node, parent, new_source)
@@ -78,7 +94,9 @@ module RuboCop
 
             key = key.sym_type? && pair.colon? ? ":#{key.source}" : key.source
 
-            format(AREF_ASGN, receiver.source, key, value.source)
+            format(AREF_ASGN, receiver: receiver.source,
+                              key: key,
+                              value: value.source)
           end
         end
 
@@ -141,9 +159,9 @@ module RuboCop
             receiver
           end
 
-          def_node_matcher :each_with_object_node, <<-END
+          def_node_matcher :each_with_object_node, <<-PATTERN
             (block (send _ :each_with_object _) (args _ $_) ...)
-          END
+          PATTERN
         end
       end
     end

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

@@ -7,25 +7,28 @@ module RuboCop
       # `sort`.
       #
       # @example
-      #   @bad
+      #   # bad
       #   array.sort_by { |x| x }
       #   array.sort_by do |var|
       #     var
       #   end
       #
-      #   @good
+      #   # good
       #   array.sort
       class RedundantSortBy < Cop
-        MSG = 'Use `sort` instead of `sort_by { |%s| %s }`.'.freeze
+        MSG = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'.freeze
 
-        def_node_matcher :redundant_sort_by, <<-END
+        def_node_matcher :redundant_sort_by, <<-PATTERN
           (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
-        END
+        PATTERN
 
         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: var_name))
           end
         end
 

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

@@ -64,7 +64,8 @@ module RuboCop
         minimum_target_ruby_version 2.4
 
         MSG =
-          'Use `match?` instead of `%s` when `MatchData` is not used.'.freeze
+          'Use `match?` instead of `%<current>s` when `MatchData` ' \
+          'is not used.'.freeze
 
         def_node_matcher :match_method?, <<-PATTERN
           {
@@ -74,16 +75,18 @@ 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_node_matcher :match_with_lvasgn?, <<-PATTERN
-          (match_with_lvasgn !nil !nil)
-        PATTERN
+        def match_with_lvasgn?(node)
+          return false unless node.match_with_lvasgn_type?
+          regexp, _rhs = *node
+          regexp.to_regexp.named_captures.empty?
+        end
 
         MATCH_NODE_PATTERN = <<-PATTERN.freeze
           {
@@ -99,8 +102,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?)
           }
@@ -139,11 +142,15 @@ module RuboCop
         def check_condition(cond)
           match_node?(cond) do
             return if last_match_used?(cond)
-            add_offense(cond, :expression,
-                        format(MSG, cond.loc.selector.source))
+
+            add_offense(cond)
           end
         end
 
+        def message(node)
+          format(MSG, current: node.loc.selector.source)
+        end
+
         def last_match_used?(match_node)
           scope_root = scope_root(match_node)
           body = scope_root ? scope_body(scope_root) : match_node.ancestors.last
@@ -176,6 +183,8 @@ module RuboCop
           case node.type
           when :module
             children[1]
+          when :defs
+            children[3]
           else
             children[2]
           end

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,15 +29,15 @@ module RuboCop
         def on_send(node)
           return unless eligible_node?(node)
 
-          add_offense(node, node.loc.selector)
+          add_offense(node, location: :selector)
         end
 
-        private
-
         def autocorrect(node)
           ->(corrector) { corrector.replace(node.loc.selector, 'size') }
         end
 
+        private
+
         def eligible_node?(node)
           return false unless node.method?(:count) && !node.arguments?
 

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

@@ -7,21 +7,21 @@ module RuboCop
       # `String#start_with?` would suffice.
       #
       # @example
-      #   @bad
+      #   # bad
       #   'abc' =~ /\Aab/
       #   'abc'.match(/\Aab/)
       #
-      #   @good
+      #   # good
       #   'abc'.start_with?('ab')
       class StartWith < Cop
         MSG = 'Use `String#start_with?` instead of a regex match anchored to ' \
               'the beginning of the string.'.freeze
         SINGLE_QUOTE = "'".freeze
 
-        def_node_matcher :redundant_regex?, <<-END
-          {(send $!nil {:match :=~} (regexp (str $#literal_at_start?) (regopt)))
+        def_node_matcher :redundant_regex?, <<-PATTERN
+          {(send $!nil? {:match :=~} (regexp (str $#literal_at_start?) (regopt)))
            (send (regexp (str $#literal_at_start?) (regopt)) {:match :=~} $_)}
-        END
+        PATTERN
 
         def literal_at_start?(regex_str)
           # is this regexp 'literal' in the sense of only matching literal
@@ -36,7 +36,7 @@ module RuboCop
         def on_send(node)
           return unless redundant_regex?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)

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

@@ -7,19 +7,19 @@ module RuboCop
       # `tr` or `delete`.
       #
       # @example
-      #   @bad
+      #   # bad
       #   'abc'.gsub('b', 'd')
       #   'abc'.gsub('a', '')
       #   'abc'.gsub(/a/, 'd')
       #   'abc'.gsub!('a', 'd')
       #
-      #   @good
+      #   # good
       #   'abc'.gsub(/.*/, 'a')
       #   'abc'.gsub(/a+/, 'd')
       #   'abc'.tr('b', 'd')
       #   'a b c'.delete(' ')
       class StringReplacement < Cop
-        MSG = 'Use `%s` instead of `%s`.'.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
         DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/
         DELETE = 'delete'.freeze
         TR = 'tr'.freeze
@@ -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)
@@ -151,7 +151,7 @@ module RuboCop
           replacement_method =
             replacement_method(node, first_source, second_source)
 
-          format(MSG, replacement_method, node.method_name)
+          format(MSG, prefer: replacement_method, current: node.method_name)
         end
 
         def method_suffix(node)

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

@@ -8,18 +8,19 @@ module RuboCop
       # with an explicit array creation.
       #
       # @example
-      #
-      #   @bad
+      #   # bad
       #   9.times.map do |i|
       #     i.to_s
       #   end
       #
-      #   @good
+      #   # good
       #   Array.new(9) do |i|
       #     i.to_s
       #   end
       class TimesMap < Cop
-        MSG = 'Use `Array.new` with a block instead of `.times.%s`.'.freeze
+        MESSAGE = 'Use `Array.new(%<count>s)` with a block ' \
+                  'instead of `.times.%<map_or_collect>s`'.freeze
+        MESSAGE_ONLY_IF = 'only if `%<count>s` is always 0 or more'.freeze
 
         def on_send(node)
           check(node)
@@ -29,32 +30,41 @@ module RuboCop
           check(node)
         end
 
-        private
-
-        def check(node)
-          times_map_call(node) do |map_or_collect|
-            add_offense(node, :expression, format(MSG, map_or_collect))
-          end
-        end
-
-        def_node_matcher :times_map_call, <<-END
-          {(block (send (send !nil :times) ${:map :collect}) ...)
-           (send (send !nil :times) ${:map :collect} (block_pass ...))}
-        END
-
         def autocorrect(node)
-          send_node = node.send_type? ? node : node.each_descendant(:send).first
-
-          count, = *send_node.receiver
+          map_or_collect, count = times_map_call(node)
 
           replacement =
             "Array.new(#{count.source}" \
-            "#{send_node.arguments.map { |arg| ", #{arg.source}" }.join})"
+            "#{map_or_collect.arguments.map { |arg| ", #{arg.source}" }.join})"
 
           lambda do |corrector|
-            corrector.replace(send_node.loc.expression, replacement)
+            corrector.replace(map_or_collect.loc.expression, replacement)
           end
         end
+
+        private
+
+        def check(node)
+          times_map_call(node) do |map_or_collect, count|
+            add_offense(node, message: message(map_or_collect, count))
+          end
+        end
+
+        def message(map_or_collect, count)
+          template = if count.literal?
+                       MESSAGE + '.'
+                     else
+                       "#{MESSAGE} #{MESSAGE_ONLY_IF}."
+                     end
+          format(template,
+                 count: count.source,
+                 map_or_collect: map_or_collect.method_name)
+        end
+
+        def_node_matcher :times_map_call, <<-PATTERN
+          {(block $(send (send $!nil? :times) {:map :collect}) ...)
+           $(send (send $!nil? :times) {:map :collect} (block_pass ...))}
+        PATTERN
       end
     end
   end