Performance

This cop is used to identify usages of ancestors.include? and change them to use ⇐ instead.

This cop identifies places where numeric argument to BigDecimal should be converted to string. Initializing from String is faster than from Numeric for BigDecimal.

In Ruby 2.7, UnboundMethod#bind_call has been added.

This cop identifies places where bind(obj).call(args, …​) can be replaced by bind_call(obj, args, …​).

The bind_call(obj, args, …​) method is faster than bind(obj).call(args, …​).

This cop identifies places where caller[n] can be replaced by caller(n..n).first.

Reordering when conditions with a splat to the end of the when branches can improve performance.

Ruby has to allocate memory for the splat expansion every time that the case when statement is run. Since Ruby does not support fall through inside of case when, like some other languages do, the order of the when branches should not matter. By placing any splat expansions at the end of the list of when branches we will reduce the number of times that memory has to be allocated for the expansion. The exception to this is if multiple of your when conditions can be true for any given condition. A likely scenario for this defining a higher level when condition to override a condition that is inside of the splat expansion.

This is not a guaranteed performance improvement. If the data being processed by the case condition is normalized in a manner that favors hitting a condition in the splat expansion, it is possible that moving the splat condition to the end will use more memory, and run slightly slower.

This cop identifies places where a case-insensitive string comparison can better be implemented using casecmp. This cop is unsafe because String#casecmp and String#casecmp? behave differently when using Non-ASCII characters.

This cop is used to identify usages of Each of these methods (compact, flatten, map) will generate a new intermediate array that is promptly thrown away. Instead it is faster to mutate when we know it’s safe.

This cop 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 is used to identify usages of count on an Enumerable that follow calls to select or reject. Querying logic can instead be passed to the count call.

ActiveRecord compatibility: ActiveRecord will ignore the block that is passed to count. Other methods, such as select, will convert the association to an array and then run the block on the array. A simple work around to make count work with a block is to call to_a.count {…​}.

Example: Model.where(id: [1, 2, 3]).select { |m| m.method == true }.size

In Ruby 2.5, String#delete_prefix has been added.

This cop identifies places where gsub(/\Aprefix/, '') and sub(/\Aprefix/, '') can be replaced by delete_prefix('prefix').

This cop has SafeMultiline configuration option that true by default because ^prefix is unsafe as it will behave incompatible with delete_prefix for receiver is multiline string.

The delete_prefix('prefix') method is faster than gsub(/\Aprefix/, '').

In Ruby 2.5, String#delete_suffix has been added.

This cop identifies places where gsub(/suffix\z/, '') and sub(/suffix\z/, '') can be replaced by delete_suffix('suffix').

This cop has SafeMultiline configuration option that true by default because suffix$ is unsafe as it will behave incompatible with delete_suffix? for receiver is multiline string.

The delete_suffix('suffix') method is faster than gsub(/suffix\z/, '').

This cop is used to identify usages of select.first, select.last, find_all.first, and find_all.last and change them to use detect instead.

ActiveRecord compatibility: ActiveRecord does not implement a detect method and find has its own meaning. Correcting ActiveRecord methods with this cop should be considered unsafe.

This cop checks for double #start_with? or #end_with? calls separated by ||. In some cases such calls can be replaced with an single #start_with?/#end_with? call.

This cop identifies unnecessary use of a regex where String#end_with? would suffice.

This cop has SafeMultiline configuration option that true by default because end$ is unsafe as it will behave incompatible with end_with? for receiver is multiline string.

Do not compute the size of statically sized objects.

This cop is used to identify usages of

This cop checks for inefficient searching of keys and values within hashes.

Hash#keys.include? is less efficient than Hash#key? because the former allocates a new array and then performs an O(n) search through that array, while Hash#key? does not allocate any array and performs a faster O(1) search for the key.

Hash#values.include? is less efficient than Hash#value?. While they both perform an O(n) search through all of the values, calling values allocates a new array while using value? does not.

This cop identifies places where inefficient readlines method can be replaced by each_line to avoid fully loading file content into memory.

This cop checks for OpenStruct.new calls. Instantiation of an OpenStruct invalidates Ruby global method cache as it causes dynamic method definition during program runtime. This could have an effect on performance, especially in case of single-threaded applications with multiple OpenStruct instantiations.

This cop identifies uses of Range#include? and Range#member?, which iterates over each item in a Range to see if a specified item is there. In contrast, Range#cover? simply compares the target item with the beginning and end points of the Range. In a great majority of cases, this is what is wanted.

This cop is Safe: false by default because Range#include? (or Range#member?) and Range#cover? are not equivalent behaviour.

This cop identifies the use of a &block parameter and block.call where yield 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.

This cop identifies places where Hash#merge! can be replaced by Hash#[]=. You can set the maximum number of key-value pairs to consider an offense with MaxKeyValuePairs.

This cop identifies places where sort { |a, b| a <⇒ b } can be replaced with sort.

This cop checks for redundant String#chars.

In Ruby 2.4, String#match?, Regexp#match?, and Symbol#match? have been added. The methods are faster than match. Because the methods avoid creating a MatchData object or saving backref. So, when MatchData is not used, use match? instead of match.

This cop is used to identify usages of reverse.each and change them to use reverse_each instead.

This cop identifies places where reverse.first(n) and reverse.first can be replaced by last(n).reverse and last.

This cop is used to identify usages of count on an Array and Hash and change them to size.

TODO: Add advanced detection of variables that could have been assigned to an array or a hash.

This cop identifies places where sort { |a, b| b <⇒ a } can be replaced by a faster sort.reverse.

This cop identifies places where gsub(/a+/, 'a') and gsub!(/a+/, 'a') can be replaced by squeeze('a') and squeeze!('a').

The squeeze('a') method is faster than gsub(/a+/, 'a').

This cop identifies unnecessary use of a regex where String#start_with? would suffice.

This cop has SafeMultiline configuration option that true by default because ^start is unsafe as it will behave incompatible with start_with? for receiver is multiline string.

This cop identifies unnecessary use of a regex where String#include? would suffice.

This cop’s offenses are not safe to auto-correct if a receiver is nil.

This cop identifies places where gsub can be replaced by tr or delete.

This cop checks for .times.map calls. In most cases such calls can be replaced with an explicit array creation.

In Ruby 2.3 or later, use unary plus operator to unfreeze a string literal instead of String#dup and String.new. Unary plus operator is faster than String#dup.

This cop identifies places where URI::Parser.new can be replaced by URI::DEFAULT_PARSER.