smock 0.1.1

data/node_modules/coffee-script/README.md

@@ -0,0 +1,60 @@
+            {
+         }   }   {
+        {   {  }  }
+         }   }{  {
+        {  }{  }  }                    _____       __  __
+       { }{ }{  { }                   / ____|     / _|/ _|
+     .- { { }  { }} -.               | |     ___ | |_| |_ ___  ___
+    (  { } { } { } }  )              | |    / _ \|  _|  _/ _ \/ _ \
+    |`-..________ ..-'|              | |___| (_) | | | ||  __/  __/
+    |                 |               \_____\___/|_| |_| \___|\___|
+    |                 ;--.
+    |                (__  \            _____           _       _
+    |                 | )  )          / ____|         (_)     | |
+    |                 |/  /          | (___   ___ _ __ _ _ __ | |_
+    |                 (  /            \___ \ / __| '__| | '_ \| __|
+    |                 |/              ____) | (__| |  | | |_) | |_
+    |                 |              |_____/ \___|_|  |_| .__/ \__|
+     `-.._________..-'                                  | |
+                                                        |_|
+
+CoffeeScript is a little language that compiles into JavaScript.
+
+## Installation
+
+If you have the node package manager, npm, installed:
+
+```shell
+npm install -g coffee-script
+```
+
+Leave off the `-g` if you don't wish to install globally. If you don't wish to use npm:
+
+```shell
+git clone https://github.com/jashkenas/coffeescript.git
+sudo coffeescript/bin/cake install
+```
+
+## Getting Started
+
+Execute a script:
+
+```shell
+coffee /path/to/script.coffee
+```
+
+Compile a script:
+
+```shell
+coffee -c /path/to/script.coffee
+```
+
+For documentation, usage, and examples, see: http://coffeescript.org/
+
+To suggest a feature or report a bug: http://github.com/jashkenas/coffeescript/issues
+
+If you'd like to chat, drop by #coffeescript on Freenode IRC.
+
+The source repository: https://github.com/jashkenas/coffeescript.git
+
+Our lovely and talented contributors are listed here: http://github.com/jashkenas/coffeescript/contributors

data/node_modules/coffee-script/bin/cake

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+var path = require('path');
+var fs   = require('fs');
+var lib  = path.join(path.dirname(fs.realpathSync(__filename)), '../lib');
+
+require(lib + '/coffee-script/cake').run();

data/node_modules/coffee-script/bin/coffee

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+var path = require('path');
+var fs   = require('fs');
+var lib  = path.join(path.dirname(fs.realpathSync(__filename)), '../lib');
+
+require(lib + '/coffee-script/command').run();

data/node_modules/coffee-script/lib/coffee-script/browser.js

@@ -0,0 +1,134 @@
+// Generated by CoffeeScript 1.8.0
+(function() {
+  var CoffeeScript, compile, runScripts,
+    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+  CoffeeScript = require('./coffee-script');
+
+  CoffeeScript.require = require;
+
+  compile = CoffeeScript.compile;
+
+  CoffeeScript["eval"] = function(code, options) {
+    if (options == null) {
+      options = {};
+    }
+    if (options.bare == null) {
+      options.bare = true;
+    }
+    return eval(compile(code, options));
+  };
+
+  CoffeeScript.run = function(code, options) {
+    if (options == null) {
+      options = {};
+    }
+    options.bare = true;
+    options.shiftLine = true;
+    return Function(compile(code, options))();
+  };
+
+  if (typeof window === "undefined" || window === null) {
+    return;
+  }
+
+  if ((typeof btoa !== "undefined" && btoa !== null) && (typeof JSON !== "undefined" && JSON !== null) && (typeof unescape !== "undefined" && unescape !== null) && (typeof encodeURIComponent !== "undefined" && encodeURIComponent !== null)) {
+    compile = function(code, options) {
+      var js, v3SourceMap, _ref;
+      if (options == null) {
+        options = {};
+      }
+      options.sourceMap = true;
+      options.inline = true;
+      _ref = CoffeeScript.compile(code, options), js = _ref.js, v3SourceMap = _ref.v3SourceMap;
+      return "" + js + "\n//# sourceMappingURL=data:application/json;base64," + (btoa(unescape(encodeURIComponent(v3SourceMap)))) + "\n//# sourceURL=coffeescript";
+    };
+  }
+
+  CoffeeScript.load = function(url, callback, options, hold) {
+    var xhr;
+    if (options == null) {
+      options = {};
+    }
+    if (hold == null) {
+      hold = false;
+    }
+    options.sourceFiles = [url];
+    xhr = window.ActiveXObject ? new window.ActiveXObject('Microsoft.XMLHTTP') : new window.XMLHttpRequest();
+    xhr.open('GET', url, true);
+    if ('overrideMimeType' in xhr) {
+      xhr.overrideMimeType('text/plain');
+    }
+    xhr.onreadystatechange = function() {
+      var param, _ref;
+      if (xhr.readyState === 4) {
+        if ((_ref = xhr.status) === 0 || _ref === 200) {
+          param = [xhr.responseText, options];
+          if (!hold) {
+            CoffeeScript.run.apply(CoffeeScript, param);
+          }
+        } else {
+          throw new Error("Could not load " + url);
+        }
+        if (callback) {
+          return callback(param);
+        }
+      }
+    };
+    return xhr.send(null);
+  };
+
+  runScripts = function() {
+    var coffees, coffeetypes, execute, i, index, s, script, scripts, _fn, _i, _len;
+    scripts = window.document.getElementsByTagName('script');
+    coffeetypes = ['text/coffeescript', 'text/literate-coffeescript'];
+    coffees = (function() {
+      var _i, _len, _ref, _results;
+      _results = [];
+      for (_i = 0, _len = scripts.length; _i < _len; _i++) {
+        s = scripts[_i];
+        if (_ref = s.type, __indexOf.call(coffeetypes, _ref) >= 0) {
+          _results.push(s);
+        }
+      }
+      return _results;
+    })();
+    index = 0;
+    execute = function() {
+      var param;
+      param = coffees[index];
+      if (param instanceof Array) {
+        CoffeeScript.run.apply(CoffeeScript, param);
+        index++;
+        return execute();
+      }
+    };
+    _fn = function(script, i) {
+      var options;
+      options = {
+        literate: script.type === coffeetypes[1]
+      };
+      if (script.src) {
+        return CoffeeScript.load(script.src, function(param) {
+          coffees[i] = param;
+          return execute();
+        }, options, true);
+      } else {
+        options.sourceFiles = ['embedded'];
+        return coffees[i] = [script.innerHTML, options];
+      }
+    };
+    for (i = _i = 0, _len = coffees.length; _i < _len; i = ++_i) {
+      script = coffees[i];
+      _fn(script, i);
+    }
+    return execute();
+  };
+
+  if (window.addEventListener) {
+    window.addEventListener('DOMContentLoaded', runScripts, false);
+  } else {
+    window.attachEvent('onload', runScripts);
+  }
+
+}).call(this);

data/node_modules/coffee-script/lib/coffee-script/cake.js

@@ -0,0 +1,114 @@
+// Generated by CoffeeScript 1.8.0
+(function() {
+  var CoffeeScript, cakefileDirectory, fatalError, fs, helpers, missingTask, oparse, options, optparse, path, printTasks, switches, tasks;
+
+  fs = require('fs');
+
+  path = require('path');
+
+  helpers = require('./helpers');
+
+  optparse = require('./optparse');
+
+  CoffeeScript = require('./coffee-script');
+
+  CoffeeScript.register();
+
+  tasks = {};
+
+  options = {};
+
+  switches = [];
+
+  oparse = null;
+
+  helpers.extend(global, {
+    task: function(name, description, action) {
+      var _ref;
+      if (!action) {
+        _ref = [description, action], action = _ref[0], description = _ref[1];
+      }
+      return tasks[name] = {
+        name: name,
+        description: description,
+        action: action
+      };
+    },
+    option: function(letter, flag, description) {
+      return switches.push([letter, flag, description]);
+    },
+    invoke: function(name) {
+      if (!tasks[name]) {
+        missingTask(name);
+      }
+      return tasks[name].action(options);
+    }
+  });
+
+  exports.run = function() {
+    var arg, args, e, _i, _len, _ref, _results;
+    global.__originalDirname = fs.realpathSync('.');
+    process.chdir(cakefileDirectory(__originalDirname));
+    args = process.argv.slice(2);
+    CoffeeScript.run(fs.readFileSync('Cakefile').toString(), {
+      filename: 'Cakefile'
+    });
+    oparse = new optparse.OptionParser(switches);
+    if (!args.length) {
+      return printTasks();
+    }
+    try {
+      options = oparse.parse(args);
+    } catch (_error) {
+      e = _error;
+      return fatalError("" + e);
+    }
+    _ref = options["arguments"];
+    _results = [];
+    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+      arg = _ref[_i];
+      _results.push(invoke(arg));
+    }
+    return _results;
+  };
+
+  printTasks = function() {
+    var cakefilePath, desc, name, relative, spaces, task;
+    relative = path.relative || path.resolve;
+    cakefilePath = path.join(relative(__originalDirname, process.cwd()), 'Cakefile');
+    console.log("" + cakefilePath + " defines the following tasks:\n");
+    for (name in tasks) {
+      task = tasks[name];
+      spaces = 20 - name.length;
+      spaces = spaces > 0 ? Array(spaces + 1).join(' ') : '';
+      desc = task.description ? "# " + task.description : '';
+      console.log("cake " + name + spaces + " " + desc);
+    }
+    if (switches.length) {
+      return console.log(oparse.help());
+    }
+  };
+
+  fatalError = function(message) {
+    console.error(message + '\n');
+    console.log('To see a list of all tasks/options, run "cake"');
+    return process.exit(1);
+  };
+
+  missingTask = function(task) {
+    return fatalError("No such task: " + task);
+  };
+
+  cakefileDirectory = function(dir) {
+    var parent;
+    if (fs.existsSync(path.join(dir, 'Cakefile'))) {
+      return dir;
+    }
+    parent = path.normalize(path.join(dir, '..'));
+    if (parent !== dir) {
+      return cakefileDirectory(parent);
+    }
+    throw new Error("Cakefile not found in " + (process.cwd()));
+  };
+
+}).call(this);

data/node_modules/coffee-script/lib/coffee-script/coffee-script.js

@@ -0,0 +1,347 @@
+// Generated by CoffeeScript 1.8.0
+(function() {
+  var Lexer, SourceMap, compile, ext, formatSourcePosition, fs, getSourceMap, helpers, lexer, parser, path, sourceMaps, vm, withPrettyErrors, _base, _i, _len, _ref,
+    __hasProp = {}.hasOwnProperty,
+    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+  fs = require('fs');
+
+  vm = require('vm');
+
+  path = require('path');
+
+  Lexer = require('./lexer').Lexer;
+
+  parser = require('./parser').parser;
+
+  helpers = require('./helpers');
+
+  SourceMap = require('./sourcemap');
+
+  exports.VERSION = '1.8.0';
+
+  exports.FILE_EXTENSIONS = ['.coffee', '.litcoffee', '.coffee.md'];
+
+  exports.helpers = helpers;
+
+  withPrettyErrors = function(fn) {
+    return function(code, options) {
+      var err;
+      if (options == null) {
+        options = {};
+      }
+      try {
+        return fn.call(this, code, options);
+      } catch (_error) {
+        err = _error;
+        throw helpers.updateSyntaxError(err, code, options.filename);
+      }
+    };
+  };
+
+  exports.compile = compile = withPrettyErrors(function(code, options) {
+    var answer, currentColumn, currentLine, extend, fragment, fragments, header, js, map, merge, newLines, _i, _len;
+    merge = helpers.merge, extend = helpers.extend;
+    options = extend({}, options);
+    if (options.sourceMap) {
+      map = new SourceMap;
+    }
+    fragments = parser.parse(lexer.tokenize(code, options)).compileToFragments(options);
+    currentLine = 0;
+    if (options.header) {
+      currentLine += 1;
+    }
+    if (options.shiftLine) {
+      currentLine += 1;
+    }
+    currentColumn = 0;
+    js = "";
+    for (_i = 0, _len = fragments.length; _i < _len; _i++) {
+      fragment = fragments[_i];
+      if (options.sourceMap) {
+        if (fragment.locationData) {
+          map.add([fragment.locationData.first_line, fragment.locationData.first_column], [currentLine, currentColumn], {
+            noReplace: true
+          });
+        }
+        newLines = helpers.count(fragment.code, "\n");
+        currentLine += newLines;
+        if (newLines) {
+          currentColumn = fragment.code.length - (fragment.code.lastIndexOf("\n") + 1);
+        } else {
+          currentColumn += fragment.code.length;
+        }
+      }
+      js += fragment.code;
+    }
+    if (options.header) {
+      header = "Generated by CoffeeScript " + this.VERSION;
+      js = "// " + header + "\n" + js;
+    }
+    if (options.sourceMap) {
+      answer = {
+        js: js
+      };
+      answer.sourceMap = map;
+      answer.v3SourceMap = map.generate(options, code);
+      return answer;
+    } else {
+      return js;
+    }
+  });
+
+  exports.tokens = withPrettyErrors(function(code, options) {
+    return lexer.tokenize(code, options);
+  });
+
+  exports.nodes = withPrettyErrors(function(source, options) {
+    if (typeof source === 'string') {
+      return parser.parse(lexer.tokenize(source, options));
+    } else {
+      return parser.parse(source);
+    }
+  });
+
+  exports.run = function(code, options) {
+    var answer, dir, mainModule, _ref;
+    if (options == null) {
+      options = {};
+    }
+    mainModule = require.main;
+    mainModule.filename = process.argv[1] = options.filename ? fs.realpathSync(options.filename) : '.';
+    mainModule.moduleCache && (mainModule.moduleCache = {});
+    dir = options.filename ? path.dirname(fs.realpathSync(options.filename)) : fs.realpathSync('.');
+    mainModule.paths = require('module')._nodeModulePaths(dir);
+    if (!helpers.isCoffee(mainModule.filename) || require.extensions) {
+      answer = compile(code, options);
+      code = (_ref = answer.js) != null ? _ref : answer;
+    }
+    return mainModule._compile(code, mainModule.filename);
+  };
+
+  exports["eval"] = function(code, options) {
+    var Module, Script, js, k, o, r, sandbox, v, _i, _len, _module, _ref, _ref1, _require;
+    if (options == null) {
+      options = {};
+    }
+    if (!(code = code.trim())) {
+      return;
+    }
+    Script = vm.Script;
+    if (Script) {
+      if (options.sandbox != null) {
+        if (options.sandbox instanceof Script.createContext().constructor) {
+          sandbox = options.sandbox;
+        } else {
+          sandbox = Script.createContext();
+          _ref = options.sandbox;
+          for (k in _ref) {
+            if (!__hasProp.call(_ref, k)) continue;
+            v = _ref[k];
+            sandbox[k] = v;
+          }
+        }
+        sandbox.global = sandbox.root = sandbox.GLOBAL = sandbox;
+      } else {
+        sandbox = global;
+      }
+      sandbox.__filename = options.filename || 'eval';
+      sandbox.__dirname = path.dirname(sandbox.__filename);
+      if (!(sandbox !== global || sandbox.module || sandbox.require)) {
+        Module = require('module');
+        sandbox.module = _module = new Module(options.modulename || 'eval');
+        sandbox.require = _require = function(path) {
+          return Module._load(path, _module, true);
+        };
+        _module.filename = sandbox.__filename;
+        _ref1 = Object.getOwnPropertyNames(require);
+        for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+          r = _ref1[_i];
+          if (r !== 'paths') {
+            _require[r] = require[r];
+          }
+        }
+        _require.paths = _module.paths = Module._nodeModulePaths(process.cwd());
+        _require.resolve = function(request) {
+          return Module._resolveFilename(request, _module);
+        };
+      }
+    }
+    o = {};
+    for (k in options) {
+      if (!__hasProp.call(options, k)) continue;
+      v = options[k];
+      o[k] = v;
+    }
+    o.bare = true;
+    js = compile(code, o);
+    if (sandbox === global) {
+      return vm.runInThisContext(js);
+    } else {
+      return vm.runInContext(js, sandbox);
+    }
+  };
+
+  exports.register = function() {
+    return require('./register');
+  };
+
+  if (require.extensions) {
+    _ref = this.FILE_EXTENSIONS;
+    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+      ext = _ref[_i];
+      if ((_base = require.extensions)[ext] == null) {
+        _base[ext] = function() {
+          throw new Error("Use CoffeeScript.register() or require the coffee-script/register module to require " + ext + " files.");
+        };
+      }
+    }
+  }
+
+  exports._compileFile = function(filename, sourceMap) {
+    var answer, err, raw, stripped;
+    if (sourceMap == null) {
+      sourceMap = false;
+    }
+    raw = fs.readFileSync(filename, 'utf8');
+    stripped = raw.charCodeAt(0) === 0xFEFF ? raw.substring(1) : raw;
+    try {
+      answer = compile(stripped, {
+        filename: filename,
+        sourceMap: sourceMap,
+        literate: helpers.isLiterate(filename)
+      });
+    } catch (_error) {
+      err = _error;
+      throw helpers.updateSyntaxError(err, stripped, filename);
+    }
+    return answer;
+  };
+
+  lexer = new Lexer;
+
+  parser.lexer = {
+    lex: function() {
+      var tag, token;
+      token = this.tokens[this.pos++];
+      if (token) {
+        tag = token[0], this.yytext = token[1], this.yylloc = token[2];
+        this.errorToken = token.origin || token;
+        this.yylineno = this.yylloc.first_line;
+      } else {
+        tag = '';
+      }
+      return tag;
+    },
+    setInput: function(tokens) {
+      this.tokens = tokens;
+      return this.pos = 0;
+    },
+    upcomingInput: function() {
+      return "";
+    }
+  };
+
+  parser.yy = require('./nodes');
+
+  parser.yy.parseError = function(message, _arg) {
+    var errorLoc, errorTag, errorText, errorToken, token, tokens, _ref1;
+    token = _arg.token;
+    _ref1 = parser.lexer, errorToken = _ref1.errorToken, tokens = _ref1.tokens;
+    errorTag = errorToken[0], errorText = errorToken[1], errorLoc = errorToken[2];
+    errorText = errorToken === tokens[tokens.length - 1] ? 'end of input' : errorTag === 'INDENT' || errorTag === 'OUTDENT' ? 'indentation' : helpers.nameWhitespaceCharacter(errorText);
+    return helpers.throwSyntaxError("unexpected " + errorText, errorLoc);
+  };
+
+  formatSourcePosition = function(frame, getSourceMapping) {
+    var as, column, fileLocation, fileName, functionName, isConstructor, isMethodCall, line, methodName, source, tp, typeName;
+    fileName = void 0;
+    fileLocation = '';
+    if (frame.isNative()) {
+      fileLocation = "native";
+    } else {
+      if (frame.isEval()) {
+        fileName = frame.getScriptNameOrSourceURL();
+        if (!fileName) {
+          fileLocation = "" + (frame.getEvalOrigin()) + ", ";
+        }
+      } else {
+        fileName = frame.getFileName();
+      }
+      fileName || (fileName = "<anonymous>");
+      line = frame.getLineNumber();
+      column = frame.getColumnNumber();
+      source = getSourceMapping(fileName, line, column);
+      fileLocation = source ? "" + fileName + ":" + source[0] + ":" + source[1] : "" + fileName + ":" + line + ":" + column;
+    }
+    functionName = frame.getFunctionName();
+    isConstructor = frame.isConstructor();
+    isMethodCall = !(frame.isToplevel() || isConstructor);
+    if (isMethodCall) {
+      methodName = frame.getMethodName();
+      typeName = frame.getTypeName();
+      if (functionName) {
+        tp = as = '';
+        if (typeName && functionName.indexOf(typeName)) {
+          tp = "" + typeName + ".";
+        }
+        if (methodName && functionName.indexOf("." + methodName) !== functionName.length - methodName.length - 1) {
+          as = " [as " + methodName + "]";
+        }
+        return "" + tp + functionName + as + " (" + fileLocation + ")";
+      } else {
+        return "" + typeName + "." + (methodName || '<anonymous>') + " (" + fileLocation + ")";
+      }
+    } else if (isConstructor) {
+      return "new " + (functionName || '<anonymous>') + " (" + fileLocation + ")";
+    } else if (functionName) {
+      return "" + functionName + " (" + fileLocation + ")";
+    } else {
+      return fileLocation;
+    }
+  };
+
+  sourceMaps = {};
+
+  getSourceMap = function(filename) {
+    var answer, _ref1;
+    if (sourceMaps[filename]) {
+      return sourceMaps[filename];
+    }
+    if (_ref1 = path != null ? path.extname(filename) : void 0, __indexOf.call(exports.FILE_EXTENSIONS, _ref1) < 0) {
+      return;
+    }
+    answer = exports._compileFile(filename, true);
+    return sourceMaps[filename] = answer.sourceMap;
+  };
+
+  Error.prepareStackTrace = function(err, stack) {
+    var frame, frames, getSourceMapping;
+    getSourceMapping = function(filename, line, column) {
+      var answer, sourceMap;
+      sourceMap = getSourceMap(filename);
+      if (sourceMap) {
+        answer = sourceMap.sourceLocation([line - 1, column - 1]);
+      }
+      if (answer) {
+        return [answer[0] + 1, answer[1] + 1];
+      } else {
+        return null;
+      }
+    };
+    frames = (function() {
+      var _j, _len1, _results;
+      _results = [];
+      for (_j = 0, _len1 = stack.length; _j < _len1; _j++) {
+        frame = stack[_j];
+        if (frame.getFunction() === exports.run) {
+          break;
+        }
+        _results.push("  at " + (formatSourcePosition(frame, getSourceMapping)));
+      }
+      return _results;
+    })();
+    return "" + (err.toString()) + "\n" + (frames.join('\n')) + "\n";
+  };
+
+}).call(this);