cssesc-source 0.1.0

data/vendor/node_modules/grunt/lib/grunt/option.js

@@ -0,0 +1,42 @@
+/*
+ * grunt
+ * http://gruntjs.com/
+ *
+ * Copyright (c) 2013 "Cowboy" Ben Alman
+ * Licensed under the MIT license.
+ * https://github.com/gruntjs/grunt/blob/master/LICENSE-MIT
+ */
+
+'use strict';
+
+// The actual option data.
+var data = {};
+
+// Get or set an option value.
+var option = module.exports = function(key, value) {
+  var no = key.match(/^no-(.+)$/);
+  if (arguments.length === 2) {
+    return (data[key] = value);
+  } else if (no) {
+    return data[no[1]] === false;
+  } else {
+    return data[key];
+  }
+};
+
+// Initialize option data.
+option.init = function(obj) {
+  return (data = obj || {});
+};
+
+// List of options as flags.
+option.flags = function() {
+  return Object.keys(data).filter(function(key) {
+    // Don't display empty arrays.
+    return !(Array.isArray(data[key]) && data[key].length === 0);
+  }).map(function(key) {
+    var val = data[key];
+    return '--' + (val === false ? 'no-' : '') + key +
+      (typeof val === 'boolean' ? '' : '=' + val);
+  });
+};

data/vendor/node_modules/grunt/lib/grunt/task.js

@@ -0,0 +1,451 @@
+/*
+ * grunt
+ * http://gruntjs.com/
+ *
+ * Copyright (c) 2013 "Cowboy" Ben Alman
+ * Licensed under the MIT license.
+ * https://github.com/gruntjs/grunt/blob/master/LICENSE-MIT
+ */
+
+'use strict';
+
+var grunt = require('../grunt');
+
+// Nodejs libs.
+var path = require('path');
+
+// Extend generic "task" util lib.
+var parent = grunt.util.task.create();
+
+// The module to be exported.
+var task = module.exports = Object.create(parent);
+
+// A temporary registry of tasks and metadata.
+var registry = {tasks: [], untasks: [], meta: {}};
+
+// The last specified tasks message.
+var lastInfo;
+
+// Number of levels of recursion when loading tasks in collections.
+var loadTaskDepth = 0;
+
+// Keep track of the number of log.error() calls.
+var errorcount;
+
+// Override built-in registerTask.
+task.registerTask = function(name) {
+  // Add task to registry.
+  registry.tasks.push(name);
+  // Register task.
+  parent.registerTask.apply(task, arguments);
+  // This task, now that it's been registered.
+  var thisTask = task._tasks[name];
+  // Metadata about the current task.
+  thisTask.meta = grunt.util._.clone(registry.meta);
+  // Override task function.
+  var _fn = thisTask.fn;
+  thisTask.fn = function(arg) {
+    // Guaranteed to always be the actual task name.
+    var name = thisTask.name;
+    // Initialize the errorcount for this task.
+    errorcount = grunt.fail.errorcount;
+    // Return the number of errors logged during this task.
+    Object.defineProperty(this, 'errorCount', {
+      enumerable: true,
+      get: function() {
+        return grunt.fail.errorcount - errorcount;
+      }
+    });
+    // Expose task.requires on `this`.
+    this.requires = task.requires.bind(task);
+    // Expose config.requires on `this`.
+    this.requiresConfig = grunt.config.requires;
+    // Return an options object with the specified defaults overwritten by task-
+    // specific overrides, via the "options" property.
+    this.options = function() {
+      var args = [{}].concat(grunt.util.toArray(arguments)).concat([
+        grunt.config([name, 'options'])
+      ]);
+      var options = grunt.util._.extend.apply(null, args);
+      grunt.verbose.writeflags(options, 'Options');
+      return options;
+    };
+    // If this task was an alias or a multi task called without a target,
+    // only log if in verbose mode.
+    var logger = _fn.alias || (thisTask.multi && (!arg || arg === '*')) ? 'verbose' : 'log';
+    // Actually log.
+    grunt[logger].header('Running "' + this.nameArgs + '"' +
+      (this.name !== this.nameArgs ? ' (' + this.name + ')' : '') + ' task');
+    // If --debug was specified, log the path to this task's source file.
+    grunt[logger].debug('Task source: ' + thisTask.meta.filepath);
+    // Actually run the task.
+    return _fn.apply(this, arguments);
+  };
+  return task;
+};
+
+// Multi task targets can't start with _ or be a reserved property (options).
+function isValidMultiTaskTarget(target) {
+  return !/^_|^options$/.test(target);
+}
+
+// Normalize multi task files.
+task.normalizeMultiTaskFiles = function(data, target) {
+  var prop, obj;
+  var files = [];
+  if (grunt.util.kindOf(data) === 'object') {
+    if ('src' in data || 'dest' in data) {
+      obj = {};
+      for (prop in data) {
+        if (prop !== 'options') {
+          obj[prop] = data[prop];
+        }
+      }
+      files.push(obj);
+    } else if (grunt.util.kindOf(data.files) === 'object') {
+      for (prop in data.files) {
+        files.push({src: data.files[prop], dest: grunt.config.process(prop)});
+      }
+    } else if (Array.isArray(data.files)) {
+      data.files.forEach(function(obj) {
+        var prop;
+        if ('src' in obj || 'dest' in obj) {
+          files.push(obj);
+        } else {
+          for (prop in obj) {
+            files.push({src: obj[prop], dest: grunt.config.process(prop)});
+          }
+        }
+      });
+    }
+  } else {
+    files.push({src: data, dest: grunt.config.process(target)});
+  }
+
+  // If no src/dest or files were specified, return an empty files array.
+  if (files.length === 0) {
+    grunt.verbose.writeln('File: ' + '[no files]'.yellow);
+    return [];
+  }
+
+  // Process all normalized file objects.
+  files = grunt.util._(files).chain().forEach(function(obj) {
+    if (!('src' in obj) || !obj.src) { return; }
+    // Normalize .src properties to flattened array.
+    if (Array.isArray(obj.src)) {
+      obj.src = grunt.util._.flatten(obj.src);
+    } else {
+      obj.src = [obj.src];
+    }
+  }).map(function(obj) {
+    // Build options object, removing unwanted properties.
+    var expandOptions = grunt.util._.extend({}, obj);
+    delete expandOptions.src;
+    delete expandOptions.dest;
+
+    // Expand file mappings.
+    if (obj.expand) {
+      return grunt.file.expandMapping(obj.src, obj.dest, expandOptions).map(function(mapObj) {
+        // Copy obj properties to result.
+        var result = grunt.util._.extend({}, obj);
+        // Make a clone of the orig obj available.
+        result.orig = grunt.util._.extend({}, obj);
+        // Set .src and .dest, processing both as templates.
+        result.src = grunt.config.process(mapObj.src);
+        result.dest = grunt.config.process(mapObj.dest);
+        // Remove unwanted properties.
+        ['expand', 'cwd', 'flatten', 'rename', 'ext'].forEach(function(prop) {
+          delete result[prop];
+        });
+        return result;
+      });
+    }
+
+    // Copy obj properties to result, adding an .orig property.
+    var result = grunt.util._.extend({}, obj);
+    // Make a clone of the orig obj available.
+    result.orig = grunt.util._.extend({}, obj);
+
+    if ('src' in result) {
+      // Expose an expand-on-demand getter method as .src.
+      Object.defineProperty(result, 'src', {
+        enumerable: true,
+        get: function fn() {
+          var src;
+          if (!('result' in fn)) {
+            src = obj.src;
+            // If src is an array, flatten it. Otherwise, make it into an array.
+            src = Array.isArray(src) ? grunt.util._.flatten(src) : [src];
+            // Expand src files, memoizing result.
+            fn.result = grunt.file.expand(expandOptions, src);
+          }
+          return fn.result;
+        }
+      });
+    }
+
+    if ('dest' in result) {
+      result.dest = obj.dest;
+    }
+
+    return result;
+  }).flatten().value();
+
+  // Log this.file src and dest properties when --verbose is specified.
+  if (grunt.option('verbose')) {
+    files.forEach(function(obj) {
+      var output = [];
+      if ('src' in obj) {
+        output.push(obj.src.length > 0 ? grunt.log.wordlist(obj.src) : '[no src]'.yellow);
+      }
+      if ('dest' in obj) {
+        output.push('-> ' + (obj.dest ? String(obj.dest).cyan : '[no dest]'.yellow));
+      }
+      if (output.length > 0) {
+        grunt.verbose.writeln('Files: ' + output.join(' '));
+      }
+    });
+  }
+
+  return files;
+};
+
+// This is the most common "multi task" pattern.
+task.registerMultiTask = function(name, info, fn) {
+  // If optional "info" string is omitted, shuffle arguments a bit.
+  if (fn == null) {
+    fn = info;
+    info = 'Custom multi task.';
+  }
+  // Store a reference to the task object, in case the task gets renamed.
+  var thisTask;
+  task.registerTask(name, info, function(target) {
+    // Guaranteed to always be the actual task name.
+    var name = thisTask.name;
+    // Arguments (sans target) as an array.
+    this.args = grunt.util.toArray(arguments).slice(1);
+    // If a target wasn't specified, run this task once for each target.
+    if (!target || target === '*') {
+      return task.runAllTargets(name, this.args);
+    } else if (!isValidMultiTaskTarget(target)) {
+      throw new Error('Invalid target "' + target + '" specified.');
+    }
+    // Fail if any required config properties have been omitted.
+    this.requiresConfig([name, target]);
+    // Return an options object with the specified defaults overwritten by task-
+    // and/or target-specific overrides, via the "options" property.
+    this.options = function() {
+      var targetObj = grunt.config([name, target]);
+      var args = [{}].concat(grunt.util.toArray(arguments)).concat([
+        grunt.config([name, 'options']),
+        grunt.util.kindOf(targetObj) === 'object' ? targetObj.options : {}
+      ]);
+      var options = grunt.util._.extend.apply(null, args);
+      grunt.verbose.writeflags(options, 'Options');
+      return options;
+    };
+    // Expose data on `this` (as well as task.current).
+    this.data = grunt.config([name, target]);
+    // Expose normalized files object.
+    this.files = task.normalizeMultiTaskFiles(this.data, target);
+    // Expose normalized, flattened, uniqued array of src files.
+    Object.defineProperty(this, 'filesSrc', {
+      enumerable: true,
+      get: function() {
+        return grunt.util._(this.files).chain().pluck('src').flatten().uniq().value();
+      }.bind(this)
+    });
+    // Expose the current target.
+    this.target = target;
+    // Recreate flags object so that the target isn't set as a flag.
+    this.flags = {};
+    this.args.forEach(function(arg) { this.flags[arg] = true; }, this);
+    // Call original task function, passing in the target and any other args.
+    return fn.apply(this, this.args);
+  });
+
+  thisTask = task._tasks[name];
+  thisTask.multi = true;
+};
+
+// Init tasks don't require properties in config, and as such will preempt
+// config loading errors.
+task.registerInitTask = function(name, info, fn) {
+  task.registerTask(name, info, fn);
+  task._tasks[name].init = true;
+};
+
+// Override built-in renameTask to use the registry.
+task.renameTask = function(oldname, newname) {
+  // Add and remove task.
+  registry.untasks.push(oldname);
+  registry.tasks.push(newname);
+  // Actually rename task.
+  return parent.renameTask.apply(task, arguments);
+};
+
+// If a property wasn't passed, run all task targets in turn.
+task.runAllTargets = function(taskname, args) {
+  // Get an array of sub-property keys under the given config object.
+  var targets = Object.keys(grunt.config.getRaw(taskname) || {});
+  // Fail if there are no actual properties to iterate over.
+  if (targets.length === 0) {
+    grunt.log.error('No "' + taskname + '" targets found.');
+    return false;
+  }
+  // Iterate over all valid target properties, running a task for each.
+  targets.filter(isValidMultiTaskTarget).forEach(function(target) {
+    // Be sure to pass in any additionally specified args.
+    task.run([taskname, target].concat(args || []).join(':'));
+  });
+};
+
+// Load tasks and handlers from a given tasks file.
+var loadTaskStack = [];
+function loadTask(filepath) {
+  // In case this was called recursively, save registry for later.
+  loadTaskStack.push(registry);
+  // Reset registry.
+  registry = {tasks: [], untasks: [], meta: {info: lastInfo, filepath: filepath}};
+  var filename = path.basename(filepath);
+  var msg = 'Loading "' + filename + '" tasks...';
+  var regCount = 0;
+  var fn;
+  try {
+    // Load taskfile.
+    fn = require(path.resolve(filepath));
+    if (typeof fn === 'function') {
+      fn.call(grunt, grunt);
+    }
+    grunt.verbose.write(msg).ok();
+    // Log registered/renamed/unregistered tasks.
+    ['un', ''].forEach(function(prefix) {
+      var list = grunt.util._.chain(registry[prefix + 'tasks']).uniq().sort().value();
+      if (list.length > 0) {
+        regCount++;
+        grunt.verbose.writeln((prefix ? '- ' : '+ ') + grunt.log.wordlist(list));
+      }
+    });
+    if (regCount === 0) {
+      grunt.verbose.error('No tasks were registered or unregistered.');
+    }
+  } catch(e) {
+    // Something went wrong.
+    grunt.log.write(msg).error().verbose.error(e.stack).or.error(e);
+  }
+  // Restore registry.
+  registry = loadTaskStack.pop() || {};
+}
+
+// Log a message when loading tasks.
+function loadTasksMessage(info) {
+  // Only keep track of names of top-level loaded tasks and collections,
+  // not sub-tasks.
+  if (loadTaskDepth === 0) { lastInfo = info; }
+  grunt.verbose.subhead('Registering ' + info + ' tasks.');
+}
+
+// Load tasks and handlers from a given directory.
+function loadTasks(tasksdir) {
+  try {
+    var files = grunt.file.glob.sync('*.{js,coffee}', {cwd: tasksdir, maxDepth: 1});
+    // Load tasks from files.
+    files.forEach(function(filename) {
+      loadTask(path.join(tasksdir, filename));
+    });
+  } catch(e) {
+    grunt.log.verbose.error(e.stack).or.error(e);
+  }
+}
+
+// Load tasks and handlers from a given directory.
+task.loadTasks = function(tasksdir) {
+  loadTasksMessage('"' + tasksdir + '"');
+  if (grunt.file.exists(tasksdir)) {
+    loadTasks(tasksdir);
+  } else {
+    grunt.log.error('Tasks directory "' + tasksdir + '" not found.');
+  }
+};
+
+// Load tasks and handlers from a given locally-installed Npm module (installed
+// relative to the base dir).
+task.loadNpmTasks = function(name) {
+  loadTasksMessage('"' + name + '" local Npm module');
+  var root = path.resolve('node_modules');
+  var pkgfile = path.join(root, name, 'package.json');
+  var pkg = grunt.file.exists(pkgfile) ? grunt.file.readJSON(pkgfile) : {keywords: []};
+
+  // Process collection plugins.
+  if (pkg.keywords && pkg.keywords.indexOf('gruntcollection') !== -1) {
+    loadTaskDepth++;
+    Object.keys(pkg.dependencies).forEach(function(depName) {
+      // Npm sometimes pulls dependencies out if they're shared, so find
+      // upwards if not found locally.
+      var filepath = grunt.file.findup('node_modules/' + depName, {
+        cwd: path.resolve('node_modules', name),
+        nocase: true
+      });
+      if (filepath) {
+        // Load this task plugin recursively.
+        task.loadNpmTasks(path.relative(root, filepath));
+      }
+    });
+    loadTaskDepth--;
+    return;
+  }
+
+  // Process task plugins.
+  var tasksdir = path.join(root, name, 'tasks');
+  if (grunt.file.exists(tasksdir)) {
+    loadTasks(tasksdir);
+  } else {
+    grunt.log.error('Local Npm module "' + name + '" not found. Is it installed?');
+  }
+};
+
+// Initialize tasks.
+task.init = function(tasks, options) {
+  if (!options) { options = {}; }
+
+  // Were only init tasks specified?
+  var allInit = tasks.length > 0 && tasks.every(function(name) {
+    var obj = task._taskPlusArgs(name).task;
+    return obj && obj.init;
+  });
+
+  // Get any local Gruntfile or tasks that might exist. Use --gruntfile override
+  // if specified, otherwise search the current directory or any parent.
+  var gruntfile = allInit ? null : grunt.option('gruntfile') ||
+    grunt.file.findup('Gruntfile.{js,coffee}', {nocase: true});
+
+  var msg = 'Reading "' + (gruntfile ? path.basename(gruntfile) : '???') + '" Gruntfile...';
+  if (gruntfile && grunt.file.exists(gruntfile)) {
+    grunt.verbose.writeln().write(msg).ok();
+    // Change working directory so that all paths are relative to the
+    // Gruntfile's location (or the --base option, if specified).
+    process.chdir(grunt.option('base') || path.dirname(gruntfile));
+    // Load local tasks, if the file exists.
+    loadTasksMessage('Gruntfile');
+    loadTask(gruntfile);
+  } else if (options.help || allInit) {
+    // Don't complain about missing Gruntfile.
+  } else if (grunt.option('gruntfile')) {
+    // If --config override was specified and it doesn't exist, complain.
+    grunt.log.writeln().write(msg).error();
+    grunt.fatal('Unable to find "' + gruntfile + '" Gruntfile.', grunt.fail.code.MISSING_GRUNTFILE);
+  } else if (!grunt.option('help')) {
+    grunt.verbose.writeln().write(msg).error();
+    grunt.log.writelns(
+      'A valid Gruntfile could not be found. Please see the getting ' +
+      'started guide for more information on how to configure grunt: ' +
+      'http://gruntjs.com/getting-started'
+    );
+    grunt.fatal('Unable to find Gruntfile.', grunt.fail.code.MISSING_GRUNTFILE);
+  }
+
+  // Load all user-specified --npm tasks.
+  (grunt.option('npm') || []).forEach(task.loadNpmTasks);
+  // Load all user-specified --tasks.
+  (grunt.option('tasks') || []).forEach(task.loadTasks);
+};