2016-08-16 22:29:10 +00:00
|
|
|
/*
|
|
|
|
* This file is part of fabric-loom, licensed under the MIT License (MIT).
|
|
|
|
*
|
2018-10-27 14:14:05 +00:00
|
|
|
* Copyright (c) 2016, 2017, 2018 FabricMC
|
2016-08-16 22:29:10 +00:00
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
|
|
* copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
* SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2016-08-16 23:30:48 +00:00
|
|
|
package net.fabricmc.loom;
|
2016-08-15 10:22:14 +00:00
|
|
|
|
2019-11-02 20:23:27 +00:00
|
|
|
import java.util.HashSet;
|
|
|
|
import java.util.Map;
|
|
|
|
import java.util.Optional;
|
|
|
|
import java.util.Set;
|
|
|
|
|
2016-08-17 16:38:54 +00:00
|
|
|
import com.google.common.collect.ImmutableMap;
|
2019-04-21 16:42:51 +00:00
|
|
|
import groovy.util.Node;
|
2019-06-11 02:20:57 +00:00
|
|
|
import org.gradle.api.Plugin;
|
|
|
|
import org.gradle.api.Project;
|
|
|
|
import org.gradle.api.Task;
|
|
|
|
import org.gradle.api.UnknownTaskException;
|
2018-10-29 11:55:30 +00:00
|
|
|
import org.gradle.api.artifacts.Configuration;
|
2019-04-21 16:42:51 +00:00
|
|
|
import org.gradle.api.artifacts.Dependency;
|
2016-08-15 10:22:14 +00:00
|
|
|
import org.gradle.api.artifacts.repositories.MavenArtifactRepository;
|
|
|
|
import org.gradle.api.plugins.JavaPlugin;
|
|
|
|
import org.gradle.api.plugins.JavaPluginConvention;
|
2019-04-21 16:42:51 +00:00
|
|
|
import org.gradle.api.publish.Publication;
|
|
|
|
import org.gradle.api.publish.PublishingExtension;
|
|
|
|
import org.gradle.api.publish.maven.MavenPublication;
|
2016-08-15 10:22:14 +00:00
|
|
|
import org.gradle.api.tasks.SourceSet;
|
2018-11-06 09:36:35 +00:00
|
|
|
import org.gradle.api.tasks.bundling.AbstractArchiveTask;
|
2016-08-15 10:22:14 +00:00
|
|
|
import org.gradle.api.tasks.javadoc.Javadoc;
|
|
|
|
import org.gradle.plugins.ide.idea.model.IdeaModel;
|
|
|
|
|
2019-11-11 18:52:19 +00:00
|
|
|
import net.fabricmc.loom.providers.LaunchProvider;
|
2019-11-02 20:23:27 +00:00
|
|
|
import net.fabricmc.loom.providers.MappingsProvider;
|
|
|
|
import net.fabricmc.loom.providers.MinecraftProvider;
|
|
|
|
import net.fabricmc.loom.task.RemapJarTask;
|
|
|
|
import net.fabricmc.loom.task.RemapSourcesJarTask;
|
|
|
|
import net.fabricmc.loom.util.Constants;
|
|
|
|
import net.fabricmc.loom.util.GroovyXmlUtil;
|
|
|
|
import net.fabricmc.loom.util.LoomDependencyManager;
|
|
|
|
import net.fabricmc.loom.util.NestedJars;
|
|
|
|
import net.fabricmc.loom.util.RemappedConfigurationEntry;
|
|
|
|
import net.fabricmc.loom.util.SetupIntelijRunConfigs;
|
2020-05-22 13:38:25 +00:00
|
|
|
import net.fabricmc.loom.util.mixin.JavaApInvoker;
|
|
|
|
import net.fabricmc.loom.util.mixin.KaptApInvoker;
|
|
|
|
import net.fabricmc.loom.util.mixin.ScalaApInvoker;
|
2020-05-27 23:46:36 +00:00
|
|
|
import net.fabricmc.loom.util.FabricApiExtension;
|
2016-08-16 23:30:48 +00:00
|
|
|
|
2016-08-15 10:22:14 +00:00
|
|
|
public class AbstractPlugin implements Plugin<Project> {
|
2016-08-17 16:38:54 +00:00
|
|
|
protected Project project;
|
|
|
|
|
2019-06-11 02:20:57 +00:00
|
|
|
public static boolean isRootProject(Project project) {
|
|
|
|
return project.getRootProject() == project;
|
|
|
|
}
|
|
|
|
|
2018-12-30 22:26:50 +00:00
|
|
|
private void extendsFrom(String a, String b) {
|
|
|
|
project.getConfigurations().getByName(a).extendsFrom(project.getConfigurations().getByName(b));
|
|
|
|
}
|
|
|
|
|
2016-08-17 16:38:54 +00:00
|
|
|
@Override
|
|
|
|
public void apply(Project target) {
|
|
|
|
this.project = target;
|
|
|
|
|
2019-04-14 18:08:26 +00:00
|
|
|
project.getLogger().lifecycle("Fabric Loom: " + AbstractPlugin.class.getPackage().getImplementationVersion());
|
2018-11-03 18:03:43 +00:00
|
|
|
|
2016-08-17 16:38:54 +00:00
|
|
|
// Apply default plugins
|
|
|
|
project.apply(ImmutableMap.of("plugin", "java"));
|
|
|
|
project.apply(ImmutableMap.of("plugin", "eclipse"));
|
|
|
|
project.apply(ImmutableMap.of("plugin", "idea"));
|
|
|
|
|
2018-11-04 00:27:55 +00:00
|
|
|
project.getExtensions().create("minecraft", LoomGradleExtension.class, project);
|
2020-05-27 23:46:36 +00:00
|
|
|
project.getExtensions().create("fabricApi", FabricApiExtension.class, project);
|
2016-08-17 16:38:54 +00:00
|
|
|
|
|
|
|
// Force add Mojang repository
|
|
|
|
addMavenRepo(target, "Mojang", "https://libraries.minecraft.net/");
|
|
|
|
|
2019-05-28 07:23:19 +00:00
|
|
|
Configuration modCompileClasspathConfig = project.getConfigurations().maybeCreate(Constants.MOD_COMPILE_CLASSPATH);
|
|
|
|
modCompileClasspathConfig.setTransitive(true);
|
|
|
|
Configuration modCompileClasspathMappedConfig = project.getConfigurations().maybeCreate(Constants.MOD_COMPILE_CLASSPATH_MAPPED);
|
|
|
|
modCompileClasspathMappedConfig.setTransitive(false);
|
|
|
|
|
2018-12-30 22:26:50 +00:00
|
|
|
Configuration minecraftNamedConfig = project.getConfigurations().maybeCreate(Constants.MINECRAFT_NAMED);
|
|
|
|
minecraftNamedConfig.setTransitive(false); // The launchers do not recurse dependencies
|
|
|
|
Configuration minecraftDependenciesConfig = project.getConfigurations().maybeCreate(Constants.MINECRAFT_DEPENDENCIES);
|
|
|
|
minecraftDependenciesConfig.setTransitive(false);
|
2018-11-05 09:40:34 +00:00
|
|
|
Configuration minecraftConfig = project.getConfigurations().maybeCreate(Constants.MINECRAFT);
|
2018-12-30 22:26:50 +00:00
|
|
|
minecraftConfig.setTransitive(false);
|
2016-08-17 16:38:54 +00:00
|
|
|
|
2019-04-07 14:18:11 +00:00
|
|
|
Configuration includeConfig = project.getConfigurations().maybeCreate(Constants.INCLUDE);
|
|
|
|
includeConfig.setTransitive(false); // Dont get transitive deps
|
|
|
|
|
2018-11-05 15:54:14 +00:00
|
|
|
project.getConfigurations().maybeCreate(Constants.MAPPINGS);
|
2019-11-09 19:00:36 +00:00
|
|
|
project.getConfigurations().maybeCreate(Constants.MAPPINGS_FINAL);
|
2018-11-05 15:54:14 +00:00
|
|
|
|
2019-05-28 07:23:19 +00:00
|
|
|
for (RemappedConfigurationEntry entry : Constants.MOD_COMPILE_ENTRIES) {
|
|
|
|
Configuration compileModsConfig = project.getConfigurations().maybeCreate(entry.getSourceConfiguration());
|
|
|
|
compileModsConfig.setTransitive(true);
|
|
|
|
Configuration compileModsMappedConfig = project.getConfigurations().maybeCreate(entry.getRemappedConfiguration());
|
|
|
|
compileModsMappedConfig.setTransitive(false); // Don't get transitive deps of already remapped mods
|
|
|
|
|
|
|
|
extendsFrom(entry.getTargetConfiguration(project.getConfigurations()), entry.getRemappedConfiguration());
|
2019-11-02 20:23:27 +00:00
|
|
|
|
2019-05-28 07:23:19 +00:00
|
|
|
if (entry.isOnModCompileClasspath()) {
|
|
|
|
extendsFrom(Constants.MOD_COMPILE_CLASSPATH, entry.getSourceConfiguration());
|
|
|
|
extendsFrom(Constants.MOD_COMPILE_CLASSPATH_MAPPED, entry.getRemappedConfiguration());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-11 22:32:12 +00:00
|
|
|
extendsFrom("compileClasspath", Constants.MINECRAFT_NAMED);
|
|
|
|
extendsFrom("runtimeClasspath", Constants.MINECRAFT_NAMED);
|
2020-06-19 13:08:01 +00:00
|
|
|
extendsFrom("testCompileClasspath", Constants.MINECRAFT_NAMED);
|
|
|
|
extendsFrom("testRuntimeClasspath", Constants.MINECRAFT_NAMED);
|
2019-12-11 14:42:02 +00:00
|
|
|
|
2018-12-30 23:42:49 +00:00
|
|
|
extendsFrom(Constants.MINECRAFT_NAMED, Constants.MINECRAFT_DEPENDENCIES);
|
|
|
|
|
2019-11-09 19:00:36 +00:00
|
|
|
extendsFrom("compile", Constants.MAPPINGS_FINAL);
|
2019-12-11 14:42:02 +00:00
|
|
|
|
2019-05-28 07:23:19 +00:00
|
|
|
configureIDEs();
|
|
|
|
configureCompile();
|
2020-05-22 13:38:25 +00:00
|
|
|
configureMixin();
|
2019-04-21 16:42:51 +00:00
|
|
|
configureMaven();
|
2016-08-17 16:38:54 +00:00
|
|
|
}
|
|
|
|
|
2020-05-22 13:38:25 +00:00
|
|
|
private void configureMixin() {
|
|
|
|
if (project.getPluginManager().hasPlugin("org.jetbrains.kotlin.kapt")) {
|
|
|
|
// If loom is applied after kapt, then kapt will use the AP arguments too early for loom to pass the arguments we need for mixin.
|
|
|
|
throw new IllegalArgumentException("fabric-loom must be applied BEFORE kapt in the plugins { } block.");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Full plugin and mappings information is only available after evaluation
|
|
|
|
project.afterEvaluate((project) -> {
|
2020-05-22 14:36:03 +00:00
|
|
|
project.getLogger().lifecycle("Configuring compiler arguments for Java");
|
2020-05-22 13:38:25 +00:00
|
|
|
new JavaApInvoker(project).configureMixin();
|
2016-08-17 16:38:54 +00:00
|
|
|
|
2019-11-02 20:23:27 +00:00
|
|
|
if (project.getPluginManager().hasPlugin("scala")) {
|
2020-05-22 14:36:03 +00:00
|
|
|
project.getLogger().lifecycle("Configuring compiler arguments for Scala");
|
2020-05-22 13:38:25 +00:00
|
|
|
new ScalaApInvoker(project).configureMixin();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (project.getPluginManager().hasPlugin("org.jetbrains.kotlin.kapt")) {
|
2020-05-22 14:36:03 +00:00
|
|
|
project.getLogger().lifecycle("Configuring compiler arguments for Kapt plugin");
|
2020-05-22 13:38:25 +00:00
|
|
|
new KaptApInvoker(project).configureMixin();
|
2019-11-02 20:23:27 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
2019-08-23 10:59:06 +00:00
|
|
|
|
2020-05-22 13:38:25 +00:00
|
|
|
public Project getProject() {
|
|
|
|
return project;
|
|
|
|
}
|
|
|
|
|
2016-08-17 16:38:54 +00:00
|
|
|
/**
|
2019-11-02 20:23:27 +00:00
|
|
|
* Permit to add a Maven repository to a target project.
|
2016-08-17 16:38:54 +00:00
|
|
|
*
|
|
|
|
* @param target The garget project
|
2019-11-11 16:52:13 +00:00
|
|
|
* @param name The name of the repository
|
|
|
|
* @param url The URL of the repository
|
2016-08-17 16:38:54 +00:00
|
|
|
* @return An object containing the name and the URL of the repository that can be modified later
|
|
|
|
*/
|
|
|
|
public MavenArtifactRepository addMavenRepo(Project target, final String name, final String url) {
|
|
|
|
return target.getRepositories().maven(repo -> {
|
|
|
|
repo.setName(name);
|
|
|
|
repo.setUrl(url);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2019-11-02 20:23:27 +00:00
|
|
|
* Add Minecraft dependencies to IDE dependencies.
|
2016-08-17 16:38:54 +00:00
|
|
|
*/
|
|
|
|
protected void configureIDEs() {
|
|
|
|
// IDEA
|
2018-11-01 11:15:09 +00:00
|
|
|
IdeaModel ideaModel = (IdeaModel) project.getExtensions().getByName("idea");
|
2016-08-17 16:38:54 +00:00
|
|
|
|
2018-11-01 11:15:09 +00:00
|
|
|
ideaModel.getModule().getExcludeDirs().addAll(project.files(".gradle", "build", ".idea", "out").getFiles());
|
|
|
|
ideaModel.getModule().setDownloadJavadoc(true);
|
|
|
|
ideaModel.getModule().setDownloadSources(true);
|
|
|
|
ideaModel.getModule().setInheritOutputDirs(true);
|
2016-08-17 16:38:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2019-11-02 20:23:27 +00:00
|
|
|
* Add Minecraft dependencies to compile time.
|
2016-08-17 16:38:54 +00:00
|
|
|
*/
|
|
|
|
protected void configureCompile() {
|
|
|
|
JavaPluginConvention javaModule = (JavaPluginConvention) project.getConvention().getPlugins().get("java");
|
|
|
|
|
|
|
|
SourceSet main = javaModule.getSourceSets().getByName(SourceSet.MAIN_SOURCE_SET_NAME);
|
|
|
|
|
|
|
|
Javadoc javadoc = (Javadoc) project.getTasks().getByName(JavaPlugin.JAVADOC_TASK_NAME);
|
|
|
|
javadoc.setClasspath(main.getOutput().plus(main.getCompileClasspath()));
|
|
|
|
|
|
|
|
project.afterEvaluate(project1 -> {
|
|
|
|
LoomGradleExtension extension = project1.getExtensions().getByType(LoomGradleExtension.class);
|
|
|
|
|
2016-08-29 10:08:23 +00:00
|
|
|
project1.getRepositories().flatDir(flatDirectoryArtifactRepository -> {
|
2019-04-21 09:18:45 +00:00
|
|
|
flatDirectoryArtifactRepository.dir(extension.getRootProjectBuildCache());
|
2016-08-29 10:08:23 +00:00
|
|
|
flatDirectoryArtifactRepository.setName("UserLocalCacheFiles");
|
|
|
|
});
|
|
|
|
|
2018-12-22 13:44:34 +00:00
|
|
|
project1.getRepositories().flatDir(flatDirectoryArtifactRepository -> {
|
|
|
|
flatDirectoryArtifactRepository.dir(extension.getRemappedModCache());
|
|
|
|
flatDirectoryArtifactRepository.setName("UserLocalRemappedMods");
|
|
|
|
});
|
|
|
|
|
2018-06-18 15:16:03 +00:00
|
|
|
project1.getRepositories().maven(mavenArtifactRepository -> {
|
2018-12-09 07:21:32 +00:00
|
|
|
mavenArtifactRepository.setName("Fabric");
|
|
|
|
mavenArtifactRepository.setUrl("https://maven.fabricmc.net/");
|
2018-06-18 15:16:03 +00:00
|
|
|
});
|
|
|
|
|
2016-08-17 16:38:54 +00:00
|
|
|
project1.getRepositories().maven(mavenArtifactRepository -> {
|
|
|
|
mavenArtifactRepository.setName("Mojang");
|
|
|
|
mavenArtifactRepository.setUrl("https://libraries.minecraft.net/");
|
|
|
|
});
|
|
|
|
|
|
|
|
project1.getRepositories().mavenCentral();
|
|
|
|
project1.getRepositories().jcenter();
|
|
|
|
|
2018-11-04 21:28:46 +00:00
|
|
|
LoomDependencyManager dependencyManager = new LoomDependencyManager();
|
|
|
|
extension.setDependencyManager(dependencyManager);
|
2016-08-17 16:38:54 +00:00
|
|
|
|
0.2.7 refactors (#178)
* Rough work on project based jars, skeleton for AccessEscalators?
* First working draft
* Minor changes
* Add support for mutable, better error checking when parsing file.
Code cleanup
Remap if needed when reading
* Fix inner classes and genSources
* Fix CME
* Caching, only regen jar when input changes
* Some work, untested
* Fix writing, fix checkstyle issues
* More fixes
* Move jars into a maven file structure, cleans up the file structure, and will benefit idea 2020
Add some basic validation to the AccessWidenerRemapper, will present any issues with the mappings when building (May need a way to disable?)
+ Some bugs fixes
* Fix issues with source jars in idea 2020, should be backwards compatible with 2019
* Move to lorenz-tiny
* Build fix + small cleanup
* Remove accesswidener's for now
* Update dev launch injector, should fix all issues with spaces in the path.
2020-03-06 11:15:34 +00:00
|
|
|
dependencyManager.addProvider(new MinecraftProvider(getProject()));
|
|
|
|
dependencyManager.addProvider(new MappingsProvider(getProject()));
|
|
|
|
dependencyManager.addProvider(new LaunchProvider(getProject()));
|
2019-04-22 11:41:16 +00:00
|
|
|
|
2018-11-04 21:28:46 +00:00
|
|
|
dependencyManager.handleDependencies(project1);
|
2018-10-29 11:55:30 +00:00
|
|
|
|
2018-11-04 21:28:46 +00:00
|
|
|
project1.getTasks().getByName("idea").finalizedBy(project1.getTasks().getByName("genIdeaWorkspace"));
|
2018-12-12 13:43:42 +00:00
|
|
|
project1.getTasks().getByName("eclipse").finalizedBy(project1.getTasks().getByName("genEclipseRuns"));
|
2020-04-26 13:04:49 +00:00
|
|
|
project1.getTasks().getByName("cleanEclipse").finalizedBy(project1.getTasks().getByName("cleanEclipseRuns"));
|
2018-11-05 12:00:54 +00:00
|
|
|
|
2019-06-11 02:20:57 +00:00
|
|
|
if (extension.autoGenIDERuns && isRootProject(project1)) {
|
2018-12-19 23:05:19 +00:00
|
|
|
SetupIntelijRunConfigs.setup(project1);
|
|
|
|
}
|
|
|
|
|
2018-12-30 11:03:25 +00:00
|
|
|
// Enables the default mod remapper
|
2018-11-06 09:36:35 +00:00
|
|
|
if (extension.remapMod) {
|
|
|
|
AbstractArchiveTask jarTask = (AbstractArchiveTask) project1.getTasks().getByName("jar");
|
2019-05-10 22:53:50 +00:00
|
|
|
RemapJarTask remapJarTask = (RemapJarTask) project1.getTasks().findByName("remapJar");
|
2018-11-06 09:36:35 +00:00
|
|
|
|
2019-06-11 02:20:57 +00:00
|
|
|
assert remapJarTask != null;
|
2019-11-02 20:23:27 +00:00
|
|
|
|
2019-06-11 02:20:57 +00:00
|
|
|
if (!remapJarTask.getInput().isPresent()) {
|
2019-07-24 20:34:27 +00:00
|
|
|
jarTask.setClassifier("dev");
|
|
|
|
remapJarTask.setClassifier("");
|
|
|
|
remapJarTask.getInput().set(jarTask.getArchivePath());
|
2019-05-10 22:53:50 +00:00
|
|
|
}
|
|
|
|
|
2019-07-09 21:01:12 +00:00
|
|
|
extension.addUnmappedMod(jarTask.getArchivePath().toPath());
|
2019-06-11 02:20:57 +00:00
|
|
|
remapJarTask.getAddNestedDependencies().set(true);
|
2020-05-11 11:48:04 +00:00
|
|
|
remapJarTask.getRemapAccessWidener().set(true);
|
2019-05-11 16:38:01 +00:00
|
|
|
|
2019-10-22 19:29:25 +00:00
|
|
|
project1.getArtifacts().add("archives", remapJarTask);
|
|
|
|
remapJarTask.dependsOn(jarTask);
|
2018-11-06 09:36:35 +00:00
|
|
|
project1.getTasks().getByName("build").dependsOn(remapJarTask);
|
2019-04-21 23:25:03 +00:00
|
|
|
|
|
|
|
Map<Project, Set<Task>> taskMap = project.getAllTasks(true);
|
2019-11-02 20:23:27 +00:00
|
|
|
|
2019-04-21 23:25:03 +00:00
|
|
|
for (Map.Entry<Project, Set<Task>> entry : taskMap.entrySet()) {
|
|
|
|
Set<Task> taskSet = entry.getValue();
|
2019-11-02 20:23:27 +00:00
|
|
|
|
2019-04-21 23:25:03 +00:00
|
|
|
for (Task task : taskSet) {
|
2019-07-24 21:52:34 +00:00
|
|
|
if (task instanceof RemapJarTask && ((RemapJarTask) task).getAddNestedDependencies().getOrElse(false)) {
|
2019-04-21 23:25:03 +00:00
|
|
|
//Run all the sub project remap jars tasks before the root projects jar, this is to allow us to include projects
|
|
|
|
NestedJars.getRequiredTasks(project1).forEach(task::dependsOn);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-12-22 13:37:16 +00:00
|
|
|
|
|
|
|
try {
|
|
|
|
AbstractArchiveTask sourcesTask = (AbstractArchiveTask) project1.getTasks().getByName("sourcesJar");
|
|
|
|
|
2019-05-10 22:53:50 +00:00
|
|
|
RemapSourcesJarTask remapSourcesJarTask = (RemapSourcesJarTask) project1.getTasks().findByName("remapSourcesJar");
|
|
|
|
remapSourcesJarTask.setInput(sourcesTask.getArchivePath());
|
|
|
|
remapSourcesJarTask.setOutput(sourcesTask.getArchivePath());
|
|
|
|
remapSourcesJarTask.doLast(task -> project1.getArtifacts().add("archives", remapSourcesJarTask.getOutput()));
|
2018-12-22 13:37:16 +00:00
|
|
|
remapSourcesJarTask.dependsOn(project1.getTasks().getByName("sourcesJar"));
|
|
|
|
project1.getTasks().getByName("build").dependsOn(remapSourcesJarTask);
|
|
|
|
} catch (UnknownTaskException e) {
|
|
|
|
// pass
|
|
|
|
}
|
2018-12-12 06:10:30 +00:00
|
|
|
} else {
|
|
|
|
AbstractArchiveTask jarTask = (AbstractArchiveTask) project1.getTasks().getByName("jar");
|
2019-05-10 22:53:50 +00:00
|
|
|
extension.addUnmappedMod(jarTask.getArchivePath().toPath());
|
2016-10-12 09:44:31 +00:00
|
|
|
}
|
2016-10-12 09:22:08 +00:00
|
|
|
});
|
2016-08-29 10:08:23 +00:00
|
|
|
}
|
2019-03-30 20:08:25 +00:00
|
|
|
|
2019-04-21 16:42:51 +00:00
|
|
|
protected void configureMaven() {
|
|
|
|
project.afterEvaluate((p) -> {
|
2019-05-28 07:23:19 +00:00
|
|
|
for (RemappedConfigurationEntry entry : Constants.MOD_COMPILE_ENTRIES) {
|
|
|
|
if (!entry.hasMavenScope()) {
|
|
|
|
continue;
|
|
|
|
}
|
2019-04-21 21:50:28 +00:00
|
|
|
|
2019-05-28 07:23:19 +00:00
|
|
|
Configuration compileModsConfig = p.getConfigurations().getByName(entry.getSourceConfiguration());
|
|
|
|
|
|
|
|
// add modsCompile to maven-publish
|
|
|
|
PublishingExtension mavenPublish = p.getExtensions().findByType(PublishingExtension.class);
|
2019-11-02 20:23:27 +00:00
|
|
|
|
2019-05-28 07:23:19 +00:00
|
|
|
if (mavenPublish != null) {
|
|
|
|
mavenPublish.publications((publications) -> {
|
|
|
|
for (Publication publication : publications) {
|
|
|
|
if (publication instanceof MavenPublication) {
|
|
|
|
((MavenPublication) publication).pom((pom) -> {
|
|
|
|
pom.withXml((xml) -> {
|
|
|
|
Node dependencies = GroovyXmlUtil.getOrCreateNode(xml.asNode(), "dependencies");
|
|
|
|
Set<String> foundArtifacts = new HashSet<>();
|
|
|
|
|
2019-11-02 20:23:27 +00:00
|
|
|
GroovyXmlUtil.childrenNodesStream(dependencies).filter((n) -> "dependency".equals(n.name())).forEach((n) -> {
|
|
|
|
Optional<Node> groupId = GroovyXmlUtil.getNode(n, "groupId");
|
|
|
|
Optional<Node> artifactId = GroovyXmlUtil.getNode(n, "artifactId");
|
|
|
|
|
|
|
|
if (groupId.isPresent() && artifactId.isPresent()) {
|
|
|
|
foundArtifacts.add(groupId.get().text() + ":" + artifactId.get().text());
|
|
|
|
}
|
|
|
|
});
|
2019-05-28 07:23:19 +00:00
|
|
|
|
|
|
|
for (Dependency dependency : compileModsConfig.getAllDependencies()) {
|
|
|
|
if (foundArtifacts.contains(dependency.getGroup() + ":" + dependency.getName())) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
Node depNode = dependencies.appendNode("dependency");
|
|
|
|
depNode.appendNode("groupId", dependency.getGroup());
|
|
|
|
depNode.appendNode("artifactId", dependency.getName());
|
|
|
|
depNode.appendNode("version", dependency.getVersion());
|
|
|
|
depNode.appendNode("scope", entry.getMavenScope());
|
|
|
|
}
|
|
|
|
});
|
2019-04-21 16:42:51 +00:00
|
|
|
});
|
2019-05-28 07:23:19 +00:00
|
|
|
}
|
2019-04-21 16:42:51 +00:00
|
|
|
}
|
2019-05-28 07:23:19 +00:00
|
|
|
});
|
|
|
|
}
|
2019-04-21 16:42:51 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
2016-08-15 10:22:14 +00:00
|
|
|
}
|