10618430945

Committed 29 Aug 2024 03:51PM UTC coverage: 82.666% (-0.005%) from 82.671%

Build # 10618430945

Build Type

Pull #311

github

Committed by

web-flow

Commit Message

Merge 6a00c511e into e7cfda55c

Pull Request Pull Request #311: Refactored code in sorted.js to avoid nested functions

Run Details

9963 of 13473 branches covered (73.95%)

Branch coverage included in aggregate %.

8 of 10 new or added lines in 1 file covered. (80.0%)

1 existing line in 1 file now uncovered.

22327 of 25588 relevant lines covered (87.26%)

1632.43 hits per line

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

78.14

/src/topics/sorted.js


'use strict';

const _ = require('lodash');

const db = require('../database');
const privileges = require('../privileges');
const user = require('../user');
const categories = require('../categories');
const meta = require('../meta');
const plugins = require('../plugins');

module.exports = function (Topics) {
        Topics.getSortedTopics = async function (params) {
                const data = {
                        nextStart: 0,
                        topicCount: 0,
                        topics: [],
                };

                params.term = params.term || 'alltime';
                params.sort = params.sort || 'recent';
                params.query = params.query || {};
                if (params.hasOwnProperty('cids') && params.cids && !Array.isArray(params.cids)) {
                        params.cids = [params.cids];
                }
                params.tags = params.tags || [];
                if (params.tags && !Array.isArray(params.tags)) {
                        params.tags = [params.tags];
                }
                data.tids = await getTids(params);
                data.tids = await sortTids(data.tids, params);
                data.tids = await filterTids(data.tids.slice(0, meta.config.recentMaxTopics), params);
                data.topicCount = data.tids.length;
                data.topics = await getTopics(data.tids, params);
                data.nextStart = params.stop + 1;
                return data;
        };

        async function getTids(params) {
                if (plugins.hooks.hasListeners('filter:topics.getSortedTids')) {
                        const result = await plugins.hooks.fire('filter:topics.getSortedTids', { params: params, tids: [] });
                        return result.tids;
                }
                let tids = [];
                if (params.term !== 'alltime') {
                        if (params.sort === 'posts') {
                                tids = await getTidsWithMostPostsInTerm(params.cids, params.uid, params.term);
                        } else {
                                tids = await Topics.getLatestTidsFromSet('topics:tid', 0, -1, params.term);
                        }

                        if (params.filter === 'watched') {
                                tids = await Topics.filterWatchedTids(tids, params.uid);
                        }
                } else if (params.filter === 'watched') {
                        tids = await getWatchedTopics(params);
                } else if (params.cids) {
                        tids = await getCidTids(params);
                } else if (params.tags.length) {
                        tids = await getTagTids(params);
                } else {
                        const method = params.sort === 'old' ?
                                'getSortedSetRange' :
                                'getSortedSetRevRange';
                        tids = await db[method](sortToSet(params.sort), 0, meta.config.recentMaxTopics - 1);
                }

                return tids;
        }

        function sortToSet(sort) {
                const map = {
                        recent: 'topics:recent',
                        old: 'topics:recent',
                        create: 'topics:tid',
                        posts: 'topics:posts',
                        votes: 'topics:votes',
                        views: 'topics:views',
                };
                if (map.hasOwnProperty(sort)) {
                        return map[sort];
                }
                return 'topics:recent';
        }

        async function getTidsWithMostPostsInTerm(cids, uid, term) {
                if (Array.isArray(cids)) {
                        cids = await privileges.categories.filterCids('topics:read', cids, uid);
                } else {
                        cids = await categories.getCidsByPrivilege('categories:cid', uid, 'topics:read');
                }

                const pids = await db.getSortedSetRevRangeByScore(
                        cids.map(cid => `cid:${cid}:pids`),
                        0,
                        1000,
                        '+inf',
                        Date.now() - Topics.getSinceFromTerm(term)
                );
                const postObjs = await db.getObjectsFields(pids.map(pid => `post:${pid}`), ['tid']);
                const tidToCount = {};
                postObjs.forEach((post) => {
                        tidToCount[post.tid] = tidToCount[post.tid] || 0;
                        tidToCount[post.tid] += 1;
                });

                return _.uniq(postObjs.map(post => String(post.tid)))
                        .sort((t1, t2) => tidToCount[t2] - tidToCount[t1]);
        }

        async function getWatchedTopics(params) {
                const sortSet = ['recent', 'old'].includes(params.sort) ? 'topics:recent' : `topics:${params.sort}`;
                const method = params.sort === 'old' ? 'getSortedSetIntersect' : 'getSortedSetRevIntersect';
                return await db[method]({
                        sets: [sortSet, `uid:${params.uid}:followed_tids`],
                        weights: [1, 0],
                        start: 0,
                        stop: meta.config.recentMaxTopics - 1,
                });
        }

        async function getTagTids(params) {
                const sets = [
                        sortToSet(params.sort),
                        ...params.tags.map(tag => `tag:${tag}:topics`),
                ];
                const method = params.sort === 'old' ?
                        'getSortedSetIntersect' :
                        'getSortedSetRevIntersect';
                return await db[method]({
                        sets: sets,
                        start: 0,
                        stop: meta.config.recentMaxTopics - 1,
                        weights: sets.map((s, index) => (index ? 0 : 1)),
                });
        }

        async function getCidTids(params) {
                if (params.tags.length) {
                        return _.intersection(...await Promise.all(params.tags.map(async (tag) => {
                                const sets = params.cids.map(cid => `cid:${cid}:tag:${tag}:topics`);
                                return await db.getSortedSetRevRange(sets, 0, -1);
                        })));
                }

                const sets = [];
                const pinnedSets = [];
                params.cids.forEach((cid) => {
                        if (params.sort === 'recent' || params.sort === 'old') {
                                sets.push(`cid:${cid}:tids`);
                        } else {
                                sets.push(`cid:${cid}:tids${params.sort ? `:${params.sort}` : ''}`);
                        }
                        pinnedSets.push(`cid:${cid}:tids:pinned`);
                });
                let pinnedTids = await db.getSortedSetRevRange(pinnedSets, 0, -1);
                pinnedTids = await Topics.tools.checkPinExpiry(pinnedTids);
                const method = params.sort === 'old' ?
                        'getSortedSetRange' :
                        'getSortedSetRevRange';
                const tids = await db[method](sets, 0, meta.config.recentMaxTopics - 1);
                return pinnedTids.concat(tids);
        }

        async function sortTids(tids, params) {
                if (params.term === 'alltime' && !params.cids && !params.tags.length && params.filter !== 'watched' && !params.floatPinned) {
                        return tids;
                }

                if (params.sort === 'posts' && params.term !== 'alltime') {
                        return tids;
                }

                const { sortMap, fields } = await plugins.hooks.fire('filter:topics.sortOptions', {
                        params,
                        fields: [
                                'tid', 'timestamp', 'lastposttime', 'upvotes', 'downvotes', 'postcount', 'pinned',
                        ],
                        sortMap: {
                                recent: sortRecent,
                                old: sortOld,
                                create: sortCreate,
                                posts: sortPopular,
                                votes: sortVotes,
                                views: sortViews,
                        },
                });

                const topicData = await Topics.getTopicsFields(tids, fields);
                const sortFn = sortMap.hasOwnProperty(params.sort) && sortMap[params.sort] ?
                        sortMap[params.sort] : sortRecent;

                if (params.floatPinned) {
                        floatPinned(topicData, sortFn);
                } else {
                        topicData.sort(sortFn);
                }

                return topicData.map(topic => topic && topic.tid);
        }

        function floatPinned(topicData, sortFn) {
                topicData.sort((a, b) => (a.pinned !== b.pinned ? b.pinned - a.pinned : sortFn(a, b)));
        }

        function sortRecent(a, b) {
                return b.lastposttime - a.lastposttime;
        }

        function sortOld(a, b) {
                return a.lastposttime - b.lastposttime;
        }

        function sortCreate(a, b) {
                return b.timestamp - a.timestamp;
        }

        function sortVotes(a, b) {
                if (a.votes !== b.votes) {
                        return b.votes - a.votes;
                }
                return b.postcount - a.postcount;
        }

        function sortPopular(a, b) {
                if (a.postcount !== b.postcount) {
                        return b.postcount - a.postcount;
                }
                return b.viewcount - a.viewcount;
        }

        function sortViews(a, b) {
                return b.viewcount - a.viewcount;
        }

        async function filterTids(tids, params) {
                const { filter } = params;
                const { uid } = params;

                if (filter === 'new') {
                        tids = await Topics.filterNewTids(tids, uid);
                } else if (filter === 'unreplied') {
                        tids = await Topics.filterUnrepliedTids(tids);
                } else {
                        tids = await Topics.filterNotIgnoredTids(tids, uid);
                }

                tids = await privileges.topics.filterTids('topics:read', tids, uid);
                let topicData = await Topics.getTopicsFields(tids, ['uid', 'tid', 'cid', 'tags']);
                const topicCids = _.uniq(topicData.map(topic => topic.cid)).filter(Boolean);

                async function getIgnoredCids() {
                        if (params.cids || filter === 'watched' || meta.config.disableRecentCategoryFilter) {
                                return [];
                        }
                        return await categories.isIgnored(topicCids, uid);
                }
                const [ignoredCids, filtered] = await Promise.all([
                        getIgnoredCids(),
                        user.blocks.filter(uid, topicData),
                ]);

                const isCidIgnored = _.zipObject(topicCids, ignoredCids);
                topicData = filtered;

                const cids = params.cids && params.cids.map(String);
                const { tags } = params;

                const conditionOne = t => !isCidIgnored[t.cid];
                const conditionTwo = t => !cids || cids.includes(String(t.cid));
                const conditionThree = t => tagsMatch(t, tags);

                tids = topicData
                        .filter(t => t && t.cid)
                        .filter(conditionOne)
                        .filter(conditionTwo)
                        .filter(conditionThree)
                        .map(t => t.tid);

                const result = await plugins.hooks.fire('filter:topics.filterSortedTids', { tids: tids, params: params });
                console.log('Benjamin Chen');
                return result.tids;
        }

        function tagsMatch(t, tags) {
                if (!tags.length) return true;
                // Generated from ChatGpt
                const topicTagValues = t.tags.map(topicTag => topicTag.value);
                return tags.every(tag => topicTagValues.includes(tag));
        }

        async function getTopics(tids, params) {
                tids = tids.slice(params.start, params.stop !== -1 ? params.stop + 1 : undefined);
                const topicData = await Topics.getTopicsByTids(tids, params);
                Topics.calculateTopicIndices(topicData, params.start);
                return topicData;
        }

        Topics.calculateTopicIndices = function (topicData, start) {
                topicData.forEach((topic, index) => {
                        if (topic) {
                                topic.index = start + index;
                        }
                });
        };
};

1
2	'use strict';
3
4	const _ = require('lodash');	8✔
5
6	const db = require('../database');	8✔
7	const privileges = require('../privileges');	8✔
8	const user = require('../user');	8✔
9	const categories = require('../categories');	8✔
10	const meta = require('../meta');	8✔
11	const plugins = require('../plugins');	8✔
12
13	module.exports = function (Topics) {	8✔
14	Topics.getSortedTopics = async function (params) {	8✔
15	const data = {	18✔
16	nextStart: 0,
17	topicCount: 0,
18	topics: [],
19	};
20
21	params.term = params.term \|\| 'alltime';	18✔
22	params.sort = params.sort \|\| 'recent';	18!
23	params.query = params.query \|\| {};	18✔
24	if (params.hasOwnProperty('cids') && params.cids && !Array.isArray(params.cids)) {	18!
25	params.cids = [params.cids];	×
26	}
27	params.tags = params.tags \|\| [];	18✔
28	if (params.tags && !Array.isArray(params.tags)) {	18!
29	params.tags = [params.tags];	×
30	}
31	data.tids = await getTids(params);	18✔
32	data.tids = await sortTids(data.tids, params);	18✔
33	data.tids = await filterTids(data.tids.slice(0, meta.config.recentMaxTopics), params);	18✔
34	data.topicCount = data.tids.length;	18✔
35	data.topics = await getTopics(data.tids, params);	18✔
36	data.nextStart = params.stop + 1;	18✔
37	return data;	18✔
38	};
39
40	async function getTids(params) {
41	if (plugins.hooks.hasListeners('filter:topics.getSortedTids')) {	18!
42	const result = await plugins.hooks.fire('filter:topics.getSortedTids', { params: params, tids: [] });	×
43	return result.tids;	×
44	}
45	let tids = [];	18✔
46	if (params.term !== 'alltime') {	18✔
47	if (params.sort === 'posts') {	1!
48	tids = await getTidsWithMostPostsInTerm(params.cids, params.uid, params.term);	1✔
49	} else {
50	tids = await Topics.getLatestTidsFromSet('topics:tid', 0, -1, params.term);	×
51	}
52
53	if (params.filter === 'watched') {	1!
54	tids = await Topics.filterWatchedTids(tids, params.uid);	×
55	}
56	} else if (params.filter === 'watched') {	17✔
57	tids = await getWatchedTopics(params);	1✔
58	} else if (params.cids) {	16✔
59	tids = await getCidTids(params);	5✔
60	} else if (params.tags.length) {	11!
61	tids = await getTagTids(params);	×
62	} else {
63	const method = params.sort === 'old' ?	11!
64	'getSortedSetRange' :
65	'getSortedSetRevRange';
66	tids = await db[method](sortToSet(params.sort), 0, meta.config.recentMaxTopics - 1);	11✔
67	}
68
69	return tids;	18✔
70	}
71
72	function sortToSet(sort) {
73	const map = {	11✔
74	recent: 'topics:recent',
75	old: 'topics:recent',
76	create: 'topics:tid',
77	posts: 'topics:posts',
78	votes: 'topics:votes',
79	views: 'topics:views',
80	};
81	if (map.hasOwnProperty(sort)) {	11!
82	return map[sort];	11✔
83	}
84	return 'topics:recent';	×
85	}
86
87	async function getTidsWithMostPostsInTerm(cids, uid, term) {
88	if (Array.isArray(cids)) {	1!
89	cids = await privileges.categories.filterCids('topics:read', cids, uid);	×
90	} else {
91	cids = await categories.getCidsByPrivilege('categories:cid', uid, 'topics:read');	1✔
92	}
93
94	const pids = await db.getSortedSetRevRangeByScore(	1✔
95	cids.map(cid => `cid:${cid}:pids`),	2✔
96	0,
97	1000,
98	'+inf',
99	Date.now() - Topics.getSinceFromTerm(term)
100	);
101	const postObjs = await db.getObjectsFields(pids.map(pid => `post:${pid}`), ['tid']);	5✔
102	const tidToCount = {};	1✔
103	postObjs.forEach((post) => {	1✔
104	tidToCount[post.tid] = tidToCount[post.tid] \|\| 0;	5✔
105	tidToCount[post.tid] += 1;	5✔
106	});
107
108	return _.uniq(postObjs.map(post => String(post.tid)))	5✔
109	.sort((t1, t2) => tidToCount[t2] - tidToCount[t1]);	4✔
110	}
111
112	async function getWatchedTopics(params) {
113	const sortSet = ['recent', 'old'].includes(params.sort) ? 'topics:recent' : `topics:${params.sort}`;	1!
114	const method = params.sort === 'old' ? 'getSortedSetIntersect' : 'getSortedSetRevIntersect';	1!
115	return await db[method]({	1✔
116	sets: [sortSet, `uid:${params.uid}:followed_tids`],
117	weights: [1, 0],
118	start: 0,
119	stop: meta.config.recentMaxTopics - 1,
120	});
121	}
122
123	async function getTagTids(params) {
124	const sets = [	×
125	sortToSet(params.sort),
126	...params.tags.map(tag => `tag:${tag}:topics`),	×
127	];
128	const method = params.sort === 'old' ?	×
129	'getSortedSetIntersect' :
130	'getSortedSetRevIntersect';
131	return await db[method]({	×
132	sets: sets,
133	start: 0,
134	stop: meta.config.recentMaxTopics - 1,
135	weights: sets.map((s, index) => (index ? 0 : 1)),	×
136	});
137	}
138
139	async function getCidTids(params) {
140	if (params.tags.length) {	5!
141	return _.intersection(...await Promise.all(params.tags.map(async (tag) => {	×
142	const sets = params.cids.map(cid => `cid:${cid}:tag:${tag}:topics`);	×
143	return await db.getSortedSetRevRange(sets, 0, -1);	×
144	})));
145	}
146
147	const sets = [];	5✔
148	const pinnedSets = [];	5✔
149	params.cids.forEach((cid) => {	5✔
150	if (params.sort === 'recent' \|\| params.sort === 'old') {	5✔
151	sets.push(`cid:${cid}:tids`);	2✔
152	} else {
153	sets.push(`cid:${cid}:tids${params.sort ? `:${params.sort}` : ''}`);	3!
154	}
155	pinnedSets.push(`cid:${cid}:tids:pinned`);	5✔
156	});
157	let pinnedTids = await db.getSortedSetRevRange(pinnedSets, 0, -1);	5✔
158	pinnedTids = await Topics.tools.checkPinExpiry(pinnedTids);	5✔
159	const method = params.sort === 'old' ?	5✔
160	'getSortedSetRange' :
161	'getSortedSetRevRange';
162	const tids = await db[method](sets, 0, meta.config.recentMaxTopics - 1);	5✔
163	return pinnedTids.concat(tids);	5✔
164	}
165
166	async function sortTids(tids, params) {
167	if (params.term === 'alltime' && !params.cids && !params.tags.length && params.filter !== 'watched' && !params.floatPinned) {	18✔
168	return tids;	11✔
169	}
170
171	if (params.sort === 'posts' && params.term !== 'alltime') {	7✔
172	return tids;	1✔
173	}
174
175	const { sortMap, fields } = await plugins.hooks.fire('filter:topics.sortOptions', {	6✔
176	params,
177	fields: [
178	'tid', 'timestamp', 'lastposttime', 'upvotes', 'downvotes', 'postcount', 'pinned',
179	],
180	sortMap: {
181	recent: sortRecent,
182	old: sortOld,
183	create: sortCreate,
184	posts: sortPopular,
185	votes: sortVotes,
186	views: sortViews,
187	},
188	});
189
190	const topicData = await Topics.getTopicsFields(tids, fields);	6✔
191	const sortFn = sortMap.hasOwnProperty(params.sort) && sortMap[params.sort] ?	6!
192	sortMap[params.sort] : sortRecent;
193
194	if (params.floatPinned) {	6!
195	floatPinned(topicData, sortFn);	×
196	} else {
197	topicData.sort(sortFn);	6✔
198	}
199
200	return topicData.map(topic => topic && topic.tid);	56✔
201	}
202
203	function floatPinned(topicData, sortFn) {
204	topicData.sort((a, b) => (a.pinned !== b.pinned ? b.pinned - a.pinned : sortFn(a, b)));	×
205	}
206
207	function sortRecent(a, b) {
208	return b.lastposttime - a.lastposttime;	1✔
209	}
210
211	function sortOld(a, b) {
212	return a.lastposttime - b.lastposttime;	1✔
213	}
214
215	function sortCreate(a, b) {
216	return b.timestamp - a.timestamp;	×
217	}
218
219	function sortVotes(a, b) {
220	if (a.votes !== b.votes) {	198!
221	return b.votes - a.votes;	×
222	}
223	return b.postcount - a.postcount;	198✔
224	}
225
226	function sortPopular(a, b) {
227	if (a.postcount !== b.postcount) {	×
228	return b.postcount - a.postcount;	×
229	}
230	return b.viewcount - a.viewcount;	×
231	}
232
233	function sortViews(a, b) {
234	return b.viewcount - a.viewcount;	×
235	}
236
237	async function filterTids(tids, params) {
238	const { filter } = params;	18✔
239	const { uid } = params;	18✔
240
241	if (filter === 'new') {	18✔
242	tids = await Topics.filterNewTids(tids, uid);	1✔
243	} else if (filter === 'unreplied') {	17✔
244	tids = await Topics.filterUnrepliedTids(tids);	1✔
245	} else {
246	tids = await Topics.filterNotIgnoredTids(tids, uid);	16✔
247	}
248
249	tids = await privileges.topics.filterTids('topics:read', tids, uid);	18✔
250	let topicData = await Topics.getTopicsFields(tids, ['uid', 'tid', 'cid', 'tags']);	18✔
251	const topicCids = _.uniq(topicData.map(topic => topic.cid)).filter(Boolean);	90✔
252
253	async function getIgnoredCids() {
254	if (params.cids \|\| filter === 'watched' \|\| meta.config.disableRecentCategoryFilter) {	18✔
255	return [];	6✔
256	}
257	return await categories.isIgnored(topicCids, uid);	12✔
258	}
259	const [ignoredCids, filtered] = await Promise.all([	18✔
260	getIgnoredCids(),
261	user.blocks.filter(uid, topicData),
262	]);
263
264	const isCidIgnored = _.zipObject(topicCids, ignoredCids);	18✔
265	topicData = filtered;	18✔
266
267	const cids = params.cids && params.cids.map(String);	18✔
268	const { tags } = params;	18✔
269
270	const conditionOne = t => !isCidIgnored[t.cid];	90✔
271	const conditionTwo = t => !cids \|\| cids.includes(String(t.cid));	90✔
272	const conditionThree = t => tagsMatch(t, tags);	46✔
273
274	tids = topicData	18✔
275	.filter(t => t && t.cid)	90✔
276	.filter(conditionOne)
277	.filter(conditionTwo)
278	.filter(conditionThree)
279	.map(t => t.tid);	46✔
280
281	const result = await plugins.hooks.fire('filter:topics.filterSortedTids', { tids: tids, params: params });	18✔
282	console.log('Benjamin Chen');	18✔
283	return result.tids;	18✔
284	}
285
286	function tagsMatch(t, tags) {
287	if (!tags.length) return true;	46!
288	// Generated from ChatGpt
NEW 289	const topicTagValues = t.tags.map(topicTag => topicTag.value);	×
NEW 290	return tags.every(tag => topicTagValues.includes(tag));	×
291	}
292
293	async function getTopics(tids, params) {
294	tids = tids.slice(params.start, params.stop !== -1 ? params.stop + 1 : undefined);	18✔
295	const topicData = await Topics.getTopicsByTids(tids, params);	18✔
296	Topics.calculateTopicIndices(topicData, params.start);	18✔
297	return topicData;	18✔
298	}
299
300	Topics.calculateTopicIndices = function (topicData, start) {	8✔
301	topicData.forEach((topic, index) => {	49✔
302	if (topic) {	123!
303	topic.index = start + index;	123✔
304	}
305	});
306	};
307	};

CMU-313 / NodeBB / 10618430945

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