groovy - 依赖于扩展对象的任务的 Gradle 插件最佳实践

Question

我想要关于定义依赖于外部状态(即在引用插件的 build.gradle 中定义)的插件任务的最佳实践的反馈。我正在使用扩展对象和闭包来推迟访问这些设置，直到它们被需要和可用。我也对在任务之间共享状态感兴趣，例如将一项任务的输出配置为另一项任务的输入。

该代码使用“project.afterEvaluate”来定义通过扩展对象配置所需设置后的任务。这似乎比应该需要的更复杂。如果我将代码移出“afterEvaluate”，它会得到 compileFlag == null 这不是外部设置。如果代码再次更改为使用 << 或 doLast 语法，则它将获得外部标志...但随后它无法与 type:Exec 和其他类似有用的类型一起使用。

我觉得我在某些方面正在与 Gradle 作斗争，这意味着我不明白如何更好地使用它。以下是我正在使用的简化伪代码。这有效，但我想看看这是否可以简化，或者最佳实践是什么。此外，除非正在执行任务，否则不应抛出异常。

apply plugin: MyPlugin

class MyPluginExtension {
    String compileFlag = null
}

class MyPlugin implements Plugin<Project> {

    void apply(Project project) {

        project.extensions.create("myPluginConfig", MyPluginExtension)

        project.afterEvaluate {

            // Closure delays getting and checking flag until strictly needed
            def compileFlag = {
                if (project.myPluginConfig.compileFlag == null) {
                    throw new InvalidUserDataException(
                            "Must set compileFlag:  myPluginConfig { compileFlag = '-flag' }")
                }
                return project.myPluginConfig.compileFlag
            }

            // Inputs for translateTask
            def javaInputs = {
                project.files(project.fileTree(
                        dir: project.projectDir, includes: ['**/*.java']))
            }

            // This is the output of the first task and input to the second
            def translatedOutputs = {
                project.files(javaInputs().collect { file ->
                    return file.path.replace('src/', 'build/dir/')
                })
            }

            // Translates all java files into 'translatedOutputs'
            project.tasks.create(name: 'translateTask', type:Exec) {
                inputs.files javaInputs()
                outputs.files translatedOutputs()

                executable '/bin/echo'
                inputs.files.each { file ->
                    args file.path
                }
            }

            // Compiles 'translatedOutputs' to binary
            project.tasks.create(name: 'compileTask', type:Exec, dependsOn: 'translateTask') {
                inputs.files translatedOutputs()
                outputs.file project.file(project.buildDir.path + '/compiledBinary')

                executable '/bin/echo'
                args compileFlag()
                translatedOutputs().each { file ->
                    args file.path
                }
            }
        }
    }
}

Answer 1

我会以另一种方式看待这个问题。看起来您想要放入扩展程序的内容确实由您的每个任务拥有。如果您有一个“全局”插件配置选项，它是否一定会被视为输入？

另一种方法是使用您自己的 SourceSet 并将它们连接到您的自定义任务中。 IMO，这还不够容易。我们仍在将源代码的 JVM 和 native 表示结合在一起。

我建议使用@TaskAction 将您的 Exec 任务提取为自定义任务，该任务可以完成繁重的工作(即使它只是调用 project.exec {})。然后你可以用@Input、@InputFiles 等注释你的输入，用@OutputFiles、@OutputDirectory 等注释你的输出。这些注释将有助于自动连接你的依赖项和输入/输出(我认为这就是一些战斗即将到来的地方从)。

您缺少的另一件事是，如果 compileFlag 影响最终输出，您需要检测对它的更改并强制重建(但不是重新翻译)。

我使用 Groovy .with method. 简化了插件类的主体

我对此并不完全满意(我认为 translateFiles 可以做得不同)，但我希望它向您展示了一些最佳实践。我通过将翻译实现为复制/重命名并将编译实现为仅创建“可执行”文件的内容(内容只是输入列表)。我还保留了您的扩展类来演示“全局”插件配置。还要看看 compileFlag 没有设置会发生什么(我希望错误好一点)。

translateTask 不会是增量的(尽管，我认为 you could probably figure out a way to do that )。所以你可能每次都需要删除输出目录。如果您想保持简单，我不会将其他输出混合到该目录中。

HTH

apply plugin: 'base'
apply plugin: MyPlugin

class MyTranslateTask extends DefaultTask {
    @InputFiles FileCollection srcFiles
    @OutputDirectory File translatedDir

    @TaskAction
    public void translate() {
        // println "toolhome is ${project.myPluginConfig.toolHome}"
        // translate java files by renaming them
        project.copy {
            includeEmptyDirs = false
            from(srcFiles)
            into(translatedDir)
            rename '(.+).java', '$1.m'
        }
    }
}

class MyCompileTask extends DefaultTask {
    @Input String compileFlag
    @InputFiles FileCollection translatedFiles
    @OutputDirectory File outputDir

    @TaskAction
    public void compile() {
        // write inputs to the executable file
        project.file("$outputDir/executable") << "${project.myPluginConfig.toolHome} $compileFlag ${translatedFiles.collect { it.path }}"  
    }
}

class MyPluginExtension {
    File toolHome = new File("/some/sane/default")
}

class MyPlugin implements Plugin<Project> {
    void apply(Project project) {
        project.with { 
            extensions.create("myPluginConfig", MyPluginExtension)

            tasks.create(name: 'translateTask', type: MyTranslateTask) {
                description = "Translates all java files into translatedDir"
                srcFiles = fileTree(dir: projectDir, includes: [ '**/*.java' ])
                translatedDir = file("${buildDir}/dir")
            }

            tasks.create(name: 'compileTask', type: MyCompileTask) {
                description = "Compiles translated files into outputDir"                
                translatedFiles = fileTree(tasks.translateTask.outputs.files.singleFile) { 
                   includes [ '**/*.m' ]
                   builtBy tasks.translateTask 
                }
                outputDir = file("${buildDir}/compiledBinary")
            }
        }
    }
}

myPluginConfig {
    toolHome = file("/some/custom/path")
}

compileTask { 
  compileFlag = '-flag'
}