#13176

Committed 11 Oct 2024 08:19PM UTC coverage: 89.045% (+0.8%) from 88.214%

Build Type

push

Committed by

Commit Message

Merge 1519a87aa into 024e9a454

Run Details

7209 of 8534 branches covered (84.47%)

Branch coverage included in aggregate %.

1064 of 1186 new or added lines in 28 files covered. (89.71%)

24 existing lines in 5 files now uncovered.

9617 of 10362 relevant lines covered (92.81%)

1781.61 hits per line

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

84.62

/src/lsp/DocumentManager.ts

import * as EventEmitter from 'eventemitter3';
import type { MaybePromise } from '../interfaces';
import util from '../util';

/**
 * Maintains a queued/buffered list of file operations. These operations don't actually do anything on their own.
 * You need to call the .apply() function and provide an action to operate on them.
 */
export class DocumentManager {

    constructor(
        private options: {
            delay: number;
            flushHandler?: (event: FlushEvent) => any;
        }) {
    }

    private queue = new Map<string, DocumentAction>();

    private timeoutHandle: NodeJS.Timeout;
    private throttle() {
        if (this.timeoutHandle) {
            clearTimeout(this.timeoutHandle);
        }
        this.timeoutHandle = setTimeout(() => {
            void this.flush();
        }, this.options.delay);
    }

    /**
     * Add/set the contents of a file
     */
    public set(options: { srcPath: string; fileContents?: string; allowStandaloneProject?: boolean }) {
        const srcPath = util.standardizePath(options.srcPath);
        if (this.queue.has(srcPath)) {
            this.queue.delete(srcPath);
        }
        this.queue.set(srcPath, {
            type: 'set',
            srcPath: srcPath,
            fileContents: options.fileContents,
            allowStandaloneProject: options.allowStandaloneProject ?? false
        });
        //schedule a future flush
        this.throttle();
    }

    /**
     * Delete a file or directory. If a directory is provided, all pending changes within that directory will be discarded
     * and only the delete action will be queued
     */
    public delete(srcPath: string) {
        srcPath = util.standardizePath(srcPath);
        //remove any pending action with this exact path
        this.queue.delete(srcPath);
        //we can't tell if this a directory, so just remove all pending changes for files that start with this path
        for (const key of this.queue.keys()) {
            if (key.startsWith(srcPath)) {
                this.queue.delete(key);
            }
        }
        //register this delete
        this.queue.set(srcPath, { type: 'delete', srcPath: srcPath });

        //schedule a future flush
        this.throttle();
    }

    private isFlushRunning = false;

    private async flush() {
        //if we're already running a flush, don't run another
        if (this.isFlushRunning) {
            return;
        }

        this.isFlushRunning = true;
        while (this.queue.size > 0) {
            try {
                const event: FlushEvent = {
                    actions: [...this.queue.values()]
                };
                this.queue.clear();
                await this.options.flushHandler?.(event);
            } catch (e) {
                console.error(e);
            }
        }
        this.emitSync('flush');
        this.isFlushRunning = false;
    }

    /**
     * Is the manager settled (i.e. no pending files, all files have been fully flushed)
     */
    public get isIdle() {
        return this.queue.size === 0 && this.isFlushRunning === false;
    }

    /**
     * Returns a promise that resolves when there are no pending files and no active flushes are running. Will immediately resolve if there are no files,
     * and will wait until files are flushed if there are files.
     */
    public async onIdle() {
        while (!this.isIdle) {
            await this.once('flush');
        }
    }

    public once(eventName: 'flush'): Promise<FlushEvent>;
    public once(eventName: string): Promise<any> {
        return new Promise((resolve) => {
            const off = this.on(eventName as any, (data) => {
                off();
                resolve(data);
            });
        });
    }

    public on(eventName: 'flush', handler: (data: any) => MaybePromise<void>);
    public on(eventName: string, handler: (...args: any[]) => MaybePromise<void>) {
        this.emitter.on(eventName, handler as any);
        return () => {
            this.emitter.removeListener(eventName, handler as any);
        };
    }

    private emitSync(eventName: 'flush');
    private emitSync(eventName: string, data?) {
        this.emitter.emit(eventName, data);
    }

    private emitter = new EventEmitter();

    public dispose() {
        this.queue = new Map();
        this.emitter.removeAllListeners();
    }
}

export interface SetDocumentAction {
    srcPath: string;
    type: 'set';
    allowStandaloneProject?: boolean;
    fileContents: string;
}
export interface DeleteDocumentAction {
    srcPath: string;
    type: 'delete';
    allowStandaloneProject?: boolean;
}

export type DocumentAction = SetDocumentAction | DeleteDocumentAction;
export type DocumentActionWithStatus = DocumentAction & { id: number; status: 'accepted' | 'rejected' };

export interface FlushEvent {
    actions: DocumentAction[];
}

1	import * as EventEmitter from 'eventemitter3';	1✔
2	import type { MaybePromise } from '../interfaces';
3	import util from '../util';	1✔
4
5	/**
6	* Maintains a queued/buffered list of file operations. These operations don't actually do anything on their own.
7	* You need to call the .apply() function and provide an action to operate on them.
8	*/
9	export class DocumentManager {	1✔
10
11	constructor(
12	private options: {	87✔
13	delay: number;
14	flushHandler?: (event: FlushEvent) => any;
15	}) {
16	}
17
18	private queue = new Map<string, DocumentAction>();	87✔
19
20	private timeoutHandle: NodeJS.Timeout;
21	private throttle() {
22	if (this.timeoutHandle) {	86✔
23	clearTimeout(this.timeoutHandle);	53✔
24	}
25	this.timeoutHandle = setTimeout(() => {	86✔
26	void this.flush();	42✔
27	}, this.options.delay);
28	}
29
30	/**
31	* Add/set the contents of a file
32	*/
33	public set(options: { srcPath: string; fileContents?: string; allowStandaloneProject?: boolean }) {
34	const srcPath = util.standardizePath(options.srcPath);	83✔
35	if (this.queue.has(srcPath)) {	83✔
36	this.queue.delete(srcPath);	6✔
37	}
38	this.queue.set(srcPath, {	83✔
39	type: 'set',
40	srcPath: srcPath,
41	fileContents: options.fileContents,
42	allowStandaloneProject: options.allowStandaloneProject ?? false	249✔
43	});
44	//schedule a future flush
45	this.throttle();	83✔
46	}
47
48	/**
49	* Delete a file or directory. If a directory is provided, all pending changes within that directory will be discarded
50	* and only the delete action will be queued
51	*/
52	public delete(srcPath: string) {
53	srcPath = util.standardizePath(srcPath);	3✔
54	//remove any pending action with this exact path
55	this.queue.delete(srcPath);	3✔
56	//we can't tell if this a directory, so just remove all pending changes for files that start with this path
57	for (const key of this.queue.keys()) {	3✔
NEW 58	if (key.startsWith(srcPath)) {	×
NEW 59	this.queue.delete(key);	×
60	}
61	}
62	//register this delete
63	this.queue.set(srcPath, { type: 'delete', srcPath: srcPath });	3✔
64
65	//schedule a future flush
66	this.throttle();	3✔
67	}
68
69	private isFlushRunning = false;	87✔
70
71	private async flush() {
72	//if we're already running a flush, don't run another
73	if (this.isFlushRunning) {	42!
NEW 74	return;	×
75	}
76
77	this.isFlushRunning = true;	42✔
78	while (this.queue.size > 0) {	42✔
79	try {	44✔
80	const event: FlushEvent = {	44✔
81	actions: [...this.queue.values()]
82	};
83	this.queue.clear();	44✔
84	await this.options.flushHandler?.(event);	44!
85	} catch (e) {
NEW 86	console.error(e);	×
87	}
88	}
89	this.emitSync('flush');	42✔
90	this.isFlushRunning = false;	42✔
91	}
92
93	/**
94	* Is the manager settled (i.e. no pending files, all files have been fully flushed)
95	*/
96	public get isIdle() {
97	return this.queue.size === 0 && this.isFlushRunning === false;	113✔
98	}
99
100	/**
101	* Returns a promise that resolves when there are no pending files and no active flushes are running. Will immediately resolve if there are no files,
102	* and will wait until files are flushed if there are files.
103	*/
104	public async onIdle() {
105	while (!this.isIdle) {	16✔
106	await this.once('flush');	11✔
107	}
108	}
109
110	public once(eventName: 'flush'): Promise<FlushEvent>;
111	public once(eventName: string): Promise<any> {
112	return new Promise((resolve) => {	11✔
113	const off = this.on(eventName as any, (data) => {	11✔
114	off();	11✔
115	resolve(data);	11✔
116	});
117	});
118	}
119
120	public on(eventName: 'flush', handler: (data: any) => MaybePromise<void>);
121	public on(eventName: string, handler: (...args: any[]) => MaybePromise<void>) {
122	this.emitter.on(eventName, handler as any);	11✔
123	return () => {	11✔
124	this.emitter.removeListener(eventName, handler as any);	11✔
125	};
126	}
127
128	private emitSync(eventName: 'flush');
129	private emitSync(eventName: string, data?) {
130	this.emitter.emit(eventName, data);	42✔
131	}
132
133	private emitter = new EventEmitter();	87✔
134
135	public dispose() {
NEW 136	this.queue = new Map();	×
NEW 137	this.emitter.removeAllListeners();	×
138	}
139	}
140
141	export interface SetDocumentAction {
142	srcPath: string;
143	type: 'set';
144	allowStandaloneProject?: boolean;
145	fileContents: string;
146	}
147	export interface DeleteDocumentAction {
148	srcPath: string;
149	type: 'delete';
150	allowStandaloneProject?: boolean;
151	}
152
153	export type DocumentAction = SetDocumentAction \| DeleteDocumentAction;
154	export type DocumentActionWithStatus = DocumentAction & { id: number; status: 'accepted' \| 'rejected' };
155
156	export interface FlushEvent {
157	actions: DocumentAction[];
158	}

rokucommunity / brighterscript / #13176

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