Skip to content

Latest commit

 

History

History
2242 lines (1682 loc) · 35.4 KB

Rules.md

File metadata and controls

2242 lines (1682 loc) · 35.4 KB
Raw

Default Rules (enabled by default)

Opt-in Rules (disabled by default)

Deprecated Rules (do not use)

acronyms

Capitalizes acronyms when the first character is capitalized.

Option Description
--acronyms Acronyms to auto-capitalize. Defaults to "ID,URL,UUID".
Examples 
- let destinationUrl: URL
- let urlRouter: UrlRouter
- let screenId: String
- let entityUuid: UUID

+ let destinationURL: URL
+ let urlRouter: URLRouter
+ let screenID: String
+ let entityUUID: UUID

andOperator

Prefer comma over && in if, guard or while conditions.

Examples 
- if true && true {
+ if true, true {
- guard true && true else {
+ guard true, true else {
- if functionReturnsBool() && true {
+ if functionReturnsBool(), true {
- if functionReturnsBool() && variable {
+ if functionReturnsBool(), variable {

anyObjectProtocol

Prefer AnyObject over class in protocol definitions.

Examples 
- protocol Foo: class {}
+ protocol Foo: AnyObject {}

NOTE: The guideline to use AnyObject instead of class was only introduced in Swift 4.1, so the anyObjectProtocol rule is disabled unless the swift version is set to 4.1 or above.


assertionFailures

Changes all instances of assert(false, ...) to assertionFailure(...) and precondition(false, ...) to preconditionFailure(...).

Examples 
- assert(false)
+ assertionFailure()
- assert(false, "message", 2, 1)
+ assertionFailure("message", 2, 1)
- precondition(false, "message", 2, 1)
+ preconditionFailure("message", 2, 1)

blankLinesAroundMark

Insert blank line before and after MARK: comments.

Option Description
--lineaftermarks Insert blank line after "MARK:": "true" (default) or "false"
Examples 
  func foo() {
    // foo
  }
  // MARK: bar
  func bar() {
    // bar
  }

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

blankLinesAtEndOfScope

Remove trailing blank line at the end of a scope.

Examples 
  func foo() {
    // foo
-
  }

  func foo() {
    // foo
  }
  array = [
    foo,
    bar,
    baz,
-
  ]

  array = [
    foo,
    bar,
    baz,
  ]

blankLinesAtStartOfScope

Remove leading blank line at the start of a scope.

Examples 
  func foo() {
-
    // foo
  }

  func foo() {
    // foo
  }
  array = [
-
    foo,
    bar,
    baz,
  ]

  array = [
    foo,
    bar,
    baz,
  ]

blankLinesBetweenImports

Remove blank lines between import statements.

Examples 
  import A
-
  import B
  import C
-
-
  @testable import D
  import E

blankLinesBetweenScopes

Insert blank line before class, struct, enum, extension, protocol or function declarations.

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

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

blockComments

Changes block comments to single line comments.

Examples 
- /*
-  * foo
-  * bar
-  */

+ // foo
+ // bar
- /**
-  * foo
-  * bar
-  */

+ /// foo
+ /// bar

braces

Wrap braces in accordance with selected style (K&R or Allman).

Option Description
--allman Use allman indentation style: "true" or "false" (default)
Examples 
- if x
- {
    // foo
  }
- else
- {
    // bar
  }

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

consecutiveBlankLines

Replace consecutive blank lines with a single blank line.

Examples 
  func foo() {
    let x = "bar"
-

    print(x)
  }

  func foo() {
    let x = "bar"

    print(x)
  }

consecutiveSpaces

Replace consecutive spaces with a single space.

Examples 
- let     foo = 5
+ let foo = 5

duplicateImports

Remove duplicate import statements.

Examples 
  import Foo
  import Bar
- import Foo
  import B
  #if os(iOS)
    import A
-   import B
  #endif

elseOnSameLine

Place else, catch or while keyword in accordance with current style (same or next line).

Option Description
--elseposition Placement of else/catch: "same-line" (default) or "next-line"
--guardelse Guard else: "same-line", "next-line" or "auto" (default)
Examples 
  if x {
    // foo
- }
- else {
    // bar
  }

  if x {
    // foo
+ } else {
    // bar
  }
  do {
    // try foo
- }
- catch {
    // bar
  }

  do {
    // try foo
+ } catch {
    // bar
  }
  repeat {
    // foo
- }
- while {
    // bar
  }

  repeat {
    // foo
+ } while {
    // bar
  }

emptyBraces

Remove whitespace inside empty braces.

Option Description
--emptybraces Empty braces: "no-space" (default), "spaced" or "linebreak"
Examples 
- func foo() {
-
- }

+ func foo() {}

enumNamespaces

Converts types used for hosting only static members into enums (an empty enum is the canonical way to create a namespace in Swift as it can't be instantiated).

extensionAccessControl

Configure the placement of an extension's access control keyword.

Option Description
--extensionacl Place ACL "on-extension" (default) or "on-declarations"
Examples

--extensionacl on-extension (default)

- extension Foo {
-     public func bar() {}
-     public func baz() {}
  }

+ public extension Foo {
+     func bar() {}
+     func baz() {}
  }

--extensionacl on-declarations

- public extension Foo {
-     func bar() {}
-     func baz() {}
-     internal func quux() {}
  }

+ extension Foo {
+     public func bar() {}
+     public func baz() {}
+     func quux() {}
  }

fileHeader

Use specified source file header template for all files.

Option Description
--header Header comments: "strip", "ignore", or the text you wish use

hoistPatternLet

Reposition let or var bindings within pattern.

Option Description
--patternlet let/var placement in patterns: "hoist" (default) or "inline"
Examples 
- (let foo, let bar) = baz()
+ let (foo, bar) = baz()
- if case .foo(let bar, let baz) = quux {
    // inner foo
  }

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

indent

Indent code in accordance with the scope level.

Option Description
--indent Number of spaces to indent, or "tab" to use tabs
--tabwidth The width of a tab character. Defaults to "unspecified"
--smarttabs Align code independently of tab width. defaults to "enabled"
--indentcase Indent cases inside a switch: "true" or "false" (default)
--ifdef #if indenting: "indent" (default), "no-indent" or "outdent"
--xcodeindentation Match Xcode indenting: "enabled" or "disabled" (default)
--indentstrings Indent Multiline Strings: "false" (default) or "true"
Examples 
  if x {
-     // foo
  } else {
-     // bar
-       }

  if x {
+   // foo
  } else {
+   // bar
+ }
  let array = [
    foo,
-     bar,
-       baz
-   ]

  let array = [
    foo,
+   bar,
+   baz
+ ]
  switch foo {
-   case bar: break
-   case baz: break
  }

  switch foo {
+ case bar: break
+ case baz: break
  }

initCoderUnavailable

Add @available(*, unavailable) attribute to required init(coder:) when it hasn't been implemented.

Examples 
+ @available(*, unavailable)
  required init?(coder aDecoder: NSCoder) {
    fatalError("init(coder:) has not been implemented")
  }

isEmpty

Prefer isEmpty over comparing count against zero.

Examples 
- if foo.count == 0 {
+ if foo.isEmpty {

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

- if foo?.count == 0 {
+ if foo?.isEmpty == true {

NOTE: In rare cases, the isEmpty rule may insert an isEmpty call for a type that doesn't implement that property, breaking the program. For this reason, the rule is disabled by default, and must be manually enabled via the --enable isEmpty option.


leadingDelimiters

Move leading delimiters to the end of the previous line.

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

+ guard let foo = maybeFoo, // first
+      let bar = maybeBar else { ... }

linebreakAtEndOfFile

Add empty blank line at end of file.

linebreaks

Use specified linebreak character for all linebreaks (CR, LF or CRLF).

Option Description
--linebreaks Linebreak character to use: "cr", "crlf" or "lf" (default)

markTypes

Adds a mark comment before top-level types and extensions.

Option Description
--marktypes Mark types "always" (default), "never", "if-not-empty"
--typemark Template for type mark comments. Defaults to "MARK: - %t"
--markextensions Mark extensions "always" (default), "never", "if-not-empty"
--extensionmark Mark for standalone extensions. Defaults to "MARK: - %t + %c"
--groupedextension Mark for extension grouped with extended type. ("MARK: %c")
Examples 
+ // MARK: - FooViewController
+
 final class FooViewController: UIViewController { }

+ // MARK: UICollectionViewDelegate
+
 extension FooViewController: UICollectionViewDelegate { }

+ // MARK: - String + FooProtocol
+
 extension String: FooProtocol { }

modifierOrder

Use consistent ordering for member modifiers.

Option Description
--modifierorder Comma-delimited list of modifiers in preferred order
Examples 
- lazy public weak private(set) var foo: UIView?
+ public private(set) lazy weak var foo: UIView?
- final public override func foo()
+ override public final func foo()
- convenience private init()
+ private convenience init()

numberFormatting

Use consistent grouping for numeric literals. Groups will be separated by _ delimiters to improve readability. For each numeric type you can specify a group size (the number of digits in each group) and a threshold (the minimum number of digits in a number before grouping is applied).

Option Description
--decimalgrouping Decimal grouping,threshold (default: 3,6) or "none", "ignore"
--binarygrouping Binary grouping,threshold (default: 4,8) or "none", "ignore"
--octalgrouping Octal grouping,threshold (default: 4,8) or "none", "ignore"
--hexgrouping Hex grouping,threshold (default: 4,8) or "none", "ignore"
--fractiongrouping Group digits after '.': "enabled" or "disabled" (default)
--exponentgrouping Group exponent digits: "enabled" or "disabled" (default)
--hexliteralcase Casing for hex literals: "uppercase" (default) or "lowercase"
--exponentcase Case of 'e' in numbers: "lowercase" or "uppercase" (default)
Examples 
- let color = 0xFF77A5
+ let color = 0xff77a5
- let big = 123456.123
+ let big = 123_456.123

organizeDeclarations

Organizes declarations within class, struct, enum, actor, and extension bodies.

Option Description
--categorymark Template for category mark comments. Defaults to "MARK: %c"
--markcategories Insert MARK comments between categories (true by default)
--beforemarks Declarations placed before first mark (e.g. typealias,struct)
--lifecycle Names of additional Lifecycle methods (e.g. viewDidLoad)
--organizetypes Declarations to organize (default: class,actor,struct,enum)
--structthreshold Minimum line count to organize struct body. Defaults to 0
--classthreshold Minimum line count to organize class body. Defaults to 0
--enumthreshold Minimum line count to organize enum body. Defaults to 0
--extensionlength Minimum line count to organize extension body. Defaults to 0
Examples 
  public class Foo {
-     public func c() -> String {}
-
-     public let a: Int = 1
-     private let g: Int = 2
-     let e: Int = 2
-     public let b: Int = 3
-
-     public func d() {}
-     func f() {}
-     init() {}
-     deinit() {}
 }

  public class Foo {
+
+     // MARK: Lifecycle
+
+     init() {}
+     deinit() {}
+
+     // MARK: Public
+
+     public let a: Int = 1
+     public let b: Int = 3
+
+     public func c() -> String {}
+     public func d() {}
+
+     // MARK: Internal
+
+     let e: Int = 2
+
+     func f() {}
+
+     // MARK: Private
+
+     private let g: Int = 2
+
 }

preferDouble

Replaces occurrences of CGFloat with Double when targeting Swift 5.5 and above.

preferKeyPath

Convert trivial map { $0.foo } closures to keyPath-based syntax.

Examples 
- let barArray = fooArray.map { $0.bar }
+ let barArray = fooArray.map(\.bar)

- let barArray = fooArray.compactMap { $0.optionalBar }
+ let barArray = fooArray.compactMap(\.optionalBar)

redundantBackticks

Remove redundant backticks around identifiers.

Examples 
- let `infix` = bar
+ let infix = bar
- func foo(with `default`: Int) {}
+ func foo(with default: Int) {}

redundantBreak

Remove redundant break in switch case.

Examples 
  switch foo {
    case bar:
        print("bar")
-       break
    default:
        print("default")
-       break
  }

redundantClosure

Removes redundant closures bodies, containing a single statement, which are called immediately.

Examples 
- let foo = { Foo() }()
+ let foo = Foo()
- lazy var bar = {
-     Bar(baaz: baaz,
-         quux: quux)
- }()
+ lazy var bar = Bar(baaz: baaz,
+                    quux: quux)

redundantExtensionACL

Remove redundant access control modifiers.

Examples 
  public extension URL {
-   public func queryParameter(_ name: String) -> String { ... }
  }

  public extension URL {
+   func queryParameter(_ name: String) -> String { ... }
  }

redundantFileprivate

Prefer private over fileprivate where equivalent.

Examples 
-  fileprivate let someConstant = "someConstant"
+  private let someConstant = "someConstant"

In Swift 4 and above, fileprivate can also be replaced with private for members that are only accessed from extensions in the same file:

  class Foo {
-   fileprivate var foo = "foo"
+   private var foo = "foo"
  }

  extension Foo {
    func bar() {
      print(self.foo)
    }
  }

redundantGet

Remove unneeded get clause inside computed properties.

Examples 
  var foo: Int {
-   get {
-     return 5
-   }
  }

  var foo: Int {
+   return 5
  }

redundantInit

Remove explicit init if not required.

Examples 
- String.init("text")
+ String("text")

redundantLet

Remove redundant let/var from ignored variables.

Examples 
- let _ = foo()
+ _ = foo()

redundantLetError

Remove redundant let error from catch clause.

Examples 
- do { ... } catch let error { log(error) }
+ do { ... } catch { log(error) }

redundantNilInit

Remove redundant nil default value (Optional vars are nil by default).

Examples 
- var foo: Int? = nil
+ var foo: Int?
// doesn't apply to `let` properties
let foo: Int? = nil
// doesn't affect non-nil initialization
var foo: Int? = 0

redundantObjc

Remove redundant @objc annotations.

Examples 
- @objc @IBOutlet var label: UILabel!
+ @IBOutlet var label: UILabel!
- @IBAction @objc func goBack() {}
+ @IBAction func goBack() {}
- @objc @NSManaged private var foo: String?
+ @NSManaged private var foo: String?

redundantParens

Remove redundant parentheses.

Examples 
- if (foo == true) {}
+ if foo == true {}
- while (i < bar.count) {}
+ while i < bar.count {}
- queue.async() { ... }
+ queue.async { ... }
- let foo: Int = ({ ... })()
+ let foo: Int = { ... }()

redundantPattern

Remove redundant pattern matching parameter syntax.

Examples 
- if case .foo(_, _) = bar {}
+ if case .foo = bar {}
- let (_, _) = bar
+ let _ = bar

redundantRawValues

Remove redundant raw string values for enum cases.

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

  enum Foo: String {
+   case bar
    case baz = "quux"
  }

redundantReturn

Remove unneeded return keyword.

Examples 
- array.filter { return $0.foo == bar }
+ array.filter { $0.foo == bar }

redundantSelf

Insert/remove explicit self where applicable.

Option Description
--self Explicit self: "insert", "remove" (default) or "init-only"
--selfrequired Comma-delimited list of functions with @autoclosure arguments
Examples 
  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
  }

In the rare case of functions with @autoclosure arguments, self may be required at the call site, but SwiftFormat is unable to detect this automatically. You can use the --selfrequired command-line option to specify a list of such methods, and the redundantSelf rule will then ignore them.

An example of such a method is the expect() function in the Nimble unit testing framework (https://github.com/Quick/Nimble), which is common enough that SwiftFormat excludes it by default.

There is also an option to always use explicit self but only inside init, by using --self init-only:

  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
  }

redundantType

Remove redundant type from variable declarations.

Option Description
--redundanttype "inferred", "explicit", or "infer-locals-only" (default)
Examples 
// inferred
- let view: UIView = UIView()
+ let view = UIView()

// explicit
- let view: UIView = UIView()
+ let view: UIView = .init()

// infer-locals-only
  class Foo {
-     let view: UIView = UIView()
+     let view: UIView = .init()

      func method() {
-         let view: UIView = UIView()
+         let view = UIView()
      }
  }

redundantVoidReturnType

Remove explicit Void return type.

Option Description
--closurevoid Closure void returns: "remove" (default) or "preserve"
Examples 
- func foo() -> Void {
    // returns nothing
  }

+ func foo() {
    // returns nothing
  }

semicolons

Remove semicolons.

Option Description
--semicolons Allow semicolons: "never" or "inline" (default)
Examples 
- let foo = 5;
+ let foo = 5
- let foo = 5; let bar = 6
+ let foo = 5
+ let bar = 6
// semicolon is not removed if it would affect the behavior of the code
return;
goto(fail)

sortDeclarations

Sorts the body of declarations with // swiftformat:sort and declarations between // swiftformat:sort:begin and // swiftformat:sort:end comments.

Examples 
  // swiftformat:sort
  enum FeatureFlags {
-     case upsellB
-     case fooFeature
-     case barFeature
-     case upsellA(
-         fooConfiguration: Foo,
-         barConfiguration: Bar)
+     case barFeature
+     case fooFeature
+     case upsellA
+         fooConfiguration: Foo,
+         barConfiguration: Bar)
+     case upsellB
  }

  enum FeatureFlags {
      // swiftformat:sort:begin
-     case upsellB
-     case fooFeature
-     case barFeature
-     case upsellA(
-         fooConfiguration: Foo,
-         barConfiguration: Bar)
+     case barFeature
+     case fooFeature
+     case upsellA
+         fooConfiguration: Foo,
+         barConfiguration: Bar)
+     case upsellB
      // swiftformat:sort:end

      var anUnsortedProperty: Foo {
          Foo()
      }
  }

sortedImports

Sort import statements alphabetically.

Option Description
--importgrouping "testable-first/last", "alpha" (default) or "length"
Examples 
- import Foo
- import Bar
+ import Bar
+ import Foo
- import B
- import A
- #if os(iOS)
-   import Foo-iOS
-   import Bar-iOS
- #endif
+ import A
+ import B
+ #if os(iOS)
+   import Bar-iOS
+   import Foo-iOS
+ #endif

sortedSwitchCases

Sorts switch cases alphabetically.

spaceAroundBraces

Add or remove space around curly braces.

Examples 
- foo.filter{ return true }.map{ $0 }
+ foo.filter { return true }.map { $0 }
- foo( {} )
+ foo({})

spaceAroundBrackets

Add or remove space around square brackets.

Examples 
- foo as[String]
+ foo as [String]
- foo = bar [5]
+ foo = bar[5]

spaceAroundComments

Add space before and/or after comments.

Examples 
- let a = 5// assignment
+ let a = 5 // assignment
- func foo() {/* ... */}
+ func foo() { /* ... */ }

spaceAroundGenerics

Remove space around angle brackets.

Examples 
- Foo <Bar> ()
+ Foo<Bar>()

spaceAroundOperators

Add or remove space around operators or delimiters.

Option Description
--operatorfunc Spacing for operator funcs: "spaced" (default) or "no-space"
--nospaceoperators Comma-delimited list of operators without surrounding space
--ranges Spacing for ranges: "spaced" (default) or "no-space"
Examples 
- foo . bar()
+ foo.bar()
- a+b+c
+ a + b + c
- func ==(lhs: Int, rhs: Int) -> Bool
+ func == (lhs: Int, rhs: Int) -> Bool

spaceAroundParens

Add or remove space around parentheses.

Examples 
- init (foo)
+ init(foo)
- switch(x){
+ switch (x) {

spaceInsideBraces

Add space inside curly braces.

Examples 
- foo.filter {return true}
+ foo.filter { return true }

spaceInsideBrackets

Remove space inside square brackets.

Examples 
- [ 1, 2, 3 ]
+ [1, 2, 3]

spaceInsideComments

Add leading and/or trailing space inside comments.

Examples 
- let a = 5 //assignment
+ let a = 5 // assignment
- func foo() { /*...*/ }
+ func foo() { /* ... */ }

spaceInsideGenerics

Remove space inside angle brackets.

Examples 
- Foo< Bar, Baz >
+ Foo<Bar, Baz>

spaceInsideParens

Remove space inside parentheses.

Examples 
- ( a, b)
+ (a, b)

specifiers

Use consistent ordering for member modifiers.

Note: specifiers rule is deprecated. Use modifierOrder instead.

strongOutlets

Remove weak modifier from @IBOutlet properties.

Examples

As per Apple's recommendation (https://developer.apple.com/videos/play/wwdc2015/407/ @ 32:30).

- @IBOutlet weak var label: UILabel!
+ @IBOutlet var label: UILabel!

strongifiedSelf

Remove backticks around self in Optional unwrap expressions.

Examples 
- guard let `self` = self else { return }
+ guard let self = self else { return }

NOTE: assignment to un-escaped self is only supported in Swift 4.2 and above, so the strongifiedSelf rule is disabled unless the Swift version is set to 4.2 or above.


todos

Use correct formatting for TODO:, MARK: or FIXME: comments.

Examples 
- /* TODO fix this properly */
+ /* TODO: fix this properly */
- // MARK - UIScrollViewDelegate
+ // MARK: - UIScrollViewDelegate

trailingClosures

Use trailing closure syntax where applicable.

Option Description
--trailingclosures Comma-delimited list of functions that use trailing closures
--nevertrailing List of functions that should never use trailing closures
Examples 
- DispatchQueue.main.async(execute: { ... })
+ DispatchQueue.main.async {
- let foo = bar.map({ ... }).joined()
+ let foo = bar.map { ... }.joined()

trailingCommas

Add or remove trailing comma from the last item in a collection literal.

Option Description
--commas Commas in collection literals: "always" (default) or "inline"
Examples 
  let array = [
    foo,
    bar,
-   baz
  ]

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

trailingSpace

Remove trailing space at end of a line.

Option Description
--trimwhitespace Trim trailing space: "always" (default) or "nonblank-lines"

typeSugar

Prefer shorthand syntax for Arrays, Dictionaries and Optionals.

Option Description
--shortoptionals Use ? for Optionals "always" (default) or "except-properties"
Examples 
- var foo: Array<String>
+ var foo: [String]
- var foo: Dictionary<String, Int>
+ var foo: [String: Int]
- var foo: Optional<(Int) -> Void>
+ var foo: ((Int) -> Void)?

unusedArguments

Mark unused function arguments with _.

Option Description
--stripunusedargs "closure-only", "unnamed-only" or "always" (default)
Examples 
- func foo(bar: Int, baz: String) {
    print("Hello \(baz)")
  }

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

+ func foo(_: Int) {
    ...
  }
- request { response, data in
    self.data += data
  }

+ request { _, data in
    self.data += data
  }

void

Use Void for type declarations and () for values.

Option Description
--voidtype How Void types are represented: "void" (default) or "tuple"
Examples 
- let foo: () -> ()
+ let foo: () -> Void
- let bar: Void -> Void
+ let bar: () -> Void
- let baz: (Void) -> Void
+ let baz: () -> Void
- func quux() -> (Void)
+ func quux() -> Void
- callback = { _ in Void() }
+ callback = { _ in () }

wrap

Wrap lines that exceed the specified maximum width.

Option Description
--maxwidth Maximum length of a line before wrapping. defaults to "none"
--nowrapoperators Comma-delimited list of operators that shouldn't be wrapped
--assetliterals Color/image literal width. "actual-width" or "visual-width"
--wrapternary Wrap ternary operators: "default", "before-operators"

wrapArguments

Align wrapped function arguments or collection elements.

Option Description
--wraparguments Wrap all arguments: "before-first", "after-first", "preserve"
--wrapparameters Wrap func params: "before-first", "after-first", "preserve"
--wrapcollections Wrap array/dict: "before-first", "after-first", "preserve"
--closingparen Closing paren position: "balanced" (default) or "same-line"
--wrapreturntype Wrap return type: "if-multiline", "preserve" (default)
--wrapconditions Wrap conditions: "before-first", "after-first", "preserve"
--wraptypealiases Wrap typealiases: "before-first", "after-first", "preserve"
Examples

NOTE: For backwards compatibility with previous versions, if no value is provided for --wrapparameters, the value for --wraparguments will be used.

--wraparguments before-first

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

+ foo(
+   bar: Int,
+   baz: String
+ )
- class Foo<Bar,
-           Baz>

+ class Foo<
+   Bar,
+   Baz
+ >

--wrapparameters after-first

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

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

--wrapcollections before-first:

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

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

wrapAttributes

Wrap @attributes onto a separate line, or keep them on the same line.

Option Description
--funcattributes Function @attributes: "preserve", "prev-line", or "same-line"
--typeattributes Type @attributes: "preserve", "prev-line", or "same-line"
--varattributes Property @attributes: "preserve", "prev-line", or "same-line"
Examples

--funcattributes prev-line

- @objc func foo() {}

+ @objc
+ func foo() { }

--funcattributes same-line

- @objc
- func foo() { }

+ @objc func foo() {}

--typeattributes prev-line

- @objc class Foo {}

+ @objc
+ class Foo { }

--typeattributes same-line

- @objc
- enum Foo { }

+ @objc enum Foo {}

wrapConditionalBodies

Wrap the bodies of inline conditional statements onto a new line.

Examples 
- guard let foo = bar else { return baz }
+ guard let foo = bar else {
+     return baz
+ }
- if foo { return bar }
+ if foo {
+    return bar
+ }

wrapEnumCases

Writes one enum case per line.

Examples 
  enum Foo {
-   case bar, baz
  }

  enum Foo {
+   case bar
+   case baz
  }

wrapMultilineStatementBraces

Wrap the opening brace of multiline statements.

Examples 
  if foo,
-   bar {
    // ...
  }

  if foo,
+   bar
+ {
    // ...
  }
  guard foo,
-   bar else {
    // ...
  }

  guard foo,
+   bar else
+ {
    // ...
  }
  func foo(
    bar: Int,
-   baz: Int) {
    // ...
  }

  func foo(
    bar: Int,
+   baz: Int)
+ {
    // ...
  }
  class Foo: NSObject,
-   BarProtocol {
    // ...
  }

  class Foo: NSObject,
+   BarProtocol
+ {
    // ...
  }

wrapSwitchCases

Writes one switch case per line.

Examples 
  switch foo {
-   case .bar, .baz:
      break
  }

  switch foo {
+   case .foo,
+        .bar:
      break
  }

yodaConditions

Prefer constant values to be on the right-hand-side of expressions.

Option Description
--yodaswap Swap yoda values: "always" (default) or "literals-only"