日本人のための SwiftFormat【ルール編】

## ルール一覧

SwiftFormat の Rules 一覧を日本語でまとめました。

### andOperator

`if`, `guard`, `while`の条件分岐の際の条件式で `&&` を使う場合はカンマを使うようにする。

<details><summary>サンプル</summary>

```diff
- if true && true {
+ if true, true {
```

</details>

### anyObjectProtocol

プロトコルの定義で、`class` を `AnyObject` に変更する。

※ `class` の代わりに `AnyObject` を使用するガイドラインは Swift4.1から導入されたので、`anyObjectProtocol`
のルールは Swift4.1以上でない限り無効になる。

<details><summary>サンプル</summary>

```diff
- protocol Foo: class {}
+ protocol Foo: AnyObject {}
```

</details>

### blankLinesAroundMark

`MARK:`コメントの前後に空白行を入れる。

<details><summary>サンプル</summary>

```diff
func foo() {
  // foo
}
// MARK: bar
func bar() {
  // bar
}

func foo() {
  // foo
}
+
// MARK: bar
+
func bar() {
  // bar
}
```

</details>

### blankLinesAtEndOfScope

スコープの末尾にある空白行を削除する。

<details><summary>サンプル</summary>

```diff
func foo() {
  // foo
-
}

func foo() {
  // foo
}
```

```diff
array = [
  foo,
  bar,
  baz,
-
]

array = [
  foo,
  bar,
  baz,
]
```
</details>

### blankLinesAtStartOfScope

スコープの先頭にある空白行を削除する。

<details><summary>サンプル</summary>

```diff
func foo() {
-
  // foo
}

func foo() {
  // foo
}
```

```diff
array = [
-
  foo,
  bar,
  baz,
]

array = [
  foo,
  bar,
  baz,
]
```
</details>

### blankLinesBetweenScopes

`class`, `struct`, `enum`, `extension`, `protocol`, `function` の宣言の前に空白行を
入れる。

<details><summary>サンプル</summary>

```diff
func foo() {
  // foo
}
func bar() {
  // bar
}
var baz: Bool
var quux: Int

func foo() {
  // foo
}
+
func bar() {
  // bar
}
+
var baz: Bool
var quux: Int
```
</details>

### braces

字下げスタイルを選択する。([K&R or Allman](https://ja.wikipedia.org/wiki/%E5%AD%97%E4%B8%8B%E3%81%92%E3%82%B9%E3%82%BF%E3%82%A4%E3%83%AB#BSD/))
デフォルトでは、`K&R`が適用される。

|option|description|
|---|---|
|`--allman`|`allman`インデントスタイルを使用: "true" or "false"(default)|

<details><summary>サンプル</summary>

```diff
- if x
- {
    // foo
  }
- else
- {
    // bar
  }

+ if x {
    // foo
  }
+ else {
    // bar
  }
```
</details>

### consecutiveBlankLines

連続する空白行を１行にまとめる。

<details><summary>サンプル</summary>

```diff
func foo() {
  let x = "bar"
-

  print(x)
}

func foo() {
  let x = "bar"

  print(x)
}
```
</details>

### consecutiveSpaces

連続するスペースを１つのスペースをに置き換える。

<details><summary>サンプル</summary>

```diff
- let     foo = 5
+ let foo = 5
```
</details>

### duplicateImports

重複する import 文を削除する。

<details><summary>サンプル</summary>

```diff
import Foo
import Bar
- import Foo
```

```diff
import B
#if os(iOS)
  import A
-   import B
#endif
```
</details>


### elseOnSameLine

`else`, `catch`, `while` キーワードのポジションを "同じ行" または "次の行" に調整する。

|option|description|
|---|---|
|--elseposition|`else/catch`のポジション: "same-line"(Default) or "next-line"|
|--guardelse|`guard else`のポジション: "same-line" or "next-line" or "auto"(default)|


### emptyBraces

カッコ内の空白を削除する。

<details><summary>サンプル</summary>

```diff
- func foo() {
-
- }

+ func foo() {}
```
</details>

### fileHeader

全てのファイルに指定されたソースファイルヘッダーテンプレートを使用する。

|option|description|
|---|---|
|`--header`|ヘッダーのコメント: "stripe", "ignore" または任意のテキスト|


### hoistPatternLet

`let` または `var` のバインディングをパターン内に再配置する。

|option|description|
|---|---|
|--paternlet|let/ var のパターン: "hoist"(default) or "inline"|

<details><summary>サンプル</summary>

```diff
- (let foo, let bar) = baz()
+ let (foo, bar) = baz()
```

```diff
- if case .foo(let bar, let baz) = quux {
    // inner foo
  }

+ if case let .foo(bar, baz) = quux {
    // inner foo
  }
```
</details>

### indent

スコープレベルでコードをインデントする。

|option|description
|---|---|
|`--indent`|インデントするスペースの数。タブを使用する場合は"tab"|
|`--tabwidth`|タブ文字の幅。デフォルトは"unspecified"|
|`--smarttabs`|タブ幅に関係なくコードを揃える。デフォルトは"enabled"|
|`--indentcase`|switch 内のケースをインデント: "true" or "false"|
|`--ifdef`|`#if` インデント: "indent"(default) or "no-indent" or "outdent"|
|`--xcodeindentation`|Xcode インデント guard/enum: "enabled" or "disabled"(default)|

<details><summary>サンプル</summary>

```diff
if x {
-     // foo
} else {
-     // bar
-       }

if x {
+   // foo
} else {
+   // bar
+ }
```

```diff
let array = [
  foo,
-     bar,
-       baz
-   ]

let array = [
  foo,
+   bar,
+   baz
+ ]
```

```diff
switch foo {
-   case bar: break
-   case baz: break
}

switch foo {
+ case bar: break
+ case baz: break
}
```
</details>


### isEmpty

`count == 0` を `isEmpty` に変換する

※ まれに、isEmpty プロパティが無い型で挿入される可能性があるため。ルールはデフォルトで無効になって
いる。`--enable isEmpty` を使用して有効にする必要がある。

<details><summary>サンプル</summary>

```diff
- if foo.count == 0 {
+ if foo.isEmpty {

- if foo.count > 0 {
+ if !foo.isEmpty {

- if foo?.count == 0 {
+ if foo?.isEmpty == true {
```
</details>

### leadingDelimiters

先頭のカンマを前の行の末尾に移動する。

<details><summary>サンプル</summary>

```diff
- guard let foo = maybeFoo // first
-     , let bar = maybeBar else { ... }

+ guard let foo = maybeFoo, // first
+      let bar = maybeBar else { ... }
```
</details>


### linebreakAtEndOfFile

ファイルの最後に空行を入れる。

### linebreaks

全ての改行に指定された改行文字を使用する。([CR, LF or CRLF](https://marusunrise2.blogspot.com/2014/06/lfcrcrlf.html))

|option|description|
|---|---|
|`--linebreaks`|使用する改行文字: "cr", "crlf" or "lf"(default)|

### modifierOrder

修飾子に一貫した順序を使用する。

|option|description|
|---|---|
|`--modifierorder`|修飾子をカンマで区切ったリスト(優先度順)|

<details><summary>サンプル</summary>

```diff
- lazy public weak private(set) var foo: UIView?
+ public private(set) lazy weak var foo: UIView?
```

```diff
- final public override func foo()
+ override public final func foo()
```

```diff
- convenience private init()
+ private convenience init()
```

</details>

### numberFormatting

数値リテラルを一貫性のあるグループにする。可読性をあげるためグループは `_` 区切り文字で区切られる。
数値タイプごとに、グループサイズ(各グループの桁数)としきい値(グループ化を適用する前の数値の最小桁数)
を指定できる。

|option|description|
|---|---|
|`--decimalgrouping`|10進数のグループ化、しきい値(default: 3, 6) or "none", "ignore"|
|`--binarygrouping`|バイナリグループ化、しきい値(default: 4, 8) or "none", "ignore"|
|`--octalgrouping`|8進数のグループ化、しきい値(default: 4, 8) or "none", "ignore"|
|`--hexgrouping`|16進数のグループ化、しきい値(default: 4, 8) or "none", "ignore"|
|`--fractiongrouping`|`.`の後の数字をグループ化: "enabled" or "disabled"(default)|
|`--exponentgrouping`|グループ指数桁数: "enabled" or "disabled"|
|`--hexliteralcase`| 16進数リテラルのケーシング: "uppercase" (default) or "lowercase"|
|`--exponentcase`|数字の `e` の大文字小文字: "lowercase" or "uppercase" (default)|

<details><summary>サンプル</summary>

```diff
- let color = 0xFF77A5
+ let color = 0xff77a5
```

```diff
- let big = 123456.123
+ let big = 123_456.123
```

</details>

### preferKeyPath

簡易的な `map { $0.foo }` クロージャーを keyPath ベースの構文にする。

<details><summary>サンプル</summary>

```diff
- let barArray = fooArray.map { $0.bar }

+ let barArray = fooArray.map(\.bar)
```
</details>

### redundantBackticks

識別子の周りの冗長なバックティックを削除する。

<details><summary>サンプル</summary>

```diff
- let `infix` = bar
+ let infix = bar
```

```diff
- func foo(with `default`: Int) {}
+ func foo(with default: Int) {}
```

</details>

### redundantBreak

スイッチケースの冗長なブレークケースを削除する。


<details><summary>サンプル</summary>

```diff
switch foo {
  case bar:
      print("bar")
-       break
  default:
      print("default")
-       break
}
```
</details>

### redundantGet

computedProperty 内の不要な get 句を削除する。

<details><summary>サンプル</summary>

```diff
var foo: Int {
-   get {
-     return 5
-   }
}

var foo: Int {
+   return 5
}
```
</details>

### redundantInit

必要なければ明示的に `init` を削除する。

<details><summary>サンプル</summary>

```diff
- String.init("text")
+ String("text")
```
</details>


### redundantLet

定数名・変数名が必要無い場合は冗長な `let/var` を削除する。

<details><summary>サンプル</summary>

```diff
- let _ = foo()
+ _ = foo()
```
</details>

### redundantLetError

catch 句から冗長な `let error` を削除する。
<details><summary>サンプル</summary>

```diff
- do { ... } catch let error { log(error) }
+ do { ... } catch { log(error) }
```
</details>

### redundantNilInit

オプショナルの場合に不必要な `nil` 宣言を削除する。

<details><summary>サンプル</summary>

```diff
- var foo: Int? = nil
+ var foo: Int?
```
</details>


### redundantObjc
不必要な `@objc` アノテーションを削除する。

<details><summary>サンプル</summary>

```diff
- @objc @IBOutlet var label: UILabel!
+ @IBOutlet var label: UILabel!
```

```diff
- @IBAction @objc func goBack() {}
+ @IBAction func goBack() {}
```

```diff
- @objc @NSManaged private var foo: String?
+ @NSManaged private var foo: String?
```
</details>


### redundantParens

<details><summary>サンプル</summary>

```diff
- if (foo == true) {}
+ if foo == true {}
```

```diff
- while (i < bar.count) {}
+ while i < bar.count {}
```

```diff
- queue.async() { ... }
+ queue.async { ... }
```

```diff
- let foo: Int = ({ ... })()
+ let foo: Int = { ... }()
```
</details>


### redundantPattern

不必要なパターンマッチングパラメータ構文を削除する。

<details><summary>サンプル</summary>

```diff
- if case .foo(_, _) = bar {}
+ if case .foo = bar {}
```

```diff
- let (_, _) = bar
+ let _ = bar
```
</details>


### redundantRawValues

enum の不必要な raw string value を削除する。

<details><summary>サンプル</summary>

```diff
enum Foo: String {
-   case bar = "bar"
  case baz = "quux"
}

enum Foo: String {
+   case bar
  case baz = "quux"
}
```
</details>

### redundantReturn

不必要な `return` キーワードを削除する。

<details><summary>サンプル</summary>

```diff
- array.filter { return $0.foo == bar }
+ array.filter { $0.foo == bar }
```
</details>


### redundantSelf

`self` を挿入または削除する。

※ [`@autoclosure`](https://qiita.com/shimesaba/items/b1baced2ec3d9244b2c9)
引数を持つ関数では、呼び出しで `self` が必要になる場合があるが、SwiftFormat
はこれを自動的に検出できないので注意が必要。もし、`@autoclosure` 引数を持つ関数がある場合には、
`--selfrequired` で関数を指定することで `redundantSelf` ルールを無視することができる。

|option|description|
|---|---|
|`--self`|`self` の明示的な設定: "insert" or "remove"(default) or "init-only"|
|`--selfrequired`|@autoclosure 引数を持つ関数のカンマ区切りリスト|

<details><summary>サンプル</summary>

```diff
func foobar(foo: Int, bar: Int) {
  self.foo = foo
  self.bar = bar
-   self.baz = 42
}

func foobar(foo: Int, bar: Int) {
  self.foo = foo
  self.bar = bar
+   baz = 42
}
```

`--self` オプションの `init-only` は `init`内でのみ有効。

```diff
init(foo: Int, bar: Int) {
  self.foo = foo
  self.bar = bar
-   baz = 42
}

init(foo: Int, bar: Int) {
  self.foo = foo
  self.bar = bar
+   self.baz = 42
}
```
</details>

### redundantVoidReturnType

不必要な `void` の return を削除する。

<details><summary>サンプル</summary>

```diff
- func foo() -> Void {
    // returns nothing
  }

+ func foo() {
    // returns nothing
  }
```
</details>


### semicolons

セミコロンの削除。なお、コードの動作に影響があるようなセミコロンは削除されない。

|option|description|
|---|---|
|`--semicolons`|セミコロンの許可: "never" or "inline"(default)|

<details><summary>サンプル</summary>

```diff
- let foo = 5;
+ let foo = 5
```

```diff
- let foo = 5; let bar = 6
+ let foo = 5
+ let bar = 6
```
</details>

### spaceAroundBraces

中括弧周りのスペースを追加または削除する。

<details><summary>サンプル</summary>

```diff
- foo.filter{ return true }.map{ $0 }
+ foo.filter { return true }.map { $0 }
```

```diff
- foo( {} )
+ foo({})
```

</details>

### spaceAroundBrackets

角括弧周りのスペースを追加または削除する。

<details><summary>サンプル</summary>

```diff
- foo as[String]
+ foo as [String]
```

```diff
- foo = bar [5]
+ foo = bar[5]
```

</details>

### spaceAroundComments

コメントの前後にスペースを追加する。

<details><summary>サンプル</summary>

```diff
- let a = 5// assignment
+ let a = 5 // assignment
```

```diff
- func foo() {/* ... */}
+ func foo() { /* ... */ }
```

</details>

### spaceAroundGenerics

山括弧周りのスペースを削除する。

<details><summary>サンプル</summary>

```diff
- Foo <Bar> ()
+ Foo<Bar>()
```
</details>

### spaceAroundOperators

演算子・区切り文字周りのスペースを追加または削除する。

|option|description|
|---|---|
|`--operatorfunc`|オペレータ関数のスペース間隔: "spaced"(default) or "no-space"|
|`--nospaceoperators`|スペースを含まない演算子のリスト|

<details><summary>サンプル</summary>

```diff
- foo . bar()
+ foo.bar()
```

```diff
- a+b+c
+ a + b + c
```

```diff
- func ==(lhs: Int, rhs: Int) -> Bool
+ func == (lhs: Int, rhs: Int) -> Bool
```
</details>

### spaceAroundParens

括弧の前後のスペースを追加または削除する。

<details><summary>サンプル</summary>

```diff
- init (foo)
+ init(foo)
```

```diff
- switch(x){
+ switch (x) {
```
</details>


### spaceInsideBraces

中括弧の内側にスペースを追加する。

<details><summary>サンプル</summary>

```diff
- foo.filter {return true}
+ foo.filter { return true }
```
</details>

### spaceInsideBrackets

角括弧内のスペースを削除する。

<details><summary>サンプル</summary>

```diff
- [ 1, 2, 3 ]
+ [1, 2, 3]
```
</details>

### spaceInsideComments

コメント内に先頭と末尾のスペースを追加する。

<details><summary>サンプル</summary>

```diff
- let a = 5 //assignment
+ let a = 5 // assignment
```

```diff
- func foo() { /*...*/ }
+ func foo() { /* ... */ }
```
</details>


### spaceInsideGenerics

山括弧内のスペースを削除する。

<details><summary>サンプル</summary>

```diff
- Foo< Bar, Baz >
+ Foo<Bar, Baz>
```
</details>

### spaceInsideParens

括弧内のスペースを削除する。

<details><summary>サンプル</summary>

```diff
- ( a, b)
+ (a, b)
```
</details>

### strongOutlets

`@IBOutlet` から `weak` 修飾子を削除する。[Apple の推奨](https://developer.apple.com/videos/play/wwdc2015/407/)

<details><summary>サンプル</summary>

```diff
- @IBOutlet weak var label: UILabel!
+ @IBOutlet var label: UILabel!
```
</details>

### strongifiedSelf

optional の unwrap 式で、`self` の周りのバックティックを削除する。

※ エスケープされていない `self` への割り当ては Swift4.2以降でのみサポートされているため、Swift
のバージョンが 4.2以降に設定されていない場合はこのルールは無効になる。

<details><summary>サンプル</summary>

```diff
- guard let `self` = self else { return }
+ guard let self = self else { return }
```
</details>


### todos

`TODO:`, `MARK:`, `FIXME:` に正しいフォーマットを適用する。

<details><summary>サンプル</summary>

```diff
- /* TODO fix this properly */
+ /* TODO: fix this properly */
```

```diff
- // MARK - UIScrollViewDelegate
+ // MARK: - UIScrollViewDelegate
```
</details>

### trailingClosures

該当する場合は、末尾の閉鎖構文を使用する。

|option|description|
|---|---|
|`--trailingclosures`|末尾のクロージャを使用するカンマ区切りのリスト|

<details><summary>サンプル</summary>

```diff
- DispatchQueue.main.async(execute: { ... })
+ DispatchQueue.main.async {
```

```diff
- let foo = bar.map({ ... }).joined()
+ let foo = bar.map { ... }.joined()
```
</details>


### trailingCommas

コレクションリテラルの最後の項目の末尾のコンマを追加または削除する。

|option|description|
|---|---|
|`--commas`|コレクションリテラル内のカンマ: "always"(default) or "inline"|

<details><summary>サンプル</summary>

```diff
let array = [
  foo,
  bar,
-   baz
]

let array = [
  foo,
  bar,
+   baz,
]
```
</details>

### trailingSpace

行末の末尾のスペースを削除する。

|option|description|
|---|---|
|`--trimwhitespace`|行末のスペーストリム: "always"(default) : "nonblank-lines"|


### typeSugar

`Array`, `Dictionary`, `Optional` の短縮構文を優先する。

|option|description|
|---|---|
|`--shortoptionals`|Optionalを使用する: "always"(default) : "except-properties"|

<details><summary>サンプル</summary>

```diff
- var foo: Array<String>
+ var foo: [String]
```

```diff
- var foo: Dictionary<String, Int>
+ var foo: [String: Int]
```

```diff
- var foo: Optional<(Int) -> Void>
+ var foo: ((Int) -> Void)?
```
</details>


### unusedArguments

関数で使用していない引数を `_` でマークする。

|option|description|
|---|---|
|`--stripunusedargs`|"closure-only", "unnamed-only" or "always" (default)|

<details><summary>サンプル</summary>

```diff
- func foo(bar: Int, baz: String) {
    print("Hello \(baz)")
  }

+ func foo(bar _: Int, baz: String) {
    print("Hello \(baz)")
  }
```

```diff
- func foo(_ bar: Int) {
    ...
  }

+ func foo(_: Int) {
    ...
  }
```

```diff
- request { response, data in
    self.data += data
  }

+ request { _, data in
    self.data += data
  }
```
</details>


### void

型の宣言には `Void` を使用する。

|option|description|
|---|---|
|`--voidtype`|Void タイプの表現方法: "void"(default) : "tuple"|

<details><summary>サンプル</summary>

```diff
- let foo: () -> ()
+ let foo: () -> Void
```

```diff
- let bar: Void -> Void
+ let bar: () -> Void
```

```diff
- let baz: (Void) -> Void
+ let baz: () -> Void
```

```diff
- func quux() -> (Void)
+ func quux() -> Void
```
</details>

### wrap

指定された最大幅を超える行を折り返す。

|option|description|
|---|---|
|`--maxwidth`|折り返す行の最大長: "none"(default)|
|`--nowrapoperators`|ラップされるべきでない演算子のカンマ区切りのリスト|

### wrapArguments

ラップされた関数の引数またはコレクションの要素を揃える。

※ 以前のバージョンとの互換性の関係で `--wrapparameters` に値が指定されていない場合は、`--wraparguments`
の値が使用される。

|option|description|
|---|---|
|`--wraparguments`|全ての引数をラップする: "before-list", "after-list", "preserve"|
|`--wrapparameters`|関数のパラメーターをラップする: "before-first", "after-first", "preserve"|
|`--wrapcollections`|配列・辞書をラップする: "before-first", "after-first", "preserve"|
|`--closingparen`|閉じ括弧の位置: "balanced" (default) or "same-line"|

<details><summary>サンプル</summary>

`--wraparguments before-first`

```diff
- foo(bar: Int,
-     baz: String)

+ foo(
+   bar: Int,
+   baz: String
+ )
```

```diff
- class Foo<Bar,
-           Baz>

+ class Foo<
+   Bar,
+   Baz
+ >

```

`--wrapparameters after-first`

```diff
- func foo(
-   bar: Int,
-   baz: String
- ) {
    ...
  }

+ func foo(bar: Int,
+          baz: String) {
    ...
  }
```

`--wrapcollections before-first`

```diff
- let foo = [bar,
             baz,
-            quuz]

+ let foo = [
+   bar,
    baz,
+   quuz
+ ]
```




</details>


### wrapAttributes

`@attributes` の折り返しを設定する。

|option|description|
|---|---|
|`--funcattributes`|関数について: "preserve", "prev-line", or "same-line"|
|`--typeattributes`|タイプについて: "preserve", "prev-line", or "same-line"|

<details><summary>サンプル</summary>

`--funcattributes prev-line`

```diff
- @objc func foo() {}

+ @objc
+ func foo() { }
```

`--funcattributes same-line`

```diff
- @objc
- func foo() { }

+ @objc func foo() {}
```

`--typeattributes prev-line`

```diff
- @objc class Foo {}

+ @objc
+ class Foo { }
```

`--typeattributes same-line`

```diff
- @objc
- enum Foo { }

+ @objc enum Foo {}
```
</details>

### wrapMultilineStatementBraces

複数行のステートメントの開始括弧の位置を一段下げる。(if / guard / while / func)

<details><summary>サンプル</summary>

```diff
if foo,
-   bar {
  // ...
}

if foo,
+   bar
+ {
  // ...
}
```

```diff
guard foo,
-   bar else {
  // ...
}

guard foo,
+   bar else
+ {
  // ...
}
```

```diff
func foo(
  bar: Int,
-   baz: Int) {
  // ...
}

func foo(
  bar: Int,
+   baz: Int)
+ {
  // ...
}
```
</details>


### yodaConditions

式の右側にある定数値を優先する。