postcss-sorting - npm Package Compare versions

Comparing version 1.2.0 to 1.2.1

index.js

@@ -5,8 +5,14 @@ var postcss = require('postcss');
 
-function getSortOrder(options) {
-    // If no options use default config
-    if (options === null || typeof options !== 'object' || !options['sort-order']) {
-        options = { 'sort-order': 'default' };
+function verifyOptions(options) {
+    if (options === null || typeof options !== 'object') {
+        options = {};
     }
 
+    options['sort-order'] = options['sort-order'] || 'default';
+    options['empty-lines-between-children-rules'] = options['empty-lines-between-children-rules'] || 0;
+
+    return options;
+}
+
+function getSortOrderFromOptions(options) {
     var sortOrder;
@@ -33,11 +39,4 @@
 
-    if (typeof sortOrder[0] === 'string') {
-        sortOrder.forEach(function (prop, propIndex) {
-            order[prop] = {
-                group: 0,
-                prop: propIndex
-            };
-        });
-    } else {
-        sortOrder.forEach(function (group, groupIndex) {
+    (typeof sortOrder[0] === 'string' ? [sortOrder] : sortOrder)
+        .forEach(function (group, groupIndex) {
             group.forEach(function (prop, propIndex) {
@@ -50,3 +49,2 @@ order[prop] = {
         });
-    }
 
@@ -56,2 +54,12 @@ return order;
 
+function getLinesBetweenChildrenFromOptions(options) {
+    var lines = options['empty-lines-between-children-rules'];
+
+    if (typeof lines !== 'number' || isNaN(lines) || !isFinite(lines) || lines < 0 || Math.floor(lines) !== lines) {
+        throw new Error('Type of "empty-lines-between-children-rules" option must be integer with positive value.');
+    }
+
+    return lines;
+}
+
 // Replace multiple line breaks with one
@@ -70,22 +78,101 @@ function cleanLineBreaks(node) {
 
-function getLinesBetweenChildrenFromOptions(opts) {
-    var options = opts || {};
-    var lines = options['empty-lines-between-children-rules'];
+function getAtruleSortName(node, order) {
+    var atruleName = '@' + node.name;
 
-    if (lines === undefined || lines === null) {
-        return 0;
+    // If atRule has a parameter like @mixin name or @include name, sort by this parameter
+    var atruleParameter = /^[\w-]+/.exec(node.params);
+
+    if (atruleParameter && atruleParameter.length) {
+        var sortNameExtended = atruleName + ' ' + atruleParameter[0];
+
+        if (order[sortNameExtended]) {
+            return sortNameExtended;
+        }
     }
 
-    if (typeof lines !== 'number' || isNaN(lines) || !isFinite(lines) || lines < 0 || Math.floor(lines) !== lines) {
-        throw new Error('Type of "empty-lines-between-children-rules" option must be integer with positive value.');
+    // If atrule with name is in order use the name
+    if (order[atruleName]) {
+        return atruleName;
     }
 
-    return lines;
+    return '@atrule';
 }
 
+function getSortName(node, order) {
+    switch (node.type) {
+    case 'decl':
+        return /^\$[\w-]+/.test(node.prop) ? '$variable' : node.prop;
+
+    case 'atrule':
+        return getAtruleSortName(node, order);
+
+    case 'rule':
+        return '>child';
+
+    default:
+        return null;
+    }
+}
+
+function getOrderProperty(node, order) {
+    var sortName = getSortName(node, order);
+
+    // Trying to get property indexes from order's list
+    var orderProperty = order[sortName];
+
+    // If no property in the list and this property is prefixed then trying to get parameters for unprefixed property
+    if (!orderProperty && postcss.vendor.prefix(sortName)) {
+        sortName = postcss.vendor.unprefixed(sortName);
+        orderProperty = order[sortName];
+    }
+
+    return orderProperty;
+}
+
+function fetchAllCommentsBeforeNode(comments, previousNode, node, currentInitialIndex) {
+    if (!previousNode || previousNode.type !== 'comment') {
+        return comments;
+    }
+
+    if (!previousNode.raws.before || previousNode.raws.before.indexOf('\n') === -1) {
+        return comments;
+    }
+
+    currentInitialIndex = currentInitialIndex || node.initialIndex;
+
+    previousNode.groupIndex = node.groupIndex;
+    previousNode.propertyIndex = node.propertyIndex;
+    previousNode.initialIndex = currentInitialIndex - 0.0001;
+
+    var previousNodeClone = cleanLineBreaks(previousNode);
+    var newComments = [previousNodeClone].concat(comments);
+
+    return fetchAllCommentsBeforeNode(newComments, previousNode.prev(), node, previousNode.initialIndex);
+}
+
+function fetchAllCommentsAfterNode(comments, nextNode, node, currentInitialIndex) {
+    if (!nextNode || nextNode.type !== 'comment') {
+        return comments;
+    }
+
+    if (!nextNode.raws.before || nextNode.raws.before.indexOf('\n') >= 0) {
+        return comments;
+    }
+
+    currentInitialIndex = currentInitialIndex || node.initialIndex;
+
+    nextNode.groupIndex = node.groupIndex;
+    nextNode.propertyIndex = node.propertyIndex;
+    nextNode.initialIndex = currentInitialIndex + 0.0001;
+
+    return fetchAllCommentsAfterNode(comments.concat(nextNode), nextNode.next(), node, nextNode.initialIndex);
+}
+
 module.exports = postcss.plugin('postcss-sorting', function (opts) {
-    var linesBetweenChildrenRules = getLinesBetweenChildrenFromOptions(opts);
+    // Verify options and use defaults if not specified
+    opts = verifyOptions(opts);
 
     return function (css) {
-        var order = getSortOrder(opts);
+        var order = getSortOrderFromOptions(opts);
+        var linesBetweenChildrenRules = getLinesBetweenChildrenFromOptions(opts);
 
@@ -104,46 +191,8 @@ // Index to place the nodes that shouldn't be sorted
                 rule.each(function (node, index) {
-                    var sortName = null;
-
                     if (node.type === 'comment') {
                         return;
-                    } else if (node.type === 'decl') {
-                        sortName = node.prop;
-
-                        // If property start with $ and letters it's a variable
-                        if (/^\$[\w-]+/.test(node.prop)) {
-                            sortName = '$variable';
-                        }
-                    } else if (node.type === 'atrule') {
-                        sortName = '@atrule';
-
-                        // If atrule with name is in order use the name
-                        var atruleName = '@' + node.name;
-
-                        if (order[atruleName]) {
-                            sortName = atruleName;
-                        }
-
-                        // Ff atRule has a parameter like @mixin name or @include name, sort by this parameter
-                        var atruleParameter = /^[\w-]+/.exec(node.params);
-
-                        if (atruleParameter && atruleParameter.length) {
-                            var sortNameExtended = atruleName + ' ' + atruleParameter[0];
-
-                            if (order[sortNameExtended]) {
-                                sortName = sortNameExtended;
-                            }
-                        }
-                    } else if (node.type === 'rule') {
-                        sortName = '>child';
                     }
 
-                    // Trying to get property indexes from order's list
-                    var orderProperty = order[sortName];
+                    var orderProperty = getOrderProperty(node, order);
 
-                    // If no property in the list and this property is prefixed then trying to get parameters for unprefixed property
-                    if (!orderProperty && postcss.vendor.prefix(sortName)) {
-                        sortName = postcss.vendor.unprefixed(sortName);
-                        orderProperty = order[sortName];
-                    }
-
                     // If the declaration's property is in order's list, save its
@@ -157,43 +206,8 @@ // group and property indexes. Otherwise set them to 10000, so
                     // If comment on separate line before node, use node's indexes for comment
-                    var commentsBefore = [];
-                    var previousNode = node.prev();
+                    var commentsBefore = fetchAllCommentsBeforeNode([], node.prev(), node);
 
-                    while (previousNode && previousNode.type === 'comment') {
-                        if (previousNode.raws.before && previousNode.raws.before.indexOf('\n') > -1) {
-                            previousNode.groupIndex = node.groupIndex;
-                            previousNode.propertyIndex = node.propertyIndex;
-                            previousNode.initialIndex = index - 1;
-
-                            var previousNodeClone = cleanLineBreaks(previousNode);
-
-                            commentsBefore.unshift(previousNodeClone);
-
-                            previousNode = previousNode.prev();
-                        } else {
-                            break;
-                        }
-                    }
-
-                    if (commentsBefore.length) {
-                        processed = processed.concat(commentsBefore);
-                    }
-
-                    // Add node itself
-                    processed.push(node);
-
                     // If comment on same line with the node and node, use node's indexes for comment
-                    var nextNode = node.next();
+                    var commentsAfter = fetchAllCommentsAfterNode([], node.next(), node);
 
-                    while (nextNode && nextNode.type === 'comment') {
-                        if (nextNode.raws.before && nextNode.raws.before.indexOf('\n') < 0) {
-                            nextNode.groupIndex = node.groupIndex;
-                            nextNode.propertyIndex = node.propertyIndex;
-                            nextNode.initialIndex = index + 1;
-
-                            processed.push(nextNode);
-                            nextNode = nextNode.next();
-                        } else {
-                            break;
-                        }
-                    }
+                    processed = processed.concat(commentsBefore, node, commentsAfter);
                 });
@@ -238,3 +252,2 @@
                 });
-
             }
@@ -241,0 +254,0 @@ });

package.json

 {
   "name": "postcss-sorting",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "PostCSS plugin to sort rules content with specified order.",
@@ -20,3 +20,3 @@ "keywords": [
   "dependencies": {
-    "postcss": "^5.0.14"
+    "postcss": "^5.0.16"
   },
@@ -26,3 +26,3 @@ "devDependencies": {
     "eslint": "^1.10.2",
-    "postcss-scss": "^0.1.3"
+    "postcss-scss": "^0.1.5"
   },
@@ -29,0 +29,0 @@ "scripts": {

README.md

@@ -244,3 +244,3 @@ # PostCSS Sorting [![Build Status][ci-img]][ci]
 
-Set number of empty lines between nested children rules. By default there is no empty lines between '>child' rules.
+Set a number of empty lines between nested children rules. By default there is no empty lines between '>child' rules.
 
@@ -247,0 +247,0 @@ Acceptable value: `{Number}` of empty lines

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Lines of code

1420

increased by0.21%

Worsened metrics

Total package byte prevSize

55884

decreased by-0.84%

Dependency changes

• Updatedpostcss@^5.0.16