[RuboCop]解析ルールまとめ(翻訳・サンプル付き)

# RuboCopとは
コーディング規約に準拠しているかどうかをチェックしてくれるRubyの静的解析ライブラリです。
要約すると、命名規則、インデントレベル、スペース位置、ロジックの複雑度 等の観点でコードを監査し、違反箇所を出力してくれます。
RuboCopは、[Rubyスタイルガイド](https://github.com/fortissimo1997/ruby-style-guide/blob/japanese/README.ja.md)の記載内容がデフォルトで解析ルールに適用されています。


# 前提
RuboCopは[v0.7.8時点](https://github.com/rubocop-hq/rubocop/tree/v0.78.0)の[default.yml](https://github.com/rubocop-hq/rubocop/blob/v0.78.0/config/default.yml)をまとめています。
文章だけで説明が事足りると判断した場合はサンプルコードを添付していません。

# 更新履歴

**※現在更新中※**

- 2020年2月1日(土) Layout編/Lint編を追記

---

# Layout編

どのプログラム言語でも下記のような問題があると思う。
ここでは主にプログラムの書式に関する解析が行われる。

- スペースの有無
- インデントレベル
- 改行位置
- タブ文字の有無
- 記述順序

この辺りで特に良いと思うのは、Space有り無し論争に終止符を打てる設定です。
※Layout/SpaceでGrepすると周辺の設定が出てくると思います。(Layout/SpaceAroundOperatorsとか)

## Layout/AccessModifierIndentation

アクセス修飾子（特定のメソッドに適用されない修飾子）は、構成に応じて、メソッド定義ほど深く、またはclass / moduleキーワードほど深くインデントする必要があります。

```ruby
# bad
class Plumbus
private
  def smooth; end
end

# good
class Plumbus
  private
  def smooth; end
end
```

## Layout/ArrayAlignment

複数行の配列の要素の記述を確認します。

```ruby
# bad
a = [1, 2, 3,
  4, 5, 6]
array = ['run',
     'forrest',
     'run']

# good
a = [1, 2, 3,
     4, 5, 6]
a = ['run',
     'forrest',
     'run']
```

## Layout/ArgumentAlignment

 複数行のメソッド定義の引数が揃っているかどうかを確認します。

```ruby
# good

foo :bar,
    :baz

foo(
  :bar,
  :baz
)

# bad

foo :bar,
  :baz

foo(
  :bar,
    :baz
)
```

## Layout/AssignmentIndentation

複数行の割り当ての右側の最初の行のインデントをチェックします。
残りの行のインデントは、「IndentationConsistency」や「EndAlignment」などの他の警官で修正できます。

```ruby
# bad
value =
if foo
  'bar'
end

# good
value =
  if foo
    'bar'
  end
```

## Layout/BlockAlignment

do endブロックに対してendキーワードが適切に配置されているかどうかをチェックします。
`EnforcedStyleAlignWith`設定パラメーターによって3つのモードがサポートされています。

- `start_of_block`：` end`は `do`が現れた行の先頭に揃えられます。
- `start_of_line`：` end`は、式が始まった行の先頭に揃えられます。
- `either`（これがデフォルトです）：` end`はどちらの場所にあってもかまいません。autofixerはデフォルトで `start_of_line`になります。

```ruby
# bad

foo.bar
   .each do
     baz
       end

# good

variable = lambda do |i|
  i
end
```

## Layout/BlockEndNewline

do..endブロックのendステートメントが独自の行にあるかどうかをチェックします。

```ruby
# bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}
```

## Layout/ClassStructure

コードスタイルが`ExpectedOrder`に設定した構成に従っているかどうかを確認します。
`Categories` の設定を利用するとマクロ名をカテゴリにマッピングできます。

- モジュールの包含（include、prepend、extend）
- 定数
- 関連付け（has_one、has_many）
- パブリック属性マクロ（attr_accessor、attr_writer、attr_reader）
- その他のマクロ(validates, validate)
- パブリッククラスメソッド
- イニシャライザー
- パブリックインスタンスメソッド
- 保護された属性マクロ（attr_accessor、attr_writer、attr_reader）
- 保護されたインスタンスメソッド
- プライベート属性マクロ（attr_accessor、attr_writer、attr_reader）
- プライベートインスタンスメソッド

サンプルYML設定
※上から順番にスタイルチェックを実施します。


```YML
# .rubocop.yml
Layout/ClassStructure:
  ExpectedOrder:
    - module_inclusion
    - constants
    - association
    - public_attribute_macros
    - public_delegate
    - macros
    - public_class_methods
    - initializer
    - public_methods
    - protected_attribute_macros
    - protected_methods
    - private_attribute_macros
    - private_delegate
    - private_methods
```

Bad Goodのサンプルは割愛します。

## Layout/ClosingHeredocIndentation

ヒアドキュメントのクロージングのインデントをチェックします。

```ruby
# bad
class Foo
  def bar
    <<~SQL
      'Hi'
  SQL
  end
end

# good
class Foo
  def bar
    <<~SQL
      'Hi'
    SQL
  end
end
```

## Layout/ClosingParenthesisIndentation

メソッド呼び出し、メソッド定義、およびグループ化された式で閉じ括弧をぶら下げているインデントをチェックします。ぶら下がり閉じ括弧は`)`、改行が先行することを意味します。

```ruby
# good: when x is on its own line, indent this way
func(
  x,
  y
)

# good: when x follows opening parenthesis, align parentheses
a = b * (x +
         y
        )

# bad
def func(
  x,
  y
  )
```

## Layout/CommentIndentation

コメントのインデントをチェックします。

```ruby
# bad
  # comment here
def method_name
end

  # comment here
a = 'hello'

# yet another comment
  if true
    true
  end

# good
# comment here
def method_name
end

# comment here
a = 'hello'

# yet another comment
if true
  true
end
```

## Layout/ConditionPosition

if / while / untilが同じ行にない条件をチェックします。

```ruby
# bad
if
  some_condition
  do_something
end

# good
if some_condition
  do_something
end
```

## Layout/DefEndAlignment

メソッド定義の終了キーワードが適切に調整されているかどうかをチェックします。

```ruby
# bad

private def foo
            end

# good

private def foo
end
```

## Layout/DotPosition

複数行のメソッドチェーンの位置 `.` の位置をチェックします。

```ruby
# bad
something.
  method

# good
something
  .method
```

## Layout/ElseAlignment

else(elsif)の記述位置をチェックします。

```ruby
# bad
if something
  code
 elsif something
  code
end

# good
if something
  code
else
  code
end
```

## Layout/EmptyComment

空のコメントをチェックします。

```ruby
# bad

#
class Foo
end

# good

#
# Description of `Foo` class.
#
class Foo
end
```

## Layout/EmptyLineAfterGuardClause

ガード節の後に空行を強制します。

```ruby
# bad
def foo
  return if need_return?
  bar
end

# good
def foo
  return if need_return?

  bar
end

# good
def foo
  return if something?
  return if something_different?

  bar
end

# also good
def foo
  if something?
    do_something
    return if need_return?
  end
end
```

## Layout/EmptyLineAfterMagicComment

マジックコメントの後の改行をチェックします。

```ruby
# good
# frozen_string_literal: true

# Some documentation for Person
class Person
  # Some code
end

# bad
# frozen_string_literal: true
# Some documentation for Person
class Person
  # Some code
end
```

## Layout/EmptyLineBetweenDefs

メソッド定義が1つの空行で区切られているかどうかをチェックします。

```ruby
# bad
def a
end
def b
end

# good
def a
end

def b
end
```

## Layout/EmptyLines

2つ以上の連続した空行をチェックします。

```ruby
# bad - It has two empty lines.
some_method# one empty line
# two empty lines

some_method

# good
some_method# one empty line

some_method
```

## Layout/EmptyLinesAroundAccessModifier

アクセス修飾子は空白行で囲む必要があります。

```ruby
# bad
class Foo
  def bar; end
  private
  def baz; end
end

# good
class Foo
  def bar; end

  private

  def baz; end
end
```

## Layout/EmptyLinesAroundArguments

メソッド呼び出しの引数の周りに空行が存在するかどうかをチェックします。

## Layout/EmptyLinesAroundBeginBody

begin-endブロックの本体の周りに空の行が存在するかどうかをチェックします。

## Layout/EmptyLinesAroundBlockBody

ブロックの本体の周りの空行が構成に一致するかどうかをチェックします。

```ruby
# good

foo do |bar|
  # ...
end
```

## Layout/EmptyLinesAroundClassBody

クラスの本体の周りの空の行が構成に一致するかどうかをチェックします。

```ruby
# good

class Foo
  def bar    # ...

  end
end
```

## Layout/EmptyLinesAroundExceptionHandlingKeywords

「begin」セクションの本文の周りに空の行が存在するかどうかをチェックします。 `begin`の開始/終了およびメソッド定義ボディの周りの空行をチェックしません。

## Layout/EmptyLinesAroundMethodBody

メソッドの本体の周りに空の行が存在するかどうかをチェックします。

## Layout/EmptyLinesAroundModuleBody

モジュールの本体の周りの空の行が構成と一致するかどうかを確認します。

## Layout/EndAlignment

終了キーワードが適切に配置されているかどうかをチェックします。
`EnforcedStyleAlignWith`設定パラメーターによって3つのモードがサポートされています：

- `keyword`（デフォルト）に設定されている場合、endはキーワード（if、classなど）の先頭に揃えられます。
- `variable`に設定されている場合、「end」は、変数の割り当てがある場合、その左辺に揃えられます。
- `start_of_line`に設定されている場合、「end」は一致するキーワードが現れる行の先頭に揃えられます。

```ruby
# bad

variable = if true
    end

# good

variable = if true
           end

variable =
  if true
  end
```

## Layout/EndOfLine

ソースコードの「Windowsスタイルの行末(CRLF)」をチェックします。

## Layout/ExtraSpacing

余分な/不要な空白をチェックします。

```ruby
# good if AllowForAlignment is true
name      = "RuboCop"
# Some comment and an empty line

website  += "/rubocop-hq/rubocop" unless cond
puts        "rubocop"          if     debug

# bad for any configuration
set_app("RuboCop")
website  = "https://github.com/rubocop-hq/rubocop"

# good only if AllowBeforeTrailingComments is true
object.method(arg)  # this is a comment

# good even if AllowBeforeTrailingComments is false or not set
object.method(arg) # this is a comment

# good with either AllowBeforeTrailingComments or AllowForAlignment
object.method(arg)         # this is a comment
another_object.method(arg) # this is another comment
some_object.method(arg)    # this is some comment
```

## Layout/FirstArgumentIndentation

メソッド呼び出しの最初の引数のインデントをチェックします。
最初の引数の後の引数は、この設定ではなく、Layout/ArgumentAlignmentによってチェックされます。

## Layout/FirstArrayElementIndentation

開きかっこと最初の要素が別々の行にある配列リテラルの最初の要素のインデントをチェックします。他の要素のインデントは、ArrayAlignmentによって処理されます。

デフォルトでは、括弧付きのメソッド呼び出しの引数であり、配列の開き角括弧がメソッド呼び出しの開き括弧と同じ行にある配列リテラルは、最初の要素を1レベル深く（2スペース）インデントします。

```ruby
#bad
array = [
  :value
]
and_in_a_method_call([
  :no_difference
                     ])

#good
array = [
  :value
]
but_in_a_method_call([
                       :its_like_this
                     ])
```

## Layout/FirstArrayElementLineBreak

複数行の配列の最初の要素の前で改行をチェックします。

```ruby
# bad
[ :a,
  :b]

# good
[
  :a,
  :b]
```

## Layout/FirstHashElementIndentation

`{`と最初のキーが別々の行にあるハッシュリテラルの最初のキーのインデントをチェックします。

デフォルトでは、括弧付きのメソッド呼び出しの引数であり、ハッシュの左中括弧がメソッド呼び出しの左括弧と同じ行にあるハッシュリテラルの最初のキーは、1ステップ深く（2スペース）インデントされます。

```ruby

# bad
hash = {
  key: :value
}
and_in_a_method_call({
  no: :difference
                     })

# good
special_inside_parentheses
hash = {
  key: :value
}
but_in_a_method_call({
                       its_like: :this
                     })
```

## Layout/FirstHashElementLineBreak

複数行のハッシュの「最初の要素の前で」改行をチェックします。

```ruby
# bad
{ a: 1,
  b: 2}

# good
{
  a: 1,
  b: 2 }
```

## Layout/FirstMethodArgumentLineBreak

複数行のメソッド呼び出しの最初の引数の前で改行をチェックします。

```ruby
# bad
method(foo, bar,
  baz)

# good
method(
  foo, bar,
  baz)

# ignored
method foo, bar,
  baz
```

## Layout/FirstMethodParameterLineBreak

複数行メソッドのパラメーター定義の最初のパラメーターの前に改行があるかどうかをチェックします。

## Layout/FirstParameterIndentation

メソッド定義の最初のパラメーターのインデントをチェックします。最初のパラメーターの後のパラメーターは、この警官ではなく、Layout / ParameterAlignmentによってチェックされます。

## Layout/HashAlignment

複数行のハッシュリテラルのキー、区切り文字、および値が構成に従って配置されていることを確認します。設定オプションは次のとおりです。

- key (左揃えキー、ハッシュロケットと値の前の1スペース)

```
  #   a: 0
  #   bb: 1
```
- separator (ハッシュロケットとコロンを揃え、キーを右揃え)

```
  #    a: 0
  #   bb: 1
```

- table (左揃えキー、ハッシュロケット、および値)

```
  #   a:  0
  #   bb: 1
```

## Layout/HeredocArgumentClosingParenthesis

引数としてHEREDOC文字列を渡すメソッド呼び出しで右括弧の配置を確認します。HEREDOC開始タグを含む行の最後に配置する必要があります。

## Layout/HeredocIndentation

ヒアドキュメント本体のインデントをチェックします。ボディは1ステップインデントされます。Ruby 2.3以降では、波線のあるheredocs（ `<<~`）を使用する必要があります。

```ruby
# bad
<<-RUBY
something
RUBY

# good
# When EnforcedStyle is squiggly, bad code is auto-corrected to the
# following code.
<<~RUBY
  something
RUBY
```

## Layout/IndentationConsistency

一貫性のないインデントをチェックします。
設定オプション：
`EnforcedStyle：normal` (デフォルト)
`EnforcedStyle：indented_internal_methods`

「indented_internal_methods」と「normal」の違いは、
「normal」では、クラスおよびモジュールで「protected」および「private」修飾子キーワードがパブリックメソッドと同じインデントレベルにあること。「indented_internal_methods」protectedおよびprivateメンバーが1レベル深くインデントされていること。
それ以外は、両方のスタイルは、同じ論理的な深さのエンティティが同じインデントを持つことを意味します。

## Layout/IndentationWidth

「半角スペース2個」を使用しないインデントをチェックします。

## Layout/InitialIndentation

ファイル内の最初のコメント行のインデントをチェックします。

## Layout/LeadingCommentSpace

コメントの開始を示す「#」の後にコメントの先頭にスペースがあるかどうかをチェックします。`#++`、 `#–`、`#：nodoc`、 `= begin`-および` = end`コメント、「shebang」ディレクティブ、ラックアップオプションなど、一部のRDoc特殊構文には先頭のスペースは不要です。

## Layout/LeadingEmptyLines

ファイルの先頭にある不要な先頭の空白行をチェックします。

## Layout/LineLength

ソースコードの行の長さをチェックします。(デフォルト：80文字）

## Layout/MultilineArrayBraceLayout

配列リテラルの右中括弧が最後の配列要素と同じ行または新しい行にあることを確認します。

`symmetric`（デフォルト）スタイルを使用する場合：

配列の開き括弧が配列の最初の要素と同じ行にある場合、閉じ括弧は配列の最後の要素と同じ行になければなりません。

配列の開き括弧が配列の最初の要素の上の行にある場合、閉じ括弧は配列の最後の要素の下の行になければなりません。

`new_line`スタイルを使用する場合：

複数行配列リテラルの右中括弧は、配列の最後の要素の後の行になければなりません。

`same_line`スタイルを使用する場合：

複数行配列リテラルの右中括弧は、配列の最後の要素と同じ行になければなりません。

```ruby
# bad
[ :a,
  :b
]

# bad
[
  :a,
  :b ]

# good
[ :a,
  :b ]

# good
[
  :a,
  :b
]
```

## Layout/MultilineArrayLineBreaks

複数行の配列の要素が別々の行で記述されるようにします。

```ruby
# bad
[
  a, b,
  c
]

# good
[
  a,
  b,
  c
]
```

## Layout/MultilineAssignmentLayout

複数行の代入演算子の後に改行があるかどうかをチェックします。

```ruby
# bad
foo = if expression
  'bar'
end

# good
foo =
  if expression
    'bar'
  end

# good
foo =
  begin
    compute
  rescue => e
    nil
  end
```

## Layout/MultilineBlockLayout

ブロックの開始後に複数行のdo endブロックに改行があるかどうかをチェックします。さらに、ブロック引数がある場合、ブロックの開始と同じ行にあるかどうかをチェックします。
それ以外の場合は行全体が長すぎるため、ブロック引数を別々の行に置くことは受け入れられます。

```ruby
# bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

# good
blah { |
  long_list,
  of_parameters,
  that_would_not,
  fit_on_one_line
|
  foo(i)
  bar(i)
}
```

## Layout/MultilineHashBraceLayout

ハッシュリテラルの右中括弧が最後のハッシュ要素と同じ行にあるか、新しい行にあるかをチェックします。

`symmetric`（デフォルト）スタイルを使用する場合：

ハッシュの開き括弧がハッシュの最初の要素と同じ行にある場合、閉じ括弧はハッシュの最後の要素と同じ行になければなりません。

ハッシュの左中括弧がハッシュの最初の要素の上の行にある場合、右中括弧はハッシュの最後の要素の下の行にあるはずです。

`new_line`スタイルを使用する場合：

複数行のハッシュリテラルの右中括弧は、ハッシュの最後の要素の後の行になければなりません。

`same_line`スタイルを使用する場合：

複数行のハッシュリテラルの右中括弧は、ハッシュの最後の要素と同じ行になければなりません。


```ruby
# bad
{ a: 1,
  b: 2
}# bad

{
  a: 1,
  b: 2 }

# good
{ a: 1,
  b: 2 }

# good
{
  a: 1,
  b: 2
}
```

## Layout/MultilineHashKeyLineBreaks

複数行のハッシュの各キーが別々の行で開始されるようにします。

## Layout/MultilineMethodArgumentLineBreaks

複数行のメソッド呼び出しの各引数が別々の行で開始されるようにします。

## Layout/MultilineMethodCallBraceLayout

メソッド呼び出しの右中括弧が最後のメソッド引数と同じ行にあるか、新しい行にあるかをチェックします。

```ruby
# bad
foo(a,
  b
)

# bad
foo(
  a,
  b)

# good
foo(a,
  b)

# good
foo(
  a,
  b
)
```

## Layout/MultilineMethodCallIndentation

複数行にわたるメソッド呼び出しのメソッド名部分のインデントをチェックします。

```ruby

# bad
while myvariable
.b  # do something

end

# good
while myvariable
      .b  # do something

end

# good
Thing.a
     .b
     .c
```

## Layout/MultilineMethodDefinitionBraceLayout

メソッド定義の右中括弧が最後のメソッド引数と同じ行にあるか、新しい行にあるかをチェックします。

## Layout/MultilineOperationIndentation

複数行にわたるバイナリ演算で右側のオペランドのインデントをチェックします。

```ruby
# bad
if a +
    b
  something
end

# good
if a +
   b
  something
end
```

## Layout/ParameterAlignment

複数行のメソッド呼び出しまたは定義のパラメーターのインデントが揃っているかどうかを確認します。

## Layout/RescueEnsureAlignment

rescueのインデントをチェックします。

```ruby

# bad
begin
  something
  rescue
  puts 'error'
end

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

## Layout/SpaceAfterColon

コロン`:`の後に、スペースがあることを確認します。
三項演算子の後のスペースは処理せず、代わりにLayout/SpaceAroundOperatorsによって処理されます。

```ruby
# bad
def f(a:, b:2); {a:3}; end

# good
def f(a:, b: 2); {a: 3}; end
```

## Layout/SpaceAfterComma

コンマ`,`の後に、スペースがあることを確認します。

```ruby
# bad
[1,2]
{ foo:bar,}

# good
[1, 2]
{ foo:bar, }
```

## Layout/SpaceAfterMethodName

メソッド名とdefのスペースをチェックします。

```ruby
# bad
def func (x) end
def method= (y) end

# good
def func(x) end
def method=(y) end
```

## Layout/SpaceAfterNot

`!`の後のスペースがないことをチェックします。

```ruby
# bad
! something

# good
!something
```

## Layout/SpaceAfterSemicolon

セミコロン`;`の後に、スペースがあることを確認します。

## Layout/SpaceAroundBlockParameters

ブロックパラメータ`||`の内側と後の間隔をチェックします。
パラメータパイプ内の改行は「Layout/MultilineBlockLayout」によってチェックされます。

```ruby
# bad
{}.each { | x,  y |puts x }
->( x,  y ) { puts x }

# good
{}.each { |x, y| puts x }
->(x, y) { puts x }
```

## Layout/SpaceAroundEqualsInParameterDefault

メソッドのデフォルト引数の`=`に、スペースがあるかどうかを確認します。（no_spaceがおすすめ）

```ruby
# EnforcedStyle: space (default)
# bad
def some_method(arg1=:default, arg2=nil, arg3=[])
  # do something...
end

# good
def some_method(arg1 = :default, arg2 = nil, arg3 = [])
  # do something...
end

# EnforcedStyle: no_space
# bad
def some_method(arg1 = :default, arg2 = nil, arg3 = [])
  # do something...
end

# good
def some_method(arg1=:default, arg2=nil, arg3=[])
  # do something...
end
```

## Layout/SpaceAroundKeyword

キーワードの周囲の間隔を確認します。

```ruby

# bad
something 'test'do|x|
end

while(something)
end

something = 123if test

# good
something 'test' do |x|
end

while (something)
end

something = 123 if test
```

## Layout/SpaceAroundOperators

演算子の周りにスペースがあることを確認します。
※`**`はチェックから除外されます。

```ruby
# bad
total = 3*4
"apple"+"juice"
my_number = 38/4

# good
total = 3 * 4
"apple" + "juice"
my_number = 38 / 4
```

## Layout/SpaceBeforeBlockBraces

ブロックを記述する場合、`{` にスペースがあるかどうかを確認します。

```ruby
# bad
foo.map{ |a|
  a.bar.to_s
}

# good
foo.map { |a|
  a.bar.to_s
}
```

## Layout/SpaceBeforeComma

コンマ`,`の前にスペースがないことをチェックします。

```ruby
# bad
[1 , 2 , 3]
a(1 , 2)
each { |a , b| }

# good
[1, 2, 3]
a(1, 2)
each { |a, b| }
```

## Layout/SpaceBeforeComment

コメント`#`とコードの間にスペースがないことを確認します。

```ruby
# bad
1 + 1# this operation does ...

# good
1 + 1 # this operation does ...`
```

## Layout/SpaceBeforeFirstArg

カッコなしのメソッド呼び出しの最初の引数の間にスペースが1つだけ使用されていることを確認します。

または、AllowForAlignment構成パラメーターがtrueの場合、引数を前後の行の何かに揃えるために余分なスペースを追加できます。

```ruby
# bad
something  x
something   y, z
something'hello'

# good
something x
something y, z
something 'hello'
```

## Layout/SpaceBeforeSemicolon

セミコロン`;`の前のスペースをチェックします。

```ruby
# bad
x = 1 ; y = 2

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

## Layout/SpaceInLambdaLiteral

 `->`とLambdaリテラルの開始パラメーター括弧`(`の間のスペースをチェックします。

```ruby
# EnforcedStyle：require_no_space（デフォルト）
# bad
a = -> (x, y) { x + y }

# good
a = ->(x, y) { x + y }

# EnforcedStyle：require_space
# bad
a = ->(x, y) { x + y }

# good
a = -> (x, y) { x + y }
```

## Layout/SpaceInsideArrayLiteralBrackets

配列リテラルに使用されるブラケットに周囲のスペースがあるかどうかをチェックします。

```ruby
# bad
array = [ a, b, c, d ]

# good
array = [a, b, c, d]
```

## Layout/SpaceInsideArrayPercentLiteral

配列パーセントリテラル（%i / %w）内の不要な追加スペースをチェックします。

```ruby

# bad
%w(foo  bar  baz)# good

%i(foo bar baz)
```

## Layout/SpaceInsideBlockBraces

`{}`に周囲のスペースがあるかどうかを確認します。パラメーターを受け取るブロックの場合、設定に応じて`{`にスペースがあるかどうかをチェックします。

設定が多いのでドキュメントを確認すること推奨する。
https://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Layout/SpaceInsideBlockBraces

おすすめは `{|| }` 閉じカッコ前にスペースを付けるパターン

```ruby
# SpaceBeforeBlockParameters: false
# bad
[1, 2, 3].each { |n| n * 2 }

# good
[1, 2, 3].each {|n| n * 2 }
```

## Layout/SpaceInsideHashLiteralBraces

ハッシュリテラルに`{}`の周囲のスペースがあるかどうかを確認します。

```ruby
# The `space` style enforces that hash literals have
# surrounding space.

# bad
h = {a: 1, b: 2}

# good
h = { a: 1, b: 2 }
```

## Layout/SpaceInsideParens

通常の括弧内 `()`のスペースをチェックします。

```ruby
# bad
f( 3)
g = (a + 3 )

# good
f(3)
g = (a + 3)
```

## Layout/SpaceInsidePercentLiteralDelimiters

％i /％w /％xリテラルの区切り文字内の不要な追加スペースをチェックします。

```ruby
# good
%i(foo bar baz)

# bad
%w( foo bar baz )

# bad
%x(  ls -l )
```

## Layout/SpaceInsideRangeLiteral

範囲リテラル内のスペースをチェックします。

```ruby
# bad
1 .. 3

# good
1..3

# bad
'a' .. 'z'

# good
'a'..'z'
```

## Layout/SpaceInsideReferenceBrackets

参照ブラケットに周囲のスペースがあるかどうかを確認します。

```ruby
# bad
hash[ :key ]
array[ index ]

# good
hash[:key]
array[index]
```

## Layout/SpaceInsideStringInterpolation

文字列補間内`"#{}"`の空白をチェックします。

```ruby
# bad
   var = "This is the #{ space } example"

# good
   var = "This is the #{no_space} example"
```

## Layout/Tab

ソースコード内のタブ文字をチェックします。

```ruby
# bad
# This example uses a tab to indent bar.
def foo
  bar
end

# good
# This example uses spaces to indent bar.
def foo
  bar
end
```

## Layout/TrailingEmptyLines

ソースコードで「末尾の空白行」と「最後の改行」を探します。

```ruby
# EnforcedStyle：final_blank_line
# `final_blank_line` ファイル末尾に空行があること
# at the end of files.

# bad
class Foo; end# EOF


# bad
class Foo; end # EOF

# good
class Foo; end

# EOF

# EnforcedStyle：final_newline（デフォルト）
# `final_newline` ファイル末尾に改行があること

# bad
class Foo; end

# EOF

# bad
class Foo; end # EOF

# good
class Foo; end# EOF
```

## Layout/TrailingWhitespace

ソースコードで末尾の空白を探します。

```ruby
# 0 のあとにスペースをいれたパターン
# bad
x = 0

# 0 のあとにスペースがないパターン
# good
x = 0
```

# Lint編

Layout編と違い、構文解析に重点を置いた検査が走る。

- 構文チェック(演算子/メソッド/ブロック)
- 非推奨警告
- リファクタリング余地のある箇所の検出

## Lint/AmbiguousBlockAssociation

かっこなしで引数が渡されたときに、メソッドとブロックのあいまいな関係をチェックします。

```ruby
# bad
some_method a { |val| puts val }

# good
# With parentheses, there's no ambiguity.
some_method(a) { |val| puts val }

# good
# Operator methods require no disambiguation
foo == bar { |b| b.baz }

# good
# Lambda arguments require no disambiguation
foo = ->(bar) { bar.baz }
```

## Lint/AmbiguousOperator

括弧なしのメソッド呼び出しの最初の引数であいまいな演算子をチェックします。

```ruby
# bad


# `*`はスプラット演算子として解釈されますが、 `*`メソッドの呼び出し（つまり、 `do_something *(some_arra)`）である可能性があります。

# good

# 曖昧さ回避
do_something(*some_array)
```

## Lint/AmbiguousRegexpLiteral

括弧なしのメソッド呼び出しの最初の引数であいまいな正規表現リテラルをチェックします。

```ruby
# bad

# これは正規表現リテラルを使用したメソッド呼び出しとして解釈されますが、 `/`メソッド呼び出しである可能性があります。
# (i.e. `do_something./(pattern)./(i)`)
do_something /pattern/i

# good

# With parentheses, there's no ambiguity.
do_something(/pattern/i)
```

## Lint/AssignmentInCondition

if / while / untilの条件で割り当てをチェックします。

安全な割り当てのための「AllowSafeAssignment」オプション
安全な割り当てとは、「`=`を条件として使用していることです。」

```ruby
# bad
if some_var = true
  do_something
end

# good
if some_var == true
  do_something
end

# AllowSafeAssignment：true（デフォルト）
# good
if (some_var = true)
  do_something
end
```

## Lint/BigDecimalNew

`BigDecimal.new()`はBigDecimal 1.3.3以降では非推奨です。
「BigDecimal.new()」を「BigDecimal()」で置き換えることができる場所を特定します。

```ruby
# bad
BigDecimal.new(123.456, 3)

# good
BigDecimal(123.456, 3)
```

## Lint/BooleanSymbol

`：true`および`：false`シンボルをチェックします。
ほとんどの場合はタイプミスなので。

## Lint/CircularArgumentReference

キーワード引数とその値の循環的参照をチェックします。

```ruby
# bad

def bake(pie: pie)
  pie.heat_up
end

# good

def bake(pie:)
  pie.refrigerate
end
```

## Lint/Debugger

デバッガーまたはpryの呼び出しをチェックします。

```ruby
# bad (ok during development)

# using pry
def some_method
  binding.pry
  do_something
end

# bad (ok during development)

# using byebug
def some_method
  byebug
  do_something
end

# good

def some_method
  do_something
end
```

## Lint/DeprecatedClassMethods

非推奨のクラスメソッド `.exists?`の使用をチェックします。

```ruby
# bad

File.exists?(some_path)
Dir.exists?(some_path)
iterator?

# good

File.exist?(some_path)
Dir.exist?(some_path)
block_given?
```

## Lint/DisjunctiveAssignmentInConstructor

単純な割り当てであるべき選言的割り当てについてコンストラクタをチェックします。インスタンス変数の選言的割り当てのみに関係しています。
Rubyは値が割り当てられるまでインスタンス変数はnilなので、分離は不要です。単純な割り当てにも同じ効果があります。

```ruby
# bad
def initialize
  @x ||= 1
end

# good
def initialize
  @x = 1
end
```

## Lint/DuplicateCaseCondition

caseの「when」式で繰り返し条件が使用されていないことを確認します。

```ruby
# bad

case x
when 'first'
  do_something
when 'first'
  do_something_else
end

# good

case x
when 'first'
  do_something
when 'second'
  do_something_else
end
```

## Lint/DuplicateHashKey

ハッシュリテラルの重複キーをチェックします。

## Lint/DuplicateMethods

重複したメソッド定義をチェックします。

## Lint/EachWithObjectArgument

each_with_objectが不変の引数で呼び出されるかどうかをチェックします。
引数は、指定されたブロックがeach_with_objectが反復処理する列挙型に基づいて何かを構築するために呼び出すオブジェクトであるため、不変の引数は意味がありません。それは間違いなくバグです。

```ruby
# bad

sum = numbers.each_with_object(0) { |e, a| a += e }

# good

num = 0
sum = numbers.each_with_object(num) { |e, a| a += e }
```

## Lint/ElseLayout

elseキーワードと同じ行に式を置くなど、奇妙なelseをチェックします。

## Lint/EmptyEnsure

空の「ensure」ブロックをチェックします

```ruby
# bad

foo = ()
if ()
  bar
end
```

## Lint/EmptyExpression

空の式の存在を確認します。

## Lint/EmptyInterpolation

空の文字列補間`"#{}"`をチェックします。

## Lint/EmptyWhen

ボディのない「when」ブランチの存在をチェックします。

## Lint/EndInMethod

メソッド定義のENDブロックをチェックします。

```ruby
# bad

def some_method
  END { do_something }
end

# good

def some_method
  at_exit { do_something }
end
```

## Lint/EnsureReturn

ensureブロックからの`return`をチェックします。
発生する例外よりも`return`が優先されるため、制御フローを変更し、例外はrescueされたかのように静かに捨てられます。

## Lint/ErbNewArguments

`ERB.new` の引数に関するチェック
https://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Lint/ErbNewArguments

## Lint/FlipFlop

フリップフロップ演算子の使用を探します。フリップフロップ演算子は、Ruby 2.6.0以降では非推奨です。

```ruby
# bad
(1..20).each do |x|
  puts x if (x == 5) .. (x == 10)
end

# good
(1..20).each do |x|
  puts x if (x >= 5) && (x <= 10)
end
```

## Lint/FloatOutOfRange

フロートリテラルを識別します。フロートリテラルは、本当に超大きいです。大きすぎる。誰もそれほど大きなフロートを必要としません。大きなフロートが必要な場合、何か問題があります。

```ruby
# bad

float = 3.0e400

# good

float = 42.9
```

## Lint/FormatParameterMismatch

format / sprintf /#% の予想されるフィールドの数と実際に引数として渡されるものとの間に不一致があるかどうかを確認します。

```ruby
# bad

format('A value: %s and another: %i', a_value)

# good

format('A value: %s and another: %i', a_value, another)
```

## Lint/HeredocMethodCallPosition

レシーバがHEREDOCであるメソッド呼び出しの順序を確認します。

```ruby
# bad

   <<-SQL
   .strip_indent
     bar
   SQL

   <<-SQL
   .strip_indent
   .trim
     bar
   SQL

# good

   <<~SQL
     bar
   SQL

   <<~SQL.trim
     bar
   SQL
```

## Lint/ImplicitStringConcatenation

同じ行にある文字列リテラルの暗黙的な文字列連結をチェックします。

```ruby
# bad

array = ['Item 1' 'Item 2']

# good

array = ['Item 1Item 2']
array = ['Item 1' + 'Item 2']
array = [
  'Item 1' \
  'Item 2'
]
```

## Lint/IneffectiveAccessModifier

クラスメソッドに適用される「private」または「protected」アクセス修飾子をチェックします。これらのアクセス修飾子は、シングルトンメソッドをプライベート/保護しません。そのために `private_class_method`を使用できます。

```ruby
# bad

class C
  private

  def self.method
    puts 'hi'
  end
end

# good

class C
  def self.method
    puts 'hi'
  end

  private_class_method :method
end

# good

class C
  class << self
    private

    def method
      puts 'hi'
    end
  end
end
```

## Lint/InheritException

「Exception」とその標準ライブラリのサブクラスから継承するエラークラスを検索しますが、「StandardError」のサブクラスは除外します。代わりに、 `RuntimeError`（デフォルト）または` StandardError`の使用を提案するように設定できます。

```ruby
# bad

class C < Exception; end

C = Class.new(Exception)

# good

class C < RuntimeError; end

C = Class.new(RuntimeError)
```

## Lint/InterpolationCheck

シングルクォートで囲まれた文字列の補間をチェックします。

## Lint/LiteralAsCondition

if / while / untilの条件として機能する条件やオペランドとして使用されるリテラルを確認します。

## Lint/LiteralInInterpolation

文字列補間されたリテラルをチェックします。補完が不要なケースをチェック。
 
## Lint/Loop

begin…end にチェーンして使用されたwhile / untilをチェックします。
ほとんどの場合、このように書きません。

## Lint/MissingCopEnableDirective

「#rubocop：disable…」ステートメントの後に「#rubocop：enable…」ステートメントがあることを確認します。これにより、広範囲のコードでcopを無効にしておくことを防ぐことができます。後者のファイルへの貢献者は気付かないでしょう。

## Lint/MultipleComparison

数学とPythonでは、 `x <y <z`スタイルの比較を使用して複数の値を比較できます。ただし、Rubyでは比較を使用できません。ただし、比較は構文エラーではありません。比較演算子の不適切な使用をチェックします。

```ruby
# bad

x < y < z
10 <= x <= 20

# good

x < y && y < z
10 <= x && x <= 20
```

## Lint/NestedMethodDefinition

ネストされたメソッド定義をチェックします。

## Lint/NestedPercentLiteral

ネストされたパーセントリテラルをチェックします。

```ruby
# bad
attributes = {
  valid_attributes: %i[name content],
  nested_attributes: %i[name content %i[incorrectly nested]]
}
```

## Lint/NextWithoutAccumulator

`reduce`ブロックで` next`を呼び出すとき、アキュムレータ（※）を省略しないでください。
※状態を保持するために追加された引数

## Lint/NonDeterministicRequireOrder

`DIR`と`Dir.glob`はファイルが返される順序についていかなる保証も行いません。最終的な順序は、オペレーティングシステムとファイルシステムによって決まります。これは、ファイルの要求など、順序が重要な場合にそれらを使用すると、デバッグが困難な断続的な障害につながる可能性があることを意味します。これが起こらないようにするには、常にリストを並べ替えます。

```ruby
# bad
Dir["./lib/**/*.rb"].each do |file|
  require file
end

# good
Dir["./lib/**/*.rb"].sort.each do |file|
  require file
end
```

## Lint/NonLocalExitFromIterator

戻り値のないイテレーターからの非ローカル出口をチェックします。
次の条件で違反を登録します。

- 値が返されません。
- ブロックの前にはメソッドチェーンがあり、
- ブロックには引数があり、ブロックを受け取るメソッドが「define_method」ではありません。または `define_singleton_method`
- 戻り値は内部スコープに含まれていません。lambdaまたはメソッド定義。

## Lint/NumberConversion

安全でない数値変換の使用を警告します。自動タイプ変換が失敗した場合、安全でない数値変換は予期しないエラーを引き起こす可能性があります。
代わりに数値クラスでの解析を好みます。

```ruby
# bad

'10'.to_i
'10.2'.to_f
'10'.to_c

# good

Integer('10', 10)
Float('10.2')
Complex('10')
```

## Lint/OrderedMagicComments

マジックコメントの適切な順序と、マジックコメントがシェバン`#!`の前に配置されていないかどうかを確認します。

## Lint/ParenthesesAsGroupedExpression

呼び出されたメソッドの名前と左括弧の間のスペースをチェックします。

```ruby
# bad

puts (x + y)

# good

puts(x + y)
```

## Lint/PercentStringArray

%wの引用符とカンマをチェックします。例：`%w('foo', "bar")`

追加の文字は、結果の文字列の一部ではなく、意図しないもの（たとえば、リテラルの配列をパーセント文字列表記に誤って変換する）である可能性が高くなります。

```ruby
# bad

%w('foo', "bar")

# good

%w(foo bar)
```

## Lint/PercentSymbolArray

%iのコロンとコンマをチェックします。例：`%i(:foo, :bar)`

結果のシンボルの一部を意図したものではなく、追加の文字が意図しないものである可能性が高い（たとえば、リテラルの配列をパーセント文字列表記に誤って変換する）

```ruby
# bad

%i(:foo, :bar)

# good

%i(foo bar)
```

## Lint/RandOne

`rand(1)`の呼び出しをチェックします。そのような呼び出しは常に `0`を返します。

## Lint/RedundantCopDisableDirective

RuboCop自体のルールコメント
犯罪を報告せずに削除できるrubocop：disableコメントのインスタンスを検出します。Cop基本クラスから継承し、add_offenseを呼び出すという点で、警官として実装されています。実装の異常な部分は、on_ *メソッドや調査メソッドがないことです。これは、他の警官が仕事をするとき、調査段階に参加しないことを意味します。代わりに、実行の後の段階で呼び出されるまで待機します。通常の警官として実装できない理由は、他のすべての警官の結果に依存して作業を行うためです。
https://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Lint/RedundantCopDisableDirective

## Lint/RedundantCopEnableDirective

RuboCop自体のルールコメント
削除可能なrubocop：enableコメントのインスタンスを検出します。

コメントが一度にすべての警官を有効にするとき、「rubocop：enable all」はその警官が実際に有効になっている警官があるかどうかをチェックします。

## Lint/RedundantRequireStatement

不要な「require」ステートメントをチェックします。

次の機能は既にロードされているため、不要な「require」ステートメントです。

ruby -ve 'p $LOADED_FEATURES.reject { |feature| %r|/| =~ feature }' ruby 2.2.8p477 (2017-09-14 revision 59906) [x86_64-darwin13]

```ruby
# bad
require 'unloaded_feature'
require 'thread'

# good
require 'unloaded_feature'
```

## Lint/RedundantSplatExpansion

スプラット拡張`*`の不要な使用をチェックします

```ruby
# bad

a = *[1, 2, 3]
a = *'a'
a = *1

begin
  foo
rescue *[StandardError, ApplicationError]
  bar
end

case foo
when *[1, 2, 3]
  bar
else
  baz
end
```

## Lint/RedundantStringCoercion

文字列補間の中における冗長な文字列変換をチェックします。

```ruby
# bad

"result is #{something.to_s}"
```

## Lint/RedundantWithIndex

冗長な「.with_index」の使用をチェックします。

```ruby
# bad
ary.each_with_index do |v|
  v
end

# good
ary.each do |v|
  v
end

# bad
ary.each.with_index do |v|
  v
end

# good
ary.each do |v|
  v
end
```

## Lint/RedundantWithObject

冗長な「.with_object」の使用をチェックします。

```ruby
# bad
ary.each_with_object([]) do |v|
  v
end

# good
ary.each do |v|
  v
end

# bad
ary.each.with_object([]) do |v|
  v
end

# good
ary.each do |v|
  v
end
```

## Lint/RegexpAsCondition

「match-current-line」として使用される正規表現リテラルをチェックします。正規表現リテラルが条件にある場合、正規表現は暗黙的に `$ _`に一致します。

```ruby
# bad
if /foo/
  do_something
end

# good
if /foo/ =~ $_
  do_something
end
```

## Lint/RequireParentheses

これはおすすめ

少なくとも1つの引数を持つ述語メソッドの呼び出しがあり、パラメーターリストの周りに括弧が使用されておらず、最後の引数にBool演算子&&または||が使用されている式をチェックします。

これらの構造の警告の背後にある考え方は、ユーザーがメソッド呼び出しからの戻り値が&& / ||のオペランドであるという印象を受けるかもしれないということです。

```ruby
# bad

if day.is? :tuesday && month == :jan  # ...

end

# good

if day.is?(:tuesday) && month == :jan  # ...

end
```

## Lint/RescueException

Exceptionクラスを対象とする`rescue`ブロックをチェックします。

```ruby
# bad

begin
  do_something
rescue Exception
  handle_exception
end

# good

begin
  do_something
rescue ArgumentError
  handle_exception
end
```

## Lint/RescueType

例外が発生した場合に `TypeError`が発生する` rescue`の引数を確認します。

```ruby
# bad
begin
  bar
rescue nil
  baz
end

# bad
def foo
  bar
rescue 1, 'a', "#{b}", 0.0, [], {}
  baz
end

# good
begin
  bar
rescue
  baz
end

# good
def foo
  bar
rescue NameError
  baz
end
```

## Lint/ReturnInVoidContext

値が無視されるコンテキストで値を持つ戻り値の使用をチェックします。（initializeおよびattribute=メソッド）

```ruby
# bad
def initialize
  foo
  return :qux if bar?
  baz
end

def foo=(bar)
  return 42
end

# good
def initialize
  foo
  return if bar?
  baz
end

def foo=(bar)
  return
end
```

## Lint/SafeNavigationChain

レシーバがnilの場合、安全なナビゲーション演算子(`&. try() present? blank? presence`)はnilを返します。安全なナビゲーション演算子の後に通常のメソッド呼び出しをチェーンすると、NoMethodErrorが発生します。安全なナビゲーション演算子の後に安全なナビゲーション演算子を使用する必要があります。

```ruby
# bad

x&.foo.bar
x&.foo + bar
x&.foo[bar]

# good

x&.foo&.bar
x&.foo || bar
```

## Lint/SafeNavigationConsistency

安全なナビゲーションが `&&`または `||`でメソッド呼び出しに使用される場合、同じオブジェクト上のすべてのメソッド呼び出しに安全なナビゲーションが使用されることを確認します。

```ruby
# bad
foo&.bar && foo.baz

# bad
foo.bar || foo&.baz

# bad
foo&.bar && (foobar.baz || foo.baz)

# good
foo.bar && foo.baz

# good
foo&.bar || foo&.baz

# good
foo&.bar && (foobar.baz || foo&.baz)
```

## Lint/ScriptPermission

最初の行にシェバン行`#!`を持つファイルに実行権限が付与されているかどうかを確認します。

## Lint/SendWithMixinArgument

Mix-Inを使用するときに、 `send`、` public_send`、および `__send__`メソッドをチェックします。

「include」および「prepend」メソッドはRuby 2.0までプライベートメソッドでしたが、「send」メソッドを介して混在していました。この警官は、パブリックメソッドで呼び出すことができるRuby 2.1以降のスタイルを使用します。また、元々パブリックメソッドであった「extend」メソッドもスタイルの統一を目的としています。

```ruby
# bad
Foo.send(:include, Bar)
Foo.send(:prepend, Bar)
Foo.send(:extend, Bar)

# bad
Foo.public_send(:include, Bar)
Foo.public_send(:prepend, Bar)
Foo.public_send(:extend, Bar)

# bad
Foo.__send__(:include, Bar)
Foo.__send__(:prepend, Bar)
Foo.__send__(:extend, Bar)

# good
Foo.include Bar
Foo.prepend Bar
Foo.extend Bar
```

## Lint/ShadowedArgument

引数を指定した際、ローカル変数と同じ名前ではないかをチェックします。

## Lint/ShadowedException

より具体的な例外がrescueされる前に、その親クラスにあたる例外をチェックします。（詳細なエラーハンドリングの可能性を潰してしまいます）

```ruby
# bad

begin
  something
rescue Exception
  handle_exception
rescue StandardError
  handle_standard_error
end

# good

begin
  something
rescue StandardError
  handle_standard_error
rescue Exception
  handle_exception
end
```

## Lint/ShadowingOuterLocalVariable

ブロック引数またはブロックローカル変数の外部ローカル変数と同じ名前の使用を探します。

```ruby
# bad

def some_method
  foo = 1

  2.times do |foo| # shadowing outer `foo`
    do_something(foo)
  end
end

# good

def some_method
  foo = 1

  2.times do |bar|
    do_something(bar)
  end
end
```

## Lint/SuppressedException

Bodyのないrescueブロックをチェックします。

## Lint/Syntax

このルールは何も検査しません。Parserの診断/エラーをRuboCopのオフェンスに再パックする方法を提供するだけです。
https://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Lint/Syntax

## Lint/ToJSON

`#to_json`にオプションの引数が含まれていることを確認します。
`#to_json`をオーバーライドする場合、呼び出し元は` JSON.generate（your_obj） `を介してJSON生成を呼び出すことができます。`JSON#generate`はオプションの引数を許可するため、メソッドも同じようにすべきです。

```ruby
# bad
def to_json
end

# good
def to_json(*_args)
end
```

## Lint/UnderscorePrefixedVariableName

利用されない変数はアンダースコア`_` を付けましょう。

呼び出しサイトでブロックキーワード引数に任意の名前を付けることはできないため、 `AllowKeywordBlockArguments`では、アンダースコアで始まるブロックキーワード引数を使用できます。

```ruby
# bad

[1, 2, 3].each do |_num|
  do_something(_num)
end

query(:sales) do |_id:, revenue:, cost:|
  {_id: _id, profit: revenue - cost}
end

# good

[1, 2, 3].each do |num|
  do_something(num)
end

[1, 2, 3].each do |_num|
  do_something # not using `_num`
end
```

## Lint/UnifiedInteger

FixnumまたはBignum定数の使用をチェックします。

## Lint/UnreachableCode

到達不能コードをチェックします。このチェックは、開始（暗黙）ブロック内の非最終位置にある制御ステートメントのフローの存在に基づいています。

```ruby
# bad

def some_method
  return
  do_something
end

# bad

def some_method
  if cond
    return
  else
    return
  end
  do_something
end

# good

def some_method
  do_something
end
```

## Lint/UnusedBlockArgument

未使用のブロック引数をチェックします。

## Lint/UnusedMethodArgument

未使用のメソッド引数をチェックします。

## Lint/UriEscapeUnescape

特定のユースケースに応じて、「URI.escape」を「CGI.escape」、「URI.encode_www_form」、または「URI.encode_www_form_component」に置き換えることができる場所を識別します。また、特定のユースケースに応じて、「URI.unescape」を「CGI.unescape」、「URI.decode_www_form」、または「URI.decode_www_form_component」に置き換えることができる場所を特定します。

```ruby
# bad
URI.escape('http://example.com')
URI.encode('http://example.com')

# good
CGI.escape('http://example.com')
URI.encode_www_form([['example', 'param'], ['lang', 'en']])
URI.encode_www_form(page: 10, locale: 'en')
URI.encode_www_form_component('http://example.com')

# bad
URI.unescape(enc_uri)
URI.decode(enc_uri)

# good
CGI.unescape(enc_uri)
URI.decode_www_form(enc_uri)
URI.decode_www_form_component(enc_uri)
```

## Lint/UriRegexp

URI.regexpが廃止されて使用すべきではない場所を特定します。代わりに、 `URI::DEFAULT_PARSER.make_regexp`を使用してください。

```ruby
# bad
URI.regexp('http://example.com')

# good
URI::DEFAULT_PARSER.make_regexp('http://example.com')
```

## Lint/UselessAccessModifier

意味のないアクセス修飾子をチェックします。

クラスまたはモジュール本体の先頭の「public」修飾子など、冗長なアクセス修飾子をチェックします。条件付きで定義されたメソッドは常に定義されていると見なされるため、そのようなメソッドを保護するアクセス修飾子は冗長ではありません。

## Lint/UselessAssignment

すべてのスコープ内のローカル変数への無駄な割り当てをすべてチェックします。基本的な考え方は、`ru​​by -cw`の警告からでした。

```ruby
# bad

def some_method
  some_var = 1
  do_something
end

# good

def some_method
  some_var = 1
  do_something(some_var)
end
```

## Lint/UselessComparison:

意味のない比較演算子の利用をチェックします。

## Lint/UselessElseWithoutRescue

「rescue」なしで「begin..end」の無駄な「else」をチェックします。

`注：この構文はRuby 2.6以降では無効になり、この設定は将来のある時点で削除される予定です。`

```ruby
# bad

begin
  do_something
else
  do_something_else # This will never be run.
end

# good

begin
  do_something
rescue
  handle_errors
else
  do_something_else
end
```

## Lint/UselessSetterCall

関数定義の最終式としてローカル変数へのセッター呼び出しをチェックします。
戻り値チェックに使えるかもしれない。

```ruby
# bad
def something
  x = Something.new
  x.attr = 5
end

# good

def something
  x = Something.new
  x.attr = 5
  x
end
```

## Lint/Void

voidコンテキストで使用される演算子、変数、リテラル、および非変化メソッドをチェックします。

```ruby
# bad
def some_method
  some_num * 10
  do_something
end

def some_method(some_var)
  some_var
  do_something
end
```

# Metrics編

コードの複雑さをチェックしてくれる設定です。

## Metrics/AbcSize

メソッドのABCサイズが設定された最大値を超えていないことを確認します。
ABCサイズは、割り当て、分岐（メソッド呼び出し）、および条件に基づいています。
http://c2.com/cgi/wiki?AbcMetric
https://en.wikipedia.org/wiki/ABC_Software_Metric
を参照してください。

これだけ言われてもなんだかピンと来ない。調べてみました。
ABCサイズは以下の3つの要素から算出されるそうです。

- 代入(Assignment )
- メソッド呼び出し(Branch)
- 条件分岐(Condition)

原文にもある通りABCサイズは、**「ABCそれぞれを2乗した総和の平方根」** です。
ここまで来ると納得感あります。デフォルトだとABCsize = 15 まで許容するそうです。
複雑なメソッドを検査するルールなんですね。

>Assignment -- an explicit transfer of data into a variable, e.g. = *= /= %= += <<= >>= &= |= ^= >>>= ++ --
Branch -- an explicit forward program branch out of scope -- a function call, class method call, or new operator
Condition -- a logical/Boolean test, == != <= >= < > else case default try catch ? and unary conditionals.
A scalar ABC size value (or "aggregate magnitude") is computed as:
       |ABC| = sqrt((A*A)+(B*B)+(C*C))
http://c2.com/cgi/wiki?AbcMetric

## Metrics/BlockLength

ブロックの長さが最大値を超えているかどうかをチェックします。
コメント行はオプションで無視できます。最大許容長は構成可能です。
警官は、特定のメソッドに渡されたブロックを無視するように構成できます。

## Metrics/BlockNesting

条件およびループ構造の過剰なネストをチェックします。

`CountBlocks`オプションを使用して、ブロックが考慮されるかどうかを設定できます。`false`（デフォルト）に設定すると、ブロックはネストレベルにカウントされません。ブロックもカウントするには、「true」に設定します。

許可されるネストの最大レベルは構成可能です。 

## Metrics/ClassLength

クラスの長さが最大値を超えているかどうかをチェックします。
コメント行はオプションで無視できます。最大許容長は構成可能です。

## Metrics/CyclomaticComplexity

メソッドの循環的複雑度が設定された最大値を超えないことを確認します。
循環的複雑度は、メソッドを通る直線的に独立したパスの数です。アルゴリズムは決定点をカウントし、1つ追加します。

ifステートメント（または、unlessまたは？:)を使用すると、複雑さが1つ増えます。elseブランチは、決定点を追加しないため、そうしません。&&演算子（またはキーワードand）はネストされたifステートメントに変換でき、|| / orはifのシーケンスの省略形であるため、これらも追加されます。ループには終了条件があると言うことができるため、ループを追加します。


## Metrics/MethodLength

メソッドの長さが最大値を超えるかどうかをチェックします。
コメント行はオプションで無視できます。最大許容長は構成可能です。

## Metrics/ModuleLength

モジュールの長さが最大値を超えているかどうかを確認します。
コメント行はオプションで無視できます。最大許容長は構成可能です。

## Metrics/ParameterLists

パラメーターが多すぎるメソッドをチェックします。
パラメーターの最大数は構成可能です。オプションで、キーワード引数を合計カウントから除外できます。

## Metrics/PerceivedComplexity

メソッドを見るときにコードの読み手側の観点で複雑さをチェックします。

そのため、「when」ノードは「if」や「&&」ほど複雑ではないものと見なされます。「case」の後に式のない特別な「case」/「when」構造の1つである場合を除きます。次に、警官はそれを「if」/「elsif」/「elsif」として扱い、すべての「when」ノードをカウントします。CyclomaticComplexity警官とは対照的に、この警官は「else」ノードが複雑さを増すと見なします。

```ruby
def my_method                   # 1
  if cond                       # 1
    case var                    # 2 (0.8 + 4 * 0.2, rounded)
    when 1 then func_one
    when 2 then func_two
    when 3 then func_three
    when 4..10 then func_other
    end
  else                          # 1
    do_something until a && b   # 2
  end                           # ===
end                             # 7 complexity points
```

# Naming編

# Security編

# Style編

# 参考

- [rubydoc.info](https://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Cop)
- [GitHub rubocop(v0.78)](https://github.com/rubocop-hq/rubocop/tree/v0.78.0)