Advisory: CVE-2021-32740

Criticality: High

URL: https://github.com/advisories/GHSA-jxhc-q857-3j6g

Solution: upgrade to >= 2.8.0

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"

Further reading

• Cognitive Complexity docs
• Cognitive Complexity: A new way of measuring understandability

This cop checks for usage of comparison operators (==, >, <) to test numbers as zero, positive, or negative. These can be replaced by their respective predicate methods. The cop can also be configured to do the reverse.

The cop disregards #nonzero? as it its value is truthy or falsey, but not true and false, and thus not always interchangeable with != 0.

The cop ignores comparisons to global variables, since they are often populated with objects which can be compared with integers, but are not themselves Interger polymorphic.

Example: EnforcedStyle: predicate (default)

# bad
 
foo == 0
0 > foo
bar.baz > 0
 
# good
 
foo.zero?
foo.negative?
bar.baz.positive?

Example: EnforcedStyle: comparison

# bad
 
foo.zero?
foo.negative?
bar.baz.positive?
 
# good
 
foo == 0
0 > foo
bar.baz > 0

Checks for a newline after the final magic comment.

Example:

# good
# frozen_string_literal: true
 
# Some documentation for Person
class Person
  # Some code
end
 
# bad
# frozen_string_literal: true
# Some documentation for Person
class Person
  # Some code
end

Check for uses of braces or do/end around single line or multi-line blocks.

Example: EnforcedStyle: linecountbased (default)

# bad - single line block
items.each do |item| item / 5 end
 
# good - single line block
items.each { |item| item / 5 }
 
# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}
 
# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

Example: EnforcedStyle: semantic

# Prefer `do...end` over `{...}` for procedural blocks.
 
# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)
 
# return value is not used out of scope
# good
map do |x|
  x
end
 
# Prefer `{...}` over `do...end` for functional blocks.
 
# return value is not used out of scope
# bad
each { |x|
  x
}
 
# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

Example: EnforcedStyle: bracesforchaining

# bad
words.each do |word|
  word.flip.flop
end.join("-")
 
# good
words.each { |word|
  word.flip.flop
}.join("-")

This cop checks the indentation of the method name part in method calls that span more than one line.

Example: EnforcedStyle: aligned

# bad
while myvariable
.b
  # do something
end
 
# good
while myvariable
      .b
  # do something
end
 
# good
Thing.a
     .b
     .c

Example: EnforcedStyle: indented

# good
while myvariable
  .b
 
  # do something
end

Example: EnforcedStyle: indentedrelativeto_receiver

# good
while myvariable
        .a
        .b
 
  # do something
end
 
# good
myvariable = Thing
               .a
               .b
               .c

This cop checks the indentation of the method name part in method calls that span more than one line.

Example: EnforcedStyle: aligned

# bad
while myvariable
.b
  # do something
end
 
# good
while myvariable
      .b
  # do something
end
 
# good
Thing.a
     .b
     .c

Example: EnforcedStyle: indented

# good
while myvariable
  .b
 
  # do something
end

Example: EnforcedStyle: indentedrelativeto_receiver

# good
while myvariable
        .a
        .b
 
  # do something
end
 
# good
myvariable = Thing
               .a
               .b
               .c

This cop checks for trailing comma in array and hash literals.

Example: EnforcedStyleForMultiline: consistent_comma

# bad
a = [1, 2,]
 
# good
a = [
  1, 2,
  3,
]
 
# good
a = [
  1,
  2,
]

Example: EnforcedStyleForMultiline: comma

# bad
a = [1, 2,]
 
# good
a = [
  1,
  2,
]

Example: EnforcedStyleForMultiline: no_comma (default)

# bad
a = [1, 2,]
 
# good
a = [
  1,
  2
]

Check for uses of braces or do/end around single line or multi-line blocks.

Example: EnforcedStyle: linecountbased (default)

# bad - single line block
items.each do |item| item / 5 end
 
# good - single line block
items.each { |item| item / 5 }
 
# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}
 
# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

Example: EnforcedStyle: semantic

# Prefer `do...end` over `{...}` for procedural blocks.
 
# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)
 
# return value is not used out of scope
# good
map do |x|
  x
end
 
# Prefer `{...}` over `do...end` for functional blocks.
 
# return value is not used out of scope
# bad
each { |x|
  x
}
 
# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

Example: EnforcedStyle: bracesforchaining

# bad
words.each do |word|
  word.flip.flop
end.join("-")
 
# good
words.each { |word|
  word.flip.flop
}.join("-")

This cop checks the indentation of the method name part in method calls that span more than one line.

Example: EnforcedStyle: aligned

# bad
while myvariable
.b
  # do something
end
 
# good
while myvariable
      .b
  # do something
end
 
# good
Thing.a
     .b
     .c

Example: EnforcedStyle: indented

# good
while myvariable
  .b
 
  # do something
end

Example: EnforcedStyle: indentedrelativeto_receiver

# good
while myvariable
        .a
        .b
 
  # do something
end
 
# good
myvariable = Thing
               .a
               .b
               .c

Check for uses of braces or do/end around single line or multi-line blocks.

Example: EnforcedStyle: linecountbased (default)

# bad - single line block
items.each do |item| item / 5 end
 
# good - single line block
items.each { |item| item / 5 }
 
# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}
 
# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

Example: EnforcedStyle: semantic

# Prefer `do...end` over `{...}` for procedural blocks.
 
# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)
 
# return value is not used out of scope
# good
map do |x|
  x
end
 
# Prefer `{...}` over `do...end` for functional blocks.
 
# return value is not used out of scope
# bad
each { |x|
  x
}
 
# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

Example: EnforcedStyle: bracesforchaining

# bad
words.each do |word|
  word.flip.flop
end.join("-")
 
# good
words.each { |word|
  word.flip.flop
}.join("-")

Check for uses of braces or do/end around single line or multi-line blocks.

Example: EnforcedStyle: linecountbased (default)

# bad - single line block
items.each do |item| item / 5 end
 
# good - single line block
items.each { |item| item / 5 }
 
# bad - multi-line block
things.map { |thing|
  something = thing.some_method
  process(something)
}
 
# good - multi-line block
things.map do |thing|
  something = thing.some_method
  process(something)
end

Example: EnforcedStyle: semantic

# Prefer `do...end` over `{...}` for procedural blocks.
 
# return value is used/assigned
# bad
foo = map do |x|
  x
end
puts (map do |x|
  x
end)
 
# return value is not used out of scope
# good
map do |x|
  x
end
 
# Prefer `{...}` over `do...end` for functional blocks.
 
# return value is not used out of scope
# bad
each { |x|
  x
}
 
# return value is used/assigned
# good
foo = map { |x|
  x
}
map { |x|
  x
}.inspect

Example: EnforcedStyle: bracesforchaining

# bad
words.each do |word|
  word.flip.flop
end.join("-")
 
# good
words.each { |word|
  word.flip.flop
}.join("-")