source: gs3-extensions/web-audio/trunk/js-mad/sink.js-master/build@ 28388

#!/usr/bin/env node

/* vim: set filetype=javascript */

var sys     = require('util');

function print(){
    [].slice.call(arguments).forEach(function(a){
        sys.puts(a);
    });
}

function _path(){
    return [].slice.call(arguments).map(function(a){return/^(.+)\/?$/.exec(a)[1]}).join('/');
}

function fh(str){
    return str.replace(/[<>]/g, function(a){return a==='<'?'&lt;':'&gt;'});
}

function findByParam(arr, name, value) {
    return arr.filter(function(obj){
        return obj[name] === value;
    });
}

function __extend(obj){
    var args    = arguments,
        l   = args.length,
        i, n;
    for (i=1; i<l; i++){
        for (n in args[i]){
            if (args[i].hasOwnProperty(n)){
                obj[n] = args[i][n];
            }
        }
    }
    return obj;
}

var paramon     = require('paramon');
var fs      = require('fs');
var Builder     = require('script-builder');

function ls(path, r){
    path    = path instanceof Array ? _path.apply(null, path) : path;
    path    = fs.readdirSync(path);
    if (r){
        for (var i=0; i<path.length; i++){
            if (!r.exec(path[i])){
                path.splice(i--, 1);
            }
        }
    }
    return path;
}

function read(path, encoding){
    path        = path instanceof Array ? _path.apply(null, path) : path;
    encoding    = encoding || 'UTF-8';
    return fs.readFileSync(path, encoding);
}

function save(path, data, encoding){
    path        = path instanceof Array ? _path.apply(null, path) : path;
    encoding    = encoding || 'UTF-8';
    return fs.writeFileSync(path, data, encoding);
}

var __define = (function(){

    if (Object.defineProperty){
        return Object.defineProperty;
    } else if (Object.prototype.__defineGetter__){
        return function(obj, prop, desc){
            desc.get && obj.__defineGetter__(prop, desc.get);
            desc.set && obj.__defineSetter__(prop, desc.set);
        }
    }

}());

function __defineConst(obj, prop, value, enumerable){
    if (__define){
        __define(obj, prop, {
            get: function(){
                return value;
            },
            enumerable: !!enumerable
        });
    } else {
        // Cheap...
        obj[prop] = value;
    }
}

function logicalMods(obj, name, value){
    if (arguments.length < 3){
        value   = obj[name];
    }
    var pos = ['major', 'minor', 'patch'];
    __define(obj, name, {
        set: function(val){
            var op  = typeof val === 'string' ? val.split(' ') : val;
            var r   = typeof value === 'string' ? value.split('.') : value;
            var n   = [];
            if (op && op instanceof Array){
                op.slice(1).forEach(function(o){
                    o = pos.indexOf(o);
                    o !== -1 && n.push(o);
                });
                !n.length && n.push(0);
                n.forEach(function(n){
                    switch(op[0]){
                    case 'increment':
                        typeof r === 'number' ? r++ : r[n]++;
                        val = r instanceof Array ? r.join('.') : r;
                        break;
                    case 'decrement':
                        typeof r === 'number' ? r-- : r[n]--;
                        val = r instanceof Array ? r.join('.') : r;
                        break;
                    }
                });
            }
            value = val;
        },
        get: function(){
            return value;
        },
    });
}

var ArrayStuff = (function f(){
var a   = Array.prototype;
a.copy  = function(){return this.slice();};
a.smap  = function(s, r){
    return this.map(function(t){
        var x = r ? r.exec(t) : [t];
        return s.replace(/\$([0-9]+)/g, function(q,n){
            return x[n];
        });
    });
};
a.table = function(tabwidth){
    tabwidth    = isNaN(+tabwidth) ? 8 : +tabwidth;
    var w   = [];
    this.forEach(function(r){
        r.forEach(function(c, i){
            w[i] = Math.max(Math.ceil(c.length / tabwidth), w[i] || 0);
        });
    });
    return this.map(function(r){
        var l   = r.length - 1,
            s   = '',
            i;
        for (i=0; i<l; i++){
            s += r[i] + Array(1 + w[i] - Math.floor(r[i].length / tabwidth)).join('\t');
        }
        return s + r[i];
    }).join('\n');
};
return f;
}());

Builder.context(ArrayStuff);

function builderContext(s){
    s       = s || {};

    Builder.Comment.prototype.toString = function(){
        return this.assignName || this.name || Object.prototype.toString.call(this);
    };

    var builder = Builder.Builder(s);
    var cp  = Builder.CommentParser();

    function group(name){
        arguments.length > 1 && group.apply(this, [].slice.call(arguments, 1));
        var g   = builder.variables[name + 's'] = [];
        var sg  = builder.variables['sub' + name + 's'] = [];
        builder.instructions.push({
            name:   name,
            exec:   function(args){
                args = args.split(/\s+/g);
                args[1] = args[1] || args[0];
                builder.variables[name + 's'].push({name: args[0], assignName: args[1]});
            }
        }, {
            name:   'sub' + name,
            exec:   function(args){
                args = args.split(/\s+/g);
                args[2] = args[2] || args[0] + args[1];
                builder.variables['sub' + name + 's'].push({subOf: args[0], name: args[1], assignName: args[2], toString: Builder.Comment.prototype.toString});
            }
        });
        cp.commands.push({
            name:   name,
            exec:   function(args){
                args = args ? args.split(/\s+/g) : [];
                this.assignName = args[0];
                !this.assignName && this.onfinish(function(){
                    this.assignName = this.name;
                });
                this[name] = true;
                builder.variables[name + 's'].push(this);
            }
        }, {
            name:   'sub' + name,
            exec:   function(args){
                args = args ? args.split(/\s+/g) : [];
                this.subOf = args[0];
                this.assignName = args[1];
                !this.name && !this.assignName && this.onfinish(function(){
                    this.assignName = args[0] + this.name;
                });
                this[name] = true;
                this['sub' + name] = true;
                builder.variables['sub' + name + 's'].push(this);
            }
        });
    }

    group('generator', 'effect', 'control', 'processor');

    cp.commands.push({
        name: 'param',
        exec: function(args){
            if (!args) return;
            var params  = this.params = this.params || [],
                p   = {},
                s, x;
            while (s = /^([^\s]+)\s*/.exec(args)){
                args    = args.substr(s[0].length);
                s   = s[1];

                x   = /^\{(.+)\}$/.exec(s);
                if (x) {
                    p.type = x[1];
                    continue;
                }

                x   = /^(.+):(.*)$/.exec(s);
                if (x) {
                    p[x[1]] = x[2] || true;
                    continue;
                }

                p.name      = s;
                p.description   = args;
                args        = '';
                break;
            }
            params.push(p);
        }
    }, {
        name: 'arg',
        exec: function(args){
            if (!args) return;
            var arglist = this.arglist = this.arglist || [],
                p   = {},
                s, x;
            while (s = /^([^\s]+)\s*/.exec(args)){
                args    = args.substr(s[0].length);
                s   = s[1];

                x   = /^\{(.+)\}$/.exec(s);
                if (x) {
                    p.type = x[1];
                    continue;
                }

                x   = /^(.+):(.*)$/.exec(s);
                if (x) {
                    p[x[1]] = x[2] || true;
                    continue;
                }

                while (/^[^\w]/.exec(s)) {
                    switch(s[0]) {
                    case '!':
                        p.optional = true; break;
                    case '=':
                        p.assignsToClass = true; break;
                    }
                    s = s.substr(1);
                }
                p.name      = s;
                p.description   = args;
                args        = '';
                break;
            }
            arglist.push(p);
        }
    }, {
        name: 'return',
        exec: function(args){
            if (!args) return;
            var p   = {},
                s, x, desc;
            while (s = /^([^\s]+)\s*/.exec(args)){
                desc    = args;
                args    = args.substr(s[0].length);
                s   = s[1];

                x   = /^\{(.+)\}$/.exec(s);
                if (x) {
                    p.type = x[1];
                    continue;
                }

                p.description   = desc;
                args        = '';
                break;
            }
            this.returns = p;
        }
    }, {
        name: 'method',
        exec: function(args){
            args = args ? args.split(/\s+/g) : [];
            this.method = true;
            if (args[0]) {
                this.methodOf = args[0];
            }
        }
    }, {
        name: 'static',
        exec: function(args){
            args = args ? args.split(/\s+/g) : [];
            this.static = true;
            this.method = true;
            if (args[0]) {
                this.methodOf = args[0];
            }
        }
    }, {
        name: 'class',
        exec: function(args){
            this.class = true;
        }
    });

    builder.group = group;

    builder.addPostProcessor(cp);
    builder.commentParser = cp;

    return builder;
}


if (process.argv.length < 3){
    throw "Try build -h for help.";
}

var args    = paramon.readFormat(process.argv, {
    name:   'build',
    usage:  'command [options]',
    params: [
        {
            name:   'debug',
            args:   ['--debug', '-d'],
            desc:   'Run in debug mode (more verbose error messages).',
            maxParams: 0,
        },
        {
            name:   'update',
            args:   ['update', '-u'],
            desc:   'Update target (wrappers).',
            minParams: 1,
            maxParams: -1,
        }
    ],
});

!args.debug && process.on('uncaughtException', function(e){
    print(e.toString());
    process.exit(1);
});

args['$!stray'].forEach(function(e){
    print('Unknown build command "' + e + '".');
    process.exit();
});

var updatables = {
    'docs': function(){
        var builder = builderContext();
        builder.run(read('sink.js'), 'sink.js');

        builder.commentParser.comments.forEach(function(comment){
            // This is probably unnecessary payload.
            delete comment.body;
        });

        var comments = builder.commentParser.comments.filter(function (func) {
            return func.assignName || func.class;
        });

        builder.commentParser.comments.forEach(function(func){
            if (!func.method) return;
            var parent = func.methodOf && findByParam(comments, 'name', func.methodOf)[0];
            if (parent) {
                parent.methods = parent.methods || [];
                parent.methods.push(func);
//          } else {
//              methods.push(func);
            }
        });

        var docs = '# sink.js\n\n';

        comments.forEach(function (func) {
            docs += '## ' + (func.static ? func.methodOf + '.' : '') + (func.assignName || func.name) + '\n\n';
            docs += func.text + '\n\n';

            if (func.arglist) {
                docs += '### Arguments\n\n';
                func.arglist.forEach(function(arg){
                    var info = arg.assignsToClass ? findByParam(func.params, 'name', arg.name)[0] || arg : arg;
                    docs += ' * ';
                    if (arg.optional) docs += '(Optional) ';
                    if (info.type) docs += '(' + fh(info.type) + ') ';
                    docs += info.name;
                    docs += ': ' + info.description;
                    docs += '\n';
                });
                docs += '\n';
            }

            if (func.methods) {
                docs += '### Methods\n\n';
                func.methods.forEach(function(method){
                    docs += '#### ';
                    if (method.static) {
                        docs += '(Static) ';
                    }
                    docs += method.name + '(';
                    if (method.arglist) {
                        docs += method.arglist.map(function(a){ return a.name }).join(', ');
                    }
                    docs += ')\n\n' + method.text + '\n\n';
                    if (method.arglist) {
                        docs += '##### Arguments\n\n';
                        method.arglist.forEach(function(arg){
                            var info = arg.assignsToClass ? findByParam(func.params, 'name', arg.name)[0] || arg : arg;
                            docs += ' * ';
                            if (arg.optional) docs += '(Optional) ';
                            if (info.type) docs += '(' + fh(info.type) + ') ';
                            docs += info.name;
                            docs += ': ' + info.description;
                            docs += '\n';
                        });
                        docs += '\n';
                    }

                    if (method.returns) {
                        docs += '##### Returns\n\n';
                        if (method.returns.type) docs += '(' + fh(method.returns.type) + ') ';
                        docs += method.returns.description;
                        docs += '\n\n';
                    }
                });
            }
        });

        save('DOCS.md', docs);
        print('Documentation updated.');
    },
};

if (args.update) {
    args.update.forEach(function(e){
        e = e.toLowerCase();
        var k;
        if (e === 'all') {
            for (k in updatables){
                if (updatables.hasOwnProperty(k)){
                    updatables[k]();
                }
            }
        } else if (e in updatables) {
            updatables[e]();
        } else {
            throw 'Unknown update target "' + e + '".';
        }
    });
    process.exit();
}