atzorvas/ccradio

This cops checks for parentheses around the arguments in method definitions. Both instance and class/singleton methods are checked.

Example: EnforcedStyle: require_parentheses (default)

# The `require_parentheses` style requires method definitions
# to always use parentheses
 
# bad
def bar num1, num2
  num1 + num2
end
 
def foo descriptive_var_name,
        another_descriptive_var_name,
        last_descriptive_var_name
  do_something
end
 
# good
def bar(num1, num2)
  num1 + num2
end
 
def foo(descriptive_var_name,
        another_descriptive_var_name,
        last_descriptive_var_name)
  do_something
end

Example: EnforcedStyle: requirenoparentheses

# The `require_no_parentheses` style requires method definitions
# to never use parentheses
 
# bad
def bar(num1, num2)
  num1 + num2
end
 
def foo(descriptive_var_name,
        another_descriptive_var_name,
        last_descriptive_var_name)
  do_something
end
 
# good
def bar num1, num2
  num1 + num2
end
 
def foo descriptive_var_name,
        another_descriptive_var_name,
        last_descriptive_var_name
  do_something
end

Example: EnforcedStyle: requirenoparenthesesexceptmultiline

# The `require_no_parentheses_except_multiline` style prefers no
# parantheses when method definition arguments fit on single line,
# but prefers parantheses when arguments span multiple lines.
 
# bad
def bar(num1, num2)
  num1 + num2
end
 
def foo descriptive_var_name,
        another_descriptive_var_name,
        last_descriptive_var_name
  do_something
end
 
# good
def bar num1, num2
  num1 + num2
end
 
def foo(descriptive_var_name,
        another_descriptive_var_name,
        last_descriptive_var_name)
  do_something
end

This cop checks for redundant uses of self.

The usage of self is only needed when:

• Sending a message to same object with zero arguments in presence of a method name clash with an argument or a local variable.

• Calling an attribute writer to prevent an local variable assignment.

Note, with using explicit self you can only send messages with public or protected scope, you cannot send private messages this way.

Note we allow uses of self with operators because it would be awkward otherwise.

Example:

# bad
def foo(bar)
  self.baz
end
 
# good
def foo(bar)
  self.bar  # Resolves name clash with the argument.
end
 
def foo
  bar = 1
  self.bar  # Resolves name clash with the local variable.
end
 
def foo
  %w[x y z].select do |bar|
    self.bar == bar  # Resolves name clash with argument of the block.
  end
end

This cop checks for missing top-level documentation of classes and modules. Classes with no body are exempt from the check and so are namespace modules - modules that have nothing in their bodies except classes, other modules, or constant definitions.

The documentation requirement is annulled if the class or module has a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the same for all its children.

Example:

# bad
class Person
  # ...
end
 
# good
# Description/Explanation of Person class
class Person
  # ...
end

Access modifiers should be surrounded by blank lines.

Example:

# bad
class Foo
  def bar; end
  private
  def baz; end
end
 
# good
class Foo
  def bar; end
 
  private
 
  def baz; end
end

This cop checks for redundant uses of self.

The usage of self is only needed when:

• Sending a message to same object with zero arguments in presence of a method name clash with an argument or a local variable.

• Calling an attribute writer to prevent an local variable assignment.

Note, with using explicit self you can only send messages with public or protected scope, you cannot send private messages this way.

Note we allow uses of self with operators because it would be awkward otherwise.

Example:

# bad
def foo(bar)
  self.baz
end
 
# good
def foo(bar)
  self.bar  # Resolves name clash with the argument.
end
 
def foo
  bar = 1
  self.bar  # Resolves name clash with the local variable.
end
 
def foo
  %w[x y z].select do |bar|
    self.bar == bar  # Resolves name clash with argument of the block.
  end
end

Here we check if the parameters on a multi-line method call or definition are aligned.

Example: EnforcedStyle: withfirstparameter (default)

# good
 
foo :bar,
    :baz
 
# bad
 
foo :bar,
  :baz

Example: EnforcedStyle: withfixedindentation

# good
 
foo :bar,
  :baz
 
# bad
 
foo :bar,
    :baz

Checks for comma (,) not followed by some kind of space.

Example:

# bad
[1,2]
{ foo:bar,}
 
# good
[1, 2]
{ foo:bar, }

This cop checks for missing top-level documentation of classes and modules. Classes with no body are exempt from the check and so are namespace modules - modules that have nothing in their bodies except classes, other modules, or constant definitions.

The documentation requirement is annulled if the class or module has a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the same for all its children.

Example:

# bad
class Person
  # ...
end
 
# good
# Description/Explanation of Person class
class Person
  # ...
end

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 redundant uses of self.

The usage of self is only needed when:

• Sending a message to same object with zero arguments in presence of a method name clash with an argument or a local variable.

• Calling an attribute writer to prevent an local variable assignment.

Note, with using explicit self you can only send messages with public or protected scope, you cannot send private messages this way.

Note we allow uses of self with operators because it would be awkward otherwise.

Example:

# bad
def foo(bar)
  self.baz
end
 
# good
def foo(bar)
  self.bar  # Resolves name clash with the argument.
end
 
def foo
  bar = 1
  self.bar  # Resolves name clash with the local variable.
end
 
def foo
  %w[x y z].select do |bar|
    self.bar == bar  # Resolves name clash with argument of the block.
  end
end

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"

This cop checks for when; uses in case expressions.

Example:

# bad
case foo
when 1; 'baz'
when 2; 'bar'
end
 
# good
case foo
when 1 then 'baz'
when 2 then 'bar'
end

This cop makes sure that accessor methods are named properly.

Example:

# bad
def set_attribute(value)
end
 
# good
def attribute=(value)
end
 
# bad
def get_attribute
end
 
# good
def attribute
end

This cop checks for redundant uses of self.

The usage of self is only needed when:

• Sending a message to same object with zero arguments in presence of a method name clash with an argument or a local variable.

• Calling an attribute writer to prevent an local variable assignment.

Note, with using explicit self you can only send messages with public or protected scope, you cannot send private messages this way.

Note we allow uses of self with operators because it would be awkward otherwise.

Example:

# bad
def foo(bar)
  self.baz
end
 
# good
def foo(bar)
  self.bar  # Resolves name clash with the argument.
end
 
def foo
  bar = 1
  self.bar  # Resolves name clash with the local variable.
end
 
def foo
  %w[x y z].select do |bar|
    self.bar == bar  # Resolves name clash with argument of the block.
  end
end

Here we check if the parameters on a multi-line method call or definition are aligned.

Example: EnforcedStyle: withfirstparameter (default)

# good
 
foo :bar,
    :baz
 
# bad
 
foo :bar,
  :baz

Example: EnforcedStyle: withfixedindentation

# good
 
foo :bar,
  :baz
 
# bad
 
foo :bar,
    :baz

This cop checks for redundant uses of self.

The usage of self is only needed when:

• Sending a message to same object with zero arguments in presence of a method name clash with an argument or a local variable.

• Calling an attribute writer to prevent an local variable assignment.

Note, with using explicit self you can only send messages with public or protected scope, you cannot send private messages this way.

Note we allow uses of self with operators because it would be awkward otherwise.

Example:

# bad
def foo(bar)
  self.baz
end
 
# good
def foo(bar)
  self.bar  # Resolves name clash with the argument.
end
 
def foo
  bar = 1
  self.bar  # Resolves name clash with the local variable.
end
 
def foo
  %w[x y z].select do |bar|
    self.bar == bar  # Resolves name clash with argument of the block.
  end
end

This cops looks for uses of global variables. It does not report offenses for built-in global variables. Built-in global variables are allowed by default. Additionally users can allow additional variables via the AllowedVariables option.

Note that backreferences like $1, $2, etc are not global variables.

Example:

# bad
$foo = 2
bar = $foo + 5
 
# good
FOO = 2
foo = 2
$stdin.read

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"

Here we check if the parameters on a multi-line method call or definition are aligned.

Example: EnforcedStyle: withfirstparameter (default)

# good
 
foo :bar,
    :baz
 
# bad
 
foo :bar,
  :baz

Example: EnforcedStyle: withfixedindentation

# good
 
foo :bar,
  :baz
 
# bad
 
foo :bar,
    :baz