wurstscript / WurstScript / 259

Committed 27 Jun 2025 02:54PM UTC coverage: 62.224% (-0.007%) from 62.231%

Build # 259

Build Type

push

circleci

Committed by

Frotty

Commit Message

Allow game exe override

Supports specifying a specific file that will be run for the runmap commands, overriding other config

Run Details

17261 of 27740 relevant lines covered (62.22%)

0.62 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstio/languageserver/WurstCommands.java

package de.peeeq.wurstio.languageserver;

import com.google.common.base.Charsets;
import com.google.common.collect.ImmutableList;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import de.peeeq.wurstio.languageserver.requests.*;
import de.peeeq.wurstscript.WLogger;
import org.eclipse.lsp4j.ExecuteCommandParams;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 *
 */
public class WurstCommands {

    public static final String WURST_RESTART = "wurst.restart";
    public static final String WURST_CLEAN = "wurst.clean";
    public static final String WURST_STARTMAP = "wurst.startmap";
    public static final String WURST_HOTSTARTMAP = "wurst.hotstartmap";
    public static final String WURST_HOTRELOAD = "wurst.hotreload";
    public static final String WURST_BUILDMAP = "wurst.buildmap";
    public static final String WURST_STARTLAST = "wurst.startlast";
    public static final String WURST_TESTS = "wurst.tests";
    public static final String WURST_TESTS_FILE = "wurst.tests_file";
    public static final String WURST_TESTS_FUNC = "wurst.tests_func";
    public static final String WURST_PERFORM_CODE_ACTION = "wurst.perform_code_action";

    static List<String> providedCommands() {
        return List.of(
                WURST_CLEAN
        );
    }

    public static CompletableFuture<Object> execute(WurstLanguageServer server, ExecuteCommandParams params) {
        switch (params.getCommand()) {
            case WURST_CLEAN:
                return server.worker().handle(new CleanProject()).thenApply(x -> x);
            case WURST_STARTMAP:
                return startMap(server, params);
            case WURST_HOTSTARTMAP:
                return startMap(server, params, "-hotstart");
            case WURST_HOTRELOAD:
                return startMap(server, params, "-hotreload");
            case WURST_TESTS:
                return testMap(server, params);
            case WURST_PERFORM_CODE_ACTION:
                return server.worker().handle(new PerformCodeActionRequest(server, params));
            case WURST_BUILDMAP:
                return buildMap(server, params);
        }
        WLogger.info("unhandled command: " + params.getCommand());
        throw new RuntimeException("unhandled command: " + params.getCommand());
    }


    private static CompletableFuture<Object> testMap(WurstLanguageServer server, ExecuteCommandParams params) {
        JsonObject options = (JsonObject) params.getArguments().get(0);
        Optional<String> filename = getString(options, "filename");
        int line = options.has("line") ? options.get("line").getAsInt() : -1;
        int column = options.has("column") ? options.get("column").getAsInt() : -1;
        int testTimeout = options.has("testTimeout") ? options.get("testTimeout").getAsInt() : 20;
        Optional<String> testName = getString(options, "testName");

        return server.worker().handle(new RunTests(filename, line, column, testName, testTimeout));
    }

    private static CompletableFuture<Object> buildMap(WurstLanguageServer server, ExecuteCommandParams params) {
        WFile workspaceRoot = server.getRootUri();
        if (params.getArguments().isEmpty()) {
            throw new RuntimeException("Missing arguments");
        }
        JsonObject options = (JsonObject) params.getArguments().get(0);
        Optional<String> mapPath = getString(options, "mappath");
        Optional<String> wc3Path = getString(options, "wc3path");
        if (!mapPath.isPresent()) {
            throw new RuntimeException("No mappath given");
        }

        Optional<File> map = mapPath.map(File::new);
        List<String> compileArgs = getCompileArgs(workspaceRoot);
        return server.worker().handle(new BuildMap(server, workspaceRoot, wc3Path, map, compileArgs)).thenApply(x -> x);
    }

    private static CompletableFuture<Object> startMap(WurstLanguageServer server, ExecuteCommandParams params, String... additionalArgs) {
        WFile workspaceRoot = server.getRootUri();
        if (params.getArguments().isEmpty()) {
            throw new RuntimeException("Missing arguments");
        }
        JsonObject options = (JsonObject) params.getArguments().get(0);
        Optional<String> mapPath = getString(options,  "mappath");
        Optional<String> wc3Path = getString(options, "wc3path");
        Optional<String> gameExePath = getString(options, "gameExePath");

        Optional<File> map = mapPath.map(File::new);
        List<String> compileArgs = getCompileArgs(workspaceRoot, additionalArgs);
        return server.worker().handle(new RunMap(server, workspaceRoot, wc3Path, map, compileArgs, gameExePath)).thenApply(x -> x);
    }

    private static Optional<String> getString(JsonObject options, String key) {
        try {
            return Optional.ofNullable(options.get(key)).map(JsonElement::getAsString);
        } catch (ClassCastException | IllegalStateException e) {
            WLogger.warning("Invalid configuration", e);
            return Optional.empty();
        }
    }

    private static final List<String> defaultArgs = ImmutableList.of("-runcompiletimefunctions", "-injectobjects", "-stacktraces");

    public static List<String> getCompileArgs(WFile rootPath, String... additionalArgs) {
        try {
            Path configFile = Paths.get(rootPath.toString(), "wurst_run.args");
            if (Files.exists(configFile)) {
                try (Stream<String> lines = Files.lines(configFile)) {
                    return Stream.concat(
                        lines.filter(s -> s.startsWith("-")),
                        Stream.of(additionalArgs)
                    ).collect(Collectors.toList());
                }
            } else {

                String cfg = String.join("\n", defaultArgs) + "\n";
                Files.write(configFile, cfg.getBytes(Charsets.UTF_8));
                return defaultArgs;
            }
        } catch (IOException e) {
            throw new RuntimeException("Could not access wurst_run.args config file", e);
        }
    }

}

1	package de.peeeq.wurstio.languageserver;
2
3	import com.google.common.base.Charsets;
4	import com.google.common.collect.ImmutableList;
5	import com.google.gson.JsonElement;
6	import com.google.gson.JsonObject;
7	import de.peeeq.wurstio.languageserver.requests.*;
8	import de.peeeq.wurstscript.WLogger;
9	import org.eclipse.lsp4j.ExecuteCommandParams;
10
11	import java.io.File;
12	import java.io.IOException;
13	import java.nio.file.Files;
14	import java.nio.file.Path;
15	import java.nio.file.Paths;
16	import java.util.List;
17	import java.util.Optional;
18	import java.util.concurrent.CompletableFuture;
19	import java.util.stream.Collectors;
20	import java.util.stream.Stream;
21
22	/**
23	*
24	*/
25	public class WurstCommands {	×
26
27	public static final String WURST_RESTART = "wurst.restart";
28	public static final String WURST_CLEAN = "wurst.clean";
29	public static final String WURST_STARTMAP = "wurst.startmap";
30	public static final String WURST_HOTSTARTMAP = "wurst.hotstartmap";
31	public static final String WURST_HOTRELOAD = "wurst.hotreload";
32	public static final String WURST_BUILDMAP = "wurst.buildmap";
33	public static final String WURST_STARTLAST = "wurst.startlast";
34	public static final String WURST_TESTS = "wurst.tests";
35	public static final String WURST_TESTS_FILE = "wurst.tests_file";
36	public static final String WURST_TESTS_FUNC = "wurst.tests_func";
37	public static final String WURST_PERFORM_CODE_ACTION = "wurst.perform_code_action";
38
39	static List<String> providedCommands() {
40	return List.of(	×
41	WURST_CLEAN
42	);
43	}
44
45	public static CompletableFuture<Object> execute(WurstLanguageServer server, ExecuteCommandParams params) {
46	switch (params.getCommand()) {	×
47	case WURST_CLEAN:
48	return server.worker().handle(new CleanProject()).thenApply(x -> x);	×
49	case WURST_STARTMAP:
50	return startMap(server, params);	×
51	case WURST_HOTSTARTMAP:
52	return startMap(server, params, "-hotstart");	×
53	case WURST_HOTRELOAD:
54	return startMap(server, params, "-hotreload");	×
55	case WURST_TESTS:
56	return testMap(server, params);	×
57	case WURST_PERFORM_CODE_ACTION:
58	return server.worker().handle(new PerformCodeActionRequest(server, params));	×
59	case WURST_BUILDMAP:
60	return buildMap(server, params);	×
61	}
62	WLogger.info("unhandled command: " + params.getCommand());	×
63	throw new RuntimeException("unhandled command: " + params.getCommand());	×
64	}
65
66
67	private static CompletableFuture<Object> testMap(WurstLanguageServer server, ExecuteCommandParams params) {
68	JsonObject options = (JsonObject) params.getArguments().get(0);	×
69	Optional<String> filename = getString(options, "filename");	×
70	int line = options.has("line") ? options.get("line").getAsInt() : -1;	×
71	int column = options.has("column") ? options.get("column").getAsInt() : -1;	×
72	int testTimeout = options.has("testTimeout") ? options.get("testTimeout").getAsInt() : 20;	×
73	Optional<String> testName = getString(options, "testName");	×
74
75	return server.worker().handle(new RunTests(filename, line, column, testName, testTimeout));	×
76	}
77
78	private static CompletableFuture<Object> buildMap(WurstLanguageServer server, ExecuteCommandParams params) {
79	WFile workspaceRoot = server.getRootUri();	×
80	if (params.getArguments().isEmpty()) {	×
81	throw new RuntimeException("Missing arguments");	×
82	}
83	JsonObject options = (JsonObject) params.getArguments().get(0);	×
84	Optional<String> mapPath = getString(options, "mappath");	×
85	Optional<String> wc3Path = getString(options, "wc3path");	×
86	if (!mapPath.isPresent()) {	×
87	throw new RuntimeException("No mappath given");	×
88	}
89
90	Optional<File> map = mapPath.map(File::new);	×
91	List<String> compileArgs = getCompileArgs(workspaceRoot);	×
92	return server.worker().handle(new BuildMap(server, workspaceRoot, wc3Path, map, compileArgs)).thenApply(x -> x);	×
93	}
94
95	private static CompletableFuture<Object> startMap(WurstLanguageServer server, ExecuteCommandParams params, String... additionalArgs) {
96	WFile workspaceRoot = server.getRootUri();	×
97	if (params.getArguments().isEmpty()) {	×
98	throw new RuntimeException("Missing arguments");	×
99	}
100	JsonObject options = (JsonObject) params.getArguments().get(0);	×
101	Optional<String> mapPath = getString(options, "mappath");	×
102	Optional<String> wc3Path = getString(options, "wc3path");	×
103	Optional<String> gameExePath = getString(options, "gameExePath");	×
104
105	Optional<File> map = mapPath.map(File::new);	×
106	List<String> compileArgs = getCompileArgs(workspaceRoot, additionalArgs);	×
107	return server.worker().handle(new RunMap(server, workspaceRoot, wc3Path, map, compileArgs, gameExePath)).thenApply(x -> x);	×
108	}
109
110	private static Optional<String> getString(JsonObject options, String key) {
111	try {
112	return Optional.ofNullable(options.get(key)).map(JsonElement::getAsString);	×
113	} catch (ClassCastException \| IllegalStateException e) {	×
114	WLogger.warning("Invalid configuration", e);	×
115	return Optional.empty();	×
116	}
117	}
118
119	private static final List<String> defaultArgs = ImmutableList.of("-runcompiletimefunctions", "-injectobjects", "-stacktraces");	×
120
121	public static List<String> getCompileArgs(WFile rootPath, String... additionalArgs) {
122	try {
123	Path configFile = Paths.get(rootPath.toString(), "wurst_run.args");	×
124	if (Files.exists(configFile)) {	×
125	try (Stream<String> lines = Files.lines(configFile)) {	×
126	return Stream.concat(	×
127	lines.filter(s -> s.startsWith("-")),	×
128	Stream.of(additionalArgs)	×
129	).collect(Collectors.toList());	×
130	}
131	} else {
132
133	String cfg = String.join("\n", defaultArgs) + "\n";	×
134	Files.write(configFile, cfg.getBytes(Charsets.UTF_8));	×
135	return defaultArgs;	×
136	}
137	} catch (IOException e) {	×
138	throw new RuntimeException("Could not access wurst_run.args config file", e);	×
139	}
140	}
141
142	}

wurstscript / WurstScript / 259

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous