Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled |
Yes |
Yes |
1.7 |
- |
This cop is used to identify usages of ancestors.include?
and
change them to use ⇐
instead.
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled |
Yes |
Yes |
1.7 |
- |
This cop identifies places where numeric argument to BigDecimal should be converted to string. Initializing from String is faster than from Numeric for BigDecimal.
BigDecimal(1, 2) BigDecimal(1.2, 3, exception: true)
# good BigDecimal('1', 2) BigDecimal('1.2', 3, exception: true)
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, …)
.
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
.
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
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled |
No |
Yes (Unsafe) |
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')
.
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/, '')
.
# bad
str.gsub(/\Aprefix/, '')
str.gsub!(/\Aprefix/, '')
str.sub(/\Aprefix/, '')
str.sub!(/\Aprefix/, '')
# good
str.delete_prefix('prefix')
str.delete_prefix!('prefix')
# good
str.gsub(/^prefix/, '')
str.gsub!(/^prefix/, '')
str.sub(/^prefix/, '')
str.sub!(/^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')
.
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/, '')
.
# bad
str.gsub(/suffix\z/, '')
str.gsub!(/suffix\z/, '')
str.sub(/suffix\z/, '')
str.sub!(/suffix\z/, '')
# good
str.delete_suffix('suffix')
str.delete_suffix!('suffix')
# good
str.gsub(/suffix$/, '')
str.gsub!(/suffix$/, '')
str.sub(/suffix$/, '')
str.sub!(/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)
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled |
Yes |
Yes (Unsafe) |
0.36 |
1.6 |
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.
# bad
'abc'.match?(/bc\Z/)
/bc\Z/.match?('abc')
'abc' =~ /bc\Z/
/bc\Z/ =~ 'abc'
'abc'.match(/bc\Z/)
/bc\Z/.match('abc')
# good
'abc'.end_with?('bc')
# good
'abc'.match?(/bc$/)
/bc$/.match?('abc')
'abc' =~ /bc$/
/bc$/ =~ 'abc'
'abc'.match(/bc$/)
/bc$/.match('abc')
Name | Default value | Configurable values |
---|---|---|
AutoCorrect |
|
Boolean |
SafeMultiline |
|
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 |
|
Boolean |
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled |
No |
Yes (Unsafe) |
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 |
Yes |
Yes |
1.7 |
- |
This cop identifies places where inefficient readlines
method
can be replaced by each_line
to avoid fully loading file content into memory.
# bad
File.readlines('testfile').each { |l| puts l }
IO.readlines('testfile', chomp: true).each { |l| puts l }
conn.readlines(10).map { |l| l.size }
file.readlines.find { |l| l.start_with?('#') }
file.readlines.each { |l| puts l }
# good
File.open('testfile', 'r').each_line { |l| puts l }
IO.open('testfile').each_line(chomp: true) { |l| puts l }
conn.each_line(10).map { |l| l.size }
file.each_line.find { |l| l.start_with?('#') }
file.each_line { |l| puts l }
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.
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled |
No |
Yes (Unsafe) |
0.36 |
1.7 |
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.
# bad
('a'..'z').include?('b') # => true
('a'..'z').member?('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.
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'
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.
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled |
Yes |
Yes |
1.7 |
- |
This cop identifies places where reverse.first(n)
and reverse.first
can be replaced by last(n).reverse
and last
.
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
(1..3).to_a.count
Array[*1..3].count
Array(1..3).count
# bad
{a: 1, b: 2, c: 3}.count
[[:foo, :bar], [1, 2]].to_h.count
Hash[*('a'..'z')].count
Hash(key: :value).count
# good
[1, 2, 3].size
(1..3).to_a.size
Array[*1..3].size
Array(1..3).size
# good
{a: 1, b: 2, c: 3}.size
[[:foo, :bar], [1, 2]].to_h.size
Hash[*('a'..'z')].size
Hash(key: :value).size
# good
[1, 2, 3].count { |e| e > 2 }
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled |
Yes |
Yes |
1.7 |
- |
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')
.
Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged |
---|---|---|---|---|
Enabled |
Yes |
Yes (Unsafe) |
0.36 |
1.6 |
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.
# bad
'abc'.match?(/\Aab/)
/\Aab/.match?('abc')
'abc' =~ /\Aab/
/\Aab/ =~ 'abc'
'abc'.match(/\Aab/)
/\Aab/.match('abc')
# good
'abc'.start_with?('ab')
# good
'abc'.match?(/^ab/)
/^ab/.match?('abc')
'abc' =~ /^ab/
/^ab/ =~ 'abc'
'abc'.match(/^ab/)
/^ab/.match('abc')
Name | Default value | Configurable values |
---|---|---|
AutoCorrect |
|
Boolean |
SafeMultiline |
|
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.
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.
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.
|