如何在Swift Argument Parser的ParsableCommand中实现依赖注入？

一、为什么ParsableCommand要求存储属性遵循Decodable？ #

Swift Argument Parser的核心逻辑是将命令行参数解析为ParsableCommand实例，这个过程依赖Swift的Decodable协议自动完成参数到属性的映射。ParsableCommand继承自ParsableArguments，而ParsableArguments协议明确要求遵循Decodable，因此所有存储属性必须符合Decodable标准——否则Swift无法自动合成解码逻辑，也就无法完成命令行参数的解析工作。

像FileManager这类系统类型本身不遵循Decodable，直接作为存储属性会触发编译错误，这就是你遇到问题的根本原因。

二、业内常用的解决方案 #

1. 业务逻辑与命令解析分离（推荐） #

把依赖相关的业务逻辑抽离到独立的服务类中，ParsableCommand仅负责命令行参数的解析和服务调用。这种方式既符合单一职责原则，又能轻松实现依赖注入。

示例代码：

// 定义抽象协议，便于测试时替换实现
protocol FileManaging {
    func fileExists(atPath path: String) -> Bool
    // 按需添加其他文件操作方法
}

extension FileManager: FileManaging {}

// 业务逻辑服务类
struct FileOperationService {
    private let fileManager: FileManaging
    
    init(fileManager: FileManaging = FileManager.default) {
        self.fileManager = fileManager
    }
    
    func performOperation(on path: String) throws {
        if fileManager.fileExists(atPath: path) {
            // 你的业务逻辑
        } else {
            throw NSError(domain: "FileError", code: 1, userInfo: [NSLocalizedDescriptionKey: "文件不存在"])
        }
    }
}

// 命令类仅处理参数解析
struct SomeCommand: ParsableCommand {
    @Argument var targetPath: String
    
    // 允许注入服务实例，测试时传入Mock
    private let fileService: FileOperationService
    
    // 初始化方法：默认使用真实服务，测试时替换为Mock
    init(fileService: FileOperationService = .init()) {
        self.fileService = fileService
    }
    
    // 手动实现Decodable，处理命令行参数（因为自定义了init）
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.targetPath = try container.decode(String.self, forKey: .targetPath)
        self.fileService = .init()
    }
    
    enum CodingKeys: String, CodingKey {
        case targetPath
    }
    
    func run() throws {
        try fileService.performOperation(on: targetPath)
    }
}

// 测试用Mock服务
class MockFileManager: FileManaging {
    var shouldExist = false
    func fileExists(atPath path: String) -> Bool {
        return shouldExist
    }
}

// 测试代码示例
let mockFileManager = MockFileManager()
mockFileManager.shouldExist = true
let mockService = FileOperationService(fileManager: mockFileManager)
let testCommand = SomeCommand(fileService: mockService, targetPath: "/test/path")
try testCommand.run()

2. 使用静态属性替换依赖 #

通过静态属性存储依赖实例，测试时直接替换静态属性的值，无需修改命令的初始化逻辑，实现成本较低。

示例代码：

protocol FileManaging {
    func fileExists(atPath path: String) -> Bool
}

extension FileManager: FileManaging {}

struct SomeCommand: ParsableCommand {
    // 静态属性存储依赖，默认使用系统FileManager
    static var fileManager: FileManaging = FileManager.default
    
    @Argument var targetPath: String
    
    func run() throws {
        if Self.fileManager.fileExists(atPath: targetPath) {
            // 业务逻辑
        }
    }
}

// 测试代码
class MockFileManager: FileManaging {
    func fileExists(atPath path: String) -> Bool {
        return true // 模拟预期结果
    }
}

// 替换静态属性后执行测试
SomeCommand.fileManager = MockFileManager()
try SomeCommand.parse(["/test/path"]).run()

3. 手动实现Decodable忽略非参数属性 #

如果不想拆分服务类，可以手动实现Decodable协议，仅处理命令行参数对应的属性，非参数的依赖属性使用默认值初始化，测试时通过自定义构造方法注入Mock。

示例代码：

struct SomeCommand: ParsableCommand {
    private let fileManager: FileManager
    @Argument var targetPath: String
    
    // 测试用构造方法，注入自定义FileManager
    init(fileManager: FileManager, targetPath: String) {
        self.fileManager = fileManager
        self.targetPath = targetPath
    }
    
    // 解析命令行参数用的构造方法，使用默认FileManager
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.targetPath = try container.decode(String.self, forKey: .targetPath)
        self.fileManager = .default
    }
    
    enum CodingKeys: String, CodingKey {
        case targetPath
    }
    
    func run() throws {
        if fileManager.fileExists(atPath: targetPath) {
            // 业务逻辑
        }
    }
}

// 测试代码
let mockFileManager = FileManager() // 实际测试中使用Mock子类
let testCommand = SomeCommand(fileManager: mockFileManager, targetPath: "/test")
try testCommand.run()

内容的提问来源于stack exchange，提问作者Nicolas Gimelli