List of things that Rubocop will check (Style)

Basically, it is written based on [Rubocop-Rubydoc](http://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Style) . There are also some quotes from RubyStyleGuide, and some examples that you wrote yourself.

=\> [GitHub](https://github.com/bbatsov/rubocop)

- Please send an edit request if there is a request for addition because it is not completed. 

### AccessModifierIndentation 

Write private / protected / public in the same column as def.

     # bad class SomeClass private def private_method # ... end end # good class SomeClass private def private_method # ... end end 

### AccessorMethodName 

Setter should be named attribute = method. Let's get the getter method name attribute.

You do not need set\_ / get\_ at the beginning

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

(※ For simple setter / getter, use attr _accessor / attr_ reader / attr\_writer)

### Alias 

### AlignArray 

### AlignHash 

### AlignParameters 

### AndOr 

Let's replace and with &&. Let's replace or with ||.

and / or is not worth using.

[RubyStyleGuide](https://github.com/fortissimo1997/ruby-style-guide/blob/japanese/README.ja.md#no-and-or-or)

### ArrayJoin 

Do not use \* when doing Array # join. It is a mysterious writing. Write the join clearly.

     # 悪い例%w(one two three) * ', ' # => 'one, two, three' # 良い例%w(one two three).join(', ') # => 'one, two, three' 

(From Ruby Style Guide)

### AsciiComments 

### AssignmentInCondition 

Let's stop assigning in if. (It looks like a mistake in writing = =)

     # bad if x = 1 end 

### AsciiIdentifiers 

### Attr 

attr behaves differently depending on the ruby version. In Ruby 1.8 and earlier, the argument changes which of getter / setter is defined. Confusing.

Use attr _read / attr_ writer / attr\_accessor instead.

     # 例attr_accessor :getter_with_setter attr_reader :getter1, :getter2, :getter3 attr_writer :setter1, :setter2, :setter3 

[From RubyStyleGuide](https://github.com/fortissimo1997/ruby-style-guide/blob/japanese/README.ja.md#attr)

### BeginBlock 

### BlockComments 

Stop using block comments.

It depends on the editor, but it is not easy to distinguish between comments. After that, you can not put a space before = begin = end.

     # 悪い例== begin comment line another comment line == end # 良い例# comment line # another comment line 

[RubyStyleGuide](https://github.com/fortissimo1997/ruby-style-guide/blob/japanese/README.ja.md#no-block-comments)

### BlockNesting 

### Blocks 

### BracesAroundHashParameters 

### CaseEquality 

### CaseIndentation 

In case statements, if the indent of when is misaligned, it will be found. (case / when / end should all be written in the same column)

     # bad case when song.name == 'Misty' puts 'Not again!' when song.duration > 120 puts 'Too long!' when Time.now.hour > 21 puts "It's too late" else song.play end # good case when song.name == 'Misty' puts 'Not again!' when song.duration > 120 puts 'Too long!' when Time.now.hour > 21 puts "It's too late" else song.play end 

### CharacterLiteral 

### ClassAndModuleCamelCase 

### ClassAndModuleChildren 

### ClassLength 

### ClassMethods 

### ClassVars 

### CollectionMethods 

### ColonMethodCall 

### CommentAnnotation 

Write annotations in the correct format.

     # bad #FIXME Comment # good # FIXME: Comment 

### ConstantName 

### Cyclomatic Complexity 

### DefWithParentheses 

### DeprecatedHashMethods 

### Documentation 

### DotPosition 

### DoubleNegation 

### EmptyLineBetweenDefs 

### EmptyLines 

### EmptyLinesAroundAccessModifier 

### EmptyLinesAroundBody 

### EmptyLiteral 

When defining an empty literal.

Use [] instead of Array.new. Use {} instead of Hash.new. Use '' instead of String.new.

     some_array = [] some_hash = {} some_string = '' 

### Encoding 

### EndBlock 

### EndOfLine 

It will find any CR carriage returns (\ r) in the code.

### EvenOdd 

\<\<\<\<\<\<\< HEAD even? For even judgment.

# Use odd? For odd judgment. 

The judgment of the even-numbered `even?` A. Use `odd?` judgment.

> > > > > > > EDIT\_REQUEST

     # bad if x % 2 == 0 # good if x.even? 

### FileName 

### FinalNewline 

### FlipFlop 

### For 

### FormatString 

### GlobalVars 

Avoid using user-defined global variables. (Do not use anything other than the default

     # bad $ORIGINAL_PATH = '/path/to/user' puts $ORIGINAL_PATH # good puts $LOAD_PATH 

### GuardClause 

### HashSyntax 

Write a symbol in the new hash notation.

     # bad hash = { :kind => 'Apple' } # good hash = { kind: 'Apple' } 

### IfUnlessModifier 

### IfWithSemicolon 

### IndentArray 

### IndentHash 

### IndentationConsistency 

There is no contradiction in indent.

     def test puts 'hello' - puts 'world' + puts 'world' end 

### IndentationWidth 

Use two spaces for indenting.

     # bad def test puts 'hello' end # good def test puts 'hello' end 

### Lambda 

### LambdaCall 

### LeadingCommentSpace 

Place a space after the comment `#` . However, in the description for Rdoc, you may write it with spaces.

### MultilineIfThen 

You do not need then when you write conditional statements on multiple lines.

     # bad if cond then end # good if cond end # good if cond then a elsif cond then b end 

### SpaceBeforeBlockBraces 

Place a space in front of the braces.

     - expect{ subject } + expect { subject } 

### MultilineTernaryOperator 

Do not write ternary operators on multiple lines. In that case, use if or unless.

     # bad true ? yes : no # good true ? yes : no # good if true yes else no end 

### LineEndConcatenation 

Use \ to concatenate at the end of a line.

     # bad some_str = 'ala' + 'bala' some_str = 'ala' << 'bala' # good some_str = 'ala' \ 'bala' 

### LineLength 

### MethodCallParentheses 

### MethodCalledOnDoEndBlock 

### MethodDef Parentheses 

When defining a method. If the method does not receive any parameters, omit the parentheses.

     # bad def some_method() # body omitted end # good def some_method # body omitted end # bad def some_method_with_parameters param1, param2 # body omitted end # good def some_method_with_parameters(param1, param2) # body omitted end 

### MethodLength 

### MethodName 

Method name should be snake\_case.

     # bad def ExampleMethod end # good def example_method end 

Depending on the setting, it can be aligned with camelCase.

### ModuleFunction 

### MultilineBlockChain 

### MultilineIfThen 

### MultilineTernaryOperator 

### NegatedIf 

### NegatedWhile 

### NestedTernaryOperator 

### NilComparison 

### NonNilCheck 

Have you judged "non-nil" redundantly?

     # bad if x != nil if !x.nil? # good if x 

However, if it describes as the last clause, it is OK.

     # good def signed_in? !current_user.nil? end 

### Not 

### NumericLiterals 

### OneLineConditional 

### OpMethod 

### ParameterLists 

### ParenthesesAroundCondition 

If you can omit the parentheses in the conditional statement, try it.

     # bad if (a && b) end # good if a && b end # good if (a && b) || c end 

### PercentLiteralDelimiters 

### PerlBackrefs 

### PredicateName 

Prefixes such as has / have / is are not required at the beginning of method names.

     # bad def is_even?(value) ... # good def even?(value) # bad def has_value? ... # good def value? ... 

### Proc 

### Raiseargs 

### RedundantBegin 

> If exception handling is performed on the entire method definition, begin and end can be omitted ( [reference](http://blog.livedoor.jp/sasata299/archives/51338814.html) )

I will omit it.

     def redundant begin ala bala rescue StandardError => e something end end def preferred ala bala rescue StandardError => e something end 

### RedundantException (half-finished exception) 

The class name can be omitted if a RuntimeError occurs. (Because the default of raise / fail is RuntimeError)

     # bad raise RuntimeError, 'message' # good - signals a RuntimeError by default raise 'message' 

RedundantException

### RedundantReturn 

Let's stop the redundant return.

     # maybe bad def test return something end # maybe good def test something end 

### RescueEnsureAlignment 

Write begin / rescue / end all in the same column.

     # bad begin something rescue puts 'error' end # good begin something rescue puts 'error' end 

### RedundantSelf 

### RegexpLiteral 

See [RuboCop | Style / RegexpLiteral-Qiita](http://qiita.com/tbpgr/items/8b54723cc5ee77f6cbf2) for details.

The setting operation changes the judgment operation. The options are slashes (default) / percent\_r / mixed.

     #例： Style/RegexpLiteral: EnforcedStyle: percent_r 

     # EnforcedStyle の設定が slashes / mixed の場合は良い。 percent_r の場合は悪い。 snake_case = /^[\dA-Z_]+$/ # EnforcedStyle の設定が percent_r の場合は良い。 slashes / mixed の場合は悪い。 snake_case = %r{^[\dA-Z_]+$} # EnforcedStyle の設定が slashes の場合は良い。 percent_r / mixed の場合は悪い。 regex = / foo (bar) (baz) /x # EnforcedStyle の設定が percent_r / mixed の場合は良い。 slashes の場合は悪い。 regex = %r{ foo (bar) (baz) }x # スラッシュ記法の中でスラッシュを使わないこと。 # AllowInnerSlashes の設定を true にしていれば警告しない。 x =~ /home\// 

### RescueModifier 

### SelfAssignment 

If the variable deals with itself, write it concisely.

     # bad x = x + 1 # good x += 1 

### Semicolon 

### SignalException 

### SingleLineBlockParams 

### SingleLineMethods 

Do not define a method on one line.

     # bad def method; nil; end # good def method nil end 

However, it can optionally be allowed only if there is no method body.

### SingleSpaceBeforeFirstArg 

### SpaceAfterColon 

In some cases, put a space after the semicolon.

     # bad x = 1;y = 2 # good x = 1; y = 2 

### SpaceAroundBlockParameters 

Leave a space outside the block parameter. Conversely, try not to put it inside.

     # bad hash.map! {|k, v|v } # bad hash.map { | k, v | v } # good hash.map { |k, v| v } 

### SpaceAfterComma 

Place a space after the commas (of several types).

     #bad ['Apple','Banana','Strawberry'] #good ['Apple', 'Banana', 'Strawberry'] 

### SpaceAfterControlKeyword 

When writing in one line. Place a space after if / unless etc.

     # bad if(a && b) || c then result end # good_ if (a && b) || c then result end 

### SpaceAfterMethodName 

When defining a method. Do not leave a space between method names and parentheses.

     # bad def func (x) end # good def func(x) end 

### SpaceAfterNot (Space after!) 

Do not leave a space after!

     # bad ! something # good !something 

### SpaceAfterSemicolon 

When writing multiple expressions on one line. Place a space after the semicolon.

     # bad x = 1;y = 2; # good x = 1; y = 2; 

### SpaceAroundEqualsInParameterDefault 

When deciding the initial value of the argument. Leave a space around the equal.

     # bad def example(value='') end # good def example(value = '') end 

### SpaceAroundOperators (space around operators) 

Put a space around the operator.

     # bad x=1+1 # bad x = 1 + 1 # good x = 1 + 1 

However, \*\* (squares) should not have space.

     # bad x = 2 **3 # good x = 2** 3 

### SpaceBeforeBlockBraces 

Place a space before the block braces.

     # bad (1..10).each{ |i| i } # good (1..10).each { |i| i } 

### SpaceBeforeComment 

Place a space before the end of line comment.

     # bad method# Comment # good method # Comment 

### SpaceBeforeModifierKeyword 

Put a space in front of if / unless etc. behind.

     # bad result if(a && b) || c # good result if (a && b) || c 

### SpaceInsideBlockBraces 

Place a space inside the block braces.

     # bad (1..10).each {|i| i} # good (1..10).each { |i| i } 

### SpaceInside Brackets 

### SpaceInsideHashLiteralBraces 

In hash notation, put a space inside the braces.

     # bad furuits = {apple: 10, banana: 20} # good furuits = { apple: 10, banana: 20 } 

### SpaceInsideParens 

Don't put a space inside the brackets.

     # bad some( arg ).other [1, 2, 3].size # good some(arg).other [1, 2, 3].size 

### SpaceInsideRangeLiteral 

Spaces are not required inside range literals.

     # bad 1 .. 3 # good 1..3 # bad 'a' .. 'z' # good 'a'..'z' 

### SpecialGlobalVars 

Do not write superglobal variables in Perl style. Instead, write in the style of the one whose meaning is clear.

Control chart:

     $: => $LOAD_PATH $" => $LOADED_FEATURES $0 => $PROGRAM_NAME $! => $ERROR_INFO $@ => $ERROR_POSITION $; => $FIELD_SEPARATOR / $FS $, => $OUTPUT_FIELD_SEPARATOR / $OFS $/ => $INPUT_RECORD_SEPARATOR / $RS $\\ => $OUTPUT_RECORD_SEPARATOR / $ORS $. => $INPUT_LINE_NUMBER / $NR $_ => $LAST_READ_LINE $> => $DEFAULT_OUTPUT $< => $DEFAULT_INPUT $$ => $PROCESS_ID / $PID $? => $CHILD_STATUS $~ => $LAST_MATCH_INFO $= => $IGNORECASE $* => $ARGV => / => ARGV $& => $MATCH $` => $PREMATCH $\' => $POSTMATCH $+ => $LAST_PAREN_MATCH 

### StringLiterals 

### SymbolArray 

### SymbolLiteral 

Do not write symbols that are like letter definitions.

     # bad :symbol" # good :symbol 

### Tab 

Try not to use tabs (\ t).

(\* Note ... In the programming world, blank space alignment is more mainstream than tab alignment)

### SymbolProc 

If you can replace proc with symbol notation, do so.

     # bad something.map { |s| s.upcase } # good something.map(&:upcase) 

### TrailingBlankLines 

Don't put an empty line at the end of the file.

### Trailing Comma 

### TrailingWhitespace 

It finds the space at the end of the line.

### TrailingUnderscoreVariable 

Do not end variables with underscores.

     # maybe bad x_ = 1 

### TrivialAccessors 

`attr_xxx` common setter / getter methods with `attr_xxx` .

     # bad class Foo def example=(value) @example = value end def example @example end end # good class Foo attr_accessor :example end 

### Unlesselse 

### VariableInterpolation 

### VariableName 

Write variables in snake\_case.

     # bad someVar = 5 # good some_var = 5 

→ [You can unify it into camelCase depending on the setting.](http://qiita.com/tbpgr/items/0cc717be54a66ff3057d)

### WhenThen 

Do not use semicolons in when then expressions. use then.

     # bad when x; apple # good when x then apple 

### WhileUntilDo 

It finds out where do is used in multiple lines of while / until.

     # bad while x > 5 do # body omitted end until x > 5 do # body omitted end # good while x > 5 # body omitted end until x > 5 # body omitted end 

### WhileUntilModifier 

### WordArray 

## Metrics 

### ParameterLists 

In the method definition. Try not to add too many types of arguments.

     # bad class Example def some_method(argument1, argument2, argument3, argument4, argument5, argument6) end end 

The number of warnings can be changed by setting.



# Original by
[Rubocop がチェックしてくれるもの一覧表 (Style編)](https://qiita.com/Yinaura/items/9928e32fa9fc9092f24c)

# About

[About this translattion](https://qiita.com/YumaInaura/items/7f6fd1e9310a6816469a)








<!-- Update From Qiita API -->

# チャットメンバー募集


何か質問、悩み事、相談などあればLINEオープンチャットもご利用ください。

https://line.me/ti/g2/eEPltQ6Tzh3pYAZV8JXKZqc7PJ6L0rpm573dcQ





# Twitter


https://twitter.com/YumaInaura


<!-- Update From Qiita API -->