!!! Note
Required Ruby version: 2.7
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes | 1.6 | - |
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, ...)
.
# bad
umethod.bind(obj).call(foo, bar)
umethod.bind(obj).(foo, bar)
# good
umethod.bind_call(obj, foo, bar)
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | No | 0.49 | - |
This cop identifies places where caller[n]
can be replaced by caller(n..n).first
.
# bad
caller[1]
caller.first
caller_locations[1]
caller_locations.first
# good
caller(2..2).first
caller(1..1).first
caller_locations(2..2).first
caller_locations(1..1).first
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Disabled | Yes | Yes (Unsafe) | 0.34 | 0.59 |
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.
# bad
case foo
when *condition
bar
when baz
foobar
end
case foo
when *[1, 2, 3, 4]
bar
when 5
baz
end
# good
case foo
when baz
foobar
when *condition
bar
end
case foo
when 1, 2, 3, 4
bar
when 5
baz
end
Name | Default value | Configurable values |
---|---|---|
AutoCorrect | false |
Boolean |
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | No | Yes | 0.36 | - |
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.
# bad
str.downcase == 'abc'
str.upcase.eql? 'ABC'
'abc' == str.downcase
'ABC'.eql? str.upcase
str.downcase == str.downcase
# good
str.casecmp('ABC').zero?
'abc'.casecmp(str).zero?
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Disabled | Yes | No | 0.59 | - |
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.
# bad
array = ["a", "b", "c"]
array.compact.flatten.map { |x| x.downcase }
# good.
array = ["a", "b", "c"]
array.compact!
array.flatten!
array.map! { |x| x.downcase }
array
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes | 0.46 | - |
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.
# 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] }
# good
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.sort_by { |a| a[:foo] }
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes (Unsafe) | 0.31 | 1.5 |
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
becomes:
Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }
# bad
[1, 2, 3].select { |e| e > 2 }.size
[1, 2, 3].reject { |e| e > 2 }.size
[1, 2, 3].select { |e| e > 2 }.length
[1, 2, 3].reject { |e| e > 2 }.length
[1, 2, 3].select { |e| e > 2 }.count { |e| e.odd? }
[1, 2, 3].reject { |e| e > 2 }.count { |e| e.even? }
array.select(&:value).count
# good
[1, 2, 3].count { |e| e > 2 }
[1, 2, 3].count { |e| e < 2 }
[1, 2, 3].count { |e| e > 2 && e.odd? }
[1, 2, 3].count { |e| e < 2 && e.even? }
Model.select('field AS field_one').count
Model.select(:value).count
!!! Note
Required Ruby version: 2.5
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes | 1.6 | - |
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')
.
The delete_prefix('prefix')
method is faster than
gsub(/\Aprefix/, '')
.
# bad
str.gsub(/\Aprefix/, '')
str.gsub!(/\Aprefix/, '')
str.gsub(/^prefix/, '')
str.gsub!(/^prefix/, '')
str.sub(/\Aprefix/, '')
str.sub!(/\Aprefix/, '')
str.sub(/^prefix/, '')
str.sub!(/^prefix/, '')
# good
str.delete_prefix('prefix')
str.delete_prefix!('prefix')
!!! Note
Required Ruby version: 2.5
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes | 1.6 | - |
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')
.
The delete_suffix('suffix')
method is faster than
gsub(/suffix\z/, '')
.
# bad
str.gsub(/suffix\z/, '')
str.gsub!(/suffix\z/, '')
str.gsub(/suffix$/, '')
str.gsub!(/suffix$/, '')
str.sub(/suffix\z/, '')
str.sub!(/suffix\z/, '')
str.sub(/suffix$/, '')
str.sub!(/suffix$/, '')
# good
str.delete_suffix('suffix')
str.delete_suffix!('suffix')
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes (Unsafe) | 0.30 | 1.5 |
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.
# bad
[].select { |item| true }.first
[].select { |item| true }.last
[].find_all { |item| true }.first
[].find_all { |item| true }.last
# good
[].detect { |item| true }
[].reverse.detect { |item| true }
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes | 0.36 | 0.48 |
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.
# bad
str.start_with?("a") || str.start_with?(Some::CONST)
str.start_with?("a", "b") || str.start_with?("c")
str.end_with?(var1) || str.end_with?(var2)
# good
str.start_with?("a", Some::CONST)
str.start_with?("a", "b", "c")
str.end_with?(var1, var2)
Name | Default value | Configurable values |
---|---|---|
IncludeActiveSupportAliases | false |
Boolean |
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes (Unsafe) | 0.36 | 0.44 |
This cop identifies unnecessary use of a regex where String#end_with?
would suffice.
# bad
'abc'.match?(/bc\Z/)
/bc\Z/.match?('abc')
'abc' =~ /bc\Z/
/bc\Z/ =~ 'abc'
'abc'.match(/bc\Z/)
/bc\Z/.match('abc')
'abc'.match?(/bc$/)
/bc$/.match?('abc')
'abc' =~ /bc$/
/bc$/ =~ 'abc'
'abc'.match(/bc$/)
/bc$/.match('abc')
# good
'abc'.end_with?('bc')
Name | Default value | Configurable values |
---|---|---|
AutoCorrect | false |
Boolean |
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | No | 0.35 | - |
Do not compute the size of statically sized objects.
# String methods
# bad
'foo'.size
%q[bar].count
%(qux).length
# Symbol methods
# bad
:fred.size
:'baz'.length
# Array methods
# bad
[1, 2, thud].count
%W(1, 2, bar).size
# Hash methods
# bad
{ a: corge, b: grault }.length
# good
foo.size
bar.count
qux.length
# good
:"#{fred}".size
CONST = :baz.length
# good
[1, 2, *thud].count
garply = [1, 2, 3]
garply.size
# good
{ a: corge, **grault }.length
waldo = { a: corge, b: grault }
waldo.size
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes | 0.30 | - |
This cop is used to identify usages of
# bad
[1, 2, 3, 4].map { |e| [e, e] }.flatten(1)
[1, 2, 3, 4].collect { |e| [e, e] }.flatten(1)
# good
[1, 2, 3, 4].flat_map { |e| [e, e] }
[1, 2, 3, 4].map { |e| [e, e] }.flatten
[1, 2, 3, 4].collect { |e| [e, e] }.flatten
Name | Default value | Configurable values |
---|---|---|
EnabledForFlattenWithoutParams | false |
Boolean |
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | No | Yes | 0.56 | - |
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.
# bad
{ a: 1, b: 2 }.keys.include?(:a)
{ a: 1, b: 2 }.keys.include?(:z)
h = { a: 1, b: 2 }; h.keys.include?(100)
# good
{ a: 1, b: 2 }.key?(:a)
{ a: 1, b: 2 }.has_key?(:z)
h = { a: 1, b: 2 }; h.key?(100)
# bad
{ a: 1, b: 2 }.values.include?(2)
{ a: 1, b: 2 }.values.include?('garbage')
h = { a: 1, b: 2 }; h.values.include?(nil)
# good
{ a: 1, b: 2 }.value?(2)
{ a: 1, b: 2 }.has_value?('garbage')
h = { a: 1, b: 2 }; h.value?(nil)
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Disabled | No | No | 0.61 | - |
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.
# bad
class MyClass
def my_method
OpenStruct.new(my_key1: 'my_value1', my_key2: 'my_value2')
end
end
# good
class MyClass
MyStruct = Struct.new(:my_key1, :my_key2)
def my_method
MyStruct.new('my_value1', 'my_value2')
end
end
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | No | Yes | 0.36 | - |
This cop identifies uses of Range#include?
, 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?
and
Range#cover?
are not equivalent behavior.
# bad
('a'..'z').include?('b') # => true
# good
('a'..'z').cover?('b') # => true
# Example of a case where `Range#cover?` may not provide
# the desired result:
('a'..'z').cover?('yellow') # => true
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes | 0.36 | - |
This cop identifies the use of a &block
parameter and block.call
where yield
would do just as well.
# bad
def method(&block)
block.call
end
def another(&func)
func.call 1, 2, 3
end
# good
def method
yield
end
def another
yield 1, 2, 3
end
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes | 0.36 | - |
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.
# bad
do_something if str.match(/regex/)
while regex.match('str')
do_something
end
# good
method(str =~ /regex/)
return value unless regex =~ 'str'
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes | 0.36 | - |
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
.
# bad
hash.merge!(a: 1)
hash.merge!({'key' => 'value'})
# good
hash[:a] = 1
hash['key'] = 'value'
# bad
hash.merge!(a: 1, b: 2)
# good
hash[:a] = 1
hash[:b] = 2
Name | Default value | Configurable values |
---|---|---|
MaxKeyValuePairs | 2 |
Integer |
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes | 0.47 | - |
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
.
# bad
def foo
if x =~ /re/
do_something
end
end
# bad
def foo
if x !~ /re/
do_something
end
end
# bad
def foo
if x.match(/re/)
do_something
end
end
# bad
def foo
if /re/ === x
do_something
end
end
# good
def foo
if x.match?(/re/)
do_something
end
end
# good
def foo
if !x.match?(/re/)
do_something
end
end
# good
def foo
if x =~ /re/
do_something(Regexp.last_match)
end
end
# good
def foo
if x.match(/re/)
do_something($~)
end
end
# good
def foo
if /re/ === x
do_something($~)
end
end
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes | 0.30 | - |
This cop is used to identify usages of reverse.each
and
change them to use reverse_each
instead.
# bad
[].reverse.each
# good
[].reverse_each
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes | 0.30 | - |
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.
# bad
[1, 2, 3].count
# bad
{a: 1, b: 2, c: 3}.count
# good
[1, 2, 3].size
# good
{a: 1, b: 2, c: 3}.size
# good
[1, 2, 3].count { |e| e > 2 }
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes (Unsafe) | 0.36 | 0.44 |
This cop identifies unnecessary use of a regex where
String#start_with?
would suffice.
# bad
'abc'.match?(/\Aab/)
/\Aab/.match?('abc')
'abc' =~ /\Aab/
/\Aab/ =~ 'abc'
'abc'.match(/\Aab/)
/\Aab/.match('abc')
'abc'.match?(/^ab/)
/^ab/.match?('abc')
'abc' =~ /^ab/
/^ab/ =~ 'abc'
'abc'.match(/^ab/)
/^ab/.match('abc')
# good
'abc'.start_with?('ab')
Name | Default value | Configurable values |
---|---|---|
AutoCorrect | false |
Boolean |
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes | 1.7 | - |
This cop identifies unnecessary use of a regex where
String#include?
would suffice.
# bad
'abc'.match?(/ab/)
/ab/.match?('abc')
'abc' =~ /ab/
/ab/ =~ 'abc'
'abc'.match(/ab/)
/ab/.match('abc')
# good
'abc'.include?('ab')
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes | 0.33 | - |
This cop identifies places where gsub
can be replaced by
tr
or delete
.
# bad
'abc'.gsub('b', 'd')
'abc'.gsub('a', '')
'abc'.gsub(/a/, 'd')
'abc'.gsub!('a', 'd')
# good
'abc'.gsub(/.*/, 'a')
'abc'.gsub(/a+/, 'd')
'abc'.tr('b', 'd')
'a b c'.delete(' ')
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes (Unsafe) | 0.36 | 0.50 |
This cop checks for .times.map calls. In most cases such calls can be replaced with an explicit array creation.
# bad
9.times.map do |i|
i.to_s
end
# good
Array.new(9) do |i|
i.to_s
end
Name | Default value | Configurable values |
---|---|---|
AutoCorrect | false |
Boolean |
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | No | 0.50 | - |
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
.
Note: String.new
(without operator) is not exactly the same as +''
.
These differ in encoding. String.new.encoding
is always ASCII-8BIT
.
However, (+'').encoding
is the same as script encoding(e.g. UTF-8
).
So, if you expect ASCII-8BIT
encoding, disable this cop.
# bad
''.dup
"something".dup
String.new
String.new('')
String.new('something')
# good
+'something'
+''
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled | Yes | Yes | 0.50 | - |
This cop identifies places where URI::Parser.new
can be replaced by URI::DEFAULT_PARSER
.
# bad
URI::Parser.new
# good
URI::DEFAULT_PARSER