[Implementation] Add implementation for commit lint

- lint itself and its configuraiton

Author: Wei Sun

Sources/DangerSwiftCommitLint/CommitChecker/BodyEmptyLineCheck.swift

@@ -1,12 +1,12 @@
 import Foundation
 
-struct BodyEmptyLineCheck: CommitChecker {
-    static var warningMessage = "Please separate commit message subject from body with newline."
+struct BodyEmptyLineCheck: CommitChecker, Hashable {
+    static var checkerMessage = "Please separate commit message subject from body with newline."
 
     private let bodyLinesOfText: [String]
 
-    init(message: CommitMessage) {
-        bodyLinesOfText = message.bodyLinesOfText
+    init(_ commitMessage: CommitMessage) {
+        bodyLinesOfText = commitMessage.bodyLinesOfText
     }
 
     var fail: Bool {

Sources/DangerSwiftCommitLint/CommitChecker/CommitChecker.swift

@@ -1,16 +1,17 @@
 import Foundation
 
-protocol CommitChecker: Hashable {
-    static var warningMessage: String { get }
+public protocol CommitChecker {
+    static var checkerMessage: String { get }
+
     var fail: Bool { get }
 
-    init(message: CommitMessage)
+    init(_ commitMessage: CommitMessage)
 
-    static func fail(message: CommitMessage) -> Bool
+    static func fail(_ commitMessage: CommitMessage) -> Bool
 }
 
-extension CommitChecker {
-    static func fail(message: CommitMessage) -> Bool {
-        Self(message: message).fail
+public extension CommitChecker {
+    static func fail(_ commitMessage: CommitMessage) -> Bool {
+        Self(commitMessage).fail
     }
 }

Sources/DangerSwiftCommitLint/CommitChecker/CommitMessage.swift

@@ -1,13 +1,14 @@
 import Danger
 import Foundation
 
-struct CommitMessage: Hashable {
+/// An abstraction of GitHub commit message.
+public struct CommitMessage: Hashable {
     /// First line of the commit message
-    let subject: String
+    public let subject: String
     /// Rest of the commit message
-    let bodyLinesOfText: [String]
+    public let bodyLinesOfText: [String]
     // Commit SHA value
-    let sha: String
+    public let sha: String?
 
     init(
         subject: String,
@@ -19,10 +20,21 @@ struct CommitMessage: Hashable {
         self.sha = sha
     }
 
-    init(_ commit: GitHub.Commit) {
+    /// Initialize CommitMessage with `Danger.GitHub.Commit.CommitData.message`.
+    /// - Parameter commit: An instance of `GitHub.Commit`
+    public init(_ commit: GitHub.Commit) {
         let commitMessageLines = commit.commit.message.components(separatedBy: .newlines)
         subject = commitMessageLines.first ?? ""
         bodyLinesOfText = Array(commitMessageLines.dropFirst())
         sha = commit.sha
     }
+
+    /// Initialize `CommitMessage` with `Danger.Git.Commit.message`
+    /// - Parameter gitCommit: An instance of `Danger.Git.Commit`
+    public init(_ gitCommit: Git.Commit) {
+        let commitMessageLines = gitCommit.message.components(separatedBy: .newlines)
+        subject = commitMessageLines.first ?? ""
+        bodyLinesOfText = Array(commitMessageLines.dropFirst())
+        sha = gitCommit.sha
+    }
 }

Sources/DangerSwiftCommitLint/CommitChecker/SubjectCapCheck.swift

@@ -1,12 +1,12 @@
 import Foundation
 
-struct SubjectCapCheck: CommitChecker {
-    static let warningMessage = "Please start commit message subject with capital letter."
+struct SubjectCapCheck: CommitChecker, Hashable {
+    static let checkerMessage = "Please start commit message subject with capital letter."
 
     private let firstCharacter: Character?
 
-    init(message: CommitMessage) {
-        firstCharacter = message.subject.first
+    init(_ commitMessage: CommitMessage) {
+        firstCharacter = commitMessage.subject.first
     }
 
     var fail: Bool {

Sources/DangerSwiftCommitLint/CommitChecker/SubjectLengthCheck.swift

@@ -1,17 +1,17 @@
 import Foundation
 
-struct SubjectLengthCheck: CommitChecker {
+struct SubjectLengthCheck: CommitChecker, Hashable {
     private enum GeneratedSubjectPattern {
         static let git = #"^Merge branch '.+' into "#
         static let gitHub = #"^Merge pull request #\d+ from "#
     }
 
-    static let warningMessage = "Please limit commit message subject line to 50 characters."
+    static let checkerMessage = "Please limit commit message subject line to 50 characters."
 
     private let subject: String
 
-    init(message: CommitMessage) {
-        subject = message.subject
+    init(_ commitMessage: CommitMessage) {
+        subject = commitMessage.subject
     }
 
     var fail: Bool {

Sources/DangerSwiftCommitLint/CommitChecker/SubjectPeriodCheck.swift

@@ -1,12 +1,12 @@
 import Foundation
 
-struct SubjectPeriodCheck: CommitChecker {
-    static var warningMessage = "Please remove period from end of commit message subject line."
+struct SubjectPeriodCheck: CommitChecker, Hashable {
+    static var checkerMessage = "Please remove period from end of commit message subject line."
 
     private let subject: String
 
-    init(message: CommitMessage) {
-        subject = message.subject
+    init(_ commitMessage: CommitMessage) {
+        subject = commitMessage.subject
     }
 
     var fail: Bool {

Sources/DangerSwiftCommitLint/CommitChecker/SubjectWordCheck.swift

@@ -1,12 +1,12 @@
 import Foundation
 
-struct SubjectWordCheck: CommitChecker {
-    static var warningMessage = "Please use more than one word in commit message."
+struct SubjectWordCheck: CommitChecker, Hashable {
+    static var checkerMessage = "Please use more than one word in commit message."
 
     private let subject: String
 
-    init(message: CommitMessage) {
-        subject = message.subject
+    init(_ commitMessage: CommitMessage) {
+        subject = commitMessage.subject
     }
 
     var fail: Bool {

Sources/DangerSwiftCommitLint/Configuration.swift

@@ -0,0 +1,108 @@
+import Foundation
+
+public extension DangerSwiftCommitLint {
+    struct Configuration {
+        /// All commit checkers provided by `DangerSwiftCommitLint`
+        public enum CommitCheckerType: CaseIterable, Hashable {
+            /// Commit subject and body are separated by an empty line (`CommitChecker/BodyEmptyLineCheck`)
+            case bodyEmptyLine
+            /// Commit subject begins with a capital letter (`CommitChecker/SubjectCapCheck`)
+            case subjectCapCheck
+            /// Commit subject is no longer than 50 characters (`CommitChecker/SubjectLengthCheck`)
+            case subjectLengthCheck
+            /// Commit subject does not end in a period (`CommitChecker/SubjectPeriodCheck`)
+            case subjectPeriodCheck
+            /// Commit subject is more than one word (`CommitChecker/SubjectWordCheck`)
+            case subjectWordCheck
+        }
+
+        /// Checker selection
+        public enum CommitCheckerSelection {
+            /// Select all checkers
+            case all
+            /// Select a set of checkers
+            case selected(Set<CommitCheckerType>)
+        }
+
+        private let disabled: CommitCheckerSelection
+        private let warn: CommitCheckerSelection
+        private let fail: CommitCheckerSelection
+        let limit: Int
+        private let customCheckers: [CommitChecker.Type]
+
+        /// Initialize the configuraiton.
+        /// - Parameters:
+        ///   - disabled: The selected checks to skip.
+        ///   - warn: The selected checks to warn on.
+        ///   - fail: The selected checks to fail on.
+        ///   - limit: The number of commits to check.
+        ///   - customCheckers: An array of custom checkers.
+        public init(
+            disabled: CommitCheckerSelection = .selected([]),
+            warn: CommitCheckerSelection = .selected([]),
+            fail: CommitCheckerSelection = .all,
+            limit: Int = 0,
+            customCheckers: [CommitChecker.Type] = []
+        ) {
+            self.disabled = disabled
+            self.warn = warn
+            self.fail = fail
+            self.limit = limit
+            self.customCheckers = customCheckers
+        }
+    }
+}
+
+extension DangerSwiftCommitLint.Configuration {
+    static var defaultCheckers: [CommitChecker.Type] {
+        CommitCheckerType.allCases.map(\.type)
+    }
+
+    var allCheckers: [CommitChecker.Type] {
+        Self.defaultCheckers + customCheckers
+    }
+
+    var disabledCheckers: [CommitChecker.Type] {
+        switch disabled {
+        case .all:
+            return allCheckers
+        case let .selected(disabled):
+            return disabled.map(\.type)
+        }
+    }
+
+    var enabledCheckers: [CommitChecker.Type] {
+        allCheckers.filter { checker in
+            disabledCheckers.contains { $0 == checker } == false
+        }
+    }
+
+    var warningCheckers: [CommitChecker.Type] {
+        switch warn {
+        case .all:
+            return allCheckers
+        case let .selected(warningCheckers):
+            return enabledCheckers.filter { type in
+                warningCheckers.map(\.type).contains { $0 == type }
+            }
+        }
+    }
+
+    var failingCheckers: [CommitChecker.Type] {
+        enabledCheckers.filter { type in
+            warningCheckers.contains { $0 == type } == false
+        }
+    }
+}
+
+private extension DangerSwiftCommitLint.Configuration.CommitCheckerType {
+    var type: CommitChecker.Type {
+        switch self {
+        case .bodyEmptyLine: return BodyEmptyLineCheck.self
+        case .subjectCapCheck: return SubjectCapCheck.self
+        case .subjectLengthCheck: return SubjectCapCheck.self
+        case .subjectPeriodCheck: return SubjectPeriodCheck.self
+        case .subjectWordCheck: return SubjectWordCheck.self
+        }
+    }
+}

Sources/DangerSwiftCommitLint/DangerSwiftCommitLint.swift

@@ -1,4 +1,69 @@
 import Danger
 import Foundation
 
-public final class DangerSwiftCommitLint {}
+public final class DangerSwiftCommitLint {
+    private enum Constants {
+        static let disableAllChecksMessage = "All checks were disabled, nothing to do."
+    }
+
+    private let danger: DangerDSL
+    private var configuration: Configuration!
+
+    /// Initialize an instance of the linter
+    /// - Parameters:
+    ///   - danger: An instance of `Danger.DangerDSL`.
+    ///   - configuration: Linter configuration.
+    init(danger: DangerDSL = Danger(), configuration: Configuration) {
+        self.danger = danger
+        self.configuration = configuration
+    }
+
+    /// Lints the PR commits.
+    public func check() {
+        if configuration.enabledCheckers.isEmpty {
+            danger.warn(Constants.disableAllChecksMessage)
+        } else {
+            checkMessages()
+        }
+    }
+}
+
+extension DangerSwiftCommitLint {
+    var commitMessages: [CommitMessage] {
+        let messages = danger.git.commits.map { CommitMessage($0) }
+        guard configuration.limit > 0 else {
+            return messages
+        }
+
+        return Array(messages.suffix(configuration.limit))
+    }
+
+    func checkMessages() {
+        // Checkers that warn the danger job.
+        configuration.warningCheckers.checkCommitMessages(commitMessages, checkerResultHanler: warning(_:shas:))
+
+        // Checkers that fail the danger job.
+        configuration.failingCheckers.checkCommitMessages(commitMessages, checkerResultHanler: failing(_:shas:))
+    }
+
+    func warning(_ message: String, shas: [String]) {
+        let warningMessage = ([message] + shas).joined(separator: "\n")
+        danger.warn(warningMessage)
+    }
+
+    func failing(_ message: String, shas: [String]) {
+        let failingMessage = ([message] + shas).joined(separator: "\n")
+        danger.warn(failingMessage)
+    }
+}
+
+extension Array where Element == CommitChecker.Type {
+    func checkCommitMessages(_ commitMessages: [CommitMessage], checkerResultHanler: (String, [String]) -> Void) {
+        forEach { checker in
+            let shas = commitMessages.compactMap { checker.fail($0) ? $0.sha : nil }
+            if shas.isEmpty == false {
+                checkerResultHanler(checker.checkerMessage, shas)
+            }
+        }
+    }
+}

Tests/DangerSwiftCommitLintTests/CommitChecker/BodyEmptyLineCheckTests.swift

@@ -8,20 +8,20 @@ final class BodyEmptyLineCheckTests: XCTestCase {
     private let commitNoNewline = CommitMessage(subject: "Title Test", bodyLinesOfText: ["Body Test"], sha: "Test SHA")
 
     func testSuccessCommitSubjectAndBody() {
-        let testSubject = BodyEmptyLineCheck(message: commitSubjectAndBody)
+        let testSubject = BodyEmptyLineCheck(commitSubjectAndBody)
         XCTAssertFalse(testSubject.fail)
-        XCTAssertFalse(BodyEmptyLineCheck.fail(message: commitSubjectAndBody))
+        XCTAssertFalse(BodyEmptyLineCheck.fail(commitSubjectAndBody))
     }
 
     func testSuccessSubjectOnly() {
-        let testSubject = BodyEmptyLineCheck(message: commitSubjectOnly)
+        let testSubject = BodyEmptyLineCheck(commitSubjectOnly)
         XCTAssertFalse(testSubject.fail)
-        XCTAssertFalse(BodyEmptyLineCheck.fail(message: commitSubjectOnly))
+        XCTAssertFalse(BodyEmptyLineCheck.fail(commitSubjectOnly))
     }
 
     func testFailureNoNewlineOnly() {
-        let testSubject = BodyEmptyLineCheck(message: commitNoNewline)
+        let testSubject = BodyEmptyLineCheck(commitNoNewline)
         XCTAssertTrue(testSubject.fail)
-        XCTAssertTrue(BodyEmptyLineCheck.fail(message: commitNoNewline))
+        XCTAssertTrue(BodyEmptyLineCheck.fail(commitNoNewline))
     }
 }