1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import PackageDescription

let package = Package(
    name: "MyPluginPackage",
    products: [
        .plugin(
            name: "MyBuildToolPlugin",
            targets: [
                "MyBuildToolPlugin"
            ]
        )
    ],
    dependencies: [
        .package(
            url: "https://github.com/example/sometool",
            from: "0.1.0"
        )
    ],
    targets: [
        .plugin(
            name: "MyBuildToolPlugin",
            capability: .buildTool(),
            dependencies: [
                .product(name: "SomeTool", package: "sometool"),
            ]
        )
    ]
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import PackagePlugin

@main
struct MyPlugin: BuildToolPlugin {
    
  func createBuildCommands(context: PluginContext, 
                           target: Target) throws -> [Command] {
    // 这个插件只对可以有源文件的包目标运行。
    guard let sourceFiles = target.sourceModule?.sourceFiles else { return [] }

    // 找到要运行的代码生成器工具（请替换成实际的那个）。
    let generatorTool = try context.tool(named: "my-code-generator")

    // 为每个具有特定后缀的源文件构造一条构建命令。
    return sourceFiles.map(\.url).compactMap {
        createBuildCommand(for: $0, in: context.pluginWorkDirectoryURL, with: generatorTool.url)
    }
  }

  func createBuildCommand(for inputPath: URL,
                          in outputDirectoryPath: URL,
                          with generatorToolPath: URL) -> Command? {
    // 跳过任何扩展名不是我们要找的文件
    // （请替换成实际的扩展名）。
    guard inputPath.pathExtension == "my-input-suffix" else { return .none }

    // 返回一条将在构建期间运行、用于生成输出文件的命令。
    let inputName = inputPath.lastPathComponent
    let outputName = inputPath.deletingPathExtension().lastPathComponent + ".swift"
    let outputPath = outputDirectoryPath.appendingPathComponent(outputName)
    return .buildCommand(
        displayName: "Generating \(outputName) from \(inputName)",
        executable: generatorToolPath,
        arguments: ["\(inputPath)", "-o", "\(outputPath)"],
        inputFiles: [inputPath],
        outputFiles: [outputPath]
    )
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import PackagePlugin
import Foundation

@main
struct MyBuildToolPlugin: BuildToolPlugin {
    
  func createBuildCommands(context: PluginContext, 
                           target: Target) throws -> [Command] {

    // 这个例子让 `sometool` 写入插件工作目录中的
    // "GeneratedFiles" 目录
    // （该目录对每个插件和每个目标都是唯一的）。
    let outputDir = context.pluginWorkDirectoryURL
        .appendingPathComponent("GeneratedFiles")
    try FileManager.default.createDirectory(
        at: outputDir,
        withIntermediateDirectories: true)

    // 返回一条把 `sometool` 作为预构建命令运行的命令。
    // 它在每次构建之前运行，并把源文件生成到
    // 构建上下文提供的输出目录中。
    return [.prebuildCommand(
            displayName: "Running SomeTool",
            executable: try context.tool(named: "SomeTool").path,
            arguments: [ "--verbose", "--outdir", outputDir ],
            outputFilesDirectory: outputDir)
    ]
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#if canImport(XcodeProjectPlugin)
import XcodeProjectPlugin

extension MyCommandPlugin: XcodeCommandPlugin {

  // 为 Xcode 项目中的目标创建构建命令的入口点。
  func createBuildCommands(context: XcodePluginContext,
                           target: XcodeTarget) throws -> [Command] {
    // 找到要运行的代码生成器工具（请替换成实际的那个）。
    let generatorTool = try context.tool(named: "my-code-generator")

    // 为每个具有特定后缀的源文件构造一条构建命令。
    return target.inputFiles.map(\.url).compactMap {
        createBuildCommand(for: $0,
                           in: context.pluginWorkDirectoryURL,
                           with: generatorTool.url)
    }
  }
}
#endif