rubocop-performance 1.16.0 → 1.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b0361feae763e4c8cbea3bd0160a1e4b0646b2e3b3246fb8dd55a5f21a53acd
-  data.tar.gz: 152d09678555d309441fb809f60b07b69b04289b3949bf1eaca3e9b70b3afe13
+  metadata.gz: f4926be80598b4880037ffd36eef32c9025051af7f0398f69a34439c135c9d87
+  data.tar.gz: ba3d738da529cbc70c33e8c5d4baa4c6c8013a5498c834f2e28dc87a8811c15a
 SHA512:
-  metadata.gz: 9f08bd2f25c0e0e537bf8fa5378e701d6b6b6794a45fe534229e73a0dd4bd623dd415965966655a802cc8e93a3776880d99c89245947aae090ba2c49f0bb183f
-  data.tar.gz: 34f697ee70070d32d17b3684712cec5628e71cbdb393722fec3bb0dbc541cf65af92a762907dbbb0c5e6c3023f8dd4738e06a131a5a28014749dac440e15bc92
+  metadata.gz: 1b9a64379554a660c30bffea5a0fc8a8d36a9e31efef6ccb4576f4df432d2f270d91d76b0e7e7638740e6cf83a50b94b4dfe37d93e5366d0171b8a0f4e5bff50
+  data.tar.gz: d27b9db647eb1a53f3e80b0ec20cd43b37b0244127a28f7fbdacefcf9477205a7f4d373c0a27d882fcb43f902d4ab398ad73ea3f51cdd21e5d422cd419d621e9

data/README.md

@@ -11,7 +11,7 @@ Performance optimization analysis for your projects, as an extension to [RuboCop
 Just install the `rubocop-performance` gem
 
 ```sh
-gem install rubocop-performance
+$ gem install rubocop-performance
 ```
 
 or if you use bundler put this in your `Gemfile`
@@ -47,7 +47,7 @@ cops together with the standard cops.
 ### Command line
 
 ```sh
-rubocop --require rubocop-performance
+$ rubocop --require rubocop-performance
 ```
 
 ### Rake task

data/config/default.yml

@@ -226,6 +226,7 @@ Performance/RedundantEqualityComparisonBlock:
   Reference: 'https://github.com/rails/rails/pull/41363'
   Enabled: pending
   Safe: false
+  AllowRegexpMatch: true
   VersionAdded: '1.10'
 
 Performance/RedundantMatch:

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

@@ -99,7 +99,7 @@ module RuboCop
 
         def inline_fix_branch(corrector, when_node)
           conditions = when_node.conditions
-          range = range_between(conditions[0].loc.expression.begin_pos, conditions[-1].loc.expression.end_pos)
+          range = range_between(conditions[0].source_range.begin_pos, conditions[-1].source_range.end_pos)
 
           corrector.replace(range, replacement(conditions))
         end
@@ -110,7 +110,7 @@ module RuboCop
           return if when_branches.one?
 
           corrector.remove(when_branch_range(when_node))
-          corrector.insert_after(when_branches.last.source_range, reordering_correction(when_node))
+          corrector.insert_after(when_branches.last, reordering_correction(when_node))
         end
 
         def reordering_correction(when_node)

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

@@ -5,35 +5,42 @@ module RuboCop
     module Performance
       # Identifies places where `sort { |a, b| a.foo <=> b.foo }`
       # can be replaced by `sort_by(&:foo)`.
-      # This cop also checks `max` and `min` methods.
+      # This cop also checks `sort!`, `min`, `max` and `minmax` methods.
       #
       # @example
       #   # bad
-      #   array.sort { |a, b| a.foo <=> b.foo }
-      #   array.max { |a, b| a.foo <=> b.foo }
-      #   array.min { |a, b| a.foo <=> b.foo }
-      #   array.sort { |a, b| a[:foo] <=> b[:foo] }
+      #   array.sort   { |a, b| a.foo <=> b.foo }
+      #   array.sort!  { |a, b| a.foo <=> b.foo }
+      #   array.max    { |a, b| a.foo <=> b.foo }
+      #   array.min    { |a, b| a.foo <=> b.foo }
+      #   array.minmax { |a, b| a.foo <=> b.foo }
+      #   array.sort   { |a, b| a[:foo] <=> b[:foo] }
       #
       #   # good
       #   array.sort_by(&:foo)
+      #   array.sort_by!(&:foo)
       #   array.sort_by { |v| v.foo }
       #   array.sort_by do |var|
       #     var.foo
       #   end
       #   array.max_by(&:foo)
       #   array.min_by(&:foo)
+      #   array.minmax_by(&:foo)
       #   array.sort_by { |a| a[:foo] }
       class CompareWithBlock < Base
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `%<compare_method>s_by%<instead>s` instead of ' \
+        MSG = 'Use `%<replacement_method>s%<instead>s` instead of ' \
               '`%<compare_method>s { |%<var_a>s, %<var_b>s| %<str_a>s ' \
               '<=> %<str_b>s }`.'
 
+        REPLACEMENT = { sort: :sort_by, sort!: :sort_by!, min: :min_by, max: :max_by, minmax: :minmax_by }.freeze
+        private_constant :REPLACEMENT
+
         def_node_matcher :compare?, <<~PATTERN
           (block
-            $(send _ {:sort :min :max})
+            $(send _ {:sort :sort! :min :max :minmax})
             (args (arg $_a) (arg $_b))
             $send)
         PATTERN
@@ -54,9 +61,9 @@ module RuboCop
 
               add_offense(range, message: message(send, method, var_a, var_b, args_a)) do |corrector|
                 replacement = if method == :[]
-                                "#{send.method_name}_by { |a| a[#{args_a.first.source}] }"
+                                "#{REPLACEMENT[send.method_name]} { |a| a[#{args_a.first.source}] }"
                               else
-                                "#{send.method_name}_by(&:#{method})"
+                                "#{REPLACEMENT[send.method_name]}(&:#{method})"
                               end
                 corrector.replace(range, replacement)
               end
@@ -82,7 +89,8 @@ module RuboCop
 
         # rubocop:disable Metrics/MethodLength
         def message(send, method, var_a, var_b, args)
-          compare_method = send.method_name
+          compare_method     = send.method_name
+          replacement_method = REPLACEMENT[compare_method]
           if method == :[]
             key = args.first
             instead = " { |a| a[#{key.source}] }"
@@ -94,6 +102,7 @@ module RuboCop
             str_b = "#{var_b}.#{method}"
           end
           format(MSG, compare_method: compare_method,
+                      replacement_method: replacement_method,
                       instead: instead,
                       var_a: var_a,
                       var_b: var_b,

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

@@ -38,6 +38,10 @@ module RuboCop
 
         MSG = 'Extract this regexp into a constant, memoize it, or append an `/o` option to its options.'
 
+        def self.autocorrect_incompatible_with
+          [RegexpMatch]
+        end
+
         def on_regexp(node)
           return if within_allowed_assignment?(node) || !include_interpolated_const?(node) || node.single_interpolation?
 

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

@@ -110,7 +110,7 @@ module RuboCop
 
         def negate_block_pass_reject(corrector, node)
           corrector.replace(
-            node.receiver.loc.expression.with(begin_pos: node.receiver.loc.begin.begin_pos),
+            node.receiver.source_range.with(begin_pos: node.receiver.loc.begin.begin_pos),
             negate_block_pass_as_inline_block(node.receiver)
           )
         end

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

@@ -8,12 +8,9 @@ module RuboCop
       # `detect` instead.
       #
       # @safety
-      #   This cop is unsafe because is assumes the class implements the
-      #   `Enumerable` interface, but can't reliably detect this. This creates
-      #   known compatibility issues with `Hash`, `ActiveRecord` and other
-      #   frameworks. `Hash` and `ActiveRecord` do not implement a `detect`
-      #   method and `find` has its own meaning. Correcting `Hash` and
-      #   `ActiveRecord` methods with this cop should be considered unsafe.
+      #   This cop is unsafe because it assumes that the receiver is an
+      #   `Array` or equivalent, but can't reliably detect it. For example,
+      #   if the receiver is a `Hash`, it may report a false positive.
       #
       # @example
       #   # bad

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

@@ -58,8 +58,8 @@ module RuboCop
         private
 
         def autocorrect(corrector, first_call_args, second_call_args, combined_args)
-          first_argument = first_call_args.first.loc.expression
-          last_argument = second_call_args.last.loc.expression
+          first_argument = first_call_args.first.source_range
+          last_argument = second_call_args.last.source_range
           range = first_argument.join(last_argument)
 
           corrector.replace(range, combined_args)

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

@@ -69,7 +69,7 @@ module RuboCop
 
             new_source = "#{receiver.source}.end_with?(#{to_string_literal(regex_str)})"
 
-            corrector.replace(node.source_range, new_source)
+            corrector.replace(node, new_source)
           end
         end
         alias on_match_with_lvasgn on_send

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

@@ -28,7 +28,7 @@ module RuboCop
         def_node_matcher :flat_map_candidate?, <<~PATTERN
           (send
             {
-              (block $(send _ ${:collect :map}) ...)
+              $(block (send _ ${:collect :map}) ...)
               $(send _ ${:collect :map} (block_pass _))
             }
             ${:flatten :flatten!}
@@ -60,7 +60,8 @@ module RuboCop
         end
 
         def register_offense(node, map_node, first_method, flatten, message)
-          range = range_between(map_node.loc.selector.begin_pos, node.loc.expression.end_pos)
+          map_send_node = map_node.block_type? ? map_node.send_node : map_node
+          range = range_between(map_send_node.loc.selector.begin_pos, node.source_range.end_pos)
           message = format(message, method: first_method, flatten: flatten)
 
           add_offense(range, message: message) do |corrector|
@@ -74,10 +75,11 @@ module RuboCop
 
           return unless flatten_level
 
-          range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
+          map_send_node = map_node.block_type? ? map_node.send_node : map_node
+          range = range_between(map_node.source_range.end_pos, node.source_range.end_pos)
 
           corrector.remove(range)
-          corrector.replace(map_node.loc.selector, 'flat_map')
+          corrector.replace(map_send_node.loc.selector, 'flat_map')
         end
       end
     end

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

@@ -57,7 +57,7 @@ module RuboCop
               # Replace `keys.include?` or `values.include?` with the appropriate
               # `key?`/`value?` method.
               corrector.replace(
-                node.loc.expression,
+                node,
                 "#{autocorrect_hash_expression(node)}.#{autocorrect_method(node)}(#{autocorrect_argument(node)})"
               )
             end

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

@@ -95,7 +95,7 @@ module RuboCop
           begin_pos = readlines_call.loc.selector.begin_pos
 
           end_pos = if enumerable_call.method?(:each)
-                      enumerable_call.loc.expression.end_pos
+                      enumerable_call.source_range.end_pos
                     else
                       enumerable_call.loc.dot.begin_pos
                     end

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

@@ -75,7 +75,7 @@ module RuboCop
 
           new_source << CLOSE_PAREN if parentheses?(node) && !args.empty?
 
-          corrector.replace(node.source_range, new_source)
+          corrector.replace(node, new_source)
         end
 
         def calls_to_report(argname, body)

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

@@ -10,6 +10,16 @@ module RuboCop
       # behavior is appropriately overridden in subclass. For example,
       # `Range#===` returns `true` when argument is within the range.
       #
+      # This cop has `AllowRegexpMatch` option and it is true by default because
+      # `regexp.match?('string')` often used in block changes to the opposite result:
+      #
+      # [source,ruby]
+      # ----
+      # [/pattern/].all? { |regexp| regexp.match?('pattern') } # => true
+      # [/pattern/].all? { |regexp| regexp =~ 'pattern' }      # => true
+      # [/pattern/].all?('pattern')                            # => false
+      # ----
+      #
       # @safety
       #   This cop is unsafe because `===` and `==` do not always behave the same.
       #
@@ -22,6 +32,19 @@ module RuboCop
       #
       #   # good
       #   items.all?(pattern)
+      #   items.all?(Klass)
+      #
+      # @example AllowRegexpMatch: true (default)
+      #
+      #   # good
+      #   items.all? { |item| item =~ pattern }
+      #   items.all? { |item| item.match?(pattern) }
+      #
+      # @example AllowRegexpMatch: false
+      #
+      #   # bad
+      #   items.all? { |item| item =~ pattern }
+      #   items.all? { |item| item.match?(pattern) }
       #
       class RedundantEqualityComparisonBlock < Base
         extend AutoCorrector
@@ -33,6 +56,7 @@ module RuboCop
 
         TARGET_METHODS = %i[all? any? one? none?].freeze
         COMPARISON_METHODS = %i[== === is_a? kind_of?].freeze
+        REGEXP_METHODS = %i[=~ match?].freeze
         IS_A_METHODS = %i[is_a? kind_of?].freeze
 
         def on_block(node)
@@ -60,7 +84,11 @@ module RuboCop
         end
 
         def use_equality_comparison_block?(block_body)
-          block_body.send_type? && COMPARISON_METHODS.include?(block_body.method_name)
+          return false unless block_body.send_type?
+
+          method_name = block_body.method_name
+
+          COMPARISON_METHODS.include?(method_name) || (!allow_regexp_match? && REGEXP_METHODS.include?(method_name))
         end
 
         def same_block_argument_and_is_a_argument?(block_body, block_argument)
@@ -69,7 +97,7 @@ module RuboCop
           elsif IS_A_METHODS.include?(block_body.method_name)
             block_argument.source == block_body.first_argument.source
           else
-            false
+            block_body.receiver.source == block_body.first_argument.receiver&.source
           end
         end
 
@@ -99,6 +127,10 @@ module RuboCop
         def offense_range(node)
           node.send_node.loc.selector.join(node.source_range.end)
         end
+
+        def allow_regexp_match?
+          cop_config.fetch('AllowRegexpMatch', true)
+        end
       end
     end
   end

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

@@ -49,7 +49,7 @@ module RuboCop
         def autocorrect(corrector, node)
           new_source = "#{node.receiver.source} =~ #{node.first_argument.source}"
 
-          corrector.replace(node.source_range, new_source)
+          corrector.replace(node, new_source)
         end
 
         def autocorrectable?(node)

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

@@ -112,11 +112,11 @@ module RuboCop
             new_source.gsub!(/\n/, padding)
           end
 
-          corrector.replace(node.source_range, new_source)
+          corrector.replace(node, new_source)
         end
 
         def correct_single_element(corrector, node, new_source)
-          corrector.replace(node.source_range, new_source)
+          corrector.replace(node, new_source)
         end
 
         def to_assignments(receiver, pairs)

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

@@ -69,11 +69,11 @@ module RuboCop
         private
 
         def offense_range(receiver, node)
-          range_between(receiver.loc.selector.begin_pos, node.loc.expression.end_pos)
+          range_between(receiver.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
         def correction_range(receiver, node)
-          range_between(receiver.loc.dot.begin_pos, node.loc.expression.end_pos)
+          range_between(receiver.loc.dot.begin_pos, node.source_range.end_pos)
         end
 
         def build_message(method, args)

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

@@ -131,6 +131,10 @@ module RuboCop
           }
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [ConstantRegexp]
+        end
+
         def on_if(node)
           check_condition(node.condition)
         end
@@ -185,9 +189,9 @@ module RuboCop
 
         def range_to_search_for_last_matches(match_node, body, scope_root)
           expression = if modifier_form?(match_node)
-                         match_node.parent.if_branch.loc.expression
+                         match_node.parent.if_branch.source_range
                        else
-                         match_node.loc.expression
+                         match_node.source_range
                        end
 
           match_node_pos = expression.begin_pos
@@ -199,15 +203,15 @@ module RuboCop
         def next_match_pos(body, match_node_pos, scope_root)
           node = search_match_nodes(body).find do |match|
             begin_pos = if modifier_form?(match)
-                          match.parent.if_branch.loc.expression.begin_pos
+                          match.parent.if_branch.source_range.begin_pos
                         else
-                          match.loc.expression.begin_pos
+                          match.source_range.begin_pos
                         end
 
             begin_pos > match_node_pos && scope_root(match) == scope_root
           end
 
-          node ? node.loc.expression.begin_pos : Float::INFINITY
+          node ? node.source_range.begin_pos : Float::INFINITY
         end
 
         def modifier_form?(match_node)
@@ -216,7 +220,7 @@ module RuboCop
 
         def find_last_match(body, range, scope_root)
           last_matches(body).find do |ref|
-            ref_pos = ref.loc.expression.begin_pos
+            ref_pos = ref.source_range.begin_pos
             range.cover?(ref_pos) && scope_root(ref) == scope_root
           end
         end
@@ -248,8 +252,8 @@ module RuboCop
 
           replace_with_match_predicate_method(corrector, recv, arg, op_range)
 
-          corrector.insert_after(arg.loc.expression, ')') unless op_range.source.end_with?('(')
-          corrector.insert_before(recv.loc.expression, '!') if oper == :!~
+          corrector.insert_after(arg, ')') unless op_range.source.end_with?('(')
+          corrector.insert_before(recv, '!') if oper == :!~
         end
 
         def replace_with_match_predicate_method(corrector, recv, arg, op_range)
@@ -264,14 +268,14 @@ module RuboCop
         end
 
         def swap_receiver_and_arg(corrector, recv, arg)
-          corrector.replace(recv.loc.expression, arg.source)
-          corrector.replace(arg.loc.expression, recv.source)
+          corrector.replace(recv, arg.source)
+          corrector.replace(arg, recv.source)
         end
 
         def correction_range(recv, arg)
           buffer = processed_source.buffer
-          op_begin_pos = recv.loc.expression.end_pos
-          op_end_pos = arg.loc.expression.begin_pos
+          op_begin_pos = recv.source_range.end_pos
+          op_end_pos = arg.source_range.begin_pos
           Parser::Source::Range.new(buffer, op_begin_pos, op_end_pos)
         end
       end

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

@@ -43,7 +43,7 @@ module RuboCop
         private
 
         def correction_range(receiver, node)
-          range_between(receiver.loc.selector.begin_pos, node.loc.expression.end_pos)
+          range_between(receiver.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
         def build_message(node)

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

@@ -52,7 +52,7 @@ module RuboCop
         end
 
         def offense_range(node, map_method)
-          range_between(node.loc.selector.begin_pos, map_method.loc.expression.end_pos)
+          range_between(node.loc.selector.begin_pos, map_method.source_range.end_pos)
         end
       end
     end

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

@@ -48,7 +48,7 @@ module RuboCop
               string_literal = to_string_literal(replace_str)
               new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
 
-              corrector.replace(node.source_range, new_code)
+              corrector.replace(node, new_code)
             end
           end
         end

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

@@ -69,7 +69,7 @@ module RuboCop
 
             new_source = "#{receiver.source}.start_with?(#{to_string_literal(regex_str)})"
 
-            corrector.replace(node.source_range, new_source)
+            corrector.replace(node, new_source)
           end
         end
         alias on_match_with_lvasgn on_send

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

@@ -27,28 +27,33 @@ module RuboCop
 
         MSG = 'Use `%<symbol_arg>s` instead of `%<string_arg>s`.'
 
+        COMMAND_METHODS = %i[
+          alias_method attr_accessor attr_reader attr_writer autoload autoload? private private_constant
+          protected public public_constant module_function
+        ].freeze
+
         # NOTE: `attr` method is not included in this list as it can cause false positives in Nokogiri API.
         # And `attr` may not be used because `Style/Attr` registers an offense.
         # https://github.com/rubocop/rubocop-performance/issues/278
-        RESTRICT_ON_SEND = %i[
-          alias_method attr_accessor attr_reader attr_writer autoload autoload?
+        RESTRICT_ON_SEND = (%i[
           class_variable_defined? const_defined? const_get const_set const_source_location
           define_method instance_method method_defined? private_class_method? private_method_defined?
           protected_method_defined? public_class_method public_instance_method public_method_defined?
           remove_class_variable remove_method undef_method class_variable_get class_variable_set
-          deprecate_constant module_function private private_constant protected public public_constant
-          remove_const ruby2_keywords
-          define_singleton_method instance_variable_defined? instance_variable_get instance_variable_set
-          method public_method public_send remove_instance_variable respond_to? send singleton_method
-          __send__
-        ].freeze
+          deprecate_constant remove_const ruby2_keywords define_singleton_method instance_variable_defined?
+          instance_variable_get instance_variable_set method public_method public_send remove_instance_variable
+          respond_to? send singleton_method __send__
+        ] + COMMAND_METHODS).freeze
 
         def on_send(node)
+          return if COMMAND_METHODS.include?(node.method_name) && node.receiver
           return unless (first_argument = node.first_argument)
           return unless first_argument.str_type?
-          return if first_argument.value.include?(' ') || first_argument.value.include?('::')
 
-          replacement = first_argument.value.to_sym.inspect
+          first_argument_value = first_argument.value
+          return if first_argument_value.include?(' ') || first_argument_value.include?('::')
+
+          replacement = first_argument_value.to_sym.inspect
 
           message = format(MSG, symbol_arg: replacement, string_arg: first_argument.source)
 

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

@@ -43,7 +43,7 @@ module RuboCop
 
             new_source = "#{'!' if negation}#{receiver.source}.include?(#{to_string_literal(regex_str)})"
 
-            corrector.replace(node.source_range, new_source)
+            corrector.replace(node, new_source)
           end
         end
         alias on_match_with_lvasgn on_send

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

@@ -70,7 +70,7 @@ module RuboCop
           replacement_method = replacement_method(node, first_source, second_source)
 
           corrector.replace(node.loc.selector, replacement_method)
-          corrector.replace(first_param.source_range, to_string_literal(first_source)) unless first_param.str_type?
+          corrector.replace(first_param, to_string_literal(first_source)) unless first_param.str_type?
 
           remove_second_param(corrector, node, first_param) if second_source.empty? && first_source.length == 1
         end

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

@@ -183,7 +183,7 @@ module RuboCop
         end
 
         def sum_method_range(node)
-          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
         def sum_map_range(map, sum)

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

@@ -52,7 +52,7 @@ module RuboCop
             add_offense(node, message: message(map_or_collect, count)) do |corrector|
               replacement = "Array.new(#{count.source}#{map_or_collect.arguments.map { |arg| ", #{arg.source}" }.join})"
 
-              corrector.replace(map_or_collect.loc.expression, replacement)
+              corrector.replace(map_or_collect, replacement)
             end
           end
         end

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

@@ -30,7 +30,7 @@ module RuboCop
             message = format(MSG, double_colon: double_colon)
 
             add_offense(node, message: message) do |corrector|
-              corrector.replace(node.loc.expression, "#{double_colon}URI::DEFAULT_PARSER")
+              corrector.replace(node, "#{double_colon}URI::DEFAULT_PARSER")
             end
           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.16.0'
+      STRING = '1.18.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.16.0
+  version: 1.18.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-06 00:00:00.000000000 Z
+date: 2023-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -123,7 +123,7 @@ metadata:
   homepage_uri: https://docs.rubocop.org/rubocop-performance/
   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.16/
+  documentation_uri: https://docs.rubocop.org/rubocop-performance/1.18/
   bug_tracker_uri: https://github.com/rubocop/rubocop-performance/issues
   rubygems_mfa_required: 'true'
 post_install_message:
@@ -134,14 +134,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.5.0.dev
 signing_key:
 specification_version: 4
 summary: Automatic performance checking tool for Ruby code.