10712361095

Committed 05 Sep 2024 01:41AM UTC coverage: 82.675% (+0.004%) from 82.671%

Build # 10712361095

Build Type

Pull #451

github

Committed by

web-flow

Commit Message

Merge 524368862 into e7cfda55c

Pull Request Pull Request #451: Refactoring code in src/meta/themes.js to reduce cognitive complexity

Run Details

9967 of 13474 branches covered (73.97%)

Branch coverage included in aggregate %.

5 of 9 new or added lines in 1 file covered. (55.56%)

1 existing line in 1 file now uncovered.

22326 of 25586 relevant lines covered (87.26%)

1632.56 hits per line

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

76.87

/src/meta/themes.js

'use strict';

const path = require('path');
const nconf = require('nconf');
const winston = require('winston');
const _ = require('lodash');
const fs = require('fs');

const file = require('../file');
const db = require('../database');
const Meta = require('./index');
const events = require('../events');
const utils = require('../utils');
const { themeNamePattern } = require('../constants');

const Themes = module.exports;

Themes.get = async () => {
        const themePath = nconf.get('themes_path');
        if (typeof themePath !== 'string') {
                return [];
        }

        let themes = await getThemes(themePath);
        themes = _.flatten(themes).filter(Boolean);
        themes = await Promise.all(themes.map(async (theme) => {
                const config = path.join(themePath, theme, 'theme.json');
                const pack = path.join(themePath, theme, 'package.json');
                try {
                        const [configFile, packageFile] = await Promise.all([
                                fs.promises.readFile(config, 'utf8'),
                                fs.promises.readFile(pack, 'utf8'),
                        ]);
                        const configObj = JSON.parse(configFile);
                        const packageObj = JSON.parse(packageFile);

                        configObj.id = packageObj.name;

                        // Minor adjustments for API output
                        configObj.type = 'local';
                        if (configObj.screenshot) {
                                configObj.screenshot_url = `${nconf.get('relative_path')}/css/previews/${encodeURIComponent(configObj.id)}`;
                        } else {
                                configObj.screenshot_url = `${nconf.get('relative_path')}/assets/images/themes/default.png`;
                        }

                        return configObj;
                } catch (err) {
                        if (err.code === 'ENOENT') {
                                return false;
                        }

                        winston.error(`[themes] Unable to parse theme.json ${theme}`);
                        return false;
                }
        }));

        return themes.filter(Boolean);
};

async function getThemes(themePath) {
        let dirs = await fs.promises.readdir(themePath);
        dirs = dirs.filter(dir => themeNamePattern.test(dir) || dir.startsWith('@'));
        return await Promise.all(dirs.map(async (dir) => {
                try {
                        const dirpath = path.join(themePath, dir);
                        const stat = await fs.promises.stat(dirpath);
                        if (!stat.isDirectory()) {
                                return false;
                        }

                        if (!dir.startsWith('@')) {
                                return dir;
                        }

                        const themes = await getThemes(path.join(themePath, dir));
                        return themes.map(theme => path.join(dir, theme));
                } catch (err) {
                        if (err.code === 'ENOENT') {
                                return false;
                        }

                        throw err;
                }
        }));
}

function throwErr(data, cond, message1, win, message2) {
        console.log('jonathan lai');
        if (win) {
                winston.error(message2);
        }
        if (!cond) {
                throw new Error(message1);
        }
}

Themes.set = async (data) => {
        switch (data.type) {
                case 'local': {
                        const current = await Meta.configs.get('theme:id');
                        const score = await db.sortedSetScore('plugins:active', current);
                        await db.sortedSetRemove('plugins:active', current);
                        await db.sortedSetAdd('plugins:active', score || 0, data.id);

                        if (current !== data.id) {
                                const pathToThemeJson = path.join(nconf.get('themes_path'), data.id, 'theme.json');
                                throwErr(data, pathToThemeJson.startsWith(nconf.get('themes_path')), '[[error:invalid-theme-id]]', false, '');


                                let config = await fs.promises.readFile(pathToThemeJson, 'utf8');
                                config = JSON.parse(config);
                                const activePluginsConfig = nconf.get('plugins:active');
                                if (!activePluginsConfig) {
                                        const score = await db.sortedSetScore('plugins:active', current);
                                        await db.sortedSetRemove('plugins:active', current);
                                        await db.sortedSetAdd('plugins:active', score || 0, data.id);
                                } else {
                                        const winText = `When defining active plugins in configuration, changing themes requires adding the theme '${data.id}' to the list of active plugins before updating it in the ACP`;
                                        throwErr(activePluginsConfig.includes(data.id), '[[error:theme-not-set-in-configuration]]', true, winText);
                                }

                                // Re-set the themes path (for when NodeBB is reloaded)
                                Themes.setPath(config);

                                console.log('jonathan lai');

                                await Meta.configs.setMultiple({
                                        'theme:type': data.type,
                                        'theme:id': data.id,
                                        'theme:staticDir': config.staticDir || '',
                                        'theme:templates': config.templates || '',
                                        'theme:src': '',
                                        bootswatchSkin: '',
                                });

                                await events.log({
                                        type: 'theme-set',
                                        uid: parseInt(data.uid, 10) || 0,
                                        ip: data.ip || '127.0.0.1',
                                        text: data.id,
                                });

                                Meta.reloadRequired = true;
                        }
                        break;
                }
                case 'bootswatch':
                        await Meta.configs.setMultiple({
                                'theme:src': data.src,
                                bootswatchSkin: data.id.toLowerCase(),
                        });
                        break;
        }
};

Themes.setupPaths = async () => {
        const data = await utils.promiseParallel({
                themesData: Themes.get(),
                currentThemeId: Meta.configs.get('theme:id'),
        });

        const themeId = data.currentThemeId || 'nodebb-theme-harmony';

        if (process.env.NODE_ENV === 'development') {
                winston.info(`[themes] Using theme ${themeId}`);
        }

        const themeObj = data.themesData.find(themeObj => themeObj.id === themeId);

        if (!themeObj) {
                throw new Error('theme-not-found');
        }

        Themes.setPath(themeObj);
};

Themes.setPath = function (themeObj) {
        // Theme's templates path
        let themePath;
        const fallback = path.join(nconf.get('themes_path'), themeObj.id, 'templates');

        if (themeObj.templates) {
                themePath = path.join(nconf.get('themes_path'), themeObj.id, themeObj.templates);
        } else if (file.existsSync(fallback)) {
                themePath = fallback;
        } else {
                winston.error('[themes] Unable to resolve this theme\'s templates. Expected to be at "templates/" or defined in the "templates" property of "theme.json"');
                throw new Error('theme-missing-templates');
        }

        nconf.set('theme_templates_path', themePath);
        nconf.set('theme_config', path.join(nconf.get('themes_path'), themeObj.id, 'theme.json'));
};

1	'use strict';
2
3	const path = require('path');	8✔
4	const nconf = require('nconf');	8✔
5	const winston = require('winston');	8✔
6	const _ = require('lodash');	8✔
7	const fs = require('fs');	8✔
8
9	const file = require('../file');	8✔
10	const db = require('../database');	8✔
11	const Meta = require('./index');	8✔
12	const events = require('../events');	8✔
13	const utils = require('../utils');	8✔
14	const { themeNamePattern } = require('../constants');	8✔
15
16	const Themes = module.exports;	8✔
17
18	Themes.get = async () => {	8✔
19	const themePath = nconf.get('themes_path');	10✔
20	if (typeof themePath !== 'string') {	10!
21	return [];	×
22	}
23
24	let themes = await getThemes(themePath);	10✔
25	themes = _.flatten(themes).filter(Boolean);	10✔
26	themes = await Promise.all(themes.map(async (theme) => {	10✔
27	const config = path.join(themePath, theme, 'theme.json');	40✔
28	const pack = path.join(themePath, theme, 'package.json');	40✔
29	try {	40✔
30	const [configFile, packageFile] = await Promise.all([	40✔
31	fs.promises.readFile(config, 'utf8'),
32	fs.promises.readFile(pack, 'utf8'),
33	]);
34	const configObj = JSON.parse(configFile);	40✔
35	const packageObj = JSON.parse(packageFile);	40✔
36
37	configObj.id = packageObj.name;	40✔
38
39	// Minor adjustments for API output
40	configObj.type = 'local';	40✔
41	if (configObj.screenshot) {	40!
42	configObj.screenshot_url = `${nconf.get('relative_path')}/css/previews/${encodeURIComponent(configObj.id)}`;	40✔
43	} else {
44	configObj.screenshot_url = `${nconf.get('relative_path')}/assets/images/themes/default.png`;	×
45	}
46
47	return configObj;	40✔
48	} catch (err) {
49	if (err.code === 'ENOENT') {	×
50	return false;	×
51	}
52
53	winston.error(`[themes] Unable to parse theme.json ${theme}`);	×
54	return false;	×
55	}
56	}));
57
58	return themes.filter(Boolean);	10✔
59	};
60
61	async function getThemes(themePath) {
62	let dirs = await fs.promises.readdir(themePath);	350✔
63	dirs = dirs.filter(dir => themeNamePattern.test(dir) \|\| dir.startsWith('@'));	10,700✔
64	return await Promise.all(dirs.map(async (dir) => {	350✔
65	try {	380✔
66	const dirpath = path.join(themePath, dir);	380✔
67	const stat = await fs.promises.stat(dirpath);	380✔
68	if (!stat.isDirectory()) {	380!
69	return false;	×
70	}
71
72	if (!dir.startsWith('@')) {	380✔
73	return dir;	40✔
74	}
75
76	const themes = await getThemes(path.join(themePath, dir));	340✔
77	return themes.map(theme => path.join(dir, theme));	340✔
78	} catch (err) {
79	if (err.code === 'ENOENT') {	×
80	return false;	×
81	}
82
83	throw err;	×
84	}
85	}));
86	}
87
88	function throwErr(data, cond, message1, win, message2) {
89	console.log('jonathan lai');	49✔
90	if (win) {	49!
NEW 91	winston.error(message2);	×
92	}
93	if (!cond) {	49!
NEW 94	throw new Error(message1);	×
95	}
96	}
97
98	Themes.set = async (data) => {	8✔
99	switch (data.type) {	51✔
100	case 'local': {
101	const current = await Meta.configs.get('theme:id');	50✔
102	const score = await db.sortedSetScore('plugins:active', current);	50✔
103	await db.sortedSetRemove('plugins:active', current);	50✔
104	await db.sortedSetAdd('plugins:active', score \|\| 0, data.id);	50✔
105
106	if (current !== data.id) {	50✔
107	const pathToThemeJson = path.join(nconf.get('themes_path'), data.id, 'theme.json');	49✔
108	throwErr(data, pathToThemeJson.startsWith(nconf.get('themes_path')), '[[error:invalid-theme-id]]', false, '');	49✔
109
110
111	let config = await fs.promises.readFile(pathToThemeJson, 'utf8');	49✔
112	config = JSON.parse(config);	49✔
113	const activePluginsConfig = nconf.get('plugins:active');	49✔
114	if (!activePluginsConfig) {	49!
115	const score = await db.sortedSetScore('plugins:active', current);	49✔
116	await db.sortedSetRemove('plugins:active', current);	49✔
117	await db.sortedSetAdd('plugins:active', score \|\| 0, data.id);	49✔
118	} else {
NEW 119	const winText = `When defining active plugins in configuration, changing themes requires adding the theme '${data.id}' to the list of active plugins before updating it in the ACP`;	×
NEW 120	throwErr(activePluginsConfig.includes(data.id), '[[error:theme-not-set-in-configuration]]', true, winText);	×
121	}
122
123	// Re-set the themes path (for when NodeBB is reloaded)
124	Themes.setPath(config);	49✔
125
126	console.log('jonathan lai');	49✔
127
128	await Meta.configs.setMultiple({	49✔
129	'theme:type': data.type,
130	'theme:id': data.id,
131	'theme:staticDir': config.staticDir \|\| '',	98✔
132	'theme:templates': config.templates \|\| '',	98✔
133	'theme:src': '',
134	bootswatchSkin: '',
135	});
136
137	await events.log({	49✔
138	type: 'theme-set',
139	uid: parseInt(data.uid, 10) \|\| 0,	98✔
140	ip: data.ip \|\| '127.0.0.1',	98✔
141	text: data.id,
142	});
143
144	Meta.reloadRequired = true;	49✔
145	}
146	break;	50✔
147	}
148	case 'bootswatch':
149	await Meta.configs.setMultiple({	1✔
150	'theme:src': data.src,
151	bootswatchSkin: data.id.toLowerCase(),
152	});
153	break;	1✔
154	}
155	};
156
157	Themes.setupPaths = async () => {	8✔
158	const data = await utils.promiseParallel({	9✔
159	themesData: Themes.get(),
160	currentThemeId: Meta.configs.get('theme:id'),
161	});
162
163	const themeId = data.currentThemeId \|\| 'nodebb-theme-harmony';	9!
164
165	if (process.env.NODE_ENV === 'development') {	9!
166	winston.info(`[themes] Using theme ${themeId}`);	×
167	}
168
169	const themeObj = data.themesData.find(themeObj => themeObj.id === themeId);	36✔
170
171	if (!themeObj) {	9!
172	throw new Error('theme-not-found');	×
173	}
174
175	Themes.setPath(themeObj);	9✔
176	};
177
178	Themes.setPath = function (themeObj) {	8✔
179	// Theme's templates path
180	let themePath;
181	const fallback = path.join(nconf.get('themes_path'), themeObj.id, 'templates');	58✔
182
183	if (themeObj.templates) {	58!
184	themePath = path.join(nconf.get('themes_path'), themeObj.id, themeObj.templates);	×
185	} else if (file.existsSync(fallback)) {	58!
186	themePath = fallback;	58✔
187	} else {
188	winston.error('[themes] Unable to resolve this theme\'s templates. Expected to be at "templates/" or defined in the "templates" property of "theme.json"');	×
189	throw new Error('theme-missing-templates');	×
190	}
191
192	nconf.set('theme_templates_path', themePath);	58✔
193	nconf.set('theme_config', path.join(nconf.get('themes_path'), themeObj.id, 'theme.json'));	58✔
194	};

CMU-313 / NodeBB / 10712361095

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