fun execute()

in gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/desktop/application/tasks/AbstractProguardTask.kt [82:162]
67 lines of code
12 McCabe index (conditional complexity)

    fun execute() {
        val javaHome = File(javaHome.get())

        fileOperations.clearDirs(destinationDir, workingDir)
        val destinationDir = destinationDir.ioFile.absoluteFile

        // todo: can be cached for a jdk
        val jmods = javaHome.resolve("jmods").walk().filter {
            it.isFile && it.path.endsWith("jmod", ignoreCase = true)
        }.toList()

        val inputToOutputJars = LinkedHashMap<File, File>()
        // avoid mangling mainJar
        inputToOutputJars[mainJar.ioFile] = mainJarInDestinationDir.ioFile
        for (inputFile in inputFiles) {
            if (inputFile.name.endsWith(".jar", ignoreCase = true)) {
                inputToOutputJars.putIfAbsent(inputFile, destinationDir.resolve(inputFile.mangledName()))
            } else {
                inputFile.copyTo(destinationDir.resolve(inputFile.name))
            }
        }

        jarsConfigurationFile.ioFile.bufferedWriter().use { writer ->
            val toSingleOutputJar = joinOutputJars.orNull == true
            for ((input, output) in inputToOutputJars.entries) {
                writer.writeLn("-injars '${input.normalizedPath()}'")
                if (!toSingleOutputJar)
                    writer.writeLn("-outjars '${output.normalizedPath()}'")
            }
            if (toSingleOutputJar)
                writer.writeLn("-outjars '${mainJarInDestinationDir.ioFile.normalizedPath()}'")

            for (jmod in jmods) {
                writer.writeLn("-libraryjars '${jmod.normalizedPath()}'(!**.jar;!module-info.class)")
            }
        }

        rootConfigurationFile.ioFile.bufferedWriter().use { writer ->
            if (dontobfuscate.orNull == true) {
                writer.writeLn("-dontobfuscate")
            }

            if (dontoptimize.orNull == true) {
                writer.writeLn("-dontoptimize")
            }

            writer.writeLn("""
                -keep public class ${mainClass.get()} {
                    public static void main(java.lang.String[]);
                }
            """.trimIndent())

            val includeFiles = sequenceOf(
                jarsConfigurationFile.ioFile,
                defaultComposeRulesFile.ioFile
            ) + configurationFiles.files.asSequence()
            for (configFile in includeFiles.filterNotNull()) {
                writer.writeLn("-include '${configFile.normalizedPath()}'")
            }
        }

        val javaBinary = jvmToolFile(toolName = "java", javaHome = javaHome)
        val args = arrayListOf<String>().apply {
            val maxHeapSize = maxHeapSize.orNull
            if (maxHeapSize != null) {
                add("-Xmx:$maxHeapSize")
            }
            cliArg("-cp", proguardFiles.map { it.normalizedPath() }.joinToString(File.pathSeparator))
            add("proguard.ProGuard")
            // todo: consider separate flag
            cliArg("-verbose", verbose)
            cliArg("-include", rootConfigurationFile)
        }

        runExternalTool(
            tool = javaBinary,
            args = args,
            environment = emptyMap(),
            logToConsole = ExternalToolRunner.LogToConsole.Always
        ).assertNormalExitValue()
    }