koa-classic-server 1.0.0 → 1.0.2

package/test/node_modules/jake/lib/task/task.js

@@ -1,449 +0,0 @@
-let EventEmitter = require('events').EventEmitter;
-let async = require('async');
-let chalk = require('chalk');
-// 'rule' module is required at the bottom because circular deps
-
-// Used for task value, so better not to use
-// null, since value should be unset/uninitialized
-let UNDEFINED_VALUE;
-
-const ROOT_TASK_NAME = '__rootTask__';
-const POLLING_INTERVAL = 100;
-
-// Parse any positional args attached to the task-name
-function parsePrereqName(name) {
-  let taskArr = name.split('[');
-  let taskName = taskArr[0];
-  let taskArgs = [];
-  if (taskArr[1]) {
-    taskArgs = taskArr[1].replace(/\]$/, '');
-    taskArgs = taskArgs.split(',');
-  }
-  return {
-    name: taskName,
-    args: taskArgs
-  };
-}
-
-/**
-  @name jake.Task
-  @class
-  @extends EventEmitter
-  @description A Jake Task
-
-  @param {String} name The name of the Task
-  @param {Array} [prereqs] Prerequisites to be run before this task
-  @param {Function} [action] The action to perform for this task
-  @param {Object} [opts]
-    @param {Array} [opts.asyc=false] Perform this task asynchronously.
-    If you flag a task with this option, you must call the global
-    `complete` method inside the task's action, for execution to proceed
-    to the next task.
- */
-class Task extends EventEmitter {
-
-  constructor(name, prereqs, action, options) {
-    // EventEmitter ctor takes no args
-    super();
-
-    if (name.indexOf(':') > -1) {
-      throw new Error('Task name cannot include a colon. It is used internally as namespace delimiter.');
-    }
-    let opts = options || {};
-
-    this._currentPrereqIndex = 0;
-    this._internal = false;
-    this._skipped = false;
-
-    this.name = name;
-    this.prereqs = prereqs;
-    this.action = action;
-    this.async = false;
-    this.taskStatus = Task.runStatuses.UNSTARTED;
-    this.description = null;
-    this.args = [];
-    this.value = UNDEFINED_VALUE;
-    this.concurrency = 1;
-    this.startTime = null;
-    this.endTime = null;
-    this.directory = null;
-    this.namespace = null;
-
-    // Support legacy async-flag -- if not explicitly passed or falsy, will
-    // be set to empty-object
-    if (typeof opts == 'boolean' && opts === true) {
-      this.async = true;
-    }
-    else {
-      if (opts.async) {
-        this.async = true;
-      }
-      if (opts.concurrency) {
-        this.concurrency = opts.concurrency;
-      }
-    }
-
-    //Do a test on self dependencies for this task
-    if(Array.isArray(this.prereqs) && this.prereqs.indexOf(this.name) !== -1) {
-      throw new Error("Cannot use prereq " + this.name + " as a dependency of itself");
-    }
-  }
-
-  get fullName() {
-    return this._getFullName();
-  }
-
-  get params() {
-    return this._getParams();
-  }
-
-  _initInvocationChain() {
-    // Legacy global invocation chain
-    jake._invocationChain.push(this);
-
-    // New root chain
-    if (!this._invocationChain) {
-      this._invocationChainRoot = true;
-      this._invocationChain = [];
-      if (jake.currentRunningTask) {
-        jake.currentRunningTask._waitForChains = jake.currentRunningTask._waitForChains || [];
-        jake.currentRunningTask._waitForChains.push(this._invocationChain);
-      }
-    }
-  }
-
-  /**
-    @name jake.Task#invoke
-    @function
-    @description Runs prerequisites, then this task. If the task has already
-    been run, will not run the task again.
-   */
-  invoke() {
-    this._initInvocationChain();
-
-    this.args = Array.prototype.slice.call(arguments);
-    this.reenabled = false
-    this.runPrereqs();
-  }
-
-  /**
-    @name jake.Task#execute
-    @function
-    @description Run only this task, without prereqs. If the task has already
-    been run, *will* run the task again.
-   */
-  execute() {
-    this._initInvocationChain();
-
-    this.args = Array.prototype.slice.call(arguments);
-    this.reenable();
-    this.reenabled = true
-    this.run();
-  }
-
-  runPrereqs() {
-    if (this.prereqs && this.prereqs.length) {
-
-      if (this.concurrency > 1) {
-        async.eachLimit(this.prereqs, this.concurrency,
-
-          (name, cb) => {
-            let parsed = parsePrereqName(name);
-
-            let prereq = this.namespace.resolveTask(parsed.name) ||
-          jake.attemptRule(name, this.namespace, 0) ||
-          jake.createPlaceholderFileTask(name, this.namespace);
-
-            if (!prereq) {
-              throw new Error('Unknown task "' + name + '"');
-            }
-
-            //Test for circular invocation
-            if(prereq === this) {
-              setImmediate(function () {
-                cb(new Error("Cannot use prereq " + prereq.name + " as a dependency of itself"));
-              });
-            }
-
-            if (prereq.taskStatus == Task.runStatuses.DONE) {
-            //prereq already done, return
-              setImmediate(cb);
-            }
-            else {
-            //wait for complete before calling cb
-              prereq.once('_done', () => {
-                prereq.removeAllListeners('_done');
-                setImmediate(cb);
-              });
-              // Start the prereq if we are the first to encounter it
-              if (prereq.taskStatus === Task.runStatuses.UNSTARTED) {
-                prereq.taskStatus = Task.runStatuses.STARTED;
-                prereq.invoke.apply(prereq, parsed.args);
-              }
-            }
-          },
-
-          (err) => {
-          //async callback is called after all prereqs have run.
-            if (err) {
-              throw err;
-            }
-            else {
-              setImmediate(this.run.bind(this));
-            }
-          }
-        );
-      }
-      else {
-        setImmediate(this.nextPrereq.bind(this));
-      }
-    }
-    else {
-      setImmediate(this.run.bind(this));
-    }
-  }
-
-  nextPrereq() {
-    let self = this;
-    let index = this._currentPrereqIndex;
-    let name = this.prereqs[index];
-    let prereq;
-    let parsed;
-
-    if (name) {
-
-      parsed = parsePrereqName(name);
-
-      prereq = this.namespace.resolveTask(parsed.name) ||
-          jake.attemptRule(name, this.namespace, 0) ||
-          jake.createPlaceholderFileTask(name, this.namespace);
-
-      if (!prereq) {
-        throw new Error('Unknown task "' + name + '"');
-      }
-
-      // Do when done
-      if (prereq.taskStatus == Task.runStatuses.DONE) {
-        self.handlePrereqDone(prereq);
-      }
-      else {
-        prereq.once('_done', () => {
-          this.handlePrereqDone(prereq);
-          prereq.removeAllListeners('_done');
-        });
-        if (prereq.taskStatus == Task.runStatuses.UNSTARTED) {
-          prereq.taskStatus = Task.runStatuses.STARTED;
-          prereq._invocationChain = this._invocationChain;
-          prereq.invoke.apply(prereq, parsed.args);
-        }
-      }
-    }
-  }
-
-  /**
-    @name jake.Task#reenable
-    @function
-    @description Reenables a task so that it can be run again.
-   */
-  reenable(deep) {
-    let prereqs;
-    let prereq;
-    this._skipped = false;
-    this.taskStatus = Task.runStatuses.UNSTARTED;
-    this.value = UNDEFINED_VALUE;
-    if (deep && this.prereqs) {
-      prereqs = this.prereqs;
-      for (let i = 0, ii = prereqs.length; i < ii; i++) {
-        prereq = jake.Task[prereqs[i]];
-        if (prereq) {
-          prereq.reenable(deep);
-        }
-      }
-    }
-  }
-
-  handlePrereqDone(prereq) {
-    this._currentPrereqIndex++;
-    if (this._currentPrereqIndex < this.prereqs.length) {
-      setImmediate(this.nextPrereq.bind(this));
-    }
-    else {
-      setImmediate(this.run.bind(this));
-    }
-  }
-
-  isNeeded() {
-    let needed = true;
-    if (this.taskStatus == Task.runStatuses.DONE) {
-      needed = false;
-    }
-    return needed;
-  }
-
-  run() {
-    let val, previous;
-    let hasAction = typeof this.action == 'function';
-
-    if (!this.isNeeded()) {
-      this.emit('skip');
-      this.emit('_done');
-    }
-    else {
-      if (this._invocationChain.length) {
-        previous = this._invocationChain[this._invocationChain.length - 1];
-        // If this task is repeating and its previous is equal to this, don't check its status because it was set to UNSTARTED by the reenable() method
-        if (!(this.reenabled && previous == this)) {
-          if (previous.taskStatus != Task.runStatuses.DONE) {
-            let now = (new Date()).getTime();
-            if (now - this.startTime > jake._taskTimeout) {
-              return jake.fail(`Timed out waiting for task: ${previous.name} with status of ${previous.taskStatus}`);
-            }
-            setTimeout(this.run.bind(this), POLLING_INTERVAL);
-            return;
-          }
-        }
-      }
-      if (!(this.reenabled && previous == this)) {
-        this._invocationChain.push(this);
-      }
-
-      if (!(this._internal || jake.program.opts.quiet)) {
-        console.log("Starting '" + chalk.green(this.fullName) + "'...");
-      }
-
-      this.startTime = (new Date()).getTime();
-      this.emit('start');
-
-      jake.currentRunningTask = this;
-
-      if (hasAction) {
-        try {
-          if (this.directory) {
-            process.chdir(this.directory);
-          }
-
-          val = this.action.apply(this, this.args);
-
-          if (typeof val == 'object' && typeof val.then == 'function') {
-            this.async = true;
-
-            val.then(
-              (result) => {
-                setImmediate(() => {
-                  this.complete(result);
-                });
-              },
-              (err) => {
-                setImmediate(() => {
-                  this.errorOut(err);
-                });
-              });
-          }
-        }
-        catch (err) {
-          this.errorOut(err);
-          return; // Bail out, not complete
-        }
-      }
-
-      if (!(hasAction && this.async)) {
-        setImmediate(() => {
-          this.complete(val);
-        });
-      }
-    }
-  }
-
-  errorOut(err) {
-    this.taskStatus = Task.runStatuses.ERROR;
-    this._invocationChain.chainStatus = Task.runStatuses.ERROR;
-    this.emit('error', err);
-  }
-
-  complete(val) {
-
-    if (Array.isArray(this._waitForChains)) {
-      let stillWaiting = this._waitForChains.some((chain) => {
-        return !(chain.chainStatus == Task.runStatuses.DONE ||
-              chain.chainStatus == Task.runStatuses.ERROR);
-      });
-      if (stillWaiting) {
-        let now = (new Date()).getTime();
-        let elapsed = now - this.startTime;
-        if (elapsed > jake._taskTimeout) {
-          return jake.fail(`Timed out waiting for task: ${this.name} with status of ${this.taskStatus}. Elapsed: ${elapsed}`);
-        }
-        setTimeout(() => {
-          this.complete(val);
-        }, POLLING_INTERVAL);
-        return;
-      }
-    }
-
-    jake._invocationChain.splice(jake._invocationChain.indexOf(this), 1);
-
-    if (this._invocationChainRoot) {
-      this._invocationChain.chainStatus = Task.runStatuses.DONE;
-    }
-
-    this._currentPrereqIndex = 0;
-
-    // If 'complete' getting called because task has been
-    // run already, value will not be passed -- leave in place
-    if (!this._skipped) {
-      this.taskStatus = Task.runStatuses.DONE;
-      this.value = val;
-
-      this.emit('complete', this.value);
-      this.emit('_done');
-
-      this.endTime = (new Date()).getTime();
-      let taskTime = this.endTime - this.startTime;
-
-      if (!(this._internal || jake.program.opts.quiet)) {
-        console.log("Finished '" + chalk.green(this.fullName) + "' after " + chalk.magenta(taskTime + ' ms'));
-      }
-
-    }
-  }
-
-  _getFullName() {
-    let ns = this.namespace;
-    let path = (ns && ns.path) || '';
-    path = (path && path.split(':')) || [];
-    if (this.namespace !== jake.defaultNamespace) {
-      path.push(this.namespace.name);
-    }
-    path.push(this.name);
-    return path.join(':');
-  }
-
-  _getParams() {
-    if (!this.action) return "";
-    let params = new RegExp('(?:'+this.action.name+'\\s*|^)\\s*\\((.*?)\\)').exec(this.action.toString().replace(/\n/g, ''))[1].replace(/\/\*.*?\*\//g, '').replace(/ /g, '');
-    return params;
-  }
-
-  static getBaseNamespacePath(fullName) {
-    return fullName.split(':').slice(0, -1).join(':');
-  }
-
-  static getBaseTaskName(fullName) {
-    return fullName.split(':').pop();
-  }
-}
-
-Task.runStatuses = {
-  UNSTARTED: 'unstarted',
-  DONE: 'done',
-  STARTED: 'started',
-  ERROR: 'error'
-};
-
-Task.ROOT_TASK_NAME = ROOT_TASK_NAME;
-
-exports.Task = Task;
-
-// Required here because circular deps
-require('../rule');
-

package/test/node_modules/jake/lib/test_task.js

@@ -1,270 +0,0 @@
-/*
- * Jake JavaScript build tool
- * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *         http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
-*/
-
-let path = require('path');
-let currDir = process.cwd();
-
-/**
-  @name jake
-  @namespace jake
-*/
-/**
-  @name jake.TestTask
-  @constructor
-  @description Instantiating a TestTask creates a number of Jake
-  Tasks that make running tests for your software easy.
-
-  @param {String} name The name of the project
-  @param {Function} definition Defines the list of files containing the tests,
-  and the name of the namespace/task for running them. Will be executed on the
-  instantiated TestTask (i.e., 'this', will be the TestTask instance), to set
-  the various instance-propertiess.
-
-  @example
-  let t = new jake.TestTask('bij-js', function () {
-    this.testName = 'testSpecial';
-    this.testFiles.include('test/**');
-  });
-
- */
-let TestTask = function () {
-  let self = this;
-  let args = Array.prototype.slice.call(arguments);
-  let name = args.shift();
-  let definition = args.pop();
-  let prereqs = args.pop() || [];
-
-  /**
-    @name jake.TestTask#testNam
-    @public
-    @type {String}
-    @description The name of the namespace to place the tests in, and
-    the top-level task for running tests. Defaults to "test"
-   */
-  this.testName = 'test';
-
-  /**
-    @name jake.TestTask#testFiles
-    @public
-    @type {jake.FileList}
-    @description The list of files containing tests to load
-   */
-  this.testFiles = new jake.FileList();
-
-  /**
-    @name jake.TestTask#showDescription
-    @public
-    @type {Boolean}
-    @description Show the created task when doing Jake -T
-   */
-  this.showDescription = true;
-
-  /*
-    @name jake.TestTask#totalTests
-    @public
-    @type {Number}
-    @description The total number of tests to run
-  */
-  this.totalTests = 0;
-
-  /*
-    @name jake.TestTask#executedTests
-    @public
-    @type {Number}
-    @description The number of tests successfully run
-  */
-  this.executedTests = 0;
-
-  if (typeof definition == 'function') {
-    definition.call(this);
-  }
-
-  if (this.showDescription) {
-    desc('Run the tests for ' + name);
-  }
-
-  task(this.testName, prereqs, {async: true}, function () {
-    let t = jake.Task[this.fullName + ':run'];
-    t.on('complete', function () {
-      complete();
-    });
-    // Pass args to the namespaced test
-    t.invoke.apply(t, arguments);
-  });
-
-  namespace(self.testName, function () {
-
-    let runTask = task('run', {async: true}, function (pat) {
-      let re;
-      let testFiles;
-
-      // Don't nest; make a top-level namespace. Don't want
-      // re-calling from inside to nest infinitely
-      jake.currentNamespace = jake.defaultNamespace;
-
-      re = new RegExp(pat);
-      // Get test files that match the passed-in pattern
-      testFiles = self.testFiles.toArray()
-        .filter(function (f) {
-          return (re).test(f);
-        }) // Don't load the same file multiple times -- should this be in FileList?
-        .reduce(function (p, c) {
-          if (p.indexOf(c) < 0) {
-            p.push(c);
-          }
-          return p;
-        }, []);
-
-      // Create a namespace for all the testing tasks to live in
-      namespace(self.testName + 'Exec', function () {
-        // Each test will be a prereq for the dummy top-level task
-        let prereqs = [];
-        // Continuation to pass to the async tests, wrapping `continune`
-        let next = function () {
-          complete();
-        };
-        // Create the task for this test-function
-        let createTask = function (name, action) {
-          // If the test-function is defined with a continuation
-          // param, flag the task as async
-          let t;
-          let isAsync = !!action.length;
-
-          // Define the actual namespaced task with the name, the
-          // wrapped action, and the correc async-flag
-          t = task(name, createAction(name, action), {
-            async: isAsync
-          });
-          t.once('complete', function () {
-            self.executedTests++;
-          });
-          t._internal = true;
-          return t;
-        };
-        // Used as the action for the defined task for each test.
-        let createAction = function (n, a) {
-          // A wrapped function that passes in the `next` function
-          // for any tasks that run asynchronously
-          return function () {
-            let cb;
-            if (a.length) {
-              cb = next;
-            }
-            if (!(n == 'before' || n == 'after' ||
-                    /_beforeEach$/.test(n) || /_afterEach$/.test(n))) {
-              jake.logger.log(n);
-            }
-            // 'this' will be the task when action is run
-            return a.call(this, cb);
-          };
-        };
-          // Dummy top-level task for everything to be prereqs for
-        let topLevel;
-
-        // Pull in each test-file, and iterate over any exported
-        // test-functions. Register each test-function as a prereq task
-        testFiles.forEach(function (file) {
-          let exp = require(path.join(currDir, file));
-
-          // Create a namespace for each filename, so test-name collisions
-          // won't be a problem
-          namespace(file, function () {
-            let testPrefix = self.testName + 'Exec:' + file + ':';
-            let testName;
-            // Dummy task for displaying file banner
-            testName = '*** Running ' + file + ' ***';
-            prereqs.push(testPrefix + testName);
-            createTask(testName, function () {});
-
-            // 'before' setup
-            if (typeof exp.before == 'function') {
-              prereqs.push(testPrefix + 'before');
-              // Create the task
-              createTask('before', exp.before);
-            }
-
-            // Walk each exported function, and create a task for each
-            for (let p in exp) {
-              if (p == 'before' || p == 'after' ||
-                  p == 'beforeEach' || p == 'afterEach') {
-                continue;
-              }
-
-              if (typeof exp.beforeEach == 'function') {
-                prereqs.push(testPrefix + p + '_beforeEach');
-                // Create the task
-                createTask(p + '_beforeEach', exp.beforeEach);
-              }
-
-              // Add the namespace:name of this test to the list of prereqs
-              // for the dummy top-level task
-              prereqs.push(testPrefix + p);
-              // Create the task
-              createTask(p, exp[p]);
-
-              if (typeof exp.afterEach == 'function') {
-                prereqs.push(testPrefix + p + '_afterEach');
-                // Create the task
-                createTask(p + '_afterEach', exp.afterEach);
-              }
-            }
-
-            // 'after' teardown
-            if (typeof exp.after == 'function') {
-              prereqs.push(testPrefix + 'after');
-              // Create the task
-              let afterTask = createTask('after', exp.after);
-              afterTask._internal = true;
-            }
-
-          });
-        });
-
-        self.totalTests = prereqs.length;
-        process.on('exit', function () {
-          // Throw in the case where the process exits without
-          // finishing tests, but no error was thrown
-          if (!jake.errorCode && (self.totalTests > self.executedTests)) {
-            throw new Error('Process exited without all tests completing.');
-          }
-        });
-
-        // Create the dummy top-level task. When calling a task internally
-        // with `invoke` that is async (or has async prereqs), have to listen
-        // for the 'complete' event to know when it's done
-        topLevel = task('__top__', prereqs);
-        topLevel._internal = true;
-        topLevel.addListener('complete', function () {
-          jake.logger.log('All tests ran successfully');
-          complete();
-        });
-
-        topLevel.invoke(); // Do the thing!
-      });
-
-    });
-    runTask._internal = true;
-
-  });
-
-
-};
-
-jake.TestTask = TestTask;
-exports.TestTask = TestTask;
-