cssesc-source 0.1.0

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

@@ -0,0 +1,95 @@
+/*
+ * 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');
+
+// The module to be exported.
+var template = module.exports = {};
+
+// External libs.
+template.date = require('dateformat');
+
+// Format today's date.
+template.today = function(format) {
+  return template.date(new Date(), format);
+};
+
+// Template delimiters.
+var allDelimiters = {};
+
+// Initialize template delimiters.
+template.addDelimiters = function(name, opener, closer) {
+  var delimiters = allDelimiters[name] = {};
+  // Used by grunt.
+  delimiters.opener = opener;
+  delimiters.closer = closer;
+  // Generate RegExp patterns dynamically.
+  var a = delimiters.opener.replace(/(.)/g, '\\$1');
+  var b = '([\\s\\S]+?)' + delimiters.closer.replace(/(.)/g, '\\$1');
+  // Used by Lo-Dash.
+  delimiters.lodash = {
+    evaluate: new RegExp(a + b, 'g'),
+    interpolate: new RegExp(a + '=' + b, 'g'),
+    escape: new RegExp(a + '-' + b, 'g')
+  };
+};
+
+// The underscore default template syntax should be a pretty sane default for
+// the config system.
+template.addDelimiters('config', '<%', '%>');
+
+// Set Lo-Dash template delimiters.
+template.setDelimiters = function(name) {
+  // Get the appropriate delimiters.
+  var delimiters = allDelimiters[name in allDelimiters ? name : 'config'];
+  // Tell Lo-Dash which delimiters to use.
+  grunt.util._.templateSettings = delimiters.lodash;
+  // Return the delimiters.
+  return delimiters;
+};
+
+// Process template + data with Lo-Dash.
+template.process = function(tmpl, options) {
+  if (!options) { options = {}; }
+  // Set delimiters, and get a opening match character.
+  var delimiters = template.setDelimiters(options.delimiters);
+  // Clone data, initializing to config data or empty object if omitted.
+  var data = Object.create(options.data || grunt.config.data || {});
+  // Expose grunt so that grunt utilities can be accessed, but only if it
+  // doesn't conflict with an existing .grunt property.
+  if (!('grunt' in data)) { data.grunt = grunt; }
+  // Keep track of last change.
+  var last = tmpl;
+  try {
+    // As long as tmpl contains template tags, render it and get the result,
+    // otherwise just use the template string.
+    while (tmpl.indexOf(delimiters.opener) >= 0) {
+      tmpl = grunt.util._.template(tmpl, data);
+      // Abort if template didn't change - nothing left to process!
+      if (tmpl === last) { break; }
+      last = tmpl;
+    }
+  } catch (e) {
+    // In upgrading to Lo-Dash (or Underscore.js 1.3.3), \n and \r in template
+    // tags now causes an exception to be thrown. Warn the user why this is
+    // happening. https://github.com/documentcloud/underscore/issues/553
+    if (String(e) === 'SyntaxError: Unexpected token ILLEGAL' && /\n|\r/.test(tmpl)) {
+      grunt.log.errorlns('A special character was detected in this template. ' +
+        'Inside template tags, the \\n and \\r special characters must be ' +
+        'escaped as \\\\n and \\\\r. (grunt 0.4.0+)');
+    }
+    // Slightly better error message.
+    e.message = 'An error occurred while processing a template (' + e.message + ').';
+    grunt.warn(e, grunt.fail.code.TEMPLATE_ERROR);
+  }
+  // Normalize linefeeds and return.
+  return grunt.util.normalizelf(tmpl);
+};

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

@@ -0,0 +1,188 @@
+/*
+ * 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';
+
+// Nodejs libs.
+var spawn = require('child_process').spawn;
+var nodeUtil = require('util');
+var path = require('path');
+
+// The module to be exported.
+var util = module.exports = {};
+
+// A few internal utilites, exposed.
+util.task = require('../util/task');
+util.namespace = require('getobject');
+
+// External libs.
+util.hooker = require('hooker');
+util.async = require('async');
+var _ = util._ = require('lodash');
+var which = require('which').sync;
+// Instead of process.exit. See https://github.com/cowboy/node-exit
+util.exit = require('exit');
+
+// Mixin Underscore.string methods.
+_.str = require('underscore.string');
+_.mixin(_.str.exports());
+
+// Return a function that normalizes the given function either returning a
+// value or accepting a "done" callback that accepts a single value.
+util.callbackify = function(fn) {
+  return function callbackable() {
+    // Invoke original function, getting its result.
+    var result = fn.apply(this, arguments);
+    // If the same number or less arguments were specified than fn accepts,
+    // assume the "done" callback was already handled.
+    var length = arguments.length;
+    if (length === fn.length) { return; }
+    // Otherwise, if the last argument is a function, assume it is a "done"
+    // callback and call it.
+    var done = arguments[length - 1];
+    if (typeof done === 'function') { done(result); }
+  };
+};
+
+// Create a new Error object, with an origError property that will be dumped
+// if grunt was run with the --debug=9 option.
+util.error = function(err, origError) {
+  if (!nodeUtil.isError(err)) { err = new Error(err); }
+  if (origError) { err.origError = origError; }
+  return err;
+};
+
+// The line feed char for the current system.
+util.linefeed = process.platform === 'win32' ? '\r\n' : '\n';
+
+// Normalize linefeeds in a string.
+util.normalizelf = function(str) {
+  return str.replace(/\r\n|\n/g, util.linefeed);
+};
+
+// What "kind" is a value?
+// I really need to rework https://github.com/cowboy/javascript-getclass
+var kindsOf = {};
+'Number String Boolean Function RegExp Array Date Error'.split(' ').forEach(function(k) {
+  kindsOf['[object ' + k + ']'] = k.toLowerCase();
+});
+util.kindOf = function(value) {
+  // Null or undefined.
+  if (value == null) { return String(value); }
+  // Everything else.
+  return kindsOf[kindsOf.toString.call(value)] || 'object';
+};
+
+// Coerce something to an Array.
+util.toArray = Function.call.bind(Array.prototype.slice);
+
+// Return the string `str` repeated `n` times.
+util.repeat = function(n, str) {
+  return new Array(n + 1).join(str || ' ');
+};
+
+// Given str of "a/b", If n is 1, return "a" otherwise "b".
+util.pluralize = function(n, str, separator) {
+  var parts = str.split(separator || '/');
+  return n === 1 ? (parts[0] || '') : (parts[1] || '');
+};
+
+// Recurse through objects and arrays, executing fn for each non-object.
+util.recurse = function recurse(value, fn, fnContinue) {
+  var obj;
+  if (fnContinue && fnContinue(value) === false) {
+    // Skip value if necessary.
+    return value;
+  } else if (util.kindOf(value) === 'array') {
+    // If value is an array, recurse.
+    return value.map(function(value) {
+      return recurse(value, fn, fnContinue);
+    });
+  } else if (util.kindOf(value) === 'object') {
+    // If value is an object, recurse.
+    obj = {};
+    Object.keys(value).forEach(function(key) {
+      obj[key] = recurse(value[key], fn, fnContinue);
+    });
+    return obj;
+  } else {
+    // Otherwise pass value into fn and return.
+    return fn(value);
+  }
+};
+
+// Spawn a child process, capturing its stdout and stderr.
+util.spawn = function(opts, done) {
+  // Build a result object and pass it (among other things) into the
+  // done function.
+  var callDone = function(code, stdout, stderr) {
+    // Remove trailing whitespace (newline)
+    stdout = _.rtrim(stdout);
+    stderr = _.rtrim(stderr);
+    // Create the result object.
+    var result = {
+      stdout: stdout,
+      stderr: stderr,
+      code: code,
+      toString: function() {
+        if (code === 0) {
+          return stdout;
+        } else if ('fallback' in opts) {
+          return opts.fallback;
+        } else if (opts.grunt) {
+          // grunt.log.error uses standard out, to be fixed in 0.5.
+          return stderr || stdout;
+        }
+        return stderr;
+      }
+    };
+    // On error (and no fallback) pass an error object, otherwise pass null.
+    done(code === 0 || 'fallback' in opts ? null : new Error(stderr), result, code);
+  };
+
+  var cmd, args;
+  var pathSeparatorRe = /[\\\/]/g;
+  if (opts.grunt) {
+    cmd = process.argv[0];
+    args = [process.argv[1]].concat(opts.args);
+  } else {
+    // On Windows, child_process.spawn will only file .exe files in the PATH,
+    // not other executable types (grunt issue #155).
+    try {
+      if (!pathSeparatorRe.test(opts.cmd)) {
+        // Only use which if cmd has no path component.
+        cmd = which(opts.cmd);
+      } else {
+        cmd = opts.cmd.replace(pathSeparatorRe, path.sep);
+      }
+    } catch (err) {
+      callDone(127, '', String(err));
+      return;
+    }
+    args = opts.args;
+  }
+
+  var child = spawn(cmd, args, opts.opts);
+  var stdout = new Buffer('');
+  var stderr = new Buffer('');
+  if (child.stdout) {
+    child.stdout.on('data', function(buf) {
+      stdout = Buffer.concat([stdout, new Buffer(buf)]);
+    });
+  }
+  if (child.stderr) {
+    child.stderr.on('data', function(buf) {
+      stderr = Buffer.concat([stderr, new Buffer(buf)]);
+    });
+  }
+  child.on('close', function(code) {
+    callDone(code, stdout.toString(), stderr.toString());
+  });
+  return child;
+};

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

@@ -0,0 +1,323 @@
+/*
+ * grunt
+ * http://gruntjs.com/
+ *
+ * Copyright (c) 2013 "Cowboy" Ben Alman
+ * Licensed under the MIT license.
+ * https://github.com/gruntjs/grunt/blob/master/LICENSE-MIT
+ */
+
+(function(exports) {
+
+  'use strict';
+
+  // Construct-o-rama.
+  function Task() {
+    // Information about the currently-running task.
+    this.current = {};
+    // Tasks.
+    this._tasks = {};
+    // Task queue.
+    this._queue = [];
+    // Queue placeholder (for dealing with nested tasks).
+    this._placeholder = {placeholder: true};
+    // Queue marker (for clearing the queue programmatically).
+    this._marker = {marker: true};
+    // Options.
+    this._options = {};
+    // Is the queue running?
+    this._running = false;
+    // Success status of completed tasks.
+    this._success = {};
+  }
+
+  // Expose the constructor function.
+  exports.Task = Task;
+
+  // Create a new Task instance.
+  exports.create = function() {
+    return new Task();
+  };
+
+  // If the task runner is running or an error handler is not defined, throw
+  // an exception. Otherwise, call the error handler directly.
+  Task.prototype._throwIfRunning = function(obj) {
+    if (this._running || !this._options.error) {
+      // Throw an exception that the task runner will catch.
+      throw obj;
+    } else {
+      // Not inside the task runner. Call the error handler and abort.
+      this._options.error.call({name: null}, obj);
+    }
+  };
+
+  // Register a new task.
+  Task.prototype.registerTask = function(name, info, fn) {
+    // If optional "info" string is omitted, shuffle arguments a bit.
+    if (fn == null) {
+      fn = info;
+      info = null;
+    }
+    // String or array of strings was passed instead of fn.
+    var tasks;
+    if (typeof fn !== 'function') {
+      // Array of task names.
+      tasks = this.parseArgs([fn]);
+      // This task function just runs the specified tasks.
+      fn = this.run.bind(this, fn);
+      fn.alias = true;
+      // Generate an info string if one wasn't explicitly passed.
+      if (!info) {
+        info = 'Alias for "' + tasks.join('", "') + '" task' +
+          (tasks.length === 1 ? '' : 's') + '.';
+      }
+    } else if (!info) {
+      info = 'Custom task.';
+    }
+    // Add task into cache.
+    this._tasks[name] = {name: name, info: info, fn: fn};
+    // Make chainable!
+    return this;
+  };
+
+  // Is the specified task an alias?
+  Task.prototype.isTaskAlias = function(name) {
+    return !!this._tasks[name].fn.alias;
+  };
+
+  // Rename a task. This might be useful if you want to override the default
+  // behavior of a task, while retaining the old name. This is a billion times
+  // easier to implement than some kind of in-task "super" functionality.
+  Task.prototype.renameTask = function(oldname, newname) {
+    // Rename task.
+    this._tasks[newname] = this._tasks[oldname];
+    // Update name property of task.
+    this._tasks[newname].name = newname;
+    // Remove old name.
+    delete this._tasks[oldname];
+    // Make chainable!
+    return this;
+  };
+
+  // Argument parsing helper. Supports these signatures:
+  //  fn('foo')                 // ['foo']
+  //  fn('foo', 'bar', 'baz')   // ['foo', 'bar', 'baz']
+  //  fn(['foo', 'bar', 'baz']) // ['foo', 'bar', 'baz']
+  Task.prototype.parseArgs = function(args) {
+    // Return the first argument if it's an array, otherwise return an array
+    // of all arguments.
+    return Array.isArray(args[0]) ? args[0] : [].slice.call(args);
+  };
+
+  // Split a colon-delimited string into an array, unescaping (but not
+  // splitting on) any \: escaped colons.
+  Task.prototype.splitArgs = function(str) {
+    if (!str) { return []; }
+    // Store placeholder for \\ followed by \:
+    str = str.replace(/\\\\/g, '\uFFFF').replace(/\\:/g, '\uFFFE');
+    // Split on :
+    return str.split(':').map(function(s) {
+      // Restore place-held : followed by \\
+      return s.replace(/\uFFFE/g, ':').replace(/\uFFFF/g, '\\');
+    });
+  };
+
+  // Given a task name, determine which actual task will be called, and what
+  // arguments will be passed into the task callback. "foo" -> task "foo", no
+  // args. "foo:bar:baz" -> task "foo:bar:baz" with no args (if "foo:bar:baz"
+  // task exists), otherwise task "foo:bar" with arg "baz" (if "foo:bar" task
+  // exists), otherwise task "foo" with args "bar" and "baz".
+  Task.prototype._taskPlusArgs = function(name) {
+    // Get task name / argument parts.
+    var parts = this.splitArgs(name);
+    // Start from the end, not the beginning!
+    var i = parts.length;
+    var task;
+    do {
+      // Get a task.
+      task = this._tasks[parts.slice(0, i).join(':')];
+      // If the task doesn't exist, decrement `i`, and if `i` is greater than
+      // 0, repeat.
+    } while (!task && --i > 0);
+    // Just the args.
+    var args = parts.slice(i);
+    // Maybe you want to use them as flags instead of as positional args?
+    var flags = {};
+    args.forEach(function(arg) { flags[arg] = true; });
+    // The task to run and the args to run it with.
+    return {task: task, nameArgs: name, args: args, flags: flags};
+  };
+
+  // Append things to queue in the correct spot.
+  Task.prototype._push = function(things) {
+    // Get current placeholder index.
+    var index = this._queue.indexOf(this._placeholder);
+    if (index === -1) {
+      // No placeholder, add task+args objects to end of queue.
+      this._queue = this._queue.concat(things);
+    } else {
+      // Placeholder exists, add task+args objects just before placeholder.
+      [].splice.apply(this._queue, [index, 0].concat(things));
+    }
+  };
+
+  // Enqueue a task.
+  Task.prototype.run = function() {
+    // Parse arguments into an array, returning an array of task+args objects.
+    var things = this.parseArgs(arguments).map(this._taskPlusArgs, this);
+    // Throw an exception if any tasks weren't found.
+    var fails = things.filter(function(thing) { return !thing.task; });
+    if (fails.length > 0) {
+      this._throwIfRunning(new Error('Task "' + fails[0].nameArgs + '" not found.'));
+      return this;
+    }
+    // Append things to queue in the correct spot.
+    this._push(things);
+    // Make chainable!
+    return this;
+  };
+
+  // Add a marker to the queue to facilitate clearing it programmatically.
+  Task.prototype.mark = function() {
+    this._push(this._marker);
+    // Make chainable!
+    return this;
+  };
+
+  // Run a task function, handling this.async / return value.
+  Task.prototype.runTaskFn = function(context, fn, done) {
+    // Async flag.
+    var async = false;
+
+    // Update the internal status object and run the next task.
+    var complete = function(success) {
+      var err = null;
+      if (success === false) {
+        // Since false was passed, the task failed generically.
+        err = new Error('Task "' + context.nameArgs + '" failed.');
+      } else if (success instanceof Error || {}.toString.call(success) === '[object Error]') {
+        // An error object was passed, so the task failed specifically.
+        err = success;
+        success = false;
+      } else {
+        // The task succeeded.
+        success = true;
+      }
+      // The task has ended, reset the current task object.
+      this.current = {};
+      // A task has "failed" only if it returns false (async) or if the
+      // function returned by .async is passed false.
+      this._success[context.nameArgs] = success;
+      // If task failed, call error handler.
+      if (!success && this._options.error) {
+        this._options.error.call({name: context.name, nameArgs: context.nameArgs}, err);
+      }
+      done(err, success);
+    }.bind(this);
+
+    // When called, sets the async flag and returns a function that can
+    // be used to continue processing the queue.
+    context.async = function() {
+      async = true;
+      // The returned function should execute asynchronously in case
+      // someone tries to do this.async()(); inside a task (WTF).
+      return function(success) {
+        setTimeout(function() { complete(success); }, 1);
+      };
+    };
+
+    // Expose some information about the currently-running task.
+    this.current = context;
+
+    try {
+      // Get the current task and run it, setting `this` inside the task
+      // function to be something useful.
+      var success = fn.call(context);
+      // If the async flag wasn't set, process the next task in the queue.
+      if (!async) {
+        complete(success);
+      }
+    } catch (err) {
+      complete(err);
+    }
+  };
+
+  // Begin task queue processing. Ie. run all tasks.
+  Task.prototype.start = function() {
+    // Abort if already running.
+    if (this._running) { return false; }
+    // Actually process the next task.
+    var nextTask = function() {
+      // Get next task+args object from queue.
+      var thing;
+      // Skip any placeholders or markers.
+      do {
+        thing = this._queue.shift();
+      } while (thing === this._placeholder || thing === this._marker);
+      // If queue was empty, we're all done.
+      if (!thing) {
+        this._running = false;
+        if (this._options.done) {
+          this._options.done();
+        }
+        return;
+      }
+      // Add a placeholder to the front of the queue.
+      this._queue.unshift(this._placeholder);
+
+      // Expose some information about the currently-running task.
+      var context = {
+        // The current task name plus args, as-passed.
+        nameArgs: thing.nameArgs,
+        // The current task name.
+        name: thing.task.name,
+        // The current task arguments.
+        args: thing.args,
+        // The current arguments, available as named flags.
+        flags: thing.flags
+      };
+
+      // Actually run the task function (handling this.async, etc)
+      this.runTaskFn(context, function() {
+        return thing.task.fn.apply(this, this.args);
+      }, nextTask);
+
+    }.bind(this);
+
+    // Update flag.
+    this._running = true;
+    // Process the next task.
+    nextTask();
+  };
+
+  // Clear remaining tasks from the queue.
+  Task.prototype.clearQueue = function(options) {
+    if (!options) { options = {}; }
+    if (options.untilMarker) {
+      this._queue.splice(0, this._queue.indexOf(this._marker) + 1);
+    } else {
+      this._queue = [];
+    }
+    // Make chainable!
+    return this;
+  };
+
+  // Test to see if all of the given tasks have succeeded.
+  Task.prototype.requires = function() {
+    this.parseArgs(arguments).forEach(function(name) {
+      var success = this._success[name];
+      if (!success) {
+        throw new Error('Required task "' + name +
+          '" ' + (success === false ? 'failed' : 'must be run first') + '.');
+      }
+    }.bind(this));
+  };
+
+  // Override default options.
+  Task.prototype.options = function(options) {
+    Object.keys(options).forEach(function(name) {
+      this._options[name] = options[name];
+    }.bind(this));
+  };
+
+}(typeof exports === 'object' && exports || this));