org.eclipse.lsp4j.MessageActionItem#org.eclipse.lsp4j.InitializeResult源码实例Demo

@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 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);
}
 

@Override
public void handleMessage(Message message, LanguageServer languageServer, URI rootUri) {
	if (message instanceof ResponseMessage) {
		ResponseMessage responseMessage = (ResponseMessage) message;
		if (responseMessage.getResult() instanceof InitializeResult) {
			Map<String, Object> htmlOptions = new HashMap<>();

			Map<String, Object> validateOptions = new HashMap<>();
			validateOptions.put("scripts", true);
			validateOptions.put("styles", true);
			htmlOptions.put("validate", validateOptions);

			htmlOptions.put("format", Collections.singletonMap("enable", Boolean.TRUE));

			Map<String, Object> html = new HashMap<>();
			html.put("html", htmlOptions);

			DidChangeConfigurationParams params = new DidChangeConfigurationParams(html);
			languageServer.getWorkspaceService().didChangeConfiguration(params);
		}
	}
}
 

@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 testStaticCommandWithDynamicRegistration() throws Exception {
	when(commandHandler.getAllCommands()).thenReturn(new HashSet<>(Arrays.asList("cmd1", "cmd2", "cmd3", "cmd4")));
	when(commandHandler.getStaticCommands()).thenReturn(new HashSet<>(Arrays.asList("cmd1", "cmd2")));
	when(commandHandler.getNonStaticCommands()).thenReturn(new HashSet<>(Arrays.asList("cmd3", "cmd4")));

	ClientPreferences mockCapabilies = mock(ClientPreferences.class);
	when(mockCapabilies.isExecuteCommandDynamicRegistrationSupported()).thenReturn(Boolean.TRUE);
	when(preferenceManager.getClientPreferences()).thenReturn(mockCapabilies);

	InitializeResult result = initialize(true);

	ExecuteCommandOptions commandProvider = result.getCapabilities().getExecuteCommandProvider();
	assertNotNull(commandProvider);
	assertTrue(commandProvider.getCommands().contains("cmd1"));
	assertTrue(commandProvider.getCommands().contains("cmd2"));
	assertFalse(commandProvider.getCommands().contains("cmd3"));
	assertFalse(commandProvider.getCommands().contains("cmd4"));
}
 

@Test
public void testStaticCommandWithoutDynamicRegistration() throws Exception {
	when(commandHandler.getAllCommands()).thenReturn(new HashSet<>(Arrays.asList("cmd1", "cmd2", "cmd3", "cmd4")));
	when(commandHandler.getStaticCommands()).thenReturn(new HashSet<>(Arrays.asList("cmd1", "cmd2")));
	when(commandHandler.getNonStaticCommands()).thenReturn(new HashSet<>(Arrays.asList("cmd3", "cmd4")));

	ClientPreferences mockCapabilies = mock(ClientPreferences.class);
	when(mockCapabilies.isExecuteCommandDynamicRegistrationSupported()).thenReturn(Boolean.FALSE);
	when(preferenceManager.getClientPreferences()).thenReturn(mockCapabilies);

	InitializeResult result = initialize(true);

	ExecuteCommandOptions commandProvider = result.getCapabilities().getExecuteCommandProvider();
	assertNotNull(commandProvider);
	assertTrue(commandProvider.getCommands().containsAll(Arrays.asList("cmd1", "cmd2", "cmd3", "cmd4")));
}
 

@Test
public void testRegisterDelayedCapability() throws Exception {
	ClientPreferences mockCapabilies = mock(ClientPreferences.class);
	when(preferenceManager.getClientPreferences()).thenReturn(mockCapabilies);
	when(mockCapabilies.isDocumentSymbolDynamicRegistered()).thenReturn(Boolean.TRUE);
	when(mockCapabilies.isWorkspaceSymbolDynamicRegistered()).thenReturn(Boolean.TRUE);
	when(mockCapabilies.isDocumentSymbolDynamicRegistered()).thenReturn(Boolean.TRUE);
	when(mockCapabilies.isCodeActionDynamicRegistered()).thenReturn(Boolean.TRUE);
	when(mockCapabilies.isDefinitionDynamicRegistered()).thenReturn(Boolean.TRUE);
	when(mockCapabilies.isHoverDynamicRegistered()).thenReturn(Boolean.TRUE);
	when(mockCapabilies.isReferencesDynamicRegistered()).thenReturn(Boolean.TRUE);
	when(mockCapabilies.isDocumentHighlightDynamicRegistered()).thenReturn(Boolean.TRUE);
	when(mockCapabilies.isFoldgingRangeDynamicRegistered()).thenReturn(Boolean.TRUE);
	when(mockCapabilies.isCompletionDynamicRegistered()).thenReturn(Boolean.TRUE);
	InitializeResult result = initialize(true);
	assertNull(result.getCapabilities().getDocumentSymbolProvider());
	server.initialized(new InitializedParams());
	verify(client, times(9)).registerCapability(any());
}
 

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 boolean shouldPrepareRename(ILanguageServerAccess access) {
	Either<Boolean, RenameOptions> provider = null;
	if (access != null) {
		InitializeResult initializeResult = access.getInitializeResult();
		if (initializeResult != null) {
			ServerCapabilities capabilities = initializeResult.getCapabilities();
			if (capabilities != null) {
				provider = capabilities.getRenameProvider();
			}
		}
	}
	if (provider != null && provider.isRight()) {
		return Boolean.TRUE.equals(provider.getRight().getPrepareProvider());
	} else {
		return false;
	}
}
 

private void handleMessage(Message message) {
    if (message instanceof ResponseMessage) {
        ResponseMessage responseMessage = (ResponseMessage) message;
        if (responseMessage.getResult() instanceof InitializeResult) {
            listener.initialize(languageServer, (InitializeResult) responseMessage.getResult());
        }
    }
}
 

@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);
}
 

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();
}
 

@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);
}
 

@Override
public void handleMessage(Message message, LanguageServer languageServer, URI rootUri) {
	if (message instanceof ResponseMessage) {
		ResponseMessage responseMessage = (ResponseMessage)message;
		if (responseMessage.getResult() instanceof InitializeResult) {
			// enable validation: so far, no better way found than changing conf after init.
			DidChangeConfigurationParams params = new DidChangeConfigurationParams(getInitializationOptions(rootUri));
			languageServer.getWorkspaceService().didChangeConfiguration(params);
		}
	}
}
 

@Override
public void handleMessage(Message message, LanguageServer languageServer, URI rootUri) {
	if (message instanceof ResponseMessage) {
		ResponseMessage responseMessage = (ResponseMessage) message;
		if (responseMessage.getResult() instanceof InitializeResult) {
			// Send json/schemaAssociations notification to register JSON Schema on JSON
			// Language server side.
			JSonLanguageServerInterface server = (JSonLanguageServerInterface) languageServer;
			Map<String, List<String>> schemaAssociations = getSchemaAssociations();
			server.sendJSonchemaAssociations(schemaAssociations);
		}
	}
}
 

private boolean isTriggerCharacter(LSPBindings server, String text) {
    InitializeResult init = server.getInitResult();
    if (init == null) return false;
    ServerCapabilities capabilities = init.getCapabilities();
    if (capabilities == null) return false;
    CompletionOptions completionOptions = capabilities.getCompletionProvider();
    if (completionOptions == null) return false;
    List<String> triggerCharacters = completionOptions.getTriggerCharacters();
    if (triggerCharacters == null) return false;
    return triggerCharacters.stream().anyMatch(trigger -> text.endsWith(trigger));
}
 

@Messages("LBL_Connecting=Connecting to language server")
public static void addBindings(FileObject root, int port, String... extensions) {
    BaseProgressUtils.showProgressDialogAndRun(() -> {
        try {
            Socket s = new Socket(InetAddress.getLocalHost(), port);
            LanguageClientImpl lc = new LanguageClientImpl();
            InputStream in = s.getInputStream();
            OutputStream out = s.getOutputStream();
            Launcher<LanguageServer> launcher = LSPLauncher.createClientLauncher(lc, in, new OutputStream() {
                @Override
                public void write(int w) throws IOException {
                    out.write(w);
                    if (w == '\n')
                        out.flush();
                }
            });
            launcher.startListening();
            LanguageServer server = launcher.getRemoteProxy();
            InitializeResult result = initServer(null, server, root);
            LSPBindings bindings = new LSPBindings(server, result, null);

            lc.setBindings(bindings);

            workspace2Extension2Server.put(root, Arrays.stream(extensions).collect(Collectors.toMap(k -> k, v -> bindings)));
        } catch (InterruptedException | ExecutionException | IOException ex) {
            Exceptions.printStackTrace(ex);
        }
    }, Bundle.LBL_Connecting());
}
 

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;
           }
       }
   }
}
 

@SuppressWarnings("unchecked")
public InitializeResult initialize(InitializeParams param) {
	logInfo("Initializing Java Language Server " + JavaLanguageServerPlugin.getVersion());
	InitializeResult result = new InitializeResult();
	handleInitializationOptions(param);
	registerCapabilities(result);

	// At the end of the InitHandler, trigger a job to import the workspace. This is used to ensure ServiceStatus notification
	// is not sent before the initialize response. See the bug https://github.com/redhat-developer/vscode-java/issues/1056
	triggerInitialization(preferenceManager.getPreferences().getRootPaths());
	return result;
}
 

@Override
public void registerCapabilities(InitializeResult initializeResult) {
	ServerCapabilities capabilities = new ServerCapabilities();
	if (!preferenceManager.getClientPreferences().isClientDocumentSymbolProviderRegistered() && !preferenceManager.getClientPreferences().isDocumentSymbolDynamicRegistered()) {
		capabilities.setDocumentSymbolProvider(Boolean.TRUE);
	}
	if (!preferenceManager.getClientPreferences().isDefinitionDynamicRegistered()) {
		capabilities.setDefinitionProvider(Boolean.TRUE);
	}
	if (!preferenceManager.getClientPreferences().isTypeDefinitionDynamicRegistered()) {
		capabilities.setTypeDefinitionProvider(Boolean.TRUE);
	}
	if (!preferenceManager.getClientPreferences().isFoldgingRangeDynamicRegistered()) {
		capabilities.setFoldingRangeProvider(Boolean.TRUE);
	}
	if (!preferenceManager.getClientPreferences().isSelectionRangeDynamicRegistered()) {
		capabilities.setSelectionRangeProvider(Boolean.TRUE);
	}
	if (!preferenceManager.getClientPreferences().isHoverDynamicRegistered()) {
		capabilities.setHoverProvider(Boolean.TRUE);
	}
	if (!preferenceManager.getClientPreferences().isCompletionDynamicRegistered()) {
		capabilities.setCompletionProvider(CompletionHandler.DEFAULT_COMPLETION_OPTIONS);
	}
	TextDocumentSyncOptions textDocumentSyncOptions = new TextDocumentSyncOptions();
	textDocumentSyncOptions.setOpenClose(Boolean.TRUE);
	textDocumentSyncOptions.setSave(new SaveOptions(Boolean.TRUE));
	textDocumentSyncOptions.setChange(TextDocumentSyncKind.Incremental);
	capabilities.setTextDocumentSync(textDocumentSyncOptions);

	WorkspaceServerCapabilities wsCapabilities = new WorkspaceServerCapabilities();
	WorkspaceFoldersOptions wsFoldersOptions = new WorkspaceFoldersOptions();
	wsFoldersOptions.setSupported(Boolean.TRUE);
	wsFoldersOptions.setChangeNotifications(Boolean.TRUE);
	wsCapabilities.setWorkspaceFolders(wsFoldersOptions);
	capabilities.setWorkspace(wsCapabilities);

	initializeResult.setCapabilities(capabilities);
}
 

@Test
public void testExecuteCommandProvider() throws Exception {
	when(commandHandler.getNonStaticCommands()).thenReturn(new HashSet<>(Arrays.asList("cmd3", "cmd4")));
	when(commandHandler.getAllCommands()).thenReturn(new HashSet<>(Arrays.asList("cmd3", "cmd4")));

	ClientPreferences mockCapabilies = mock(ClientPreferences.class);
	when(mockCapabilies.isExecuteCommandDynamicRegistrationSupported()).thenReturn(Boolean.FALSE);
	when(preferenceManager.getClientPreferences()).thenReturn(mockCapabilies);
	InitializeResult result = initialize(false);
	List<String> commands = result.getCapabilities().getExecuteCommandProvider().getCommands();
	assertFalse(commands.isEmpty());
}
 

@Test
public void testExecuteCommandProviderDynamicRegistration() throws Exception {
	ClientPreferences mockCapabilies = mock(ClientPreferences.class);
	when(mockCapabilies.isExecuteCommandDynamicRegistrationSupported()).thenReturn(Boolean.TRUE);
	when(preferenceManager.getClientPreferences()).thenReturn(mockCapabilies);
	InitializeResult result = initialize(true);
	assertNull(result.getCapabilities().getExecuteCommandProvider());
}
 

@Test
public void testWillSaveAndWillSaveWaitUntilCapabilities() throws Exception {
	ClientPreferences mockCapabilies = mock(ClientPreferences.class);
	when(mockCapabilies.isExecuteCommandDynamicRegistrationSupported()).thenReturn(Boolean.TRUE);
	when(preferenceManager.getClientPreferences()).thenReturn(mockCapabilies);
	when(mockCapabilies.isWillSaveRegistered()).thenReturn(Boolean.TRUE);
	when(mockCapabilies.isWillSaveWaitUntilRegistered()).thenReturn(Boolean.TRUE);
	InitializeResult result = initialize(true);
	Either<TextDocumentSyncKind, TextDocumentSyncOptions> o = result.getCapabilities().getTextDocumentSync();
	assertTrue(o.isRight());
	assertTrue(o.getRight().getWillSave());
	assertTrue(o.getRight().getWillSaveWaitUntil());
}
 

@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\'");
	}
	initializeParams = params;

	InitializeResult result = new InitializeResult();

	result.setCapabilities(createServerCapabilities(params));
	access.addBuildListener(this);
	return requestManager.runWrite(() -> {
		if (workspaceManager.isSupportsWorkspaceFolders()) {
			List<WorkspaceFolder> workspaceFolders = params.getWorkspaceFolders();
			if (workspaceFolders == null)
				workspaceFolders = Collections.emptyList();
			workspaceManager.initialize(workspaceFolders, this::publishDiagnostics, CancelIndicator.NullImpl);
		} else {
			workspaceManager.initialize(baseDir, this::publishDiagnostics, CancelIndicator.NullImpl);
		}
		return result;
	}, (cancelIndicator, it) -> it).thenApply(it -> initializeResult = it);
}
 

default void initialize(@NotNull LanguageServer server, @NotNull InitializeResult result) {
}
 

@Override
public InitializeResult getInitializeResult() {
	return initializeResult;
}
 

private LSPBindings(LanguageServer server, InitializeResult initResult, Process process) {
    this.server = server;
    this.initResult = initResult;
    this.process = process;
}
 

public InitializeResult getInitResult() {
    //XXX: defenzive copy?
    return initResult;
}
 

@Override
public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
    ServerCapabilities capabilities = createServerCapabilities();
    return CompletableFuture.completedFuture(new InitializeResult(capabilities));
}
 

@Override
public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
	logInfo(">> initialize");
	InitHandler handler = new InitHandler(pm, preferenceManager, client, commandHandler);
	return CompletableFuture.completedFuture(handler.initialize(params));
}