@fontoxml/fontoxml-development-tools/src/App.js

import ask from 'ask-nicely';
import { readFileSync } from 'fs';
import os from 'os';
import path from 'path';
import { fileURLToPath } from 'url';

import addCoreModulesToApp from './addCoreModulesToApp.js';
import addModulesToApp from './addModulesToApp.js';
import AssertableWritableStream from './AssertableWritableStream.js';
import ConfigManager from './ConfigManager.js';
import createConfigFileInHomedir from './createConfigFileInHomedir.js';
import enrichRequestObject from './enrichRequestObject.js';
import FdtCommand from './FdtCommand.js';
import getParentDirectoryContainingFileSync from './getParentDirectoryContainingFileSync.js';
import ModuleRegistrationApi from './ModuleRegistrationApi.js';
import FdtResponse from './response/FdtResponse.js';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

let packageJson = {};
try {
	packageJson = JSON.parse(
		readFileSync(path.resolve(__dirname, '..', 'package.json'), 'utf8')
	);
} catch (_err) {
	// TODO: Handle this error properly.
	// Ignore
}

const DEFAULT_OPTIONS = {
	appName: 'fdt',
	appVersion: packageJson.version,
	catchErrors: true,
	commandClass: FdtCommand,
	configFilename: '.fdtrc',
	configHomedirPath: os.homedir(),
	configPath: path.join(__dirname, '..'),
	hideStacktraceOnErrors: !process.env.FDT_STACK_TRACE_ON_ERROR,
};

function enableTestMode(options) {
	options.catchErrors = false;
	options.useTestOutput = true;

	if (!options.configFilename) {
		options.configFilename = '.fdttestrc';
	}

	/* istanbul ignore else */
	if (options.skipCreateConfigFileInHomedir === undefined) {
		options.skipCreateConfigFileInHomedir = true;
	}
}

function enableTestOutput(app, options) {
	if (options.stdout === undefined && options.silent === undefined) {
		app.testOutput = new AssertableWritableStream({ stripAnsi: true });
		options.stdout = app.testOutput;
	}
}

export default class FontoXMLDevelopmentToolsApp {
	/**
	 * Initializes this instance of the FontoXMLDevelopmentToolsApp.
	 *
	 * @param {object} [options]
	 *     An optional options object.
	 * @param {string} [options.appName]
	 *     The name to use for the app. Default: 'fdt'.
	 * @param {string} [options.appVersion]
	 *     The current version of the app. Default: from package.json.
	 * @param {boolean} [options.catchErrors]
	 *     When set to false, run errors are thrown instead of being pretty outputted. Default: true.
	 * @param {function(): FdtCommand} [options.commandClass]
	 *     The Command class constructor to use for all commands, must inherit from fdt.FdtCommand.
	 * @param {boolean} [options.configFilename]
	 *     The filename to use for finding, loading, and saving configuration files. Default: '.fdtrc'.
	 * @param {boolean} [options.configHomedirPath]
	 *     The homedir to use for storing configuration. Default: os.homedir().
	 * @param {boolean} [options.configPath]
	 *     The path to the build in configuration file. Default: <the root directory of this package>.
	 * @param {boolean} [options.hideStacktraceOnErrors]
	 *     When set to true, the stacktrace is not outputted when errors are outputted. Default: !process.env.FDT_STACK_TRACE_ON_ERROR.
	 * @param {boolean} [options.silent]
	 *     Disables outputting to options.stdout.
	 * @param {boolean} [options.skipAddModules]
	 *     When set to true, skip loading of the built-in Fonto related modules.
	 * @param {boolean} [options.skipCreateConfigFileInHomedir]
	 *     When set to true, skip creating a configuration file in the home directory on start if it does not exist.
	 * @param {boolean} [options.skipEnrichRequestObject]
	 *     When set to true, skip adding the fdt property to the request object.
	 * @param {WritableStream} [options.stdout]
	 *     Stream to use for output, instead of stdout.
	 * @param {boolean} [options.testMode]
	 *     When set to true, enable test mode. This is meant for unit tests and will do the following:
	 *         - Set configFilename to '.fdttestrc' (if no explicit value was set).
	 *         - Set skipCreateConfigFileInHomedir to true (if no explicit value was set).
	 *         - Set useTestOutput to true.
	 * @param {boolean} [options.useTestOutput]
	 *     When set to true, enable test output. This is meant for unit tests and will do the following:
	 *         - Output everything to .testOutput stream which has some helper methods for unit testing.
	 */
	async init(options = {}) {
		// const appObject = new FontoXMLDevelopmentToolsApp();
		/* istanbul ignore else: All tests should be run in testmode to prevent configuration conflicts */
		if (options.testMode) {
			enableTestMode(options);
		}

		/* istanbul ignore else: All tests should be run using test output to prevent output conflicts */
		if (options.useTestOutput) {
			enableTestOutput(this, options);
		}

		// Default options, but AFTER test mode options have been determined.
		options = { ...DEFAULT_OPTIONS, ...options };

		this.name = options.appName;
		this.version = options.appVersion;

		this.catchErrors = options.catchErrors;
		this.hideStacktraceOnErrors = !!options.hideStacktraceOnErrors;
		this.processPath = process.cwd();

		let configLocation = getParentDirectoryContainingFileSync(
			this.processPath,
			options.configFilename
		);

		if (!configLocation) {
			// Instantiate with a configuration file from either the FDT directory or your home directory.
			/* istanbul ignore if: All tests should skip creating the config file in the homedir */
			if (!options.skipCreateConfigFileInHomedir) {
				createConfigFileInHomedir(options);
			}

			configLocation = options.configHomedirPath;
		}

		this.config = new ConfigManager(
			configLocation,
			options.configPath,
			options.configFilename
		);

		// TODO: Refactor to also integrate AskNicely.
		const colorConfig = null; // TODO: Windows color config.
		/* istanbul ignore next */
		this.logger = new FdtResponse(colorConfig, {
			indentation: '  ',
			stdout: options.silent
				? { write: () => {} }
				: options.stdout || process.stdout,
		});

		const CommandClass = options.commandClass;
		if (
			CommandClass !== FdtCommand &&
			!(CommandClass.prototype instanceof FdtCommand)
		) {
			throw new Error(
				'Optional option commandClass does not inherit from FdtCommand.'
			);
		}
		this.cli = new CommandClass(this.name);
		Object.assign(this.cli, ask);

		this.modules = [];
		this.builtInModules = [];
		await addCoreModulesToApp(this, options);

		this.request = Object.create(null);
		if (!options.skipEnrichRequestObject) {
			await enrichRequestObject(this);
		}

		if (!options.skipAddModules) {
			await addModulesToApp(this);
		}
		return this;
	}

	/**
	 * Retrieve the path to a registered module by its name.
	 *
	 * @param {string} moduleName The name of the module (see its package.json).
	 *
	 * @return {(string|undefined)}
	 */
	getPathToModule(moduleName) {
		for (const module of this.modules) {
			const moduleInfo = module.getInfo();
			if (moduleInfo.name === moduleName) {
				return moduleInfo.path;
			}
		}
		return undefined;
	}

	/**
	 * Built in modules are not saved to the config files. These modules can be added at runtime.
	 * This is useful when creating a tools bundle powered by fdt.
	 *
	 * @param {string} modulePath The absolute path to the module to enable.
	 * @param {...*}   [extra] Extra parameters which can be used by the module, only used for built-in modules.
	 *
	 * @return {(ModuleRegistrationApi|null)}
	 */
	async enableBuiltInModule(modulePath, ...extra) {
		const enabledModule = await this.enableModule(modulePath, ...extra);

		if (enabledModule) {
			this.builtInModules.push(enabledModule);
		}

		return enabledModule;
	}

	/**
	 * Enable a module, which can be saved to the config file.
	 *
	 * @param {string} modulePath The absolute path to the module to enable.
	 * @param {...*}   [extra] Extra parameters which can be used by the module, only used for built-in modules.
	 *
	 * @return {(ModuleRegistrationApi|null)}
	 */
	async silentEnableModule(modulePath, ...extra) {
		const enabledModule = new ModuleRegistrationApi(this, modulePath);
		const modInfo = enabledModule.getInfo();

		const modulesWithSameName = this.modules.filter(
			(mod) => mod.getInfo().name === modInfo.name
		);
		if (modulesWithSameName.length) {
			return null;
		}

		await enabledModule.load(...extra);

		this.modules.push(enabledModule);

		return enabledModule;
	}

	/**
	 * Enable a module, which can be saved to the config file. Outputs notice when the module is a duplicate.
	 *
	 * @param {string} modulePath The absolute path to the module to enable.
	 * @param {...*}   [extra] Extra parameters which can be used by the module, only used for built-in modules.
	 *
	 * @return {(ModuleRegistrationApi|null)}
	 */
	async enableModule(modulePath, ...extra) {
		let enabledModule = await this.silentEnableModule(modulePath, ...extra);

		if (!enabledModule) {
			enabledModule = new ModuleRegistrationApi(this, modulePath);
			const modInfo = enabledModule.getInfo();
			const moduleWithSameName = this.modules
				.filter((mod) => mod.getInfo().name === modInfo.name)
				.map((mod) => {
					const info = mod.getInfo();
					return info.path + (info.builtIn ? ' (built-in)' : '');
				});
			this.logger.break();
			this.logger.notice(
				`Not loading module with name "${modInfo.path}", a module with the same name is already loaded.`
			);
			this.logger.list(moduleWithSameName, '-');
			this.logger.debug(
				`You can check your modules with \`${
					this.getInfo().name
				} module --list --verbose\` and remove the conflicting module(s) with \`${
					this.getInfo().name
				} module --remove <modulePath>\`.`
			);
			return null;
		}

		return enabledModule;
	}

	/**
	 * Returns an object with information that a module could use to reason about which fdt instance it is used for.
	 *
	 * @return {{name: *, version: ?string}}
	 */
	getInfo() {
		return {
			name: this.name,
			version: this.version,
		};
	}

	/**
	 * Run a (sub) command based on args. It uses this.request as request by default.
	 *
	 * @param {Array<string>} args    The arguments, specifying which (sub) command to run with what options and parameters.
	 * @param {Object}        request Optionally a request object, should not be specified. Default: this.request.
	 *
	 * @return {Promise.<TResult>}
	 */
	run(args, request) {
		const executedRequest = this.cli.execute(
			Object.assign([], args),
			{ ...(request || this.request) },
			this.logger
		);

		if (!this.catchErrors) {
			return executedRequest;
		}

		return executedRequest
			.catch((error) => {
				this.error(undefined, error, {
					cwd: this.processPath,
					node: `Version ${process.version} running on ${process.platform} ${process.arch}.`,
					fdt: `Version ${this.version}.`,
					args: [this.name]
						.concat(
							args.map((arg) =>
								arg.indexOf(' ') >= 0 ? `"${arg}"` : arg
							)
						)
						.join(' '),
					mods: this.modules
						.map(
							(mod) =>
								`${mod.getInfo().name} (${
									mod.getInfo().version
								})`
						)
						.join(os.EOL),
				});

				// Do not hard exit program, but rather exit with error code once the program is closing itself
				/* istanbul ignore next: Process will not exit untill unit tests are done. */
				process.on('exit', function () {
					process.exit(1);
				});
			})
			.then(() => {
				/* istanbul ignore next: We might be on either os when running the unit tests. */
				if (os.platform() !== 'win32') {
					this.logger.break();
				}
				return this;
			});
	}

	/**
	 * @param {string}                                                 caption
	 * @param {Error|ErrorWithInnerError|ErrorWithSolution|InputError} error
	 * @param {Object}                                                 [debugVariables]
	 */
	error(caption, error, debugVariables) {
		this.logger.destroyAllSpinners();

		if (
			error instanceof this.logger.ErrorWithInnerError ||
			error instanceof this.logger.ErrorWithSolution
		) {
			this.logger.caption('Error');
			this.logger.error(error.message);
			if (error.solution) {
				this.logger.break();
				this.logger.notice(error.solution);
			}
			if (!this.hideStacktraceOnErrors) {
				if (error.innerError) {
					this.logger.indent();
					this.logger.caption('Inner error');
					this.logger.debug(
						error.innerError.stack || error.innerError
					);
					this.logger.outdent();
				}
				if (debugVariables) {
					this.logger.properties(debugVariables);
				}
			}
			return;
		}
		if (
			error instanceof this.cli.InputError ||
			error instanceof this.logger.InputError
		) {
			this.logger.caption('Input error');
			this.logger.error(error.message);
			this.logger.break();
			this.logger.notice(
				'You might be able to fix this, use the "--help" flag for usage info.'
			);
			if (error.solution) {
				this.logger.log(error.solution);
			}
			if (!this.hideStacktraceOnErrors && debugVariables) {
				this.logger.properties(debugVariables);
			}
			return;
		}

		this.logger.caption(caption || 'Error');

		if (error) {
			this.logger.error(error.message || error.stack || error);
		}

		if (error.solution) {
			this.logger.break();
			this.logger.notice(error.solution);
		}

		if (!this.hideStacktraceOnErrors) {
			if (error && error.stack) {
				this.logger.indent();
				this.logger.debug(error.stack);
				this.logger.outdent();
			}

			if (debugVariables) {
				this.logger.properties(debugVariables);
			}
		}
	}
}