First version: Basics work

Author: juri

.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj

Package.resolved

@@ -0,0 +1,16 @@
+{
+  "object": {
+    "pins": [
+      {
+        "package": "SwiftCLI",
+        "repositoryURL": "https://github.com/jakeheis/SwiftCLI",
+        "state": {
+          "branch": null,
+          "revision": "37f4a7f863f6fe76ce44fc0023f331eea0089beb",
+          "version": "5.2.0"
+        }
+      }
+    ]
+  },
+  "version": 1
+}

Package.swift

@@ -0,0 +1,28 @@
+// swift-tools-version:4.2
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "GitAnnotateTicket",
+    products: [
+        .executable(name: "annotate-git-commit", targets: ["GitAnnotateTicket"]),
+        .library(name: "GitAnnotateTicketKit", targets: ["GitAnnotateTicketKit"]),
+    ],
+    dependencies: [
+        .package(url: "https://github.com/jakeheis/SwiftCLI", from: "5.2.0"),
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
+        // Targets can depend on other targets in this package, and on products in packages which this package depends on.
+        .target(
+            name: "GitAnnotateTicket",
+            dependencies: ["GitAnnotateTicketKit"]),
+        .target(
+            name: "GitAnnotateTicketKit",
+            dependencies: ["SwiftCLI"]),
+        .testTarget(
+            name: "GitAnnotateTicketTests",
+            dependencies: ["GitAnnotateTicketKit"]),
+    ]
+)

Sources/GitAnnotateTicket/main.swift

@@ -0,0 +1,3 @@
+import GitAnnotateTicketKit
+
+runAnnotator()

Sources/GitAnnotateTicketKit/Annotate.swift

@@ -0,0 +1,98 @@
+import Foundation
+import SwiftCLI
+
+private let ticketPrefix = "Ticket: "
+
+struct AnnotatorError: Error {
+    let message: String
+}
+
+extension AnnotatorError: CustomStringConvertible {
+    var description: String {
+        return self.message
+    }
+}
+
+
+func messageHasTicket(_ message: String) -> Bool {
+    return message.split(separator: "\n").first(where: { $0.hasPrefix(ticketPrefix) }) != nil
+}
+
+func readBranch() throws -> String {
+    return try capture("git", arguments: ["rev-parse", "--abbrev-ref", "HEAD"]).stdout
+}
+
+func extractFirstMatch(of regexp: NSRegularExpression, in string: String) -> String? {
+    let fullNSRange = NSRange(location: 0, length: string.utf16.count)
+    guard
+        let result = regexp.firstMatch(in: string, options: [], range: fullNSRange),
+        result.numberOfRanges == 2,
+        let range = Range(result.range(at: 1), in: string)
+    else {
+        return nil
+    }
+    return String(string[range])
+}
+
+func makeTicketReader(branchReader: @escaping () throws -> String) -> (NSRegularExpression) throws -> String? {
+    return { regexp in
+        let branch = try branchReader()
+        guard let ticket = extractFirstMatch(of: regexp, in: branch) else {
+            throw AnnotatorError(message: "Couldn't find ticket in branch '\(branch)' with regexp '\(regexp.pattern)'")
+        }
+        return ticket
+    }
+}
+
+func makeMessageUpdater(
+    regexp: NSRegularExpression,
+    ticketReader: @escaping (NSRegularExpression) throws -> String?) -> (String) throws -> String
+{
+    return { message in
+        guard !messageHasTicket(message) else { return message }
+        guard let ticket = try ticketReader(regexp) else {
+            throw AnnotatorError(message: "Couldn't match ticket name in branch")
+        }
+
+        let messageWithTicket = message + (message.hasSuffix("\n\n") ? "" : "\n") + ticketPrefix + ticket + "\n"
+        return messageWithTicket
+    }
+}
+
+func updateFile(at url: URL, with updater: (String) throws -> String) throws {
+    let messageData = try Data(contentsOf: url)
+    guard let message = String(bytes: messageData, encoding: .utf8) else {
+        throw AnnotatorError(message: "Couldn't parse commit message in \(url)")
+    }
+    let updatedMessage = try updater(message)
+    try Data(updatedMessage.utf8).write(to: url, options: .atomic)
+}
+
+func parseRegexp(raw: String) throws -> NSRegularExpression {
+    let regexp = try NSRegularExpression(pattern: raw, options: [])
+    guard regexp.numberOfCaptureGroups == 1 else {
+        throw AnnotatorError(message: "Regexp must have one capture group for matching the ticket name")
+    }
+    return regexp
+}
+
+class AddTicket: Command {
+    let name = "add-ticket"
+    let rawRegexp = Parameter()
+    let file = Parameter()
+
+    func execute() throws {
+        try updateFile(
+            at: URL(fileURLWithPath: file.value, isDirectory: false),
+            with: makeMessageUpdater(
+                regexp: try parseRegexp(raw: rawRegexp.value),
+                ticketReader: makeTicketReader(branchReader: readBranch)))
+    }
+}
+
+public func runAnnotator() {
+    let argv = ProcessInfo.processInfo.arguments
+    let annotator = CLI(name: argv[0])
+    annotator.commands = [AddTicket()]
+    exit(annotator.go())
+}

Tests/GitAnnotateTicketTests/MessageUpdaterTests.swift

@@ -0,0 +1,36 @@
+//
+//  MessageUpdaterTests.swift
+//  git-branch-commitTests
+//
+//  Created by Juri Pakaste on 14/11/2018.
+//
+
+import XCTest
+@testable import GitAnnotateTicketKit
+
+let regexp = try! NSRegularExpression(pattern: "\\b(ch\\d+)\\b", options: [])
+let matchingBranch = "feature/ch1234/foo"
+let nonMatchingBranch = "feature/no-ticket-here"
+
+class MessageUpdaterTests: XCTestCase {
+    func testUpdateEmpty() throws {
+        let messageUpdater = makeMessageUpdater(regexp: regexp, ticketReader: makeTicketReader(branchReader: { matchingBranch }))
+        XCTAssertEqual(try messageUpdater(""), "\nTicket: ch1234\n")
+    }
+
+    func testUpdateNonEmpty() throws {
+        let messageUpdater = makeMessageUpdater(regexp: regexp, ticketReader: makeTicketReader(branchReader: { matchingBranch }))
+        XCTAssertEqual(try messageUpdater("lines\nof\ntext\n"), "lines\nof\ntext\n\nTicket: ch1234\n")
+    }
+
+    func testUpdateNonEmptyNoExtraLines() throws {
+        let messageUpdater = makeMessageUpdater(regexp: regexp, ticketReader: makeTicketReader(branchReader: { matchingBranch }))
+        XCTAssertEqual(try messageUpdater("lines\nof\ntext\n\n"), "lines\nof\ntext\n\nTicket: ch1234\n")
+    }
+
+    static var allTests = [
+        ("testUpdateEmpty", testUpdateEmpty),
+        ("testUpdateNonEmpty", testUpdateNonEmpty),
+        ("testUpdateNonEmptyNoExtraLines", testUpdateNonEmptyNoExtraLines),
+    ]
+}

Tests/GitAnnotateTicketTests/XCTestManifests.swift

@@ -0,0 +1,10 @@
+import XCTest
+
+#if !os(macOS)
+public func allTests() -> [XCTestCaseEntry] {
+    return [
+        testCase(GitAnnotateTicketTests.allTests),
+        testCase(MessageUpdaterTests.allTests)
+    ]
+}
+#endif

Tests/LinuxMain.swift

@@ -0,0 +1,7 @@
+import XCTest
+
+import GitAnnotateTicketTests
+
+var tests = [XCTestCaseEntry]()
+tests += GitAnnotateTicketTests.allTests()
+XCTMain(tests)