Showing 2,171 of 2,171 total issues
Prefer single-quoted strings when you don't need string interpolation or special symbols. Open
(easter + offset.to_i.days).strftime("%d.%m")
- Read upRead up
- Exclude checks
Checks if uses of quotes match the configured preference.
Example: EnforcedStyle: single_quotes (default)
# bad
"No special symbols"
"No string interpolation"
"Just text"
# good
'No special symbols'
'No string interpolation'
'Just text'
"Wait! What's #{this}!"
Example: EnforcedStyle: double_quotes
# bad
'Just some text'
'No special chars or interpolation'
# good
"Just some text"
"No special chars or interpolation"
"Every string in #{project} uses double_quotes"
Do not use space inside array brackets. Open
language_codes = [ context[:locales] ].flatten
- Read upRead up
- Exclude checks
Checks that brackets used for array literals have or don't have surrounding space depending on configuration.
Example: EnforcedStyle: space
# The `space` style enforces that array literals have
# surrounding space.
# bad
array = [a, b, c, d]
# good
array = [ a, b, c, d ]
Example: EnforcedStyle: no_space
# The `no_space` style enforces that array literals have
# no surrounding space.
# bad
array = [ a, b, c, d ]
# good
array = [a, b, c, d]
Example: EnforcedStyle: compact
# The `compact` style normally requires a space inside
# array brackets, with the exception that successive left
# or right brackets are collapsed together in nested arrays.
# bad
array = [ a, [ b, c ] ]
# good
array = [ a, [ b, c ]]
Expression at 34, 55 should be on its own line. Open
rel && rel.merge(and_rel) || and_rel ;end;end
- Read upRead up
- Exclude checks
This cop checks whether the end statement of a do..end block is on its own line.
Example:
# bad
blah do |i|
foo(i) end
# good
blah do |i|
foo(i)
end
# bad
blah { |i|
foo(i) }
# good
blah { |i|
foo(i)
}
Do not use space inside array brackets. Open
language_codes = [ context[:locales] ].flatten
- Read upRead up
- Exclude checks
Checks that brackets used for array literals have or don't have surrounding space depending on configuration.
Example: EnforcedStyle: space
# The `space` style enforces that array literals have
# surrounding space.
# bad
array = [a, b, c, d]
# good
array = [ a, b, c, d ]
Example: EnforcedStyle: no_space
# The `no_space` style enforces that array literals have
# no surrounding space.
# bad
array = [ a, b, c, d ]
# good
array = [a, b, c, d]
Example: EnforcedStyle: compact
# The `compact` style normally requires a space inside
# array brackets, with the exception that successive left
# or right brackets are collapsed together in nested arrays.
# bad
array = [ a, [ b, c ] ]
# good
array = [ a, [ b, c ]]
Space inside parentheses detected. Open
alphabeth_codes = Languageble.alphabeth_list_for( language_codes ).flatten
- Read upRead up
- Exclude checks
Checks for spaces inside ordinary round parentheses.
Example:
# bad
f( 3)
g = (a + 3 )
# good
f(3)
g = (a + 3)
Space between { and | missing. Open
date = [ Time, Date, DateTime ].any? {|c| date_in.is_a?(c) } && date_in || Time.parse(date_in)
- Read upRead up
- Exclude checks
Checks that block braces have or don't have surrounding space inside them on configuration. For blocks taking parameters, it checks that the left brace has or doesn't have trailing space depending on configuration.
Example: EnforcedStyle: space (default)
# The `space` style enforces that block braces have
# surrounding space.
# bad
some_array.each {puts e}
# good
some_array.each { puts e }
Example: EnforcedStyle: no_space
# The `no_space` style enforces that block braces don't
# have surrounding space.
# bad
some_array.each { puts e }
# good
some_array.each {puts e}
Example: EnforcedStyleForEmptyBraces: no_space (default)
# The `no_space` EnforcedStyleForEmptyBraces style enforces that
# block braces don't have a space in between when empty.
# bad
some_array.each { }
some_array.each { }
some_array.each { }
# good
some_array.each {}
Example: EnforcedStyleForEmptyBraces: space
# The `space` EnforcedStyleForEmptyBraces style enforces that
# block braces have at least a spece in between when empty.
# bad
some_array.each {}
# good
some_array.each { }
some_array.each { }
some_array.each { }
Example: SpaceBeforeBlockParameters: true (default)
# The SpaceBeforeBlockParameters style set to `true` enforces that
# there is a space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.
# bad
[1, 2, 3].each {|n| n * 2 }
# good
[1, 2, 3].each { |n| n * 2 }
Example: SpaceBeforeBlockParameters: true
# The SpaceBeforeBlockParameters style set to `false` enforces that
# there is no space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.
# bad
[1, 2, 3].each { |n| n * 2 }
# good
[1, 2, 3].each {|n| n * 2 }
unexpected token error
(Using Ruby 2.1 parser; configure using TargetRubyVersion
parameter, under AllCops
) Open
[Memory.by_short_name(value).first&.id, "Memory"]
- Exclude checks
Do not use space inside array brackets. Open
language_codes = [ context[:locales] ].flatten
- Read upRead up
- Exclude checks
Checks that brackets used for array literals have or don't have surrounding space depending on configuration.
Example: EnforcedStyle: space
# The `space` style enforces that array literals have
# surrounding space.
# bad
array = [a, b, c, d]
# good
array = [ a, b, c, d ]
Example: EnforcedStyle: no_space
# The `no_space` style enforces that array literals have
# no surrounding space.
# bad
array = [ a, b, c, d ]
# good
array = [a, b, c, d]
Example: EnforcedStyle: compact
# The `compact` style normally requires a space inside
# array brackets, with the exception that successive left
# or right brackets are collapsed together in nested arrays.
# bad
array = [ a, [ b, c ] ]
# good
array = [ a, [ b, c ]]
Use only ascii symbols in comments. Open
# place_id[int] id места, где произошло событие
- Read upRead up
- Exclude checks
This cop checks for non-ascii (non-English) characters in comments. You could set an array of allowed non-ascii chars in AllowedChars attribute (empty by default).
Example:
# bad
# Translates from English to 日本語。
# good
# Translates from English to Japanese
Expression at 20, 31 should be on its own line. Open
x.mb_chars.downcase ;end
- Read upRead up
- Exclude checks
This cop checks whether the end statement of a do..end block is on its own line.
Example:
# bad
blah do |i|
foo(i) end
# good
blah do |i|
foo(i)
end
# bad
blah { |i|
foo(i) }
# good
blah { |i|
foo(i)
}
Wrap stabby lambda arguments with parentheses. Open
scope :with_memory, -> context do
- Read upRead up
- Exclude checks
Check for parentheses around stabby lambda arguments.
There are two different styles. Defaults to require_parentheses
.
Example: EnforcedStyle: require_parentheses (default)
# bad
->a,b,c { a + b + c }
# good
->(a,b,c) { a + b + c}
Example: EnforcedStyle: requirenoparentheses
# bad
->(a,b,c) { a + b + c }
# good
->a,b,c { a + b + c}
Wrap stabby lambda arguments with parentheses. Open
scope :with_orders, -> context do
- Read upRead up
- Exclude checks
Check for parentheses around stabby lambda arguments.
There are two different styles. Defaults to require_parentheses
.
Example: EnforcedStyle: require_parentheses (default)
# bad
->a,b,c { a + b + c }
# good
->(a,b,c) { a + b + c}
Example: EnforcedStyle: requirenoparentheses
# bad
->(a,b,c) { a + b + c }
# good
->a,b,c { a + b + c}
Do not use space inside array brackets. Open
language_codes = [ context[:locales] ].flatten
- Read upRead up
- Exclude checks
Checks that brackets used for array literals have or don't have surrounding space depending on configuration.
Example: EnforcedStyle: space
# The `space` style enforces that array literals have
# surrounding space.
# bad
array = [a, b, c, d]
# good
array = [ a, b, c, d ]
Example: EnforcedStyle: no_space
# The `no_space` style enforces that array literals have
# no surrounding space.
# bad
array = [ a, b, c, d ]
# good
array = [a, b, c, d]
Example: EnforcedStyle: compact
# The `compact` style normally requires a space inside
# array brackets, with the exception that successive left
# or right brackets are collapsed together in nested arrays.
# bad
array = [ a, [ b, c ] ]
# good
array = [ a, [ b, c ]]
Wrap stabby lambda arguments with parentheses. Open
scope :with_scripta, -> context do
- Read upRead up
- Exclude checks
Check for parentheses around stabby lambda arguments.
There are two different styles. Defaults to require_parentheses
.
Example: EnforcedStyle: require_parentheses (default)
# bad
->a,b,c { a + b + c }
# good
->(a,b,c) { a + b + c}
Example: EnforcedStyle: requirenoparentheses
# bad
->(a,b,c) { a + b + c }
# good
->a,b,c { a + b + c}
Indent the first line of the right-hand-side of a multi-line assignment. Open
if digits.size > 3
digits[0..5]
elsif digits.size > 0
digits + firsts[ 0...4 - digits.size ].join
elsif firsts.size > 2
- Read upRead up
- Exclude checks
This cop checks the indentation of the first line of the right-hand-side of a multi-line assignment.
Example:
# bad
value =
if foo
'bar'
end
# good
value =
if foo
'bar'
end
The indentation of the remaining lines can be corrected with
other cops such as IndentationConsistency
and EndAlignment
.
Space found before semicolon. Open
class Tweet < Description ;end
- Read upRead up
- Exclude checks
Checks for semicolon (;) preceded by space.
Example:
# bad
x = 1 ; y = 2
# good
x = 1; y = 2
Bad indentation of the first parameter. Open
where( "unaccent(notes_orders.text) ~* unaccent(?)", "\\m#{text}.*" )))).distinct
- Read upRead up
- Exclude checks
This cop checks the indentation of the first parameter in a method call. Parameters after the first one are checked by Style/AlignParameters, not by this cop.
Example:
# bad
some_method(
first_param,
second_param)
# good
some_method(
first_param,
second_param)
Avoid multi-line chains of blocks. Open
x.mb_chars.downcase.to_s != x ;end
.map do |x|
- Read upRead up
- Exclude checks
This cop checks for chaining of a block after another block that spans multiple lines.
Example:
Thread.list.find_all do |t|
t.alive?
end.map do |t|
t.object_id
end
Space inside parentheses detected. Open
alphabeth_codes = Languageble.alphabeth_list_for( language_codes ).flatten
- Read upRead up
- Exclude checks
Checks for spaces inside ordinary round parentheses.
Example:
# bad
f( 3)
g = (a + 3 )
# good
f(3)
g = (a + 3)
Bad indentation of the first parameter. Open
where("unaccent(names_subjects.text) ~* unaccent(?)", "\\m#{text}.*").or(
where("unaccent(descriptions_subjects.text) ~* unaccent(?)", "\\m#{text}.*")))))
- Read upRead up
- Exclude checks
This cop checks the indentation of the first parameter in a method call. Parameters after the first one are checked by Style/AlignParameters, not by this cop.
Example:
# bad
some_method(
first_param,
second_param)
# good
some_method(
first_param,
second_param)