Show more descriptive error messages for invalid config #65

Author: hudochenkov

lib/validateOptions.js

@@ -11,24 +11,33 @@ module.exports = function validateOptions(options) {
 		return reportError('Options should be an object.');
 	}
 
-	if (!_.isUndefined(options.order) && !_.isNull(options.order) && !validateOrder(options.order)) {
-		return reportInvalidOption('order');
+	if (!_.isUndefined(options.order) && !_.isNull(options.order)) {
+		const { isValid, message } = validateOrder(options.order);
+
+		if (!isValid) {
+			return reportInvalidOption('order', message);
+		}
 	}
 
-	if (
-		!_.isUndefined(options['properties-order']) &&
-		!_.isNull(options['properties-order']) &&
-		!validatePropertiesOrder(options['properties-order'])
-	) {
-		return reportInvalidOption('properties-order');
+	if (!_.isUndefined(options['properties-order']) && !_.isNull(options['properties-order'])) {
+		const { isValid, message } = validatePropertiesOrder(options['properties-order']);
+
+		if (!isValid) {
+			return reportInvalidOption('properties-order', message);
+		}
 	}
 
 	if (
 		!_.isUndefined(options['unspecified-properties-position']) &&
-		!_.isNull(options['unspecified-properties-position']) &&
-		!validateUnspecifiedPropertiesPosition(options['unspecified-properties-position'])
+		!_.isNull(options['unspecified-properties-position'])
 	) {
-		return reportInvalidOption('unspecified-properties-position');
+		const { isValid, message } = validateUnspecifiedPropertiesPosition(
+			options['unspecified-properties-position']
+		);
+
+		if (!isValid) {
+			return reportInvalidOption('unspecified-properties-position', message);
+		}
 	}
 
 	return true;
@@ -38,46 +47,68 @@ function reportError(errorMessage) {
 	return `postcss-sorting: ${errorMessage}`;
 }
 
-function reportInvalidOption(optionName) {
-	return reportError(`Invalid "${optionName}" option value`);
+function reportInvalidOption(optionName, optionError) {
+	optionError = optionError || 'Invalid value';
+
+	return reportError(`${optionName}: ${optionError}`);
+}
+
+function keywordsList(keywords) {
+	return keywords.reduce(function(accumulator, value, index) {
+		const comma = index === 0 ? '' : ', ';
+
+		return accumulator + comma + value;
+	}, '');
 }
 
 function validateOrder(options) {
 	// Otherwise, begin checking array options
 	if (!Array.isArray(options)) {
-		return false;
+		return {
+			isValid: false,
+			message: 'Should be an array',
+		};
 	}
 
+	const keywords = ['custom-properties', 'dollar-variables', 'declarations', 'rules', 'at-rules'];
+
 	// Every item in the array must be a certain string or an object
 	// with a "type" property
 	if (
 		!options.every(item => {
 			if (_.isString(item)) {
-				return _.includes(
-					['custom-properties', 'dollar-variables', 'declarations', 'rules', 'at-rules'],
-					item
-				);
+				return _.includes(keywords, item);
 			}
 
 			return _.isPlainObject(item) && !_.isUndefined(item.type);
 		})
 	) {
-		return false;
+		return {
+			isValid: false,
+			message: `Every item in the array must be an object with a "type" property, or one of keywords: ${keywordsList(
+				keywords
+			)}.`,
+		};
 	}
 
 	const objectItems = options.filter(_.isPlainObject);
+	let wrongObjectItem;
 
 	if (
 		!objectItems.every(item => {
 			let result = true;
 
 			if (item.type !== 'at-rule' && item.type !== 'rule') {
+				wrongObjectItem = `"type" could be 'at-rule' or 'rule' only`;
+
 				return false;
 			}
 
 			if (item.type === 'at-rule') {
 				// if parameter is specified, name should be specified also
 				if (!_.isUndefined(item.parameter) && _.isUndefined(item.name)) {
+					wrongObjectItem = `"at-rule" with "parameter" should also has a "name"`;
+
 					return false;
 				}
 
@@ -101,34 +132,64 @@ function validateOrder(options) {
 				}
 			}
 
+			if (!result) {
+				wrongObjectItem = `Following option is incorrect: ${JSON.stringify(item)}`;
+			}
+
 			return result;
 		})
 	) {
-		return false;
+		return {
+			isValid: false,
+			message: wrongObjectItem,
+		};
 	}
 
-	return true;
+	return {
+		isValid: true,
+	};
 }
 
 function validatePropertiesOrder(options) {
 	// Return true early if alphabetical
 	if (options === 'alphabetical') {
-		return true;
+		return {
+			isValid: true,
+		};
 	}
 
 	// Otherwise, begin checking array options
 	if (!Array.isArray(options)) {
-		return false;
+		return {
+			isValid: false,
+			message: 'Should be an array',
+		};
 	}
 
 	// Every item in the array must be a string
 	if (!options.every(item => _.isString(item))) {
-		return false;
+		return {
+			isValid: false,
+			message: 'Array should contain strings only',
+		};
 	}
 
-	return true;
+	return {
+		isValid: true,
+	};
 }
 
 function validateUnspecifiedPropertiesPosition(options) {
-	return _.isString(options) && _.includes(['top', 'bottom', 'bottomAlphabetical'], options);
+	const keywords = ['top', 'bottom', 'bottomAlphabetical'];
+
+	if (_.isString(options) && _.includes(keywords, options)) {
+		return {
+			isValid: true,
+		};
+	}
+
+	return {
+		isValid: false,
+		message: `Option should be one of the following values: ${keywordsList(keywords)}.`,
+	};
 }