macgyver 0.0.8

data/assets/MacGap.app/Contents/Resources/http.js

@@ -0,0 +1,119 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var util = require('util');
+var EventEmitter = require('events').EventEmitter;
+
+
+var incoming = require('_http_incoming');
+var IncomingMessage = exports.IncomingMessage = incoming.IncomingMessage;
+
+
+var common = require('_http_common');
+exports.METHODS = util._extend([], common.methods).sort();
+exports.parsers = common.parsers;
+
+
+var outgoing = require('_http_outgoing');
+var OutgoingMessage = exports.OutgoingMessage = outgoing.OutgoingMessage;
+
+
+var server = require('_http_server');
+exports.ServerResponse = server.ServerResponse;
+exports.STATUS_CODES = server.STATUS_CODES;
+
+
+var agent = require('_http_agent');
+var Agent = exports.Agent = agent.Agent;
+var globalAgent = exports.globalAgent = agent.globalAgent;
+
+var client = require('_http_client');
+var ClientRequest = exports.ClientRequest = client.ClientRequest;
+
+exports.request = function(options, cb) {
+  return globalAgent.request(options, cb);
+};
+
+exports.get = function(options, cb) {
+  return globalAgent.get(options, cb);
+};
+
+exports._connectionListener = server._connectionListener;
+var Server = exports.Server = server.Server;
+
+exports.createServer = function(requestListener) {
+  return new Server(requestListener);
+};
+
+
+// Legacy Interface
+
+function Client(port, host) {
+  if (!(this instanceof Client)) return new Client(port, host);
+  EventEmitter.call(this);
+
+  host = host || 'localhost';
+  port = port || 80;
+  this.host = host;
+  this.port = port;
+  this.agent = new Agent({ host: host, port: port, maxSockets: 1 });
+}
+util.inherits(Client, EventEmitter);
+Client.prototype.request = function(method, path, headers) {
+  var self = this;
+  var options = {};
+  options.host = self.host;
+  options.port = self.port;
+  if (method[0] === '/') {
+    headers = path;
+    path = method;
+    method = 'GET';
+  }
+  options.method = method;
+  options.path = path;
+  options.headers = headers;
+  options.agent = self.agent;
+  var c = new ClientRequest(options);
+  c.on('error', function(e) {
+    self.emit('error', e);
+  });
+  // The old Client interface emitted 'end' on socket end.
+  // This doesn't map to how we want things to operate in the future
+  // but it will get removed when we remove this legacy interface.
+  c.on('socket', function(s) {
+    s.on('end', function() {
+      if (self._decoder) {
+        var ret = self._decoder.end();
+        if (ret)
+          self.emit('data', ret);
+      }
+      self.emit('end');
+    });
+  });
+  return c;
+};
+
+exports.Client = util.deprecate(Client,
+    'http.Client will be removed soon. Do not use it.');
+
+exports.createClient = util.deprecate(function(port, host) {
+  return new Client(port, host);
+}, 'http.createClient is deprecated. Use `http.request` instead.');

data/assets/MacGap.app/Contents/Resources/https.js

@@ -0,0 +1,134 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var tls = require('tls');
+var http = require('http');
+var util = require('util');
+var inherits = require('util').inherits;
+var debug = util.debuglog('https');
+
+function Server(opts, requestListener) {
+  if (!(this instanceof Server)) return new Server(opts, requestListener);
+
+  if (process.features.tls_npn && !opts.NPNProtocols) {
+    opts.NPNProtocols = ['http/1.1', 'http/1.0'];
+  }
+
+  tls.Server.call(this, opts, http._connectionListener);
+
+  this.httpAllowHalfOpen = false;
+
+  if (requestListener) {
+    this.addListener('request', requestListener);
+  }
+
+  this.addListener('clientError', function(err, conn) {
+    conn.destroy();
+  });
+
+  this.timeout = 2 * 60 * 1000;
+}
+inherits(Server, tls.Server);
+exports.Server = Server;
+
+Server.prototype.setTimeout = http.Server.prototype.setTimeout;
+
+exports.createServer = function(opts, requestListener) {
+  return new Server(opts, requestListener);
+};
+
+
+// HTTPS agents.
+
+function createConnection(port, host, options) {
+  if (util.isObject(port)) {
+    options = port;
+  } else if (util.isObject(host)) {
+    options = host;
+  } else if (util.isObject(options)) {
+    options = options;
+  } else {
+    options = {};
+  }
+
+  if (util.isNumber(port)) {
+    options.port = port;
+  }
+
+  if (util.isString(host)) {
+    options.host = host;
+  }
+
+  debug('createConnection', options);
+  return tls.connect(options);
+}
+
+
+function Agent(options) {
+  http.Agent.call(this, options);
+  this.defaultPort = 443;
+  this.protocol = 'https:';
+}
+inherits(Agent, http.Agent);
+Agent.prototype.createConnection = createConnection;
+
+Agent.prototype.getName = function(options) {
+  var name = http.Agent.prototype.getName.call(this, options);
+
+  name += ':';
+  if (options.ca)
+    name += options.ca;
+
+  name += ':';
+  if (options.cert)
+    name += options.cert;
+
+  name += ':';
+  if (options.ciphers)
+    name += options.ciphers;
+
+  name += ':';
+  if (options.key)
+    name += options.key;
+
+  name += ':';
+  if (options.pfx)
+    name += options.pfx;
+
+  name += ':';
+  if (!util.isUndefined(options.rejectUnauthorized))
+    name += options.rejectUnauthorized;
+
+  return name;
+};
+
+var globalAgent = new Agent();
+
+exports.globalAgent = globalAgent;
+exports.Agent = Agent;
+
+exports.request = function(options, cb) {
+  return globalAgent.request(options, cb);
+};
+
+exports.get = function(options, cb) {
+  return globalAgent.get(options, cb);
+};

data/assets/MacGap.app/Contents/Resources/module.js

@@ -0,0 +1,529 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var NativeModule = require('native_module');
+var util = NativeModule.require('util');
+var runInThisContext = require('vm').runInThisContext;
+var runInNewContext = require('vm').runInNewContext;
+var assert = require('assert').ok;
+
+
+// If obj.hasOwnProperty has been overridden, then calling
+// obj.hasOwnProperty(prop) will break.
+// See: https://github.com/joyent/node/issues/1707
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+
+function Module(id, parent) {
+  this.id = id;
+  this.exports = {};
+  this.parent = parent;
+  if (parent && parent.children) {
+    parent.children.push(this);
+  }
+
+  this.filename = null;
+  this.loaded = false;
+  this.children = [];
+}
+module.exports = Module;
+
+// Set the environ variable NODE_MODULE_CONTEXTS=1 to make node load all
+// modules in their own context.
+Module._contextLoad = (+process.env['NODE_MODULE_CONTEXTS'] > 0);
+Module._cache = {};
+Module._pathCache = {};
+Module._extensions = {};
+var modulePaths = [];
+Module.globalPaths = [];
+
+Module.wrapper = NativeModule.wrapper;
+Module.wrap = NativeModule.wrap;
+
+var path = NativeModule.require('path');
+
+Module._debug = util.debuglog('module');
+
+
+// We use this alias for the preprocessor that filters it out
+var debug = Module._debug;
+
+
+// given a module name, and a list of paths to test, returns the first
+// matching file in the following precedence.
+//
+// require("a.<ext>")
+//   -> a.<ext>
+//
+// require("a")
+//   -> a
+//   -> a.<ext>
+//   -> a/index.<ext>
+
+function statPath(path) {
+  var fs = NativeModule.require('fs');
+  try {
+    return fs.statSync(path);
+  } catch (ex) {}
+  return false;
+}
+
+// check if the directory is a package.json dir
+var packageMainCache = {};
+
+function readPackage(requestPath) {
+  if (hasOwnProperty(packageMainCache, requestPath)) {
+    return packageMainCache[requestPath];
+  }
+
+  var fs = NativeModule.require('fs');
+  try {
+    var jsonPath = path.resolve(requestPath, 'package.json');
+    var json = fs.readFileSync(jsonPath, 'utf8');
+  } catch (e) {
+    return false;
+  }
+
+  try {
+    var pkg = packageMainCache[requestPath] = JSON.parse(json).main;
+  } catch (e) {
+    e.path = jsonPath;
+    e.message = 'Error parsing ' + jsonPath + ': ' + e.message;
+    throw e;
+  }
+  return pkg;
+}
+
+function tryPackage(requestPath, exts) {
+  var pkg = readPackage(requestPath);
+
+  if (!pkg) return false;
+
+  var filename = path.resolve(requestPath, pkg);
+  return tryFile(filename) || tryExtensions(filename, exts) ||
+         tryExtensions(path.resolve(filename, 'index'), exts);
+}
+
+// In order to minimize unnecessary lstat() calls,
+// this cache is a list of known-real paths.
+// Set to an empty object to reset.
+Module._realpathCache = {};
+
+// check if the file exists and is not a directory
+function tryFile(requestPath) {
+  var fs = NativeModule.require('fs');
+  var stats = statPath(requestPath);
+  if (stats && !stats.isDirectory()) {
+    return fs.realpathSync(requestPath, Module._realpathCache);
+  }
+  return false;
+}
+
+// given a path check a the file exists with any of the set extensions
+function tryExtensions(p, exts) {
+  for (var i = 0, EL = exts.length; i < EL; i++) {
+    var filename = tryFile(p + exts[i]);
+
+    if (filename) {
+      return filename;
+    }
+  }
+  return false;
+}
+
+
+Module._findPath = function(request, paths) {
+  var exts = Object.keys(Module._extensions);
+
+  if (request.charAt(0) === '/') {
+    paths = [''];
+  }
+
+  var trailingSlash = (request.slice(-1) === '/');
+
+  var cacheKey = JSON.stringify({request: request, paths: paths});
+  if (Module._pathCache[cacheKey]) {
+    return Module._pathCache[cacheKey];
+  }
+
+  // For each path
+  for (var i = 0, PL = paths.length; i < PL; i++) {
+    var basePath = path.resolve(paths[i], request);
+    var filename;
+
+    if (!trailingSlash) {
+      // try to join the request to the path
+      filename = tryFile(basePath);
+
+      if (!filename && !trailingSlash) {
+        // try it with each of the extensions
+        filename = tryExtensions(basePath, exts);
+      }
+    }
+
+    if (!filename) {
+      filename = tryPackage(basePath, exts);
+    }
+
+    if (!filename) {
+      // try it with each of the extensions at "index"
+      filename = tryExtensions(path.resolve(basePath, 'index'), exts);
+    }
+
+    if (filename) {
+      Module._pathCache[cacheKey] = filename;
+      return filename;
+    }
+  }
+  return false;
+};
+
+// 'from' is the __dirname of the module.
+Module._nodeModulePaths = function(from) {
+  // guarantee that 'from' is absolute.
+  from = path.resolve(from);
+
+  // note: this approach *only* works when the path is guaranteed
+  // to be absolute.  Doing a fully-edge-case-correct path.split
+  // that works on both Windows and Posix is non-trivial.
+  var splitRe = process.platform === 'win32' ? /[\/\\]/ : /\//;
+  var paths = [];
+  var parts = from.split(splitRe);
+
+  for (var tip = parts.length - 1; tip >= 0; tip--) {
+    // don't search in .../node_modules/node_modules
+    if (parts[tip] === 'node_modules') continue;
+    var dir = parts.slice(0, tip + 1).concat('node_modules').join(path.sep);
+    paths.push(dir);
+  }
+
+  return paths;
+};
+
+
+Module._resolveLookupPaths = function(request, parent) {
+  if (NativeModule.exists(request)) {
+    return [request, []];
+  }
+
+  var start = request.substring(0, 2);
+  if (start !== './' && start !== '..') {
+    var paths = modulePaths;
+    if (parent) {
+      if (!parent.paths) parent.paths = [];
+      paths = parent.paths.concat(paths);
+    }
+    return [request, paths];
+  }
+
+  // with --eval, parent.id is not set and parent.filename is null
+  if (!parent || !parent.id || !parent.filename) {
+    // make require('./path/to/foo') work - normally the path is taken
+    // from realpath(__filename) but with eval there is no filename
+    var mainPaths = ['.'].concat(modulePaths);
+    mainPaths = Module._nodeModulePaths('.').concat(mainPaths);
+    return [request, mainPaths];
+  }
+
+  // Is the parent an index module?
+  // We can assume the parent has a valid extension,
+  // as it already has been accepted as a module.
+  var isIndex = /^index\.\w+?$/.test(path.basename(parent.filename));
+  var parentIdPath = isIndex ? parent.id : path.dirname(parent.id);
+  var id = path.resolve(parentIdPath, request);
+
+  // make sure require('./path') and require('path') get distinct ids, even
+  // when called from the toplevel js file
+  if (parentIdPath === '.' && id.indexOf('/') === -1) {
+    id = './' + id;
+  }
+
+  debug('RELATIVE: requested:' + request +
+        ' set ID to: ' + id + ' from ' + parent.id);
+
+  return [id, [path.dirname(parent.filename)]];
+};
+
+
+Module._load = function(request, parent, isMain) {
+  if (parent) {
+    debug('Module._load REQUEST  ' + (request) + ' parent: ' + parent.id);
+  }
+
+  var filename = Module._resolveFilename(request, parent);
+
+  var cachedModule = Module._cache[filename];
+  if (cachedModule) {
+    return cachedModule.exports;
+  }
+
+  if (NativeModule.exists(filename)) {
+    // REPL is a special case, because it needs the real require.
+    if (filename == 'repl') {
+      var replModule = new Module('repl');
+      replModule._compile(NativeModule.getSource('repl'), 'repl.js');
+      NativeModule._cache.repl = replModule;
+      return replModule.exports;
+    }
+
+    debug('load native module ' + request);
+    return NativeModule.require(filename);
+  }
+
+  var module = new Module(filename, parent);
+
+  if (isMain) {
+    process.mainModule = module;
+    module.id = '.';
+  }
+
+  Module._cache[filename] = module;
+
+  var hadException = true;
+
+  try {
+    module.load(filename);
+    hadException = false;
+  } finally {
+    if (hadException) {
+      delete Module._cache[filename];
+    }
+  }
+
+  return module.exports;
+};
+
+Module._resolveFilename = function(request, parent) {
+  if (NativeModule.exists(request)) {
+    return request;
+  }
+
+  var resolvedModule = Module._resolveLookupPaths(request, parent);
+  var id = resolvedModule[0];
+  var paths = resolvedModule[1];
+
+  // look up the filename first, since that's the cache key.
+  debug('looking for ' + JSON.stringify(id) +
+        ' in ' + JSON.stringify(paths));
+
+  var filename = Module._findPath(request, paths);
+  if (!filename) {
+    var err = new Error("Cannot find module '" + request + "'");
+    err.code = 'MODULE_NOT_FOUND';
+    throw err;
+  }
+  return filename;
+};
+
+
+Module.prototype.load = function(filename) {
+  debug('load ' + JSON.stringify(filename) +
+        ' for module ' + JSON.stringify(this.id));
+
+  assert(!this.loaded);
+  this.filename = filename;
+  this.paths = Module._nodeModulePaths(path.dirname(filename));
+
+  var extension = path.extname(filename) || '.js';
+  if (!Module._extensions[extension]) extension = '.js';
+  Module._extensions[extension](this, filename);
+  this.loaded = true;
+};
+
+
+Module.prototype.require = function(path) {
+  assert(util.isString(path), 'path must be a string');
+  assert(path, 'missing path');
+  return Module._load(path, this);
+};
+
+
+// Resolved path to process.argv[1] will be lazily placed here
+// (needed for setting breakpoint when called with --debug-brk)
+var resolvedArgv;
+
+
+// Returns exception if any
+Module.prototype._compile = function(content, filename) {
+  var self = this;
+  // remove shebang
+  content = content.replace(/^\#\!.*/, '');
+
+  function require(path) {
+    return self.require(path);
+  }
+
+  require.resolve = function(request) {
+    return Module._resolveFilename(request, self);
+  };
+
+  Object.defineProperty(require, 'paths', { get: function() {
+    throw new Error('require.paths is removed. Use ' +
+                    'node_modules folders, or the NODE_PATH ' +
+                    'environment variable instead.');
+  }});
+
+  require.main = process.mainModule;
+
+  // Enable support to add extra extension types
+  require.extensions = Module._extensions;
+  require.registerExtension = function() {
+    throw new Error('require.registerExtension() removed. Use ' +
+                    'require.extensions instead.');
+  };
+
+  require.cache = Module._cache;
+
+  var dirname = path.dirname(filename);
+
+  if (Module._contextLoad) {
+    if (self.id !== '.') {
+      debug('load submodule');
+      // not root module
+      var sandbox = {};
+      for (var k in global) {
+        sandbox[k] = global[k];
+      }
+      sandbox.require = require;
+      sandbox.exports = self.exports;
+      sandbox.__filename = filename;
+      sandbox.__dirname = dirname;
+      sandbox.module = self;
+      sandbox.global = sandbox;
+      sandbox.root = root;
+
+      return runInNewContext(content, sandbox, { filename: filename });
+    }
+
+    debug('load root module');
+    // root module
+    global.require = require;
+    global.exports = self.exports;
+    global.__filename = filename;
+    global.__dirname = dirname;
+    global.module = self;
+
+    return runInThisContext(content, { filename: filename });
+  }
+
+  // create wrapper function
+  var wrapper = Module.wrap(content);
+
+  var compiledWrapper = runInThisContext(wrapper, { filename: filename });
+  if (global.v8debug) {
+    if (!resolvedArgv) {
+      // we enter the repl if we're not given a filename argument.
+      if (process.argv[1]) {
+        resolvedArgv = Module._resolveFilename(process.argv[1], null);
+      } else {
+        resolvedArgv = 'repl';
+      }
+    }
+
+    // Set breakpoint on module start
+    if (filename === resolvedArgv) {
+      global.v8debug.Debug.setBreakPoint(compiledWrapper, 0, 0);
+    }
+  }
+  var args = [self.exports, require, self, filename, dirname];
+  return compiledWrapper.apply(self.exports, args);
+};
+
+
+function stripBOM(content) {
+  // Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
+  // because the buffer-to-string conversion in `fs.readFileSync()`
+  // translates it to FEFF, the UTF-16 BOM.
+  if (content.charCodeAt(0) === 0xFEFF) {
+    content = content.slice(1);
+  }
+  return content;
+}
+
+
+// Native extension for .js
+Module._extensions['.js'] = function(module, filename) {
+  var content = NativeModule.require('fs').readFileSync(filename, 'utf8');
+  module._compile(stripBOM(content), filename);
+};
+
+
+// Native extension for .json
+Module._extensions['.json'] = function(module, filename) {
+  var content = NativeModule.require('fs').readFileSync(filename, 'utf8');
+  try {
+    module.exports = JSON.parse(stripBOM(content));
+  } catch (err) {
+    err.message = filename + ': ' + err.message;
+    throw err;
+  }
+};
+
+
+//Native extension for .node
+Module._extensions['.node'] = process.dlopen;
+
+
+// bootstrap main module.
+Module.runMain = function() {
+  // Load the main module--the command line argument.
+  Module._load(process.argv[1], null, true);
+  // Handle any nextTicks added in the first tick of the program
+  process._tickCallback();
+};
+
+Module._initPaths = function() {
+  var isWindows = process.platform === 'win32';
+
+  if (isWindows) {
+    var homeDir = process.env.USERPROFILE;
+  } else {
+    var homeDir = process.env.HOME;
+  }
+
+  var paths = [path.resolve(process.execPath, '..', '..', 'lib', 'node')];
+
+  if (homeDir) {
+    paths.unshift(path.resolve(homeDir, '.node_libraries'));
+    paths.unshift(path.resolve(homeDir, '.node_modules'));
+  }
+
+  if (process.env['NODE_PATH']) {
+    paths = process.env['NODE_PATH'].split(path.delimiter).concat(paths);
+  }
+
+  modulePaths = paths;
+
+  // clone as a read-only copy, for introspection.
+  Module.globalPaths = modulePaths.slice(0);
+};
+
+// bootstrap repl
+Module.requireRepl = function() {
+  return Module._load('repl', '.');
+};
+
+Module._initPaths();
+
+// backwards compatibility
+Module.Module = Module;