Basically, it is written based on Rubocop-Rubydoc . There are also some quotes from RubyStyleGuide, and some examples that you wrote yourself.
=> GitHub
- 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.
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
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
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 )
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 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.
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編)
About
チャットメンバー募集
何か質問、悩み事、相談などあればLINEオープンチャットもご利用ください。