SwiftFormat/Rules.md

Rules

• andOperator
• anyObjectProtocol
• assertionFailures
• blankLinesAroundMark
• blankLinesAtEndOfScope
• blankLinesAtStartOfScope
• blankLinesBetweenScopes
• braces
• consecutiveBlankLines
• consecutiveSpaces
• duplicateImports
• elseOnSameLine
• emptyBraces
• enumNamespaces
• extensionAccessControl
• fileHeader
• hoistPatternLet
• indent
• initCoderUnavailable
• isEmpty
• leadingDelimiters
• linebreakAtEndOfFile
• linebreaks
• markTypes
• modifierOrder
• numberFormatting
• organizeDeclarations
• preferKeyPath
• redundantBackticks
• redundantBreak
• redundantExtensionACL
• redundantFileprivate
• redundantGet
• redundantInit
• redundantLet
• redundantLetError
• redundantNilInit
• redundantObjc
• redundantParens
• redundantPattern
• redundantRawValues
• redundantReturn
• redundantSelf
• redundantType
• redundantVoidReturnType
• semicolons
• sortedImports
• sortedSwitchCases
• spaceAroundBraces
• spaceAroundBrackets
• spaceAroundComments
• spaceAroundGenerics
• spaceAroundOperators
• spaceAroundParens
• spaceInsideBraces
• spaceInsideBrackets
• spaceInsideComments
• spaceInsideGenerics
• spaceInsideParens
• specifiers (deprecated)
• strongOutlets
• strongifiedSelf
• todos
• trailingClosures
• trailingCommas
• trailingSpace
• typeSugar
• unusedArguments
• void
• wrap
• wrapArguments
• wrapAttributes
• wrapEnumCases
• wrapMultilineStatementBraces
• wrapSwitchCases
• yodaConditions

---

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.

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,
  ]

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

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)

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, and enum bodies.

Option	Description
--categorymark	Template for category mark comments. Defaults to "MARK: %c"
--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
+
 }

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
  }

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" (default), "explicit", or "infer-locals-only"

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.

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)

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"

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"

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 {}

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"