README.md

@@ -1,4 +1,4 @@
-# i love gradle
+# bad gradle
-# i love gradle
+# bad gradle
-# i love gradle
+# bad gradle
-# i love gradle
+# bad gradle

src/main/kotlin/org/ecorous/esnesnon/gradle/RunConfigGenerator.kt

@@ -0,0 +1,94 @@
+package org.ecorous.esnesnon.gradle
+
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.tasks.SourceSet
+import java.nio.file.Files
+import java.util.*
+import kotlin.io.path.absolute
+import kotlin.io.path.createParentDirectories
+import kotlin.io.path.notExists
+
+private const val LOG4J_CONFIG_PATH = ".gradle/nonsense/log4j.xml"
+private const val ASSET_DIR = "caches/nonsense-gradle/assets"
+
+object RunConfigGenerator {
+    fun generate(project: Project) {
+
+        val log4jPath = project.rootDir.resolve(LOG4J_CONFIG_PATH).toPath().absolute()
+        if (log4jPath.notExists()) {
+            log4jPath.createParentDirectories()
+            RunConfigGenerator::class.java.getResourceAsStream("/log4j.xml").let {
+                it.use { s ->
+                    Files.copy(s!!, log4jPath)
+                }
+            }
+        }
+
+        val runConfigPath = project.rootDir.resolve(".idea").resolve("runConfigurations")
+        runConfigPath.mkdirs()
+        val envs = listOf("client", "server")
+        for (s in envs) {
+            val name = "Minecraft_${capitalize(s)}.xml"
+            if (!runConfigPath.resolve(name).exists()) {
+                val config = RunConfig(s, project)
+                runConfigPath.resolve(name).writeText(config.getXml())
+            }
+        }
+    }
+}
+
+fun capitalize(s: String): String {
+    if (s.isEmpty()) {
+        return s
+    }
+    return s.substring(0, 1).uppercase(Locale.ROOT) + s.substring(1).replace("([^A-Z])([A-Z])".toRegex(), "$1 $2")
+}
+
+class RunConfig(private val env: String, private val project: Project) {
+
+    private fun getAssetIndex(): String {
+        val index = project.gradle.gradleUserHomeDir.toPath().resolve(ASSET_DIR).resolve("indexes").resolve(NonsenseGradlePlugin.minecraftVersion+".json").absolute()
+        if (index.notExists()) {
+            index.createParentDirectories()
+            VersionChecker.downloadAssetIndex(NonsenseGradlePlugin.minecraftVersion, index)
+        }
+        return index.fileName.toString()
+    }
+
+    fun getXml(): String {
+        var modulePath = project.name
+        var parent = project.parent
+        while (parent != null) {
+            modulePath = parent.name + "." + modulePath
+            parent = project.parent!!
+        }
+        val moduleName =
+            "$modulePath." + project.extensions.getByType(JavaPluginExtension::class.java).sourceSets.getByName(
+                SourceSet.MAIN_SOURCE_SET_NAME
+            ).name
+        val args =
+            "--assetDir ${project.gradle.gradleUserHomeDir.resolve(ASSET_DIR).toPath().absolute()} --version Nonsense --assetIndex ${getAssetIndex()}"
+        val parameters = "-Dnonsense.development=true -Dlog4j.configurationFile=${project.rootDir.resolve(
+            LOG4J_CONFIG_PATH).toPath().absolute()} -Dlog4j2.formatMsgNoLookups=true"
+        val xml = """
+            <component name="ProjectRunConfigurationManager">
+              <configuration default="false" factoryName="Application" name="Minecraft ${capitalize(env)}" type="Application">
+                <option name="MAIN_CLASS_NAME" value="org.ecorous.esnesnon.nonsense.loader.impl.launch.client.Nonsense${capitalize(env)}"/>
+                <module name="$moduleName"/>
+                <option name="PROGRAM_PARAMETERS" value="$args"/>
+                <option name="VM_PARAMETERS" value="$parameters"/>
+                <option name="WORKING_DIRECTORY" value="${project.rootDir}/run/"/>
+                <method v="2">
+                  <option enabled="true" name="Make"/>
+                </method>
+                <envs>
+                  
+                </envs>
+                <shortenClasspath name="ARGS_FILE"/>
+              <classpathModifications/></configuration>
+            </component>
+        """.trimIndent()
+        return xml
+    }
+}

src/main/kotlin/org/ecorous/esnesnon/gradle/common/Env.kt

@@ -1,6 +0,0 @@
-package org.ecorous.esnesnon.gradle.common
-
-enum class Env(val id: String, val pascalName: String) {
-    SERVER("server", "Server"),
-    CLIENT("client", "Client"),
-}

src/main/kotlin/org/ecorous/esnesnon/gradle/common/strings.kt

@@ -1,21 +0,0 @@
-package org.ecorous.esnesnon.gradle.common
-
-fun sanitizeXmlValue(value: String): String {
-    return value.replace("&", "&").replace("\"", """)
-}
-
-fun formatXmlList(arg: Array<String>): String {
-    return sanitizeXmlValue(
-        arg
-            .asSequence()
-            .map {
-                var result = it
-                result = result.replace("\\", "\\\\")
-                result = result.replace("\"", "\\\"")
-                if (result.contains(" "))
-                    result = "\"$result\""
-
-                result
-            }.joinToString(" ")
-    )
-}

src/main/kotlin/org/ecorous/esnesnon/gradle/ext/Stuff.kt

@@ -1,7 +1,7 @@
 package org.ecorous.esnesnon.gradle.ext
 
 import org.ecorous.esnesnon.gradle.NonsenseGradlePlugin
-import org.ecorous.esnesnon.gradle.run.RunConfigGenerator
+import org.ecorous.esnesnon.gradle.RunConfigGenerator
 import org.ecorous.esnesnon.gradle.VersionChecker
 import org.ecorous.esnesnon.nonsense_remapper.NonsenseRemapper
 import org.ecorous.esnesnon.nonsense_remapper.api.Mapper

src/main/kotlin/org/ecorous/esnesnon/gradle/run/RunConfigAdapter.kt

@@ -1,16 +0,0 @@
-package org.ecorous.esnesnon.gradle.run
-
-import org.gradle.api.Project
-
-interface RunConfigAdapter {
-    fun generate(
-        project: Project,
-        name: String,
-        mainClass: String,
-        vmArgs: Array<String>,
-        programArgs: Array<String>
-    )
-
-    /** Typically, return whether we are running within the IDE which makes use of this format. */
-    fun shouldGenerate(): Boolean;
-}

src/main/kotlin/org/ecorous/esnesnon/gradle/run/RunConfigGenerator.kt

@@ -1,58 +0,0 @@
-package org.ecorous.esnesnon.gradle.run
-
-import org.ecorous.esnesnon.gradle.NonsenseGradlePlugin
-import org.ecorous.esnesnon.gradle.VersionChecker
-import org.ecorous.esnesnon.gradle.common.Env
-import org.ecorous.esnesnon.gradle.run.adapter.EclipseAdapter
-import org.ecorous.esnesnon.gradle.run.adapter.IdeaAdapter
-import org.gradle.api.Project
-import java.nio.file.Files
-import java.nio.file.Path
-import kotlin.io.path.absolute
-import kotlin.io.path.createParentDirectories
-import kotlin.io.path.notExists
-
-object RunConfigGenerator {
-    private const val LOG4J_CONFIG_PATH = ".gradle/nonsense/log4j.xml"
-    private const val ASSET_DIR = "caches/nonsense-gradle/assets"
-    private val ADAPTERS = arrayOf(EclipseAdapter(), IdeaAdapter())
-
-    fun generate(project: Project) {
-        val log4jPath = project.rootDir.resolve(LOG4J_CONFIG_PATH).toPath().absolute()
-        if (log4jPath.notExists()) {
-            log4jPath.createParentDirectories()
-            RunConfigGenerator::class.java.getResourceAsStream("/log4j.xml").use { input ->
-                Files.copy(input!!, log4jPath)
-            }
-        }
-
-        val assetPath = project.gradle.gradleUserHomeDir.resolve(ASSET_DIR).toPath().absolute()
-        val assetIndexPath = assetPath.resolve("indexes").resolve(NonsenseGradlePlugin.minecraftVersion + ".json")
-        if (assetIndexPath.notExists()) {
-            assetIndexPath.createParentDirectories()
-            VersionChecker.downloadAssetIndex(NonsenseGradlePlugin.minecraftVersion, assetIndexPath)
-        }
-
-        val runConfigPath = project.rootDir.resolve(".idea").resolve("runConfigurations")
-        runConfigPath.mkdirs()
-
-        for (adapter in ADAPTERS) {
-            if (!adapter.shouldGenerate())
-                continue
-
-            for (env in Env.values()) {
-                adapter.generate(
-                    project,
-                    "Minecraft ${env.pascalName}",
-                    "org.ecorous.esnesnon.nonsense.loader.impl.launch.client.Nonsense${env.pascalName}",
-                    arrayOf("-Dnonsense.development=true", "-Dlog4j.configurationFile=" + assetPath),
-                    arrayOf(
-                        "--assetDir", assetPath.toString(),
-                        "--version", "Nonsense",
-                        "--assetIndex", assetIndexPath.toString()
-                    )
-                )
-            }
-        }
-    }
-}

src/main/kotlin/org/ecorous/esnesnon/gradle/run/adapter/EclipseAdapter.kt

@@ -1,51 +0,0 @@
-package org.ecorous.esnesnon.gradle.run.adapter
-
-import org.ecorous.esnesnon.gradle.common.formatXmlList
-import org.ecorous.esnesnon.gradle.common.sanitizeXmlValue
-import org.ecorous.esnesnon.gradle.run.RunConfigAdapter
-import org.gradle.api.Project
-import org.gradle.plugins.ide.eclipse.model.EclipseModel
-import java.nio.charset.StandardCharsets
-
-class EclipseAdapter : RunConfigAdapter {
-    override fun generate(
-        project: Project,
-        name: String,
-        mainClass: String,
-        vmArgs: Array<String>,
-        programArgs: Array<String>
-    ) {
-        val projectName = project.extensions.findByType(EclipseModel::class.java)?.project?.name ?: project.name
-        val file = project.rootDir.resolve("$name.launch")
-
-        file.writer(StandardCharsets.UTF_8).use {
-            // @formatter:off
-            it.write(
-                """
-                <?xml version="1.0" encoding="UTF-8" standalone="no"?>
-                <launchConfiguration type="org.eclipse.jdt.launching.localJavaApplication">
-                    <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
-                        <listEntry value="/${sanitizeXmlValue(projectName)}"/>
-                    </listAttribute>
-                    <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
-                        <listEntry value="4"/>
-                    </listAttribute>
-                    <booleanAttribute key="org.eclipse.jdt.launching.ATTR_USE_START_ON_FIRST_THREAD" value="true"/>
-                    <stringAttribute key="org.eclipse.jdt.launching.CLASSPATH_PROVIDER" value="org.eclipse.buildship.core.classpathprovider"/>
-                    <stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="${sanitizeXmlValue(mainClass)}"/>
-                    <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${formatXmlList(programArgs)}"/>
-                    <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="${sanitizeXmlValue(projectName)}"/>
-                    <stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="${formatXmlList(vmArgs)}"/>
-                    <stringAttribute key="org.eclipse.jdt.launching.WORKING_DIRECTORY" value="${'$'}{workspace_loc:${sanitizeXmlValue(projectName)}}/%RUN_DIRECTORY%"/>
-                    <booleanAttribute key="org.eclipse.jdt.launching.ATTR_ATTR_USE_ARGFILE" value="true"/>
-                </launchConfiguration>
-                """.trimIndent()
-            )
-            // @formatter:on
-        }
-    }
-
-    override fun shouldGenerate(): Boolean {
-        return System.getProperty("eclipse.version") != null
-    }
-}

src/main/kotlin/org/ecorous/esnesnon/gradle/run/adapter/IdeaAdapter.kt

@@ -1,50 +0,0 @@
-package org.ecorous.esnesnon.gradle.run.adapter
-
-import org.ecorous.esnesnon.gradle.common.formatXmlList
-import org.ecorous.esnesnon.gradle.common.sanitizeXmlValue
-import org.ecorous.esnesnon.gradle.run.RunConfigAdapter
-import org.gradle.api.Project
-import java.nio.charset.StandardCharsets
-import kotlin.io.path.createDirectories
-import kotlin.io.path.isDirectory
-import kotlin.io.path.writer
-
-class IdeaAdapter : RunConfigAdapter {
-    override fun generate(
-        project: Project,
-        name: String,
-        mainClass: String,
-        vmArgs: Array<String>,
-        programArgs: Array<String>
-    ) {
-        val folder = project.projectDir.toPath().resolve(".idea/runConfigurations")
-        if (!folder.isDirectory())
-            folder.createDirectories()
-
-        val file = folder.resolve("$name.xml")
-
-        file.writer(StandardCharsets.UTF_8).use {
-            it.write(
-                """
-                <component name="ProjectRunConfigurationManager">
-                    <configuration default="false" name="%NAME%" type="Application" factoryName="Application">
-                        <option name="MAIN_CLASS_NAME" value="${sanitizeXmlValue(mainClass)}"/>
-                        <module name="%IDEA_MODULE%"/>
-                        <option name="PROGRAM_PARAMETERS" value="${formatXmlList(programArgs)}"/>
-                        <option name="VM_PARAMETERS" value="${formatXmlList(vmArgs)}"/>
-                        <option name="WORKING_DIRECTORY" value="${'$'}PROJECT_DIR${'$'}/%RUN_DIRECTORY%/"/>
-                        <method v="2">
-                            <option name="Make" enabled="true"/>
-                        </method>
-                        <shortenClasspath name="ARGS_FILE"/>
-                    </configuration>
-                </component>
-                """.trimIndent()
-            )
-        }
-    }
-
-    override fun shouldGenerate(): Boolean {
-        return System.getProperty("idea.version") != null
-    }
-}