#12881

Committed 31 Jul 2024 10:28AM UTC coverage: 86.176% (-2.6%) from 88.769%

Build Type

push

Committed by

Commit Message

Merge 4b0283eea into 7a40b6493

Run Details

10582 of 13072 branches covered (80.95%)

Branch coverage included in aggregate %.

7 of 7 new or added lines in 2 files covered. (100.0%)

903 existing lines in 45 files now uncovered.

12289 of 13468 relevant lines covered (91.25%)

26729.06 hits per line

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

86.96

/src/DependencyGraph.ts

import { EventEmitter } from 'eventemitter3';
/**
 * A graph of files and their dependencies.
 * Each file will only contain nodes that they directly reference (i.e. script imports, inheritance, etc)
 */
export class DependencyGraph {
    /**
     * A dictionary of all unique nodes in the entire graph
     */
    public nodes = {} as Record<string, Node>;

    /**
     * An internal event emitter for when keys have changed.
     */
    private onchangeEmitter = new EventEmitter<string, DependencyChangedEvent>();

    /**
     * Add a node to the graph.
     */
    public addOrReplace(key: string, dependencies?: string[]) {
        //sort the dependencies
        dependencies = dependencies?.sort() ?? [];

        //dispose any existing node
        this.nodes[key]?.dispose();

        //create a new dependency node
        let node = new Node(key, dependencies, this);
        this.nodes[key] = node;
        this.emit(key, { sourceKey: key, notifiedKeys: new Set() });
    }

    /**
     * Add a new dependency to an existing node (or create a new node if the node doesn't exist
     */
    public addDependency(key: string, dependencyKey: string) {
        let existingNode = this.nodes[key];
        if (existingNode) {
            let dependencies = existingNode.dependencies.includes(dependencyKey) ? existingNode.dependencies : [dependencyKey, ...existingNode.dependencies];
            this.addOrReplace(key, dependencies);
        } else {
            this.addOrReplace(key, [dependencyKey]);
        }
    }

    /**
     * Remove a dependency from an existing node.
     * Do nothing if the node does not have that dependency.
     * Do nothing if that node does not exist
     */
    public removeDependency(key: string, dependencyKey: string) {
        let existingNode = this.nodes[key];
        let idx = (existingNode?.dependencies ?? []).indexOf(dependencyKey);
        if (existingNode && idx > -1) {
            existingNode.dependencies.splice(idx, 1);
            this.addOrReplace(key, existingNode.dependencies);
        }
    }

    /**
     * Get a list of the dependencies for the given key, recursively.
     * @param keys the key (or keys) for which to get the dependencies
     * @param exclude a list of keys to exclude from traversal. Anytime one of these nodes is encountered, it is skipped.
     */
    public getAllDependencies(keys: string | string[], exclude?: string[]) {
        if (typeof keys === 'string') {
            return this.nodes[keys]?.getAllDependencies(exclude) ?? [];
        } else {
            const set = new Set<string>();
            for (const key of keys) {
                const dependencies = this.getAllDependencies(key, exclude);
                for (const dependency of dependencies) {
                    set.add(dependency);
                }
            }
            return [...set];
        }
    }

    /**
     * Get a list of the immediate dependencies for the given key.
     */
    public getImmediateDependencies(keys: string | string[], exclude?: string[]) {
        if (typeof keys === 'string') {
            return this.nodes[keys]?.dependencies ?? [];
        } else {
            const set = new Set<string>();
            for (const key of keys) {
                const dependencies = this.getImmediateDependencies(key, exclude);
                for (const dependency of dependencies) {
                    set.add(dependency);
                }
            }
            return [...set];
        }
    }

    /**
     * Remove the item. This will emit an onchange event for all dependent nodes
     */
    public remove(key: string) {
        this.nodes[key]?.dispose();
        delete this.nodes[key];
        this.emit(key, { sourceKey: key, notifiedKeys: new Set() });
    }

    /**
     * Emit event that this item has changed
     */
    public emit(key: string, event: DependencyChangedEvent) {
        //prevent infinite event loops by skipping already-notified keys
        if (!event.notifiedKeys.has(key)) {
            event.notifiedKeys.add(key);
            this.onchangeEmitter.emit(key, event);
        }
    }

    /**
     * Listen for any changes to dependencies with the given key.
     * @param key the name of the dependency
     * @param handler a function called anytime changes occur
     */
    public onchange(key: string, handler: (event: DependencyChangedEvent) => void) {
        this.onchangeEmitter.on(key, handler);
        return () => {
            this.onchangeEmitter.off(key, handler);
        };
    }

    public dispose() {
        for (let key in this.nodes) {
            let node = this.nodes[key];
            node.dispose();
        }
        this.onchangeEmitter.removeAllListeners();
    }
}

export interface DependencyChangedEvent {
    /**
     * The key that was the initiator of this event. Child keys will emit this same event object, but this key will remain the same
     */
    sourceKey: string;
    /**
     * A set of keys that have already been notified of this change. Used to prevent circular reference notification cycles
     */
    notifiedKeys: Set<string>;
}

export class Node {
    public constructor(
        public key: string,
        public dependencies: string[],
        public graph: DependencyGraph
    ) {
        if (dependencies.length > 0) {
            this.subscriptions = [];

            for (let dependency of this.dependencies) {
                let sub = this.graph.onchange(dependency, (event) => {
                    //notify the graph that we changed since one of our dependencies changed
                    this.graph.emit(this.key, event);
                });

                this.subscriptions.push(sub);
            }
        }
    }

    private subscriptions: Array<() => void> | undefined;

    /**
     * Return the full list of unique dependencies for this node by traversing all descendents
     * @param exclude a list of keys to exclude from traversal. Anytime one of these nodes is encountered, it is skipped.
     */
    public getAllDependencies(exclude: string[] = []) {
        let dependencyMap = {};
        let dependencyStack = [...this.dependencies];
        //keep walking the dependency graph until we run out of unseen dependencies
        while (dependencyStack.length > 0) {
            let dependency = dependencyStack.pop();

            //if this is a new dependency and we aren't supposed to skip it
            if (dependency && !dependencyMap[dependency] && !exclude.includes(dependency)) {
                dependencyMap[dependency] = true;

                //get the node for this dependency
                let node = this.graph.nodes[dependency];
                if (node) {
                    dependencyStack.push(...node.dependencies);
                }
            }
        }
        return Object.keys(dependencyMap);
    }

    public dispose() {
        for (let unsubscribe of this.subscriptions ?? []) {
            unsubscribe();
        }
    }
}

1	import { EventEmitter } from 'eventemitter3';	1✔
2	/**
3	* A graph of files and their dependencies.
4	* Each file will only contain nodes that they directly reference (i.e. script imports, inheritance, etc)
5	*/
6	export class DependencyGraph {	1✔
7	/**
8	* A dictionary of all unique nodes in the entire graph
9	*/
10	public nodes = {} as Record<string, Node>;	1,564✔
11
12	/**
13	* An internal event emitter for when keys have changed.
14	*/
15	private onchangeEmitter = new EventEmitter<string, DependencyChangedEvent>();	1,564✔
16
17	/**
18	* Add a node to the graph.
19	*/
20	public addOrReplace(key: string, dependencies?: string[]) {
21	//sort the dependencies
22	dependencies = dependencies?.sort() ?? [];	4,259✔
23
24	//dispose any existing node
25	this.nodes[key]?.dispose();	4,259✔
26
27	//create a new dependency node
28	let node = new Node(key, dependencies, this);	4,259✔
29	this.nodes[key] = node;	4,259✔
30	this.emit(key, { sourceKey: key, notifiedKeys: new Set() });	4,259✔
31	}
32
33	/**
34	* Add a new dependency to an existing node (or create a new node if the node doesn't exist
35	*/
36	public addDependency(key: string, dependencyKey: string) {
37	let existingNode = this.nodes[key];	1,495✔
38	if (existingNode) {	1,495✔
39	let dependencies = existingNode.dependencies.includes(dependencyKey) ? existingNode.dependencies : [dependencyKey, ...existingNode.dependencies];	276✔
40	this.addOrReplace(key, dependencies);	276✔
41	} else {
42	this.addOrReplace(key, [dependencyKey]);	1,219✔
43	}
44	}
45
46	/**
47	* Remove a dependency from an existing node.
48	* Do nothing if the node does not have that dependency.
49	* Do nothing if that node does not exist
50	*/
51	public removeDependency(key: string, dependencyKey: string) {
52	let existingNode = this.nodes[key];	129✔
53	let idx = (existingNode?.dependencies ?? []).indexOf(dependencyKey);	129✔
54	if (existingNode && idx > -1) {	129✔
55	existingNode.dependencies.splice(idx, 1);	128✔
56	this.addOrReplace(key, existingNode.dependencies);	128✔
57	}
58	}
59
60	/**
61	* Get a list of the dependencies for the given key, recursively.
62	* @param keys the key (or keys) for which to get the dependencies
63	* @param exclude a list of keys to exclude from traversal. Anytime one of these nodes is encountered, it is skipped.
64	*/
65	public getAllDependencies(keys: string \| string[], exclude?: string[]) {
66	if (typeof keys === 'string') {	3,657✔
67	return this.nodes[keys]?.getAllDependencies(exclude) ?? [];	3,656✔
68	} else {
69	const set = new Set<string>();	1✔
70	for (const key of keys) {	1✔
71	const dependencies = this.getAllDependencies(key, exclude);	2✔
72	for (const dependency of dependencies) {	2✔
73	set.add(dependency);	5✔
74	}
75	}
76	return [...set];	1✔
77	}
78	}
79
80	/**
81	* Get a list of the immediate dependencies for the given key.
82	*/
83	public getImmediateDependencies(keys: string \| string[], exclude?: string[]) {
UNCOV 84	if (typeof keys === 'string') {	×
UNCOV 85	return this.nodes[keys]?.dependencies ?? [];	×
86	} else {
UNCOV 87	const set = new Set<string>();	×
UNCOV 88	for (const key of keys) {	×
UNCOV 89	const dependencies = this.getImmediateDependencies(key, exclude);	×
UNCOV 90	for (const dependency of dependencies) {	×
UNCOV 91	set.add(dependency);	×
92	}
93	}
UNCOV 94	return [...set];	×
95	}
96	}
97
98	/**
99	* Remove the item. This will emit an onchange event for all dependent nodes
100	*/
101	public remove(key: string) {
102	this.nodes[key]?.dispose();	165✔
103	delete this.nodes[key];	165✔
104	this.emit(key, { sourceKey: key, notifiedKeys: new Set() });	165✔
105	}
106
107	/**
108	* Emit event that this item has changed
109	*/
110	public emit(key: string, event: DependencyChangedEvent) {
111	//prevent infinite event loops by skipping already-notified keys
112	if (!event.notifiedKeys.has(key)) {	5,647✔
113	event.notifiedKeys.add(key);	5,623✔
114	this.onchangeEmitter.emit(key, event);	5,623✔
115	}
116	}
117
118	/**
119	* Listen for any changes to dependencies with the given key.
120	* @param key the name of the dependency
121	* @param handler a function called anytime changes occur
122	*/
123	public onchange(key: string, handler: (event: DependencyChangedEvent) => void) {
124	this.onchangeEmitter.on(key, handler);	10,036✔
125	return () => {	10,036✔
126	this.onchangeEmitter.off(key, handler);	8,827✔
127	};
128	}
129
130	public dispose() {
131	for (let key in this.nodes) {	1,416✔
132	let node = this.nodes[key];	3,411✔
133	node.dispose();	3,411✔
134	}
135	this.onchangeEmitter.removeAllListeners();	1,416✔
136	}
137	}
138
139	export interface DependencyChangedEvent {
140	/**
141	* The key that was the initiator of this event. Child keys will emit this same event object, but this key will remain the same
142	*/
143	sourceKey: string;
144	/**
145	* A set of keys that have already been notified of this change. Used to prevent circular reference notification cycles
146	*/
147	notifiedKeys: Set<string>;
148	}
149
150	export class Node {	1✔
151	public constructor(
152	public key: string,	4,259✔
153	public dependencies: string[],	4,259✔
154	public graph: DependencyGraph	4,259✔
155	) {
156	if (dependencies.length > 0) {	4,259✔
157	this.subscriptions = [];	2,875✔
158
159	for (let dependency of this.dependencies) {	2,875✔
160	let sub = this.graph.onchange(dependency, (event) => {	4,602✔
161	//notify the graph that we changed since one of our dependencies changed
162	this.graph.emit(this.key, event);	1,223✔
163	});
164
165	this.subscriptions.push(sub);	4,602✔
166	}
167	}
168	}
169
170	private subscriptions: Array<() => void> \| undefined;
171
172	/**
173	* Return the full list of unique dependencies for this node by traversing all descendents
174	* @param exclude a list of keys to exclude from traversal. Anytime one of these nodes is encountered, it is skipped.
175	*/
176	public getAllDependencies(exclude: string[] = []) {	1,601✔
177	let dependencyMap = {};	2,073✔
178	let dependencyStack = [...this.dependencies];	2,073✔
179	//keep walking the dependency graph until we run out of unseen dependencies
180	while (dependencyStack.length > 0) {	2,073✔
181	let dependency = dependencyStack.pop();	5,585✔
182
183	//if this is a new dependency and we aren't supposed to skip it
184	if (dependency && !dependencyMap[dependency] && !exclude.includes(dependency)) {	5,585✔
185	dependencyMap[dependency] = true;	4,823✔
186
187	//get the node for this dependency
188	let node = this.graph.nodes[dependency];	4,823✔
189	if (node) {	4,823✔
190	dependencyStack.push(...node.dependencies);	2,836✔
191	}
192	}
193	}
194	return Object.keys(dependencyMap);	2,073✔
195	}
196
197	public dispose() {
198	for (let unsubscribe of this.subscriptions ?? []) {	3,984✔
199	unsubscribe();	4,252✔
200	}
201	}
202	}

rokucommunity / brighterscript / #12881

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