softinio/Fishee
1
0
Fork 0
mirror of https://github.com/softinio/Fishee.git synced 2025-02-22 13:36:04 -08:00
Code Issues Projects Releases Packages Wiki Activity Actions

swift format

Browse source
This commit is contained in:
Salar Rahmanian 2025-02-09 10:34:15 -08:00
parent f69cec36ac
commit 54edbfc36c
8 changed files with 407 additions and 395 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
Sources/Algebra.swift
View file

@ -18,27 +18,27 @@ import Foundation
/// Data Structure/Schema representing an entry in a fish history file. /// Data Structure/Schema representing an entry in a fish history file.
struct FishHistoryEntry: Equatable { struct FishHistoryEntry: Equatable {
let cmd: String let cmd: String
let when: Int let when: Int
let paths: [String] let paths: [String]
/// Converts time to Date object /// Converts time to Date object
func getDate() -> Date { func getDate() -> Date {
Date(timeIntervalSince1970: TimeInterval(when)) Date(timeIntervalSince1970: TimeInterval(when))
}
/// Converts structure back to list of strings as expected in a fish history file.
func writeEntry() -> [String] {
var output: [String] = []
output.append("- cmd: \(cmd)")
output.append(" when: \(when)")
if !paths.isEmpty {
output.append(" paths:")
paths.forEach { output.append(" - \(String($0))") }
} }
/// Converts structure back to list of strings as expected in a fish history file. return output
func writeEntry() -> [String] { }
var output: [String] = []
output.append("- cmd: \(cmd)")
output.append(" when: \(when)")
if !paths.isEmpty {
output.append(" paths:")
paths.forEach { output.append(" - \(String($0))") }
}
return output
}
} }

26
Sources/FileHelpers.swift
View file

@ -14,10 +14,8 @@
// limitations under the License. // limitations under the License.
// //
import Foundation import Foundation
/// Gets the full file path to a given file. /// Gets the full file path to a given file.
/// ///
/// - Parameters /// - Parameters
@ -25,20 +23,20 @@ import Foundation
/// ///
/// - Returns: A Valid file URL or None if invalid. /// - Returns: A Valid file URL or None if invalid.
func getPath(_ pathStr: String) -> URL? { func getPath(_ pathStr: String) -> URL? {
let userHomeDirectory = FileManager.default.homeDirectoryForCurrentUser.path let userHomeDirectory = FileManager.default.homeDirectoryForCurrentUser.path
var filePath: String = pathStr var filePath: String = pathStr
if pathStr.hasPrefix("~") { if pathStr.hasPrefix("~") {
filePath = (pathStr as NSString).expandingTildeInPath filePath = (pathStr as NSString).expandingTildeInPath
} }
if pathStr.hasPrefix("$HOME") { if pathStr.hasPrefix("$HOME") {
filePath = filePath.replacingOccurrences(of: "$HOME", with: userHomeDirectory) filePath = filePath.replacingOccurrences(of: "$HOME", with: userHomeDirectory)
} }
if !FileManager.default.fileExists(atPath: filePath) { if !FileManager.default.fileExists(atPath: filePath) {
return nil return nil
} }
return URL(fileURLWithPath: filePath) return URL(fileURLWithPath: filePath)
} }

141
Sources/Fishee.swift
View file

@ -14,7 +14,6 @@
// limitations under the License. // limitations under the License.
// //
import ArgumentParser import ArgumentParser
import Foundation import Foundation
@ -22,81 +21,83 @@ let DEFAULT_FISH_HISTORY_LOCATION: String = "~/.local/share/fish/fish_history"
@main @main
struct Fishee: ParsableCommand { struct Fishee: ParsableCommand {
@Option(name: [.short, .customLong("history-file")], help: "Location of your fish history file. Will default to ~/.local/share/fish/fish_history") @Option(
var fishHistoryLocationStr: String? name: [.short, .customLong("history-file")],
help: "Location of your fish history file. Will default to ~/.local/share/fish/fish_history")
var fishHistoryLocationStr: String?
@Option(name: .shortAndLong, help: "File path to file to merge with history file.") @Option(name: .shortAndLong, help: "File path to file to merge with history file.")
var mergeFile: String? var mergeFile: String?
@Option( @Option(
name: [.short, .customLong("output-file")], name: [.short, .customLong("output-file")],
help: "File to write to. Default: same as current history file." help: "File to write to. Default: same as current history file."
) )
var writeFileStr: String? var writeFileStr: String?
@Flag( @Flag(
name: .shortAndLong, name: .shortAndLong,
help: "Dry run. Will only print to the console without actually modifying the history file." help: "Dry run. Will only print to the console without actually modifying the history file."
) )
var dryRun: Bool = false var dryRun: Bool = false
@Flag( @Flag(
name: .shortAndLong, name: .shortAndLong,
help: "Remove duplicates from combined history. Default: false" help: "Remove duplicates from combined history. Default: false"
) )
var removeDuplicates: Bool = false var removeDuplicates: Bool = false
@Flag( @Flag(
name: .shortAndLong, name: .shortAndLong,
inversion: .prefixedNo, inversion: .prefixedNo,
help: "Backup fish history file given before writing." help: "Backup fish history file given before writing."
) )
var backup: Bool = true var backup: Bool = true
var fishHistoryLocation: URL? { var fishHistoryLocation: URL? {
let pathStr = fishHistoryLocationStr ?? DEFAULT_FISH_HISTORY_LOCATION let pathStr = fishHistoryLocationStr ?? DEFAULT_FISH_HISTORY_LOCATION
return getPath(pathStr) return getPath(pathStr)
}
var writeFileLocation: URL? {
let pathStr = writeFileStr ?? DEFAULT_FISH_HISTORY_LOCATION
return getPath(pathStr)
}
public func run() throws {
let mergeFileLocation = mergeFile.flatMap { getPath($0) }
let finalHistory: [FishHistoryEntry] =
switch (fishHistoryLocation, mergeFileLocation) {
case let (fishHistoryLocation?, mergeFileLocation?):
{
let currentHistory = parseFishHistory(from: fishHistoryLocation.path) ?? []
let toMergeHistory = parseFishHistory(from: mergeFileLocation.path) ?? []
return mergeFishHistory(
currentHistory, toMergeHistory, removeDuplicates: removeDuplicates)
}()
case let (fishHistoryLocation?, nil):
parseFishHistory(from: fishHistoryLocation.path) ?? []
default:
[]
}
if dryRun {
finalHistory.forEach { print("\($0.writeEntry().joined(separator: "\n"))") }
} else {
if let writePath = writeFileLocation?.path {
let result = writeFishHistory(
to: writePath,
history: finalHistory,
backup: backup
)
if result {
print("Succussfully updated \(writePath)")
} else {
print("Failed to update \(writePath)")
}
}
} }
var writeFileLocation: URL? { return
let pathStr = writeFileStr ?? DEFAULT_FISH_HISTORY_LOCATION }
return getPath(pathStr)
}
public func run() throws {
let mergeFileLocation = mergeFile.flatMap { getPath($0) }
let finalHistory: [FishHistoryEntry] = switch (fishHistoryLocation, mergeFileLocation) {
case let (fishHistoryLocation?, mergeFileLocation?):
{
let currentHistory = parseFishHistory(from: fishHistoryLocation.path) ?? []
let toMergeHistory = parseFishHistory(from: mergeFileLocation.path) ?? []
return mergeFishHistory(currentHistory, toMergeHistory, removeDuplicates: removeDuplicates)
}()
case let (fishHistoryLocation?, nil):
parseFishHistory(from: fishHistoryLocation.path) ?? []
default:
[]
}
if dryRun {
finalHistory.forEach { print("\($0.writeEntry().joined(separator: "\n"))") }
}
else {
if let writePath = writeFileLocation?.path {
let result = writeFishHistory(
to: writePath,
history: finalHistory,
backup: backup
)
if result {
print("Succussfully updated \(writePath)")
}
else {
print("Failed to update \(writePath)")
}
}
}
return
}
} }

177
Sources/Parser.swift
View file

@ -14,10 +14,8 @@
// limitations under the License. // limitations under the License.
// //
import Foundation import Foundation
/// Make a backup of the fish history. /// Make a backup of the fish history.
/// ///
/// ``` /// ```
@ -31,33 +29,33 @@ import Foundation
/// ///
/// - Returns: true if backup copy successful, false if not. /// - Returns: true if backup copy successful, false if not.
func backupHistory(_ path: String) -> Bool { func backupHistory(_ path: String) -> Bool {
let fileManager = FileManager.default let fileManager = FileManager.default
guard fileManager.fileExists(atPath: path) else { guard fileManager.fileExists(atPath: path) else {
print("File does not exist at path: \(path)") print("File does not exist at path: \(path)")
return false return false
} }
let fileURL = URL(fileURLWithPath: path) let fileURL = URL(fileURLWithPath: path)
let fileExtension = fileURL.pathExtension let fileExtension = fileURL.pathExtension
let fileNameWithoutExtension = fileURL.deletingPathExtension().lastPathComponent let fileNameWithoutExtension = fileURL.deletingPathExtension().lastPathComponent
let directory = fileURL.deletingLastPathComponent() let directory = fileURL.deletingLastPathComponent()
let newFileName = "\(fileNameWithoutExtension)_copy" let newFileName = "\(fileNameWithoutExtension)_copy"
let newFileURL = directory.appendingPathComponent(newFileName).appendingPathExtension(fileExtension) let newFileURL = directory.appendingPathComponent(newFileName).appendingPathExtension(
fileExtension)
do { do {
try? fileManager.removeItem(at: newFileURL) try? fileManager.removeItem(at: newFileURL)
try fileManager.copyItem(at: fileURL, to: newFileURL) try fileManager.copyItem(at: fileURL, to: newFileURL)
print("File duplicated successfully to: \(newFileURL.path)") print("File duplicated successfully to: \(newFileURL.path)")
return true return true
} catch { } catch {
print("error making a backup of \(path), got error: \(error)") print("error making a backup of \(path), got error: \(error)")
return false return false
} }
} }
/// Write fish history to file. /// Write fish history to file.
/// ///
/// - Parameters /// - Parameters
@ -67,32 +65,31 @@ func backupHistory(_ path: String) -> Bool {
/// ///
/// - Returns: true if writing to file copy successful, false if not. /// - Returns: true if writing to file copy successful, false if not.
func writeFishHistory(to path: String, history: [FishHistoryEntry], backup: Bool = true) -> Bool { func writeFishHistory(to path: String, history: [FishHistoryEntry], backup: Bool = true) -> Bool {
var output = "" var output = ""
if backup { if backup {
let result = backupHistory(path) let result = backupHistory(path)
if !result { if !result {
print("Failed to backup \(path) so aborting!") print("Failed to backup \(path) so aborting!")
return false return false
}
} }
}
history.forEach { output += $0.writeEntry().joined(separator: "\n") + "\n" } history.forEach { output += $0.writeEntry().joined(separator: "\n") + "\n" }
if !output.isEmpty { if !output.isEmpty {
do { do {
try output.write(toFile: path, atomically: true, encoding: .utf8) try output.write(toFile: path, atomically: true, encoding: .utf8)
print("Successfully wrote merged history to \(path)") print("Successfully wrote merged history to \(path)")
return true return true
} catch { } catch {
print("Error writing merged history: \(error)") print("Error writing merged history: \(error)")
return false return false
}
}
else {
print("Nothing to write to \(path)")
return false
} }
} else {
print("Nothing to write to \(path)")
return false
}
} }
/// Parse the fish history file. /// Parse the fish history file.
@ -102,41 +99,45 @@ func writeFishHistory(to path: String, history: [FishHistoryEntry], backup: Bool
/// ///
/// - Returns: List of ``FishHistoryEntry`` entries from history file. /// - Returns: List of ``FishHistoryEntry`` entries from history file.
func parseFishHistory(from filePath: String) -> [FishHistoryEntry]? { func parseFishHistory(from filePath: String) -> [FishHistoryEntry]? {
guard let fileContents = try? String(contentsOfFile: filePath, encoding: .utf8) else { guard let fileContents = try? String(contentsOfFile: filePath, encoding: .utf8) else {
print("Failed to open file.") print("Failed to open file.")
return nil 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)
} }
}
let lines = fileContents.split(separator: "\n").map { String($0).trimmingCharacters(in: .whitespaces) } if let cmd = result.currentCmd, let when = result.currentWhen {
let entry = FishHistoryEntry(cmd: cmd, when: when, paths: result.currentPaths)
return result.entries + [entry]
}
let initialState: (entries: [FishHistoryEntry], currentCmd: String?, currentWhen: Int?, currentPaths: [String]) = ([], nil, nil, []) return result.entries
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
} }
/// Merge two given ``FishHistoryEntry`` lists into one list. /// Merge two given ``FishHistoryEntry`` lists into one list.
@ -147,18 +148,20 @@ func parseFishHistory(from filePath: String) -> [FishHistoryEntry]? {
/// - removeDuplicates: if true, remove any duplicates found after merging the two lists. /// - removeDuplicates: if true, remove any duplicates found after merging the two lists.
/// ///
/// - Returns: Single list of ``FishHistoryEntry`` entries. /// - Returns: Single list of ``FishHistoryEntry`` entries.
func mergeFishHistory(_ left: [FishHistoryEntry], _ right: [FishHistoryEntry], removeDuplicates: Bool = false) -> [FishHistoryEntry] { func mergeFishHistory(
_ left: [FishHistoryEntry], _ right: [FishHistoryEntry], removeDuplicates: Bool = false
) -> [FishHistoryEntry] {
let merged = left + right let merged = left + right
if removeDuplicates { if removeDuplicates {
let finalList = merged.reduce(into: [String:FishHistoryEntry]()) { result, entry in let finalList = merged.reduce(into: [String: FishHistoryEntry]()) { result, entry in
if result[entry.cmd] == nil { if result[entry.cmd] == nil {
result[entry.cmd] = entry result[entry.cmd] = entry
} }
}
return Array(finalList.values)
} else {
return merged
} }
return Array(finalList.values)
} else {
return merged
}
} }

34
Tests/AlgebraTest.swift
View file

@ -16,27 +16,29 @@
import Foundation import Foundation
import Testing import Testing
@testable import Fishee @testable import Fishee
@Suite @Suite
final class AlgebraTests { final class AlgebraTests {
let historyItem = FishHistoryEntry(cmd: "cd Projects/Fishee/", when: 1727545693, paths: ["Projects/Fishee/"]) let historyItem = FishHistoryEntry(
cmd: "cd Projects/Fishee/", when: 1_727_545_693, paths: ["Projects/Fishee/"])
@Test func dateFromHistoryTest() { @Test func dateFromHistoryTest() {
let gotDate = historyItem.getDate() let gotDate = historyItem.getDate()
#expect(gotDate == Date(timeIntervalSince1970: 1727545693)) #expect(gotDate == Date(timeIntervalSince1970: 1_727_545_693))
} }
@Test func writeEntryTest() { @Test func writeEntryTest() {
let entry = historyItem.writeEntry() let entry = historyItem.writeEntry()
#expect(entry.count > 0) #expect(entry.count > 0)
let expectedEntry = """ let expectedEntry = """
- cmd: cd Projects/Fishee/ - cmd: cd Projects/Fishee/
when: 1727545693 when: 1727545693
paths: paths:
- Projects/Fishee/ - Projects/Fishee/
""" """
#expect(entry.joined(separator: "\n") == expectedEntry) #expect(entry.joined(separator: "\n") == expectedEntry)
} }
} }

46
Tests/FileHelpersTests.swift
View file

@ -16,33 +16,35 @@
import Foundation import Foundation
import Testing import Testing
@testable import Fishee
@testable import Fishee
@Suite(.serialized) @Suite(.serialized)
final class FileHelpersTests { final class FileHelpersTests {
let filePath = FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent("myfile.txt") let filePath = FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent(
"myfile.txt")
init() { init() {
try? "this is a test".write( try? "this is a test".write(
to: filePath, to: filePath,
atomically: true, atomically: true,
encoding: .utf8 encoding: .utf8
) )
} }
deinit { deinit {
try? FileManager.default.removeItem(at: filePath) try? FileManager.default.removeItem(at: filePath)
} }
@Test(arguments: [ @Test(arguments: [
"$HOME/myfile.txt", "$HOME/myfile.txt",
"~/myfile.txt", "~/myfile.txt",
"\(FileManager.default.homeDirectoryForCurrentUser.path)/myfile.txt" "\(FileManager.default.homeDirectoryForCurrentUser.path)/myfile.txt",
]) ])
func getPathTest(testPath: String) { func getPathTest(testPath: String) {
let path = getPath(testPath) let path = getPath(testPath)
let expected = URL(fileURLWithPath: "\(FileManager.default.homeDirectoryForCurrentUser.path)/myfile.txt") let expected = URL(
#expect(path == expected) fileURLWithPath: "\(FileManager.default.homeDirectoryForCurrentUser.path)/myfile.txt")
} #expect(path == expected)
}
} }

86
Tests/FisheeTests.swift
View file

@ -14,64 +14,64 @@
// limitations under the License. // limitations under the License.
// //
import Foundation import Foundation
import Testing import Testing
@testable import Fishee @testable import Fishee
@Suite @Suite
final class FisheeTests { final class FisheeTests {
@Test func DryRunTest() { @Test func DryRunTest() {
do { do {
let help = try #require(Fishee.parse(["--dry-run"]) as Fishee) let help = try #require(Fishee.parse(["--dry-run"]) as Fishee)
#expect(help.dryRun) #expect(help.dryRun)
} catch { } catch {
Issue.record("Test failed! \(error)") Issue.record("Test failed! \(error)")
}
} }
}
@Test func HistoryFileTest() { @Test func HistoryFileTest() {
do { do {
let help = try #require(Fishee.parse(["--history-file", "/tmp/fishtest.txt"]) as Fishee) let help = try #require(Fishee.parse(["--history-file", "/tmp/fishtest.txt"]) as Fishee)
#expect(help.fishHistoryLocationStr == "/tmp/fishtest.txt") #expect(help.fishHistoryLocationStr == "/tmp/fishtest.txt")
} catch { } catch {
Issue.record("Test failed! \(error)") Issue.record("Test failed! \(error)")
}
} }
}
@Test func OutputFileTest() { @Test func OutputFileTest() {
do { do {
let help = try #require(Fishee.parse(["--output-file", "/tmp/fishtest.txt"]) as Fishee) let help = try #require(Fishee.parse(["--output-file", "/tmp/fishtest.txt"]) as Fishee)
#expect(help.writeFileStr == "/tmp/fishtest.txt") #expect(help.writeFileStr == "/tmp/fishtest.txt")
} catch { } catch {
Issue.record("Test failed! \(error)") Issue.record("Test failed! \(error)")
}
} }
}
@Test func RemoveDuplicatesTest() { @Test func RemoveDuplicatesTest() {
do { do {
let help = try #require(Fishee.parse(["--remove-duplicates"]) as Fishee) let help = try #require(Fishee.parse(["--remove-duplicates"]) as Fishee)
#expect(help.removeDuplicates) #expect(help.removeDuplicates)
} catch { } catch {
Issue.record("Test failed! \(error)") Issue.record("Test failed! \(error)")
}
} }
}
@Test func BackupTest() { @Test func BackupTest() {
do { do {
let help = try #require(Fishee.parse(["--backup"]) as Fishee) let help = try #require(Fishee.parse(["--backup"]) as Fishee)
#expect(help.backup) #expect(help.backup)
} catch { } catch {
Issue.record("Test failed! \(error)") Issue.record("Test failed! \(error)")
}
} }
}
@Test func NoBackupTest() { @Test func NoBackupTest() {
do { do {
let help = try #require(Fishee.parse(["--no-backup"]) as Fishee) let help = try #require(Fishee.parse(["--no-backup"]) as Fishee)
#expect(!help.backup) #expect(!help.backup)
} catch { } catch {
Issue.record("Test failed! \(error)") Issue.record("Test failed! \(error)")
}
} }
}
} }

130
Tests/ParserTests.swift
View file

@ -16,81 +16,87 @@
import Foundation import Foundation
import Testing import Testing
@testable import Fishee @testable import Fishee
@Suite(.serialized) @Suite(.serialized)
final class ParserTests { final class ParserTests {
let fishHistoryFile = Bundle.module.path(forResource: "fish_history_test", ofType: "txt") let fishHistoryFile = Bundle.module.path(forResource: "fish_history_test", ofType: "txt")
let historyItem = FishHistoryEntry(cmd: "cd Projects/Fishee/", when: 1727545693, paths: ["Projects/Fishee/"]) let historyItem = FishHistoryEntry(
let historyItem2 = FishHistoryEntry(cmd: "swift package tools-version", when: 1727545709, paths: []) cmd: "cd Projects/Fishee/", when: 1_727_545_693, paths: ["Projects/Fishee/"])
let filePathforWriteTest = FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent("myfile.txt") let historyItem2 = FishHistoryEntry(
let filePathforFileBackupTest = FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent("myfile_copy.txt") cmd: "swift package tools-version", when: 1_727_545_709, paths: [])
let filePathforWriteTest = FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent(
"myfile.txt")
let filePathforFileBackupTest = FileManager.default.homeDirectoryForCurrentUser
.appendingPathComponent("myfile_copy.txt")
deinit { deinit {
if FileManager.default.fileExists(atPath: filePathforWriteTest.path) { if FileManager.default.fileExists(atPath: filePathforWriteTest.path) {
_ = try? FileManager.default.removeItem(at: filePathforWriteTest) _ = try? FileManager.default.removeItem(at: filePathforWriteTest)
}
if FileManager.default.fileExists(atPath: filePathforFileBackupTest.path) {
_ = try? FileManager.default.removeItem(at: filePathforFileBackupTest)
}
} }
if FileManager.default.fileExists(atPath: filePathforFileBackupTest.path) {
@Test func parseFishHistoryTest() { _ = try? FileManager.default.removeItem(at: filePathforFileBackupTest)
#expect(fishHistoryFile != nil)
let fishHistory = parseFishHistory(from: fishHistoryFile!)
#expect(fishHistory!.count > 0)
let expectedHistory = [historyItem, historyItem2]
#expect(fishHistory == expectedHistory)
} }
}
@Test func writeFishHistoryTest() { @Test func parseFishHistoryTest() {
let written = writeFishHistory( #expect(fishHistoryFile != nil)
to: filePathforWriteTest.path, let fishHistory = parseFishHistory(from: fishHistoryFile!)
history: [historyItem], #expect(fishHistory!.count > 0)
backup: false let expectedHistory = [historyItem, historyItem2]
) #expect(fishHistory == expectedHistory)
#expect(written) }
let fileContent = try? String(contentsOf: filePathforWriteTest, encoding: .utf8) @Test func writeFishHistoryTest() {
let expectedEntry = """ let written = writeFishHistory(
- cmd: cd Projects/Fishee/ to: filePathforWriteTest.path,
when: 1727545693 history: [historyItem],
paths: backup: false
- Projects/Fishee/ )
#expect(written)
""" let fileContent = try? String(contentsOf: filePathforWriteTest, encoding: .utf8)
#expect(fileContent == expectedEntry) let expectedEntry = """
- cmd: cd Projects/Fishee/
when: 1727545693
paths:
- Projects/Fishee/
// confirm backup functionality is working """
#expect(FileManager.default.fileExists(atPath: filePathforWriteTest.path)) #expect(fileContent == expectedEntry)
let write_again = writeFishHistory( // confirm backup functionality is working
to: filePathforWriteTest.path, #expect(FileManager.default.fileExists(atPath: filePathforWriteTest.path))
history: [historyItem],
backup: true
)
#expect(write_again)
#expect(FileManager.default.fileExists(atPath: filePathforFileBackupTest.path))
}
@Test func mergeFishHistoryTest() { let write_again = writeFishHistory(
let merged = mergeFishHistory([historyItem], [historyItem2]) to: filePathforWriteTest.path,
#expect(merged.count == 2) history: [historyItem],
#expect(merged.contains(historyItem)) backup: true
#expect(merged.contains(historyItem2)) )
} #expect(write_again)
#expect(FileManager.default.fileExists(atPath: filePathforFileBackupTest.path))
}
@Test func mergeFishHistoryWithDuplicateTest() { @Test func mergeFishHistoryTest() {
let merged = mergeFishHistory([historyItem], [historyItem, historyItem2]) let merged = mergeFishHistory([historyItem], [historyItem2])
#expect(merged.count == 3) #expect(merged.count == 2)
#expect(merged.contains(historyItem)) #expect(merged.contains(historyItem))
#expect(merged.contains(historyItem2)) #expect(merged.contains(historyItem2))
} }
@Test func mergeFishHistoryRemoveDuplicateTest() { @Test func mergeFishHistoryWithDuplicateTest() {
let merged = mergeFishHistory([historyItem], [historyItem, historyItem2], removeDuplicates: true) let merged = mergeFishHistory([historyItem], [historyItem, historyItem2])
#expect(merged.count == 2) #expect(merged.count == 3)
#expect(merged.contains(historyItem)) #expect(merged.contains(historyItem))
#expect(merged.contains(historyItem2)) #expect(merged.contains(historyItem2))
} }
@Test func mergeFishHistoryRemoveDuplicateTest() {
let merged = mergeFishHistory(
[historyItem], [historyItem, historyItem2], removeDuplicates: true)
#expect(merged.count == 2)
#expect(merged.contains(historyItem))
#expect(merged.contains(historyItem2))
}
} }