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

'use strict';

const fs = require('fs');
const path = require('path');

const CONFIG_FILE_NAME = Symbol('configuration file name');
const LOCATIONS = Symbol('configuration file location');
const SERIALIZERS = Symbol('configuration file serializers');

function suffixPath(configLocation, configFileName) {
	const suffix = path.sep + configFileName;
	return configLocation.substr(-suffix.length) !== suffix
		? configLocation + suffix
		: configLocation;
}

function readJsonOrReturnObject(jsonPath) {
	try {
		return JSON.parse(fs.readFileSync(jsonPath));
	} catch (_error) {
		return {};
	}
}

/**
 * Manages a unified configuration file for all modules that register their config.
 */
class ConfigManager {
	/**
	 * @param {Array} possibleLocations  A list of possible config file locations, from high to low priority.
	 * @param {string} configFileName    The name of the config file.
	 *
	 * @constructor
	 */
	constructor(possibleLocations, configFileName) {
		this[CONFIG_FILE_NAME] = configFileName;
		this[LOCATIONS] = possibleLocations.filter(possibleLocation => !!possibleLocation);
		this[SERIALIZERS] = {};

		if (!this[LOCATIONS].length) {
			throw new Error('No config location');
		}

		this.read();
	}

	/**
	 * @param {string} configName   A key of the configuration object that you can share with other modules, or not.
	 * @param {*}      defaultValue If no configuration is found, use this.
	 * @param {*|function(config): ?*} [serialize]
	 *
	 * @return {*}
	 */
	registerConfig(configName, defaultValue, serialize) {
		if (!this[configName]) {
			this[configName] = defaultValue || null;
		}

		Object.assign(this[SERIALIZERS], {
			[configName]: serialize
		});

		return this[configName];
	}

	/**
	 * Checks the path & exist status for all possible configuration file locations.
	 *
	 * @return {Array}
	 */
	getStatus() {
		return this[LOCATIONS].filter(configLocation => !!configLocation)
			.map(configLocation => suffixPath(configLocation, this[CONFIG_FILE_NAME]))
			.map(configLocation => ({
				path: configLocation,
				exists: fs.existsSync(configLocation)
			}));
	}

	/**
	 * Read all possible configuration files and assign them to one new object.
	 */
	read() {
		Object.assign(
			this,
			this.getStatus().reduce(
				(config, file) =>
					file.exists ? Object.assign(readJsonOrReturnObject(file.path), config) : config,
				{}
			)
		);
	}

	/**
	 * Save a stringified version of the configuration object to a given location.
	 *
	 * @param {string} configLocation (Preferably absolute) path to the dot-rc file, or its intended directory.
	 *
	 * @return {Promise} Resolves to the successful configuration location.
	 */
	save(configLocation) {
		if (!configLocation) {
			const configStatus = this.getStatus();
			configLocation = (
				configStatus.find(loc => loc.exists) || configStatus[configStatus.length - 1]
			).path;
		}

		const suffix = path.sep + this[CONFIG_FILE_NAME];
		if (configLocation.substr(-suffix.length) !== suffix) {
			configLocation += suffix;
		}

		return new Promise((resolve, reject) =>
			fs.writeFile(configLocation, this.toString(), error => {
				return error ? reject(error) : resolve(configLocation);
			})
		);
	}

	/**
	 * Prepare a stringified version of the configuration object - one that can be deserialized too.
	 *
	 * @return {string}
	 */
	toString() {
		const serializedConfig = Object.keys(this[SERIALIZERS]).reduce((config, serializerName) => {
			const serializerFn = this[SERIALIZERS][serializerName];
			const serialized =
				typeof serializerFn === 'function'
					? serializerFn(this[serializerName])
					: this[serializerName];

			return serialized !== null && serialized !== undefined
				? Object.assign(config, {
						[serializerName]: serialized
				  })
				: config;
		}, {});

		return JSON.stringify(serializedConfig, null, '\t');
	}
}

module.exports = ConfigManager;