Use element as handle when element is a string identifier

src/vs/workbench/api/node/extHostTreeViews.ts

@@ -156,16 +156,16 @@ class ExtHostTreeView<T> extends Disposable {
 
 	private resolveElement(element: T, index: number, parentHandle?: TreeItemHandle): TPromise<ITreeItem> {
 		return asWinJsPromise(() => this.dataProvider.getTreeItem(element))
-			.then(extTreeItem => this.massageTreeItem(extTreeItem, index, parentHandle));
+			.then(extTreeItem => this.massageTreeItem(element, extTreeItem, index, parentHandle));
 	}
 
-	private massageTreeItem(extensionTreeItem: vscode.TreeItem, index: number, parentHandle: TreeItemHandle): ITreeItem {
+	private massageTreeItem(element: T, extensionTreeItem: vscode.TreeItem, index: number, parentHandle: TreeItemHandle): ITreeItem {
 		if (!extensionTreeItem) {
 			return null;
 		}
 		const icon = this.getLightIconPath(extensionTreeItem);
 		const label = extensionTreeItem.label;
-		const handle = this.generateHandle(label, index, parentHandle);
+		const handle = typeof element === 'string' ? element : this.generateHandle(label, index, parentHandle);
 		return {
 			handle,
 			parentHandle,

src/vs/workbench/test/electron-browser/api/extHostTreeViews.test.ts

@@ -22,7 +22,6 @@ import { TreeItemCollapsibleState, ITreeItem } from 'vs/workbench/common/views';
 
 suite('ExtHostTreeView', function () {
 
-
 	class RecordingShape extends mock<MainThreadTreeViewsShape>() {
 
 		onRefresh = new Emitter<{ [treeItemHandle: string]: ITreeItem }>();
@@ -37,9 +36,9 @@ suite('ExtHostTreeView', function () {
 
 	let testObject: ExtHostTreeViews;
 	let target: RecordingShape;
-	let onDidChangeTreeData: Emitter<string>;
-	let tree;
-	let labels;
+	let onDidChangeTreeNode: Emitter<{ key: string }>;
+	let onDidChangeTreeKey: Emitter<string>;
+	let tree, labels, nodes;
 
 	setup(() => {
 		tree = {
@@ -54,6 +53,7 @@ suite('ExtHostTreeView', function () {
 		};
 
 		labels = {};
+		nodes = {};
 
 		let threadService = new TestThreadService();
 		// Use IInstantiationService to get typechecking when instantiating
@@ -66,38 +66,68 @@ suite('ExtHostTreeView', function () {
 		threadService.setTestInstance(MainContext.MainThreadCommands, inst.createInstance(MainThreadCommands, threadService));
 		target = new RecordingShape();
 		testObject = new ExtHostTreeViews(target, new ExtHostCommands(threadService, new ExtHostHeapService()));
-		onDidChangeTreeData = new Emitter<string>();
-		testObject.registerTreeDataProvider('testDataProvider', aTreeDataProvider());
+		onDidChangeTreeNode = new Emitter<{ key: string }>();
+		onDidChangeTreeKey = new Emitter<string>();
+		testObject.registerTreeDataProvider('testNodeTreeProvider', aNodeTreeDataProvider());
+		testObject.registerTreeDataProvider('testStringTreeProvider', aStringTreeDataProvider());
 
-		testObject.$getElements('testDataProvider').then(elements => {
+		testObject.$getElements('testNodeTreeProvider').then(elements => {
 			for (const element of elements) {
-				testObject.$getChildren('testDataProvider', element.handle);
+				testObject.$getChildren('testNodeTreeProvider', element.handle);
 			}
 		});
 	});
 
-	test('construct tree', () => {
-		return testObject.$getElements('testDataProvider')
+	test('construct node tree', () => {
+		return testObject.$getElements('testNodeTreeProvider')
 			.then(elements => {
 				const actuals = elements.map(e => e.handle);
 				assert.deepEqual(actuals, ['0/0:a', '0/1:b']);
 				return TPromise.join([
-					testObject.$getChildren('testDataProvider', '0/0:a')
+					testObject.$getChildren('testNodeTreeProvider', '0/0:a')
 						.then(children => {
 							const actuals = children.map(e => e.handle);
 							assert.deepEqual(actuals, ['0/0:a/0:aa', '0/0:a/1:ab']);
 							return TPromise.join([
-								testObject.$getChildren('testDataProvider', '0/0:a/0:aa').then(children => assert.equal(children.length, 0)),
-								testObject.$getChildren('testDataProvider', '0/0:a/1:ab').then(children => assert.equal(children.length, 0))
+								testObject.$getChildren('testNodeTreeProvider', '0/0:a/0:aa').then(children => assert.equal(children.length, 0)),
+								testObject.$getChildren('testNodeTreeProvider', '0/0:a/1:ab').then(children => assert.equal(children.length, 0))
 							]);
 						}),
-					testObject.$getChildren('testDataProvider', '0/1:b')
+					testObject.$getChildren('testNodeTreeProvider', '0/1:b')
 						.then(children => {
 							const actuals = children.map(e => e.handle);
 							assert.deepEqual(actuals, ['0/1:b/0:ba', '0/1:b/1:bb']);
 							return TPromise.join([
-								testObject.$getChildren('testDataProvider', '0/1:b/0:ba').then(children => assert.equal(children.length, 0)),
-								testObject.$getChildren('testDataProvider', '0/1:b/1:bb').then(children => assert.equal(children.length, 0))
+								testObject.$getChildren('testNodeTreeProvider', '0/1:b/0:ba').then(children => assert.equal(children.length, 0)),
+								testObject.$getChildren('testNodeTreeProvider', '0/1:b/1:bb').then(children => assert.equal(children.length, 0))
+							]);
+						})
+				]);
+			});
+	});
+
+	test('construct string tree', () => {
+		return testObject.$getElements('testStringTreeProvider')
+			.then(elements => {
+				const actuals = elements.map(e => e.handle);
+				assert.deepEqual(actuals, ['a', 'b']);
+				return TPromise.join([
+					testObject.$getChildren('testStringTreeProvider', 'a')
+						.then(children => {
+							const actuals = children.map(e => e.handle);
+							assert.deepEqual(actuals, ['aa', 'ab']);
+							return TPromise.join([
+								testObject.$getChildren('testStringTreeProvider', 'aa').then(children => assert.equal(children.length, 0)),
+								testObject.$getChildren('testStringTreeProvider', 'ab').then(children => assert.equal(children.length, 0))
+							]);
+						}),
+					testObject.$getChildren('testStringTreeProvider', 'b')
+						.then(children => {
+							const actuals = children.map(e => e.handle);
+							assert.deepEqual(actuals, ['ba', 'bb']);
+							return TPromise.join([
+								testObject.$getChildren('testStringTreeProvider', 'ba').then(children => assert.equal(children.length, 0)),
+								testObject.$getChildren('testStringTreeProvider', 'bb').then(children => assert.equal(children.length, 0))
 							]);
 						})
 				]);
@@ -109,7 +139,7 @@ suite('ExtHostTreeView', function () {
 			assert.equal(undefined, actuals);
 			done();
 		});
-		onDidChangeTreeData.fire();
+		onDidChangeTreeNode.fire();
 	});
 
 	test('refresh a parent node', () => {
@@ -122,7 +152,7 @@ suite('ExtHostTreeView', function () {
 				});
 				c(null);
 			});
-			onDidChangeTreeData.fire('b');
+			onDidChangeTreeNode.fire(getNode('b'));
 		});
 	});
 
@@ -136,7 +166,7 @@ suite('ExtHostTreeView', function () {
 			});
 			done();
 		});
-		onDidChangeTreeData.fire('bb');
+		onDidChangeTreeNode.fire(getNode('bb'));
 	});
 
 	test('refresh parent and child node trigger refresh only on parent - scenario 1', function (done) {
@@ -153,9 +183,9 @@ suite('ExtHostTreeView', function () {
 			});
 			done();
 		});
-		onDidChangeTreeData.fire('b');
-		onDidChangeTreeData.fire('aa');
-		onDidChangeTreeData.fire('bb');
+		onDidChangeTreeNode.fire(getNode('b'));
+		onDidChangeTreeNode.fire(getNode('aa'));
+		onDidChangeTreeNode.fire(getNode('bb'));
 	});
 
 	test('refresh parent and child node trigger refresh only on parent - scenario 2', function (done) {
@@ -172,9 +202,9 @@ suite('ExtHostTreeView', function () {
 			});
 			done();
 		});
-		onDidChangeTreeData.fire('bb');
-		onDidChangeTreeData.fire('aa');
-		onDidChangeTreeData.fire('b');
+		onDidChangeTreeNode.fire(getNode('bb'));
+		onDidChangeTreeNode.fire(getNode('aa'));
+		onDidChangeTreeNode.fire(getNode('b'));
 	});
 
 	test('refresh an element for label change', function (done) {
@@ -187,7 +217,7 @@ suite('ExtHostTreeView', function () {
 			});
 			done();
 		});
-		onDidChangeTreeData.fire('a');
+		onDidChangeTreeNode.fire(getNode('a'));
 	});
 
 	test('refresh calls are throttled on roots', function (done) {
@@ -195,10 +225,10 @@ suite('ExtHostTreeView', function () {
 			assert.equal(undefined, actuals);
 			done();
 		});
-		onDidChangeTreeData.fire();
-		onDidChangeTreeData.fire();
-		onDidChangeTreeData.fire();
-		onDidChangeTreeData.fire();
+		onDidChangeTreeNode.fire();
+		onDidChangeTreeNode.fire();
+		onDidChangeTreeNode.fire();
+		onDidChangeTreeNode.fire();
 	});
 
 	test('refresh calls are throttled on elements', function (done) {
@@ -207,10 +237,10 @@ suite('ExtHostTreeView', function () {
 			done();
 		});
 
-		onDidChangeTreeData.fire('a');
-		onDidChangeTreeData.fire('b');
-		onDidChangeTreeData.fire('b');
-		onDidChangeTreeData.fire('a');
+		onDidChangeTreeNode.fire(getNode('a'));
+		onDidChangeTreeNode.fire(getNode('b'));
+		onDidChangeTreeNode.fire(getNode('b'));
+		onDidChangeTreeNode.fire(getNode('a'));
 	});
 
 	test('refresh calls are throttled on unknown elements', function (done) {
@@ -219,10 +249,10 @@ suite('ExtHostTreeView', function () {
 			done();
 		});
 
-		onDidChangeTreeData.fire('a');
-		onDidChangeTreeData.fire('b');
-		onDidChangeTreeData.fire('g');
-		onDidChangeTreeData.fire('a');
+		onDidChangeTreeNode.fire(getNode('a'));
+		onDidChangeTreeNode.fire(getNode('b'));
+		onDidChangeTreeNode.fire(getNode('g'));
+		onDidChangeTreeNode.fire(getNode('a'));
 	});
 
 	test('refresh calls are throttled on unknown elements and root', function (done) {
@@ -231,10 +261,10 @@ suite('ExtHostTreeView', function () {
 			done();
 		});
 
-		onDidChangeTreeData.fire('a');
-		onDidChangeTreeData.fire('b');
-		onDidChangeTreeData.fire('g');
-		onDidChangeTreeData.fire('');
+		onDidChangeTreeNode.fire(getNode('a'));
+		onDidChangeTreeNode.fire(getNode('b'));
+		onDidChangeTreeNode.fire(getNode('g'));
+		onDidChangeTreeNode.fire();
 	});
 
 	test('refresh calls are throttled on elements and root', function (done) {
@@ -243,10 +273,10 @@ suite('ExtHostTreeView', function () {
 			done();
 		});
 
-		onDidChangeTreeData.fire('a');
-		onDidChangeTreeData.fire('b');
-		onDidChangeTreeData.fire();
-		onDidChangeTreeData.fire('a');
+		onDidChangeTreeNode.fire(getNode('a'));
+		onDidChangeTreeNode.fire(getNode('b'));
+		onDidChangeTreeNode.fire();
+		onDidChangeTreeNode.fire(getNode('a'));
 	});
 
 	test('generate unique handles from labels by escaping them', () => {
@@ -254,9 +284,9 @@ suite('ExtHostTreeView', function () {
 			'a/0:b': {}
 		};
 
-		onDidChangeTreeData.fire();
+		onDidChangeTreeNode.fire();
 
-		return testObject.$getElements('testDataProvider')
+		return testObject.$getElements('testNodeTreeProvider')
 			.then(elements => {
 				assert.deepEqual(elements.map(e => e.handle), ['0/0:a//0:b']);
 			});
@@ -272,42 +302,70 @@ suite('ExtHostTreeView', function () {
 		return result;
 	}
 
-	function aTreeDataProvider(): TreeDataProvider<string> {
-		const getTreeElement = (element) => {
-			let parent = tree;
-			for (let i = 0; i < element.length; i++) {
-				parent = parent[element.substring(0, i + 1)];
-				if (!parent) {
-					return null;
-				}
-			}
-			return parent;
+	function aNodeTreeDataProvider(): TreeDataProvider<{ key: string }> {
+		return {
+			getChildren: (element: { key: string }): { key: string }[] => {
+				return getChildren(element ? element.key : undefined).map(key => getNode(key));
+			},
+			getTreeItem: (element: { key: string }): TreeItem => {
+				return getTreeItem(element.key);
+			},
+			onDidChangeTreeData: onDidChangeTreeNode.event
 		};
+	}
+
+	function aStringTreeDataProvider(): TreeDataProvider<string> {
 		return {
 			getChildren: (element: string): string[] => {
-				if (!element) {
-					return Object.keys(tree);
-				}
-				let treeElement = getTreeElement(element);
-				if (treeElement) {
-					const children = Object.keys(treeElement);
-					const collapsibleStateIndex = children.indexOf('collapsibleState');
-					if (collapsibleStateIndex !== -1) {
-						children.splice(collapsibleStateIndex, 1);
-					}
-					return children;
-				}
-				return [];
+				return getChildren(element);
 			},
 			getTreeItem: (element: string): TreeItem => {
-				const treeElement = getTreeElement(element);
-				return {
-					label: labels[element] || element,
-					collapsibleState: treeElement ? treeElement['collapsibleState'] : TreeItemCollapsibleState.Collapsed
-				};
+				return getTreeItem(element);
 			},
-			onDidChangeTreeData: onDidChangeTreeData.event
+			onDidChangeTreeData: onDidChangeTreeKey.event
+		};
+	}
+
+	function getTreeElement(element): any {
+		let parent = tree;
+		for (let i = 0; i < element.length; i++) {
+			parent = parent[element.substring(0, i + 1)];
+			if (!parent) {
+				return null;
+			}
+		}
+		return parent;
+	}
+
+	function getChildren(key: string): string[] {
+		if (!key) {
+			return Object.keys(tree);
+		}
+		let treeElement = getTreeElement(key);
+		if (treeElement) {
+			const children = Object.keys(treeElement);
+			const collapsibleStateIndex = children.indexOf('collapsibleState');
+			if (collapsibleStateIndex !== -1) {
+				children.splice(collapsibleStateIndex, 1);
+			}
+			return children;
+		}
+		return [];
+	}
+
+	function getTreeItem(key: string): TreeItem {
+		const treeElement = getTreeElement(key);
+		return {
+			label: labels[key] || key,
+			collapsibleState: treeElement ? treeElement['collapsibleState'] : TreeItemCollapsibleState.Collapsed
 		};
 	}
 
+	function getNode(key: string): { key: string } {
+		if (!nodes[key]) {
+			nodes[key] = { key };
+		}
+		return nodes[key];
+	}
+
 });