#13729

Committed 10 Feb 2025 06:43PM UTC coverage: 89.113% (+1.0%) from 88.149%

Build Type

push

Committed by

Commit Message

Language Server Rewrite (#993)

Run Details

7461 of 8823 branches covered (84.56%)

Branch coverage included in aggregate %.

1149 of 1263 new or added lines in 28 files covered. (90.97%)

23 existing lines in 5 files now uncovered.

9794 of 10540 relevant lines covered (92.92%)

1836.2 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.56

/src/BusyStatusTracker.ts

import { EventEmitter } from 'eventemitter3';
import { Deferred } from './deferred';

interface RunInfo<T> {
    label: string;
    startTime: Date;
    scope?: T;
    deferred?: Deferred;
}

/**
 * Tracks the busy/idle status of various sync or async tasks
 * Reports the overall status to the client
 */
export class BusyStatusTracker<T = any> {
    /**
     * @readonly
     */
    public activeRuns: Array<RunInfo<T>> = [];

    /**
     * Begin a busy task. It's expected you will call `endScopeRun` when the task is complete.
     * @param scope an object used for reference as to what is doing the work. Can be used to bulk-cancel all runs for a given scope.
     * @param label  label for the run. This is required for the `endScopedRun` method to know what to end.
     */
    public beginScopedRun(scope: T, label: string) {
        const deferred = new Deferred();

        const runInfo = {
            label: label,
            startTime: new Date(),
            deferred: deferred,
            scope: scope
        };

        void this._run(runInfo, () => {
            //don't mark the busy run as completed until the deferred is resolved
            return deferred.promise;
        });
    }

    /**
     * End the earliest run for the given scope and label
     * @param scope an object used for reference as to what is doing the work. Can be used to bulk-cancel all runs for a given scope.
     * @param label label for the run
     */
    public endScopedRun(scope: T, label: string) {
        const earliestRunIndex = this.activeRuns.findIndex(x => x.scope === scope && x.label === label);
        if (earliestRunIndex === -1) {
            return;
        }
        const earliestRun = this.activeRuns[earliestRunIndex];
        this.activeRuns.splice(earliestRunIndex, 1);
        earliestRun.deferred.resolve();
        return earliestRun.deferred.promise;
    }

    /**
     * End all runs for a given scope. This is typically used when the scope is destroyed, and we want to make sure all runs are cleaned up.
     * @param scope an object used for reference as to what is doing the work.
     */
    public endAllRunsForScope(scope: T) {
        for (let i = this.activeRuns.length - 1; i >= 0; i--) {
            const activeRun = this.activeRuns[i];
            if (activeRun.scope === scope) {
                //delete the active run
                this.activeRuns.splice(i, 1);
                //mark the run as resolved
                activeRun.deferred.resolve();
            }
        }
    }

    /**
     * Start a new piece of work
     */
    public run<A, R = A | Promise<A>>(callback: (finalize?: FinalizeBuildStatusRun) => R, label?: string): R {
        const run = {
            label: label,
            startTime: new Date()
        };
        return this._run<A, R>(run, callback);
    }

    private _run<A, R = A | Promise<A>>(runInfo: RunInfo<T>, callback: (finalize?: FinalizeBuildStatusRun) => R, label?: string): R {
        this.activeRuns.push(runInfo);

        if (this.activeRuns.length === 1) {
            this.emit('change', BusyStatus.busy);
        }
        this.emit('active-runs-change', { activeRuns: [...this.activeRuns] });

        let isFinalized = false;
        const finalizeRun = () => {
            if (isFinalized === false) {
                isFinalized = true;

                let idx = this.activeRuns.indexOf(runInfo);
                if (idx > -1) {
                    this.activeRuns.splice(idx, 1);
                }

                this.emit('active-runs-change', { activeRuns: [...this.activeRuns] });

                if (this.activeRuns.length <= 0) {
                    this.emit('change', BusyStatus.idle);
                }
            }
        };

        let result: R | PromiseLike<R>;
        //call the callback function
        try {
            result = callback(finalizeRun);
            //if the result is a promise, don't finalize until it completes
            if (typeof (result as any)?.then === 'function') {
                return Promise.resolve(result).finally(finalizeRun).then(() => result) as any;
            } else {
                finalizeRun();
                return result;
            }
        } catch (e) {
            finalizeRun();
            throw e;
        }
    }

    private emitter = new EventEmitter<string, BusyStatus>();

    public once(eventName: 'active-runs-change'): Promise<{ activeRuns: Array<RunInfo<T>> }>;
    public once(eventName: 'change'): Promise<BusyStatus>;
    public once<T>(eventName: string): Promise<T> {
        return new Promise<T>((resolve) => {
            const off = this.on(eventName as any, (data) => {
                off();
                resolve(data as any);
            });
        });
    }

    public on(eventName: 'active-runs-change', handler: (event: { activeRuns: Array<RunInfo<T>> }) => void);
    public on(eventName: 'change', handler: (status: BusyStatus) => void);
    public on(eventName: string, handler: (event: any) => void) {
        this.emitter.on(eventName, handler);
        return () => {
            this.emitter.off(eventName, handler);
        };
    }

    private emit(eventName: 'active-runs-change', event: { activeRuns: Array<RunInfo<T>> });
    private emit(eventName: 'change', status: BusyStatus);
    private emit(eventName: string, event: any) {
        this.emitter.emit(eventName, event);
    }

    public destroy() {
        this.emitter.removeAllListeners();
    }

    /**
     * The current status of the busy tracker.
     * @readonly
     */
    public get status() {
        return this.activeRuns.length === 0 ? BusyStatus.idle : BusyStatus.busy;
    }
}

export type FinalizeBuildStatusRun = (status?: BusyStatus) => void;

export enum BusyStatus {
    busy = 'busy',
    idle = 'idle'
}

1	import { EventEmitter } from 'eventemitter3';	1✔
2	import { Deferred } from './deferred';	1✔
3
4	interface RunInfo<T> {
5	label: string;
6	startTime: Date;
7	scope?: T;
8	deferred?: Deferred;
9	}
10
11	/**
12	* Tracks the busy/idle status of various sync or async tasks
13	* Reports the overall status to the client
14	*/
15	export class BusyStatusTracker<T = any> {	1✔
16	/**
17	* @readonly
18	*/
19	public activeRuns: Array<RunInfo<T>> = [];	157✔
20
21	/**
22	* Begin a busy task. It's expected you will call `endScopeRun` when the task is complete.
23	* @param scope an object used for reference as to what is doing the work. Can be used to bulk-cancel all runs for a given scope.
24	* @param label label for the run. This is required for the `endScopedRun` method to know what to end.
25	*/
26	public beginScopedRun(scope: T, label: string) {
27	const deferred = new Deferred();	97✔
28
29	const runInfo = {	97✔
30	label: label,
31	startTime: new Date(),
32	deferred: deferred,
33	scope: scope
34	};
35
36	void this._run(runInfo, () => {	97✔
37	//don't mark the busy run as completed until the deferred is resolved
38	return deferred.promise;	97✔
39	});
40	}
41
42	/**
43	* End the earliest run for the given scope and label
44	* @param scope an object used for reference as to what is doing the work. Can be used to bulk-cancel all runs for a given scope.
45	* @param label label for the run
46	*/
47	public endScopedRun(scope: T, label: string) {
48	const earliestRunIndex = this.activeRuns.findIndex(x => x.scope === scope && x.label === label);	128✔
49	if (earliestRunIndex === -1) {	91!
NEW 50	return;	×
51	}
52	const earliestRun = this.activeRuns[earliestRunIndex];	91✔
53	this.activeRuns.splice(earliestRunIndex, 1);	91✔
54	earliestRun.deferred.resolve();	91✔
55	return earliestRun.deferred.promise;	91✔
56	}
57
58	/**
59	* End all runs for a given scope. This is typically used when the scope is destroyed, and we want to make sure all runs are cleaned up.
60	* @param scope an object used for reference as to what is doing the work.
61	*/
62	public endAllRunsForScope(scope: T) {
63	for (let i = this.activeRuns.length - 1; i >= 0; i--) {	15✔
64	const activeRun = this.activeRuns[i];	10✔
65	if (activeRun.scope === scope) {	10✔
66	//delete the active run
67	this.activeRuns.splice(i, 1);	3✔
68	//mark the run as resolved
69	activeRun.deferred.resolve();	3✔
70	}
71	}
72	}
73
74	/**
75	* Start a new piece of work
76	*/
77	public run<A, R = A \| Promise<A>>(callback: (finalize?: FinalizeBuildStatusRun) => R, label?: string): R {
78	const run = {	296✔
79	label: label,
80	startTime: new Date()
81	};
82	return this._run<A, R>(run, callback);	296✔
83	}
84
85	private _run<A, R = A \| Promise<A>>(runInfo: RunInfo<T>, callback: (finalize?: FinalizeBuildStatusRun) => R, label?: string): R {
86	this.activeRuns.push(runInfo);	393✔
87
88	if (this.activeRuns.length === 1) {	393✔
89	this.emit('change', BusyStatus.busy);	223✔
90	}
91	this.emit('active-runs-change', { activeRuns: [...this.activeRuns] });	393✔
92
93	let isFinalized = false;	393✔
94	const finalizeRun = () => {	393✔
95	if (isFinalized === false) {	392✔
96	isFinalized = true;	390✔
97
98	let idx = this.activeRuns.indexOf(runInfo);	390✔
99	if (idx > -1) {	390✔
100	this.activeRuns.splice(idx, 1);	296✔
101	}
102
103	this.emit('active-runs-change', { activeRuns: [...this.activeRuns] });	390✔
104
105	if (this.activeRuns.length <= 0) {	390✔
106	this.emit('change', BusyStatus.idle);	223✔
107	}
108	}
109	};
110
111	let result: R \| PromiseLike<R>;
112	//call the callback function
113	try {	393✔
114	result = callback(finalizeRun);	393✔
115	//if the result is a promise, don't finalize until it completes
116	if (typeof (result as any)?.then === 'function') {	392✔
117	return Promise.resolve(result).finally(finalizeRun).then(() => result) as any;	380✔
118	} else {
119	finalizeRun();	12✔
120	return result;	12✔
121	}
122	} catch (e) {
123	finalizeRun();	1✔
124	throw e;	1✔
125	}
126	}
127
128	private emitter = new EventEmitter<string, BusyStatus>();	157✔
129
130	public once(eventName: 'active-runs-change'): Promise<{ activeRuns: Array<RunInfo<T>> }>;
131	public once(eventName: 'change'): Promise<BusyStatus>;
132	public once<T>(eventName: string): Promise<T> {
133	return new Promise<T>((resolve) => {	4✔
134	const off = this.on(eventName as any, (data) => {	4✔
135	off();	4✔
136	resolve(data as any);	4✔
137	});
138	});
139	}
140
141	public on(eventName: 'active-runs-change', handler: (event: { activeRuns: Array<RunInfo<T>> }) => void);
142	public on(eventName: 'change', handler: (status: BusyStatus) => void);
143	public on(eventName: string, handler: (event: any) => void) {
144	this.emitter.on(eventName, handler);	77✔
145	return () => {	77✔
146	this.emitter.off(eventName, handler);	5✔
147	};
148	}
149
150	private emit(eventName: 'active-runs-change', event: { activeRuns: Array<RunInfo<T>> });
151	private emit(eventName: 'change', status: BusyStatus);
152	private emit(eventName: string, event: any) {
153	this.emitter.emit(eventName, event);	1,229✔
154	}
155
156	public destroy() {
157	this.emitter.removeAllListeners();	15✔
158	}
159
160	/**
161	* The current status of the busy tracker.
162	* @readonly
163	*/
164	public get status() {
165	return this.activeRuns.length === 0 ? BusyStatus.idle : BusyStatus.busy;	431✔
166	}
167	}
168
169	export type FinalizeBuildStatusRun = (status?: BusyStatus) => void;
170
171	export enum BusyStatus {	1✔
172	busy = 'busy',	1✔
173	idle = 'idle'	1✔
174	}

rokucommunity / brighterscript / #13729

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous