#13361

Committed 25 Nov 2024 08:56PM UTC coverage: 89.053% (+0.9%) from 88.164%

Build Type

push

Committed by

Commit Message

Merge 3ae8b7ca6 into bc54435b1

Run Details

7359 of 8712 branches covered (84.47%)

Branch coverage included in aggregate %.

1121 of 1237 new or added lines in 29 files covered. (90.62%)

24 existing lines in 5 files now uncovered.

9724 of 10471 relevant lines covered (92.87%)

1825.48 hits per line

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

84.75

/src/common/Sequencer.ts

import type { CancellationToken } from 'vscode-languageserver-protocol';
import { util } from '../util';
import { EventEmitter } from 'eventemitter3';

/**
 * Supports running a series of actions in sequence, either synchronously or asynchronously
 */
export class Sequencer {
    constructor(
        private options: {
            name: string;
            async?: boolean;
            cancellationToken?: CancellationToken;
            /**
             * The number of operations to run before registering a nexttick
             */
            minSyncDuration: number;
        }
    ) {

    }

    // eslint-disable-next-line @typescript-eslint/ban-types
    private actions: Array<{ args: any[]; func: Function }> = [];

    public forEach<T>(items: T[], func: (item: T) => any) {
        for (const item of items) {
            this.actions.push({
                args: [item],
                func: func
            });
        }
        return this;
    }

    private emitter = new EventEmitter();

    public onCancel(callback: () => void) {
        this.emitter.on('cancel', callback);
        return this;
    }

    public onComplete(callback: () => void) {
        this.emitter.on('complete', callback);
        return this;
    }

    public onSuccess(callback: () => void) {
        this.emitter.on('success', callback);
        return this;
    }

    public once(func: () => any) {
        this.actions.push({
            args: [],
            func: func
        });
        return this;
    }

    /**
     * Actually run the sequence
     */
    public run() {
        if (this.options?.async) {
            return this.runAsync();
        } else {
            return this.runSync();
        }
    }

    private async runAsync() {
        try {
            let start = Date.now();
            for (const action of this.actions) {
                //register a very short timeout between every action so we don't hog the CPU
                if (Date.now() - start > this.options.minSyncDuration) {
                    await util.sleep(1);
                    start = Date.now();
                }

                //if the cancellation token has asked us to cancel, then stop processing now
                if (this.options.cancellationToken?.isCancellationRequested) {
                    return this.handleCancel();
                }
                action.func(...action.args);
            }
            this.emitter.emit('success');
        } finally {
            this.emitter.emit('complete');
            this.dispose();
        }
    }

    private runSync() {
        try {
            for (const action of this.actions) {
                //if the cancellation token has asked us to cancel, then stop processing now
                if (this.options.cancellationToken.isCancellationRequested) {
                    return this.handleCancel();
                }
                action.func(...action.args);
            }
            this.emitter.emit('success');
        } finally {
            this.emitter.emit('complete');
            this.dispose();
        }
    }

    private handleCancel() {
        console.log(`Cancelling sequence ${this.options.name}`);
        this.emitter.emit('cancel');
    }

    private dispose() {
        this.emitter.removeAllListeners();
    }
}

1	import type { CancellationToken } from 'vscode-languageserver-protocol';
2	import { util } from '../util';	1✔
3	import { EventEmitter } from 'eventemitter3';	1✔
4
5	/**
6	* Supports running a series of actions in sequence, either synchronously or asynchronously
7	*/
8	export class Sequencer {	1✔
9	constructor(
10	private options: {	768✔
11	name: string;
12	async?: boolean;
13	cancellationToken?: CancellationToken;
14	/**
15	* The number of operations to run before registering a nexttick
16	*/
17	minSyncDuration: number;
18	}
19	) {
20
21	}
22
23	// eslint-disable-next-line @typescript-eslint/ban-types
24	private actions: Array<{ args: any[]; func: Function }> = [];	768✔
25
26	public forEach<T>(items: T[], func: (item: T) => any) {
27	for (const item of items) {	1,535✔
28	this.actions.push({	2,548✔
29	args: [item],
30	func: func
31	});
32	}
33	return this;	1,535✔
34	}
35
36	private emitter = new EventEmitter();	768✔
37
38	public onCancel(callback: () => void) {
39	this.emitter.on('cancel', callback);	767✔
40	return this;	767✔
41	}
42
43	public onComplete(callback: () => void) {
NEW 44	this.emitter.on('complete', callback);	×
NEW 45	return this;	×
46	}
47
48	public onSuccess(callback: () => void) {
49	this.emitter.on('success', callback);	767✔
50	return this;	767✔
51	}
52
53	public once(func: () => any) {
54	this.actions.push({	1,534✔
55	args: [],
56	func: func
57	});
58	return this;	1,534✔
59	}
60
61	/**
62	* Actually run the sequence
63	*/
64	public run() {
65	if (this.options?.async) {	768!
66	return this.runAsync();	115✔
67	} else {
68	return this.runSync();	653✔
69	}
70	}
71
72	private async runAsync() {
73	try {	115✔
74	let start = Date.now();	115✔
75	for (const action of this.actions) {	115✔
76	//register a very short timeout between every action so we don't hog the CPU
77	if (Date.now() - start > this.options.minSyncDuration) {	521!
NEW 78	await util.sleep(1);	×
NEW 79	start = Date.now();	×
80	}
81
82	//if the cancellation token has asked us to cancel, then stop processing now
83	if (this.options.cancellationToken?.isCancellationRequested) {	521!
NEW 84	return this.handleCancel();	×
85	}
86	action.func(...action.args);	521✔
87	}
88	this.emitter.emit('success');	114✔
89	} finally {
90	this.emitter.emit('complete');	115✔
91	this.dispose();	115✔
92	}
93	}
94
95	private runSync() {
96	try {	653✔
97	for (const action of this.actions) {	653✔
98	//if the cancellation token has asked us to cancel, then stop processing now
99	if (this.options.cancellationToken.isCancellationRequested) {	3,558✔
100	return this.handleCancel();	1✔
101	}
102	action.func(...action.args);	3,557✔
103	}
104	this.emitter.emit('success');	652✔
105	} finally {
106	this.emitter.emit('complete');	653✔
107	this.dispose();	653✔
108	}
109	}
110
111	private handleCancel() {
112	console.log(`Cancelling sequence ${this.options.name}`);	1✔
113	this.emitter.emit('cancel');	1✔
114	}
115
116	private dispose() {
117	this.emitter.removeAllListeners();	768✔
118	}
119	}

rokucommunity / brighterscript / #13361

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