@theia/core 1.46.1 → 1.47.0-next.0

package/src/browser/tree/tree-model.ts

@@ -99,21 +99,41 @@ export interface TreeModel extends Tree, TreeSelectionService, TreeExpansionServ
      */
     navigateBackward(): Promise<void>;
 
+    /**
+     * Selects the previous tree node, regardless of its selection or visibility state.
+     */
+    selectPrev(): void;
+
     /**
      * Selects the previous node relatively to the currently selected one. This method takes the expansion state of the tree into consideration.
      */
     selectPrevNode(type?: TreeSelection.SelectionType): void;
 
+    /**
+     * Returns the previous tree node, regardless of its selection or visibility state.
+     */
+    getPrevNode(node?: TreeNode): TreeNode | undefined;
+
     /**
      * Returns the previous selectable tree node.
      */
     getPrevSelectableNode(node?: TreeNode): SelectableTreeNode | undefined;
 
+    /**
+     * Selects the next tree node, regardless of its selection or visibility state.
+     */
+    selectNext(): void;
+
     /**
      * Selects the next node relatively to the currently selected one. This method takes the expansion state of the tree into consideration.
      */
     selectNextNode(type?: TreeSelection.SelectionType): void;
 
+    /**
+     * Returns the next tree node, regardless of its selection or visibility state.
+     */
+    getNextNode(node?: TreeNode): TreeNode | undefined;
+
     /**
      * Returns the next selectable tree node.
      */
@@ -294,6 +314,11 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         }
     }
 
+    selectPrev(): void {
+        const node = this.getPrevNode();
+        this.selectNodeIfSelectable(node);
+    }
+
     selectPrevNode(type: TreeSelection.SelectionType = TreeSelection.SelectionType.DEFAULT): void {
         const node = this.getPrevSelectableNode();
         if (node) {
@@ -301,6 +326,11 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         }
     }
 
+    getPrevNode(node: TreeNode | undefined = this.getFocusedNode()): TreeNode | undefined {
+        const iterator = this.createBackwardTreeIterator(node);
+        return iterator && this.doGetNode(iterator);
+    }
+
     getPrevSelectableNode(node: TreeNode | undefined = this.getFocusedNode()): SelectableTreeNode | undefined {
         if (!node) {
             return this.getNextSelectableNode(this.root);
@@ -309,6 +339,11 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         return iterator && this.doGetNextNode(iterator, this.isVisibleSelectableNode.bind(this));
     }
 
+    selectNext(): void {
+        const node = this.getNextNode();
+        this.selectNodeIfSelectable(node);
+    }
+
     selectNextNode(type: TreeSelection.SelectionType = TreeSelection.SelectionType.DEFAULT): void {
         const node = this.getNextSelectableNode();
         if (node) {
@@ -316,11 +351,28 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         }
     }
 
+    getNextNode(node: TreeNode | undefined = this.getFocusedNode()): TreeNode | undefined {
+        const iterator = this.createTreeIterator(node);
+        return iterator && this.doGetNode(iterator);
+    }
+
     getNextSelectableNode(node: TreeNode | undefined = this.getFocusedNode() ?? this.root): SelectableTreeNode | undefined {
         const iterator = this.createIterator(node);
         return iterator && this.doGetNextNode(iterator, this.isVisibleSelectableNode.bind(this));
     }
 
+    protected selectNodeIfSelectable(node: TreeNode | undefined): void {
+        if (SelectableTreeNode.is(node)) {
+            this.addSelection(node);
+        }
+    }
+
+    protected doGetNode(iterator: TreeIterator): TreeNode | undefined {
+        iterator.next();
+        const result = iterator.next();
+        return result.done ? undefined : result.value;
+    }
+
     protected doGetNextNode<T extends TreeNode>(iterator: TreeIterator, criterion: (node: TreeNode) => node is T): T | undefined {
         // Skip the first item. // TODO: clean this up, and skip the first item in a different way without loading everything.
         iterator.next();
@@ -338,6 +390,17 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         return SelectableTreeNode.isVisible(node);
     }
 
+    protected createBackwardTreeIterator(node: TreeNode | undefined): TreeIterator | undefined {
+        const { filteredNodes } = this.treeSearch;
+        if (filteredNodes.length === 0) {
+            return node ? new BottomUpTreeIterator(node!, { pruneCollapsed: false }) : undefined;
+        }
+        if (node && filteredNodes.indexOf(node) === -1) {
+            return undefined;
+        }
+        return Iterators.cycle(filteredNodes.slice().reverse(), node);
+    }
+
     protected createBackwardIterator(node: TreeNode | undefined): TreeIterator | undefined {
         const { filteredNodes } = this.treeSearch;
         if (filteredNodes.length === 0) {
@@ -349,6 +412,17 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         return Iterators.cycle(filteredNodes.slice().reverse(), node);
     }
 
+    protected createTreeIterator(node: TreeNode | undefined): TreeIterator | undefined {
+        const { filteredNodes } = this.treeSearch;
+        if (filteredNodes.length === 0) {
+            return node && new TopDownTreeIterator(node, { pruneCollapsed: false });
+        }
+        if (node && filteredNodes.indexOf(node) === -1) {
+            return undefined;
+        }
+        return Iterators.cycle(filteredNodes, node);
+    }
+
     protected createIterator(node: TreeNode | undefined): TreeIterator | undefined {
         const { filteredNodes } = this.treeSearch;
         if (filteredNodes.length === 0) {

package/src/browser/tree/tree-selectable.spec.ts

@@ -0,0 +1,152 @@
+// *****************************************************************************
+// Copyright (C) 2018 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { TreeNode } from './tree';
+import { TreeModel } from './tree-model';
+import { notEmpty } from '../../common/objects';
+import { expect } from 'chai';
+import { createTreeTestContainer } from './test/tree-test-container';
+import { SelectableTreeNode } from './tree-selection';
+import { MockSelectableTreeModel } from './test/mock-selectable-tree-model';
+import { ExpandableTreeNode } from './tree-expansion';
+
+describe('Selectable Tree', () => {
+    let model: TreeModel;
+    function assertNodeRetrieval(method: () => TreeNode | undefined, sequence: string[]): void {
+        for (const expectedNodeId of sequence) {
+            const actualNode = method();
+            const expectedNode = retrieveNode<SelectableTreeNode>(expectedNodeId);
+            expect(actualNode?.id).to.be.equal(expectedNode.id);
+            model.addSelection(expectedNode);
+        }
+    }
+    function assertNodeSelection(method: () => void, sequence: string[]): void {
+        for (const expectedNodeId of sequence) {
+            method();
+            const node = retrieveNode<SelectableTreeNode>(expectedNodeId);
+            expect(node.selected).to.be.true;
+        }
+    }
+    describe('Get and Set Next Nodes Methods', () => {
+        const uncollapsedSelectionOrder = ['1.1', '1.1.1', '1.1.2', '1.2', '1.2.1', '1.2.1.1', '1.2.1.2', '1.2.2', '1.2.3', '1.3'];
+        const collapsedSelectionOrder = ['1.1', '1.2', '1.2.1', '1.2.2', '1.2.3', '1.3'];
+        beforeEach(() => {
+            model = createTreeModel();
+            model.root = MockSelectableTreeModel.HIERARCHICAL_MOCK_ROOT();
+            model.addSelection(retrieveNode<SelectableTreeNode>('1'));
+
+        });
+        it('`getNextNode()` should select each node in sequence (uncollapsed)', done => {
+            assertNodeRetrieval(model.getNextNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getNextNode()` should select each node in sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeRetrieval(model.getNextNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getNextSelectableNode()` should select each node in sequence (uncollapsed)', done => {
+            assertNodeRetrieval(model.getNextSelectableNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getNextSelectableNode()` should select each node in sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeRetrieval(model.getNextSelectableNode.bind(model), collapsedSelectionOrder);
+            done();
+        });
+        it('`selectNext()` should select each node in sequence (uncollapsed)', done => {
+            assertNodeSelection(model.selectNext.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectNext()` should select each node in sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeSelection(model.selectNext.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectNextNode()` should select each node in sequence (uncollapsed)', done => {
+            assertNodeSelection(model.selectNextNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectNextNode()` should select each node in sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeSelection(model.selectNextNode.bind(model), collapsedSelectionOrder);
+            done();
+        });
+    });
+
+    describe('Get and Set Previous Nodes Methods', () => {
+        const uncollapsedSelectionOrder = ['1.2.3', '1.2.2', '1.2.1.2', '1.2.1.1', '1.2.1', '1.2', '1.1.2', '1.1.1', '1.1'];
+        const collapsedSelectionOrder = ['1.2.3', '1.2.2', '1.2.1', '1.2', '1.1'];
+        beforeEach(() => {
+            model = createTreeModel();
+            model.root = MockSelectableTreeModel.HIERARCHICAL_MOCK_ROOT();
+            model.addSelection(retrieveNode<SelectableTreeNode>('1.3'));
+        });
+        it('`getPrevNode()` should select each node in reverse sequence (uncollapsed)', done => {
+            assertNodeRetrieval(model.getPrevNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getPrevNode()` should select each node in reverse sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeRetrieval(model.getPrevNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getPrevSelectableNode()` should select each node in reverse sequence (uncollapsed)', done => {
+            assertNodeRetrieval(model.getPrevSelectableNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getPrevSelectableNode()` should select each node in reverse sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeRetrieval(model.getPrevSelectableNode.bind(model), collapsedSelectionOrder);
+            done();
+        });
+        it('`selectPrev()` should select each node in reverse sequence (uncollapsed)', done => {
+            assertNodeSelection(model.selectPrev.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectPrev()` should select each node in reverse sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeSelection(model.selectPrev.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectPrevNode()` should select each node in reverse sequence (uncollapsed)', done => {
+            assertNodeSelection(model.selectPrevNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectPrevNode()` should select each node in reverse sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeSelection(model.selectPrevNode.bind(model), collapsedSelectionOrder);
+            done();
+        });
+    });
+
+    const findNode = (id: string) => model.getNode(id);
+    function createTreeModel(): TreeModel {
+        const container = createTreeTestContainer();
+        return container.get(TreeModel);
+    }
+    function retrieveNode<T extends TreeNode>(id: string): Readonly<T> {
+        const readonlyNode: Readonly<T> = model.getNode(id) as T;
+        return readonlyNode;
+    }
+    function collapseNode(...ids: string[]): void {
+        ids.map(findNode).filter(notEmpty).filter(ExpandableTreeNode.is).forEach(node => {
+            model.collapseNode(node);
+            expect(node).to.have.property('expanded', false);
+        });
+    }
+
+});

package/src/common/disposable.spec.ts

@@ -14,8 +14,11 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { expect } from 'chai';
+import { expect, spy, use } from 'chai';
 import { DisposableCollection, Disposable } from './disposable';
+import * as spies from 'chai-spies';
+
+use(spies);
 
 describe('Disposables', () => {
     it('Is safe to use Disposable.NULL', () => {
@@ -26,4 +29,66 @@ describe('Disposables', () => {
         expect(collectionA.disposed, 'A should be disposed after being disposed.').to.be.true;
         expect(collectionB.disposed, 'B should not be disposed because A was disposed.').to.be.false;
     });
+
+    it('Collection is auto-pruned when an element is disposed', () => {
+        const onDispose = spy(() => { });
+        const elementDispose = () => { };
+
+        const collection = new DisposableCollection();
+        collection.onDispose(onDispose);
+
+        const disposable1 = Disposable.create(elementDispose);
+        collection.push(disposable1);
+        expect(collection['disposables']).to.have.lengthOf(1);
+
+        const disposable2 = Disposable.create(elementDispose);
+        collection.push(disposable2);
+        expect(collection['disposables']).to.have.lengthOf(2);
+
+        disposable1.dispose();
+        expect(collection['disposables']).to.have.lengthOf(1);
+        expect(onDispose).to.have.not.been.called();
+        expect(collection.disposed).is.false;
+
+        // Test that calling dispose on an already disposed element doesn't
+        // alter the collection state
+        disposable1.dispose();
+        expect(collection['disposables']).to.have.lengthOf(1);
+        expect(onDispose).to.have.not.been.called();
+        expect(collection.disposed).is.false;
+
+        disposable2.dispose();
+        expect(collection['disposables']).to.be.empty;
+        expect(collection.disposed).is.true;
+        expect(onDispose).to.have.been.called.once;
+    });
+
+    it('onDispose is only called once on actual disposal of elements', () => {
+        const onDispose = spy(() => { });
+        const elementDispose = spy(() => { });
+
+        const collection = new DisposableCollection();
+        collection.onDispose(onDispose);
+
+        // if the collection is empty 'onDispose' is not called
+        collection.dispose();
+        expect(onDispose).to.not.have.been.called();
+
+        // 'onDispose' is called because we actually dispose an element
+        collection.push(Disposable.create(elementDispose));
+        collection.dispose();
+        expect(elementDispose).to.have.been.called.once;
+        expect(onDispose).to.have.been.called.once;
+
+        // if the collection is empty 'onDispose' is not called and no further element is disposed
+        collection.dispose();
+        expect(elementDispose).to.have.been.called.once;
+        expect(onDispose).to.have.been.called.once;
+
+        // 'onDispose' is not called again even if we actually dispose an element
+        collection.push(Disposable.create(elementDispose));
+        collection.dispose();
+        expect(elementDispose).to.have.been.called.twice;
+        expect(onDispose).to.have.been.called.once;
+    });
 });

package/src/common/disposable.ts

@@ -47,6 +47,34 @@ Object.defineProperty(Disposable, 'NULL', {
     }
 });
 
+/**
+ * Utility for tracking a collection of Disposable objects.
+ *
+ * This utility provides a number of benefits over just using an array of
+ * Disposables:
+ *
+ * - the collection is auto-pruned when an element it contains is disposed by
+ * any code that has a reference to it
+ * - you can register to be notified when all elements in the collection have
+ * been disposed [1]
+ * - you can conveniently dispose all elements by calling dispose()
+ * on the collection
+ *
+ * Unlike an array, however, this utility does not give you direct access to
+ * its elements.
+ *
+ * Being notified when all elements are disposed is simple:
+ * ```
+ * const dc = new DisposableCollection(myDisposables);
+ * dc.onDispose(() => {
+ *    console.log('All elements in the collection have been disposed');
+ * });
+ * ```
+ *
+ * [1] The collection will notify only once. It will continue to function in so
+ * far as accepting new Disposables and pruning them when they are disposed, but
+ * such activity will never result in another notification.
+ */
 export class DisposableCollection implements Disposable {
 
     protected readonly disposables: Disposable[] = [];

package/src/common/quick-pick-service.ts

@@ -191,7 +191,7 @@ export interface QuickPick<T extends QuickPickItemOrSeparator> extends QuickInpu
     readonly onDidAccept: Event<{ inBackground: boolean } | undefined>;
     readonly onDidChangeValue: Event<string>;
     readonly onDidTriggerButton: Event<QuickInputButton>;
-    readonly onDidTriggerItemButton: Event<QuickPickItemButtonEvent<T>>;
+    readonly onDidTriggerItemButton: Event<QuickPickItemButtonEvent<QuickPickItem>>;
     readonly onDidChangeActive: Event<T[]>;
     readonly onDidChangeSelection: Event<T[]>;
 }

package/src/common/reference.ts

@@ -22,6 +22,50 @@ export interface Reference<T> extends Disposable {
     readonly object: T
 }
 
+/**
+ * Abstract class for a map of reference-counted disposable objects, with the
+ * following features:
+ *
+ *    - values are not inserted explicitly; instead, acquire() is used to
+ *      create the value for a given key, or return the previously created
+ *      value for it. How the value is created for a given key is
+ *      implementation specific.
+ *
+ *    - any subsquent acquire() with the same key will bump the reference
+ *      count on that value. acquire() returns not the value directly but
+ *      a reference object that holds the value. Calling dispose() on the
+ *      reference decreases the value's effective reference count.
+ *
+ *    - a contained value will have its dispose() function called when its
+ *      reference count reaches zero. The key/value pair will be purged
+ *      from the collection.
+ *
+ *    - calling dispose() on the value directly, instead of calling it on
+ *      the reference returned by acquire(), will automatically dispose
+ *      all outstanding references to that value and the key/value pair
+ *      will be purged from the collection.
+ *
+ *    - supports synchronous and asynchronous implementations. acquire() will
+ *      return a Promise if the value cannot be created immediately
+ *
+ *    - functions has|keys|values|get are always synchronous and the result
+ *      excludes asynchronous additions in flight.
+ *
+ *    - functions values|get return the value directly and not a reference
+ *      to the value. Use these functions to obtain a value without bumping
+ *      its reference count.
+ *
+ *    - clients can register to be notified when values are added and removed;
+ *      notification for asynchronous additions happen when the creation
+ *      completes, not when it's requested.
+ *
+ *    - keys can be any value/object that can be successfully stringified using
+ *      JSON.stringify(), sans arguments
+ *
+ *    - calling dispose() on the collection will dispose all outstanding
+ *      references to all contained values, which results in the disposal of
+ *      the values themselves.
+ */
 export abstract class AbstractReferenceCollection<K, V extends Disposable> implements Disposable {
 
     protected readonly _keys = new Map<string, K>();
@@ -108,6 +152,12 @@ export abstract class AbstractReferenceCollection<K, V extends Disposable> imple
 
 }
 
+/**
+ * Asynchronous implementation of AbstractReferenceCollection that requires
+ * the client to provide a value factory, used to service the acquire()
+ * function. That factory may return a Promise if the value cannot be
+ * created immediately.
+ */
 export class ReferenceCollection<K, V extends Disposable> extends AbstractReferenceCollection<K, V> {
 
     constructor(protected readonly factory: (key: K) => MaybePromise<V>) {
@@ -148,6 +198,11 @@ export class ReferenceCollection<K, V extends Disposable> extends AbstractRefere
 
 }
 
+/**
+ * Synchronous implementation of AbstractReferenceCollection that requires
+ * the client to provide a value factory, used to service the acquire()
+ * function.
+ */
 export class SyncReferenceCollection<K, V extends Disposable> extends AbstractReferenceCollection<K, V> {
 
     constructor(protected readonly factory: (key: K) => V) {

package/src/electron-browser/messaging/electron-messaging-frontend-module.ts

@@ -23,7 +23,7 @@ import { ElectronFrontendIdProvider } from './electron-frontend-id-provider';
 import { FrontendIdProvider } from '../../browser/messaging/frontend-id-provider';
 import { ConnectionSource } from '../../browser/messaging/connection-source';
 import { LocalConnectionProvider, RemoteConnectionProvider, ServiceConnectionProvider } from '../../browser/messaging/service-connection-provider';
-import { WebSocketConnectionProvider } from '../../browser';
+import { WebSocketConnectionProvider } from '../../browser/messaging/ws-connection-provider';
 import { ConnectionCloseService, connectionCloseServicePath } from '../../common/messaging/connection-management';
 import { WebSocketConnectionSource } from '../../browser/messaging/ws-connection-source';