Multiple single file builds using one "build script" for requirejs optimizer

builder.js

//Load the requirejs optimizer
var requirejs = require('./path/to/r.js'),
    //Set up basic config, include config that is
    //common to all the optimize() calls.
    basConfig = {
        baseUrl: './some/path',
        paths: {
            //whatever is neded globally.
        }
    };

// Function used to mix in baseConfig to a new config target
function mix(target) {
    for (var prop in basConfig) {
        if (basConfig.hasOwnProperty(prop)) {
            target[prop] = basConfig[prop];
        }
    }
    return target;
}

//Now do a series of builds of individual files, using the args suggested by:
//http://requirejs.org/docs/optimization.html#onejs

requirejs.optimize(mix({
    name: 'first/main/module',
    include: [/*if you need to include extra modules */],
    out: 'path/to/output/firstMain-built.js'
}), function (buildReportText) {
    //First build complete, start the next one.
    requirejs.optimize(mix({
        name: 'second/main/module',
        include: [/*if you need to include extra modules */],
        out: 'path/to/output/secondMain-built.js'
    }), function (buildReportText) {
        //all done.
    });
});

reduceRight will create an array of functions

Not quite; this usage of reduceRight creates a function, actually a chain of nested functions, from an array of simple objects (the first parameters to requirejs.optimize). Note: I forgot to include the call to mix in my example above; let's just assume it's already been map'ped onto the spec objects. Expanding what my snippet would do, it'll create a function, async_runner, whose definition looks like this:

// Expansion of the reduceRight() call

var async_runner = function (buildReportText) {
  requirejs.optimize(spec1, function (buildReportText) {
    requirejs.optimize(spec2, function (buildReportText) {
      requirejs.optimize(spec3, function (buildReportText) {});
    });
  });
}

Knowing that we don't actually use the buildReportText parameter on the outermost function, we can invoke the whole nested mess with a call like async_runner().

This approach rather cleanly abstracts the interesting core data (here, a sequence of input parameters) from the rather hairy code that consumes that data.

James, check out this gist for a little example that you can run in node to play with this idea.

Thanks for the heads-up. requirejs-rails on the precompilation branch has been updated for this change. See rjs_driver.js.erb on the branch.

@whitley, neat use of reduceRight, thanks for the explanation. Nice approach to know in general for repeated async calls.