cloudamatic/mu

This cop checks for rescue blocks with no body.

Example:

# bad
 
def some_method
  do_something
rescue
  # do nothing
end

Example:

# bad
 
begin
  do_something
rescue
  # do nothing
end

Example:

# good
 
def some_method
  do_something
rescue
  handle_exception
end

Example:

# good
 
begin
  do_something
rescue
  handle_exception
end

This cop checks for a rescued exception that get shadowed by a less specific exception being rescued before a more specific exception is rescued.

Example:

# bad
 
begin
  something
rescue Exception
  handle_exception
rescue StandardError
  handle_standard_error
end
 
# good
 
begin
  something
rescue StandardError
  handle_standard_error
rescue Exception
  handle_exception
end
 
# good, however depending on runtime environment.
#
# This is a special case for system call errors.
# System dependent error code depends on runtime environment.
# For example, whether `Errno::EAGAIN` and `Errno::EWOULDBLOCK` are
# the same error code or different error code depends on environment.
# This good case is for `Errno::EAGAIN` and `Errno::EWOULDBLOCK` with
# the same error code.
begin
  something
rescue Errno::EAGAIN, Errno::EWOULDBLOCK
  handle_standard_error
end

This cop checks for unused block arguments.

Example:

# bad
 
do_something do |used, unused|
  puts used
end
 
do_something do |bar|
  puts :foo
end
 
define_method(:foo) do |bar|
  puts :baz
end

Example:

#good
 
do_something do |used, _unused|
  puts used
end
 
do_something do
  puts :foo
end
 
define_method(:foo) do |_bar|
  puts :baz
end

This cop checks for excessive nesting of conditional and looping constructs.

You can configure if blocks are considered using the CountBlocks option. When set to false (the default) blocks are not counted towards the nesting level. Set to true to count blocks as well.

The maximum level of nesting allowed is configurable.

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.

Example:

# bad
do_something if str.match(/regex/)
while regex.match('str')
  do_something
end
 
# good
method(str =~ /regex/)
return value unless regex =~ 'str'

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.

Example:

# bad
do_something if str.match(/regex/)
while regex.match('str')
  do_something
end
 
# good
method(str =~ /regex/)
return value unless regex =~ 'str'

This cop checks for string conversion in string interpolation, which is redundant.

Example:

# bad
 
"result is #{something.to_s}"

Example:

# good
 
"result is #{something}"

This cop checks for unused method arguments.

Example:

# bad
 
def some_method(used, unused, _unused_but_allowed)
  puts used
end

Example:

# good
 
def some_method(used, _unused, _unused_but_allowed)
  puts used
end

This cop checks for every useless assignment to local variable in every scope. The basic idea for this cop was from the warning of ruby -cw:

assigned but unused variable - foo

Currently this cop has advanced logic that detects unreferenced reassignments and properly handles varied cases such as branch, loop, rescue, ensure, etc.

Example:

# bad
 
def some_method
  some_var = 1
  do_something
end

Example:

# good
 
def some_method
  some_var = 1
  do_something(some_var)
end

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.

Example:

# bad
do_something if str.match(/regex/)
while regex.match('str')
  do_something
end
 
# good
method(str =~ /regex/)
return value unless regex =~ 'str'

This cop checks for every useless assignment to local variable in every scope. The basic idea for this cop was from the warning of ruby -cw:

assigned but unused variable - foo

Currently this cop has advanced logic that detects unreferenced reassignments and properly handles varied cases such as branch, loop, rescue, ensure, etc.

Example:

# bad
 
def some_method
  some_var = 1
  do_something
end

Example:

# good
 
def some_method
  some_var = 1
  do_something(some_var)
end

This cop checks for every useless assignment to local variable in every scope. The basic idea for this cop was from the warning of ruby -cw:

assigned but unused variable - foo

Currently this cop has advanced logic that detects unreferenced reassignments and properly handles varied cases such as branch, loop, rescue, ensure, etc.

Example:

# bad
 
def some_method
  some_var = 1
  do_something
end

Example:

# good
 
def some_method
  some_var = 1
  do_something(some_var)
end

This cop checks whether the end keywords are aligned properly.

Three modes are supported through the EnforcedStyleAlignWith configuration parameter:

If it's set to keyword (which is the default), the end shall be aligned with the start of the keyword (if, class, etc.).

If it's set to variable the end shall be aligned with the left-hand-side of the variable assignment, if there is one.

If it's set to start_of_line, the end shall be aligned with the start of the line where the matching keyword appears.

Example: EnforcedStyleAlignWith: keyword (default)

# bad
 
variable = if true
    end
 
# good
 
variable = if true
           end

Example: EnforcedStyleAlignWith: variable

# bad
 
variable = if true
    end
 
# good
 
variable = if true
end

Example: EnforcedStyleAlignWith: startofline

# bad
 
variable = if true
    end
 
# good
 
puts(if true
end)

This cop checks for every useless assignment to local variable in every scope. The basic idea for this cop was from the warning of ruby -cw:

assigned but unused variable - foo

Currently this cop has advanced logic that detects unreferenced reassignments and properly handles varied cases such as branch, loop, rescue, ensure, etc.

Example:

# bad
 
def some_method
  some_var = 1
  do_something
end

Example:

# good
 
def some_method
  some_var = 1
  do_something(some_var)
end

This cop checks for excessive nesting of conditional and looping constructs.

You can configure if blocks are considered using the CountBlocks option. When set to false (the default) blocks are not counted towards the nesting level. Set to true to count blocks as well.

The maximum level of nesting allowed is configurable.

This cop checks for excessive nesting of conditional and looping constructs.

You can configure if blocks are considered using the CountBlocks option. When set to false (the default) blocks are not counted towards the nesting level. Set to true to count blocks as well.

The maximum level of nesting allowed is configurable.

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

Example:

# 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(' ')

This cop checks for rescue blocks with no body.

Example:

# bad
 
def some_method
  do_something
rescue
  # do nothing
end

Example:

# bad
 
begin
  do_something
rescue
  # do nothing
end

Example:

# good
 
def some_method
  do_something
rescue
  handle_exception
end

Example:

# good
 
begin
  do_something
rescue
  handle_exception
end

This cop checks for rescue blocks with no body.

Example:

# bad
 
def some_method
  do_something
rescue
  # do nothing
end

Example:

# bad
 
begin
  do_something
rescue
  # do nothing
end

Example:

# good
 
def some_method
  do_something
rescue
  handle_exception
end

Example:

# good
 
begin
  do_something
rescue
  handle_exception
end

This cop checks for string conversion in string interpolation, which is redundant.

Example:

# bad
 
"result is #{something.to_s}"

Example:

# good
 
"result is #{something}"