[CPFeature-003] Finished the working part, but still need some clean up

Author: enuance

Sources/CommitPrefix/CLIArguments.swift

@@ -30,64 +30,110 @@ import SPMUtility
 public struct CLIArguments {
 
     public enum UserCommand {
-        case delete
-        case view
-        case newEntry(entry: String)
+        case viewState
+        case outputPrefixes
+        case deletePrefixes
+        case modeNormal
+        case modeBranchParse(validator: String)
+        case newPrefixes(value: String)
+    }
+    
+    private enum ParsedCommand {
+        case viewState
+        case outputPrefixes
+        case deletePrefixes
+        case modeNormal
+        case modeBranchParse
+        case userEntry(value: String)
     }
 
     private let parser: ArgumentParser
     private let rawArgs: [String]
 
-    private let delete: OptionArgument<Bool>
-    private let view: OptionArgument<Bool>
-    private let newEntry: PositionalArgument<[String]>
+    private let outputPrefixes: OptionArgument<Bool>
+    private let deletePrefixes: OptionArgument<Bool>
+    private let modeNormal: OptionArgument<Bool>
+    private let modeBranchParse: OptionArgument<Bool>
+    private let userEntry: PositionalArgument<[String]>
 
     public init(arguments: [String] = CommandLine.arguments) {
         // The first argument specifies the path of the executable file
         self.rawArgs = Array(arguments.dropFirst())
         let argBuilder = ArgumentBuilder()
         self.parser = argBuilder.buildParser()
-        self.delete = argBuilder.buildDeleteArgument(parser: parser)
-        self.view = argBuilder.buildViewArgument(parser: parser)
-        self.newEntry = argBuilder.buildNewEntryArgument(parser: parser)
+        
+        self.outputPrefixes = argBuilder.buildOutputArgument(parser: parser)
+        self.deletePrefixes = argBuilder.buildDeleteArgument(parser: parser)
+        self.modeNormal = argBuilder.buildNormalArgument(parser: parser)
+        self.modeBranchParse = argBuilder.buildBranchParseArgument(parser: parser)
+        self.userEntry = argBuilder.buildUserEntryArgument(parser: parser)
     }
 
+    private func singleCommandParse(_ allCommands: [ParsedCommand]) throws -> UserCommand {
+        precondition(allCommands.count == 1, "Intended for single Parsed Command only!")
+        guard let foundCommand = allCommands.first else {
+            throw CPError.userCommandNotRecognized
+        }
+        
+        switch foundCommand {
+        case .outputPrefixes:
+            return .outputPrefixes
+        case .deletePrefixes:
+            return .deletePrefixes
+        case .modeNormal:
+            return .modeNormal
+        case .userEntry(value: let prefixes):
+            return .newPrefixes(value: prefixes)
+        default:
+            throw CPError.userCommandNotRecognized
+        }
+    }
+    
+    private func doubleCommandParse(_ allCommands: [ParsedCommand]) throws -> UserCommand {
+        precondition(allCommands.count == 2, "Intended for two Parsed Commands only!")
+        let firstCommand = allCommands[0]
+        let secondCommand = allCommands[1]
+        
+        switch (firstCommand, secondCommand) {
+        case (.modeBranchParse, .userEntry(value: let validator)):
+            return .modeBranchParse(validator: validator)
+        case (.userEntry(value: let validator), .modeBranchParse):
+            return .modeBranchParse(validator: validator)
+        default:
+            throw CPError.userCommandNotRecognized
+        }
+    }
+    
     func getCommand() throws -> UserCommand {
         guard let parsedArgs = try? parser.parse(rawArgs) else {
             throw CPError.userCommandNotRecognized
         }
 
-        var allCommands = [UserCommand]()
+        var allCommands = [ParsedCommand]()
 
-        parsedArgs.get(delete).map { _ in allCommands.append(.delete) }
-        parsedArgs.get(view).map { _ in allCommands.append(.view) }
-        try parsedArgs.get(newEntry).map { userEntry in
-            
-            guard userEntry.count < 2 else {
-                throw CPError.newEntryShouldNotHaveSpaces
-            }
-            
-            guard let theEntry = userEntry.first else {
-                throw CPError.emptyEntry
-            }
-            
-            guard !theEntry.isEmpty else {
-                throw CPError.emptyEntry
-            }
-            
-            allCommands.append(.newEntry(entry: theEntry))
-            
-        }
+        parsedArgs.get(outputPrefixes).map { _ in allCommands.append(.outputPrefixes) }
+        parsedArgs.get(deletePrefixes).map { _ in allCommands.append(.deletePrefixes) }
+        parsedArgs.get(modeNormal).map { _ in allCommands.append(.modeNormal) }
+        parsedArgs.get(modeBranchParse).map { _ in allCommands.append(.modeBranchParse) }
 
-        guard allCommands.count < 2 else {
-            throw CPError.multipleArguments
+        try parsedArgs.get(userEntry).map { userEntry in
+            let noMoreThanOneEntry = userEntry.count < 2
+            guard noMoreThanOneEntry else { throw CPError.newEntryShouldNotHaveSpaces }
+            guard let theEntry = userEntry.first else { throw CPError.emptyEntry }
+            allCommands.append(.userEntry(value: theEntry))
         }
 
-        guard let command = allCommands.first else {
-            throw CPError.userCommandNotRecognized
+        switch allCommands.count {
+        case 0:
+            return .viewState
+        case 1:
+            return try singleCommandParse(allCommands)
+        case 2:
+            return try doubleCommandParse(allCommands)
+        default:
+            throw CPError.multipleArguments
         }
 
-        return command
     }
 
 }
@@ -108,30 +154,50 @@ private struct ArgumentBuilder {
     func buildParser() -> ArgumentParser {
         ArgumentParser(usage: usage, overview: overview)
     }
-
+    
+    func buildOutputArgument(parser: ArgumentParser) -> OptionArgument<Bool> {
+        return parser.add(
+            option: "--output",
+            shortName: "-o",
+            kind: Bool.self,
+            usage: "Outputs the full, formated prefix to standard output",
+            completion: nil
+        )
+    }
+    
     func buildDeleteArgument(parser: ArgumentParser) -> OptionArgument<Bool> {
         return parser.add(
             option: "--delete",
             shortName: "-d",
             kind: Bool.self,
-            usage: "Deletes the stored prefix",
+            usage: "Deletes the stored prefixes",
             completion: nil
         )
     }
 
-    func buildViewArgument(parser: ArgumentParser) -> OptionArgument<Bool> {
+    func buildNormalArgument(parser: ArgumentParser) -> OptionArgument<Bool> {
+        return parser.add(
+            option: "--normal",
+            shortName: "-n",
+            kind: Bool.self,
+            usage: "Sets the mode to NORMAL",
+            completion: nil
+        )
+    }
+    
+    func buildBranchParseArgument(parser: ArgumentParser) -> OptionArgument<Bool> {
         return parser.add(
-            option: "--view",
-            shortName: "-v",
+            option: "--branchParse",
+            shortName: "-b",
             kind: Bool.self,
-            usage: "Display the currently stored prefix",
+            usage: "Sets the mode to BRANCH_PARSE. Requires a validator",
             completion: nil
         )
     }
 
-    func buildNewEntryArgument(parser: ArgumentParser) -> PositionalArgument<[String]> {
+    func buildUserEntryArgument(parser: ArgumentParser) -> PositionalArgument<[String]> {
         return parser.add(
-            positional: "NewEntry",
+            positional: "UserEntry",
             kind: [String].self,
             optional: true,
             usage: nil,

Sources/CommitPrefix/CPDebugPrint.swift

@@ -35,10 +35,10 @@ private let isDebugMode = false
 /// A Debug Printer that only prints in debug mode
 public func cpDebugPrint(_ value: Any, file: String = #file, line: Int = #line, function: String = #function) {
     guard isDebugMode else { return }
-    print("/n", "********** Commit Prefix Debug **********")
+    print("********** Commit Prefix Debug **********")
     print("File: \(file)")
     print("Line: \(line)")
     print("Function: \(function)")
     print("value: ", value)
-    print("*****************************************", "/n")
+    print("*****************************************")
 }

Sources/CommitPrefix/CPError.swift

@@ -36,7 +36,7 @@ enum CPError: Error {
     case fileReadWriteError
     case directoryNotFound(name: String, path: String)
     case hookReadWriteError
-    case expectedYesOrNo
+    case branchValidatorFormatError
 
     var message: String {
         switch self {
@@ -47,7 +47,7 @@ enum CPError: Error {
         case .emptyEntry:
             return "Your entry is empty."
         case .multipleArguments:
-            return "Multiple arguments entered. Only one at a time is supported."
+            return "Too many arguments entered. Only two at a time is supported."
         case .notAGitRepo(currentLocation: let location):
             return "Not in a git repo or at the root of one: \(location)"
         case .fileReadWriteError:
@@ -56,8 +56,35 @@ enum CPError: Error {
             return "Directory named \(name) was not found at \(path)"
         case .hookReadWriteError:
             return "An error occured while reading or writing to the commit-msg hook"
+        case .branchValidatorFormatError:
+            return "The branch validator must be at least two characters long "
+            + "and contain no numbers or spaces"
+        }
+        
+    }
+    
+}
+
+enum CPTermination: Error {
+    
+    case overwriteCancelled
+    case expectedYesOrNo
+    case branchValidatorNotPresent
+    case invalidBranchPrefix(validator: String)
+    
+    var message: String {
+        switch self {
+        case .overwriteCancelled:
+            return "Overwrite is cancelled"
         case .expectedYesOrNo:
-            return "expected y or n. The transaction has been cancelled."
+            return "Expected y or n. The transaction has been cancelled."
+        case .branchValidatorNotPresent:
+            return "Attempting to provide a branch prefix without a branch validator"
+        case .invalidBranchPrefix(validator: let validator):
+            return """
+            Your branch does not begin with \(validator) and is invalid.
+            Either change your branch name or use commitPrefix in non-branch mode.
+            """
         }
 
     }

Sources/CommitPrefix/CPFileHandler.swift

@@ -29,51 +29,52 @@ import Files
 
 public struct CPFileHandler {
 
-    private let commitPrefixFile: File
-    private let commitMessageHook: CommitMessageHook
+    private let cpInteractor: CPInteractor
 
     public init() throws {
-        let currentDirectory = Folder.current
-        let correctLocation = currentDirectory.containsSubfolder(named: FolderName.git)
-        guard correctLocation else {
-            throw CPError.notAGitRepo(currentLocation: currentDirectory.path)
+        guard Folder.current.containsSubfolder(named: FolderName.git) else {
+            throw CPError.notAGitRepo(currentLocation: Folder.current.path)
         }
-        let gitDirectory = try currentDirectory.subfolder(named: FolderName.git)
-        self.commitPrefixFile = try gitDirectory.createFileIfNeeded(withName: FileName.commitPrefix)
-        self.commitMessageHook = try CommitMessageHook(gitDirectory: gitDirectory)
+        let gitDirectory = try Folder.current.subfolder(named: FolderName.git)
+        self.cpInteractor = try CPInteractor(gitDirectory: gitDirectory)
+        try CommitMessageHook.findOrCreate(with: gitDirectory)
     }
 
-    public func locateOrCreateHook() throws {
-        try commitMessageHook.locateOrCreateHook()
+    public func outputPrefixes() throws -> String {
+        try cpInteractor.outputPrefixes()
     }
 
-    public func outputPrefix() throws -> String {
-        let contents = try? commitPrefixFile.readAsString(encodedAs: .utf8)
-        guard let readContents = contents else {
-            throw CPError.fileReadWriteError
+    public func viewState() throws -> String {
+        let cpState = try cpInteractor.getCommitPrefixState()
+        switch cpState.mode {
+        case .normal:
+            return """
+            CommitPrefix MODE NORMAL
+            - prefixes: \(cpState.normalPrefixes.joined())
+            """
+        case .branchParse:
+            return """
+            CommitPrefix MODE BRANCH_PARSE
+            - branch prefixes: \(cpState.branchPrefixes.joined())
+            - stored prefixes: \(cpState.normalPrefixes.joined())
+            """
         }
-        return readContents
     }
 
-    public func deletePrefix() throws -> String {
-        do {
-            try commitPrefixFile.write("", encoding: .utf8)
-        } catch {
-            throw CPError.fileReadWriteError
-        }
-        return "CommitPrefix Deleted"
+    public func deletePrefixes() throws -> String {
+        try cpInteractor.deletePrefixes()
     }
 
-    public func writeNew(prefix: String) throws -> String {
-        let bracketSet = CharacterSet(charactersIn: "[]")
-        let debracketedPrefix = prefix.trimmingCharacters(in: bracketSet)
-        let formattedPrefix = "[\(debracketedPrefix)]"
-        do {
-            try commitPrefixFile.write(formattedPrefix, encoding: .utf8)
-        } catch {
-            throw CPError.fileReadWriteError
-        }
-        return formattedPrefix
+    public func writeNew(prefixes rawValue: String) throws -> String {
+        try cpInteractor.writeNew(prefixes: rawValue)
+    }
+    
+    public func activateBranchMode(with validator: String) throws -> String {
+        try cpInteractor.activateBranchMode(with: validator)
+    }
+    
+    public func activateNormalMode() throws -> String {
+        try cpInteractor.activateNormalMode()
     }
 
 }