A new start

node_modules/flagged-respawn/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Tyler Kellen
+
+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.

node_modules/flagged-respawn/README.md

@@ -0,0 +1,93 @@
+# flagged-respawn [![Build Status](https://secure.travis-ci.org/js-cli/js-flagged-respawn.svg)](http://travis-ci.org/js-cli/js-flagged-respawn)
+> A tool for respawning node binaries when special flags are present.
+
+[![NPM](https://nodei.co/npm/flagged-respawn.png)](https://nodei.co/npm/flagged-respawn/)
+
+## What is it?
+
+Say you wrote a command line tool that runs arbitrary javascript (e.g. task runner, test framework, etc). For the sake of discussion, let's pretend it's a testing harness you've named `testify`.
+
+Everything is going splendidly until one day you decide to test some code that relies on a feature behind a v8 flag in node (`--harmony`, for example).  Without much thought, you run `testify --harmony spec tests.js`.
+
+It doesn't work. After digging around for a bit, you realize this produces a [`process.argv`](http://nodejs.org/docs/latest/api/process.html#process_process_argv) of:
+
+`['node', '/usr/local/bin/test', '--harmony', 'spec', 'tests.js']`
+
+Crap. The `--harmony` flag is in the wrong place! It should be applied to the **node** command, not our binary. What we actually wanted was this:
+
+`['node', '--harmony', '/usr/local/bin/test', 'spec', 'tests.js']`
+
+Flagged-respawn fixes this problem and handles all the edge cases respawning creates, such as:
+- Providing a method to determine if a respawn is needed.
+- Piping stderr/stdout from the child into the parent.
+- Making the parent process exit with the same code as the child.
+- If the child is killed, making the parent exit with the same signal.
+
+To see it in action, clone this repository and run `npm install` / `npm run respawn` / `npm run nospawn`.
+
+## Sample Usage
+
+```js
+#!/usr/bin/env node
+
+const flaggedRespawn = require('flagged-respawn');
+
+// get a list of all possible v8 flags for the running version of node
+const v8flags = require('v8flags').fetch();
+
+flaggedRespawn(v8flags, process.argv, function (ready, child) {
+  if (ready) {
+    console.log('Running!');
+    // your cli code here
+  } else {
+    console.log('Special flags found, respawning.');
+  }
+  if (process.pid !== child.pid) {
+    console.log('Respawned to PID:', child.pid);
+  }
+});
+
+```
+
+
+## API
+
+### <u>flaggedRespawn(flags, argv, [ forcedFlags, ] callback) : Void</u>
+
+Respawns the script itself when *argv* has special flag contained in *flags* and/or *forcedFlags* is not empty. Because members of *flags* and *forcedFlags* are passed to `node` command, each of them needs to be a node flag or a V8 flag.
+
+#### Forbid respawning
+
+If `--no-respawning` flag is given in *argv*, this function does not respawned even if *argv* contains members of flags or *forcedFlags* is not empty. (This flag is also used internally to prevent from respawning more than once).
+
+#### Parameter:
+
+| Parameter     |  Type  | Description |
+|:--------------|:------:|:----------------------------------------------------|
+| *flags*       | Array  | An array of node flags and V8 flags which are available when present in *argv*. |
+| *argv*        | Array  | Command line arguments to respawn.   |
+| *forcedFlags* | Array or String  | An array of node flags or a string of a single flag and V8 flags for respawning forcely. |
+| *callback*    | function | A called function when not respawning or after respawned. |
+
+* **<u><i>callback</i>(ready, proc, argv) : Void</u>**
+
+    *callback* function is called both when respawned or not, and it can be distinguished by callback's argument: *ready*. (*ready* indicates whether a process spawned its child process (false) or not (true), but it does not indicate whether a process is a spawned child process or not. *ready* for a spawned child process is true.)
+    
+    *argv* is an array of command line arguments which is respawned (when *ready* is false) or is passed current process except flags within *flags* and `--no-respawning` (when *ready* is true).
+
+    **Parameter:**
+    
+    | Parameter |  Type   | Description               |
+    |:----------|:-------:|:--------------------------|
+    | *ready*   | boolean | True, if not respawning and is ready to execute main function. |
+    | *proc*    | object  | Child process object if respawned, otherwise current process object. |
+    | *argv*    | Array   | An array of command line arguments. |
+
+## Release History
+
+* 2017-12-16 - v1.0.0 - Force/Forbid respawn, Improved API & testing
+* 2016-03-22 - v0.3.2 - fix issue with v8 flags values being dropped
+* 2014-09-12 - v0.3.1 - use `{ stdio: 'inherit' }` for spawn to maintain colors
+* 2014-09-11 - v0.3.0 - for real this time
+* 2014-09-11 - v0.2.0 - cleanup
+* 2014-09-04 - v0.1.1 - initial release

node_modules/flagged-respawn/index.js

@@ -0,0 +1,52 @@
+const reorder = require('./lib/reorder');
+const respawn = require('./lib/respawn');
+const remover = require('./lib/remover');
+
+const FORBID_RESPAWNING_FLAG = '--no-respawning';
+
+module.exports = function (flags, argv, forcedFlags, execute) {
+  if (!flags) {
+    throw new Error('You must specify flags to respawn with.');
+  }
+  if (!argv) {
+    throw new Error('You must specify an argv array.');
+  }
+
+  if (typeof forcedFlags === 'function') {
+    execute = forcedFlags;
+    forcedFlags = [];
+  }
+
+  if (typeof forcedFlags === 'string') {
+    forcedFlags = [forcedFlags];
+  }
+
+  if (!Array.isArray(forcedFlags)) {
+    forcedFlags = [];
+  }
+
+  var index = argv.indexOf(FORBID_RESPAWNING_FLAG);
+  if (index >= 0) {
+    argv = argv.slice(0, index).concat(argv.slice(index + 1));
+    argv = remover(flags, argv);
+    execute(true, process, argv);
+    return;
+  }
+
+  var proc = process;
+  var reordered = reorder(flags, argv);
+  var ready = JSON.stringify(argv) === JSON.stringify(reordered);
+
+  if (forcedFlags.length) {
+    reordered = reordered.slice(0, 1)
+      .concat(forcedFlags)
+      .concat(reordered.slice(1));
+    ready = false;
+  }
+
+  if (!ready) {
+    reordered.push(FORBID_RESPAWNING_FLAG);
+    proc = respawn(reordered);
+  }
+  execute(ready, proc, reordered);
+};

node_modules/flagged-respawn/lib/is-v8flags.js

@@ -0,0 +1,13 @@
+function isV8flags(flag, v8flags) {
+  return v8flags.indexOf(replaceSeparatorsFromDashesToUnderscores(flag)) >= 0;
+}
+
+function replaceSeparatorsFromDashesToUnderscores(flag) {
+  var arr = /^(-+)(.*)$/.exec(flag);
+  if (!arr) {
+    return flag;
+  }
+  return arr[1] + arr[2].replace(/\-/g, '_');
+}
+
+module.exports = isV8flags;

node_modules/flagged-respawn/lib/remover.js

@@ -0,0 +1,13 @@
+const isV8flags = require('./is-v8flags');
+
+module.exports = function(flags, argv) {
+  var args = argv.slice(0, 1);
+  for (var i = 1, n = argv.length; i < n; i++) {
+    var arg = argv[i];
+    var flag = arg.split('=')[0];
+    if (!isV8flags(flag, flags)) {
+      args.push(arg);
+    }
+  }
+  return args;
+};

node_modules/flagged-respawn/lib/reorder.js

@@ -0,0 +1,18 @@
+const isV8flags = require('./is-v8flags');
+
+module.exports = function (flags, argv) {
+  if (!argv) {
+    argv = process.argv;
+  }
+  var args = [argv[1]];
+  argv.slice(2).forEach(function (arg) {
+    var flag = arg.split('=')[0];
+    if (isV8flags(flag, flags)) {
+      args.unshift(arg);
+    } else {
+      args.push(arg);
+    }
+  });
+  args.unshift(argv[0]);
+  return args;
+};

node_modules/flagged-respawn/lib/respawn.js

@@ -0,0 +1,16 @@
+const spawn = require('child_process').spawn;
+
+module.exports = function (argv) {
+  var child = spawn(argv[0], argv.slice(1), { stdio: 'inherit' });
+  child.on('exit', function (code, signal) {
+    process.on('exit', function () {
+      /* istanbul ignore if */
+      if (signal) {
+        process.kill(process.pid, signal);
+      } else {
+        process.exit(code);
+      }
+    });
+  });
+  return child;
+};

node_modules/flagged-respawn/package.json

@@ -0,0 +1,69 @@
+{
+  "_from": "flagged-respawn@^1.0.0",
+  "_id": "flagged-respawn@1.0.0",
+  "_inBundle": false,
+  "_integrity": "sha1-Tnmumy6zi/hrO7Vr8+ClaqX8q9c=",
+  "_location": "/flagged-respawn",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "flagged-respawn@^1.0.0",
+    "name": "flagged-respawn",
+    "escapedName": "flagged-respawn",
+    "rawSpec": "^1.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^1.0.0"
+  },
+  "_requiredBy": [
+    "/liftoff"
+  ],
+  "_resolved": "https://registry.npmjs.org/flagged-respawn/-/flagged-respawn-1.0.0.tgz",
+  "_shasum": "4e79ae9b2eb38bf86b3bb56bf3e0a56aa5fcabd7",
+  "_spec": "flagged-respawn@^1.0.0",
+  "_where": "/var/www/html/autocompletion/node_modules/liftoff",
+  "author": {
+    "name": "Tyler Kellen",
+    "url": "http://goingslowly.com/"
+  },
+  "bugs": {
+    "url": "https://github.com/js-cli/js-flagged-respawn/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "A tool for respawning node binaries when special flags are present.",
+  "devDependencies": {
+    "chai": "^3.5.0",
+    "jscs": "^3.0.7",
+    "jshint": "^2.9.5",
+    "mocha": "^3.5.3",
+    "nyc": "^11.3.0",
+    "v8flags": "^3.0.1"
+  },
+  "engines": {
+    "node": ">= 0.8.0"
+  },
+  "files": [
+    "index.js",
+    "lib/"
+  ],
+  "homepage": "https://github.com/js-cli/js-flagged-respawn",
+  "keywords": [
+    "respawn flags"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "flagged-respawn",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/js-cli/js-flagged-respawn.git"
+  },
+  "scripts": {
+    "cover": "nyc --reporter=lcov --reporter=text-summary npm test",
+    "lint": "jshint index.js lib/ && jscs index.js lib/",
+    "nospawn": "node test/bin/respawner test",
+    "respawn": "node test/bin/respawner --harmony test",
+    "test": "npm run lint && mocha -R spec test"
+  },
+  "version": "1.0.0"
+}