Java 类org.eclipse.lsp4j.InitializeResult 实例源码

@Override
public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
    sendLogMessageNotification(MessageType.Info, "Initializing capabilities of the server...");
    Integer processId = params.getProcessId();
    if(processId != null) {
        setParentProcessId(processId.longValue());
    } else {
        sendLogMessageNotification(MessageType.Info, "Missing Parent process ID!!");
        setParentProcessId(0);
    }

    InitializeResult result = new InitializeResult();

    ServerCapabilities capabilities = new ServerCapabilities();
    capabilities.setTextDocumentSync(TextDocumentSyncKind.Full);
    capabilities.setCompletionProvider(new CompletionOptions(Boolean.TRUE, Arrays.asList(".","?","&", "\"", "=")));
    capabilities.setHoverProvider(Boolean.TRUE);

    result.setCapabilities(capabilities);
    return CompletableFuture.completedFuture(result);
}

protected CamelLanguageServer initializeLanguageServer(String text)
throws URISyntaxException, InterruptedException, ExecutionException {
    InitializeParams params = new InitializeParams();
    params.setProcessId(new Random().nextInt());
    params.setRootUri(getTestResource("/workspace/").toURI().toString());
    CamelLanguageServer camelLanguageServer = new CamelLanguageServer();
    camelLanguageServer.connect(new DummyLanguageClient());
    CompletableFuture<InitializeResult> initialize = camelLanguageServer.initialize(params);

    assertThat(initialize).isCompleted();
    assertThat(initialize.get().getCapabilities().getCompletionProvider().getResolveProvider()).isTrue();

    camelLanguageServer.getTextDocumentService().didOpen(new DidOpenTextDocumentParams(createTestTextDocument(text)));

    return camelLanguageServer;
}

@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);
    InitializeResult result = initialize(true);
    assertNull(result.getCapabilities().getDocumentSymbolProvider());
    DidChangeConfigurationParams params = new DidChangeConfigurationParams();
    server.didChangeConfiguration(params);
    verify(client, times(7)).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();
}

protected InitializeResult initialize() {
  return this.initialize(null);
}

protected InitializeResult initialize(final Procedure1<? super InitializeParams> initializer) {
  try {
    InitializeParams _initializeParams = new InitializeParams();
    final Procedure1<InitializeParams> _function = (InitializeParams it) -> {
      it.setProcessId(Integer.valueOf(1));
      it.setRootUri(this._uriExtensions.toUriString(this.root.toURI().normalize()));
    };
    final InitializeParams params = ObjectExtensions.<InitializeParams>operator_doubleArrow(_initializeParams, _function);
    if (initializer!=null) {
      initializer.apply(params);
    }
    return this.languageServer.initialize(params).get();
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}

@Test
public void testName() throws Exception {
  CompletableFuture<MessageActionItem> future = new CompletableFuture<>();
  when(transmitter.sendShowMessageRequest(any())).thenReturn(future);

  ServerInitializerImpl initializer = new ServerInitializerImpl();
  CheLanguageClient client = new CheLanguageClient(eventService, transmitter, "id");
  CompletableFuture<Pair<LanguageServer, InitializeResult>> initialize =
      initializer.initialize(launcher, client, "/tmp");
  Pair<LanguageServer, InitializeResult> resultPair = initialize.get();
  server = resultPair.first;
  ArgumentCaptor<ShowMessageRequestParams> captor =
      ArgumentCaptor.forClass(ShowMessageRequestParams.class);
  verify(transmitter, timeout(1500)).sendShowMessageRequest(captor.capture());

  ShowMessageRequestParams value = captor.getValue();
  assertNotNull(value);
  assertEquals(value.getType(), MessageType.Error);
  assertEquals(value.getMessage(), "Error Message!!!!");
}

@Test
public void initializerShouldNotifyObservers() throws Exception {
  when(languageDescription.getLanguageId()).thenReturn("languageId");
  when(server.initialize(any(InitializeParams.class))).thenReturn(completableFuture);

  when(launcher.launch(anyString(), any())).thenReturn(server);
  when(launcher.getDescription()).thenReturn(serverDescription);
  when(serverDescription.getId()).thenReturn("launcherId");
  doNothing().when(initializer).registerCallbacks(any(), any());

  initializer.addObserver(observer);
  Pair<LanguageServer, InitializeResult> initResult =
      initializer.initialize(launcher, null, "/path").get();

  assertEquals(server, initResult.first);
  verify(observer, timeout(2000))
      .onServerInitialized(eq(launcher), eq(server), any(ServerCapabilities.class), eq("/path"));
}

@Override
public CompletableFuture<InitializeResult> initialize(final InitializeParams params) {
  InitializeResult result = new InitializeResult();
  ServerCapabilities cap = new ServerCapabilities();

  cap.setTextDocumentSync(TextDocumentSyncKind.Full);
  cap.setDocumentSymbolProvider(true);
  cap.setWorkspaceSymbolProvider(true);
  cap.setDefinitionProvider(true);
  cap.setCodeLensProvider(new CodeLensOptions(true));
  cap.setExecuteCommandProvider(
      new ExecuteCommandOptions(Lists.newArrayList(SomMinitest.COMMAND)));

  CompletionOptions completion = new CompletionOptions();
  List<String> autoComplTrigger = new ArrayList<>();
  autoComplTrigger.add("#"); // Smalltalk symbols
  autoComplTrigger.add(":"); // end of keywords, to complete arguments
  autoComplTrigger.add("="); // right-hand side of assignments
  completion.setTriggerCharacters(autoComplTrigger);
  completion.setResolveProvider(false); // TODO: look into that

  cap.setCompletionProvider(completion);
  result.setCapabilities(cap);

  loadWorkspace(params);

  return CompletableFuture.completedFuture(result);
}

@Test
public void testExecuteCommandProvider() throws Exception {
    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());
}

public InitializedLanguageServer(
    String id,
    LanguageServer server,
    InitializeResult initializeResult,
    LanguageServerLauncher launcher) {
  this.id = id;
  this.server = server;
  this.initializeResult = initializeResult;
  this.launcher = launcher;
}

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

@Override
public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
    throw new UnsupportedOperationException();
}

@Override
public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
    throw new UnsupportedOperationException();
}

public InitializeResult getInitializeResult() {
  return initializeResult;
}

@BeforeMethod
public void setUp() throws Exception {

  this.serverCapabilities = new ServerCapabilities();
  serverDescription =
      new LanguageServerDescription(
          "foo", Collections.singletonList("id"), Collections.emptyList());
  initializeResult = new InitializeResult(serverCapabilities);

  completableFuture = completedFuture(initializeResult);

  when(languageServerLauncher.isAbleToLaunch()).thenReturn(true);
  when(languageServerLauncher.getDescription()).thenReturn(serverDescription);
  when(languageServerLauncher.isLocal()).thenReturn(true);
  when(languageDescription.getLanguageId()).thenReturn("id");
  when(languageDescription.getFileExtensions()).thenReturn(Collections.singletonList("txt"));
  when(languageDescription.getMimeType()).thenReturn("plain/text");

  when(languageServer.getTextDocumentService()).thenReturn(mock(TextDocumentService.class));
  when(languageServer.initialize(any(InitializeParams.class))).thenReturn(completableFuture);

  when(languageRecognizer.recognizeByPath(anyString())).thenReturn(languageDescription);
  when(languageRecognizer.recognizeById(anyString())).thenReturn(languageDescription);

  when(pmp.get()).thenReturn(pm);

  when(clientFactory.create(anyString())).thenReturn(languageClient);

  when(httpJsonRequestFactory.fromUrl(any(String.class))).thenReturn(httpJsonRequest);
  when(httpJsonRequest.useGetMethod()).thenReturn(httpJsonRequest);
  when(httpJsonRequest.request()).thenReturn(httpJsonResponse);
  when(httpJsonResponse.asDto(any())).thenReturn(workspace);

  registry =
      spy(
          new LanguageServerRegistryImpl(
              "",
              "",
              httpJsonRequestFactory,
              new HashSet<>(),
              Collections.singleton(languageServerLauncher),
              Collections.singleton(languageDescription),
              pmp,
              initializer,
              null,
              clientFactory,
              languageRecognizer) {
            @Override
            protected String extractProjectPath(String filePath) throws LanguageServerException {
              return PROJECT_PATH;
            }
          });

  when(initializer.initialize(
          any(LanguageServerLauncher.class), any(LanguageClient.class), anyString()))
      .thenAnswer(invocation -> completedFuture(Pair.of(languageServer, initializeResult)));
}

@BeforeMethod
public void setUp() throws Exception {
  initializer = spy(new ServerInitializerImpl());
  completableFuture =
      CompletableFuture.completedFuture(new InitializeResult(new ServerCapabilities()));
}

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

/**
 * The initialize request is sent as the first request from the client to
 * the server.
 * 
 * If the server receives request or notification before the initialize request it should act as follows:
 *  - for a request the respond should be errored with code: -32001. The message can be picked by the server.
 *  - notifications should be dropped, except for the exit notification. This will allow the exit a server without an initialize request.
 *  
 * Until the server has responded to the initialize request with an InitializeResult 
 * the client must not sent any additional requests or notifications to the server.
 * 
 * During the initialize request the server is allowed to sent the notifications window/showMessage, 
 * window/logMessage and telemetry/event as well as the window/showMessageRequest request to the client.
 */
@JsonRequest
CompletableFuture<InitializeResult> initialize(InitializeParams params);

@Test
public void testInit() {
  RequestMessage _requestMessage = new RequestMessage();
  final Procedure1<RequestMessage> _function = (RequestMessage it) -> {
    it.setJsonrpc("2.0");
    it.setId("1");
    it.setMethod(MessageMethods.DOC_COMPLETION);
    InitializeResult _initializeResult = new InitializeResult();
    final Procedure1<InitializeResult> _function_1 = (InitializeResult it_1) -> {
      ServerCapabilities _serverCapabilities = new ServerCapabilities();
      it_1.setCapabilities(_serverCapabilities);
    };
    InitializeResult _doubleArrow = ObjectExtensions.<InitializeResult>operator_doubleArrow(_initializeResult, _function_1);
    it.setParams(_doubleArrow);
  };
  final RequestMessage message = ObjectExtensions.<RequestMessage>operator_doubleArrow(_requestMessage, _function);
  StringConcatenation _builder = new StringConcatenation();
  _builder.append("{");
  _builder.newLine();
  _builder.append("  ");
  _builder.append("\"jsonrpc\": \"2.0\",");
  _builder.newLine();
  _builder.append("  ");
  _builder.append("\"id\": \"1\",");
  _builder.newLine();
  _builder.append("  ");
  _builder.append("\"method\": \"textDocument/completion\",");
  _builder.newLine();
  _builder.append("  ");
  _builder.append("\"params\": {");
  _builder.newLine();
  _builder.append("    ");
  _builder.append("\"capabilities\": {}");
  _builder.newLine();
  _builder.append("  ");
  _builder.append("}");
  _builder.newLine();
  _builder.append("}");
  _builder.newLine();
  this.assertSerialize(message, _builder);
}

/**
 * The initialize request is sent as the first request from the client to
 * the server.
 * 
 * If the server receives request or notification before the initialize request it should act as follows:
 *  - for a request the respond should be errored with code: -32001. The message can be picked by the server.
 *  - notifications should be dropped, except for the exit notification. This will allow the exit a server without an initialize request.
 *  
 * Until the server has responded to the initialize request with an InitializeResult 
 * the client must not sent any additional requests or notifications to the server.
 * 
 * During the initialize request the server is allowed to sent the notifications window/showMessage, 
 * window/logMessage and telemetry/event as well as the window/showMessageRequest request to the client.
 */
@JsonRequest
CompletableFuture<InitializeResult> initialize(InitializeParams params);

/**
 * Initialize new {@link LanguageServer} with given project path.
 *
 * @return
 */
CompletableFuture<Pair<LanguageServer, InitializeResult>> initialize(
    LanguageServerLauncher launcher, LanguageClient client, String projectPath)
    throws LanguageServerException;