10693261024

Committed 04 Sep 2024 01:08AM UTC coverage: 82.672% (+0.001%) from 82.671%

Build # 10693261024

Build Type

Pull #448

github

Committed by

web-flow

Commit Message

Merge 16aa141b1 into e7cfda55c

Pull Request Pull Request #448: Refactoring code in src/groups/update.js

Run Details

9965 of 13474 branches covered (73.96%)

Branch coverage included in aggregate %.

12 of 12 new or added lines in 1 file covered. (100.0%)

16 existing lines in 1 file now uncovered.

22325 of 25584 relevant lines covered (87.26%)

1632.67 hits per line

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

78.75

/src/groups/update.js

'use strict';

const winston = require('winston');

const categories = require('../categories');
const plugins = require('../plugins');
const slugify = require('../slugify');
const db = require('../database');
const user = require('../user');
const batch = require('../batch');
const meta = require('../meta');
const cache = require('../cache');


module.exports = function (Groups) {
        Groups.update = async function (groupName, values) {
                const exists = await db.exists(`group:${groupName}`);
                if (!exists) {
                        throw new Error('[[error:no-group]]');
                }

                ({ values } = await plugins.hooks.fire('filter:group.update', {
                        groupName: groupName,
                        values: values,
                }));

                // Cast some values as bool (if not boolean already)
                // 'true' and '1' = true, everything else false
                ['userTitleEnabled', 'private', 'hidden', 'disableJoinRequests', 'disableLeave'].forEach((prop) => {
                        if (values.hasOwnProperty(prop) && typeof values[prop] !== 'boolean') {
                                values[prop] = values[prop] === 'true' || parseInt(values[prop], 10) === 1;
                        }
                });

                const payload = payload_helper(values);

                if (values.hasOwnProperty('disableJoinRequests')) {
                        payload.disableJoinRequests = values.disableJoinRequests ? '1' : '0';
                }

                if (values.hasOwnProperty('disableLeave')) {
                        payload.disableLeave = values.disableLeave ? '1' : '0';
                }

                if (values.hasOwnProperty('name')) {
                        await checkNameChange(groupName, values.name);
                }

                if (values.hasOwnProperty('private')) {
                        await updatePrivacy(groupName, values.private);
                }

                if (values.hasOwnProperty('hidden')) {
                        await updateVisibility(groupName, values.hidden);
                }

                if (values.hasOwnProperty('memberPostCids')) {
                        const validCids = await categories.getCidsByPrivilege('categories:cid', groupName, 'topics:read');
                        const cidsArray = values.memberPostCids.split(',').map(cid => parseInt(cid.trim(), 10)).filter(Boolean);
                        payload.memberPostCids = cidsArray.filter(cid => validCids.includes(cid)).join(',') || '';
                }

                await db.setObject(`group:${groupName}`, payload);
                await Groups.renameGroup(groupName, values.name);

                plugins.hooks.fire('action:group.update', {
                        name: groupName,
                        values: values,
                });
        };

        function payload_helper(values) {
                const payload = {
                        description: values.description || '',
                        icon: values.icon || '',
                        labelColor: values.labelColor || '#000000',
                        textColor: values.textColor || '#ffffff',
                };

                if (values.hasOwnProperty('userTitle')) {
                        payload.userTitle = values.userTitle || '';
                }

                if (values.hasOwnProperty('userTitleEnabled')) {
                        payload.userTitleEnabled = values.userTitleEnabled ? '1' : '0';
                }

                if (values.hasOwnProperty('hidden')) {
                        payload.hidden = values.hidden ? '1' : '0';
                }

                if (values.hasOwnProperty('private')) {
                        payload.private = values.private ? '1' : '0';
                }
                return payload;
        }


        async function updateVisibility(groupName, hidden) {
                if (hidden) {
                        await db.sortedSetRemoveBulk([
                                ['groups:visible:createtime', groupName],
                                ['groups:visible:memberCount', groupName],
                                ['groups:visible:name', `${groupName.toLowerCase()}:${groupName}`],
                        ]);
                        return;
                }
                const groupData = await db.getObjectFields(`group:${groupName}`, ['createtime', 'memberCount']);
                await db.sortedSetAddBulk([
                        ['groups:visible:createtime', groupData.createtime, groupName],
                        ['groups:visible:memberCount', groupData.memberCount, groupName],
                        ['groups:visible:name', 0, `${groupName.toLowerCase()}:${groupName}`],
                ]);
        }

        Groups.hide = async function (groupName) {
                await showHide(groupName, 'hidden');
        };

        Groups.show = async function (groupName) {
                await showHide(groupName, 'show');
        };

        async function showHide(groupName, hidden) {
                hidden = hidden === 'hidden';
                await Promise.all([
                        db.setObjectField(`group:${groupName}`, 'hidden', hidden ? 1 : 0),
                        updateVisibility(groupName, hidden),
                ]);
        }

        async function updatePrivacy(groupName, isPrivate) {
                const groupData = await Groups.getGroupFields(groupName, ['private']);
                const currentlyPrivate = groupData.private === 1;
                if (!currentlyPrivate || currentlyPrivate === isPrivate) {
                        return;
                }
                const pendingUids = await db.getSetMembers(`group:${groupName}:pending`);
                if (!pendingUids.length) {
                        return;
                }

                winston.verbose(`[groups.update] Group is now public, automatically adding ${pendingUids.length} new members, who were pending prior.`);

                for (const uid of pendingUids) {
                        /* eslint-disable no-await-in-loop */
                        await Groups.join(groupName, uid);
                }
                await db.delete(`group:${groupName}:pending`);
        }

        async function checkNameChange(currentName, newName) {
                if (Groups.isPrivilegeGroup(newName)) {
                        throw new Error('[[error:invalid-group-name]]');
                }
                const currentSlug = slugify(currentName);
                const newSlug = slugify(newName);
                if (currentName === newName || currentSlug === newSlug) {
                        return;
                }
                Groups.validateGroupName(newName);
                const [group, exists] = await Promise.all([
                        Groups.getGroupData(currentName),
                        Groups.existsBySlug(newSlug),
                ]);

                if (exists) {
                        throw new Error('[[error:group-already-exists]]');
                }

                if (!group) {
                        throw new Error('[[error:no-group]]');
                }

                if (group.system) {
                        throw new Error('[[error:not-allowed-to-rename-system-group]]');
                }
        }

        Groups.renameGroup = async function (oldName, newName) {
                if (oldName === newName || !newName || String(newName).length === 0) {
                        return;
                }
                const group = await db.getObject(`group:${oldName}`);
                if (!group) {
                        return;
                }

                const exists = await Groups.exists(newName);
                if (exists) {
                        throw new Error('[[error:group-already-exists]]');
                }

                await updateMemberGroupTitles(oldName, newName);
                await updateNavigationItems(oldName, newName);
                await updateWidgets(oldName, newName);
                await updateConfig(oldName, newName);
                await updateChatRooms(oldName, newName);
                await db.setObject(`group:${oldName}`, { name: newName, slug: slugify(newName) });
                if (!Groups.isPrivilegeGroup(oldName) && !Groups.isPrivilegeGroup(newName)) {
                        await db.deleteObjectField('groupslug:groupname', group.slug);
                        await db.setObjectField('groupslug:groupname', slugify(newName), newName);
                }

                const allGroups = await db.getSortedSetRange('groups:createtime', 0, -1);
                const keys = allGroups.map(group => `group:${group}:members`);
                await renameGroupsMember(keys, oldName, newName);
                cache.del(keys);

                await db.rename(`group:${oldName}`, `group:${newName}`);
                await db.rename(`group:${oldName}:members`, `group:${newName}:members`);
                await db.rename(`group:${oldName}:owners`, `group:${newName}:owners`);
                await db.rename(`group:${oldName}:pending`, `group:${newName}:pending`);
                await db.rename(`group:${oldName}:invited`, `group:${newName}:invited`);
                await db.rename(`group:${oldName}:member:pids`, `group:${newName}:member:pids`);

                await renameGroupsMember(['groups:createtime', 'groups:visible:createtime', 'groups:visible:memberCount'], oldName, newName);
                await renameGroupsMember(['groups:visible:name'], `${oldName.toLowerCase()}:${oldName}`, `${newName.toLowerCase()}:${newName}`);

                plugins.hooks.fire('action:group.rename', {
                        old: oldName,
                        new: newName,
                });
                Groups.cache.reset();
        };

        async function updateMemberGroupTitles(oldName, newName) {
                await batch.processSortedSet(`group:${oldName}:members`, async (uids) => {
                        let usersData = await user.getUsersData(uids);
                        usersData = usersData.filter(userData => userData && userData.groupTitleArray.includes(oldName));

                        usersData.forEach((userData) => {
                                userData.newTitleArray = userData.groupTitleArray.map(oldTitle => (oldTitle === oldName ? newName : oldTitle));
                        });

                        await Promise.all(usersData.map(u => user.setUserField(u.uid, 'groupTitle', JSON.stringify(u.newTitleArray))));
                }, {});
        }

        async function renameGroupsMember(keys, oldName, newName) {
                const isMembers = await db.isMemberOfSortedSets(keys, oldName);
                keys = keys.filter((key, index) => isMembers[index]);
                if (!keys.length) {
                        return;
                }
                const scores = await db.sortedSetsScore(keys, oldName);
                await db.sortedSetsRemove(keys, oldName);
                await db.sortedSetsAdd(keys, scores, newName);
        }

        async function updateNavigationItems(oldName, newName) {
                const navigation = require('../navigation/admin');
                const navItems = await navigation.get();
                navItems.forEach((navItem) => {
                        if (navItem && Array.isArray(navItem.groups) && navItem.groups.includes(oldName)) {
                                navItem.groups.splice(navItem.groups.indexOf(oldName), 1, newName);
                        }
                });
                navigation.unescapeFields(navItems);
                await navigation.save(navItems);
        }

        async function updateWidgets(oldName, newName) {
                const admin = require('../widgets/admin');
                const widgets = require('../widgets');

                const data = await admin.get();

                data.areas.forEach((area) => {
                        area.widgets = area.data;
                        area.widgets.forEach((widget) => {
                                if (widget && widget.data && Array.isArray(widget.data.groups) && widget.data.groups.includes(oldName)) {
                                        widget.data.groups.splice(widget.data.groups.indexOf(oldName), 1, newName);
                                }
                        });
                });
                for (const area of data.areas) {
                        if (area.data.length) {
                                await widgets.setArea(area);
                        }
                }
        }

        async function updateConfig(oldName, newName) {
                const configKeys = [
                        'groupsExemptFromPostQueue',
                        'groupsExemptFromNewUserRestrictions',
                        'groupsExemptFromMaintenanceMode',
                ];

                for (const key of configKeys) {
                        if (meta.config[key] && meta.config[key].includes(oldName)) {
                                meta.config[key].splice(
                                        meta.config[key].indexOf(oldName), 1, newName
                                );
                                await meta.configs.set(key, meta.config[key]);
                        }
                }
        }

        async function updateChatRooms(oldName, newName) {
                const messaging = require('../messaging');
                const roomIds = await db.getSortedSetRange('chat:rooms:public', 0, -1);
                const roomData = await messaging.getRoomsData(roomIds);
                const bulkSet = [];
                roomData.forEach((room) => {
                        if (room && room.public && Array.isArray(room.groups) && room.groups.includes(oldName)) {
                                room.groups.splice(room.groups.indexOf(oldName), 1, newName);
                                bulkSet.push([`chat:room:${room.roomId}`, { groups: JSON.stringify(room.groups) }]);
                        }
                });
                await db.setObjectBulk(bulkSet);
        }
};

1	'use strict';
2
3	const winston = require('winston');	8✔
4
5	const categories = require('../categories');	8✔
6	const plugins = require('../plugins');	8✔
7	const slugify = require('../slugify');	8✔
8	const db = require('../database');	8✔
9	const user = require('../user');	8✔
10	const batch = require('../batch');	8✔
11	const meta = require('../meta');	8✔
12	const cache = require('../cache');	8✔
13
14
15	module.exports = function (Groups) {	8✔
16	Groups.update = async function (groupName, values) {	8✔
17	const exists = await db.exists(`group:${groupName}`);	14✔
18	if (!exists) {	14!
19	throw new Error('[[error:no-group]]');	×
20	}
21
22	({ values } = await plugins.hooks.fire('filter:group.update', {	14✔
23	groupName: groupName,
24	values: values,
25	}));
26
27	// Cast some values as bool (if not boolean already)
28	// 'true' and '1' = true, everything else false
29	['userTitleEnabled', 'private', 'hidden', 'disableJoinRequests', 'disableLeave'].forEach((prop) => {	14✔
30	if (values.hasOwnProperty(prop) && typeof values[prop] !== 'boolean') {	70✔
31	values[prop] = values[prop] === 'true' \|\| parseInt(values[prop], 10) === 1;	8✔
32	}
33	});
34
35	const payload = payload_helper(values);	14✔
36
37	if (values.hasOwnProperty('disableJoinRequests')) {	14✔
38	payload.disableJoinRequests = values.disableJoinRequests ? '1' : '0';	2!
39	}
40
41	if (values.hasOwnProperty('disableLeave')) {	14!
42	payload.disableLeave = values.disableLeave ? '1' : '0';	×
43	}
44
45	if (values.hasOwnProperty('name')) {	14✔
46	await checkNameChange(groupName, values.name);	12✔
47	}
48
49	if (values.hasOwnProperty('private')) {	5✔
50	await updatePrivacy(groupName, values.private);	2✔
51	}
52
53	if (values.hasOwnProperty('hidden')) {	5✔
54	await updateVisibility(groupName, values.hidden);	2✔
55	}
56
57	if (values.hasOwnProperty('memberPostCids')) {	5!
UNCOV 58	const validCids = await categories.getCidsByPrivilege('categories:cid', groupName, 'topics:read');	×
59	const cidsArray = values.memberPostCids.split(',').map(cid => parseInt(cid.trim(), 10)).filter(Boolean);	×
60	payload.memberPostCids = cidsArray.filter(cid => validCids.includes(cid)).join(',') \|\| '';	×
61	}
62
63	await db.setObject(`group:${groupName}`, payload);	5✔
64	await Groups.renameGroup(groupName, values.name);	5✔
65
66	plugins.hooks.fire('action:group.update', {	5✔
67	name: groupName,
68	values: values,
69	});
70	};
71
72	function payload_helper(values) {
73	const payload = {	14✔
74	description: values.description \|\| '',	25✔
75	icon: values.icon \|\| '',	27✔
76	labelColor: values.labelColor \|\| '#000000',	28✔
77	textColor: values.textColor \|\| '#ffffff',	28✔
78	};
79
80	if (values.hasOwnProperty('userTitle')) {	14✔
81	payload.userTitle = values.userTitle \|\| '';	2!
82	}
83
84	if (values.hasOwnProperty('userTitleEnabled')) {	14✔
85	payload.userTitleEnabled = values.userTitleEnabled ? '1' : '0';	2!
86	}
87
88	if (values.hasOwnProperty('hidden')) {	14✔
89	payload.hidden = values.hidden ? '1' : '0';	2!
90	}
91
92	if (values.hasOwnProperty('private')) {	14✔
93	payload.private = values.private ? '1' : '0';	2!
94	}
95	return payload;	14✔
96	}
97
98
99	async function updateVisibility(groupName, hidden) {
100	if (hidden) {	5✔
101	await db.sortedSetRemoveBulk([	3✔
102	['groups:visible:createtime', groupName],
103	['groups:visible:memberCount', groupName],
104	['groups:visible:name', `${groupName.toLowerCase()}:${groupName}`],
105	]);
106	return;	3✔
107	}
108	const groupData = await db.getObjectFields(`group:${groupName}`, ['createtime', 'memberCount']);	2✔
109	await db.sortedSetAddBulk([	2✔
110	['groups:visible:createtime', groupData.createtime, groupName],
111	['groups:visible:memberCount', groupData.memberCount, groupName],
112	['groups:visible:name', 0, `${groupName.toLowerCase()}:${groupName}`],
113	]);
114	}
115
116	Groups.hide = async function (groupName) {	8✔
117	await showHide(groupName, 'hidden');	1✔
118	};
119
120	Groups.show = async function (groupName) {	8✔
121	await showHide(groupName, 'show');	2✔
122	};
123
124	async function showHide(groupName, hidden) {
125	hidden = hidden === 'hidden';	3✔
126	await Promise.all([	3✔
127	db.setObjectField(`group:${groupName}`, 'hidden', hidden ? 1 : 0),	3✔
128	updateVisibility(groupName, hidden),
129	]);
130	}
131
132	async function updatePrivacy(groupName, isPrivate) {
133	const groupData = await Groups.getGroupFields(groupName, ['private']);	2✔
134	const currentlyPrivate = groupData.private === 1;	2✔
135	if (!currentlyPrivate \|\| currentlyPrivate === isPrivate) {	2!
UNCOV 136	return;	×
137	}
138	const pendingUids = await db.getSetMembers(`group:${groupName}:pending`);	2✔
139	if (!pendingUids.length) {	2!
140	return;	2✔
141	}
142
UNCOV 143	winston.verbose(`[groups.update] Group is now public, automatically adding ${pendingUids.length} new members, who were pending prior.`);	×
144
UNCOV 145	for (const uid of pendingUids) {	×
146	/* eslint-disable no-await-in-loop */
UNCOV 147	await Groups.join(groupName, uid);	×
148	}
UNCOV 149	await db.delete(`group:${groupName}:pending`);	×
150	}
151
152	async function checkNameChange(currentName, newName) {
153	if (Groups.isPrivilegeGroup(newName)) {	12✔
154	throw new Error('[[error:invalid-group-name]]');	1✔
155	}
156	const currentSlug = slugify(currentName);	11✔
157	const newSlug = slugify(newName);	11✔
158	if (currentName === newName \|\| currentSlug === newSlug) {	11✔
159	return;	1✔
160	}
161	Groups.validateGroupName(newName);	10✔
162	const [group, exists] = await Promise.all([	4✔
163	Groups.getGroupData(currentName),
164	Groups.existsBySlug(newSlug),
165	]);
166
167	if (exists) {	4✔
168	throw new Error('[[error:group-already-exists]]');	1✔
169	}
170
171	if (!group) {	3!
UNCOV 172	throw new Error('[[error:no-group]]');	×
173	}
174
175	if (group.system) {	3✔
176	throw new Error('[[error:not-allowed-to-rename-system-group]]');	1✔
177	}
178	}
179
180	Groups.renameGroup = async function (oldName, newName) {	8✔
181	if (oldName === newName \|\| !newName \|\| String(newName).length === 0) {	5✔
182	return;	2✔
183	}
184	const group = await db.getObject(`group:${oldName}`);	3✔
185	if (!group) {	3!
UNCOV 186	return;	×
187	}
188
189	const exists = await Groups.exists(newName);	3✔
190	if (exists) {	3!
UNCOV 191	throw new Error('[[error:group-already-exists]]');	×
192	}
193
194	await updateMemberGroupTitles(oldName, newName);	3✔
195	await updateNavigationItems(oldName, newName);	3✔
196	await updateWidgets(oldName, newName);	3✔
197	await updateConfig(oldName, newName);	3✔
198	await updateChatRooms(oldName, newName);	3✔
199	await db.setObject(`group:${oldName}`, { name: newName, slug: slugify(newName) });	3✔
200	if (!Groups.isPrivilegeGroup(oldName) && !Groups.isPrivilegeGroup(newName)) {	3!
201	await db.deleteObjectField('groupslug:groupname', group.slug);	3✔
202	await db.setObjectField('groupslug:groupname', slugify(newName), newName);	3✔
203	}
204
205	const allGroups = await db.getSortedSetRange('groups:createtime', 0, -1);	3✔
206	const keys = allGroups.map(group => `group:${group}:members`);	103✔
207	await renameGroupsMember(keys, oldName, newName);	3✔
208	cache.del(keys);	3✔
209
210	await db.rename(`group:${oldName}`, `group:${newName}`);	3✔
211	await db.rename(`group:${oldName}:members`, `group:${newName}:members`);	3✔
212	await db.rename(`group:${oldName}:owners`, `group:${newName}:owners`);	3✔
213	await db.rename(`group:${oldName}:pending`, `group:${newName}:pending`);	3✔
214	await db.rename(`group:${oldName}:invited`, `group:${newName}:invited`);	3✔
215	await db.rename(`group:${oldName}:member:pids`, `group:${newName}:member:pids`);	3✔
216
217	await renameGroupsMember(['groups:createtime', 'groups:visible:createtime', 'groups:visible:memberCount'], oldName, newName);	3✔
218	await renameGroupsMember(['groups:visible:name'], `${oldName.toLowerCase()}:${oldName}`, `${newName.toLowerCase()}:${newName}`);	3✔
219
220	plugins.hooks.fire('action:group.rename', {	3✔
221	old: oldName,
222	new: newName,
223	});
224	Groups.cache.reset();	3✔
225	};
226
227	async function updateMemberGroupTitles(oldName, newName) {
228	await batch.processSortedSet(`group:${oldName}:members`, async (uids) => {	3✔
229	let usersData = await user.getUsersData(uids);	2✔
230	usersData = usersData.filter(userData => userData && userData.groupTitleArray.includes(oldName));	2✔
231
232	usersData.forEach((userData) => {	2✔
UNCOV 233	userData.newTitleArray = userData.groupTitleArray.map(oldTitle => (oldTitle === oldName ? newName : oldTitle));	×
234	});
235
236	await Promise.all(usersData.map(u => user.setUserField(u.uid, 'groupTitle', JSON.stringify(u.newTitleArray))));	2✔
237	}, {});
238	}
239
240	async function renameGroupsMember(keys, oldName, newName) {
241	const isMembers = await db.isMemberOfSortedSets(keys, oldName);	9✔
242	keys = keys.filter((key, index) => isMembers[index]);	115✔
243	if (!keys.length) {	9✔
244	return;	5✔
245	}
246	const scores = await db.sortedSetsScore(keys, oldName);	4✔
247	await db.sortedSetsRemove(keys, oldName);	4✔
248	await db.sortedSetsAdd(keys, scores, newName);	4✔
249	}
250
251	async function updateNavigationItems(oldName, newName) {
252	const navigation = require('../navigation/admin');	3✔
253	const navItems = await navigation.get();	3✔
254	navItems.forEach((navItem) => {	3✔
255	if (navItem && Array.isArray(navItem.groups) && navItem.groups.includes(oldName)) {	24!
UNCOV 256	navItem.groups.splice(navItem.groups.indexOf(oldName), 1, newName);	×
257	}
258	});
259	navigation.unescapeFields(navItems);	3✔
260	await navigation.save(navItems);	3✔
261	}
262
263	async function updateWidgets(oldName, newName) {
264	const admin = require('../widgets/admin');	3✔
265	const widgets = require('../widgets');	3✔
266
267	const data = await admin.get();	3✔
268
269	data.areas.forEach((area) => {	3✔
270	area.widgets = area.data;	141✔
271	area.widgets.forEach((widget) => {	141✔
UNCOV 272	if (widget && widget.data && Array.isArray(widget.data.groups) && widget.data.groups.includes(oldName)) {	×
273	widget.data.groups.splice(widget.data.groups.indexOf(oldName), 1, newName);	×
274	}
275	});
276	});
277	for (const area of data.areas) {	3✔
278	if (area.data.length) {	141!
UNCOV 279	await widgets.setArea(area);	×
280	}
281	}
282	}
283
284	async function updateConfig(oldName, newName) {
285	const configKeys = [	3✔
286	'groupsExemptFromPostQueue',
287	'groupsExemptFromNewUserRestrictions',
288	'groupsExemptFromMaintenanceMode',
289	];
290
291	for (const key of configKeys) {	3✔
292	if (meta.config[key] && meta.config[key].includes(oldName)) {	9!
UNCOV 293	meta.config[key].splice(	×
294	meta.config[key].indexOf(oldName), 1, newName
295	);
UNCOV 296	await meta.configs.set(key, meta.config[key]);	×
297	}
298	}
299	}
300
301	async function updateChatRooms(oldName, newName) {
302	const messaging = require('../messaging');	3✔
303	const roomIds = await db.getSortedSetRange('chat:rooms:public', 0, -1);	3✔
304	const roomData = await messaging.getRoomsData(roomIds);	3✔
305	const bulkSet = [];	3✔
306	roomData.forEach((room) => {	3✔
UNCOV 307	if (room && room.public && Array.isArray(room.groups) && room.groups.includes(oldName)) {	×
308	room.groups.splice(room.groups.indexOf(oldName), 1, newName);	×
309	bulkSet.push([`chat:room:${room.roomId}`, { groups: JSON.stringify(room.groups) }]);	×
310	}
311	});
312	await db.setObjectBulk(bulkSet);	3✔
313	}
314	};

CMU-313 / NodeBB / 10693261024

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