Merge pull request #6 from csscomb/v0.0.0

Allow to require and apply rules

Author: mishanga

.csscomb.json

@@ -1,7 +1,12 @@
 {
+    "exclude": [
+        ".git/**",
+        "node_modules/**"
+    ],
     "colon-space": true,
     "rule-indent": true,
     "stick-brace": "\n",
+    "strip-spaces": true,
     "sort-order": [
         [
             "position",

.jscs.json

@@ -17,7 +17,7 @@
         "return",
         "catch"
     ],
-    "requireMultipleVarDecl": true,
+    "disallowMultipleVarDecl": true,
     "disallowLeftStickedOperators": [
         "?",
         "+",

lib/cli.js

@@ -4,27 +4,31 @@
  * Usage example:
  * ./node_modules/.bin/csscomb file1 [dir1 [fileN [dirN]]]
  */
-var fs = require('fs'),
-    program = require('commander');
+var fs = require('fs');
+var program = require('commander');
+var vow = require('vow');
+var Comb = require('./csscomb');
 
 program
     .version(require('../package.json').version)
     .usage('[options] <file ...>')
     .option('-c, --config [path]', 'configuration file path')
     .parse(process.argv);
 
+var comb = new Comb();
 var configPath = program.config || (process.cwd() + '/.csscomb.json');
 
-/**
- * Trying to load config.
- * Custom config path can be specified using '-c' option.
- */
 if (fs.existsSync(configPath)) {
-    var config = require(configPath);
+    comb.configure(require(configPath));
+    if (program.args.length > 0) {
+        vow.all(program.args.map(function(path) {
+            return comb.processPath(path);
+        })).fail(function(e) {
+            console.log('stack: ', e.stack);
+            process.exit(1);
+        });
+    }
 } else {
     console.log('Configuration file ' + configPath + ' was not found.');
-    /**
-     * Quitting with 1 error code.
-     */
     process.exit(1);
 }

lib/csscomb.js

@@ -0,0 +1,180 @@
+var cssp = require('cssp');
+var minimatch = require('minimatch');
+var vow = require('vow');
+var vfs = require('vow-fs');
+
+/**
+ * Starts Code Style processing process.
+ *
+ * @name Comb
+ */
+var Comb = function() {
+    this._rules = {
+        'colon-space': {},
+        'rule-indent': {},
+        'sort-order': {},
+        'stick-brace': {},
+        'strip-spaces': {}
+    },
+    this._config = {};
+    this._exclude = null;
+};
+
+Comb.prototype = {
+
+    /**
+     * Loads configuration from JSON.
+     * Activates and configures required rules.
+     *
+     * @param {Object} config
+     */
+    configure: function(config) {
+        for (var rule in config) {
+            if (config.hasOwnProperty(rule) && config[rule] && this._rules[rule]) {
+                var beautifier;
+                try {
+                    beautifier = require('./rules/' + rule);
+                    beautifier.value = config[rule];
+                    this._config[rule] = beautifier;
+                } catch (e) {}
+            }
+        }
+        this._exclude = (config.exclude || []).map(function(pattern) {
+            return new minimatch.Minimatch(pattern);
+        });
+    },
+
+    /**
+     * Processes stylesheet tree node.
+     *
+     * @param {Array} tree Parsed tree
+     * @returns {Array}
+     */
+    processTree: function(tree) {
+        this.processNode(['tree', tree]);
+        return tree;
+    },
+
+    /**
+     * Processes tree node.
+     * @param {Array} node Tree node
+     */
+    processNode: function(node, level) {
+        var _this = this;
+        var config = this._config;
+        node.forEach(function(node) {
+            if (!Array.isArray(node)) return;
+            var nodeType = node.shift();
+            for (var rule in config) {
+                if (config.hasOwnProperty(rule)) {
+                    config[rule].process(nodeType, node);
+                }
+            }
+            node.unshift(nodeType);
+            _this.processNode(node, level);
+        });
+    },
+
+    /**
+     * Process file provided with a string.
+     * @param {String} text
+     * @param {String} filename
+     */
+    processString: function(text, filename) {
+        var tree;
+        try {
+            tree = this.processTree(cssp.parse(text));
+        } catch (e) {
+            throw new Error('Parsing error at ' + filename + ': ' + e.message);
+        }
+        return cssp.translate(cssp.transform(tree));
+    },
+
+    /**
+     * Process single file.
+     *
+     * @param {String} path
+     * @returns {Promise}
+     */
+    processFile: function(path) {
+        var _this = this;
+        if (this._shouldProcess(path) && path.match(/\.css$/)) {
+            return vfs.read(path, 'utf8').then(function(data) {
+                return vfs.write(path, _this.processString(data, path), 'utf8');
+            });
+        }
+        return null;
+    },
+
+    /**
+     * Process directory recursively.
+     *
+     * @param {String} path
+     * @returns {Promise}
+     */
+    processDirectory: function(path) {
+        var _this = this;
+        return vfs.listDir(path).then(function(filenames) {
+            return vow.all(filenames.map(function(filename) {
+                var fullname = path + '/' + filename;
+                return vfs.stat(fullname).then(function(stat) {
+                    if (_this._shouldProcess(fullname)) {
+                        if (stat.isDirectory()) {
+                            return _this.processDirectory(fullname);
+                        } else if (fullname.match(/\.css$/)) {
+                            return vow.when(_this.processFile(fullname)).then(function(errors) {
+                                if (errors) return errors;
+                            });
+                        }
+                    }
+                    return;
+                });
+            })).then(function(results) {
+                return [].concat.apply([], results);
+            });
+        });
+    },
+
+    /**
+     * Processs directory or file.
+     *
+     * @param {String} path
+     */
+    processPath: function(path) {
+        path = path.replace(/\/$/, '');
+        var _this = this;
+        return vfs.exists(path).then(function(exists) {
+            if (exists) {
+                return vfs.stat(path).then(function(stat) {
+                    if (stat.isDirectory()) {
+                        return _this.processDirectory(path);
+                    } else {
+                        return vow.when(_this.processFile(path)).then(function(errors) {
+                            if (errors) return [errors];
+                            return;
+                        });
+                    }
+                });
+            } else {
+                throw new Error('Path ' + path + ' was not found.');
+            }
+        });
+    },
+
+    /**
+     * Returns true if specified path is not in exluded list.
+     *
+     * @returns {Boolean}
+     */
+    _shouldProcess: function(path) {
+        path = path.replace(/^\.\//, '');
+        var exclude = this._exclude;
+        for (var i = exclude.length; i--;) {
+            if (exclude[i].match(path)) return false;
+        }
+        return true;
+    }
+
+};
+
+module.exports = Comb;

package.json

@@ -21,7 +21,11 @@
         "node": ">= 0.8.0"
     },
     "dependencies": {
-        "commander": "1.1.1"
+        "commander": "1.1.1",
+        "cssp": "1.0.6",
+        "minimatch": "0.2.12",
+        "vow": "0.3.7",
+        "vow-fs": "0.1.13"
     },
     "devDependencies": {
         "jshint-groups": "0.5.1",