Style

Access modifiers should be declared to apply to a group of methods or inline before each method, depending on configuration. EnforcedStyle config covers only method definitions. Applications of visibility methods to symbols can be controlled using AllowModifiersOnSymbols config.

This cop checks for grouping of accessors in class and module bodies. By default it enforces accessors to be placed in grouped declarations, but it can be configured to enforce separating them in multiple declarations.

This cop enforces the use of either #alias or #alias_method depending on configuration. It also flags uses of alias :symbol rather than alias bareword.

This cop checks for uses of and and or, and suggests using && and || instead. It can be configured to check only in conditions or in all contexts.

In Ruby 2.7, arguments forwarding has been added.

This cop identifies places where do_something(*args, &block) can be replaced by do_something(…​).

This cop enforces the use of Array() instead of explicit Array check or [*var].

This cop is disabled by default because false positive will occur if the argument of Array() is not an array (e.g. Hash, Set), an array will be returned as an incompatibility result.

This cop checks for uses of "*" as a substitute for join.

Not all cases can reliably checked, due to Ruby’s dynamic types, so we consider only cases when the first argument is an array literal or the second is a string literal.

This cop checks for non-ascii (non-English) characters in comments. You could set an array of allowed non-ascii chars in AllowedChars attribute (copyright notice "©" by default).

This cop checks for uses of Module#attr.

This cop checks for cases when you could use a block accepting version of a method that does automatic resource cleanup.

This cop checks if usage of %() or %Q() matches configuration.

This cop checks for BEGIN blocks.

This cop checks for places where attr_reader and attr_writer for the same method can be combined into single attr_accessor.

This cop looks for uses of block comments (=begin…​=end).

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

This cop checks for uses of the case equality operator(===).

This cop identifies places where if-elsif constructions can be replaced with case-when.

Checks for uses of the character literal ?x.

This cop checks the style of children definitions at classes and modules. Basically there are two different styles:

The compact style is only forced for classes/modules with one child.

This cop enforces consistent use of Object#is_a? or Object#kind_of?.

This cop enforces the use of Object#instance_of? instead of class comparison for equality.

This cop checks for uses of the class/module name instead of self, when defining class/module methods.

This cop enforces using def self.method_name or class << self to define class methods.

This cop checks for uses of class variables. Offenses are signaled only on assignment to class variables to reduce the number of offenses that would be reported.

You have to be careful when setting a value for a class variable; if a class has been inherited, changing the value of a class variable also affects the inheriting classes. This means that it’s almost always better to use a class instance variable instead.

This cop checks for places where custom logic on rejection nils from arrays and hashes can be replaced with {Array,Hash}#{compact,compact!}.

It is marked as unsafe by default because false positives may occur in the nil check of block arguments to the receiver object. For example, [[1, 2], [3, nil]].reject { |first, second| second.nil? } and [[1, 2], [3, nil]].compact are not compatible. This will work fine when the receiver is a hash object.

This cop enforces the use of consistent method names from the Enumerable module.

Unfortunately we cannot actually know if a method is from Enumerable or not (static analysis limitation), so this cop can yield some false positives.

You can customize the mapping from undesired method to desired method.

e.g. to use detect over find:

The default mapping for PreferredMethods behaves as follows.

This cop checks for class methods that are defined using the :: operator instead of the . operator.

This cop checks for places where multiple consecutive loops over the same data can be combined into a single loop. It is very likely that combining them will make the code more efficient and more concise.

It is marked as unsafe, because the first loop might modify a state that the second loop depends on; these two aren’t combinable.

This cop enforces using `` or %x around command literals.

This cop checks that comment annotation keywords are written according to guidelines.

This cop checks for comments put on the same line as some keywords. These keywords are: class, module, def, begin, end.

Note that some comments (:nodoc:, :yields:, rubocop:disable and rubocop:todo) are allowed.

Auto-correction removes comments from end keyword and keeps comments for class, module, def and begin above the keyword.

Check for if and case statements where each branch is used for assignment to the same variable when using the return of the condition can be used instead.

This cop checks that constants defined in classes and modules have an explicit visibility declaration. By default, Ruby makes all class- and module constants public, which litters the public API of the class or module. Explicitly declaring a visibility makes intent more clear, and prevents outside actors from touching private state.

Check that a copyright notice was given in each source file.

The default regexp for an acceptable copyright notice can be found in config/default.yml. The default can be changed as follows:

This regex string is treated as an unanchored regex. For each file that RuboCop scans, a comment that matches this regex must be found or an offense is reported.

This cop checks for consistent usage of the DateTime class over the Time class. This cop is disabled by default since these classes, although highly overlapping, have particularities that make them not replaceable in certain situations when dealing with multiple timezones and/or DST.

This cop checks for parentheses in the definition of a method, that does not take any arguments. Both instance and class/singleton methods are checked.

This cop checks for places where the #dir method can replace more complex constructs to retrieve a canonicalized absolute path to the current file.

Detects comments to enable/disable RuboCop. This is useful if want to make sure that every RuboCop error gets fixed and not quickly disabled with a comment.

Specific cops can be allowed with the AllowedCops configuration. Note that if this configuration is set, rubocop:disable all is still disallowed.

When using class_eval (or other eval) with string interpolation, add a comment block showing its appearance if interpolated (a practice used in Rails code).

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, constant definitions or constant visibility declarations.

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.

This cop checks for missing documentation comment for public methods. It can optionally be configured to also require documentation for non-public methods.

Detects double disable comments on one line. This is mostly to catch automatically generated comments that need to be regenerated.

This cop checks for uses of double negation (!!) to convert something to a boolean value.

When using EnforcedStyle: allowed_in_returns, allow double nagation in contexts that use boolean as a return value. When using EnforcedStyle: forbidden, double nagation should be forbidden always.

Please, note that when something is a boolean value !!something and !something.nil? are not the same thing. As you’re unlikely to write code that can accept values of any type this is rarely a problem in practice.

This cop checks for loops which iterate a constant number of times, using a Range literal and #each. This can be done more readably using Integer#times.

This check only applies if the block takes no parameters.

This cop looks for inject / reduce calls where the passed in object is returned at the end and so could be replaced by each_with_object without the need to return the object at the end.

However, we can’t replace with each_with_object if the accumulator parameter is assigned to within the block.

This cop checks for pipes for empty block parameters. Pipes for empty block parameters do not cause syntax errors, but they are redundant.

This cop checks for case statements with an empty condition.

Checks for empty else-clauses, possibly including comments and/or an explicit nil depending on the EnforcedStyle.

This cop checks for parentheses for empty lambda parameters. Parentheses for empty lambda parameters do not cause syntax errors, but they are redundant.

This cop checks for the use of a method, the result of which would be a literal, like an empty array, hash, or string.

This cop checks for the formatting of empty method definitions. By default it enforces empty method definitions to go on a single line (compact style), but it can be configured to enforce the end to go on its own line (expanded style).

This cop checks ensures source files have no utf-8 encoding comments.

This cop checks for END blocks.

This cop checks for endless methods.

It can enforce either the use of endless methods definitions for single-lined method bodies, or disallow endless methods.

Other method definition types are not considered by this cop.

The supported styles are: * allow_single_line (default) - only single line endless method definitions are allowed. * allow_always - all endless method definitions are allowed. * disallow - all endless method definitions are disallowed.

This cop ensures that eval methods (eval, instance_eval, class_eval and module_eval) are given filename and line number values (FILE and LINE). This data is used to ensure that any errors raised within the evaluated code will be given the correct identification in a backtrace.

The cop also checks that the line number given relative to LINE is correct.

This cop checks for places where Integer#even? or Integer#odd? can be used.

This cop checks for use of the File.expand_path arguments. Likewise, it also checks for the Pathname.new argument.

Contrastive bad case and good case are alternately shown in the following examples.

This cop enforces the use of explicit block argument to avoid writing block literal that just passes its arguments to another block.

This cop enforces consistency when using exponential notation for numbers in the code (eg 1.2e4). Different styles are supported: * scientific which enforces a mantissa between 1 (inclusive) and 10 (exclusive). * engineering which enforces the exponent to be a multiple of 3 and the mantissa to be between 0.1 (inclusive) and 10 (exclusive). * integral which enforces the mantissa to always be a whole number without trailing zeroes.

This cop checks for division with integers coerced to floats. It is recommended to either always use fdiv or coerce one side only. This cop also provides other options for code consistency.

This cop is marked as unsafe, because if operand variable is a string object then .to_f will be removed and an error will occur.

This cop looks for uses of the for keyword or each method. The preferred alternative is set in the EnforcedStyle configuration parameter. An each call with a block on a single line is always allowed.

This cop enforces the use of a single string formatting utility. Valid options include Kernel#format, Kernel#sprintf and String#%.

The detection of String#% cannot be implemented in a reliable manner for all cases, so only two scenarios are considered - if the first argument is a string literal and if the second argument is an array literal.

Use a consistent style for named format string tokens.

This cop can be customized ignored methods with IgnoredMethods.

It is allowed to contain unannotated token if the number of them is less than or equals to MaxUnannotatedPlaceholdersAllowed.

This cop is designed to help you transition from mutable string literals to frozen string literals. It will add the comment # frozen_string_literal: true to the top of files to enable frozen string literals. Frozen string literals may be default in future Ruby. The comment will be added below a shebang and encoding comment.

Note that the cop will ignore files where the comment exists but is set to false instead of true.

This cop enforces the use of $stdout/$stderr/$stdin instead of STDOUT/STDERR/STDIN. STDOUT/STDERR/STDIN are constants, and while you can actually reassign (possibly to redirect some stream) constants in Ruby, you’ll get an interpreter warning if you do so.

This cop 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.

Use a guard clause instead of wrapping the code inside a conditional expression

Checks for presence or absence of braces around hash literal as a last array item depending on configuration.

This cop checks for uses of each_key and each_value Hash methods.

This cop checks for usages of Hash#reject, Hash#select, and Hash#filter methods that can be replaced with Hash#except method.

This cop should only be enabled on Ruby version 3.0 or higher. (Hash#except was added in Ruby 3.0.)

For safe detection, it is limited to commonly used string and symbol comparisons when used ==. And do not check Hash#delete_if and Hash#keep_if to change receiver object.

This cop checks for places where case-when represents a simple 1:1 mapping and can be replaced with a hash lookup.

This cop checks hash literal syntax.

It can enforce either the use of the class hash rocket syntax or the use of the newer Ruby 1.9 syntax (when applicable).

A separate offense is registered for each problematic pair.

The supported styles are:

This cop looks for uses of .each_with_object({}) {…​}, .map {…​}.to_h, and Hash[_.map {…​}] that are actually just transforming the keys of a hash, and tries to use a simpler & faster call to transform_keys instead.

This can produce false positives if we are transforming an enumerable of key-value-like pairs that isn’t actually a hash, e.g.: [[k1, v1], [k2, v2], …​]

This cop should only be enabled on Ruby version 2.5 or newer (transform_keys was added in Ruby 2.5.)

This cop looks for uses of .each_with_object({}) {…​}, .map {…​}.to_h, and Hash[_.map {…​}] that are actually just transforming the values of a hash, and tries to use a simpler & faster call to transform_values instead.

This can produce false positives if we are transforming an enumerable of key-value-like pairs that isn’t actually a hash, e.g.: [[k1, v1], [k2, v2], …​]

This cop should only be enabled on Ruby version 2.4 or newer (transform_values was added in Ruby 2.4.)

This cop checks for identical expressions at the beginning or end of each branch of a conditional expression. Such expressions should normally be placed outside the conditional expression - before or after it.

If the else branch of a conditional consists solely of an if node, it can be combined with the else to become an elsif. This helps to keep the nesting level from getting too deep.

Checks for if and unless statements that would fit on one line if written as modifier if/unless. The cop also checks for modifier if/unless lines that exceed the maximum line length.

The maximum line length is configured in the Layout/LineLength cop. The tab size is configured in the IndentationWidth of the Layout/IndentationStyle cop.

Checks for if and unless statements used as modifiers of other if or unless statements.

This cop checks for redundant if with boolean literal branches. It checks only conditions to return boolean value (true or false) for safe detection. The conditions to be checked are comparison methods, predicate methods, and double negative. However, auto-correction is unsafe because there is no guarantee that all predicate methods will return boolean value. Those methods can be allowed with AllowedMethods config.

Checks for uses of semicolon in if statements.

This cop checks for raise or fail statements which do not specify an explicit exception class. (This raises a RuntimeError. Some projects might prefer to use exception classes which more precisely identify the nature of the error.)

Use Kernel#loop for infinite loops.

This cop is marked as unsafe as the rule does not necessarily apply if the body might raise a StopIteration exception; contrary to other infinite loops, Kernel#loop silently rescues that and returns nil.

This cop checks for trailing inline comments.

This cop check for usages of not (not or !) called on a method when an inverse of that method can be used instead. Methods that can be inverted by a not (not or !) should be defined in InverseMethods Methods that are inverted by inverting the return of the block that is passed to the method should be defined in InverseBlocks

This cop checks for hardcoded IP addresses, which can make code brittle. IP addresses are likely to need to be changed when code is deployed to a different server or environment, which may break a deployment if forgotten. Prefer setting IP addresses in ENV or other configuration.

This cop enforces that optional keyword parameters are placed at the end of the parameters list.

This improves readability, because when looking through the source, it is expected to find required parameters at the beginning of parameters list and optional parameters at the end.

This cop (by default) checks for uses of the lambda literal syntax for single line lambdas, and the method call syntax for multiline lambdas. It is configurable to enforce one of the styles for both single line and multiline lambdas as well.

This cop checks for use of the lambda.(args) syntax.

This cop checks for string literal concatenation at the end of a line.

This cop enforces the presence (default) or absence of parentheses in method calls containing parameters.

In the default style (require_parentheses), macro methods are ignored. Additional methods can be added to the IgnoredMethods or IgnoredPatterns list. These options are valid only in the default style. Macros can be included by either setting IgnoreMacros to false or adding specific macros to the IncludedMacros list.

Precedence of options is all follows:

eg. If a method is listed in both IncludedMacros and IgnoredMethods, then the latter takes precedence (that is, the method is ignored).

In the alternative style (omit_parentheses), there are three additional options.

This cop checks for unwanted parentheses in parameterless method calls.

This cop checks for methods called on a do…​end block. The point of this check is that it’s easy to miss the call tacked on to the block when reading code.

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

This cop does not consider endless methods, since parentheses are always required for them.

This cop checks for potential uses of Enumerable#minmax.

Checks for if expressions that do not have an else branch.

Supported styles are: if, case, both.

This cop checks for the presence of method_missing without also defining respond_to_missing?.

This cop checks for grouping of mixins in class and module bodies. By default it enforces mixins to be placed in separate declarations, but it can be configured to enforce grouping them in one declaration.

This cop checks that include, extend and prepend statements appear inside classes and modules, not at the top level, so as to not affect the behavior of Object.

This cop checks for use of extend self or module_function in a module.

Supported styles are: module_function, extend_self, forbidden.

In case there are private methods, the cop won’t be activated. Otherwise, it forces to change the flow of the default code.

The option forbidden prohibits the usage of both styles.

These offenses are not safe to auto-correct since there are different implications to each approach.

This cop checks for chaining of a block after another block that spans multiple lines.

Checks for uses of if/unless modifiers with multiple-lines bodies.

Checks for uses of the then keyword in multi-line if statements.

This cop checks expressions wrapping styles for multiline memoization.

This cop checks for method signatures that span multiple lines.

This cop checks for multi-line ternary op expressions.

This cop checks uses of the then keyword in multi-line when statements.

This cop checks against comparing a variable with multiple items, where Array#include?, Set#include? or a case could be used instead to avoid code repetition. It accepts comparisons of multiple method calls to avoid unnecessary method calls by default. It can be configured by AllowMethodComparison option.

This cop checks whether some constant value isn’t a mutable literal (e.g. array or hash).

Strict mode can be used to freeze all constants, rather than just literals. Strict mode is considered an experimental feature. It has not been updated with an exhaustive list of all methods that will produce frozen objects so there is a decent chance of getting some false positives. Luckily, there is no harm in freezing an already frozen object.

Checks for uses of if with a negated condition. Only ifs without else are considered. There are three different styles:

This cop checks for uses of if-else and ternary operators with a negated condition which can be simplified by inverting condition and swapping branches.

Checks for uses of unless with a negated condition. Only unless without else are considered. There are three different styles:

Checks for uses of while with a negated condition.

This cop checks for nested use of if, unless, while and until in their modifier form.

This cop checks for unparenthesized method calls in the argument list of a parenthesized method call.

This cop checks for nested ternary op expressions.

Use next to skip iteration instead of a condition at the end.

This cop checks for comparison of something with nil using == and nil?.

Supported styles are: predicate, comparison.