more tree model tests

src/vs/base/browser/ui/list/treeModel.ts

@@ -5,7 +5,7 @@
 
 'use strict';
 
-import { ISpreadSpliceable } from './splice';
+import { ISpliceable } from 'vs/base/common/sequence';
 
 export interface ITreeElement<T> {
 	readonly element: T;
@@ -73,30 +73,32 @@ export class TreeModel<T> {
 
 	private root = TreeNode.createRoot<T>();
 
-	constructor(private spliceable: ISpreadSpliceable<ITreeNode<T>>) { }
+	constructor(private spliceable: ISpliceable<ITreeNode<T>>) { }
 
 	splice(start: number[], deleteCount: number, elements: ITreeElement<T>[]): void {
 		if (start.length === 0) {
 			throw new Error('Invalid tree location');
 		}
 
-		const { node, listIndex } = this.findNode(start, this.root, 0);
-		const { listDeleteCount, listElements } = node.splice(start[start.length - 1], deleteCount, elements);
+		const { parentNode, parentListIndex } = this.findParentNode(start, this.root, 0);
+		const lastIndex = start[start.length - 1];
+		const { listDeleteCount, listElements } = parentNode.splice(lastIndex, deleteCount, elements);
 
-		this.spliceable.splice(listIndex, listDeleteCount, ...listElements);
+		this.spliceable.splice(parentListIndex + lastIndex, listDeleteCount, listElements);
 	}
 
-	private findNode(location: number[], node: TreeNode<T>, listIndex: number): { node: TreeNode<T>; listIndex: number } {
-		const [i, ...rest] = location;
-
-		if (rest.length === 0) {
-			return { node, listIndex };
+	private findParentNode(location: number[], node: TreeNode<T>, listIndex: number): { parentNode: TreeNode<T>; parentListIndex: number } {
+		if (location.length === 1) {
+			return { parentNode: node, parentListIndex: listIndex };
 		}
 
-		for (let j = 0; j < i; j++) {
+		const [i, ...rest] = location;
+		const limit = Math.min(i, node.children.length);
+
+		for (let j = 0; j < limit; j++) {
 			listIndex += node.children[j].count;
 		}
 
-		return this.findNode(rest, node.children[i], listIndex);
+		return this.findParentNode(rest, node.children[i], listIndex + 1);
 	}
 }

src/vs/base/test/browser/ui/list/treeModel.test.ts

@@ -5,19 +5,28 @@
 
 import * as assert from 'assert';
 import { TreeModel, ITreeNode } from 'vs/base/browser/ui/list/treeModel';
+import { ISpliceable } from 'vs/base/browser/ui/list/splice';
+
+function toSpliceable<T>(arr: T[]): ISpliceable<T> {
+	return {
+		splice(start: number, deleteCount: number, elements: T[]): void {
+			arr.splice(start, deleteCount, ...elements);
+		}
+	};
+}
 
 suite('TreeModel2', () => {
 
 	test('ctor', () => {
 		const list = [] as ITreeNode<number>[];
-		const model = new TreeModel<number>(list);
+		const model = new TreeModel<number>(toSpliceable(list));
 		assert(model);
 		assert.equal(list.length, 0);
 	});
 
 	test('insert', () => {
 		const list = [] as ITreeNode<number>[];
-		const model = new TreeModel<number>(list);
+		const model = new TreeModel<number>(toSpliceable(list));
 
 		model.splice([0], 0, [
 			{ element: 0, children: [] },
@@ -36,7 +45,7 @@ suite('TreeModel2', () => {
 
 	test('deep insert', () => {
 		const list = [] as ITreeNode<number>[];
-		const model = new TreeModel<number>(list);
+		const model = new TreeModel<number>(toSpliceable(list));
 
 		model.splice([0], 0, [
 			{
@@ -67,7 +76,7 @@ suite('TreeModel2', () => {
 
 	test('delete', () => {
 		const list = [] as ITreeNode<number>[];
-		const model = new TreeModel<number>(list);
+		const model = new TreeModel<number>(toSpliceable(list));
 
 		model.splice([0], 0, [
 			{ element: 0, children: [] },
@@ -79,4 +88,60 @@ suite('TreeModel2', () => {
 
 		assert.equal(list.length, 0);
 	});
+
+	test('nested delete', () => {
+		const list = [] as ITreeNode<number>[];
+		const model = new TreeModel<number>(toSpliceable(list));
+
+		model.splice([0], 0, [
+			{
+				element: 0, children: [
+					{ element: 10, children: [] },
+					{ element: 11, children: [] },
+					{ element: 12, children: [] },
+				]
+			},
+			{ element: 1, children: [] },
+			{ element: 2, children: [] }
+		]);
+
+		model.splice([0, 1], 1, []);
+
+		assert.deepEqual(list.length, 5, 'list has 5 elements');
+		assert.deepEqual(list[0].element, 0);
+		assert.deepEqual(list[0].depth, 1);
+		assert.deepEqual(list[1].element, 10);
+		assert.deepEqual(list[1].depth, 2);
+		assert.deepEqual(list[2].element, 12);
+		assert.deepEqual(list[2].depth, 2);
+		assert.deepEqual(list[3].element, 1);
+		assert.deepEqual(list[3].depth, 1);
+		assert.deepEqual(list[4].element, 2);
+		assert.deepEqual(list[4].depth, 1);
+	});
+
+	test('deep delete', () => {
+		const list = [] as ITreeNode<number>[];
+		const model = new TreeModel<number>(toSpliceable(list));
+
+		model.splice([0], 0, [
+			{
+				element: 0, children: [
+					{ element: 10, children: [] },
+					{ element: 11, children: [] },
+					{ element: 12, children: [] },
+				]
+			},
+			{ element: 1, children: [] },
+			{ element: 2, children: [] }
+		]);
+
+		model.splice([0], 1, []);
+
+		assert.deepEqual(list.length, 2, 'list has 2 elements only');
+		assert.deepEqual(list[0].element, 1);
+		assert.deepEqual(list[0].depth, 1);
+		assert.deepEqual(list[1].element, 2);
+		assert.deepEqual(list[1].depth, 1);
+	});
 });
\ No newline at end of file