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