prChangesTreeDataProvider.ts

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

import * as vscode from 'vscode';
import { ProgressHelper } from './progress';
import { ReviewModel } from './reviewModel';
import { GitApiImpl } from '../api/api1';
import { commands, contexts } from '../common/executeCommands';
import { Disposable } from '../common/lifecycle';
import Logger, { PR_TREE } from '../common/logger';
import { FILE_LIST_LAYOUT, GIT, HIDE_VIEWED_FILES, OPEN_DIFF_ON_CLICK, PR_SETTINGS_NAMESPACE, SHOW_ONLY_OWNED_FILES } from '../common/settingKeys';
import { isDescendant } from '../common/utils';
import { FolderRepositoryManager } from '../github/folderRepositoryManager';
import { PullRequestModel } from '../github/pullRequestModel';
import { RepositoriesManager } from '../github/repositoriesManager';
import { GitFileChangeNode } from './treeNodes/fileChangeNode';
import { RepositoryChangesNode } from './treeNodes/repositoryChangesNode';
import { BaseTreeNode, TreeNode } from './treeNodes/treeNode';
import { TreeUtils } from './treeNodes/treeUtils';

export class PullRequestChangesTreeDataProvider extends Disposable implements vscode.TreeDataProvider<TreeNode>, BaseTreeNode {
	private _onDidChangeTreeData = new vscode.EventEmitter<TreeNode | void>();
	readonly onDidChangeTreeData = this._onDidChangeTreeData.event;

	private _pullRequestManagerMap: Map<FolderRepositoryManager, RepositoryChangesNode> = new Map();
	private _view: vscode.TreeView<TreeNode>;
	private _children: TreeNode[] | undefined;

	public get view(): vscode.TreeView<TreeNode> {
		return this._view;
	}

	constructor(private _git: GitApiImpl, private _reposManager: RepositoriesManager) {
		super();
		this._view = this._register(vscode.window.createTreeView('prStatus:github', {
			treeDataProvider: this,
			showCollapseAll: true,
			canSelectMany: true,
			manageCheckboxStateManually: true
		}));

		this._register(
			vscode.workspace.onDidChangeConfiguration(async e => {
				if (e.affectsConfiguration(`${PR_SETTINGS_NAMESPACE}.${FILE_LIST_LAYOUT}`)) {
					this._onDidChangeTreeData.fire();
					const layout = vscode.workspace
						.getConfiguration(PR_SETTINGS_NAMESPACE)
						.get<string>(FILE_LIST_LAYOUT);
					await vscode.commands.executeCommand('setContext', 'fileListLayout:flat', layout === 'flat');
				} else if (e.affectsConfiguration(`${GIT}.${OPEN_DIFF_ON_CLICK}`)) {
					this._onDidChangeTreeData.fire();
				} else if (e.affectsConfiguration(`${PR_SETTINGS_NAMESPACE}.${HIDE_VIEWED_FILES}`)) {
					this._onDidChangeTreeData.fire();
				} else if (e.affectsConfiguration(`${PR_SETTINGS_NAMESPACE}.${SHOW_ONLY_OWNED_FILES}`)) {
					this._onDidChangeTreeData.fire();
				}
			}),
		);

		this._register(this._view.onDidChangeCheckboxState(e => TreeUtils.processCheckboxUpdates(e, this._view.selection)));
	}

	refresh(treeNode?: TreeNode) {
		this._onDidChangeTreeData.fire(treeNode);
	}

	private updateViewTitle(): void {
		let pullRequestNumber: number | undefined;
		if (this._pullRequestManagerMap.size === 1) {
			const pullRequestIterator = this._pullRequestManagerMap.values().next();
			if (!pullRequestIterator.done) {
				pullRequestNumber = pullRequestIterator.value.pullRequestModel.number;
			}
		}

		this._view.title = pullRequestNumber
			? vscode.l10n.t('Changes in Pull Request #{0}', pullRequestNumber)
			: (this._pullRequestManagerMap.size > 1 ? vscode.l10n.t('Changes in Pull Requests') : vscode.l10n.t('Changes in Pull Request'));
	}

	async addPrToView(
		pullRequestManager: FolderRepositoryManager,
		pullRequestModel: PullRequestModel,
		reviewModel: ReviewModel,
		shouldReveal: boolean,
		progress: ProgressHelper
	) {
		Logger.appendLine(`Adding PR #${pullRequestModel.number} to tree`, PR_TREE);
		if (this._pullRequestManagerMap.has(pullRequestManager)) {
			const existingNode = this._pullRequestManagerMap.get(pullRequestManager);
			if (existingNode && (existingNode.pullRequestModel === pullRequestModel)) {
				Logger.appendLine(`PR #${pullRequestModel.number} already exists in tree`, PR_TREE);
				return;
			} else {
				existingNode?.dispose();
			}
		}
		const node: RepositoryChangesNode = new RepositoryChangesNode(
			this,
			pullRequestModel,
			pullRequestManager,
			reviewModel,
			progress
		);
		this._pullRequestManagerMap.set(pullRequestManager, node);
		this.updateViewTitle();

		await this.setReviewModeContexts();
		this._onDidChangeTreeData.fire();

		if (shouldReveal) {
			this.reveal(node);
		}
	}

	private async setReviewModeContexts() {
		await commands.setContext(contexts.IN_REVIEW_MODE, this._pullRequestManagerMap.size > 0);

		const rootUrisNotInReviewMode: vscode.Uri[] = [];
		const rootUrisInReviewMode: vscode.Uri[] = [];
		this._git.repositories.forEach(repo => {
			const folderManager = this._reposManager.getManagerForFile(repo.rootUri);
			if (folderManager && !this._pullRequestManagerMap.has(folderManager)) {
				rootUrisNotInReviewMode.push(repo.rootUri);
			} else if (folderManager) {
				rootUrisInReviewMode.push(repo.rootUri);
			}
		});
		await commands.setContext(contexts.REPOS_NOT_IN_REVIEW_MODE, rootUrisNotInReviewMode);
		await commands.setContext(contexts.REPOS_IN_REVIEW_MODE, rootUrisInReviewMode);
	}

	async removePrFromView(pullRequestManager: FolderRepositoryManager) {
		const oldPR = this._pullRequestManagerMap.has(pullRequestManager) ? this._pullRequestManagerMap.get(pullRequestManager) : undefined;
		if (oldPR) {
			Logger.appendLine(`Removing PR #${oldPR.pullRequestModel.number} from tree`, PR_TREE);
		}
		oldPR?.dispose();
		this._pullRequestManagerMap.delete(pullRequestManager);
		this.updateViewTitle();

		await this.setReviewModeContexts();
		this._onDidChangeTreeData.fire();
	}

	getTreeItem(element: TreeNode): vscode.TreeItem | Thenable<vscode.TreeItem> {
		return element.getTreeItem();
	}

	getParent(element: TreeNode) {
		return element.getParent();
	}

	async reveal(
		element: TreeNode,
		options?: { select?: boolean; focus?: boolean; expand?: boolean | number },
	): Promise<void> {
		try {
			await this._view.reveal(element, options);
		} catch (e) {
			Logger.error(e, PR_TREE);
		}
	}

	get children(): TreeNode[] | undefined {
		return this._children;
	}

	private sortMap() {
		const workspaceFolders = vscode.workspace.workspaceFolders;
		const compareFolders = (a: vscode.Uri, b: vscode.Uri) => {
			const aFolder = a.fsPath.toLowerCase();
			const bFolder = b.fsPath.toLowerCase();

			return isDescendant(aFolder, bFolder) || isDescendant(bFolder, aFolder);
		};

		return Array.from(this._pullRequestManagerMap.entries()).sort((a, b) => {
			if (a[0].repository.rootUri.toString() === b[0].repository.rootUri.toString()) {
				return 0;
			}
			if (!workspaceFolders) return 0;
			const aIndex = workspaceFolders.findIndex(folder => compareFolders(folder.uri, a[0].repository.rootUri));
			const bIndex = workspaceFolders.findIndex(folder => compareFolders(folder.uri, b[0].repository.rootUri));
			if (aIndex === -1) {
				return 1;
			}
			if (bIndex === -1) {
				return -1;
			}
			return aIndex - bIndex;
		}).map(([_, value]) => value);
	}

	async getChildren(element?: TreeNode): Promise<TreeNode[]> {
		if (!element) {
			this._children = [];
			if (this._pullRequestManagerMap.size >= 1) {
				const sortedValues = this.sortMap();
				for (const item of sortedValues) {
					this._children.push(item);
				}
			}
			return this._children;
		} else {
			return await element.getChildren();
		}
	}

	getDescriptionNode(folderRepoManager: FolderRepositoryManager): RepositoryChangesNode | undefined {
		return this._pullRequestManagerMap.get(folderRepoManager);
	}

	async resolveTreeItem?(item: vscode.TreeItem, element: TreeNode): Promise<vscode.TreeItem> {
		if (element instanceof GitFileChangeNode) {
			await element.resolve();
		}
		return element;
	}
}