@codingame/monaco-vscode-testing-service-override 2.0.3 → 2.1.0

package/vscode/src/vs/workbench/contrib/testing/browser/testCoverageView.js

@@ -1,36 +1,48 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { append, $ } from 'vscode/vscode/vs/base/browser/dom';
+import { assertNever } from 'vscode/vscode/vs/base/common/assert';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { memoize } from 'vscode/vscode/vs/base/common/decorators';
 import { createMatches } from 'vscode/vscode/vs/base/common/filters';
 import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
 import { DisposableStore, MutableDisposable, Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { basenameOrAuthority } from 'vscode/vscode/vs/base/common/resources';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { Position } from 'vscode/vscode/vs/editor/common/core/position';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { localize2WithPath, localizeWithPath } from 'vscode/vscode/vs/nls';
+import { registerAction2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
 import { EditorOpenSource } from 'vscode/vscode/vs/platform/editor/common/editor';
 import { FileKind } from 'vscode/vscode/vs/platform/files/common/files';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
 import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
-import { WorkbenchCompressibleAsyncDataTree } from 'vscode/vscode/vs/platform/list/browser/listService';
+import { WorkbenchCompressibleObjectTree } from 'vscode/vscode/vs/platform/list/browser/listService';
 import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
 import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
 import { ResourceLabels } from 'vscode/vscode/vs/workbench/browser/labels';
-import { ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { ViewAction, ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
 import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { testingWasCovered, testingStatesToIcons } from './icons.js';
 import { ManagedTestCoverageBars } from './testCoverageBars.js';
-import { FileCoverage } from 'vscode/vscode/vs/workbench/contrib/testing/common/testCoverage';
+import { FileCoverage, getTotalCoveragePercent } from 'vscode/vscode/vs/workbench/contrib/testing/common/testCoverage';
 import { ITestCoverageService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testCoverageService';
 import { SIDE_GROUP, ACTIVE_GROUP, IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { observableValue } from 'vscode/vscode/vs/base/common/observableInternal/base';
 import { autorun } from 'vscode/vscode/vs/base/common/observableInternal/autorun';
 
-var FileCoverageRenderer_1;
+var FileCoverageRenderer_1, FunctionCoverageRenderer_1;
 let TestCoverageView = class TestCoverageView extends ViewPane {
     constructor(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, coverageService) {
         super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
         this.coverageService = coverageService;
         this.tree = ( new MutableDisposable());
+        this.sortOrder = observableValue('sortOrder', 1 );
     }
     renderBody(container) {
         super.renderBody(container);
@@ -38,7 +50,7 @@ let TestCoverageView = class TestCoverageView extends ViewPane {
         this._register(autorun(reader => {
             const coverage = this.coverageService.selected.read(reader);
             if (coverage) {
-                const t = (this.tree.value ??= this.instantiationService.createInstance(TestCoverageTree, container, labels));
+                const t = (this.tree.value ??= this.instantiationService.createInstance(TestCoverageTree, container, labels, this.sortOrder));
                 t.setInput(coverage);
             }
             else {
@@ -63,17 +75,112 @@ TestCoverageView = ( __decorate([
     ( __param(9, ITelemetryService)),
     ( __param(10, ITestCoverageService))
 ], TestCoverageView));
-class TestCoverageInput {
-    constructor(coverage) {
-        this.tree = coverage.tree;
+let fnNodeId = 0;
+class FunctionCoverageNode {
+    get hits() {
+        return this.data.count;
+    }
+    get label() {
+        return this.data.name;
+    }
+    get location() {
+        return this.data.location;
+    }
+    get tpc() {
+        const attr = this.attributableCoverage();
+        return attr && getTotalCoveragePercent(attr.statement, attr.branch, undefined);
+    }
+    constructor(uri, data, details) {
+        this.uri = uri;
+        this.data = data;
+        this.id = String(fnNodeId++);
+        this.containedDetails = ( new Set());
+        this.children = [];
+        if (data.location instanceof Range) {
+            for (const detail of details) {
+                if (this.contains(detail.location)) {
+                    this.containedDetails.add(detail);
+                }
+            }
+        }
+    }
+    contains(location) {
+        const own = this.data.location;
+        return own instanceof Range && (location instanceof Range ? own.containsRange(location) : own.containsPosition(location));
+    }
+    attributableCoverage() {
+        const { location, count } = this.data;
+        if (!(location instanceof Range) || !count) {
+            return;
+        }
+        const statement = { covered: 0, total: 0 };
+        const branch = { covered: 0, total: 0 };
+        for (const detail of this.containedDetails) {
+            if (detail.type !== 1 ) {
+                continue;
+            }
+            statement.covered += detail.count > 0 ? 1 : 0;
+            statement.total++;
+            if (detail.branches) {
+                for (const { count } of detail.branches) {
+                    branch.covered += count > 0 ? 1 : 0;
+                    branch.total++;
+                }
+            }
+        }
+        return { statement, branch };
+    }
+}
+FunctionCoverageNode.__decorator = ( __decorate([
+    memoize
+], FunctionCoverageNode.prototype, "attributableCoverage", null));
+class RevealUncoveredFunctions {
+    get label() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testCoverageView',
+            'functionsWithoutCoverage',
+            "{0} functions without coverage...",
+            this.n
+        ));
+    }
+    constructor(n) {
+        this.n = n;
+        this.id = String(fnNodeId++);
+    }
+}
+class LoadingDetails {
+    constructor() {
+        this.id = String(fnNodeId++);
+        this.label = ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testCoverageView',
+            'loadingCoverageDetails',
+            "Loading Coverage Details..."
+        ));
     }
 }
-const isFileCoverage = (c) => 'value' in c;
-const isFunctionCoverage = (c) => 'type' in c && c.type === 0 ;
+const isFileCoverage = (c) => typeof c === 'object' && 'value' in c;
+const isFunctionCoverage = (c) => c instanceof FunctionCoverageNode;
+const shouldShowFunctionDetailsOnExpand = (c) => isFileCoverage(c) && c.value instanceof FileCoverage && !!c.value.function?.total;
 let TestCoverageTree = class TestCoverageTree extends Disposable {
-    constructor(container, labels, instantiationService, editorService) {
+    constructor(container, labels, sortOrder, instantiationService, editorService) {
         super();
-        this.tree = instantiationService.createInstance(WorkbenchCompressibleAsyncDataTree, 'TestCoverageView', container, ( new TestCoverageTreeListDelegate()), ( new TestCoverageCompressionDelegate()), [instantiationService.createInstance(FileCoverageRenderer, labels)], instantiationService.createInstance(TestCoverageDataSource), {
+        this.tree = instantiationService.createInstance(WorkbenchCompressibleObjectTree, 'TestCoverageView', container, ( new TestCoverageTreeListDelegate()), [
+            instantiationService.createInstance(FileCoverageRenderer, labels),
+            instantiationService.createInstance(FunctionCoverageRenderer),
+            instantiationService.createInstance(BasicRenderer),
+        ], {
+            expandOnlyOnTwistieClick: true,
+            sorter: ( new Sorter(sortOrder)),
+            keyboardNavigationLabelProvider: {
+                getCompressedNodeKeyboardNavigationLabel(elements) {
+                    return ( elements.map(e => this.getKeyboardNavigationLabel(e))).join('/');
+                },
+                getKeyboardNavigationLabel(e) {
+                    return isFileCoverage(e)
+                        ? basenameOrAuthority(e.value.uri)
+                        : e.label;
+                },
+            },
             accessibilityProvider: {
                 getAriaLabel(element) {
                     if (isFileCoverage(element)) {
@@ -86,7 +193,9 @@ let TestCoverageTree = class TestCoverageTree extends Disposable {
                             (element.value.tpc * 100).toFixed(2)
                         ));
                     }
-                    return element.name;
+                    else {
+                        return element.label;
+                    }
                 },
                 getWidgetAriaLabel() {
                     return ( localizeWithPath(
@@ -96,67 +205,158 @@ let TestCoverageTree = class TestCoverageTree extends Disposable {
                     ));
                 }
             },
-            autoExpandSingleChildren: true,
             identityProvider: ( new TestCoverageIdentityProvider()),
         });
+        this._register(autorun(reader => {
+            sortOrder.read(reader);
+            this.tree.resort(null, true);
+        }));
         this._register(this.tree);
+        this._register(this.tree.onDidChangeCollapseState(e => {
+            const el = e.node.element;
+            if (!e.node.collapsed && !e.node.children.length && el && shouldShowFunctionDetailsOnExpand(el)) {
+                if (el.value.hasSynchronousDetails) {
+                    this.tree.setChildren(el, [{ element: ( new LoadingDetails()), incompressible: true }]);
+                }
+                el.value.details().then(details => this.updateWithDetails(el, details));
+            }
+        }));
         this._register(this.tree.onDidOpen(e => {
             let resource;
-            if (e.element && isFileCoverage(e.element) && !e.element.children?.size) {
-                resource = e.element.value.uri;
+            let selection;
+            if (e.element) {
+                if (isFileCoverage(e.element) && !e.element.children?.size) {
+                    resource = e.element.value.uri;
+                }
+                else if (isFunctionCoverage(e.element)) {
+                    resource = e.element.uri;
+                    selection = e.element.location;
+                }
             }
             if (!resource) {
                 return;
             }
             editorService.openEditor({
                 resource,
-                options: { preserveFocus: e.editorOptions.preserveFocus, pinned: e.editorOptions.pinned, source: EditorOpenSource.USER }
+                options: {
+                    selection: selection instanceof Position ? Range.fromPositions(selection, selection) : selection,
+                    revealIfOpened: true,
+                    selectionRevealType: 3 ,
+                    preserveFocus: e.editorOptions.preserveFocus,
+                    pinned: e.editorOptions.pinned,
+                    source: EditorOpenSource.USER,
+                },
             }, e.sideBySide ? SIDE_GROUP : ACTIVE_GROUP);
         }));
     }
     setInput(coverage) {
-        this.tree.setInput(( new TestCoverageInput(coverage)));
+        const files = [];
+        for (let node of coverage.tree.nodes) {
+            while (!(node.value instanceof FileCoverage) && node.children?.size === 1) {
+                node = Iterable.first(( node.children.values()));
+            }
+            files.push(node);
+        }
+        const toChild = (file) => {
+            const isFile = !file.children?.size;
+            return {
+                element: file,
+                incompressible: isFile,
+                collapsed: isFile,
+                collapsible: !isFile || !!file.value?.function?.total,
+                children: file.children && ( Iterable.map(file.children?.values(), toChild))
+            };
+        };
+        this.tree.setChildren(null, ( Iterable.map(files, toChild)));
     }
     layout(height, width) {
         this.tree.layout(height, width);
     }
-};
-TestCoverageTree = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IEditorService))
-], TestCoverageTree));
-class TestCoverageDataSource {
-    hasChildren(element) {
-        return element instanceof TestCoverageInput || (isFileCoverage(element) && !!element.children?.size);
-    }
-    async getChildren(element) {
-        if (element instanceof TestCoverageInput) {
-            const files = [];
-            for (let node of element.tree.nodes) {
-                while (!(node.value instanceof FileCoverage) && node.children?.size === 1) {
-                    node = Iterable.first(( node.children.values()));
+    updateWithDetails(el, details) {
+        if (!this.tree.hasElement(el)) {
+            return;
+        }
+        const functions = [];
+        for (const fn of details) {
+            if (fn.type !== 0 ) {
+                continue;
+            }
+            let arr = functions;
+            while (true) {
+                const parent = arr.find(p => ( p.containedDetails.has(fn)));
+                if (parent) {
+                    arr = parent.children;
+                }
+                else {
+                    break;
                 }
-                files.push(node);
             }
-            return files;
-        }
-        if (isFileCoverage(element) && element.children) {
-            return ( element.children.values());
+            arr.push(( new FunctionCoverageNode(el.value.uri, fn, details)));
         }
-        return Iterable.empty();
-    }
-}
-class TestCoverageCompressionDelegate {
-    isIncompressible(element) {
-        return isFunctionCoverage(element) || !element.children?.size;
+        const makeChild = (fn) => ({
+            element: fn,
+            incompressible: true,
+            collapsed: true,
+            collapsible: fn.children.length > 0,
+            children: ( fn.children.map(makeChild))
+        });
+        this.tree.setChildren(el, ( functions.map(makeChild)));
     }
-}
+};
+TestCoverageTree = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IEditorService))
+], TestCoverageTree));
 class TestCoverageTreeListDelegate {
     getHeight(element) {
         return 22;
     }
-    getTemplateId(_element) {
-        return FileCoverageRenderer.ID;
+    getTemplateId(element) {
+        if (isFileCoverage(element)) {
+            return FileCoverageRenderer.ID;
+        }
+        if (isFunctionCoverage(element)) {
+            return FunctionCoverageRenderer.ID;
+        }
+        if (element instanceof LoadingDetails || element instanceof RevealUncoveredFunctions) {
+            return BasicRenderer.ID;
+        }
+        assertNever();
+    }
+}
+class Sorter {
+    constructor(order) {
+        this.order = order;
+    }
+    compare(a, b) {
+        const order = this.order.get();
+        if (isFileCoverage(a) && isFileCoverage(b)) {
+            switch (order) {
+                case 1 :
+                case 2 :
+                    return ( a.value.uri.toString()).localeCompare(( b.value.uri.toString()));
+                case 0 :
+                    return b.value.tpc - a.value.tpc;
+            }
+        }
+        else if (isFunctionCoverage(a) && isFunctionCoverage(b)) {
+            switch (order) {
+                case 1 :
+                    return Position.compare(a.location instanceof Range ? a.location.getStartPosition() : a.location, b.location instanceof Range ? b.location.getStartPosition() : b.location);
+                case 2 :
+                    return a.label.localeCompare(b.label);
+                case 0 : {
+                    const attrA = a.tpc;
+                    const attrB = b.tpc;
+                    return (attrA !== undefined && attrB !== undefined && attrB - attrA)
+                        || (b.hits - a.hits)
+                        || a.label.localeCompare(b.label);
+                }
+            }
+        }
+        else {
+            return 0;
+        }
     }
 }
 let FileCoverageRenderer = class FileCoverageRenderer {
@@ -206,10 +406,140 @@ FileCoverageRenderer = FileCoverageRenderer_1 = ( __decorate([
     ( __param(1, ILabelService)),
     ( __param(2, IInstantiationService))
 ], FileCoverageRenderer));
+let FunctionCoverageRenderer = class FunctionCoverageRenderer {
+    static { FunctionCoverageRenderer_1 = this; }
+    static { this.ID = 'N'; }
+    constructor(instantiationService) {
+        this.instantiationService = instantiationService;
+        this.templateId = FunctionCoverageRenderer_1.ID;
+    }
+    renderTemplate(container) {
+        const templateDisposables = ( new DisposableStore());
+        container.classList.add('test-coverage-list-item');
+        const icon = append(container, $('.state'));
+        const label = append(container, $('.name'));
+        return {
+            container,
+            bars: templateDisposables.add(this.instantiationService.createInstance(ManagedTestCoverageBars, { compact: false, container })),
+            templateDisposables,
+            icon,
+            label,
+        };
+    }
+    renderElement(node, _index, templateData) {
+        this.doRender(node.element, templateData, node.filterData);
+    }
+    renderCompressedElements(node, _index, templateData) {
+        this.doRender(node.element.elements[node.element.elements.length - 1], templateData, node.filterData);
+    }
+    disposeTemplate(templateData) {
+        templateData.templateDisposables.dispose();
+    }
+    doRender(element, templateData, _filterData) {
+        const covered = element.hits > 0;
+        const icon = covered ? testingWasCovered : testingStatesToIcons.get(0 );
+        templateData.container.classList.toggle('not-covered', !covered);
+        templateData.icon.className = `computed-state ${ThemeIcon.asClassName(icon)}`;
+        templateData.label.innerText = element.label;
+        templateData.bars.setCoverageInfo(element.attributableCoverage());
+    }
+};
+FunctionCoverageRenderer = FunctionCoverageRenderer_1 = ( __decorate([
+    ( __param(0, IInstantiationService))
+], FunctionCoverageRenderer));
+class BasicRenderer {
+    constructor() {
+        this.templateId = BasicRenderer.ID;
+    }
+    static { this.ID = 'B'; }
+    renderCompressedElements(node, _index, container) {
+        this.renderInner(node.element.elements[node.element.elements.length - 1], container);
+    }
+    renderTemplate(container) {
+        return container;
+    }
+    renderElement(node, index, container) {
+        this.renderInner(node.element, container);
+    }
+    disposeTemplate() {
+    }
+    renderInner(element, container) {
+        container.innerText = element.label;
+    }
+}
 class TestCoverageIdentityProvider {
     getId(element) {
-        return isFileCoverage(element) ? ( element.value.uri.toString()) : element.name;
+        return isFileCoverage(element)
+            ? ( element.value.uri.toString())
+            : element.id;
     }
 }
+registerAction2(class TestCoverageChangeSortingAction extends ViewAction {
+    constructor() {
+        super({
+            id: "testing.coverageViewChangeSorting" ,
+            viewId: "workbench.view.testCoverage" ,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/testing/browser/testCoverageView',
+                'testing.changeCoverageSort',
+                'Change Sort Order'
+            )),
+            icon: Codicon.sortPrecedence,
+            menu: {
+                id: MenuId.ViewTitle,
+                when: ( ContextKeyExpr.equals('view', "workbench.view.testCoverage" )),
+                group: 'navigation',
+            }
+        });
+    }
+    runInView(accessor, view) {
+        const disposables = ( new DisposableStore());
+        const quickInput = disposables.add(accessor.get(IQuickInputService).createQuickPick());
+        const items = [
+            { label: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testCoverageView',
+                'testing.coverageSortByLocation',
+                'Sort by Location'
+            )), value: 1 , description: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testCoverageView',
+                'testing.coverageSortByLocationDescription',
+                'Files are sorted alphabetically, functions are sorted by position'
+            )) },
+            { label: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testCoverageView',
+                'testing.coverageSortByCoverage',
+                'Sort by Coverage'
+            )), value: 0 , description: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testCoverageView',
+                'testing.coverageSortByCoverageDescription',
+                'Files and functions are sorted by total coverage'
+            )) },
+            { label: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testCoverageView',
+                'testing.coverageSortByName',
+                'Sort by Name'
+            )), value: 2 , description: ( localizeWithPath(
+                'vs/workbench/contrib/testing/browser/testCoverageView',
+                'testing.coverageSortByNameDescription',
+                'Files and functions are sorted alphabetically'
+            )) },
+        ];
+        quickInput.placeholder = ( localizeWithPath(
+            'vs/workbench/contrib/testing/browser/testCoverageView',
+            'testing.coverageSortPlaceholder',
+            'Sort the Test Coverage view...'
+        ));
+        quickInput.items = items;
+        quickInput.show();
+        quickInput.onDidHide(() => quickInput.dispose());
+        quickInput.onDidAccept(() => {
+            const picked = quickInput.selectedItems[0]?.value;
+            if (picked !== undefined) {
+                view.sortOrder.set(picked, undefined);
+                quickInput.dispose();
+            }
+        });
+    }
+});
 
 export { TestCoverageView };