Refactor to allow stylelint-order access to sorting without running postcss-sorting as plugin

Author: hudochenkov

index.js

@@ -1,7 +1,8 @@
-const order = require('./lib/order');
-const propertiesOrder = require('./lib/properties-order');
 const validateOptions = require('./lib/validateOptions');
 const isString = require('./lib/isString');
+const getContainingNode = require('./lib/getContainingNode');
+const sortNode = require('./lib/order/sortNode');
+const sortNodeProperties = require('./lib/properties-order/sortNodeProperties');
 
 module.exports = (opts) => {
 	return {
@@ -37,10 +38,21 @@ function plugin(css, opts) {
 	}
 
 	if (opts.order) {
-		order(css, opts);
+		css.walk((input) => {
+			const node = getContainingNode(input);
+
+			sortNode(node, opts.order);
+		});
 	}
 
 	if (opts['properties-order']) {
-		propertiesOrder(css, opts);
+		css.walk((input) => {
+			const node = getContainingNode(input);
+
+			sortNodeProperties(node, {
+				order: opts['properties-order'],
+				unspecifiedPropertiesPosition: opts['unspecified-properties-position'] || 'bottom',
+			});
+		});
 	}
 }

lib/order/index.js

@@ -0,0 +1,36 @@
+const createExpectedOrder = require('../createExpectedOrder');
+const isRuleWithNodes = require('../isRuleWithNodes');
+const processLastComments = require('../processLastComments');
+const processMostNodes = require('../processMostNodes');
+const sorting = require('../sorting');
+
+module.exports = function sortNode(node, optsOrder) {
+	if (!isRuleWithNodes(node)) {
+		return;
+	}
+
+	const expectedOrder = createExpectedOrder(optsOrder);
+
+	// Nodes for sorting
+	let processed = [];
+
+	// Add indexes to nodes
+	node.each((childNode, index) => {
+		processed = processMostNodes(childNode, index, expectedOrder, processed);
+	});
+
+	// Add last comments in the rule. Need this because last comments are not belonging to anything
+	node.each((childNode, index) => {
+		processed = processLastComments(childNode, index, processed);
+	});
+
+	// Sort declarations saved for sorting
+	processed.sort(sorting.sortByIndexes);
+
+	// Enforce semicolon for the last node
+	node.raws.semicolon = true;
+
+	// Replace rule content with sorted one
+	node.removeAll();
+	node.append(processed);
+};

lib/order/sortNode.js

@@ -0,0 +1,83 @@
+let createExpectedPropertiesOrder = require('../createExpectedPropertiesOrder');
+let getComments = require('../getComments');
+let getPropertiesOrderData = require('../getPropertiesOrderData');
+let isCustomProperty = require('../isCustomProperty');
+let isRuleWithNodes = require('../isRuleWithNodes');
+let isStandardSyntaxProperty = require('../isStandardSyntaxProperty');
+let sorting = require('../sorting');
+let vendor = require('../vendor');
+
+module.exports = function sortNodeProperties(node, { order, unspecifiedPropertiesPosition }) {
+	if (!isRuleWithNodes(node)) {
+		return;
+	}
+
+	let isAlphabetical = order === 'alphabetical';
+	let expectedOrder = isAlphabetical ? null : createExpectedPropertiesOrder(order);
+
+	let allRuleNodes = [];
+	let declarations = [];
+
+	node.each((childNode, index) => {
+		if (
+			childNode.type === 'decl' &&
+			isStandardSyntaxProperty(childNode.prop) &&
+			!isCustomProperty(childNode.prop)
+		) {
+			let unprefixedPropName = vendor.unprefixed(childNode.prop);
+
+			// Hack to allow -moz-osx-font-smoothing to be understood
+			// just like -webkit-font-smoothing
+			if (unprefixedPropName.indexOf('osx-') === 0) {
+				unprefixedPropName = unprefixedPropName.slice(4);
+			}
+
+			let propData = {
+				name: childNode.prop,
+				unprefixedName: unprefixedPropName,
+				orderData: isAlphabetical
+					? null
+					: getPropertiesOrderData(expectedOrder, unprefixedPropName),
+				node: childNode,
+				initialIndex: index,
+				unspecifiedPropertiesPosition,
+			};
+
+			// add a marker
+			childNode.sortProperty = true;
+
+			// If comment on separate line before node, use node's indexes for comment
+			let commentsBefore = getComments.beforeDeclaration([], childNode.prev(), propData);
+
+			// If comment on same line with the node and node, use node's indexes for comment
+			let commentsAfter = getComments.afterDeclaration([], childNode.next(), propData);
+
+			declarations = declarations.concat(commentsBefore, propData, commentsAfter);
+		}
+	});
+
+	if (isAlphabetical) {
+		declarations.sort(sorting.sortDeclarationsAlphabetically);
+	} else {
+		declarations.sort(sorting.sortDeclarations);
+	}
+
+	let foundDeclarations = false;
+
+	node.each((childNode) => {
+		if (childNode.sortProperty) {
+			if (!foundDeclarations) {
+				foundDeclarations = true;
+
+				declarations.forEach((item) => {
+					allRuleNodes.push(item.node);
+				});
+			}
+		} else {
+			allRuleNodes.push(childNode);
+		}
+	});
+
+	node.removeAll();
+	node.append(allRuleNodes);
+};