下面列出了org.eclipse.lsp4j.MessageActionItem#org.eclipse.lsp4j.InitializeParams 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Override
public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
LOGGER.info("Initializing XML Language server" + System.lineSeparator() + new ServerInfo().details());
this.parentProcessId = params.getProcessId();
// Update XML language service extensions with InitializeParams
xmlLanguageService.initializeParams(params);
ExtendedClientCapabilities extendedClientCapabilities = InitializationOptionsExtendedClientCapabilities
.getExtendedClientCapabilities(params);
capabilityManager.setClientCapabilities(params.getCapabilities(), extendedClientCapabilities);
xmlTextDocumentService.updateClientCapabilities(capabilityManager.getClientCapabilities().capabilities,
capabilityManager.getClientCapabilities().getExtendedCapabilities());
updateSettings(InitializationOptionsSettings.getSettings(params));
ServerCapabilities nonDynamicServerCapabilities = ServerCapabilitiesInitializer.getNonDynamicServerCapabilities(
capabilityManager.getClientCapabilities(), xmlTextDocumentService.isIncrementalSupport());
return CompletableFuture.completedFuture(new InitializeResult(nonDynamicServerCapabilities));
}
@Override
public void start(InitializeParams params, XMLExtensionsRegistry registry) {
// register DTD content model provider
ContentModelProvider modelProvider = new CMDTDContentModelProvider(registry.getResolverExtensionManager());
ContentModelManager modelManager = registry.getComponent(ContentModelManager.class);
modelManager.registerModelProvider(modelProvider);
// register diagnostic participant
registry.registerDiagnosticsParticipant(diagnosticsParticipant);
// register definition participant
registry.registerDefinitionParticipant(definitionParticipant);
// register highlighting participant
registry.registerHighlightingParticipant(highlightingParticipant);
// register reference participant
registry.registerReferenceParticipant(referenceParticipant);
// register codelens participant
registry.registerCodeLensParticipant(codeLensParticipant);
}
@Override
public void start(InitializeParams params, XMLExtensionsRegistry registry) {
// Register resolver
uiResolver = new XSDURIResolverExtension(registry.getDocumentProvider());
registry.getResolverExtensionManager().registerResolver(uiResolver);
// register XSD content model provider
ContentModelProvider modelProvider = new CMXSDContentModelProvider(registry.getResolverExtensionManager());
modelManager = registry.getComponent(ContentModelManager.class);
modelManager.registerModelProvider(modelProvider);
// register completion, diagnostic participant
registry.registerCompletionParticipant(completionParticipant);
registry.registerDefinitionParticipant(definitionParticipant);
registry.registerDiagnosticsParticipant(diagnosticsParticipant);
registry.registerReferenceParticipant(referenceParticipant);
registry.registerCodeLensParticipant(codeLensParticipant);
registry.registerHighlightingParticipant(highlightingParticipant);
registry.registerRenameParticipant(renameParticipant);
registry.registerDocumentLinkParticipant(documentLinkParticipant);
}
@Test
public void symbolSettingsTest() {
//Tests that when the settings are updated the shared settings are also updated correctly
InitializeParams params = createInitializeParams(json);
Object initializationOptionsSettings = InitializationOptionsSettings.getSettings(params);
XMLLanguageServer languageServer = new XMLLanguageServer();
languageServer.updateSettings(initializationOptionsSettings); // This should set/update the sharedSettings
XMLExcludedSymbolFile xsdFile = new XMLExcludedSymbolFile("**\\*.xsd");
XMLExcludedSymbolFile xmlFile = new XMLExcludedSymbolFile("**\\*.xml");
XMLExcludedSymbolFile[] expectedExcludedFiles = new XMLExcludedSymbolFile[] {xsdFile, xmlFile};
XMLExcludedSymbolFile[] actualExpectedFiles = languageServer.getSettings().getSymbolSettings().getExcludedFiles();
assertArrayEquals(expectedExcludedFiles, actualExpectedFiles);
}
@Override
public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
Integer processId = params.getProcessId();
if(processId != null) {
setParentProcessId(processId.longValue());
} else {
LOGGER.info("Missing Parent process ID!!");
setParentProcessId(0);
}
new SettingsManager(getTextDocumentService()).apply(params);
ServerCapabilities capabilities = createServerCapabilities();
InitializeResult result = new InitializeResult(capabilities);
return CompletableFuture.completedFuture(result);
}
@Test
public void diagnosticsNoTarget() throws Exception {
RdfLintLanguageServer lsp = new RdfLintLanguageServer();
InitializeParams initParams = new InitializeParams();
String rootPath = this.getClass().getClassLoader().getResource("testValidatorsImpl/").getPath();
String parentPath = rootPath + "TrimValidator/turtle_needtrim";
initParams.setRootUri(RdfLintLanguageServer.convertFilePath2Uri(parentPath));
lsp.initialize(initParams);
LanguageClient client = mock(LanguageClient.class);
lsp.connect(client);
lsp.refreshFileTripleSet();
verify(client, never()).publishDiagnostics(any());
}
@Test
public void diagnosticsClose() throws Exception {
RdfLintLanguageServer lsp = new RdfLintLanguageServer();
InitializeParams initParams = new InitializeParams();
String rootPath = this.getClass().getClassLoader().getResource("testValidatorsImpl/").getPath();
String parentPath = rootPath + "TrimValidator/turtle_needtrim";
initParams.setRootUri(RdfLintLanguageServer.convertFilePath2Uri(parentPath));
lsp.initialize(initParams);
LanguageClient client = mock(LanguageClient.class);
lsp.connect(client);
DidCloseTextDocumentParams closeParams = new DidCloseTextDocumentParams();
closeParams.setTextDocument(new TextDocumentIdentifier());
closeParams.getTextDocument()
.setUri(RdfLintLanguageServer.convertFilePath2Uri(parentPath + "/needtrim.rdf"));
lsp.didClose(closeParams);
verify(client, times(2)).publishDiagnostics(any());
}
/** Connects, initializes and waits for the initial build of the test project. */
protected void startLspServer(File root) {
ClientCapabilities capabilities = new ClientCapabilities();
WorkspaceClientCapabilities wcc = new WorkspaceClientCapabilities();
wcc.setExecuteCommand(new ExecuteCommandCapabilities());
capabilities.setWorkspace(wcc);
InitializeParams initParams = new InitializeParams();
initParams.setCapabilities(capabilities);
initParams.setRootUri(new FileURI(root).toString());
languageClient.addListener(this);
languageServer.connect(languageClient);
languageServer.initialize(initParams);
languageServer.initialized(null);
joinServerRequests();
}
@Override
public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
if (initializeParams != null) {
throw new IllegalStateException("This language server has already been initialized.");
}
URI baseDir = getBaseDir(params);
if (languagesRegistry.getExtensionToFactoryMap().isEmpty()) {
throw new IllegalStateException(
"No Xtext languages have been registered. Please make sure you have added the languages\'s setup class in \'/META-INF/services/org.eclipse.xtext.ISetup\'");
}
this.initializeParams = params;
openFilesManager.setIssueRegistry(issueRegistry);
openFilesManager.addListener(this);
lspBuilder.getIndexRaw().addListener(this);
Stopwatch sw = Stopwatch.createStarted();
LOG.info("Start server initialization in workspace directory " + baseDir);
lspBuilder.initialize(baseDir, issueRegistry);
LOG.info("Server initialization done after " + sw);
initializeResult = new InitializeResult();
initializeResult.setCapabilities(createServerCapabilities(params));
return CompletableFuture.completedFuture(initializeResult);
}
@Test
public void testCancelInitJob() throws Exception {
File workspaceDir = copyFiles("maven/salut", true);
String rootPathURI = workspaceDir.toURI().toString();
Collection<IPath> rootPaths = Collections.singleton(ResourceUtils.canonicalFilePathFromURI(rootPathURI));
InitializeParams params = new InitializeParams();
params.setRootUri(rootPathURI);
server.initialize(params);
Job[] initWorkspaceJobs = Job.getJobManager().find(rootPaths);
assertEquals(1, initWorkspaceJobs.length);
Job initWorkspaceJob = initWorkspaceJobs[0];
assertNotNull(initWorkspaceJob);
projectsManager.updateWorkspaceFolders(Collections.emptySet(), rootPaths);
waitForBackgroundJobs();
assertTrue("the init job hasn't been cancelled, status is: " + initWorkspaceJob.getResult().getSeverity(), initWorkspaceJob.getResult().matches(IStatus.CANCEL));
}
private InitializeResult initialize(boolean dynamicRegistration) throws InterruptedException, ExecutionException {
InitializeParams params = new InitializeParams();
ClientCapabilities capabilities = new ClientCapabilities();
WorkspaceClientCapabilities workspaceCapabilities = new WorkspaceClientCapabilities();
workspaceCapabilities.setDidChangeConfiguration(new DidChangeConfigurationCapabilities(dynamicRegistration));
ExecuteCommandCapabilities executeCommand = new ExecuteCommandCapabilities(dynamicRegistration);
workspaceCapabilities.setExecuteCommand(executeCommand);
capabilities.setWorkspace(workspaceCapabilities);
TextDocumentClientCapabilities textDocument = new TextDocumentClientCapabilities();
SynchronizationCapabilities synchronizationCapabilities = new SynchronizationCapabilities();
synchronizationCapabilities.setWillSave(Boolean.TRUE);
synchronizationCapabilities.setWillSaveWaitUntil(Boolean.TRUE);
capabilities.setTextDocument(textDocument);
params.setCapabilities(capabilities);
CompletableFuture<InitializeResult> result = server.initialize(params);
return result.get();
}
private InitializeParams getInitParams() {
InitializeParams initParams = new InitializeParams();
initParams.setRootUri(FileUtils.pathToUri(projectRootPath));
//TODO update capabilities when implemented
WorkspaceClientCapabilities workspaceClientCapabilities = new WorkspaceClientCapabilities();
workspaceClientCapabilities.setApplyEdit(true);
workspaceClientCapabilities.setDidChangeWatchedFiles(new DidChangeWatchedFilesCapabilities());
workspaceClientCapabilities.setExecuteCommand(new ExecuteCommandCapabilities());
workspaceClientCapabilities.setWorkspaceEdit(new WorkspaceEditCapabilities());
workspaceClientCapabilities.setSymbol(new SymbolCapabilities());
workspaceClientCapabilities.setWorkspaceFolders(false);
workspaceClientCapabilities.setConfiguration(false);
TextDocumentClientCapabilities textDocumentClientCapabilities = new TextDocumentClientCapabilities();
textDocumentClientCapabilities.setCodeAction(new CodeActionCapabilities());
textDocumentClientCapabilities.setCompletion(new CompletionCapabilities(new CompletionItemCapabilities(true)));
textDocumentClientCapabilities.setDefinition(new DefinitionCapabilities());
textDocumentClientCapabilities.setDocumentHighlight(new DocumentHighlightCapabilities());
textDocumentClientCapabilities.setFormatting(new FormattingCapabilities());
textDocumentClientCapabilities.setHover(new HoverCapabilities());
textDocumentClientCapabilities.setOnTypeFormatting(new OnTypeFormattingCapabilities());
textDocumentClientCapabilities.setRangeFormatting(new RangeFormattingCapabilities());
textDocumentClientCapabilities.setReferences(new ReferencesCapabilities());
textDocumentClientCapabilities.setRename(new RenameCapabilities());
textDocumentClientCapabilities.setSemanticHighlightingCapabilities(new SemanticHighlightingCapabilities(false));
textDocumentClientCapabilities.setSignatureHelp(new SignatureHelpCapabilities());
textDocumentClientCapabilities.setSynchronization(new SynchronizationCapabilities(true, true, true));
initParams.setCapabilities(
new ClientCapabilities(workspaceClientCapabilities, textDocumentClientCapabilities, null));
initParams.setInitializationOptions(
serverDefinition.getInitializationOptions(URI.create(initParams.getRootUri())));
return initParams;
}
@Override
public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
String rootUriString = params.getRootUri();
if (rootUriString != null) {
URI uri = URI.create(params.getRootUri());
Path workspaceRoot = Paths.get(uri);
groovyServices.setWorkspaceRoot(workspaceRoot);
}
CompletionOptions completionOptions = new CompletionOptions(false, Arrays.asList("."));
ServerCapabilities serverCapabilities = new ServerCapabilities();
serverCapabilities.setCompletionProvider(completionOptions);
serverCapabilities.setTextDocumentSync(TextDocumentSyncKind.Full);
serverCapabilities.setDocumentSymbolProvider(true);
serverCapabilities.setWorkspaceSymbolProvider(true);
serverCapabilities.setDocumentSymbolProvider(true);
serverCapabilities.setReferencesProvider(true);
serverCapabilities.setDefinitionProvider(true);
serverCapabilities.setTypeDefinitionProvider(true);
serverCapabilities.setHoverProvider(true);
serverCapabilities.setRenameProvider(true);
SignatureHelpOptions signatureHelpOptions = new SignatureHelpOptions();
signatureHelpOptions.setTriggerCharacters(Arrays.asList("(", ","));
serverCapabilities.setSignatureHelpProvider(signatureHelpOptions);
InitializeResult initializeResult = new InitializeResult(serverCapabilities);
return CompletableFuture.completedFuture(initializeResult);
}
public void initializeParams(InitializeParams params) {
if (initialized) {
extensions.stream().forEach(extension -> {
try {
extension.start(params, this);
} catch (Exception e) {
LOGGER.log(Level.SEVERE, "Error while starting extension <" + extension.getClass().getName() + ">",
e);
}
});
} else {
this.params = params;
}
}
@Override
public void start(InitializeParams params, XMLExtensionsRegistry registry) {
uiResolver = new XMLCatalogURIResolverExtension(registry);
registry.getResolverExtensionManager().registerResolver(uiResolver);
IXMLNotificationService notificationService = registry.getNotificationService();
if (notificationService != null) {
this.pathWarner = new InvalidPathWarner(notificationService);
}
}
@Override
public void start(InitializeParams params, XMLExtensionsRegistry registry) {
completionParticipant = new EntitiesCompletionParticipant();
registry.registerCompletionParticipant(completionParticipant);
definitionParticipant = new EntitiesDefinitionParticipant();
registry.registerDefinitionParticipant(definitionParticipant);
hoverParticipant = new EntitiesHoverParticipant();
registry.registerHoverParticipant(hoverParticipant);
}
@Override
public void start(InitializeParams params, XMLExtensionsRegistry registry) {
// register xml-model content model provider
ContentModelManager modelManager = registry.getComponent(ContentModelManager.class);
ContentModelProvider modelProvider = new CMXMLModelContentModelProvider(modelManager);
modelManager.registerModelProvider(modelProvider);
}
@Override
public void start(InitializeParams params, XMLExtensionsRegistry registry) {
URIResolverExtensionManager resolverManager = registry.getComponent(URIResolverExtensionManager.class);
contentModelManager = new ContentModelManager(resolverManager);
registry.registerComponent(contentModelManager);
if (params != null) {
contentModelManager.setRootURI(params.getRootUri());
}
registry.registerCompletionParticipant(completionParticipant);
registry.registerHoverParticipant(hoverParticipant);
registry.registerDiagnosticsParticipant(diagnosticsParticipant);
registry.registerCodeActionParticipant(codeActionParticipant);
registry.registerDocumentLinkParticipant(documentLinkParticipant);
registry.registerTypeDefinitionParticipant(typeDefinitionParticipant);
}
@Test
public void cachePathSettings() {
// Emulate InitializeParams#getInitializationOptions() object created as
// JSONObject when XMLLanguageServer#initialize(InitializeParams params) is
// called
InitializeParams params = createInitializeParams(json);
Object initializationOptionsSettings = InitializationOptionsSettings.getSettings(params);
XMLLanguageServer languageServer = new XMLLanguageServer();
String originalUserHome = System.getProperty("user.home");
String userDir = System.getProperty("user.dir");
try {
System.setProperty("user.home", userDir + separator + targetTestFolder); // .../org.eclipse.lemminx/target/generated-test-sources/
languageServer.updateSettings(initializationOptionsSettings);
// Ensure the expanded absolute path is being used.
assertEquals(System.getProperty("user.home") + separator + testFolder + separator + "Nested",
FilesUtils.getCachePathSetting());
} catch (Exception e) {
fail();
} finally {
//Reset static cache path
FilesUtils.setCachePathSetting(null);
System.setProperty("user.home", originalUserHome);
}
}
@Test
public void extendedClientCapabilitiesTest() {
InitializeParams params = createInitializeParams(json);
ExtendedClientCapabilities clientCapabilities = InitializationOptionsExtendedClientCapabilities
.getExtendedClientCapabilities(params);
assertNotNull(clientCapabilities);
assertNotNull(clientCapabilities.getCodeLens());
assertNotNull(clientCapabilities.getCodeLens().getCodeLensKind());
assertNotNull(clientCapabilities.getCodeLens().getCodeLensKind().getValueSet());
assertEquals(1, clientCapabilities.getCodeLens().getCodeLensKind().getValueSet().size());
assertEquals(CodeLensKind.References,
clientCapabilities.getCodeLens().getCodeLensKind().getValueSet().get(0));
assertTrue(clientCapabilities.isActionableNotificationSupport());
assertTrue(clientCapabilities.isOpenSettingsCommandSupport());
}
private void initializeLanguageServer(InitializeParams params) throws ExecutionException, InterruptedException {
camelLanguageServer = new CamelLanguageServer();
camelLanguageServer.connect(new DummyLanguageClient());
camelLanguageServer.startServer();
CompletableFuture<InitializeResult> initialize = camelLanguageServer.initialize(params);
assertThat(initialize).isCompleted();
assertThat(initialize.get().getCapabilities().getCompletionProvider().getResolveProvider()).isTrue();
}
private InitializeParams getInitParams() throws URISyntaxException {
InitializeParams params = new InitializeParams();
params.setProcessId(new Random().nextInt());
params.setRootUri(getTestResource("/workspace/").toURI().toString());
params.setInitializationOptions(getInitializationOptions());
return params;
}
@Override
public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
// initialize rdflint
String rootPath = convertUri2FilePath(params.getRootUri());
String configPath = ConfigurationLoader.searchConfigPath(rootPath);
try {
rdflintParams = ConfigurationLoader.loadConfig(configPath);
rdflintParams.setTargetDir(rootPath);
rdflintParams.setOutputDir(rootPath);
if (rdflintParams.getSuppressPath() == null) {
rdflintParams.setSuppressPath(ConfigurationLoader.searchSuppressPath(rootPath));
}
} catch (IOException ex) {
showException("Error cannot initialize rdflint", ex);
}
validators = new LinkedList<>();
validators.add(new TrimValidator());
validators.add(new UndefinedSubjectValidator());
validators.add(new ShaclValidator());
validators.forEach(v ->
v.setParameters(rdflintParams)
);
refreshFileTripleSet();
ServerCapabilities capabilities = new ServerCapabilities();
capabilities.setTextDocumentSync(TextDocumentSyncKind.Full);
InitializeResult result = new InitializeResult(capabilities);
return CompletableFuture.completedFuture(result);
}
@Test
public void diagnosticsOpen() throws Exception {
RdfLintLanguageServer lsp = new RdfLintLanguageServer();
InitializeParams initParams = new InitializeParams();
String rootPath = this.getClass().getClassLoader().getResource("testValidatorsImpl/").getPath();
String parentPath = rootPath + "TrimValidator/turtle_needtrim";
initParams.setRootUri(RdfLintLanguageServer.convertFilePath2Uri(parentPath));
lsp.initialize(initParams);
LanguageClient client = mock(LanguageClient.class);
lsp.connect(client);
DidOpenTextDocumentParams openParams = new DidOpenTextDocumentParams();
openParams.setTextDocument(new TextDocumentItem());
openParams.getTextDocument()
.setUri(RdfLintLanguageServer.convertFilePath2Uri(parentPath + "/needtrim.rdf"));
openParams.getTextDocument().setText("<rdf:RDF\n"
+ " xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"\n"
+ " xmlns:schema=\"http://schema.org/\"\n"
+ " >\n"
+ "\n"
+ " <rdf:Description rdf:about=\"something\">\n"
+ " <schema:familyName xml:lang=\"ja\">familyName </schema:familyName>\n"
+ " </rdf:Description>\n"
+ "\n"
+ "</rdf:RDF>");
lsp.didOpen(openParams);
verify(client, times(1)).publishDiagnostics(any());
}
@Test
public void diagnosticsChange() throws Exception {
RdfLintLanguageServer lsp = new RdfLintLanguageServer();
InitializeParams initParams = new InitializeParams();
String rootPath = this.getClass().getClassLoader().getResource("testValidatorsImpl/").getPath();
String parentPath = rootPath + "TrimValidator/turtle_needtrim";
initParams.setRootUri(RdfLintLanguageServer.convertFilePath2Uri(parentPath));
lsp.initialize(initParams);
LanguageClient client = mock(LanguageClient.class);
lsp.connect(client);
DidChangeTextDocumentParams changeParams = new DidChangeTextDocumentParams();
changeParams.setTextDocument(new VersionedTextDocumentIdentifier());
changeParams.getTextDocument()
.setUri(RdfLintLanguageServer.convertFilePath2Uri(parentPath + "/needtrim.rdf"));
List<TextDocumentContentChangeEvent> changeEvents = new LinkedList<>();
changeParams.setContentChanges(changeEvents);
changeEvents.add(new TextDocumentContentChangeEvent());
changeEvents.get(0).setText("<rdf:RDF\n"
+ " xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"\n"
+ " xmlns:schema=\"http://schema.org/\"\n"
+ " >\n"
+ "\n"
+ " <rdf:Description rdf:about=\"something\">\n"
+ " <schema:familyName xml:lang=\"ja\">familyName </schema:familyName>\n"
+ " </rdf:Description>\n"
+ "\n"
+ "</rdf:RDF>");
lsp.didChange(changeParams);
verify(client, times(1)).publishDiagnostics(any());
}
@Test
public void diagnosticsChangeParseError() throws Exception {
RdfLintLanguageServer lsp = new RdfLintLanguageServer();
InitializeParams initParams = new InitializeParams();
String rootPath = this.getClass().getClassLoader().getResource("testValidatorsImpl/").getPath();
String parentPath = rootPath + "TrimValidator/turtle_needtrim";
initParams.setRootUri(RdfLintLanguageServer.convertFilePath2Uri(parentPath));
lsp.initialize(initParams);
LanguageClient client = mock(LanguageClient.class);
lsp.connect(client);
DidChangeTextDocumentParams changeParams = new DidChangeTextDocumentParams();
changeParams.setTextDocument(new VersionedTextDocumentIdentifier());
changeParams.getTextDocument()
.setUri(RdfLintLanguageServer.convertFilePath2Uri(parentPath + "/needtrim.rdf"));
List<TextDocumentContentChangeEvent> changeEvents = new LinkedList<>();
changeParams.setContentChanges(changeEvents);
changeEvents.add(new TextDocumentContentChangeEvent());
changeEvents.get(0).setText("<rdf:RDF\n"
+ " xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"\n"
+ " xmlns:schema=\"http://schema.org/\"\n"
+ " >\n"
+ "\n"
+ " <rdf:Description rdf:about=\"something\">\n"
+ " <schema:familyName xml:lang=\"ja\">familyName</schema:familyN>\n"
+ " </rdf:Description>\n"
+ "\n"
+ "</rdf:RDF>");
lsp.didChange(changeParams);
verify(client, times(1)).publishDiagnostics(any());
}
/** Starts the compiler in a blocking fashion */
public N4jscExitState start() throws Exception {
InitializeParams params = new InitializeParams();
File baseDir = options.getDir();
if (baseDir == null) {
throw new N4jscException(N4jscExitCode.ARGUMENT_DIRS_INVALID, "No base directory");
}
params.setRootUri(baseDir.toURI().toString());
languageServer.initialize(params).get();
warnIfNoProjectsFound();
verbosePrintAllProjects();
switch (options.getGoal()) {
case clean:
performClean();
break;
case compile:
performCompile();
break;
default:
break;
}
languageServer.shutdown();
languageServer.exit();
writeTestCatalog();
return determineExitState();
}
@Deprecated
private URI deprecatedToBaseDir(InitializeParams params) {
String rootPath = params.getRootPath();
if (rootPath != null) {
return uriExtensions.toUri(uriExtensions.toUriString(URI.createFileURI(rootPath)));
}
return null;
}
/**
* Compute the base dir.
*/
protected URI getBaseDir(InitializeParams params) {
String rootUri = params.getRootUri();
if (rootUri != null) {
return uriExtensions.toUri(rootUri);
}
return deprecatedToBaseDir(params);
}
private static InitializeResult initServer(Process p, LanguageServer server, FileObject root) throws InterruptedException, ExecutionException {
InitializeParams initParams = new InitializeParams();
initParams.setRootUri(Utils.toURI(root));
initParams.setRootPath(FileUtil.toFile(root).getAbsolutePath()); //some servers still expect root path
initParams.setProcessId(0);
TextDocumentClientCapabilities tdcc = new TextDocumentClientCapabilities();
DocumentSymbolCapabilities dsc = new DocumentSymbolCapabilities();
dsc.setHierarchicalDocumentSymbolSupport(true);
dsc.setSymbolKind(new SymbolKindCapabilities(Arrays.asList(SymbolKind.values())));
tdcc.setDocumentSymbol(dsc);
WorkspaceClientCapabilities wcc = new WorkspaceClientCapabilities();
wcc.setWorkspaceEdit(new WorkspaceEditCapabilities());
wcc.getWorkspaceEdit().setDocumentChanges(true);
wcc.getWorkspaceEdit().setResourceOperations(Arrays.asList(ResourceOperationKind.Create, ResourceOperationKind.Delete, ResourceOperationKind.Rename));
initParams.setCapabilities(new ClientCapabilities(wcc, tdcc, null));
CompletableFuture<InitializeResult> initResult = server.initialize(initParams);
while (true) {
try {
return initResult.get(100, TimeUnit.MILLISECONDS);
} catch (TimeoutException ex) {
if (p != null && !p.isAlive()) {
InitializeResult emptyResult = new InitializeResult();
emptyResult.setCapabilities(new ServerCapabilities());
return emptyResult;
}
}
}
}