cakewalk/lib/cakewalk.js

var fs = require('fs');
var coffee = require('coffee-script');
var stylus = require('stylus');
var jade = require('jade');
var colors = require('colors');
var walk = require('./walk.js').walk;
var BuildError = require('./errors.js').BuildError;
var CoffeeScriptError = require('./errors.js').CoffeeScriptError;
var StylusError = require('./errors.js').StylusError;
var JadeError = require('./errors.js').JadeError;


/**
 * Watch a file, passing its contents through a specified function and writing
 * the result to disk.
 */
function Builder(source, destination, compileFunction) {
    this.source = source;
    this.destination = destination;
    this.compileFunction = compileFunction;
    this.build();
    this.start();
}

Builder.prototype = {

    /**
     * Compile our target file.
     */
    build: function() {
        console.log('Reading:'.grey, this.source);
        var self = this;

        fs.readFile(this.source, 'utf8', function(err, data) {

            try {
                var compiled = self.compileFunction(data);
            } catch(err) {
                err.printError();
            }

            if(compiled) {
                fs.writeFile(self.destination, compiled, function(err) {
                    console.log('Writing:'.grey, self.destination);
                });
            }

        });
    },

    /**
     * Start watching file and build when it changes.
     */
    start: function() {
        var self = this;
        fs.watch(this.source, function(event, filename) {
            if(event == 'change') {
                self.build();
            }
        });
    },

    /**
     * Stop watching (and building) file.
     */
    stop: function() {
        fs.unwatchFile(this.source);
    }

};


/**
 * Compiles CoffeeScript into JavaScript.
 */
function CoffeeBuilder(source, destination) {

    var destination = destination || replaceExtension(source, 'js');

    var builder = new Builder(source, destination, function(input) {
        try {
            return coffee.compile(input);
        } catch(err) {
            throw new CoffeeScriptError(err.message, source);
        }
    });

    this.start = builder.start;
    this.stop = builder.stop;
}


/**
 * Compiles Stylus into CSS.
 */
function StylusBuilder(source, destination) {

    var destination = destination || replaceExtension(source, 'css');

    var builder = new Builder(source, destination, function(input) {
        var output;
        stylus.render(input, {}, function(err, css) {
            if(err) {
                throw new StylusError(err.message, source);
            }
            output = css;
        });
        return output;
    });

    this.start = builder.start;
    this.stop = builder.stop;
}


/**
 * Compiles Jade into HTML.
 */
function JadeBuilder(source, destination) {

    var destination = destination || replaceExtension(source, 'html');

    var builder = new Builder(source, destination, function(input) {
        try {
            return jade.compile(input, { pretty: true })();
        } catch(err) {
            throw new JadeError(err.message, source);
        }
    });

    this.start = builder.start;
    this.stop = builder.stop;
}


/*
 * Replace the extension on a filename.
 */
function replaceExtension(filename, newExtension) {
    return filename.replace(/(?:\.\w+)$/i, '.' + newExtension);
};


/**
 * Cakewalker
 *
 * Object that initiates the walking procedure.
 *
 * Usage:
 * new Cakewalk('path/to/directory/to/watch');
 */
function Cakewalker(directory) {

    this.builders = [];
    this.directory = directory || '.';

    this.start();

}

// Note: the last rule in the below pattern should ignore all files prefixed
// with an underscore. Those files should be treated as includes and mixins and
// thus need not be compiled separately.
Cakewalker.IGNORE_PATTERN = new RegExp(/(?:\.git|\.svn|node_modules|\/_)/);

Cakewalker.COFFEE_PATTERN = new RegExp(/\.coffee$/);
Cakewalker.STYLUS_PATTERN = new RegExp(/\.styl$/);
Cakewalker.JADE_PATTERN = new RegExp(/\.jade$/);

Cakewalker.prototype = {

    /**
     * Walk a directory, find files to compile, and watch them for changes.
     */
    start: function() {

        var self = this;

        walk(this.directory, function(err, files) {

            if(err) throw new Error(err);

            for(var i=0; i<files.length; i++) {
                var file = files[i];

                if(!Cakewalker.IGNORE_PATTERN.test(file)) {

                    if(Cakewalker.COFFEE_PATTERN.test(file)) {
                        self.builders.push(new CoffeeBuilder(file));
                    } else if(Cakewalker.STYLUS_PATTERN.test(file)) {
                        self.builders.push(new StylusBuilder(file));
                    } else if(Cakewalker.JADE_PATTERN.test(file)) {
                        self.builders.push(new JadeBuilder(file));
                    }

                }
            }

            if(self.builders.length === 0) {
                console.error('No CoffeeScript, Stylus, or Jade files found. Exiting.');
                process.exit();
            }

        });

    },

    /**
     * Stop watching and building.
     */
    stop: function() {
        for(var i = 0; i < builders.length; i++) {
            builders[i].stop();
        }
    }

}


exports.Cakewalker = Cakewalker;