org.eclipse.lsp4j.WorkspaceFolder Java Examples

private void updateFallbackWorkspaceFolder()
{
    if(oldFrameworkSDKPath == null)
    {
        return;
    }
    WorkspaceFolder folder = new WorkspaceFolder(Paths.get(oldFrameworkSDKPath).toUri().toString());
    fallbackConfig = new SimpleProjectConfigStrategy(folder);
    WorkspaceFolderData fallbackFolderData = workspaceFolderManager.setFallbackFolderData(folder, fallbackConfig);
    for(Path openFilePath : fileTracker.getOpenFiles())
    {
        WorkspaceFolderData folderData = workspaceFolderManager.getWorkspaceFolderDataForSourceFile(openFilePath);
        if(fallbackFolderData.equals(folderData))
        {
            fallbackConfig.didOpen(openFilePath);
        }
    }
}
 

public void addWorkspaceFolder(WorkspaceFolder folder)
{
    IProjectConfigStrategy config = projectConfigStrategyFactory.create(folder);
    WorkspaceFolderData folderData = workspaceFolderManager.addWorkspaceFolder(folder, config);
    folderData.codeProblemTracker.setLanguageClient(languageClient);
    folderData.configProblemTracker.setLanguageClient(languageClient);
    
    //let's get the code intelligence up and running!
    Path path = getMainCompilationUnitPath(folderData);
    if (path != null)
    {
        String normalizedPath = FilenameNormalization.normalize(path.toAbsolutePath().toString());
        IFileSpecification fileSpec = fileTracker.getFileSpecification(normalizedPath);
        compilerWorkspace.fileChanged(fileSpec);
    }

    checkProjectForProblems(folderData);
}
 

public WorkspaceFolderData setFallbackFolderData(WorkspaceFolder folder, IProjectConfigStrategy config)
{
    if(fallbackFolderData != null)
    {
        if(fallbackFolderData.folder.equals(folder)
                && fallbackFolderData.config.equals(config))
        {
            return fallbackFolderData;
        }
        fallbackFolderData.cleanup();
        fallbackFolderData = null;
    }
    WorkspaceFolderData folderData = new WorkspaceFolderData(folder, config);
    fallbackFolderData = folderData;
    return fallbackFolderData;
}
 

@Nonnull
public static WorkspaceFolder toWorkspaceFolder(@Nonnull Module project) {
    WorkspaceFolder folder = new WorkspaceFolder();
    folder.setUri(toUri(project).toString());
    folder.setName(project.getName());
    return folder;
}
 

/**
 * Updates the workspace folders and refreshes the workspace.
 * 
 * @since 2.21
 */
public void didChangeWorkspaceFolders(DidChangeWorkspaceFoldersParams params, CancelIndicator cancelIndicator) {
	WorkspaceFoldersChangeEvent event = params.getEvent();
	Map<String, WorkspaceFolder> uri2workspaceFolder = new HashMap<>();
	workspaceFolders.forEach(it -> uri2workspaceFolder.put(it.getUri(), it));
	event.getRemoved().forEach(it -> uri2workspaceFolder.remove(it.getUri()));
	event.getAdded().forEach(it -> {
		if (!uri2workspaceFolder.containsKey(it.getUri())) 
			uri2workspaceFolder.put(it.getUri(), it);
	});
	this.workspaceFolders = new ArrayList<>(uri2workspaceFolder.values());
	refreshWorkspaceConfig(cancelIndicator);
}
 

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

protected void addProjectsForWorkspaceFolder(WorkspaceConfig workspaceConfig, WorkspaceFolder workspaceFolder, Set<String> existingNames) {
	if (workspaceFolder != null && workspaceFolder.getUri() != null) {
		FileProjectConfig project = new FileProjectConfig(uriExtensions.toUri(workspaceFolder.getUri()), getUniqueProjectName(workspaceFolder.getName(), existingNames));
		project.addSourceFolder(".");
		workspaceConfig.addProject(project);
	}
}
 

@Override
public IWorkspaceConfig getWorkspaceConfig(List<WorkspaceFolder> workspaceFolders) {
	WorkspaceConfig workspaceConfig = new WorkspaceConfig();
	Set<String> existingProjectNames = new HashSet<>();
	for(WorkspaceFolder workspaceFolder: workspaceFolders) 
		addProjectsForWorkspaceFolder(workspaceConfig, workspaceFolder, existingProjectNames);
	return workspaceConfig;
}
 

@Override
public com.google.inject.Module getServerModule() {
  ServerModule _serverModule = new ServerModule();
  final com.google.inject.Module _function = (Binder it) -> {
    AnnotatedBindingBuilder<IMultiRootWorkspaceConfigFactory> _bind = it.<IMultiRootWorkspaceConfigFactory>bind(IMultiRootWorkspaceConfigFactory.class);
    _bind.toInstance(new MultiRootWorkspaceConfigFactory() {
      @Override
      public void addProjectsForWorkspaceFolder(final WorkspaceConfig workspaceConfig, final WorkspaceFolder workspaceFolder, final Set<String> existingNames) {
        String _uri = null;
        if (workspaceFolder!=null) {
          _uri=workspaceFolder.getUri();
        }
        boolean _tripleNotEquals = (_uri != null);
        if (_tripleNotEquals) {
          URI _uri_1 = this.getUriExtensions().toUri(workspaceFolder.getUri());
          String _uniqueProjectName = this.getUniqueProjectName(workspaceFolder.getName(), existingNames);
          final FileProjectConfig project = new FileProjectConfig(_uri_1, _uniqueProjectName) {
            @Override
            public boolean isIndexOnly() {
              return true;
            }
          };
          project.addSourceFolder(".");
          workspaceConfig.addProject(project);
        }
      }
    });
  };
  return Modules2.mixin(_serverModule, _function);
}
 

@Override
public void addProjectsForWorkspaceFolder(WorkspaceConfig workspaceConfig, WorkspaceFolder workspaceFolder,
		Set<String> existingNames) {
	if (workspaceFolder != null) {
		if (workspaceFolder.getUri() != null) {
			SourceFolderCustomImplTest.CustomFileProjectConfig project = new SourceFolderCustomImplTest.CustomFileProjectConfig(
					getUriExtensions().toUri(workspaceFolder.getUri()), workspaceConfig);
			project.addSourceFolder(".");
			workspaceConfig.addProject(project);
		}
	}
}
 

public void removeWorkspaceFolder(WorkspaceFolder folder)
{
    if(!workspaceFolderToData.containsKey(folder))
    {
        return;
    }
    workspaceFolders.remove(folder);
    WorkspaceFolderData folderData = workspaceFolderToData.get(folder);
    workspaceFolderToData.remove(folder);
    folderData.cleanup();
}
 

public WorkspaceFolderData addWorkspaceFolder(WorkspaceFolder folder, IProjectConfigStrategy config)
{
    workspaceFolders.add(folder);
    WorkspaceFolderData folderData = new WorkspaceFolderData(folder, config);
    workspaceFolderToData.put(folder, folderData);
    return folderData;
}
 

public ASConfigProjectConfigStrategy(WorkspaceFolder workspaceFolder)
{
    this.workspaceFolder = workspaceFolder;

    Path workspacePath = Paths.get(URI.create(workspaceFolder.getUri()));
    asconfigPath = workspacePath.resolve(ASCONFIG_JSON);
}
 

public DefaultLanguageServerWrapper(StartupLogic startupLogic, LSP lsp, String serverPath, List<String> lspArgs, BiConsumer<LanguageServerWrapper, File> workspaceInit) {
    this.documentManager = new DefaultDocumentManager(this, startupLogic);
    this.startupLogic = startupLogic;
    this.fileWatchManager = startupLogic.getFileWatchManager();
    this.lsp = lsp;
    this.serverPath = () -> serverPath;
    this.lspArgs = lspArgs;
    this.workspaceInit = workspaceInit;

    if (!lsp.usesWorkspaces()) return;
    this.workspaces.addListener((ListChangeListener<WorkspaceFolder>) change -> {
        var added = new ArrayList<WorkspaceFolder>();
        var removed = new ArrayList<WorkspaceFolder>();

        while (change.next()) {
            added.addAll(change.getAddedSubList());
            removed.addAll(change.getRemoved());
        }

        LOGGER.info("Adding: {}  Removing: {}", added, removed);

        this.languageServer.getWorkspaceService().didChangeWorkspaceFolders(
                new DidChangeWorkspaceFoldersParams(
                        new WorkspaceFoldersChangeEvent(
                                added,
                                removed)));
    });
}
 

@Override
public CompletableFuture<List<WorkspaceFolder>> workspaceFolders() {
    List<WorkspaceFolder> res = new ArrayList<>(wrapper.allWatchedProjects.size());
    for (final Module project : wrapper.allWatchedProjects) {
        res.add(LSPIJUtils.toWorkspaceFolder(project));
    }
    return CompletableFuture.completedFuture(res);
}
 

public WorkspaceFoldersChangeEvent(@NonNull final List<WorkspaceFolder> added, @NonNull final List<WorkspaceFolder> removed) {
  this.added = Preconditions.<List<WorkspaceFolder>>checkNotNull(added, "added");
  this.removed = Preconditions.<List<WorkspaceFolder>>checkNotNull(removed, "removed");
}
 

protected InitializeResult initialize(final Procedure1<? super InitializeParams> initializer, final boolean callInitialized) {
  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()));
      String _rootUri = it.getRootUri();
      WorkspaceFolder _workspaceFolder = new WorkspaceFolder(_rootUri, "");
      it.setWorkspaceFolders(Collections.<WorkspaceFolder>unmodifiableList(CollectionLiterals.<WorkspaceFolder>newArrayList(_workspaceFolder)));
    };
    final InitializeParams params = ObjectExtensions.<InitializeParams>operator_doubleArrow(_initializeParams, _function);
    if (initializer!=null) {
      initializer.apply(params);
    }
    Boolean _elvis = null;
    ClientCapabilities _capabilities = params.getCapabilities();
    TextDocumentClientCapabilities _textDocument = null;
    if (_capabilities!=null) {
      _textDocument=_capabilities.getTextDocument();
    }
    DocumentSymbolCapabilities _documentSymbol = null;
    if (_textDocument!=null) {
      _documentSymbol=_textDocument.getDocumentSymbol();
    }
    Boolean _hierarchicalDocumentSymbolSupport = null;
    if (_documentSymbol!=null) {
      _hierarchicalDocumentSymbolSupport=_documentSymbol.getHierarchicalDocumentSymbolSupport();
    }
    if (_hierarchicalDocumentSymbolSupport != null) {
      _elvis = _hierarchicalDocumentSymbolSupport;
    } else {
      _elvis = Boolean.valueOf(false);
    }
    this.hierarchicalDocumentSymbolSupport = (_elvis).booleanValue();
    final InitializeResult result = this.languageServer.initialize(params).get();
    if (callInitialized) {
      this.languageServer.initialized(null);
    }
    return result;
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}
 

public SimpleProjectConfigStrategy(WorkspaceFolder workspaceFolder)
{
    this.workspaceFolder = workspaceFolder;
}
 

private WorkspaceFolder getWorkspace(File file) {
    return getWorkspace(file.getAbsolutePath());
}
 

protected List<WorkspaceFolder> getWorkspaceFolders() {
	return workspaceFolders;
}
 

@Override
public CompletableFuture<List<WorkspaceFolder>> workspaceFolders() {
    return LanguageClient.super.workspaceFolders();
}
 

@Override
protected void addProjectsForWorkspaceFolder(WorkspaceConfig workspaceConfig, WorkspaceFolder workspaceFolder, Set<String> existingNames) {
	if (workspaceFolder != null && workspaceFolder.getUri() != null)
		findProjects(workspaceConfig, uriExtensions.toUri(workspaceFolder.getUri()));
}
 

/**
 * The array of added workspace folders
 */
@Pure
@NonNull
public List<WorkspaceFolder> getAdded() {
  return this.added;
}
 

/**
 * The array of added workspace folders
 */
public void setAdded(@NonNull final List<WorkspaceFolder> added) {
  this.added = Preconditions.checkNotNull(added, "added");
}
 

/**
 * The array of the removed workspace folders
 */
@Pure
@NonNull
public List<WorkspaceFolder> getRemoved() {
  return this.removed;
}
 

/**
 * The array of the removed workspace folders
 */
public void setRemoved(@NonNull final List<WorkspaceFolder> removed) {
  this.removed = Preconditions.checkNotNull(removed, "removed");
}
 

protected List<WorkspaceFolder> readWorkspaceFolders(final JsonReader in) throws IOException {
  return gson.fromJson(in, WORKSPACEFOLDERS_TYPE_TOKEN.getType());
}
 

protected void writeWorkspaceFolders(final JsonWriter out, final List<WorkspaceFolder> value) throws IOException {
  gson.toJson(value, WORKSPACEFOLDERS_TYPE_TOKEN.getType(), out);
}
 

@Override
public CompletableFuture<List<WorkspaceFolder>> workspaceFolders() {
	throw new UnsupportedOperationException();
}
 

private WorkspaceFolder getWorkspace(String file, String name) {
    var workspace = new WorkspaceFolder();
    workspace.setUri(getURI(file));
    workspace.setName(name);
    return workspace;
}