@ai-qa/workflow 2.0.3 → 2.0.6

package/qa-dashboard/node_modules/express-ejs-layouts/lib/express-layouts.js

@@ -0,0 +1,117 @@
+/*jslint sloppy:true indent:2 plusplus:true regexp:true*/
+
+var contentPattern = '&&<>&&';
+
+function contentFor(contentName) {
+  return contentPattern + contentName + contentPattern;
+}
+
+function parseContents(locals) {
+  var name, i = 1, str = locals.body,
+    regex = new RegExp('\r?\n?' + contentPattern + '.+?' + contentPattern + '\r?\n?', 'g'),
+    split = str.split(regex),
+    matches = str.match(regex);
+
+  locals.body = split[0];
+
+  if (matches !== null) {
+    matches.forEach(function (match) {
+      name = match.split(contentPattern)[1];
+      locals[name] = split[i];
+      i++;
+    });
+  }
+}
+
+function parseScripts(locals) {
+  var str = locals.body, regex = /\<script[\s\S]*?\>[\s\S]*?\<\/script\>/g;
+
+  if (regex.test(str)) {
+    locals.body = str.replace(regex, '');
+    locals.script = str.match(regex).join('\n');
+  }
+}
+
+function parseStyles(locals) {
+  var str = locals.body, regex = /(?:\<style[\s\S]*?\>[\s\S]*?\<\/style\>)|(?:\<link[\s\S]*?\>(?:\<\/link\>)?)/g;
+
+  if (regex.test(str)) {
+    locals.body = str.replace(regex, '');
+    locals.style = str.match(regex).join('\n');
+  }
+}
+
+function parseMetas(locals) {
+  var str = locals.body, regex = /\<meta[\s\S]*?\>/g;
+
+  if (regex.test(str)) {
+    locals.body = str.replace(regex, '');
+    locals.meta = str.match(regex).join('\n');
+  }
+}
+
+module.exports = function (req, res, next) {
+  if(!res.__render) res.__render = res.render;
+
+  res.render = function (view, options, fn) {
+    var layout, self = this, app = req.app,
+      defaultLayout = app.get('layout');
+
+    options = options || {};
+    if (typeof options === 'function') {
+      fn = options;
+      options = {};
+    }
+
+    if (options.layout === false || ((options.layout || defaultLayout) === false)) {
+      res.__render.call(res, view, options, fn);
+      return;
+    }
+
+    layout = options.layout || res.locals.layout || defaultLayout;
+    if (layout === true || layout === undefined) {
+      layout = 'layout';
+    }
+
+    options.contentFor = contentFor;
+    res.__render.call(res, view, options, function (err, str) {
+      var l, locals;
+
+      if (err) { return fn ? fn(err) : next(err); }
+
+      locals = {
+        body: str,
+        defineContent: function(contentName) { return locals[contentName] || ''; }
+      };
+      for (l in options) {
+        if (options.hasOwnProperty(l) && l !== 'layout' && l !== 'contentFor') {
+          locals[l] = options[l];
+        }
+      }
+
+      if (typeof locals.body !== 'string') {
+        res.__render.call(self, view, locals, fn);
+        return;
+      }
+
+      if (options.extractScripts === true || (options.extractScripts === undefined && app.get('layout extractScripts') === true)) {
+        locals.script = '';
+        parseScripts(locals);
+      }
+
+      if (options.extractStyles === true || (options.extractStyles === undefined && app.get('layout extractStyles') === true)) {
+        locals.style = '';
+        parseStyles(locals);
+      }
+
+      if (options.extractMetas === true || (options.extractMetas === undefined && app.get('layout extractMetas') === true)) {
+        locals.meta = '';
+        parseMetas(locals);
+      }
+
+      parseContents(locals);
+      res.__render.call(self, layout, locals, fn);
+    });
+  };
+  next();
+};

package/qa-dashboard/node_modules/express-ejs-layouts/package.json

@@ -0,0 +1,24 @@
+{
+  "author": "Igor Soarez <igorsoarez@gmail.com>",
+  "name": "express-ejs-layouts",
+  "description": "Layout support for ejs in express.",
+  "keywords": [
+    "express",
+    "layout",
+    "ejs"
+  ],
+  "version": "2.5.1",
+  "main": "lib/express-layouts.js",
+  "devDependencies": {
+    "ejs": "^2.6.1",
+    "express": "*",
+    "mocha": "*",
+    "should": "*",
+    "supertest": "*"
+  },
+  "optionalDependencies": {},
+  "scripts": {
+    "test": "mocha"
+  },
+  "repository": "git://github.com/Soarez/express-ejs-layouts.git"
+}

package/qa-dashboard/node_modules/filelist/README.md

@@ -0,0 +1,84 @@
+## FileList
+
+A FileList is a lazy-evaluated list of files. When given a list
+of glob patterns for possible files to be included in the file
+list, instead of searching the file structures to find the files,
+a FileList holds the pattern for latter use.
+
+This allows you to define a FileList to match any number of
+files, but only search out the actual files when then FileList
+itself is actually used. The key is that the first time an
+element of the FileList/Array is requested, the pending patterns
+are resolved into a real list of file names.
+
+### Usage
+
+Add files to the list with the `include` method. You can add glob
+patterns, individual files, or RegExp objects. When the Array
+methods are invoked on the FileList, these items are resolved to
+an actual list of files.
+
+```javascript
+var fl = new FileList();
+fl.include('test/*.js');
+fl.exclude('test/helpers.js');
+```
+
+Use the `exclude` method to override inclusions. You can use this
+when your inclusions are too broad.
+
+### Array methods
+
+FileList has lazy-evaluated versions of most of the array
+methods, including the following:
+
+* join
+* pop
+* push
+* concat
+* reverse
+* shift
+* unshift
+* slice
+* splice
+* sort
+* filter
+* forEach
+* some
+* every
+* map
+* indexOf
+* lastIndexOf
+* reduce
+* reduceRight
+
+When you call one of these methods, the items in the FileList
+will be resolved to the full list of files, and the method will
+be invoked on that result.
+
+### Special `length` method
+
+`length`: FileList includes a length *method* (instead of a
+property) which returns the number of actual files in the list
+once it's been resolved.
+
+### FileList-specific methods
+
+`include`: Add a filename/glob/regex to the list
+
+`exclude`: Override inclusions by excluding a filename/glob/regex
+
+`resolve`: Resolve the items in the FileList to the full list of
+files. This method is invoked automatically when one of the array
+methods is called.
+
+`toArray`: Immediately resolves the list of items, and returns an
+actual array of filepaths.
+
+`clearInclusions`: Clears any pending items -- must be used
+before resolving the list.
+
+`clearExclusions`: Clears the list of exclusions rules.
+
+
+

package/qa-dashboard/node_modules/filelist/index.d.ts

@@ -0,0 +1,110 @@
+// IncludeOptions definitions copied from minimatch (https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/minimatch/index.d.ts)
+interface IncludeOptions {
+  /**
+   * Dump a ton of stuff to stderr.
+   *
+   * @default false
+   */
+  debug?: boolean;
+
+  /**
+   * Do not expand {a,b} and {1..3} brace sets.
+   *
+   * @default false
+   */
+  nobrace?: boolean;
+
+  /**
+   * Disable ** matching against multiple folder names.
+   *
+   * @default false
+   */
+  noglobstar?: boolean;
+
+  /**
+   * Allow patterns to match filenames starting with a period,
+   * even if the pattern does not explicitly have a period in that spot.
+   *
+   * @default false
+   */
+  dot?: boolean;
+
+  /**
+   * Disable "extglob" style patterns like +(a|b).
+   *
+   * @default false
+   */
+  noext?: boolean;
+
+  /**
+   * Perform a case-insensitive match.
+   *
+   * @default false
+   */
+  nocase?: boolean;
+
+  /**
+   * When a match is not found by minimatch.match,
+   * return a list containing the pattern itself if this option is set.
+   * Otherwise, an empty list is returned if there are no matches.
+   *
+   * @default false
+   */
+  nonull?: boolean;
+
+  /**
+   * If set, then patterns without slashes will be matched against
+   * the basename of the path if it contains slashes.
+   *
+   * @default false
+   */
+  matchBase?: boolean;
+
+  /**
+   * Suppress the behavior of treating #
+   * at the start of a pattern as a comment.
+   *
+   * @default false
+   */
+  nocomment?: boolean;
+
+  /**
+   * Suppress the behavior of treating a leading ! character as negation.
+   *
+   * @default false
+   */
+  nonegate?: boolean;
+
+  /**
+   * Returns from negate expressions the same as if they were not negated.
+   * (Ie, true on a hit, false on a miss.)
+   *
+   * @default false
+   */
+  flipNegate?: boolean;
+}
+
+export class FileList {
+  static clone(): FileList
+  static verbose: boolean
+}
+
+export interface FileList extends Omit<Array<string>, "length"> {
+  pendingAdd: string[]
+  pending: boolean
+  excludes: {
+    pats: RegExp[],
+    funcs: Function[],
+    regex: null | RegExp
+  }
+  items: string[]
+  toArray(): string[]
+  include(...items: string[]): this
+  include(...items: (IncludeOptions | string)[]): this
+  exclude(...items: string[]): this
+  shouldExclude(item: string): boolean
+  resolve(): this
+  clearInclusions(): this
+  clearExclusions(): this
+  length(): number
+}