Add support for ForgeGradle patcher projects

Author: DenWav

src/gradle-tooling-extension/groovy/com/demonwav/mcdev/platform/forge/gradle/tooling/ForgePatcherModelBuilderImpl.groovy

@@ -0,0 +1,55 @@
+/*
+ * Minecraft Dev for IntelliJ
+ *
+ * https://minecraftdev.org
+ *
+ * Copyright (c) 2017 minecraft-dev
+ *
+ * MIT License
+ */
+
+package com.demonwav.mcdev.platform.forge.gradle.tooling
+
+import com.demonwav.mcdev.platform.mcp.gradle.tooling.McpModelBuilderImpl
+import org.gradle.api.Project
+import org.jetbrains.annotations.NotNull
+import org.jetbrains.plugins.gradle.tooling.ErrorMessageBuilder
+import org.jetbrains.plugins.gradle.tooling.ModelBuilderService
+
+final class ForgePatcherModelBuilderImpl implements ModelBuilderService {
+
+    @Override
+    boolean canBuild(String modelName) {
+        return ForgePatcherModel.name == modelName
+    }
+
+    @Override
+    Object buildAll(String modelName, Project project) {
+        def extension = project.extensions.findByName("minecraft")
+        if (extension == null) {
+            // No ForgeGradle
+            return null
+        }
+
+        if (project.plugins.findPlugin("net.minecraftforge.gradle.patcher") == null) {
+            // Not using the patcher plugin
+            return null
+        }
+
+        def mcpModel = new McpModelBuilderImpl().buildAll(modelName, project)
+
+        def set = new HashSet<String>()
+        for (p in extension.projects) {
+            set.add(p.capName)
+        }
+
+        return new ForgePatcherModelImpl(mcpModel, set)
+    }
+
+    @Override
+    ErrorMessageBuilder getErrorMessageBuilder(@NotNull Project project, @NotNull Exception e) {
+        return ErrorMessageBuilder.create(
+                project, e, "MinecraftDev import errors"
+        ).withDescription("Unable to build MinecraftDev Forge patcher project configuration")
+    }
+}

src/gradle-tooling-extension/groovy/com/demonwav/mcdev/platform/forge/gradle/tooling/ForgePatcherModelImpl.groovy

@@ -0,0 +1,26 @@
+/*
+ * Minecraft Dev for IntelliJ
+ *
+ * https://minecraftdev.org
+ *
+ * Copyright (c) 2017 minecraft-dev
+ *
+ * MIT License
+ */
+
+package com.demonwav.mcdev.platform.forge.gradle.tooling
+
+import com.demonwav.mcdev.platform.mcp.gradle.tooling.McpModel
+import groovy.transform.CompileStatic
+
+@CompileStatic
+final class ForgePatcherModelImpl implements ForgePatcherModel, Serializable {
+
+    final McpModel mcpModel
+    final Set<String> projects
+
+    ForgePatcherModelImpl(McpModel mcpModel, Set<String> projects) {
+        this.mcpModel = mcpModel
+        this.projects = projects
+    }
+}

src/gradle-tooling-extension/java/com/demonwav/mcdev/platform/forge/gradle/tooling/ForgePatcherModel.java

@@ -0,0 +1,19 @@
+/*
+ * Minecraft Dev for IntelliJ
+ *
+ * https://minecraftdev.org
+ *
+ * Copyright (c) 2017 minecraft-dev
+ *
+ * MIT License
+ */
+
+package com.demonwav.mcdev.platform.forge.gradle.tooling;
+
+import com.demonwav.mcdev.platform.mcp.gradle.tooling.McpModel;
+import java.util.Set;
+
+public interface ForgePatcherModel {
+    McpModel getMcpModel();
+    Set<String> getProjects();
+}

src/gradle-tooling-extension/resources/META-INF/services/org.jetbrains.plugins.gradle.tooling.ModelBuilderService

@@ -1 +1,2 @@
 com.demonwav.mcdev.platform.mcp.gradle.tooling.McpModelBuilderImpl
+com.demonwav.mcdev.platform.forge.gradle.tooling.ForgePatcherModelBuilderImpl

src/main/kotlin/com/demonwav/mcdev/facet/MinecraftFacetConfiguration.kt

@@ -44,5 +44,7 @@ data class MinecraftFacetConfigurationData(
     var userChosenTypes: MutableMap<PlatformType, Boolean> = mutableMapOf(),
     @Tag("autoDetectTypes")
     @AbstractCollection(surroundWithTag = false, elementTag = "platformType", elementValueAttribute = "")
-    var autoDetectTypes: MutableSet<PlatformType> = mutableSetOf()
+    var autoDetectTypes: MutableSet<PlatformType> = mutableSetOf(),
+    @Tag("forgePatcher")
+    var forgePatcher: Boolean = false
 )

src/main/kotlin/com/demonwav/mcdev/facet/MinecraftFacetDetector.kt

@@ -93,6 +93,13 @@ class MinecraftFacetDetector(project: Project) : AbstractProjectComponent(projec
             val types = facet.configuration.state.autoDetectTypes
             types.clear()
             types.addAll(platforms)
+
+            if (facet.configuration.state.forgePatcher) {
+                // make sure Forge and MCP are present
+                types.add(PlatformType.FORGE)
+                types.add(PlatformType.MCP)
+            }
+
             facet.refresh()
         }
 

src/main/kotlin/com/demonwav/mcdev/platform/forge/gradle/ForgePatcherDataService.kt

@@ -0,0 +1,93 @@
+/*
+ * Minecraft Dev for IntelliJ
+ *
+ * https://minecraftdev.org
+ *
+ * Copyright (c) 2017 minecraft-dev
+ *
+ * MIT License
+ */
+
+package com.demonwav.mcdev.platform.forge.gradle
+
+import com.demonwav.mcdev.facet.MinecraftFacet
+import com.demonwav.mcdev.facet.MinecraftFacetConfiguration
+import com.demonwav.mcdev.platform.PlatformType
+import com.demonwav.mcdev.platform.mcp.McpModuleSettings
+import com.demonwav.mcdev.platform.mcp.McpModuleType
+import com.demonwav.mcdev.util.findChildren
+import com.intellij.openapi.externalSystem.model.DataNode
+import com.intellij.openapi.externalSystem.model.project.ProjectData
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider
+import com.intellij.openapi.externalSystem.service.project.manage.AbstractProjectDataService
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.module.ModuleManager
+import com.intellij.openapi.project.Project
+
+class ForgePatcherDataService : AbstractProjectDataService<ForgePatcherModelData, Module>() {
+
+    override fun getTargetDataKey() = ForgePatcherModelData.KEY
+
+    override fun importData(toImport: Collection<DataNode<ForgePatcherModelData>>,
+                            projectData: ProjectData?,
+                            project: Project,
+                            modelsProvider: IdeModifiableModelsProvider) {
+        if (projectData == null || toImport.isEmpty()) {
+            return
+        }
+
+        for (node in toImport) {
+            val data = node.data
+
+            val moduleManager = ModuleManager.getInstance(project)
+
+            for (name in data.model.projects) {
+                val rootModule = moduleManager.findModuleByName(name) ?: continue
+                var children = rootModule.findChildren()
+
+                if (children.isEmpty()) {
+                    children = setOf(rootModule)
+                }
+
+                children.forEach { register(it, modelsProvider) }
+                for (m in moduleManager.modules) {
+                    if (m !in children) {
+                        MinecraftFacet.getInstance(m)?.apply {
+                            configuration.state.forgePatcher = false
+                            refresh()
+                        }
+                    }
+                }
+
+                for (child in children) {
+                    val mcpModule = MinecraftFacet.getInstance(child, McpModuleType) ?: continue
+                    val mcp = data.model.mcpModel
+                    mcpModule.updateSettings(McpModuleSettings.State(mcp.minecraftVersion, mcp.mcpVersion, mcp.mappingFiles))
+                }
+            }
+        }
+    }
+
+    fun register(module: Module, modelsProvider: IdeModifiableModelsProvider) {
+        val model = modelsProvider.getModifiableFacetModel(module)
+        val facet = model.getFacetByType(MinecraftFacet.ID)
+
+        if (facet == null) {
+            val configuration = MinecraftFacetConfiguration()
+            configuration.state.autoDetectTypes.addAll(platforms)
+            configuration.state.forgePatcher = true
+
+            model.addFacet(MinecraftFacet.facetType.createFacet(module, "Minecraft", configuration, null))
+        } else {
+            val types = facet.configuration.state.autoDetectTypes
+            facet.configuration.state.forgePatcher = true
+            types.clear()
+            types.addAll(platforms)
+            facet.refresh()
+        }
+    }
+
+    companion object {
+        private val platforms = setOf(PlatformType.FORGE, PlatformType.MCP)
+    }
+}

src/main/kotlin/com/demonwav/mcdev/platform/forge/gradle/ForgePatcherModelData.kt

@@ -0,0 +1,24 @@
+/*
+ * Minecraft Dev for IntelliJ
+ *
+ * https://minecraftdev.org
+ *
+ * Copyright (c) 2017 minecraft-dev
+ *
+ * MIT License
+ */
+
+package com.demonwav.mcdev.platform.forge.gradle
+
+import com.demonwav.mcdev.platform.forge.gradle.tooling.ForgePatcherModel
+import com.intellij.openapi.externalSystem.model.Key
+import com.intellij.openapi.externalSystem.model.ProjectKeys
+import com.intellij.openapi.externalSystem.model.project.AbstractExternalEntityData
+import com.intellij.openapi.externalSystem.model.project.ModuleData
+
+class ForgePatcherModelData(val module: ModuleData, val model: ForgePatcherModel) : AbstractExternalEntityData(module.owner) {
+
+    companion object {
+        val KEY = Key.create(ForgePatcherModelData::class.java, ProjectKeys.TASK.processingWeight + 1)
+    }
+}

src/main/kotlin/com/demonwav/mcdev/platform/forge/gradle/ForgePatcherProjectResolverExtension.kt

@@ -0,0 +1,32 @@
+/*
+ * Minecraft Dev for IntelliJ
+ *
+ * https://minecraftdev.org
+ *
+ * Copyright (c) 2017 minecraft-dev
+ *
+ * MIT License
+ */
+
+package com.demonwav.mcdev.platform.forge.gradle
+
+import com.demonwav.mcdev.platform.forge.gradle.tooling.ForgePatcherModel
+import com.intellij.openapi.externalSystem.model.DataNode
+import com.intellij.openapi.externalSystem.model.project.ModuleData
+import org.gradle.tooling.model.idea.IdeaModule
+import org.jetbrains.plugins.gradle.service.project.AbstractProjectResolverExtension
+
+class ForgePatcherProjectResolverExtension : AbstractProjectResolverExtension() {
+
+    override fun getExtraProjectModelClasses() = setOf(ForgePatcherModel::class.java)
+    override fun getToolingExtensionsClasses() = extraProjectModelClasses
+
+    override fun populateModuleExtraModels(gradleModule: IdeaModule, ideModule: DataNode<ModuleData>) {
+        val model = resolverCtx.getExtraProject(gradleModule, ForgePatcherModel::class.java)
+        if (model != null) {
+            ideModule.createChild(ForgePatcherModelData.KEY, ForgePatcherModelData(ideModule.data, model))
+        }
+
+        super.populateModuleExtraModels(gradleModule, ideModule)
+    }
+}

src/main/kotlin/com/demonwav/mcdev/util/Util.kt

@@ -12,6 +12,8 @@ package com.demonwav.mcdev.util
 
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.application.ModalityState
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.module.ModuleManager
 import org.jetbrains.annotations.Contract
 
 inline fun <T> runInlineReadAction(func: () -> T): T {
@@ -104,3 +106,27 @@ fun <T : Any> Array<T?>.castNotNull(): Array<T> {
     @Suppress("UNCHECKED_CAST")
     return this as Array<T>
 }
+
+fun Module.findChildren(): Set<Module> {
+    runInlineReadAction {
+        val manager = ModuleManager.getInstance(project)
+        val result = mutableSetOf<Module>()
+
+        for (m in manager.modules) {
+            if (m === this) {
+                continue
+            }
+
+            val path = manager.getModuleGroupPath(m) ?: continue
+            val namedModule = manager.findModuleByName(path.last()) ?: continue
+
+            if (namedModule != this) {
+                continue
+            }
+
+            result.add(m)
+        }
+
+        return result
+    }
+}