wurstscript / WurstScript / 228

Committed 29 Nov 2023 05:00PM UTC coverage: 62.48% (-0.09%) from 62.574%

Build # 228

Build Type

push

circleci

Committed by

web-flow

Commit Message

Show dialog for choosing game path, cleanup (#1083)

* show dialog for choosing game path

* cleanup code

* remove logs and refactor

* remove confusing mpq error, make some mpq loads readonly

Run Details

17295 of 27681 relevant lines covered (62.48%)

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/WurstLanguageServer.java

package de.peeeq.wurstio.languageserver;

import de.peeeq.wurstscript.CompileTimeInfo;
import de.peeeq.wurstscript.WLogger;
import org.eclipse.lsp4j.*;
import org.eclipse.lsp4j.jsonrpc.RemoteEndpoint;
import org.eclipse.lsp4j.jsonrpc.messages.Either;
import org.eclipse.lsp4j.services.*;

import java.io.FileDescriptor;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Collections;
import java.util.concurrent.CompletableFuture;

/**
 *
 */
public class WurstLanguageServer implements LanguageServer, LanguageClientAware {
    private WFile rootUri;
    private final de.peeeq.wurstio.languageserver.LanguageWorker languageWorker = new de.peeeq.wurstio.languageserver.LanguageWorker();
    private LanguageClient languageClient;
    private RemoteEndpoint remoteEndpoint;

    @Override
    public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
        System.err.println("Loading Wurst version " + CompileTimeInfo.version);
        setupLogger();
        System.setErr(new PrintStream(new FileOutputStream(FileDescriptor.err), true, StandardCharsets.UTF_8));
        if (params.getRootUri() == null) {
            System.err.println("Workspace null. Make sure to open a valid project root using File->Open Folder, before opening code files.");
            return CompletableFuture.completedFuture(null);
        }
        WLogger.info("initialize " + params.getRootUri());
        rootUri = WFile.create(params.getRootUri());
        languageWorker.setRootPath(rootUri);

        ServerCapabilities capabilities = new ServerCapabilities();
        capabilities.setCompletionProvider(new CompletionOptions(false, Collections.singletonList(".")));
        capabilities.setHoverProvider(true);
        capabilities.setDefinitionProvider(true);
        capabilities.setSignatureHelpProvider(new SignatureHelpOptions(Arrays.asList("(", ".")));
        capabilities.setDocumentHighlightProvider(true);
        capabilities.setReferencesProvider(true);
        capabilities.setExecuteCommandProvider(new ExecuteCommandOptions(WurstCommands.providedCommands()));
        capabilities.setRenameProvider(true);


        capabilities.setTextDocumentSync(Either.forLeft(TextDocumentSyncKind.Full));
        capabilities.setCodeActionProvider(true);
        capabilities.setDocumentSymbolProvider(true);
        capabilities.setWorkspaceSymbolProvider(true);
        capabilities.setDocumentFormattingProvider(true);
        capabilities.setColorProvider(true);
        capabilities.setCodeLensProvider(new CodeLensOptions(true));
        capabilities.setFoldingRangeProvider(true);


        InitializeResult res = new InitializeResult(capabilities);
        WLogger.info("initialization done: " + params.getRootUri());
        return CompletableFuture.completedFuture(res);
    }
    private void setupLogger() {
        WLogger.setLogger("languageServer");
    }

    @Override
    public CompletableFuture<Object> shutdown() {
        WLogger.info("shutdown");
        languageWorker.stop();
        return CompletableFuture.completedFuture("ok");
    }

    @Override
    public void exit() {
        System.exit(0);
    }

    @Override
    public TextDocumentService getTextDocumentService() {
        WLogger.info("getTextDocumentService");
        return new WurstTextDocumentService(languageWorker);
    }

    @Override
    public WorkspaceService getWorkspaceService() {
        WLogger.info("getWorkspaceService");
        return new WurstWorkspaceService(this);
    }

    @Override
    public void connect(LanguageClient client) {
        WLogger.info("connect to LanguageClient");
        this.languageClient = client;
        languageWorker.setLanguageClient(client);
    }

    public LanguageWorker worker() {
        return languageWorker;
    }

    public WFile getRootUri() {
        return rootUri;
    }

    public LanguageClient getLanguageClient() {
        return languageClient;
    }

    public ConfigProvider getConfigProvider() {
        return new ConfigProvider(languageClient);
    }

    public void setRemoteEndpoint(RemoteEndpoint remoteEndpoint) {
        this.remoteEndpoint = remoteEndpoint;
    }

    public RemoteEndpoint getRemoteEndpoint() {
        return remoteEndpoint;
    }
}

1	package de.peeeq.wurstio.languageserver;
2
3	import de.peeeq.wurstscript.CompileTimeInfo;
4	import de.peeeq.wurstscript.WLogger;
5	import org.eclipse.lsp4j.*;
6	import org.eclipse.lsp4j.jsonrpc.RemoteEndpoint;
7	import org.eclipse.lsp4j.jsonrpc.messages.Either;
8	import org.eclipse.lsp4j.services.*;
9
10	import java.io.FileDescriptor;
11	import java.io.FileOutputStream;
12	import java.io.PrintStream;
13	import java.nio.charset.StandardCharsets;
14	import java.util.Arrays;
15	import java.util.Collections;
16	import java.util.concurrent.CompletableFuture;
17
18	/**
19	*
20	*/
21	public class WurstLanguageServer implements LanguageServer, LanguageClientAware {	×
22	private WFile rootUri;
23	private final de.peeeq.wurstio.languageserver.LanguageWorker languageWorker = new de.peeeq.wurstio.languageserver.LanguageWorker();	×
24	private LanguageClient languageClient;
25	private RemoteEndpoint remoteEndpoint;
26
27	@Override
28	public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
29	System.err.println("Loading Wurst version " + CompileTimeInfo.version);	×
30	setupLogger();	×
31	System.setErr(new PrintStream(new FileOutputStream(FileDescriptor.err), true, StandardCharsets.UTF_8));	×
32	if (params.getRootUri() == null) {	×
33	System.err.println("Workspace null. Make sure to open a valid project root using File->Open Folder, before opening code files.");	×
34	return CompletableFuture.completedFuture(null);	×
35	}
36	WLogger.info("initialize " + params.getRootUri());	×
37	rootUri = WFile.create(params.getRootUri());	×
38	languageWorker.setRootPath(rootUri);	×
39
40	ServerCapabilities capabilities = new ServerCapabilities();	×
41	capabilities.setCompletionProvider(new CompletionOptions(false, Collections.singletonList(".")));	×
42	capabilities.setHoverProvider(true);	×
43	capabilities.setDefinitionProvider(true);	×
44	capabilities.setSignatureHelpProvider(new SignatureHelpOptions(Arrays.asList("(", ".")));	×
45	capabilities.setDocumentHighlightProvider(true);	×
46	capabilities.setReferencesProvider(true);	×
47	capabilities.setExecuteCommandProvider(new ExecuteCommandOptions(WurstCommands.providedCommands()));	×
48	capabilities.setRenameProvider(true);	×
49
50
51	capabilities.setTextDocumentSync(Either.forLeft(TextDocumentSyncKind.Full));	×
52	capabilities.setCodeActionProvider(true);	×
53	capabilities.setDocumentSymbolProvider(true);	×
54	capabilities.setWorkspaceSymbolProvider(true);	×
55	capabilities.setDocumentFormattingProvider(true);	×
56	capabilities.setColorProvider(true);	×
57	capabilities.setCodeLensProvider(new CodeLensOptions(true));	×
58	capabilities.setFoldingRangeProvider(true);	×
59
60
61	InitializeResult res = new InitializeResult(capabilities);	×
62	WLogger.info("initialization done: " + params.getRootUri());	×
63	return CompletableFuture.completedFuture(res);	×
64	}
65	private void setupLogger() {
66	WLogger.setLogger("languageServer");	×
67	}	×
68
69	@Override
70	public CompletableFuture<Object> shutdown() {
71	WLogger.info("shutdown");	×
72	languageWorker.stop();	×
73	return CompletableFuture.completedFuture("ok");	×
74	}
75
76	@Override
77	public void exit() {
78	System.exit(0);	×
79	}	×
80
81	@Override
82	public TextDocumentService getTextDocumentService() {
83	WLogger.info("getTextDocumentService");	×
84	return new WurstTextDocumentService(languageWorker);	×
85	}
86
87	@Override
88	public WorkspaceService getWorkspaceService() {
89	WLogger.info("getWorkspaceService");	×
90	return new WurstWorkspaceService(this);	×
91	}
92
93	@Override
94	public void connect(LanguageClient client) {
95	WLogger.info("connect to LanguageClient");	×
96	this.languageClient = client;	×
97	languageWorker.setLanguageClient(client);	×
98	}	×
99
100	public LanguageWorker worker() {
101	return languageWorker;	×
102	}
103
104	public WFile getRootUri() {
105	return rootUri;	×
106	}
107
108	public LanguageClient getLanguageClient() {
109	return languageClient;	×
110	}
111
112	public ConfigProvider getConfigProvider() {
113	return new ConfigProvider(languageClient);	×
114	}
115
116	public void setRemoteEndpoint(RemoteEndpoint remoteEndpoint) {
117	this.remoteEndpoint = remoteEndpoint;	×
118	}	×
119
120	public RemoteEndpoint getRemoteEndpoint() {
121	return remoteEndpoint;	×
122	}
123	}

wurstscript / WurstScript / 228

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