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

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

@Inject
public LanguageServerInitializationHandler(
    RequestHandlerConfigurator requestHandlerConfigurator, LanguageServerRegistry registry) {
  requestHandlerConfigurator
      .newConfiguration()
      .methodName("languageServer/initialize")
      .paramsAsString()
      .resultAsDto(ServerCapabilitiesDto.class)
      .withFunction(
          path -> {
            try {
              ServerCapabilities capabilities =
                  registry.initialize(LanguageServiceUtils.prefixURI(path));
              return capabilities == null ? null : new ServerCapabilitiesDto(capabilities);
            } catch (LanguageServerException e) {
              throw new JsonRpcException(-27000, e.getMessage());
            }
          });
}

private void onServerInitialized(
    LanguageServerLauncher launcher,
    LanguageServer server,
    ServerCapabilities capabilities,
    String projectPath) {
  LanguageServerDescription description = launcher.getDescription();
  FileSystem fileSystem = FileSystems.getDefault();
  for (String pattern : description.getFileWatchPatterns()) {
    PathMatcher matcher = fileSystem.getPathMatcher(pattern);
    int watcherId =
        watcherManager.registerByMatcher(
            matcher,
            s -> send(server, s, FileChangeType.Created),
            s -> send(server, s, FileChangeType.Changed),
            s -> send(server, s, FileChangeType.Deleted));

    watcherIds.add(watcherId);
  }
}

public ServerCapabilities compute() {

    ServerCapabilities result = new ServerCapabilities();
    result.setCodeActionProvider(or(ServerCapabilities::getCodeActionProvider));
    result.setCodeLensProvider(getCodeLensProvider());
    result.setCompletionProvider(getCompletionProvider());
    result.setDefinitionProvider(or(ServerCapabilities::getDefinitionProvider));
    result.setDocumentFormattingProvider(or(ServerCapabilities::getDocumentFormattingProvider));
    result.setDocumentHighlightProvider(or(ServerCapabilities::getDocumentHighlightProvider));
    result.setDocumentOnTypeFormattingProvider(getDocumentOnTypeFormattingProvider());
    result.setDocumentRangeFormattingProvider(
        or(ServerCapabilities::getDocumentRangeFormattingProvider));
    result.setDocumentSymbolProvider(or(ServerCapabilities::getDocumentSymbolProvider));
    result.setHoverProvider(or(ServerCapabilities::getHoverProvider));
    result.setReferencesProvider(or(ServerCapabilities::getReferencesProvider));
    result.setRenameProvider(or(ServerCapabilities::getRenameProvider));
    result.setSignatureHelpProvider(getSignatureHelpProvider());
    result.setTextDocumentSync(getTextDocumentSync());
    result.setWorkspaceSymbolProvider(or(ServerCapabilities::getWorkspaceSymbolProvider));

    return result;
  }

@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 void updateInPerspective(@NotNull ActionEvent event) {
  EditorPartPresenter activeEditor = editorAgent.getActiveEditor();
  if (Objects.nonNull(activeEditor) && activeEditor instanceof TextEditor) {
    TextEditorConfiguration configuration = ((TextEditor) activeEditor).getConfiguration();
    if (configuration instanceof LanguageServerEditorConfiguration) {
      ServerCapabilities capabilities =
          ((LanguageServerEditorConfiguration) configuration).getServerCapabilities();
      event
          .getPresentation()
          .setEnabledAndVisible(
              capabilities.getDocumentSymbolProvider() != null
                  && capabilities.getDocumentSymbolProvider());
      return;
    }
  }
  event.getPresentation().setEnabledAndVisible(false);
}

@Override
public void updateInPerspective(@NotNull ActionEvent event) {
  EditorPartPresenter activeEditor = editorAgent.getActiveEditor();
  if (activeEditor instanceof TextEditor) {
    TextEditorConfiguration configuration = ((TextEditor) activeEditor).getConfiguration();
    if (configuration instanceof LanguageServerEditorConfiguration) {
      ServerCapabilities capabilities =
          ((LanguageServerEditorConfiguration) configuration).getServerCapabilities();
      event
          .getPresentation()
          .setEnabledAndVisible(
              capabilities.getReferencesProvider() != null
                  && capabilities.getReferencesProvider());
      return;
    }
  }
  event.getPresentation().setEnabledAndVisible(false);
}

@Override
public void updateInPerspective(@NotNull ActionEvent event) {
  EditorPartPresenter activeEditor = editorAgent.getActiveEditor();
  if (Objects.nonNull(activeEditor) && activeEditor instanceof TextEditor) {
    TextEditorConfiguration configuration = ((TextEditor) activeEditor).getConfiguration();
    if (configuration instanceof LanguageServerEditorConfiguration) {
      ServerCapabilities capabilities =
          ((LanguageServerEditorConfiguration) configuration).getServerCapabilities();
      event
          .getPresentation()
          .setEnabledAndVisible(
              capabilities.getWorkspaceSymbolProvider() != null
                  && capabilities.getWorkspaceSymbolProvider());
      return;
    }
  }
  event.getPresentation().setEnabledAndVisible(false);
}

@Override
public void updateInPerspective(@NotNull ActionEvent event) {
  EditorPartPresenter activeEditor = editorAgent.getActiveEditor();
  if (activeEditor instanceof TextEditor) {
    TextEditorConfiguration configuration = ((TextEditor) activeEditor).getConfiguration();
    if (configuration instanceof LanguageServerEditorConfiguration) {
      ServerCapabilities capabilities =
          ((LanguageServerEditorConfiguration) configuration).getServerCapabilities();
      event
          .getPresentation()
          .setEnabledAndVisible(
              capabilities.getDefinitionProvider() != null
                  && capabilities.getDefinitionProvider());
      return;
    }
  }
  event.getPresentation().setEnabledAndVisible(false);
}

@Override
public void updateInPerspective(ActionEvent event) {
  EditorPartPresenter activeEditor = editorAgent.getActiveEditor();
  Presentation presentation = event.getPresentation();
  if (activeEditor != workspaceAgent.getActivePart()) {
    presentation.setEnabledAndVisible(false);
    return;
  }
  if (Objects.nonNull(activeEditor) && activeEditor instanceof TextEditor) {
    TextEditorConfiguration configuration = ((TextEditor) activeEditor).getConfiguration();
    if (configuration instanceof LanguageServerEditorConfiguration) {
      ServerCapabilities capabilities =
          ((LanguageServerEditorConfiguration) configuration).getServerCapabilities();
      presentation.setEnabledAndVisible(
          capabilities.getRenameProvider() != null && capabilities.getRenameProvider());
      return;
    }
  }
  presentation.setEnabledAndVisible(false);
}

public Promise<ServerCapabilities> getOrInitializeServer(String projectPath, VirtualFile file) {
  // call initialize service
  final MessageLoader loader =
      loaderFactory.newLoader("Initializing Language Server for " + file.getName());
  loader.show();
  return jsonRpcClient
      .initializeServer(file.getLocation().toString())
      .then(
          (ServerCapabilities arg) -> {
            loader.hide();
            return arg;
          })
      .catchError(
          arg -> {
            notificationManager.notify(
                "Initializing Language Server for " + file.getName(),
                arg.getMessage(),
                FAIL,
                EMERGE_MODE);
            loader.hide();
            return null;
          });
}

@Inject
public LanguageServerCodeAssistProcessor(
    TextDocumentServiceClient documentServiceClient,
    DtoBuildHelper dtoBuildHelper,
    LanguageServerResources resources,
    CompletionImageProvider imageProvider,
    @Assisted ServerCapabilities serverCapabilities,
    FuzzyMatches fuzzyMatches) {
  this.documentServiceClient = documentServiceClient;
  this.dtoBuildHelper = dtoBuildHelper;
  this.resources = resources;
  this.imageProvider = imageProvider;
  this.serverCapabilities = serverCapabilities;
  this.fuzzyMatches = fuzzyMatches;
  this.latestCompletionResult = LatestCompletionResult.NO_RESULT;
}

CompletionItemBasedCompletionProposal(
    HasLinkedMode editor,
    ExtendedCompletionItem completionItem,
    String currentWord,
    TextDocumentServiceClient documentServiceClient,
    LanguageServerResources resources,
    Icon icon,
    ServerCapabilities serverCapabilities,
    List<Match> highlights,
    int offset) {
  this.editor = editor;
  this.completionItem = completionItem;
  this.currentWord = currentWord;
  this.documentServiceClient = documentServiceClient;
  this.resources = resources;
  this.icon = icon;
  this.serverCapabilities = serverCapabilities;
  this.highlights = highlights;
  this.offset = offset;
  this.resolved = false;
}

@Inject
public LanguageServerReconcileStrategy(
    TextDocumentSynchronizeFactory synchronizeFactory,
    @Assisted ServerCapabilities serverCapabilities) {

  Either<TextDocumentSyncKind, TextDocumentSyncOptions> sync =
      serverCapabilities.getTextDocumentSync();
  TextDocumentSyncKind documentSync;
  if (sync.isLeft()) {
    documentSync = sync.getLeft();
  } else {
    documentSync = sync.getRight().getChange();
  }

  synchronize = synchronizeFactory.getSynchronize(documentSync);
}

@Override
public void onServerInitialized(
    LanguageServerLauncher launcher,
    LanguageServer server,
    ServerCapabilities capabilities,
    String projectPath) {

  try {
    Map<String, String> preferences =
        requestFactory.fromUrl(apiUrl + "/preferences").useGetMethod().request().asProperties();

    Endpoint endpoint = ServiceEndpoints.toEndpoint(server);
    YamlSchemaAssociations serviceObject =
        ServiceEndpoints.toServiceObject(endpoint, YamlSchemaAssociations.class);
    Map<String, String[]> associations =
        jsonToSchemaAssociations(preferences.get("yaml.preferences"));
    serviceObject.yamlSchemaAssociation(associations);

  } catch (ApiException | IOException e) {
    LOG.error(e.getLocalizedMessage(), e);
  }
}

@Override
public void onServerInitialized(
    LanguageServerLauncher launcher,
    LanguageServer server,
    ServerCapabilities capabilities,
    String projectPath) {
  Endpoint endpoint = ServiceEndpoints.toEndpoint(server);
  JsonExtension serviceObject = ServiceEndpoints.toServiceObject(endpoint, JsonExtension.class);
  Map<String, String[]> associations = new HashMap<>();
  associations.put("/*.schema.json", new String[] {"http://json-schema.org/draft-04/schema#"});
  associations.put("/bower.json", new String[] {"http://json.schemastore.org/bower"});
  associations.put("/.bower.json", new String[] {"http://json.schemastore.org/bower"});
  associations.put("/.bowerrc", new String[] {"http://json.schemastore.org/bowerrc"});
  associations.put("/composer.json", new String[] {"https://getcomposer.org/schema.json"});
  associations.put("/package.json", new String[] {"http://json.schemastore.org/package"});
  associations.put("/jsconfig.json", new String[] {"http://json.schemastore.org/jsconfig"});
  associations.put("/tsconfig.json", new String[] {"http://json.schemastore.org/tsconfig"});
  serviceObject.jsonSchemaAssociation(associations);
}

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

/**
 * The capabilities the language server provides.
 */
@Pure
@NonNull
public ServerCapabilities getCapabilities() {
  return this.capabilities;
}

/**
 * The capabilities the language server provides.
 */
public void setCapabilities(@NonNull final ServerCapabilities capabilities) {
  this.capabilities = capabilities;
}

@POST
@Produces(MediaType.APPLICATION_JSON)
@Path("initialize")
public ServerCapabilitiesDto initialize(@QueryParam("path") String path)
    throws LanguageServerException {
  // in most cases starts new LS if not already started
  ServerCapabilities capabilities = registry.initialize(LanguageServiceUtils.prefixURI(path));
  return capabilities == null ? null : new ServerCapabilitiesDto(capabilities);
}

private Boolean or(Function<ServerCapabilities, Boolean> f) {
  Boolean leftVal = f.apply(left);
  Boolean rightVal = f.apply(right);
  if (leftVal == null) {
    return rightVal;
  }
  if (rightVal == null) {
    return leftVal;
  }
  return leftVal || rightVal;
}

@Override
public ServerCapabilities getCapabilities(String fileUri) throws LanguageServerException {
  return getApplicableLanguageServers(fileUri)
      .stream()
      .flatMap(Collection::stream)
      .map(s -> s.getInitializeResult().getCapabilities())
      .reduce(
          null,
          (left, right) ->
              left == null ? right : new ServerCapabilitiesOverlay(left, right).compute());
}

private void onServerInitialized(
    LanguageServerLauncher launcher,
    LanguageServer server,
    ServerCapabilities capabilities,
    String projectPath) {
  observers.forEach(
      observer -> observer.onServerInitialized(launcher, server, capabilities, projectPath));
}

@Test
public void testFindServer() throws Exception {
  ServerCapabilities cap = registry.initialize(PREFIX + FILE_PATH);

  assertNotNull(cap);
  assertEquals(cap, serverCapabilities);
  Mockito.verify(initializer)
      .initialize(eq(languageServerLauncher), any(LanguageClient.class), eq(PROJECT_PATH));
}

public ExtendedInitializeResult(
    String project,
    ServerCapabilities serverCapabilities,
    LanguageDescription languageDescription) {
  this.project = project;
  this.capabilities = serverCapabilities;
  this.supportedLanguages = Collections.singletonList(languageDescription);
}

public Promise<ServerCapabilities> initializeServer(String path) {
  return Promises.create(
      (resolve, reject) ->
          requestTransmitter
              .newRequest()
              .endpointId(WS_AGENT_JSON_RPC_ENDPOINT_ID)
              .methodName("languageServer/initialize")
              .paramsAsString(path)
              .sendAndReceiveResultAsDto(ServerCapabilities.class, 30000)
              .onSuccess(resolve::apply)
              .onFailure(error -> reject.apply(getPromiseError(error)))
              .onTimeout(
                  () -> {
                    final TimeoutException e = new TimeoutException();
                    reject.apply(
                        new PromiseError() {

                          @Override
                          public String getMessage() {
                            return "Timeout initializing error";
                          }

                          @Override
                          public Throwable getCause() {
                            return e;
                          }
                        });
                  }));
}

@Inject
public LanguageServerFormatter(
    TextDocumentServiceClient client,
    DtoFactory dtoFactory,
    NotificationManager manager,
    @Assisted ServerCapabilities capabilities,
    EditorPreferencesManager editorPreferencesManager) {
  this.client = client;
  this.dtoFactory = dtoFactory;
  this.manager = manager;
  this.capabilities = capabilities;
  this.editorPreferencesManager = editorPreferencesManager;
}

@Inject
public LanguageServerSignatureHelp(
    TextDocumentServiceClient client,
    DtoBuildHelper helper,
    NotificationManager notificationManager,
    @Assisted ServerCapabilities capabilities) {
  this.client = client;
  this.helper = helper;
  this.notificationManager = notificationManager;
  this.capabilities = capabilities;
}

@Override
public Promise<EditorPartPresenter> createEditor(VirtualFile file) {
  if (file instanceof File) {
    File resource = (File) file;

    Promise<ServerCapabilities> promise =
        registry.getOrInitializeServer(resource.getProject().getPath(), file);
    return promise.then(
        new Function<ServerCapabilities, EditorPartPresenter>() {
          @Override
          public EditorPartPresenter apply(ServerCapabilities capabilities)
              throws FunctionException {
            if (editorBuilder == null) {
              Log.debug(
                  AbstractTextEditorProvider.class,
                  "No builder registered for default editor type - giving up.");
              return null;
            }

            final TextEditor editor = editorBuilder.buildEditor();
            TextEditorConfiguration configuration =
                capabilities == null
                    ? new DefaultTextEditorConfiguration()
                    : editorConfigurationFactory.build(editor, capabilities);
            editor.initialize(configuration);
            return editor;
          }
        });
  }
  return null;
}

@Inject
public LanguageServerEditorConfiguration(
    @Assisted TextEditor editor,
    LanguageServerCodeassistProcessorFactory codeAssistProcessor,
    LanguageServerQuickAssistProcessorFactory quickAssistProcessorFactory,
    Provider<DocumentPositionMap> docPositionMapProvider,
    LanguageServerAnnotationModelFactory annotationModelFactory,
    LanguageServerReconcileStrategyFactory reconcileStrategyProviderFactory,
    LanguageServerFormatterFactory formatterFactory,
    LanguageServerSignatureHelpFactory signatureHelpFactory,
    @Assisted ServerCapabilities serverCapabilities) {
  codeAssistProcessorFactory = codeAssistProcessor;
  quickAssistProcessor = quickAssistProcessorFactory.create(editor);
  if ((serverCapabilities.getDocumentFormattingProvider() != null
          && serverCapabilities.getDocumentFormattingProvider())
      || (serverCapabilities.getDocumentRangeFormattingProvider() != null
          && serverCapabilities.getDocumentRangeFormattingProvider())
      || serverCapabilities.getDocumentOnTypeFormattingProvider() != null) {
    this.formatter = formatterFactory.create(serverCapabilities);
  } else {
    this.formatter = null;
  }
  this.serverCapabilities = serverCapabilities;
  DocumentPositionMap documentPositionMap = docPositionMapProvider.get();
  documentPositionMap.addPositionCategory(DocumentPositionMap.Categories.DEFAULT_CATEGORY);
  this.annotationModel = annotationModelFactory.get(documentPositionMap);

  this.reconciler =
      new DefaultReconciler(DocumentPartitioner.DEFAULT_CONTENT_TYPE, getPartitioner());
  reconciler.addReconcilingStrategy(
      DocumentPartitioner.DEFAULT_CONTENT_TYPE,
      reconcileStrategyProviderFactory.build(serverCapabilities));
  if (serverCapabilities.getSignatureHelpProvider() != null) {
    signatureHelpProvider = signatureHelpFactory.create(serverCapabilities);
  } else {
    signatureHelpProvider = null;
  }
}

public InitializeResult(@NonNull final ServerCapabilities capabilities) {
  this.capabilities = capabilities;
}

/**
 * The capabilities the language server provides.
 */
@Pure
@NonNull
public ServerCapabilities getCapabilities() {
  return this.capabilities;
}

/**
 * The capabilities the language server provides.
 */
public void setCapabilities(@NonNull final ServerCapabilities capabilities) {
  this.capabilities = capabilities;
}

public InitializeResult(@NonNull final ServerCapabilities capabilities) {
  this.capabilities = capabilities;
}

public ServerCapabilitiesOverlay(ServerCapabilities left, ServerCapabilities right) {
  this.left = left;
  this.right = right;
}

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

public ServerCapabilities getCapabilities() {
  return capabilities;
}

public void setCapabilities(ServerCapabilities capabilities) {
  this.capabilities = capabilities;
}

public ServerCapabilities getServerCapabilities() {
  return serverCapabilities;
}