Naming

Naming/AccessorMethodName

Enabled by default Safe Supports autocorrection Version Added Version Changed

Enabled

Yes

No

0.50

-

Makes sure that accessor methods are named properly. Applies to both instance and class methods.

Offenses are only registered for methods with the expected arity. Getters (get_attribute) must have no arguments to be registered, and setters (set_attribute(value)) must have exactly one.

Examples

# bad
def set_attribute(value)
end

# good
def attribute=(value)
end

# bad
def get_attribute
end

# good
def attribute
end

# accepted, incorrect arity for getter
def get_value(attr)
end

# accepted, incorrect arity for setter
def set_value
end

References

Naming/AsciiIdentifiers

Enabled by default Safe Supports autocorrection Version Added Version Changed

Enabled

Yes

No

0.50

0.87

Checks for non-ascii characters in identifier and constant names. Identifiers are always checked and whether constants are checked can be controlled using AsciiConstants config.

Examples

# bad
def καλημερα # Greek alphabet (non-ascii)
end

# bad
def こんにちはと言う # Japanese character (non-ascii)
end

# bad
def hello_🍣 # Emoji (non-ascii)
end

# good
def say_hello
end

# bad
신장 = 10 # Hangul character (non-ascii)

# good
height = 10

# bad
params[:عرض_gteq] # Arabic character (non-ascii)

# good
params[:width_gteq]

AsciiConstants: true (default)

# bad
class Foö
end

FOÖ = "foo"

AsciiConstants: false

# good
class Foö
end

FOÖ = "foo"

Configurable attributes

Name Default value Configurable values

AsciiConstants

true

Boolean

References

Naming/BinaryOperatorParameterName

Enabled by default Safe Supports autocorrection Version Added Version Changed

Enabled

Yes

Always

0.50

1.2

Makes sure that certain binary operator methods have their sole parameter named other.

Examples

# bad
def +(amount); end

# good
def +(other); end

References

Naming/BlockForwarding

Requires Ruby version 3.1
Enabled by default Safe Supports autocorrection Version Added Version Changed

Pending

Yes

Always

1.24

-

In Ruby 3.1, anonymous block forwarding has been added.

This cop identifies places where do_something(&block) can be replaced by do_something(&).

It also supports the opposite style by alternative explicit option. You can specify the block variable name for autocorrection with BlockForwardingName. The default variable name is block. If the name is already in use, it will not be autocorrected.

Examples

EnforcedStyle: anonymous (default)

# bad
def foo(&block)
  bar(&block)
end

# good
def foo(&)
  bar(&)
end

EnforcedStyle: explicit

# bad
def foo(&)
  bar(&)
end

# good
def foo(&block)
  bar(&block)
end

Configurable attributes

Name Default value Configurable values

EnforcedStyle

anonymous

anonymous, explicit

BlockForwardingName

block

String

References

Naming/BlockParameterName

Enabled by default Safe Supports autocorrection Version Added Version Changed

Enabled

Yes

No

0.53

0.77

Checks block parameter names for how descriptive they are. It is highly configurable.

The MinNameLength config option takes an integer. It represents the minimum amount of characters the name must be. Its default is 1. The AllowNamesEndingInNumbers config option takes a boolean. When set to false, this cop will register offenses for names ending with numbers. Its default is false. The AllowedNames config option takes an array of permitted names that will never register an offense. The ForbiddenNames config option takes an array of restricted names that will always register an offense.

Examples

# bad
bar do |varOne, varTwo|
  varOne + varTwo
end

# With `AllowNamesEndingInNumbers` set to false
foo { |num1, num2| num1 * num2 }

# With `MinNameLength` set to number greater than 1
baz { |a, b, c| do_stuff(a, b, c) }

# good
bar do |thud, fred|
  thud + fred
end

foo { |speed, distance| speed * distance }

baz { |age, height, gender| do_stuff(age, height, gender) }

Configurable attributes

Name Default value Configurable values

MinNameLength

1

Integer

AllowNamesEndingInNumbers

true

Boolean

AllowedNames

[]

Array

ForbiddenNames

[]

Array

Naming/ClassAndModuleCamelCase

Enabled by default Safe Supports autocorrection Version Added Version Changed

Enabled

Yes

No

0.50

0.85

Checks for class and module names with an underscore in them.

AllowedNames config takes an array of permitted names. Its default value is ['module_parent']. These names can be full class/module names or part of the name. eg. Adding my_class to the AllowedNames config will allow names like my_class, my_class::User, App::my_class, App::my_class::User, etc.

Examples

# bad
class My_Class
end
module My_Module
end

# good
class MyClass
end
module MyModule
end
class module_parent::MyModule
end

Configurable attributes

Name Default value Configurable values

AllowedNames

module_parent

Array

References

Naming/ConstantName

Enabled by default Safe Supports autocorrection Version Added Version Changed

Enabled

Yes

No

0.50

-

Checks whether constant names are written using SCREAMING_SNAKE_CASE.

To avoid false positives, it ignores cases in which we cannot know for certain the type of value that would be assigned to a constant.

Examples

# bad
InchInCm = 2.54
INCHinCM = 2.54
Inch_In_Cm = 2.54

# good
INCH_IN_CM = 2.54

References

Naming/FileName

Enabled by default Safe Supports autocorrection Version Added Version Changed

Enabled

Yes

No

0.50

1.23

Makes sure that Ruby source files have snake_case names. Ruby scripts (i.e. source files with a shebang in the first line) are ignored.

The cop also ignores .gemspec files, because Bundler recommends using dashes to separate namespaces in nested gems (i.e. bundler-console becomes Bundler::Console). As such, the gemspec is supposed to be named bundler-console.gemspec.

When ExpectMatchingDefinition (default: false) is true, the cop requires each file to have a class, module or Struct defined in it that matches the filename. This can be further configured using CheckDefinitionPathHierarchy (default: true) to determine whether the path should match the namespace of the above definition.

When IgnoreExecutableScripts (default: true) is true, files that start with a shebang line are not considered by the cop.

When Regex is set, the cop will flag any filename that does not match the regular expression.

Examples

# bad
lib/layoutManager.rb

anything/usingCamelCase

# good
lib/layout_manager.rb

anything/using_snake_case.rake

Configurable attributes

Name Default value Configurable values

Exclude

Rakefile.rb

Array

ExpectMatchingDefinition

false

Boolean

CheckDefinitionPathHierarchy

true

Boolean

CheckDefinitionPathHierarchyRoots

lib, spec, test, src

Array

Regex

<none>

IgnoreExecutableScripts

true

Boolean

AllowedAcronyms

CLI, DSL, ACL, API, ASCII, CPU, CSS, DNS, EOF, GUID, HTML, HTTP, HTTPS, ID, IP, JSON, LHS, QPS, RAM, RHS, RPC, SLA, SMTP, SQL, SSH, TCP, TLS, TTL, UDP, UI, UID, UUID, URI, URL, UTF8, VM, XML, XMPP, XSRF, XSS

Array

References

Naming/HeredocDelimiterCase

Enabled by default Safe Supports autocorrection Version Added Version Changed

Enabled

Yes

Always

0.50

1.2

Checks that your heredocs are using the configured case. By default it is configured to enforce uppercase heredocs.

Examples

EnforcedStyle: uppercase (default)

# bad
<<-sql
  SELECT * FROM foo
sql

# good
<<-SQL
  SELECT * FROM foo
SQL

EnforcedStyle: lowercase

# bad
<<-SQL
  SELECT * FROM foo
SQL

# good
<<-sql
  SELECT * FROM foo
sql

Configurable attributes

Name Default value Configurable values

EnforcedStyle

uppercase

lowercase, uppercase

References

Naming/HeredocDelimiterNaming

Enabled by default Safe Supports autocorrection Version Added Version Changed

Enabled

Yes

No

0.50

-

Checks that your heredocs are using meaningful delimiters. By default it disallows END and EO*, and can be configured through forbidden listing additional delimiters.

Examples

# good
<<-SQL
  SELECT * FROM foo
SQL

# bad
<<-END
  SELECT * FROM foo
END

# bad
<<-EOS
  SELECT * FROM foo
EOS

Configurable attributes

Name Default value Configurable values

ForbiddenDelimiters

(?i-mx:(^|\s)(EO[A-Z]{1}|END)(\s|$))

Array

References

Naming/InclusiveLanguage

Enabled by default Safe Supports autocorrection Version Added Version Changed

Disabled

Yes

Always

1.18

1.49

Recommends the use of inclusive language instead of problematic terms. The cop can check the following locations for offenses:

  • identifiers

  • constants

  • variables

  • strings

  • symbols

  • comments

  • file paths

Each of these locations can be individually enabled/disabled via configuration, for example CheckIdentifiers = true/false.

Flagged terms are configurable for the cop. For each flagged term an optional Regex can be specified to identify offenses. Suggestions for replacing a flagged term can be configured and will be displayed as part of the offense message. An AllowedRegex can be specified for a flagged term to exempt allowed uses of the term. WholeWord: true can be set on a flagged term to indicate the cop should only match when a term matches the whole word (partial matches will not be offenses).

The cop supports autocorrection when there is only one suggestion. When there are multiple suggestions, the best suggestion cannot be identified and will not be autocorrected.

Examples

FlaggedTerms: { whitelist: { Suggestions: ['allowlist'] } }

# Suggest replacing identifier whitelist with allowlist

# bad
whitelist_users = %w(user1 user1)

# good
allowlist_users = %w(user1 user2)

FlaggedTerms: { master: { Suggestions: ['main', 'primary', 'leader'] } }

# Suggest replacing master in an instance variable name with main, primary, or leader

# bad
@master_node = 'node1.example.com'

# good
@primary_node = 'node1.example.com'

FlaggedTerms: { whitelist: { Regex: !ruby/regexp '/white[-_\s]?list' } }

# Identify problematic terms using a Regexp

# bad
white_list = %w(user1 user2)

# good
allow_list = %w(user1 user2)

FlaggedTerms: { master: { AllowedRegex: 'master\'?s degree' } }

# Specify allowed uses of the flagged term as a string or regexp.

# bad
# They had a masters

# good
# They had a master's degree

FlaggedTerms: { slave: { WholeWord: true } }

# Specify that only terms that are full matches will be flagged.

# bad
Slave

# good (won't be flagged despite containing `slave`)
TeslaVehicle

Configurable attributes

Name Default value Configurable values

CheckIdentifiers

true

Boolean

CheckConstants

true

Boolean

CheckVariables

true

Boolean

CheckStrings

false

Boolean

CheckSymbols

true

Boolean

CheckComments

true

Boolean

CheckFilepaths

true

Boolean

FlaggedTerms

{"whitelist"⇒{"Regex"⇒/white[-\s]?list/, "Suggestions"⇒["allowlist", "permit"]}, "blacklist"⇒{"Regex"⇒/black[-\s]?list/, "Suggestions"⇒["denylist", "block"]}, "slave"⇒{"WholeWord"⇒true, "Suggestions"⇒["replica", "secondary", "follower"]}}

Naming/MemoizedInstanceVariableName

Enabled by default Safe Supports autocorrection Version Added Version Changed

Enabled

No

Always (Unsafe)

0.53

1.2

Checks for memoized methods whose instance variable name does not match the method name. Applies to both regular methods (defined with def) and dynamic methods (defined with define_method or define_singleton_method).

This cop can be configured with the EnforcedStyleForLeadingUnderscores directive. It can be configured to allow for memoized instance variables prefixed with an underscore. Prefixing ivars with an underscore is a convention that is used to implicitly indicate that an ivar should not be set or referenced outside of the memoization method.

Safety

This cop relies on the pattern @instance_var ||= …​, but this is sometimes used for other purposes than memoization so this cop is considered unsafe. Also, its autocorrection is unsafe because it may conflict with instance variable names already in use.

Examples

EnforcedStyleForLeadingUnderscores: disallowed (default)

# bad
# Method foo is memoized using an instance variable that is
# not `@foo`. This can cause confusion and bugs.
def foo
  @something ||= calculate_expensive_thing
end

def foo
  return @something if defined?(@something)
  @something = calculate_expensive_thing
end

# good
def _foo
  @foo ||= calculate_expensive_thing
end

# good
def foo
  @foo ||= calculate_expensive_thing
end

# good
def foo
  @foo ||= begin
    calculate_expensive_thing
  end
end

# good
def foo
  helper_variable = something_we_need_to_calculate_foo
  @foo ||= calculate_expensive_thing(helper_variable)
end

# good
define_method(:foo) do
  @foo ||= calculate_expensive_thing
end

# good
define_method(:foo) do
  return @foo if defined?(@foo)
  @foo = calculate_expensive_thing
end

EnforcedStyleForLeadingUnderscores: required

# bad
def foo
  @something ||= calculate_expensive_thing
end

# bad
def foo
  @foo ||= calculate_expensive_thing
end

def foo
  return @foo if defined?(@foo)
  @foo = calculate_expensive_thing
end

# good
def foo
  @_foo ||= calculate_expensive_thing
end

# good
def _foo
  @_foo ||= calculate_expensive_thing
end

def foo
  return @_foo if defined?(@_foo)
  @_foo = calculate_expensive_thing
end

# good
define_method(:foo) do
  @_foo ||= calculate_expensive_thing
end

# good
define_method(:foo) do
  return @_foo if defined?(@_foo)
  @_foo = calculate_expensive_thing
end

EnforcedStyleForLeadingUnderscores :optional

# bad
def foo
  @something ||= calculate_expensive_thing
end

# good
def foo
  @foo ||= calculate_expensive_thing
end

# good
def foo
  @_foo ||= calculate_expensive_thing
end

# good
def _foo
  @_foo ||= calculate_expensive_thing
end

# good
def foo
  return @_foo if defined?(@_foo)
  @_foo = calculate_expensive_thing
end

# good
define_method(:foo) do
  @foo ||= calculate_expensive_thing
end

# good
define_method(:foo) do
  @_foo ||= calculate_expensive_thing
end

Configurable attributes

Name Default value Configurable values

EnforcedStyleForLeadingUnderscores

disallowed

disallowed, required, optional

Naming/MethodName

Enabled by default Safe Supports autocorrection Version Added Version Changed

Enabled

Yes

No

0.50

-

Makes sure that all methods use the configured style, snake_case or camelCase, for their names.

This cop has AllowedPatterns configuration option.

Naming/MethodName:
  AllowedPatterns:
    - '\AonSelectionBulkChange\z'
    - '\AonSelectionCleared\z'

Method names matching patterns are always allowed.

Examples

EnforcedStyle: snake_case (default)

# bad
def fooBar; end

# good
def foo_bar; end

EnforcedStyle: camelCase

# bad
def foo_bar; end

# good
def fooBar; end

Configurable attributes

Name Default value Configurable values

EnforcedStyle

snake_case

snake_case, camelCase

AllowedPatterns

[]

Array

References

Naming/MethodParameterName

Enabled by default Safe Supports autocorrection Version Added Version Changed

Enabled

Yes

No

0.53

0.77

Checks method parameter names for how descriptive they are. It is highly configurable.

The MinNameLength config option takes an integer. It represents the minimum amount of characters the name must be. Its default is 3. The AllowNamesEndingInNumbers config option takes a boolean. When set to false, this cop will register offenses for names ending with numbers. Its default is false. The AllowedNames config option takes an array of permitted names that will never register an offense. The ForbiddenNames config option takes an array of restricted names that will always register an offense.

Examples

# bad
def bar(varOne, varTwo)
  varOne + varTwo
end

# With `AllowNamesEndingInNumbers` set to false
def foo(num1, num2)
  num1 * num2
end

# With `MinNameLength` set to number greater than 1
def baz(a, b, c)
  do_stuff(a, b, c)
end

# good
def bar(thud, fred)
  thud + fred
end

def foo(speed, distance)
  speed * distance
end

def baz(age_a, height_b, gender_c)
  do_stuff(age_a, height_b, gender_c)
end

Configurable attributes

Name Default value Configurable values

MinNameLength

3

Integer

AllowNamesEndingInNumbers

true

Boolean

AllowedNames

as, at, by, cc, db, id, if, in, io, ip, of, on, os, pp, to

Array

ForbiddenNames

[]

Array

Naming/PredicateName

Enabled by default Safe Supports autocorrection Version Added Version Changed

Enabled

Yes

No

0.50

0.77

Checks that predicate method names end with a question mark and do not start with a forbidden prefix.

A method is determined to be a predicate method if its name starts with one of the prefixes listed in the NamePrefix configuration. The list defaults to is_, has_, and have_ but may be overridden.

Predicate methods must end with a question mark.

When ForbiddenPrefixes is also set (as it is by default), predicate methods which begin with a forbidden prefix are not allowed, even if they end with a ?. These methods should be changed to remove the prefix.

Examples

NamePrefix: ['is_', 'has_', 'have_'] (default)

# bad
def is_even(value)
end

# When ForbiddenPrefixes: ['is_', 'has_', 'have_'] (default)
# good
def even?(value)
end

# When ForbiddenPrefixes: []
# good
def is_even?(value)
end

NamePrefix: ['seems_to_be_']

# bad
def seems_to_be_even(value)
end

# When ForbiddenPrefixes: ['seems_to_be_']
# good
def even?(value)
end

# When ForbiddenPrefixes: []
# good
def seems_to_be_even?(value)
end

AllowedMethods: ['is_a?'] (default)

# Despite starting with the `is_` prefix, this method is allowed
# good
def is_a?(value)
end

AllowedMethods: ['is_even?']

# good
def is_even?(value)
end

MethodDefinitionMacros: ['define_method', 'define_singleton_method'] (default)

# bad
define_method(:is_even) { |value| }

# good
define_method(:even?) { |value| }

MethodDefinitionMacros: ['def_node_matcher']

# bad
def_node_matcher(:is_even) { |value| }

# good
def_node_matcher(:even?) { |value| }

Configurable attributes

Name Default value Configurable values

NamePrefix

is_, has_, have_

Array

ForbiddenPrefixes

is_, has_, have_

Array

AllowedMethods

is_a?

Array

MethodDefinitionMacros

define_method, define_singleton_method

Array

Exclude

spec/**/*

Array

References

Naming/RescuedExceptionsVariableName

Enabled by default Safe Supports autocorrection Version Added Version Changed

Enabled

Yes

Always

0.67

0.68

Makes sure that rescued exceptions variables are named as expected.

The PreferredName config option takes a String. It represents the required name of the variable. Its default is e.

This cop does not consider nested rescues because it cannot guarantee that the variable from the outer rescue is not used within the inner rescue (in which case, changing the inner variable would shadow the outer variable).

Examples

PreferredName: e (default)

# bad
begin
  # do something
rescue MyException => exception
  # do something
end

# good
begin
  # do something
rescue MyException => e
  # do something
end

# good
begin
  # do something
rescue MyException => _e
  # do something
end

PreferredName: exception

# bad
begin
  # do something
rescue MyException => e
  # do something
end

# good
begin
  # do something
rescue MyException => exception
  # do something
end

# good
begin
  # do something
rescue MyException => _exception
  # do something
end

Configurable attributes

Name Default value Configurable values

PreferredName

e

String

Naming/VariableName

Enabled by default Safe Supports autocorrection Version Added Version Changed

Enabled

Yes

No

0.50

1.8

Makes sure that all variables use the configured style, snake_case or camelCase, for their names.

Examples

EnforcedStyle: snake_case (default)

# bad
fooBar = 1

# good
foo_bar = 1

EnforcedStyle: camelCase

# bad
foo_bar = 1

# good
fooBar = 1

AllowedIdentifiers: ['fooBar']

# good (with EnforcedStyle: snake_case)
fooBar = 1

AllowedPatterns: ['_v\d+\z']

# good (with EnforcedStyle: camelCase)
:release_v1

Configurable attributes

Name Default value Configurable values

EnforcedStyle

snake_case

snake_case, camelCase

AllowedIdentifiers

[]

Array

AllowedPatterns

[]

Array

References

Naming/VariableNumber

Enabled by default Safe Supports autocorrection Version Added Version Changed

Enabled

Yes

No

0.50

1.4

Makes sure that all numbered variables use the configured style, snake_case, normalcase, or non_integer, for their numbering.

Additionally, CheckMethodNames and CheckSymbols configuration options can be used to specify whether method names and symbols should be checked. Both are enabled by default.

Examples

EnforcedStyle: normalcase (default)

# bad
:some_sym_1
variable_1 = 1

def some_method_1; end

def some_method1(arg_1); end

# good
:some_sym1
variable1 = 1

def some_method1; end

def some_method1(arg1); end

EnforcedStyle: snake_case

# bad
:some_sym1
variable1 = 1

def some_method1; end

def some_method_1(arg1); end

# good
:some_sym_1
variable_1 = 1

def some_method_1; end

def some_method_1(arg_1); end

EnforcedStyle: non_integer

# bad
:some_sym1
:some_sym_1

variable1 = 1
variable_1 = 1

def some_method1; end

def some_method_1; end

def some_methodone(arg1); end
def some_methodone(arg_1); end

# good
:some_symone
:some_sym_one

variableone = 1
variable_one = 1

def some_methodone; end

def some_method_one; end

def some_methodone(argone); end
def some_methodone(arg_one); end

# In the following examples, we assume `EnforcedStyle: normalcase` (default).

CheckMethodNames: true (default)

# bad
def some_method_1; end

CheckMethodNames: false

# good
def some_method_1; end

CheckSymbols: true (default)

# bad
:some_sym_1

CheckSymbols: false

# good
:some_sym_1

AllowedIdentifiers: [capture3]

# good
expect(Open3).to receive(:capture3)

AllowedPatterns: ['_v\d+\z']

# good
:some_sym_v1

Configurable attributes

Name Default value Configurable values

EnforcedStyle

normalcase

snake_case, normalcase, non_integer

CheckMethodNames

true

Boolean

CheckSymbols

true

Boolean

AllowedIdentifiers

capture3, iso8601, rfc1123_date, rfc822, rfc2822, rfc3339, x86_64

Array

AllowedPatterns

[]

Array

References