v0.0.15

Author: mishanga

.csscomb.json

@@ -12,6 +12,7 @@
     "element-case": "lower",
     "eof-newline": true,
     "leading-zero": false,
+    "remove-empty-rulesets": true,
     "rule-indent": true,
     "stick-brace": "\n",
     "strip-spaces": true,

.gitignore

@@ -2,3 +2,5 @@ node_modules
 
 .idea
 *.iml
+
+.DS_Store

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.0.15 - 2013-10-03
+- Option: remove-empty-rulesets (#67)
+- Option colon-space expanded
+- Some refactoring and fixes
+
 ## 0.0.14 - 2013-09-12
 - Option: eof-newline (#55)
 - Verbose option (#62)

README.md

@@ -42,6 +42,7 @@ Example configuration:
     "exclude": ["node_modules/**"],
     "verbose": true,
 
+    "remove-empty-rulesets": true,
     "always-semicolon": true,
     "block-indent": true,
     "colon-space": true,
@@ -59,6 +60,14 @@ Example configuration:
 
 ## Options
 
+### exclude
+
+Available values: `{String[]}`
+
+Array of [Ant path patterns](http://ant.apache.org/manual/dirtasks.html#patterns) to exclude.
+
+Example: `{ "exclude": ["node_modules/**"] }` - exclude all files and directories under `node_modules` dir.
+
 ### verbose
 
 Available value: `{Boolean}` `true`
@@ -80,6 +89,14 @@ $ ./bin/csscomb ./test --verbose
 $ ./bin/csscomb ./test -v
 ```
 
+### remove-empty-rulesets
+
+Available values: `{Boolean}` `true`
+
+Example: `{ "remove-empty-rulesets": true }` - remove rulesets that have no declarations or comments.
+
+`a { color: red; } p { /* hey */ } b { }` → `a { color: red; } p { /* hey */ } `
+
 ### always-semicolon
 
 Available value: `{Boolean}` `true`
@@ -122,9 +139,10 @@ a { color: red
 ### colon-space
 
 Available values:
-  * `{Boolean}` `true` (means `after`)
+  * `{Boolean}` `true` (means `after`) or `false` (no whitespace at all)
   * `{String}`: `before`, `after`, `both` or any combination of whitespaces
   and/or a colon (` `, `: `, `\t:\n\t` etc.)
+  * `{Array}` with two `{String}` values: for setting left and right whitespace around a colon
 
 Example: `{ "colon-space": true }`
 
@@ -151,7 +169,7 @@ a {
 }
 ```
 
-Example: `{ "colon-space": ":" }`
+Example: `{ "colon-space": "" }`
 
 ```css
 /* before */
@@ -161,6 +179,16 @@ a { color: red }
 a { color:red }
 ```
 
+Example: `{ "colon-space": ["\t", "\t"] }`
+
+```css
+/* before */
+a { color: red }
+
+/* after */
+a { color	:	red }
+```
+
 ### color-case
 
 Available values: `{String}` `lower` or `upper`
@@ -405,3 +433,4 @@ This software is released under the terms of the [MIT license](https://github.co
 * https://github.com/senchalabs/cssbeautify
 * https://github.com/css/gonzales
 * https://github.com/css/csso
+* https://github.com/nzakas/parser-lib

lib/csscomb.js

@@ -11,6 +11,7 @@ var vfs = require('vow-fs');
  */
 var Comb = function() {
     this._options = [
+        'remove-empty-rulesets',
         'always-semicolon',
         'color-case',
         'color-shorthand',
@@ -76,23 +77,25 @@ Comb.prototype = {
      * @param {Number} level Indent level
      */
     processNode: function(node, level) {
-        var _this = this;
         node.forEach(function(node) {
             if (!Array.isArray(node)) return;
+
             var nodeType = node.shift();
-            _this._handlers.forEach(function(handler) {
+            this._handlers.forEach(function(handler) {
                 handler.process(nodeType, node, level);
             });
             node.unshift(nodeType);
+
             if (nodeType === 'atrulers') level++;
-            _this.processNode(node, level);
-        });
+
+            this.processNode(node, level);
+        }, this);
     },
 
     /**
      * Process file provided with a string.
      * @param {String} text
-     * @param {String} filename
+     * @param {String} [filename]
      */
     processString: function(text, filename) {
         if (!text) return text;

lib/options/colon-space.js

@@ -8,10 +8,33 @@ module.exports = {
      */
     setValue: function(value) {
         this._value = false;
-        if (value === true) this._value = 'after';
-        if (typeof value === 'string'&& value.match(/after|before|both|(?=.*(?:[ \t\n]|:))[ \t\n]*:?[ \t\n]*/)) {
+        if (value === true)
+            value = 'after';
+        if (value === false)
+            value = '';
+        if (value === 'both')
+            this._value = [' ', ' '];
+        if (value === 'before')
+            this._value = [' ', ''];
+        if (value === 'after')
+            this._value = ['', ' '];
+        if (value.constructor === Array && value[0].match(/^[ \t]*$/) && value[1].match(/^[ \t]*$/))
             this._value = value;
+        if (typeof value === 'string') {
+            if (value.match(/^[ \t]*$/)) {
+                this._value = ['', value];
+            } else {
+                var detectSpaces = value.match(/^(([ \t]*):)?([ \t]*)$/);
+                if (detectSpaces) {
+                    if (detectSpaces[1]) {
+                        this._value = [detectSpaces[2], detectSpaces[3]];
+                    } else {
+                        this._value = ['', detectSpaces[3]];
+                    }
+                }
+            }
         }
+
         if (!this._value) return;
         return this;
     },
@@ -22,20 +45,13 @@ module.exports = {
      * @param {node} node
      */
     process: function(nodeType, node) {
-        var detectSpaces = this._value.match(/(([ \t\n]*):)?([ \t\n]*)/);
         if (nodeType === 'property') {
             if (node[node.length - 1][0] === 's') node.pop();
-            if (this._value === 'both' || this._value === 'before')
-                node.push(['s', ' ']);
-            if (detectSpaces && detectSpaces[1])
-                node.push(['s', detectSpaces[2]]);
+            if (this._value[0] !== '') node.push(['s', this._value[0]]);
         }
         if (nodeType === 'value') {
             if (node[0][0] === 's') node.shift();
-            if (this._value === 'both' || this._value === 'after')
-                node.unshift(['s', ' ']);
-            if (detectSpaces)
-                node.unshift(['s', detectSpaces[3]]);
+            if (this._value[1] !== '') node.unshift(['s', this._value[1]]);
         }
     }
 

lib/options/remove-empty-rulesets.js

@@ -0,0 +1,85 @@
+module.exports = {
+
+    /**
+     * Sets handler value.
+     *
+     * @param {String} value Option value
+     * @returns {Object|undefined}
+     */
+    setValue: function(value) {
+        if (value === true) {
+            this._value = value;
+            return this;
+        }
+    },
+
+    /**
+     * Remove rulesets with no declarations.
+     *
+     * @param {String} nodeType
+     * @param {Array} nodeContent
+     */
+    process: function(nodeType, nodeContent) {
+        if (nodeType === 'stylesheet') {
+            this._processStylesheetContent(nodeContent);
+        }
+    },
+
+    _processStylesheetContent: function(nodeContent) {
+        this._removeEmptyRulesets(nodeContent);
+        this._mergeAdjacentWhitespace(nodeContent);
+    },
+
+    _removeEmptyRulesets: function(nodeContent) {
+        var i = nodeContent.length;
+        while (i--) {
+            if (this._isRuleset(nodeContent[i]) && this._isEmptyRuleset(nodeContent[i])) {
+                nodeContent.splice(i, 1);
+            }
+        }
+    },
+
+    /**
+     * Removing ruleset nodes from tree may result in two adjacent whitespace nodes which is not correct AST:
+     * [space, ruleset, space] => [space, space]
+     * To ensure correctness of further processing we should merge such nodes into one.
+     * [space, space] => [space]
+     */
+    _mergeAdjacentWhitespace: function(nodeContent) {
+        var i = nodeContent.length - 1;
+        while (i-- > 0) {
+            if (this._isWhitespace(nodeContent[i]) && this._isWhitespace(nodeContent[i + 1])) {
+                nodeContent[i][1] += nodeContent[i + 1][1];
+                nodeContent.splice(i + 1, 1);
+            }
+        }
+    },
+
+    _isEmptyRuleset: function(ruleset) {
+        return ruleset.filter(this._isBlock).every(this._isEmptyBlock, this);
+    },
+
+    /**
+     * Block considered empty when it has no declarations or comments.
+     */
+    _isEmptyBlock: function(node) {
+        return !node.some(this._isDeclarationOrComment);
+    },
+
+    _isDeclarationOrComment: function(node) {
+        return node[0] === 'declaration' || node[0] === 'comment';
+    },
+
+    _isRuleset: function(node) {
+        return node[0] === 'ruleset';
+    },
+
+    _isBlock: function(node) {
+        return node[0] === 'block';
+    },
+
+    _isWhitespace: function(node) {
+        return node[0] === 's';
+    }
+
+};

package.json

@@ -1,7 +1,7 @@
 {
     "name": "csscomb",
     "description": "CSS coding style formatter",
-    "version": "0.0.14",
+    "version": "0.0.15",
     "homepage": "http://csscomb.com/",
     "author": "Mikhail Troshev <mishanga@yandex-team.ru>",
     "repository": "https://github.com/csscomb/csscomb.js",

test/colon-space.js

@@ -30,7 +30,24 @@ describe('options/colon-space', function() {
             'a {color /* bar */: red }'
         );
     });
-    it('`after` value should set space after colon', function() {
+    it('False Boolean value should set no space around colon', function() {
+        comb.configure({ 'colon-space': false });
+        assert.equal(
+            comb.processString(
+                'a { color: red }' +
+                'a{color:red}' +
+                'a {color : red}' +
+                'a {color : /* foo */ red }' +
+                'a {color /* bar */ : red }'
+            ),
+            'a { color:red }' +
+            'a{color:red}' +
+            'a {color:red}' +
+            'a {color:/* foo */ red }' +
+            'a {color /* bar */:red }'
+        );
+    });
+    it('String `after` value should set space after colon', function() {
         comb.configure({ 'colon-space': 'after' });
         assert.equal(
             comb.processString(
@@ -47,7 +64,7 @@ describe('options/colon-space', function() {
             'a {color /* bar */: red }'
         );
     });
-    it('`before` value should set space before colon', function() {
+    it('String `before` value should set space before colon', function() {
         comb.configure({ 'colon-space': 'before' });
         assert.equal(
             comb.processString(
@@ -64,7 +81,7 @@ describe('options/colon-space', function() {
             'a {color /* bar */ :red }'
         );
     });
-    it('`both` value should set spaces around colon', function() {
+    it('String `both` value should set spaces around colon', function() {
         comb.configure({ 'colon-space': 'both' });
         assert.equal(
             comb.processString(
@@ -77,7 +94,7 @@ describe('options/colon-space', function() {
             'a {color : red}'
         );
     });
-    it('`  ` value should set two spaces after colon', function() {
+    it('String `  ` value should set two spaces after colon', function() {
         comb.configure({ 'colon-space': '  ' });
         assert.equal(
             comb.processString(
@@ -90,7 +107,7 @@ describe('options/colon-space', function() {
             'a {color:  red}'
         );
     });
-    it('`:` value should set no space around colon', function() {
+    it('String `:` value should set no space around colon', function() {
         comb.configure({ 'colon-space': ':' });
         assert.equal(
             comb.processString(
@@ -103,20 +120,20 @@ describe('options/colon-space', function() {
             'a {color:red}'
         );
     });
-    it('`\\n:` value should set a newline before colon', function() {
-        comb.configure({ 'colon-space': '\n:' });
+    it('String `` value should set no space around colon', function() {
+        comb.configure({ 'colon-space': '' });
         assert.equal(
             comb.processString(
                 'a { color: red }' +
                 'a{color:red}' +
                 'a {color : red}'
             ),
-            'a { color\n:red }' +
-            'a{color\n:red}' +
-            'a {color\n:red}'
+            'a { color:red }' +
+            'a{color:red}' +
+            'a {color:red}'
         );
     });
-    it('`\\t:\\t` value should set tabs around colon', function() {
+    it('String `\\t:\\t` value should set tabs around colon', function() {
         comb.configure({ 'colon-space': '\t:\t' });
         assert.equal(
             comb.processString(