configure

#!/usr/bin/env node

// Given a number of files, scans them and generates package.config declarations
// for the packages in those files. Also takes into account any configuration
// information declared explicitly in them.
//
// Run like this -
//
// node configure.js file1.js file2.js ... > pkgmap.js
// node build.js pkgmap.js main.js > concatted.js
// minify concatted.js > main.min.js

function package(name) {
    package.__configurations__[name] = {path: package.__PATH__};
}

package.__configurations__  = {}

package.config = function (cfg) {
    Object.keys(cfg).forEach(function (k) {
        // path configurations override non-path configurations
        // (i.e. urls and externals). This lets you give preference
        // to local files over what is fetched from the net. Otherwise,
        // we flag a "conflict" and report to user.
        var conflict = package.__configurations__.hasOwnProperty(k)
            && !(cfg[k].path && !package.__configurations__[k].path)
            && JSON.stringify(package.__configurations__[k]) !== JSON.stringify(cfg[k]);

        if (conflict) {
            console.error("Package [" + k + "] has conflicting configuration!");
            console.error("\tPrevious: " + JSON.stringify(package.__configurations__[k]));
            console.error("\tNew: " + JSON.stringify(cfg[k]));
            throw "Aborted";
        } else {
            package.__configurations__[k] = cfg[k];
        }
    });
};

package.fetch = function (url, callback) {
    callback(package, url, 'undefined'); // Dummy
};

package.declare = function () {
    // no op
};

package.external = function (pkgname, exportedName, url, dependsOn, depNames) {
    var cfg = {};
    cfg[pkgname] = { external: {
        url: url,
        dependsOn: dependsOn || [],
        depNames: depNames || dependsOn || [],
        name: exportedName
    }};
    package.config(cfg);
};


function fetchKnownPackageConfigs(next) {
    var urlp = require('url').parse('http://sriku.org/lib/package_registry/packages.js');
    urlp.headers = {'Accept-Encoding': 'identity'};
    require(urlp.protocol.split(':')[0]).get(urlp, function (res) {
        var source = "";
        res.setEncoding('utf8');
        res.on('data', function (chunk) {
            source += chunk;
        });
        res.on('end', function () {
            eval('(function (package) {\n' + source + '\n})')(package);
            require('fs').writeFileSync('./.packages.js', source, 'utf8');
            next && next();
        });
        res.on('error', function (err) {
            next && next();
        });
    }).on('error', function (err) {
        next && next();
    });
}

if (process.argv.length <= 2) {
    process.stderr.write('Usage: configure file1.js file2.js ... > build-config.js\n');
    process.stderr.write("Will generate a package.config() declaration for all the packages\n");
    process.stderr.write("found in the given files to stdout. The order of the files is irrelevant,\n");
    process.stderr.write("so you don't need to know the package dependencies in advance. Just make\n");
    process.stderr.write("the generated configuration the first file you provide to the build.js.\n");
    process.stderr.write("\nThe '-r' or '--registry' flag can be used to fetch the registry\n");
    process.stderr.write("of known packages.\n\n");
} 

function main() {
    var slicedArgs = process.argv.slice(2);
    var i = 0, arg;
    function iter() {
        if (i < slicedArgs.length) {
            arg = slicedArgs[i++];
            switch (arg) {
                case '-r': 
                case '--registry':
                    fetchKnownPackageConfigs(iter);
                    break;
                default: 
                    package.__PATH__ = arg;
                    eval('(function (package) {\n' + require('fs').readFileSync(arg, 'utf8') + '\n})')(package);
                    process.nextTick(iter);
            }
        } else {
            process.stdout.write('package.config({\n');
            Object.keys(package.__configurations__).forEach(function (c, i, keys) {
                process.stdout.write('    ' + JSON.stringify(c) + ': ');
                var cfg = package.__configurations__[c];
                if (cfg && cfg.constructor === Function) {
                    process.stdout.write('(' + cfg.toString() + ')');
                } else {
                    process.stdout.write(JSON.stringify(cfg));
                }
                if (i + 1 < keys.length) {
                    process.stdout.write(',\n');
                } else {
                    process.stdout.write('\n');
                }
            });
            process.stdout.write('});\n');
        }
    }

    if (slicedArgs.length > 0) {
        iter();
    }
}

main();