Initial Version (work in progress)

Sources/Parser.swift

@@ -0,0 +1,131 @@
+//
+// Copyright © 2024 Salar Rahmanian.
+//	    
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//      http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+// limitations under the License.
+//
+	
+
+import Foundation
+
+
+func backupHistory(_ path: String) -> Bool {
+    let fileManager = FileManager.default
+        
+    guard fileManager.fileExists(atPath: path) else {
+        print("File does not exist at path: \(path)")
+        return false
+    }
+    
+    let fileURL = URL(fileURLWithPath: path)
+    let fileExtension = fileURL.pathExtension
+    let fileNameWithoutExtension = fileURL.deletingPathExtension().lastPathComponent
+    let directory = fileURL.deletingLastPathComponent()
+    
+    let newFileName = "\(fileNameWithoutExtension)_copy"
+    let newFileURL = directory.appendingPathComponent(newFileName).appendingPathExtension(fileExtension)
+    
+    do {
+        try fileManager.copyItem(at: fileURL, to: newFileURL)
+        print("File duplicated successfully to: \(newFileURL.path)")
+        return true
+    } catch {
+        return false
+    }
+}
+
+
+func writeFishHistory(to path: String, history: [FishHistoryEntry], historyFileLocation: String?, backup: Bool = true) -> Bool {
+    var output = ""
+    
+    if backup {
+        if let backupFile = historyFileLocation {
+            let result = backupHistory(backupFile)
+            if !result {
+                print("Failed to backup \(backupFile) so aborting!")
+                return false
+            }
+        }
+    }
+    
+    history.forEach { output += $0.writeEntry().joined(separator: "\n") + "\n" }
+    
+    if !output.isEmpty {
+        do {
+            try output.write(toFile: path, atomically: true, encoding: .utf8)
+            print("Successfully wrote merged history to \(path)")
+            return true
+        } catch {
+            print("Error writing merged history: \(error)")
+            return false
+        }
+    }
+    else {
+        print("Nothing to write to \(path)")
+        return false
+    }
+}
+
+func parseFishHistory(from filePath: String) -> [FishHistoryEntry]? {
+    guard let fileContents = try? String(contentsOfFile: filePath) else {
+        print("Failed to open file.")
+        return nil
+    }
+    
+    let lines = fileContents.split(separator: "\n").map { String($0).trimmingCharacters(in: .whitespaces) }
+
+    let initialState: (entries: [FishHistoryEntry], currentCmd: String?, currentWhen: Int?, currentPaths: [String]) = ([], nil, nil, [])
+    
+    let result = lines.reduce(into: initialState) { state, line in
+        if line.starts(with: "- cmd:") {
+            if let cmd = state.currentCmd, let when = state.currentWhen {
+                let entry = FishHistoryEntry(cmd: cmd, when: when, paths: state.currentPaths)
+                state.entries.append(entry)
+                state.currentPaths = []
+            }
+            state.currentCmd = String(line.dropFirst("- cmd:".count).trimmingCharacters(in: .whitespaces))
+        } else if line.starts(with: "when:") {
+            if let whenValue = Int(line.dropFirst("when:".count).trimmingCharacters(in: .whitespaces)) {
+                state.currentWhen = whenValue
+            }
+        } else if line.starts(with: "paths:") {
+            return
+        } else if line.starts(with: "- ") {
+            let path = String(line.dropFirst("- ".count).trimmingCharacters(in: .whitespaces))
+            state.currentPaths.append(path)
+        }
+    }
+    
+    if let cmd = result.currentCmd, let when = result.currentWhen {
+        let entry = FishHistoryEntry(cmd: cmd, when: when, paths: result.currentPaths)
+        return result.entries + [entry]
+    }
+    
+    return result.entries
+}
+
+func mergeFishHistory(_ left: [FishHistoryEntry], _ right: [FishHistoryEntry], removeDuplicates: Bool = false) -> [FishHistoryEntry] {
+    
+    let merged = left + right
+    
+    if removeDuplicates {
+        let finalList = merged.reduce(into: [String:FishHistoryEntry]()) { result, entry in
+            if result[entry.cmd] == nil {
+                result[entry.cmd] = entry
+            }
+        }
+        return Array(finalList.values)
+    } else {
+        return merged
+    }
+    
+}