imports/architectury-loom
1
0
Fork 0
mirror of https://github.com/architectury/architectury-loom.git synced 2026-04-02 21:47:42 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/dev/1.2' into dev/1.2

Browse Source 
# Conflicts:
#	src/main/java/net/fabricmc/loom/configuration/LoomConfigurations.java
#	src/main/java/net/fabricmc/loom/configuration/ide/RunConfig.java
This commit is contained in:
Juuz
2023-04-23 13:39:04 +03:00
parent b1e378eb61 2e6a1a9128
commit 9b98c655a1
6 changed files with 100 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
src/main/java/net/fabricmc/loom/configuration/LoomConfigurations.java
View File

@@ -53,49 +53,49 @@ public abstract class LoomConfigurations implements Runnable {
public void run() {
final LoomGradleExtension extension = LoomGradleExtension.get(getProject());
register(Constants.Configurations.MOD_COMPILE_CLASSPATH, Type.CONSUMABLE);
registerNonTransitive(Constants.Configurations.MOD_COMPILE_CLASSPATH_MAPPED, Type.DEFAULT);
register(Constants.Configurations.MOD_COMPILE_CLASSPATH, Role.RESOLVABLE);
registerNonTransitive(Constants.Configurations.MOD_COMPILE_CLASSPATH_MAPPED, Role.RESOLVABLE);
// Set up the Minecraft compile configurations.
var minecraftClientCompile = registerNonTransitive(Constants.Configurations.MINECRAFT_CLIENT_COMPILE_LIBRARIES, Type.DEFAULT);
var minecraftServerCompile = registerNonTransitive(Constants.Configurations.MINECRAFT_SERVER_COMPILE_LIBRARIES, Type.DEFAULT);
var minecraftCompile = registerNonTransitive(Constants.Configurations.MINECRAFT_COMPILE_LIBRARIES, Type.RESOLVABLE);
var minecraftClientCompile = registerNonTransitive(Constants.Configurations.MINECRAFT_CLIENT_COMPILE_LIBRARIES, Role.RESOLVABLE);
var minecraftServerCompile = registerNonTransitive(Constants.Configurations.MINECRAFT_SERVER_COMPILE_LIBRARIES, Role.RESOLVABLE);
var minecraftCompile = registerNonTransitive(Constants.Configurations.MINECRAFT_COMPILE_LIBRARIES, Role.RESOLVABLE);
minecraftCompile.configure(configuration -> {
configuration.extendsFrom(minecraftClientCompile.get());
configuration.extendsFrom(minecraftServerCompile.get());
});
// Set up the minecraft runtime configurations, this extends from the compile configurations.
var minecraftClientRuntime = registerNonTransitive(Constants.Configurations.MINECRAFT_CLIENT_RUNTIME_LIBRARIES, Type.DEFAULT);
var minecraftServerRuntime = registerNonTransitive(Constants.Configurations.MINECRAFT_SERVER_RUNTIME_LIBRARIES, Type.DEFAULT);
var minecraftClientRuntime = registerNonTransitive(Constants.Configurations.MINECRAFT_CLIENT_RUNTIME_LIBRARIES, Role.RESOLVABLE);
var minecraftServerRuntime = registerNonTransitive(Constants.Configurations.MINECRAFT_SERVER_RUNTIME_LIBRARIES, Role.RESOLVABLE);
// Runtime extends from compile
minecraftClientRuntime.configure(configuration -> configuration.extendsFrom(minecraftClientCompile.get()));
minecraftServerRuntime.configure(configuration -> configuration.extendsFrom(minecraftServerCompile.get()));
registerNonTransitive(Constants.Configurations.MINECRAFT_RUNTIME_LIBRARIES, Type.RESOLVABLE).configure(minecraftRuntime -> {
registerNonTransitive(Constants.Configurations.MINECRAFT_RUNTIME_LIBRARIES, Role.RESOLVABLE).configure(minecraftRuntime -> {
minecraftRuntime.extendsFrom(minecraftClientRuntime.get());
minecraftRuntime.extendsFrom(minecraftServerRuntime.get());
});
registerNonTransitive(Constants.Configurations.MINECRAFT_NATIVES, Type.DEFAULT);
registerNonTransitive(Constants.Configurations.LOADER_DEPENDENCIES, Type.CONSUMABLE);
registerNonTransitive(Constants.Configurations.MINECRAFT_NATIVES, Role.RESOLVABLE);
registerNonTransitive(Constants.Configurations.LOADER_DEPENDENCIES, Role.RESOLVABLE);
registerNonTransitive(Constants.Configurations.MINECRAFT, Type.CONSUMABLE);
registerNonTransitive(Constants.Configurations.INCLUDE, Type.DEFAULT);
registerNonTransitive(Constants.Configurations.MAPPING_CONSTANTS, Type.DEFAULT);
registerNonTransitive(Constants.Configurations.MINECRAFT, Role.NONE);
registerNonTransitive(Constants.Configurations.INCLUDE, Role.RESOLVABLE);
registerNonTransitive(Constants.Configurations.MAPPING_CONSTANTS, Role.RESOLVABLE);
register(Constants.Configurations.NAMED_ELEMENTS, Type.CONSUMABLE).configure(configuration -> {
register(Constants.Configurations.NAMED_ELEMENTS, Role.CONSUMABLE).configure(configuration -> {
configuration.extendsFrom(getConfigurations().getByName(JavaPlugin.API_CONFIGURATION_NAME));
});
extendsFrom(JavaPlugin.COMPILE_ONLY_CONFIGURATION_NAME, Constants.Configurations.MAPPING_CONSTANTS);
register(Constants.Configurations.MAPPINGS, Type.DEFAULT);
register(Constants.Configurations.MAPPINGS_FINAL, Type.DEFAULT);
register(Constants.Configurations.LOOM_DEVELOPMENT_DEPENDENCIES, Type.CONSUMABLE);
register(Constants.Configurations.UNPICK_CLASSPATH, Type.DEFAULT);
register(Constants.Configurations.LOCAL_RUNTIME, Type.CONSUMABLE);
register(Constants.Configurations.MAPPINGS, Role.RESOLVABLE);
register(Constants.Configurations.MAPPINGS_FINAL, Role.RESOLVABLE);
register(Constants.Configurations.LOOM_DEVELOPMENT_DEPENDENCIES, Role.RESOLVABLE);
register(Constants.Configurations.UNPICK_CLASSPATH, Role.RESOLVABLE);
register(Constants.Configurations.LOCAL_RUNTIME, Role.RESOLVABLE);
extendsFrom(JavaPlugin.RUNTIME_CLASSPATH_CONFIGURATION_NAME, Constants.Configurations.LOCAL_RUNTIME);
extension.createRemapConfigurations(SourceSetHelper.getMainSourceSet(getProject()));
@@ -113,21 +113,21 @@ public abstract class LoomConfigurations implements Runnable {
GradleUtils.afterSuccessfulEvaluation(getProject(), () -> {
if (extension.shouldGenerateSrgTiny()) {
registerNonTransitive(Constants.Configurations.SRG, Type.RESOLVABLE);
registerNonTransitive(Constants.Configurations.SRG, Role.RESOLVABLE);
}
});
if (extension.isForge()) {
// Set up Forge configurations
registerNonTransitive(Constants.Configurations.FORGE, Type.RESOLVABLE);
registerNonTransitive(Constants.Configurations.FORGE_USERDEV, Type.RESOLVABLE);
registerNonTransitive(Constants.Configurations.FORGE_INSTALLER, Type.RESOLVABLE);
registerNonTransitive(Constants.Configurations.FORGE_UNIVERSAL, Type.RESOLVABLE);
register(Constants.Configurations.FORGE_DEPENDENCIES, Type.BUCKET);
registerNonTransitive(Constants.Configurations.FORGE_NAMED, Type.BUCKET);
registerNonTransitive(Constants.Configurations.FORGE_EXTRA, Type.BUCKET);
registerNonTransitive(Constants.Configurations.MCP_CONFIG, Type.RESOLVABLE);
register(Constants.Configurations.FORGE_RUNTIME_LIBRARY, Type.RESOLVABLE).configure(configuration -> {
registerNonTransitive(Constants.Configurations.FORGE, Role.RESOLVABLE);
registerNonTransitive(Constants.Configurations.FORGE_USERDEV, Role.RESOLVABLE);
registerNonTransitive(Constants.Configurations.FORGE_INSTALLER, Role.RESOLVABLE);
registerNonTransitive(Constants.Configurations.FORGE_UNIVERSAL, Role.RESOLVABLE);
register(Constants.Configurations.FORGE_DEPENDENCIES, Role.RESOLVABLE);
registerNonTransitive(Constants.Configurations.FORGE_NAMED, Role.RESOLVABLE);
registerNonTransitive(Constants.Configurations.FORGE_EXTRA, Role.RESOLVABLE);
registerNonTransitive(Constants.Configurations.MCP_CONFIG, Role.RESOLVABLE);
register(Constants.Configurations.FORGE_RUNTIME_LIBRARY, Role.RESOLVABLE).configure(configuration -> {
// Resolve for runtime usage
Usage javaRuntime = getProject().getObjects().named(Usage.class, Usage.JAVA_RUNTIME);
configuration.attributes(attributes -> attributes.attribute(Usage.USAGE_ATTRIBUTE, javaRuntime));
@@ -161,12 +161,12 @@ public abstract class LoomConfigurations implements Runnable {
}
}
private NamedDomainObjectProvider<Configuration> register(String name, Type type) {
return getConfigurations().register(name, type::apply);
private NamedDomainObjectProvider<Configuration> register(String name, Role role) {
return getConfigurations().register(name, role::apply);
}
private NamedDomainObjectProvider<Configuration> registerNonTransitive(String name, Type type) {
final NamedDomainObjectProvider<Configuration> provider = register(name, type);
private NamedDomainObjectProvider<Configuration> registerNonTransitive(String name, Role role) {
final NamedDomainObjectProvider<Configuration> provider = register(name, role);
provider.configure(configuration -> configuration.setTransitive(false));
return provider;
}
@@ -175,16 +175,15 @@ public abstract class LoomConfigurations implements Runnable {
getConfigurations().getByName(a, configuration -> configuration.extendsFrom(getConfigurations().getByName(b)));
}
enum Type {
BUCKET(false, false), // Gradle docs call this a "bucket of dependencies"
enum Role {
NONE(false, false),
CONSUMABLE(true, false),
RESOLVABLE(false, true),
DEFAULT(true, true);
RESOLVABLE(false, true);
private final boolean canBeConsumed;
private final boolean canBeResolved;
Type(boolean canBeConsumed, boolean canBeResolved) {
Role(boolean canBeConsumed, boolean canBeResolved) {
this.canBeConsumed = canBeConsumed;
this.canBeResolved = canBeResolved;
}

10
src/main/java/net/fabricmc/loom/configuration/ide/RunConfig.java
View File

@@ -141,10 +141,10 @@ public class RunConfig {
String environment = settings.getEnvironment();
SourceSet sourceSet = settings.getSource(project);
String defaultMain = settings.getDefaultMainClass();
String mainClass = settings.getMainClass().getOrNull();
if (defaultMain == null) {
throw new IllegalArgumentException("Run configuration '" + name + "' must specify 'defaultMainClass'");
if (mainClass == null) {
throw new IllegalArgumentException("Run configuration '" + name + "' must specify 'mainClass'");
}
if (configName == null) {
@@ -182,7 +182,7 @@ public class RunConfig {
// Custom parameters
runConfig.programArgs.addAll(settings.getProgramArgs());
runConfig.vmArgs.addAll(settings.getVmArgs());
runConfig.vmArgs.add("-Dfabric.dli.main=" + getMainClass(environment, extension, defaultMain));
runConfig.vmArgs.add("-Dfabric.dli.main=" + mainClass);
runConfig.environmentVariables = new HashMap<>();
runConfig.environmentVariables.putAll(settings.getEnvironmentVariables());
runConfig.projectName = project.getName();
@@ -252,7 +252,7 @@ public class RunConfig {
return sb.toString();
}
private static String getMainClass(String side, LoomGradleExtension extension, String defaultMainClass) {
static String getMainClass(String side, LoomGradleExtension extension, String defaultMainClass) {
InstallerData installerData = extension.getInstallerData() == null ? null : extension.getInstallerData();
if (installerData == null) {

27
src/main/java/net/fabricmc/loom/configuration/ide/RunConfigSettings.java
View File

@@ -1,7 +1,7 @@
/*
* This file is part of fabric-loom, licensed under the MIT License (MIT).
*
* Copyright (c) 2021 FabricMC
* Copyright (c) 2021-2023 FabricMC
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
@@ -31,10 +31,12 @@ import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import org.gradle.api.Named;
import org.gradle.api.Project;
import org.gradle.api.provider.Property;
import org.gradle.api.tasks.SourceSet;
import org.jetbrains.annotations.ApiStatus;
@@ -78,6 +80,14 @@ public final class RunConfigSettings implements Named {
*/
private String defaultMainClass;
/**
* The main class of the run configuration.
*
* <p>If unset, {@link #defaultMainClass} is used as the fallback, including the overwritten main class
* from installer files.
*/
private final Property<String> mainClass;
/**
* The source set getter, which obtains the source set from the given project.
*/
@@ -112,6 +122,11 @@ public final class RunConfigSettings implements Named {
this.project = project;
this.extension = LoomGradleExtension.get(project);
this.ideConfigGenerated = extension.isRootProject();
this.mainClass = project.getObjects().property(String.class).convention(project.provider(() -> {
Objects.requireNonNull(environment, "Run config " + baseName + " must specify environment");
Objects.requireNonNull(defaultMainClass, "Run config " + baseName + " must specify default main class");
return RunConfig.getMainClass(environment, extension, defaultMainClass);
}));
setSource(p -> {
final String sourceSetName = MinecraftSourceSets.get(p).getSourceSetForEnv(getEnvironment());
@@ -189,6 +204,16 @@ public final class RunConfigSettings implements Named {
this.defaultMainClass = defaultMainClass;
}
/**
* The main class of the run configuration.
*
* <p>If unset, {@link #getDefaultMainClass defaultMainClass} is used as the fallback,
* including the overwritten main class from installer files.
*/
public Property<String> getMainClass() {
return mainClass;
}
public String getRunDir() {
return runDir;
}

18
src/test/groovy/net/fabricmc/loom/test/integration/RunConfigTest.groovy
View File

@@ -1,7 +1,7 @@
/*
* This file is part of fabric-loom, licensed under the MIT License (MIT).
*
* Copyright (c) 2018-2021 FabricMC
* Copyright (c) 2018-2023 FabricMC
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
@@ -59,6 +59,22 @@ class RunConfigTest extends Specification implements GradleProjectTestTrait {
task << tasks * STANDARD_TEST_VERSIONS.size()
}
@Unroll
def "Custom main class (gradle #version)"() {
setup:
def gradle = gradleProject(project: "runconfigs", sharedFiles: true, version: version)
when:
def result = gradle.run(task: 'runCustomMain')
then:
result.task(':runCustomMain').outcome == SUCCESS
result.output.contains('hello custom main')
where:
version << STANDARD_TEST_VERSIONS
}
@RestoreSystemProperties
@Unroll
def "idea auto configuration (gradle #version)"() {

5
src/test/resources/projects/runconfigs/build.gradle
View File

@@ -20,6 +20,11 @@ loom {
inherit testmodServer
vmArg "-Dfabric.autoTest"
}
customMain {
inherit server
name = 'Custom Main Class'
mainClass.set 'net.fabricmc.example.Main'
}
}
runConfigs.configureEach {

10
src/test/resources/projects/runconfigs/src/main/java/net/fabricmc/example/Main.java Normal file
View File

@@ -0,0 +1,10 @@
package net.fabricmc.example;
import net.fabricmc.loader.impl.launch.knot.KnotServer;
public class Main {
public static void main(String[] args) {
System.out.println("hello custom main");
KnotServer.main(args);
}
}