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.

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 (empty 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(===).

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 checks for uses of the class/module name instead of self, when defining class/module 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 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 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: begin, class, def, end, module.

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

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.

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 eval method usage. eval can receive source location metadata, that are filename and line number. The metadata is used by backtraces. This cop recommends to pass the metadata to eval method.

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 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 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 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 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

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

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 lines at the beginning or end of each branch of a conditional statement.

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.

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 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 (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 checks for the presence of method_missing without falling back on super.

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? could be used instead to avoid code repetition.

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:

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.

This cop checks for non-nil checks, which are usually redundant.

With IncludeSemanticChanges set to false by default, this cop does not report offenses for !x.nil? and does no changes that might change behavior.

With IncludeSemanticChanges set to true, this cop reports offenses for !x.nil? and autocorrects that and x != nil to solely x, which is usually OK, but might change behavior.

This cop checks for uses of the keyword not instead of !.

This cop checks for octal, hex, binary, and decimal literals using uppercase prefixes and corrects them to lowercase prefix or no prefix (in case of decimals).

This cop checks for big numeric literals without _ between groups of digits in them.

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 Integer polymorphic.

TODO: Make configurable. Checks for uses of if/then/else/end on a single line.

This cop checks for options hashes and discourages them if the current Ruby version supports keyword arguments.

This cop checks for optional arguments to methods that do not come at the end of the argument list.

This cop checks for potential usage of the ||= operator.

Checks for simple usages of parallel assignment. This will only complain when the number of variables being assigned matched the number of assigning variables.

This cop checks for the presence of superfluous parentheses around the condition of if/unless/while/until.

AllowSafeAssignment option for safe assignment. By safe assignment we mean putting parentheses around an assignment to indicate "I know I’m using an assignment as a condition. It’s not a mistake."

This cop enforces the consistent usage of %-literal delimiters.

Specify the 'default' key to set all preferred delimiters at once. You can continue to specify individual preferred delimiters to override the default.

This cop checks for usage of the %Q() syntax when %q() would do.

This cop looks for uses of Perl-style regexp match backreferences like $1, $2, etc.

This cop (by default) checks for uses of methods Hash#has_key? and Hash#has_value? where it enforces Hash#key? and Hash#value? It is configurable to enforce the inverse, using verbose method names also.

This cop checks for uses of Proc.new where Kernel#proc would be more appropriate.

This cop checks the args passed to fail and raise. For exploded style (default), it recommends passing the exception class and message to raise, rather than construct an instance of the error. It will still allow passing just a message, or the construction of an error with more than one argument.

The exploded style works identically, but with the addition that it will also suggest constructing error objects when the exception is passed multiple arguments.

This cop checks for the use of randomly generated numbers, added/subtracted with integer literals, as well as those with Integer#succ and Integer#pred methods. Prefer using ranges instead, as it clearly states the intentions.