Addded TrailingCommaRule

CHANGELOG.md

@@ -36,6 +36,12 @@
 * `closure_spacing` rule now accepts empty bodies with a space.  
   [Marcelo Fabri](https://github.com/marcelofabri)
   [#875](https://github.com/realm/SwiftLint/issues/875)
+
+* Add `TrailingCommaRule` to enforce/forbid trailing commas in arrays and
+  dictionaries. The default is to forbid them, but this can be changed with
+  the `mandatory_comma` configuration.  
+  [Marcelo Fabri](https://github.com/marcelofabri)
+  [#883](https://github.com/realm/SwiftLint/issues/883)
 
 ##### Bug Fixes
 

Source/SwiftLintFramework/Models/MasterRuleList.swift

@@ -79,6 +79,7 @@ public let masterRuleList = RuleList(rules:
     SwitchCaseOnNewlineRule.self,
     SyntacticSugarRule.self,
     TodoRule.self,
+    TrailingCommaRule.self,
     TrailingNewlineRule.self,
     TrailingSemicolonRule.self,
     TrailingWhitespaceRule.self,

Source/SwiftLintFramework/Rules/CommaRule.swift

@@ -24,22 +24,22 @@ public struct CommaRule: CorrectableRule, ConfigurationProviderRule {
             "abc(a: \"string\", b: \"string\"",
             "enum a { case a, b, c }",
             "func abc(\n  a: String,  // comment\n  bcd: String // comment\n) {\n}\n",
-            "func abc(\n  a: String,\n  bcd: String\n) {\n}\n",
+            "func abc(\n  a: String,\n  bcd: String\n) {\n}\n"
         ],
         triggeringExamples: [
             "func abc(a: String↓ ,b: String) { }",
             "func abc(a: String↓ ,b: String↓ ,c: String↓ ,d: String) { }",
             "abc(a: \"string\"↓,b: \"string\"",
             "enum a { case a↓ ,b }",
-            "let result = plus(\n    first: 3↓ , // #683\n    second: 4\n)\n",
+            "let result = plus(\n    first: 3↓ , // #683\n    second: 4\n)\n"
         ],
         corrections: [
             "func abc(a: String,b: String) {}\n": "func abc(a: String, b: String) {}\n",
             "abc(a: \"string\",b: \"string\"\n": "abc(a: \"string\", b: \"string\"\n",
             "abc(a: \"string\"  ,  b: \"string\"\n": "abc(a: \"string\", b: \"string\"\n",
             "enum a { case a  ,b }\n": "enum a { case a, b }\n",
             "let a = [1,1]\nlet b = 1\nf(1, b)\n": "let a = [1, 1]\nlet b = 1\nf(1, b)\n",
-            "let a = [1↓,1↓,1↓,1]\n": "let a = [1, 1, 1, 1]\n",
+            "let a = [1↓,1↓,1↓,1]\n": "let a = [1, 1, 1, 1]\n"
         ]
     )
 

Source/SwiftLintFramework/Rules/CyclomaticComplexityRule.swift

@@ -28,7 +28,7 @@ public struct CyclomaticComplexityRule: ASTRule, ConfigurationProviderRule {
             "if true {}; if true {}; if true {}; if true {}; if true {}; if true {}\n" +
                 "func f2() {\n" +
                     "if true {}; if true {}; if true {}; if true {}; if true {}\n" +
-                "}}",
+                "}}"
         ],
         triggeringExamples: [
             "func f1() {\n  if true {\n    if true {\n      if false {}\n    }\n" +

Source/SwiftLintFramework/Rules/ExplicitInitRule.swift

@@ -24,14 +24,14 @@ public struct ExplicitInitRule: ASTRule, ConfigurationProviderRule, CorrectableR
             "struct S { let n: Int }; extension S { init() { self.init(n: 1) } }",      // self
             "[1].flatMap(String.init)",                   // pass init as closure
             "[String.self].map { $0.init(1) }",           // initialize from a metatype value
-            "[String.self].map { type in type.init(1) }", // initialize from a metatype value
+            "[String.self].map { type in type.init(1) }"  // initialize from a metatype value
         ],
         triggeringExamples: [
             "[1].flatMap{String↓.init($0)}",
-            "[String.self].map { Type in Type↓.init(1) }", // starting with capital assumes as type
+            "[String.self].map { Type in Type↓.init(1) }"  // starting with capital assumes as type
         ],
         corrections: [
-            "[1].flatMap{String.init($0)}" : "[1].flatMap{String($0)}",
+            "[1].flatMap{String.init($0)}" : "[1].flatMap{String($0)}"
         ]
     )
 

Source/SwiftLintFramework/Rules/ForceUnwrappingRule.swift

@@ -39,7 +39,7 @@ public struct ForceUnwrappingRule: OptInRule, ConfigurationProviderRule {
             "let unwrapped = optional↓!",
             "return cell↓!",
             "let url = NSURL(string: \"http://www.google.com\")↓!",
-            "let dict = [\"Boooo\": \"👻\"]func bla() -> String { return dict[\"Boooo\"]↓! }",
+            "let dict = [\"Boooo\": \"👻\"]func bla() -> String { return dict[\"Boooo\"]↓! }"
         ]
     )
 

Source/SwiftLintFramework/Rules/FunctionParameterCountRule.swift

@@ -26,7 +26,7 @@ public struct FunctionParameterCountRule: ASTRule, ConfigurationProviderRule {
         ],
         triggeringExamples: [
             "func f(a: Int, b: Int, c: Int, d: Int, e: Int, f: Int) {}",
-            "func f(a: Int, b: Int, c: Int, d: Int, e: Int, f: Int = 2, g: Int) {}",
+            "func f(a: Int, b: Int, c: Int, d: Int, e: Int, f: Int = 2, g: Int) {}"
         ]
     )
 

Source/SwiftLintFramework/Rules/LegacyCGGeometryFunctionsRule.swift

@@ -39,7 +39,7 @@ public struct LegacyCGGeometryFunctionsRule: CorrectableRule, ConfigurationProvi
             // "rect.divide(atDistance: 10.2, fromEdge: edge)", No correction available for divide
             "rect1.contains(rect2)",
             "rect.contains(point)",
-            "rect1.intersects(rect2)",
+            "rect1.intersects(rect2)"
         ],
         triggeringExamples: [
             "↓CGRectGetWidth(rect)",

Source/SwiftLintFramework/Rules/LegacyConstructorRule.swift

@@ -39,7 +39,7 @@ public struct LegacyConstructorRule: CorrectableRule, ConfigurationProviderRule
             "UIEdgeInsets(top: 0, left: 0, bottom: 10, right: 10)",
             "UIEdgeInsets(top: aTop, left: aLeft, bottom: aBottom, right: aRight)",
             "NSEdgeInsets(top: 0, left: 0, bottom: 10, right: 10)",
-            "NSEdgeInsets(top: aTop, left: aLeft, bottom: aBottom, right: aRight)",
+            "NSEdgeInsets(top: aTop, left: aLeft, bottom: aBottom, right: aRight)"
         ],
         triggeringExamples: [
             "↓CGPointMake(10, 10)",
@@ -61,7 +61,7 @@ public struct LegacyConstructorRule: CorrectableRule, ConfigurationProviderRule
             "↓UIEdgeInsetsMake(0, 0, 10, 10)",
             "↓UIEdgeInsetsMake(top, left, bottom, right)",
             "↓NSEdgeInsetsMake(0, 0, 10, 10)",
-            "↓NSEdgeInsetsMake(top, left, bottom, right)",
+            "↓NSEdgeInsetsMake(top, left, bottom, right)"
         ],
         corrections: [
             "↓CGPointMake(10,  10   )\n": "CGPoint(x: 10, y: 10)\n",
@@ -93,7 +93,7 @@ public struct LegacyConstructorRule: CorrectableRule, ConfigurationProviderRule
             "↓NSEdgeInsetsMake(0, 0, 10, 10)\n":
             "NSEdgeInsets(top: 0, left: 0, bottom: 10, right: 10)\n",
             "↓NSEdgeInsetsMake(top, left, bottom, right)\n":
-            "NSEdgeInsets(top: top, left: left, bottom: bottom, right: right)\n",
+            "NSEdgeInsets(top: top, left: left, bottom: bottom, right: right)\n"
         ]
     )
 
@@ -128,7 +128,7 @@ public struct LegacyConstructorRule: CorrectableRule, ConfigurationProviderRule
             "UIEdgeInsetsMake\\(\\s*\(twoVarsOrNum)\\s*,\\s*\(twoVarsOrNum)\\s*\\)":
             "UIEdgeInsets(top: $1, left: $2, bottom: $3, right: $4)",
             "NSEdgeInsetsMake\\(\\s*\(twoVarsOrNum)\\s*,\\s*\(twoVarsOrNum)\\s*\\)":
-            "NSEdgeInsets(top: $1, left: $2, bottom: $3, right: $4)",
+            "NSEdgeInsets(top: $1, left: $2, bottom: $3, right: $4)"
         ]
 
         let description = self.dynamicType.description

Source/SwiftLintFramework/Rules/LegacyNSGeometryFunctionsRule.swift

@@ -36,7 +36,7 @@ public struct LegacyNSGeometryFunctionsRule: CorrectableRule, ConfigurationProvi
             // "rect.divide(atDistance: 10.2, fromEdge: edge)", No correction available for divide
             "rect1.contains(rect2)",
             "rect.contains(point)",
-            "rect1.intersects(rect2)",
+            "rect1.intersects(rect2)"
         ],
         triggeringExamples: [
             "↓NSWidth(rect)",

Source/SwiftLintFramework/Rules/MarkRule.swift

@@ -35,7 +35,7 @@ public struct MarkRule: ConfigurationProviderRule {
             "//MARK: - bad",
             "//MARK:- bad",
             "//MARK: -bad",
-            "//MARK:-bad",
+            "//MARK:-bad"
         ]
     )
 

Source/SwiftLintFramework/Rules/NimbleOperatorRule.swift

@@ -38,7 +38,7 @@ public struct NimbleOperatorRule: ConfigurationProviderRule, OptInRule {
             "↓expect(10).to(beLessThan(11))\n",
             "↓expect(10).to(beLessThanOrEqualTo(10))\n",
             "↓expect(x).to(beIdenticalTo(x))\n",
-            "expect(10) > 2\n ↓expect(10).to(beGreaterThan(2))\n",
+            "expect(10) > 2\n ↓expect(10).to(beGreaterThan(2))\n"
         ]
     )
 

Source/SwiftLintFramework/Rules/PrivateOutletRule.swift

@@ -23,11 +23,11 @@ public struct PrivateOutletRule: ASTRule, OptInRule, ConfigurationProviderRule {
             "class Foo {\n  @IBOutlet private var label: UILabel!\n}\n",
             "class Foo {\n  var notAnOutlet: UILabel\n}\n",
             "class Foo {\n  @IBOutlet weak private var label: UILabel?\n}\n",
-            "class Foo {\n  @IBOutlet private weak var label: UILabel?\n}\n",
+            "class Foo {\n  @IBOutlet private weak var label: UILabel?\n}\n"
         ],
         triggeringExamples: [
             "class Foo {\n  @IBOutlet var label: UILabel?\n}\n",
-            "class Foo {\n  @IBOutlet var label: UILabel!\n}\n",
+            "class Foo {\n  @IBOutlet var label: UILabel!\n}\n"
         ]
     )
 

Source/SwiftLintFramework/Rules/PrivateUnitTestRule.swift

@@ -103,7 +103,7 @@ public struct PrivateUnitTestRule: ASTRule, ConfigurationProviderRule {
                 "internal func test2() {}\n " +
                 "public func test3() {}\n " +
                 "private ↓func test4() {}\n " +
-            "}",
+            "}"
         ]
     )
 

Source/SwiftLintFramework/Rules/ReturnArrowWhitespaceRule.swift

@@ -46,7 +46,7 @@ public struct ReturnArrowWhitespaceRule: CorrectableRule, ConfigurationProviderR
             "func abc()\n  ->  Int {}\n": "func abc()\n  -> Int {}\n",
             "func abc()\n->  Int {}\n": "func abc()\n-> Int {}\n",
             "func abc()  ->\n  Int {}\n": "func abc() ->\n  Int {}\n",
-            "func abc()  ->\nInt {}\n": "func abc() ->\nInt {}\n",
+            "func abc()  ->\nInt {}\n": "func abc() ->\nInt {}\n"
         ]
     )
 
@@ -101,7 +101,7 @@ public struct ReturnArrowWhitespaceRule: CorrectableRule, ConfigurationProviderR
             "(\(incorrectSpace)\\->\(space)*)",
             "(\(space)\\->\(incorrectSpace))",
             "\\n\(space)*\\->\(incorrectSpace)",
-            "\(incorrectSpace)\\->\\n\(space)*",
+            "\(incorrectSpace)\\->\\n\(space)*"
         ]
 
         // ex: `func abc()-> Int {` & `func abc() ->Int {`

Source/SwiftLintFramework/Rules/RuleConfigurations/TrailingCommaConfiguration.swift

@@ -0,0 +1,39 @@
+//
+//  TrailingCommaConfiguration.swift
+//  SwiftLint
+//
+//  Created by Marcelo Fabri on 25/11/16.
+//  Copyright © 2016 Realm. All rights reserved.
+//
+
+import Foundation
+
+public struct TrailingCommaConfiguration: RuleConfiguration, Equatable {
+    private(set) var severityConfiguration = SeverityConfiguration(.Warning)
+    private(set) var mandatoryComma: Bool
+
+    public var consoleDescription: String {
+        return severityConfiguration.consoleDescription + ", mandatory_comma: \(mandatoryComma)"
+    }
+
+    public init(mandatoryComma: Bool = false) {
+        self.mandatoryComma = mandatoryComma
+    }
+
+    public mutating func applyConfiguration(configuration: AnyObject) throws {
+        guard let configuration = configuration as? [String: AnyObject] else {
+            throw ConfigurationError.UnknownConfiguration
+        }
+
+        mandatoryComma = (configuration["mandatory_comma"] as? Bool == true)
+
+        if let severityString = configuration["severity"] as? String {
+            try severityConfiguration.applyConfiguration(severityString)
+        }
+    }
+}
+
+public func == (lhs: TrailingCommaConfiguration,
+                rhs: TrailingCommaConfiguration) -> Bool {
+    return lhs.mandatoryComma == rhs.mandatoryComma
+}

Source/SwiftLintFramework/Rules/StatementPositionRule.swift

@@ -55,7 +55,7 @@ public struct StatementPositionRule: CorrectableRule, ConfigurationProviderRule
             "\n\n  }\n  catch {",
             "\"}\nelse{\"",
             "struct A { let catchphrase: Int }\nlet a = A(\n catchphrase: 0\n)",
-            "struct A { let `catch`: Int }\nlet a = A(\n `catch`: 0\n)",
+            "struct A { let `catch`: Int }\nlet a = A(\n `catch`: 0\n)"
         ],
         triggeringExamples: [
             "↓  }else if {",

Source/SwiftLintFramework/Rules/SyntacticSugarRule.swift

@@ -35,7 +35,7 @@ public struct SyntacticSugarRule: Rule, ConfigurationProviderRule {
             "let x: ↓ImplicitlyUnwrappedOptional<Int>",
             "func x(a: ↓Array<Int>, b: Int) -> [Int: Any]",
             "func x(a: [Int], b: Int) -> ↓Dictionary<Int, String>",
-            "func x(a: ↓Array<Int>, b: Int) -> ↓Dictionary<Int, String>",
+            "func x(a: ↓Array<Int>, b: Int) -> ↓Dictionary<Int, String>"
         ]
     )
 

Source/SwiftLintFramework/Rules/TrailingCommaRule.swift

@@ -0,0 +1,111 @@
+//
+//  TrailingCommaRule.swift
+//  SwiftLint
+//
+//  Created by Marcelo Fabri on 21/11/16.
+//  Copyright © 2016 Realm. All rights reserved.
+//
+
+import Foundation
+import SourceKittenFramework
+
+public struct TrailingCommaRule: ASTRule, ConfigurationProviderRule {
+    public var configuration = TrailingCommaConfiguration()
+
+    public init() {}
+
+    public static let description = RuleDescription(
+        identifier: "trailing_comma",
+        name: "Trailing Comma",
+        description: "Trailing commas in arrays and dictionaries should be avoided/enforced.",
+        nonTriggeringExamples: [
+            "let foo = [1, 2, 3]\n",
+            "let foo = []\n",
+            "let foo = [:]\n",
+            "let foo = [1: 2, 2: 3]\n"
+        ],
+        triggeringExamples: [
+            "let foo = [1, 2, 3↓,]\n",
+            "let foo = [1, 2, 3↓, ]\n",
+            "let foo = [1, 2, 3   ↓,]\n",
+            "let foo = [1: 2, 2: 3↓, ]\n",
+            "struct Bar {\n let foo = [1: 2, 2: 3↓, ]\n}\n",
+            "let foo = [1, 2, 3↓,] + [4, 5, 6↓,]\n"
+        ]
+    )
+
+    public func validateFile(file: File,
+                             kind: SwiftExpressionKind,
+                             dictionary: [String: SourceKitRepresentable]) -> [StyleViolation] {
+
+        let allowedKinds: [SwiftExpressionKind] = [.Array, .Dictionary]
+
+        guard let bodyOffset = (dictionary["key.bodyoffset"] as? Int64).flatMap({ Int($0) }),
+            bodyLength = (dictionary["key.bodylength"] as? Int64).flatMap({ Int($0) }),
+            elements = dictionary["key.elements"]  as? [SourceKitRepresentable]
+            where allowedKinds.contains(kind) else {
+                return []
+        }
+
+        let endPositions = elements.flatMap { element -> Int? in
+            guard let dictionary = element as? [String: SourceKitRepresentable],
+                offset = (dictionary["key.offset"] as? Int64).flatMap({ Int($0) }),
+                length = (dictionary["key.length"] as? Int64).flatMap({ Int($0) }) else {
+                    return nil
+            }
+
+            return offset + length
+        }
+
+        guard let lastPosition = endPositions.maxElement() else {
+            return []
+        }
+
+        let length = bodyLength + bodyOffset - lastPosition
+        let contentsAfterLastElement = file.contents
+            .substringWithByteRange(start: lastPosition, length: length) ?? ""
+
+        // if a trailing comma is not present
+        guard let commaIndex = contentsAfterLastElement.lastIndexOf(",") else {
+            guard configuration.mandatoryComma else {
+                return []
+            }
+
+            return violations(file, byteOffset: lastPosition)
+        }
+
+        // trailing comma is present, which is a violation if mandatoryComma is false
+        guard !configuration.mandatoryComma else {
+            return []
+        }
+
+        let violationOffset = lastPosition + commaIndex
+        return violations(file, byteOffset: violationOffset)
+    }
+
+    private func violations(file: File, byteOffset: Int) -> [StyleViolation] {
+        return [
+            StyleViolation(ruleDescription: self.dynamicType.description,
+                severity: configuration.severityConfiguration.severity,
+                location: Location(file: file, byteOffset: byteOffset)
+            )
+        ]
+    }
+}
+
+public enum SwiftExpressionKind: String {
+    case Array = "source.lang.swift.expr.array"
+    case Dictionary = "source.lang.swift.expr.dictionary"
+    case Other
+
+    public init?(rawValue: String) {
+        switch rawValue {
+        case Array.rawValue:
+            self = .Array
+        case Dictionary.rawValue:
+            self = .Dictionary
+        default:
+            self = .Other
+        }
+    }
+}

Source/SwiftLintFramework/Rules/ValidDocsRule.swift

@@ -193,7 +193,7 @@ public struct ValidDocsRule: ConfigurationProviderRule {
             "/// docs\n/// - throws: NSError\n/// - returns: false" +
                 "\nfunc a() throws -> Bool { return true }",
             "/// docs\n/// - parameter param: this is a closure\n/// - returns: Bool" +
-                "\nfunc a(param: (Void throws -> Bool)) -> Bool { return true }",
+                "\nfunc a(param: (Void throws -> Bool)) -> Bool { return true }"
         ],
         triggeringExamples: [
             "/// docs\npublic ↓func a(param: Void) {}\n",
@@ -223,7 +223,7 @@ public struct ValidDocsRule: ConfigurationProviderRule {
                 "\nfunc a(param: () -> Void) -> Foo<Void> {return Foo<Void>}",
             "/// docs\n/// - parameter param: this is a void closure" +
                 "\nfunc a(param: () -> Void) -> Foo<[Int]> {return Foo<[Int]>}",
-            "/// docs\nfunc a() throws -> Bool { return true }",
+            "/// docs\nfunc a() throws -> Bool { return true }"
         ]
     )