--- /dev/null
+'use strict';
+
+// Nodejs libs.
+var path = require('path');
+
+// This allows grunt to require() .coffee files.
+require('coffee-script/register');
+
+// The module to be exported.
+var grunt = module.exports = {};
+
+// Expose internal grunt libs.
+function gRequire(name) {
+ return grunt[name] = require('./grunt/' + name);
+}
+
+var util = require('grunt-legacy-util');
+grunt.util = util;
+grunt.util.task = require('./util/task');
+
+var Log = require('grunt-legacy-log').Log;
+var log = new Log({grunt: grunt});
+grunt.log = log;
+
+gRequire('template');
+gRequire('event');
+var fail = gRequire('fail');
+gRequire('file');
+var option = gRequire('option');
+var config = gRequire('config');
+var task = gRequire('task');
+var help = gRequire('help');
+gRequire('cli');
+var verbose = grunt.verbose = log.verbose;
+
+// Expose some grunt metadata.
+grunt.package = require('../package.json');
+grunt.version = grunt.package.version;
+
+// Expose specific grunt lib methods on grunt.
+function gExpose(obj, methodName, newMethodName) {
+ grunt[newMethodName || methodName] = obj[methodName].bind(obj);
+}
+gExpose(task, 'registerTask');
+gExpose(task, 'registerMultiTask');
+gExpose(task, 'registerInitTask');
+gExpose(task, 'renameTask');
+gExpose(task, 'loadTasks');
+gExpose(task, 'loadNpmTasks');
+gExpose(config, 'init', 'initConfig');
+gExpose(fail, 'warn');
+gExpose(fail, 'fatal');
+
+// Expose the task interface. I've never called this manually, and have no idea
+// how it will work. But it might.
+grunt.tasks = function(tasks, options, done) {
+ // Update options with passed-in options.
+ option.init(options);
+
+ // Display the grunt version and quit if the user did --version.
+ var _tasks, _options;
+ if (option('version')) {
+ // Not --verbose.
+ log.writeln('grunt v' + grunt.version);
+
+ if (option('verbose')) {
+ // --verbose
+ verbose.writeln('Install path: ' + path.resolve(__dirname, '..'));
+ // Yes, this is a total hack, but we don't want to log all that verbose
+ // task initialization stuff here.
+ grunt.log.muted = true;
+ // Initialize task system so that available tasks can be listed.
+ grunt.task.init([], {help: true});
+ // Re-enable logging.
+ grunt.log.muted = false;
+
+ // Display available tasks (for shell completion, etc).
+ _tasks = Object.keys(grunt.task._tasks).sort();
+ verbose.writeln('Available tasks: ' + _tasks.join(' '));
+
+ // Display available options (for shell completion, etc).
+ _options = [];
+ Object.keys(grunt.cli.optlist).forEach(function(long) {
+ var o = grunt.cli.optlist[long];
+ _options.push('--' + (o.negate ? 'no-' : '') + long);
+ if (o.short) { _options.push('-' + o.short); }
+ });
+ verbose.writeln('Available options: ' + _options.join(' '));
+ }
+
+ return;
+ }
+
+ // Init colors.
+ log.initColors();
+
+ // Display help and quit if the user did --help.
+ if (option('help')) {
+ help.display();
+ return;
+ }
+
+ // A little header stuff.
+ verbose.header('Initializing').writeflags(option.flags(), 'Command-line options');
+
+ // Determine and output which tasks will be run.
+ var tasksSpecified = tasks && tasks.length > 0;
+ tasks = task.parseArgs([tasksSpecified ? tasks : 'default']);
+
+ // Initialize tasks.
+ task.init(tasks, options);
+
+ verbose.writeln();
+ if (!tasksSpecified) {
+ verbose.writeln('No tasks specified, running default tasks.');
+ }
+ verbose.writeflags(tasks, 'Running tasks');
+
+ // Handle otherwise unhandleable (probably asynchronous) exceptions.
+ var uncaughtHandler = function(e) {
+ fail.fatal(e, fail.code.TASK_FAILURE);
+ };
+ process.on('uncaughtException', uncaughtHandler);
+
+ // Report, etc when all tasks have completed.
+ task.options({
+ error: function(e) {
+ fail.warn(e, fail.code.TASK_FAILURE);
+ },
+ done: function() {
+ // Stop handling uncaught exceptions so that we don't leave any
+ // unwanted process-level side effects behind. There is no need to do
+ // this in the error callback, because fail.warn() will either kill
+ // the process, or with --force keep on going all the way here.
+ process.removeListener('uncaughtException', uncaughtHandler);
+
+ // Output a final fail / success report.
+ fail.report();
+
+ if (done) {
+ // Execute "done" function when done (only if passed, of course).
+ done();
+ } else {
+ // Otherwise, explicitly exit.
+ util.exit(0);
+ }
+ }
+ });
+
+ // Execute all tasks, in order. Passing each task individually in a forEach
+ // allows the error callback to execute multiple times.
+ tasks.forEach(function(name) { task.run(name); });
+ // Run tasks async internally to reduce call-stack, per:
+ // https://github.com/gruntjs/grunt/pull/1026
+ task.start({asyncDone: true});
+};