rubocop-performance 1.9.1 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c90f0ddd451c37a5c2187423524462aaa583fc0a7d4fb0342077eb792f03bfcc
-  data.tar.gz: 7606efa668ec94c24a35b93df1062a5a6f39e8c787e013d2707f69448841b7e9
+  metadata.gz: f7398f6e66937ee06d17e56c52ebe2858d26fcaf0a91d00d0c90caccbd1722b6
+  data.tar.gz: ab180bb4e81913bdabd470b04264e91b9687edde72f6f6d126e9918a11f361ca
 SHA512:
-  metadata.gz: a2a0094a2edfa59ee9a517cbf5d71ae1fa0fc67042bf0c35b129872a1b6cb6f892c182a0777da2a4e34f1a4c4b4292c30d19a34083b65844802e75b021f75322
-  data.tar.gz: e24dab2beb33688d61cf110a748d5295921c185324df366c0e02478ff44c34acb0857d8b603ca308021c7eaaf6e13d9ecbaeda1f80572b180d499c1b4e5fec5d
+  metadata.gz: 5ae6caa06f44418aab93a55378a7727e48dde52eaf49c0e70e6e84ed01c62210048dc9c5cbe826bffbc0b7b85a779084517828350f50f76f88759f291385bdef
+  data.tar.gz: e9a63b027c140d453648376871ab24f5192004971239aa8b06ad5f73b3da917a7b70923d8ac161fc3a10d352a167ac55577136c05f8dfd12a78e4c0c08acfbc3

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012-20 Bozhidar Batsov
+Copyright (c) 2012-21 Bozhidar Batsov
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,9 +1,10 @@
 # RuboCop Performance
 
 [![Gem Version](https://badge.fury.io/rb/rubocop-performance.svg)](https://badge.fury.io/rb/rubocop-performance)
-[![CircleCI](https://circleci.com/gh/rubocop-hq/rubocop-performance.svg?style=svg)](https://circleci.com/gh/rubocop-hq/rubocop-performance)
+[![CircleCI](https://circleci.com/gh/rubocop/rubocop-performance.svg?style=svg)](https://circleci.com/gh/rubocop/rubocop-performance)
+[![Discord](https://img.shields.io/badge/chat-on%20discord-7289da.svg?sanitize=true)](https://discord.gg/wJjWvGRDmm)
 
-Performance optimization analysis for your projects, as an extension to [RuboCop](https://github.com/rubocop-hq/rubocop).
+Performance optimization analysis for your projects, as an extension to [RuboCop](https://github.com/rubocop/rubocop).
 
 ## Installation
 

data/config/default.yml

@@ -10,7 +10,7 @@ Performance/AncestorsInclude:
 Performance/ArraySemiInfiniteRangeSlice:
   Description: 'Identifies places where slicing arrays with semi-infinite ranges can be replaced by `Array#take` and `Array#drop`.'
   # This cop was created due to a mistake in microbenchmark.
-  # Refer https://github.com/rubocop-hq/rubocop-performance/pull/175#issuecomment-731892717
+  # Refer https://github.com/rubocop/rubocop-performance/pull/175#issuecomment-731892717
   Enabled: false
   # Unsafe for string slices because strings do not have `#take` and `#drop` methods.
   Safe: false
@@ -80,6 +80,7 @@ Performance/ConstantRegexp:
   Description: 'Finds regular expressions with dynamic components that are all constants.'
   Enabled: pending
   VersionAdded: '1.9'
+  VersionChanged: '1.10'
 
 Performance/Count:
   Description: >-
@@ -136,11 +137,10 @@ Performance/EndWith:
   # object. Switching these methods has to be done with knowledge of the types
   # of the variables which rubocop doesn't have.
   SafeAutoCorrect: false
-  AutoCorrect: false
   Enabled: true
   SafeMultiline: true
   VersionAdded: '0.36'
-  VersionChanged: '1.6'
+  VersionChanged: '1.10'
 
 Performance/FixedSize:
   Description: 'Do not compute the size of statically sized objects except in constants.'
@@ -174,6 +174,12 @@ Performance/IoReadlines:
   Enabled: false
   VersionAdded: '1.7'
 
+Performance/MapCompact:
+  Description: 'Use `filter_map` instead of `collection.map(&:do_something).compact`.'
+  Enabled: pending
+  SafeAutoCorrect: false
+  VersionAdded: '1.11'
+
 Performance/MethodObjectAsBlock:
   Description: 'Use block explicitly instead of block-passing a method object.'
   Reference: 'https://github.com/JuanitoFatas/fast-ruby#normal-way-to-apply-method-vs-method-code'
@@ -200,6 +206,15 @@ Performance/RedundantBlockCall:
   Enabled: true
   VersionAdded: '0.36'
 
+Performance/RedundantEqualityComparisonBlock:
+  Description: >-
+                  Checks for uses `Enumerable#all?`, `Enumerable#any?`, `Enumerable#one?`,
+                  or `Enumerable#none?` are compared with `===` or similar methods in block.
+  Reference: 'https://github.com/rails/rails/pull/41363'
+  Enabled: pending
+  Safe: false
+  VersionAdded: '1.10'
+
 Performance/RedundantMatch:
   Description: >-
                   Use `=~` instead of `String#match` or `Regexp#match` in a context where the
@@ -211,7 +226,9 @@ Performance/RedundantMerge:
   Description: 'Use Hash#[]=, rather than Hash#merge! with a single key-value pair.'
   Reference: 'https://github.com/JuanitoFatas/fast-ruby#hashmerge-vs-hash-code'
   Enabled: true
+  Safe: false
   VersionAdded: '0.36'
+  VersionChanged: '1.11'
   # Max number of key-value pairs to consider an offense
   MaxKeyValuePairs: 2
 
@@ -220,6 +237,11 @@ Performance/RedundantSortBlock:
   Enabled: 'pending'
   VersionAdded: '1.7'
 
+Performance/RedundantSplitRegexpArgument:
+  Description: 'This cop identifies places where `split` argument can be replaced from a deterministic regexp to a string.'
+  Enabled: pending
+  VersionAdded: '1.10'
+
 Performance/RedundantStringChars:
   Description: 'Checks for redundant `String#chars`.'
   Enabled: 'pending'
@@ -244,6 +266,11 @@ Performance/ReverseFirst:
   Enabled: 'pending'
   VersionAdded: '1.7'
 
+Performance/SelectMap:
+  Description: 'Use `filter_map` instead of `ary.select(&:foo).map(&:bar)`.'
+  Enabled: false
+  VersionAdded: '1.11'
+
 Performance/Size:
   Description: >-
                   Use `size` instead of `count` for counting
@@ -270,11 +297,10 @@ Performance/StartWith:
   # object. Switching these methods has to be done with knowledge of the types
   # of the variables which rubocop doesn't have.
   SafeAutoCorrect: false
-  AutoCorrect: false
   Enabled: true
   SafeMultiline: true
   VersionAdded: '0.36'
-  VersionChanged: '1.6'
+  VersionChanged: '1.10'
 
 Performance/StringInclude:
   Description: 'Use `String#include?` instead of a regex match with literal-only pattern.'
@@ -304,7 +330,7 @@ Performance/TimesMap:
   Enabled: true
   VersionAdded: '0.36'
   VersionChanged: '0.50'
-  SafeAutoCorrect: false # see https://github.com/rubocop-hq/rubocop/issues/4658
+  SafeAutoCorrect: false # see https://github.com/rubocop/rubocop/issues/4658
 
 Performance/UnfreezeString:
   Description: 'Use unary plus to get an unfrozen string literal.'

data/config/obsoletion.yml

@@ -0,0 +1,7 @@
+#
+# Configuration for obsoletion.
+#
+# See: https://docs.rubocop.org/rubocop/extensions.html#config-obsoletions
+#
+extracted:
+  Performance/*: ~

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

@@ -6,7 +6,7 @@ module RuboCop
       # This cop identifies places where slicing arrays with semi-infinite ranges
       # can be replaced by `Array#take` and `Array#drop`.
       # This cop was created due to a mistake in microbenchmark and hence is disabled by default.
-      # Refer https://github.com/rubocop-hq/rubocop-performance/pull/175#issuecomment-731892717
+      # Refer https://github.com/rubocop/rubocop-performance/pull/175#issuecomment-731892717
       # This cop is also unsafe for string slices because strings do not have `#take` and `#drop` methods.
       #
       # @example

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

@@ -33,7 +33,7 @@ module RuboCop
         def_node_matcher :bind_with_call_method?, <<~PATTERN
           (send
             $(send
-              (send nil? _) :bind
+              _ :bind
               $(...)) :call
             $...)
         PATTERN
@@ -64,7 +64,7 @@ module RuboCop
 
         def correction_range(receiver, node)
           location_of_bind = receiver.loc.selector.begin_pos
-          location_of_call = node.loc.end.end_pos
+          location_of_call = node.source_range.end.end_pos
 
           range_between(location_of_bind, location_of_call)
         end

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

@@ -63,6 +63,8 @@ module RuboCop
 
         def on_send(node)
           chain_array_allocation?(node) do |fm, sm|
+            return if node.each_descendant(:send).any? { |descendant| descendant.method?(:lazy) }
+
             range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
 
             add_offense(range, message: format(MSG, method: fm, second_method: sm))

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

@@ -6,9 +6,9 @@ module RuboCop
       # This cop finds regular expressions with dynamic components that are all constants.
       #
       # Ruby allocates a new Regexp object every time it executes a code containing such
-      # a regular expression. It is more efficient to extract it into a constant
-      # or add an `/o` option to perform `#{}` interpolation only once and reuse that
-      # Regexp object.
+      # a regular expression. It is more efficient to extract it into a constant,
+      # memoize it, or add an `/o` option to perform `#{}` interpolation only once and
+      # reuse that Regexp object.
       #
       # @example
       #
@@ -28,13 +28,18 @@ module RuboCop
       #     pattern.scan(TOKEN).reject { |token| token.match?(/\A#{SEPARATORS}\Z/o) }
       #   end
       #
+      #   # good
+      #   def separators
+      #     @separators ||= /\A#{SEPARATORS}\Z/
+      #   end
+      #
       class ConstantRegexp < Base
         extend AutoCorrector
 
-        MSG = 'Extract this regexp into a constant or append an `/o` option to its options.'
+        MSG = 'Extract this regexp into a constant, memoize it, or append an `/o` option to its options.'
 
         def on_regexp(node)
-          return if within_const_assignment?(node) ||
+          return if within_allowed_assignment?(node) ||
                     !include_interpolated_const?(node) ||
                     node.single_interpolation?
 
@@ -45,8 +50,8 @@ module RuboCop
 
         private
 
-        def within_const_assignment?(node)
-          node.each_ancestor(:casgn).any?
+        def within_allowed_assignment?(node)
+          node.each_ancestor(:casgn, :or_asgn).any?
         end
 
         def_node_matcher :regexp_escape?, <<~PATTERN

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

@@ -3,7 +3,8 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop is used to identify usages of
+      # This cop is used to identify usages of `map { ... }.flatten` and
+      # change them to use `flat_map { ... }` instead.
       #
       # @example
       #   # bad

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # In Ruby 2.7, `Enumerable#filter_map` has been added.
+      #
+      # This cop identifies places where `map { ... }.compact` can be replaced by `filter_map`.
+      # It is marked as unsafe auto-correction by default because `map { ... }.compact`
+      # that is not compatible with `filter_map`.
+      #
+      # [source,ruby]
+      # ----
+      # [true, false, nil].compact              #=> [true, false]
+      # [true, false, nil].filter_map(&:itself) #=> [true]
+      # ----
+      #
+      # @example
+      #   # bad
+      #   ary.map(&:foo).compact
+      #   ary.collect(&:foo).compact
+      #
+      #   # good
+      #   ary.filter_map(&:foo)
+      #   ary.map(&:foo).compact!
+      #
+      class MapCompact < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `filter_map` instead.'
+        RESTRICT_ON_SEND = %i[compact].freeze
+
+        minimum_target_ruby_version 2.7
+
+        def_node_matcher :map_compact, <<~PATTERN
+          {
+            (send
+              $(send _ {:map :collect}
+                (block_pass
+                  (sym _))) _)
+            (send
+              (block
+                $(send _ {:map :collect})
+                  (args ...) _) _)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (map_node = map_compact(node))
+
+          compact_loc = node.loc
+          range = range_between(map_node.loc.selector.begin_pos, compact_loc.selector.end_pos)
+
+          add_offense(range) do |corrector|
+            corrector.replace(map_node.loc.selector, 'filter_map')
+            corrector.remove(compact_loc.dot)
+            corrector.remove(compact_loc.selector)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -78,7 +78,7 @@ module RuboCop
         end
 
         def calls_to_report(argname, body)
-          return [] if blockarg_assigned?(body, argname)
+          return [] if blockarg_assigned?(body, argname) || shadowed_block_argument?(body, argname)
 
           blockarg_calls(body, argname).map do |call|
             return [] if args_include_block_pass?(call)
@@ -87,6 +87,12 @@ module RuboCop
           end
         end
 
+        def shadowed_block_argument?(body, block_argument_of_method_signature)
+          return false unless body.block_type?
+
+          body.arguments.map(&:source).include?(block_argument_of_method_signature.to_s)
+        end
+
         def args_include_block_pass?(blockcall)
           _receiver, _call, *args = *blockcall
 

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop checks for uses `Enumerable#all?`, `Enumerable#any?`, `Enumerable#one?`,
+      # and `Enumerable#none?` are compared with `===` or similar methods in block.
+      #
+      # By default, `Object#===` behaves the same as `Object#==`, but this
+      # behavior is appropriately overridden in subclass. For example,
+      # `Range#===` returns `true` when argument is within the range.
+      # Therefore, It is marked as unsafe by default because `===` and `==`
+      # do not always behave the same.
+      #
+      # @example
+      #   # bad
+      #   items.all? { |item| pattern === item }
+      #   items.all? { |item| item == other }
+      #   items.all? { |item| item.is_a?(Klass) }
+      #   items.all? { |item| item.kind_of?(Klass) }
+      #
+      #   # good
+      #   items.all?(pattern)
+      #
+      class RedundantEqualityComparisonBlock < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.5
+
+        MSG = 'Use `%<prefer>s` instead of block.'
+
+        TARGET_METHODS = %i[all? any? one? none?].freeze
+        COMPARISON_METHODS = %i[== === is_a? kind_of?].freeze
+        IS_A_METHODS = %i[is_a? kind_of?].freeze
+
+        def on_block(node)
+          return unless TARGET_METHODS.include?(node.method_name)
+          return unless one_block_argument?(node.arguments)
+
+          block_argument = node.arguments.first
+          block_body = node.body
+          return unless use_equality_comparison_block?(block_body)
+          return if same_block_argument_and_is_a_argument?(block_body, block_argument)
+          return unless (new_argument = new_argument(block_argument, block_body))
+
+          range = offense_range(node)
+          prefer = "#{node.method_name}(#{new_argument})"
+
+          add_offense(range, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(range, prefer)
+          end
+        end
+
+        private
+
+        def one_block_argument?(block_arguments)
+          block_arguments.one? && !block_arguments.source.include?(',')
+        end
+
+        def use_equality_comparison_block?(block_body)
+          block_body.send_type? && COMPARISON_METHODS.include?(block_body.method_name)
+        end
+
+        def same_block_argument_and_is_a_argument?(block_body, block_argument)
+          if block_body.method?(:===)
+            block_argument.source != block_body.children[2].source
+          elsif IS_A_METHODS.include?(block_body.method_name)
+            block_argument.source == block_body.first_argument.source
+          else
+            false
+          end
+        end
+
+        def new_argument(block_argument, block_body)
+          if block_argument.source == block_body.receiver.source
+            block_body.first_argument.source
+          elsif block_argument.source == block_body.first_argument.source
+            block_body.receiver.source
+          end
+        end
+
+        def offense_range(node)
+          node.send_node.loc.selector.join(node.source_range.end)
+        end
+      end
+    end
+  end
+end

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

@@ -8,6 +8,9 @@ module RuboCop
       # You can set the maximum number of key-value pairs to consider
       # an offense with `MaxKeyValuePairs`.
       #
+      # This cop is marked as unsafe because RuboCop cannot determine if the
+      # receiver of `merge!` is actually a hash or not.
+      #
       # @example
       #   # bad
       #   hash.merge!(a: 1)

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `split` argument can be replaced from
+      # a deterministic regexp to a string.
+      #
+      # @example
+      #   # bad
+      #   'a,b,c'.split(/,/)
+      #
+      #   # good
+      #   'a,b,c'.split(',')
+      class RedundantSplitRegexpArgument < Base
+        extend AutoCorrector
+
+        MSG = 'Use string as argument instead of regexp.'
+        RESTRICT_ON_SEND = %i[split].freeze
+        DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/.freeze
+        STR_SPECIAL_CHARS = %w[\n \" \' \\\\ \t \b \f \r].freeze
+
+        def_node_matcher :split_call_with_regexp?, <<~PATTERN
+          {(send !nil? :split $regexp)}
+        PATTERN
+
+        def on_send(node)
+          return unless (regexp_node = split_call_with_regexp?(node))
+          return if regexp_node.ignore_case? || regexp_node.content == ' '
+          return unless determinist_regexp?(regexp_node)
+
+          add_offense(regexp_node) do |corrector|
+            new_argument = replacement(regexp_node)
+
+            corrector.replace(regexp_node, "\"#{new_argument}\"")
+          end
+        end
+
+        private
+
+        def determinist_regexp?(regexp_node)
+          DETERMINISTIC_REGEX.match?(regexp_node.source)
+        end
+
+        def replacement(regexp_node)
+          regexp_content = regexp_node.content
+          stack = []
+          chars = regexp_content.chars.each_with_object([]) do |char, strings|
+            if stack.empty? && char == '\\'
+              stack.push(char)
+            else
+              strings << "#{stack.pop}#{char}"
+            end
+          end
+          chars.map do |char|
+            char = char.dup
+            char.delete!('\\') unless STR_SPECIAL_CHARS.include?(char)
+            char
+          end.join
+        end
+      end
+    end
+  end
+end

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

@@ -6,41 +6,53 @@ module RuboCop
       # This cop is used to identify usages of `reverse.each` and
       # change them to use `reverse_each` instead.
       #
+      # If the return value is used, it will not be detected because the result will be different.
+      #
+      # [source,ruby]
+      # ----
+      # [1, 2, 3].reverse.each {} #=> [3, 2, 1]
+      # [1, 2, 3].reverse_each {} #=> [1, 2, 3]
+      # ----
+      #
       # @example
       #   # bad
-      #   [].reverse.each
+      #   items.reverse.each
       #
       #   # good
-      #   [].reverse_each
+      #   items.reverse_each
       class ReverseEach < Base
         include RangeHelp
         extend AutoCorrector
 
         MSG = 'Use `reverse_each` instead of `reverse.each`.'
         RESTRICT_ON_SEND = %i[each].freeze
-        UNDERSCORE = '_'
 
         def_node_matcher :reverse_each?, <<~MATCHER
-          (send $(send _ :reverse) :each)
+          (send (send _ :reverse) :each)
         MATCHER
 
         def on_send(node)
-          reverse_each?(node) do |receiver|
-            location_of_reverse = receiver.loc.selector.begin_pos
-            end_location = node.loc.selector.end_pos
+          return if use_return_value?(node)
 
-            range = range_between(location_of_reverse, end_location)
+          reverse_each?(node) do
+            range = offense_range(node)
 
             add_offense(range) do |corrector|
-              corrector.replace(replacement_range(node), UNDERSCORE)
+              corrector.replace(range, 'reverse_each')
             end
           end
         end
 
         private
 
-        def replacement_range(node)
-          range_between(node.loc.dot.begin_pos, node.loc.selector.begin_pos)
+        def use_return_value?(node)
+          !!node.ancestors.detect do |ancestor|
+            ancestor.assignment? || ancestor.send_type? || ancestor.return_type?
+          end
+        end
+
+        def offense_range(node)
+          range_between(node.children.first.loc.selector.begin_pos, node.loc.selector.end_pos)
         end
       end
     end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # In Ruby 2.7, `Enumerable#filter_map` has been added.
+      #
+      # This cop identifies places where `select.map` can be replaced by `filter_map`.
+      #
+      # @example
+      #   # bad
+      #   ary.select(&:foo).map(&:bar)
+      #   ary.filter(&:foo).map(&:bar)
+      #
+      #   # good
+      #   ary.filter_map { |o| o.bar if o.foo }
+      #
+      class SelectMap < Base
+        include RangeHelp
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.7
+
+        MSG = 'Use `filter_map` instead of `%<method_name>s.map`.'
+        RESTRICT_ON_SEND = %i[select filter].freeze
+
+        def_node_matcher :bad_method?, <<~PATTERN
+          (send nil? :bad_method ...)
+        PATTERN
+
+        def on_send(node)
+          return if (first_argument = node.first_argument) && !first_argument.block_pass_type?
+          return unless (send_node = map_method_candidate(node))
+          return unless send_node.method?(:map)
+
+          map_method = send_node.parent&.block_type? ? send_node.parent : send_node
+
+          range = offense_range(node, map_method)
+          add_offense(range, message: format(MSG, method_name: node.method_name))
+        end
+
+        private
+
+        def map_method_candidate(node)
+          return unless (parent = node.parent)
+
+          if parent.block_type? && parent.parent&.send_type?
+            parent.parent
+          elsif parent.send_type?
+            parent
+          end
+        end
+
+        def offense_range(node, map_method)
+          range_between(node.loc.selector.begin_pos, map_method.loc.expression.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -150,7 +150,9 @@ module RuboCop
           replacement = build_good_method(init, block_pass)
 
           corrector.remove(sum_range)
-          corrector.replace(map_range, ".#{replacement}")
+
+          dot = '.' if map.receiver
+          corrector.replace(map_range, "#{dot}#{replacement}")
         end
 
         def sum_method_range(node)
@@ -228,7 +230,11 @@ module RuboCop
         end
 
         def method_call_with_args_range(node)
-          node.receiver.source_range.end.join(node.source_range.end)
+          if (receiver = node.receiver)
+            receiver.source_range.end.join(node.source_range.end)
+          else
+            node.source_range
+          end
         end
       end
     end

data/lib/rubocop/cop/performance_cops.rb

@@ -23,18 +23,22 @@ require_relative 'performance/end_with'
 require_relative 'performance/fixed_size'
 require_relative 'performance/flat_map'
 require_relative 'performance/inefficient_hash_search'
+require_relative 'performance/map_compact'
 require_relative 'performance/method_object_as_block'
 require_relative 'performance/open_struct'
 require_relative 'performance/range_include'
 require_relative 'performance/io_readlines'
 require_relative 'performance/redundant_block_call'
+require_relative 'performance/redundant_equality_comparison_block'
 require_relative 'performance/redundant_match'
 require_relative 'performance/redundant_merge'
 require_relative 'performance/redundant_sort_block'
+require_relative 'performance/redundant_split_regexp_argument'
 require_relative 'performance/redundant_string_chars'
 require_relative 'performance/regexp_match'
 require_relative 'performance/reverse_each'
 require_relative 'performance/reverse_first'
+require_relative 'performance/select_map'
 require_relative 'performance/size'
 require_relative 'performance/sort_reverse'
 require_relative 'performance/squeeze'

data/lib/rubocop/performance.rb

@@ -8,5 +8,7 @@ module RuboCop
     CONFIG = YAML.safe_load(CONFIG_DEFAULT.read).freeze
 
     private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
+
+    ::RuboCop::ConfigObsoletion.files << PROJECT_ROOT.join('config', 'obsoletion.yml')
   end
 end

data/lib/rubocop/performance/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Performance
     # This module holds the RuboCop Performance version information.
     module Version
-      STRING = '1.9.1'
+      STRING = '1.11.0'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-performance
 version: !ruby/object:Gem::Version
-  version: 1.9.1
+  version: 1.11.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-28 00:00:00.000000000 Z
+date: 2021-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.90.0
+        version: 1.7.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -28,7 +28,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.90.0
+        version: 1.7.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -59,6 +59,7 @@ files:
 - LICENSE.txt
 - README.md
 - config/default.yml
+- config/obsoletion.yml
 - lib/rubocop-performance.rb
 - lib/rubocop/cop/mixin/regexp_metacharacter.rb
 - lib/rubocop/cop/mixin/sort_block.rb
@@ -84,17 +85,21 @@ files:
 - lib/rubocop/cop/performance/flat_map.rb
 - lib/rubocop/cop/performance/inefficient_hash_search.rb
 - lib/rubocop/cop/performance/io_readlines.rb
+- lib/rubocop/cop/performance/map_compact.rb
 - lib/rubocop/cop/performance/method_object_as_block.rb
 - lib/rubocop/cop/performance/open_struct.rb
 - lib/rubocop/cop/performance/range_include.rb
 - lib/rubocop/cop/performance/redundant_block_call.rb
+- lib/rubocop/cop/performance/redundant_equality_comparison_block.rb
 - lib/rubocop/cop/performance/redundant_match.rb
 - lib/rubocop/cop/performance/redundant_merge.rb
 - lib/rubocop/cop/performance/redundant_sort_block.rb
+- lib/rubocop/cop/performance/redundant_split_regexp_argument.rb
 - lib/rubocop/cop/performance/redundant_string_chars.rb
 - lib/rubocop/cop/performance/regexp_match.rb
 - lib/rubocop/cop/performance/reverse_each.rb
 - lib/rubocop/cop/performance/reverse_first.rb
+- lib/rubocop/cop/performance/select_map.rb
 - lib/rubocop/cop/performance/size.rb
 - lib/rubocop/cop/performance/sort_reverse.rb
 - lib/rubocop/cop/performance/squeeze.rb
@@ -109,15 +114,15 @@ files:
 - lib/rubocop/performance.rb
 - lib/rubocop/performance/inject.rb
 - lib/rubocop/performance/version.rb
-homepage: https://github.com/rubocop-hq/rubocop-performance
+homepage: https://github.com/rubocop/rubocop-performance
 licenses:
 - MIT
 metadata:
   homepage_uri: https://docs.rubocop.org/rubocop-performance/
-  changelog_uri: https://github.com/rubocop-hq/rubocop-performance/blob/master/CHANGELOG.md
-  source_code_uri: https://github.com/rubocop-hq/rubocop-performance/
-  documentation_uri: https://docs.rubocop.org/rubocop-performance/1.9/
-  bug_tracker_uri: https://github.com/rubocop-hq/rubocop-performance/issues
+  changelog_uri: https://github.com/rubocop/rubocop-performance/blob/master/CHANGELOG.md
+  source_code_uri: https://github.com/rubocop/rubocop-performance/
+  documentation_uri: https://docs.rubocop.org/rubocop-performance/1.11/
+  bug_tracker_uri: https://github.com/rubocop/rubocop-performance/issues
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -126,14 +131,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.0.rc.2
+rubygems_version: 3.2.12
 signing_key:
 specification_version: 4
 summary: Automatic performance checking tool for Ruby code.