@Suppress("unused")
    internal
    fun generate() =
        outputDirectory.withOutputDirectory { outputDir ->
            for (scriptPlugin in plugins) {
                scriptPlugin.writeScriptPluginAdapterTo(outputDir)
            }
        }
}


internal
fun PrecompiledScriptPlugin.writeScriptPluginAdapterTo(outputDir: File) {

    val (packageDir, packageDeclaration) =
        packageName?.let { packageName ->

        final File outputFile = createOutputFile(outputDir);
        final BuildOperationLogInfo configuration = createLogInfo(taskName, outputFile, MAX_FAILURES);
        return new DefaultBuildOperationLogger(configuration, logger, outputFile);
    }

    protected File createOutputFile(File outputDir) {
        GFileUtils.mkdirs(outputDir);
        return new File(outputDir, "output.txt");

        ).use { facade ->
            destinationDirectory.get().asFile.let { outputDir ->
                outputDir.deleteRecursively()
                outputDir.mkdirs()
                GradleJars(classpath.files).run {
                    facade.writeBuiltinPluginIdExtensionsTo(
                        builtInPluginIdExtFileIn(outputDir),
                        gradleApiJars,

            def taskName = binary.tasks.taskName("compile", textSourceSet.name)
            def outputDir = new File(binary.outputDir, textSourceSet.name)
            tasks.create(taskName, Copy) {
                from textSourceSet.source
                destinationDir = outputDir
            }
        }
    }
// tag::component-registration[]
// tag::binary-registration[]
// tag::binaries-generation[]

        then:
        !objectFile(orgFile)
        objectFile(movedFile)
    }

    def objectFile(TestFile testFile) {
        assert outputDir.listFiles().size() == 1
        assert outputDir.listFiles()[0].listFiles().size() == 1
        outputDir.listFiles()[0].listFiles()[0].text == testFile.absolutePath
    }

    def compile(TestFile... sourceToCompile) {

        packDir."$packType"(sourceFile, readonly)

        then:
        buildTriggeredAndSucceeded()
        executedAndNotSkipped(":unpack")
        outputDir.file("A").text == "original"
        outputDir.file("B").text == "new-file"

        where:
        type      | packType | source        | readonly
        "zipTree" | "zipTo"  | "source.zip"  | true

        programTarget: ProgramTarget = ProgramTarget.Settings,
        action: ExecutableProgram.() -> Unit
    ) {

        outputDir().let { outputDir ->
            compileProgramTo(outputDir, program, sourceHash, programKind, programTarget)
            withClassLoaderFor(outputDir) {
                val executableProgram = loadClass("Program").getDeclaredConstructor().newInstance()

        dependencies {
            compile project(path: ':', configuration: '_classpath')
        }

       task generateFiles {
            ext.outputDir = file("$buildDir/someDir")
            doLast {
                ext.outputDir.mkdirs()
                file("${ext.outputDir}/a.txt") << 'some text'
            }
        }

        artifacts {
            _classpath file:file("someDir"), builtBy: generateFiles
        }

        val outputDir =
            root.resolve("output")

        scriptPlugin(
            "my-script.gradle.kts",
            """

                package org.acme

            """
        ).writeScriptPluginAdapterTo(outputDir)

        val expectedFile =
            outputDir.resolve("org/acme/MyScriptPlugin.kt")

        assertThat(

            def taskName = binary.tasks.taskName("compile", markdownSourceSet.name)
            def outputDir = new File(binary.outputDir, markdownSourceSet.name)
            tasks.create(taskName, MarkdownHtmlCompile) { compileTask ->
                compileTask.source = markdownSourceSet.source
                compileTask.destinationDir = outputDir
                compileTask.smartQuotes = markdownSourceSet.smartQuotes