aboutsummaryrefslogtreecommitdiff
path: root/node_modules/filelist
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/filelist')
-rw-r--r--node_modules/filelist/README.md84
-rw-r--r--node_modules/filelist/index.d.ts54
-rw-r--r--node_modules/filelist/index.js486
-rw-r--r--node_modules/filelist/jakefile.js15
-rw-r--r--node_modules/filelist/package.json28
5 files changed, 667 insertions, 0 deletions
diff --git a/node_modules/filelist/README.md b/node_modules/filelist/README.md
new file mode 100644
index 0000000..b52ebe7
--- /dev/null
+++ b/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.
+
+
+
diff --git a/node_modules/filelist/index.d.ts b/node_modules/filelist/index.d.ts
new file mode 100644
index 0000000..dbf6dc5
--- /dev/null
+++ b/node_modules/filelist/index.d.ts
@@ -0,0 +1,54 @@
+// Type definitions for filelist v0.0.6
+// Project: https://github.com/mde/filelist
+// Definitions by: Christophe MASSOLIN <https://github.com/FuriouZz>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare module "filelist" {
+ export class FileList {
+ pendingAdd: string[]
+ pending: boolean
+ excludes: {
+ pats: RegExp[],
+ funcs: Function[],
+ regex: null | RegExp
+ }
+ items: string[]
+ static clone(): FileList
+ static verbose: boolean
+ toArray(): string[]
+ include(options: any, ...items: string[]): void
+ exclude(...items: string[]): void
+ resolve(): void
+ clearInclusions(): void
+ clearExclusions(): void
+ length(): number
+ toString(): string;
+ toLocaleString(): string;
+ push(...items: string[]): number;
+ pop(): string | undefined;
+ concat(...items: ReadonlyArray<string>[]): string[];
+ concat(...items: (string | ReadonlyArray<string>)[]): string[];
+ join(separator?: string): string;
+ reverse(): string[];
+ shift(): string | undefined;
+ slice(start?: number, end?: number): string[];
+ sort(compareFn?: (a: string, b: string) => number): this;
+ splice(start: number, deleteCount?: number): string[];
+ splice(start: number, deleteCount: number, ...items: string[]): string[];
+ unshift(...items: string[]): number;
+ indexOf(searchElement: string, fromIndex?: number): number;
+ lastIndexOf(searchElement: string, fromIndex?: number): number;
+ every(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any): boolean;
+ some(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any): boolean;
+ forEach(callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any): void;
+ map<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[];
+ filter<S extends string>(callbackfn: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[];
+ filter(callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): string[];
+ reduce(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
+ reduce(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
+ reduce<U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U;
+ reduceRight(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
+ reduceRight(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
+ reduceRight<U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U;
+ }
+} \ No newline at end of file
diff --git a/node_modules/filelist/index.js b/node_modules/filelist/index.js
new file mode 100644
index 0000000..fef873a
--- /dev/null
+++ b/node_modules/filelist/index.js
@@ -0,0 +1,486 @@
+/*
+ * 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.
+ *
+*/
+var fs = require('fs')
+, path = require('path')
+, minimatch = require('minimatch')
+, escapeRegExpChars
+, merge
+, basedir
+, _readDir
+, readdirR
+, globSync;
+
+ /**
+ @name escapeRegExpChars
+ @function
+ @return {String} A string of escaped characters
+ @description Escapes regex control-characters in strings
+ used to build regexes dynamically
+ @param {String} string The string of chars to escape
+ */
+ escapeRegExpChars = (function () {
+ var specials = [ '^', '$', '/', '.', '*', '+', '?', '|', '(', ')',
+ '[', ']', '{', '}', '\\' ];
+ var sRE = new RegExp('(\\' + specials.join('|\\') + ')', 'g');
+ return function (string) {
+ var str = string || '';
+ str = String(str);
+ return str.replace(sRE, '\\$1');
+ };
+ })();
+
+ /**
+ @name merge
+ @function
+ @return {Object} Returns the merged object
+ @description Merge merges `otherObject` into `object` and takes care of deep
+ merging of objects
+ @param {Object} object Object to merge into
+ @param {Object} otherObject Object to read from
+ */
+ merge = function (object, otherObject) {
+ var obj = object || {}
+ , otherObj = otherObject || {}
+ , key, value;
+
+ for (key in otherObj) {
+ value = otherObj[key];
+
+ // Check if a value is an Object, if so recursively add it's key/values
+ if (typeof value === 'object' && !(value instanceof Array)) {
+ // Update value of object to the one from otherObj
+ obj[key] = merge(obj[key], value);
+ }
+ // Value is anything other than an Object, so just add it
+ else {
+ obj[key] = value;
+ }
+ }
+
+ return obj;
+ };
+ /**
+ Given a patern, return the base directory of it (ie. the folder
+ that will contain all the files matching the path).
+ eg. file.basedir('/test/**') => '/test/'
+ Path ending by '/' are considerd as folder while other are considerd
+ as files, eg.:
+ file.basedir('/test/a/') => '/test/a'
+ file.basedir('/test/a') => '/test'
+ The returned path always end with a '/' so we have:
+ file.basedir(file.basedir(x)) == file.basedir(x)
+ */
+ basedir = function (pathParam) {
+ var bd = ''
+ , parts
+ , part
+ , pos = 0
+ , p = pathParam || '';
+
+ // If the path has a leading asterisk, basedir is the current dir
+ if (p.indexOf('*') == 0 || p.indexOf('**') == 0) {
+ return '.';
+ }
+
+ // always consider .. at the end as a folder and not a filename
+ if (/(?:^|\/|\\)\.\.$/.test(p.slice(-3))) {
+ p += '/';
+ }
+
+ parts = p.split(/\\|\//);
+ for (var i = 0, l = parts.length - 1; i < l; i++) {
+ part = parts[i];
+ if (part.indexOf('*') > -1 || part.indexOf('**') > -1) {
+ break;
+ }
+ pos += part.length + 1;
+ bd += part + p[pos - 1];
+ }
+ if (!bd) {
+ bd = '.';
+ }
+ // Strip trailing slashes
+ if (!(bd == '\\' || bd == '/')) {
+ bd = bd.replace(/\\$|\/$/, '');
+ }
+ return bd;
+
+ };
+
+ // Return the contents of a given directory
+ _readDir = function (dirPath) {
+ var dir = path.normalize(dirPath)
+ , paths = []
+ , ret = [dir]
+ , msg;
+
+ try {
+ paths = fs.readdirSync(dir);
+ }
+ catch (e) {
+ msg = 'Could not read path ' + dir + '\n';
+ if (e.stack) {
+ msg += e.stack;
+ }
+ throw new Error(msg);
+ }
+
+ paths.forEach(function (p) {
+ var curr = path.join(dir, p);
+ var stat = fs.statSync(curr);
+ if (stat.isDirectory()) {
+ ret = ret.concat(_readDir(curr));
+ }
+ else {
+ ret.push(curr);
+ }
+ });
+
+ return ret;
+ };
+
+ /**
+ @name file#readdirR
+ @function
+ @return {Array} Returns the contents as an Array, can be configured via opts.format
+ @description Reads the given directory returning it's contents
+ @param {String} dir The directory to read
+ @param {Object} opts Options to use
+ @param {String} [opts.format] Set the format to return(Default: Array)
+ */
+ readdirR = function (dir, opts) {
+ var options = opts || {}
+ , format = options.format || 'array'
+ , ret;
+ ret = _readDir(dir);
+ return format == 'string' ? ret.join('\n') : ret;
+ };
+
+
+globSync = function (pat, opts) {
+ var dirname = basedir(pat)
+ , files
+ , matches;
+
+ try {
+ files = readdirR(dirname).map(function(file){
+ return file.replace(/\\/g, '/');
+ });
+ }
+ // Bail if path doesn't exist -- assume no files
+ catch(e) {
+ if (FileList.verbose) console.error(e.message);
+ }
+
+ if (files) {
+ pat = path.normalize(pat);
+ matches = minimatch.match(files, pat, opts || {});
+ }
+ return matches || [];
+};
+
+// Constants
+// ---------------
+// List of all the builtin Array methods we want to override
+var ARRAY_METHODS = Object.getOwnPropertyNames(Array.prototype)
+// Array methods that return a copy instead of affecting the original
+ , SPECIAL_RETURN = {
+ 'concat': true
+ , 'slice': true
+ , 'filter': true
+ , 'map': true
+ }
+// Default file-patterns we want to ignore
+ , DEFAULT_IGNORE_PATTERNS = [
+ /(^|[\/\\])CVS([\/\\]|$)/
+ , /(^|[\/\\])\.svn([\/\\]|$)/
+ , /(^|[\/\\])\.git([\/\\]|$)/
+ , /\.bak$/
+ , /~$/
+ ]
+// Ignore core files
+ , DEFAULT_IGNORE_FUNCS = [
+ function (name) {
+ var isDir = false
+ , stats;
+ try {
+ stats = fs.statSync(name);
+ isDir = stats.isDirectory();
+ }
+ catch(e) {}
+ return (/(^|[\/\\])core$/).test(name) && !isDir;
+ }
+ ];
+
+var FileList = function () {
+ var self = this
+ , wrap;
+
+ // List of glob-patterns or specific filenames
+ this.pendingAdd = [];
+ // Switched to false after lazy-eval of files
+ this.pending = true;
+ // Used to calculate exclusions from the list of files
+ this.excludes = {
+ pats: DEFAULT_IGNORE_PATTERNS.slice()
+ , funcs: DEFAULT_IGNORE_FUNCS.slice()
+ , regex: null
+ };
+ this.items = [];
+
+ // Wrap the array methods with the delegates
+ wrap = function (prop) {
+ var arr;
+ self[prop] = function () {
+ if (self.pending) {
+ self.resolve();
+ }
+ if (typeof self.items[prop] == 'function') {
+ // Special method that return a copy
+ if (SPECIAL_RETURN[prop]) {
+ arr = self.items[prop].apply(self.items, arguments);
+ return FileList.clone(self, arr);
+ }
+ else {
+ return self.items[prop].apply(self.items, arguments);
+ }
+ }
+ else {
+ return self.items[prop];
+ }
+ };
+ };
+ for (var i = 0, ii = ARRAY_METHODS.length; i < ii; i++) {
+ wrap(ARRAY_METHODS[i]);
+ }
+
+ // Include whatever files got passed to the constructor
+ this.include.apply(this, arguments);
+
+ // Fix constructor linkage
+ this.constructor = FileList;
+};
+
+FileList.prototype = new (function () {
+ var globPattern = /[*?\[\{]/;
+
+ var _addMatching = function (item) {
+ var matches = globSync(item.path, item.options);
+ this.items = this.items.concat(matches);
+ }
+
+ , _resolveAdd = function (item) {
+ if (globPattern.test(item.path)) {
+ _addMatching.call(this, item);
+ }
+ else {
+ this.push(item.path);
+ }
+ }
+
+ , _calculateExcludeRe = function () {
+ var pats = this.excludes.pats
+ , pat
+ , excl = []
+ , matches = [];
+
+ for (var i = 0, ii = pats.length; i < ii; i++) {
+ pat = pats[i];
+ if (typeof pat == 'string') {
+ // Glob, look up files
+ if (/[*?]/.test(pat)) {
+ matches = globSync(pat);
+ matches = matches.map(function (m) {
+ return escapeRegExpChars(m);
+ });
+ excl = excl.concat(matches);
+ }
+ // String for regex
+ else {
+ excl.push(escapeRegExpChars(pat));
+ }
+ }
+ // Regex, grab the string-representation
+ else if (pat instanceof RegExp) {
+ excl.push(pat.toString().replace(/^\/|\/$/g, ''));
+ }
+ }
+ if (excl.length) {
+ this.excludes.regex = new RegExp('(' + excl.join(')|(') + ')');
+ }
+ else {
+ this.excludes.regex = /^$/;
+ }
+ }
+
+ , _resolveExclude = function () {
+ var self = this;
+ _calculateExcludeRe.call(this);
+ // No `reject` method, so use reverse-filter
+ this.items = this.items.filter(function (name) {
+ return !self.shouldExclude(name);
+ });
+ };
+
+ /**
+ * Includes file-patterns in the FileList. Should be called with one or more
+ * pattern for finding file to include in the list. Arguments should be strings
+ * for either a glob-pattern or a specific file-name, or an array of them
+ */
+ this.include = function () {
+ var args = Array.prototype.slice.call(arguments)
+ , arg
+ , includes = { items: [], options: {} };
+
+ for (var i = 0, ilen = args.length; i < ilen; i++) {
+ arg = args[i];
+
+ if (typeof arg === 'object' && !Array.isArray(arg)) {
+ merge(includes.options, arg);
+ } else {
+ includes.items = includes.items.concat(arg).filter(function (item) {
+ return !!item;
+ });
+ }
+ }
+
+ var items = includes.items.map(function(item) {
+ return { path: item, options: includes.options };
+ });
+
+ this.pendingAdd = this.pendingAdd.concat(items);
+
+ return this;
+ };
+
+ /**
+ * Indicates whether a particular file would be filtered out by the current
+ * exclusion rules for this FileList.
+ * @param {String} name The filename to check
+ * @return {Boolean} Whether or not the file should be excluded
+ */
+ this.shouldExclude = function (name) {
+ if (!this.excludes.regex) {
+ _calculateExcludeRe.call(this);
+ }
+ var excl = this.excludes;
+ return excl.regex.test(name) || excl.funcs.some(function (f) {
+ return !!f(name);
+ });
+ };
+
+ /**
+ * Excludes file-patterns from the FileList. Should be called with one or more
+ * pattern for finding file to include in the list. Arguments can be:
+ * 1. Strings for either a glob-pattern or a specific file-name
+ * 2. Regular expression literals
+ * 3. Functions to be run on the filename that return a true/false
+ */
+ this.exclude = function () {
+ var args = Array.isArray(arguments[0]) ? arguments[0] : arguments
+ , arg;
+ for (var i = 0, ii = args.length; i < ii; i++) {
+ arg = args[i];
+ if (typeof arg == 'function' && !(arg instanceof RegExp)) {
+ this.excludes.funcs.push(arg);
+ }
+ else {
+ this.excludes.pats.push(arg);
+ }
+ }
+ if (!this.pending) {
+ _resolveExclude.call(this);
+ }
+ return this;
+ };
+
+ /**
+ * Populates the FileList from the include/exclude rules with a list of
+ * actual files
+ */
+ this.resolve = function () {
+ var item
+ , uniqueFunc = function (p, c) {
+ if (p.indexOf(c) < 0) {
+ p.push(c);
+ }
+ return p;
+ };
+ if (this.pending) {
+ this.pending = false;
+ while ((item = this.pendingAdd.shift())) {
+ _resolveAdd.call(this, item);
+ }
+ // Reduce to a unique list
+ this.items = this.items.reduce(uniqueFunc, []);
+ // Remove exclusions
+ _resolveExclude.call(this);
+ }
+ return this;
+ };
+
+ /**
+ * Convert to a plain-jane array
+ */
+ this.toArray = function () {
+ // Call slice to ensure lazy-resolution before slicing items
+ var ret = this.slice().items.slice();
+ return ret;
+ };
+
+ /**
+ * Clear any pending items -- only useful before
+ * calling `resolve`
+ */
+ this.clearInclusions = function () {
+ this.pendingAdd = [];
+ return this;
+ };
+
+ /**
+ * Clear any current exclusion rules
+ */
+ this.clearExclusions = function () {
+ this.excludes = {
+ pats: []
+ , funcs: []
+ , regex: null
+ };
+ return this;
+ };
+
+})();
+
+// Static method, used to create copy returned by special
+// array methods
+FileList.clone = function (list, items) {
+ var clone = new FileList();
+ if (items) {
+ clone.items = items;
+ }
+ clone.pendingAdd = list.pendingAdd;
+ clone.pending = list.pending;
+ for (var p in list.excludes) {
+ clone.excludes[p] = list.excludes[p];
+ }
+ return clone;
+};
+
+FileList.verbose = true
+
+exports.FileList = FileList;
diff --git a/node_modules/filelist/jakefile.js b/node_modules/filelist/jakefile.js
new file mode 100644
index 0000000..18d4d7d
--- /dev/null
+++ b/node_modules/filelist/jakefile.js
@@ -0,0 +1,15 @@
+testTask('FileList', function () {
+ this.testFiles.include('test/*.js');
+});
+
+publishTask('FileList', function () {
+ this.packageFiles.include([
+ 'jakefile.js',
+ 'README.md',
+ 'package.json',
+ 'index.js',
+ 'index.d.ts'
+ ]);
+});
+
+
diff --git a/node_modules/filelist/package.json b/node_modules/filelist/package.json
new file mode 100644
index 0000000..9921036
--- /dev/null
+++ b/node_modules/filelist/package.json
@@ -0,0 +1,28 @@
+{
+ "name": "filelist",
+ "version": "1.0.2",
+ "description": "Lazy-evaluating list of files, based on globs or regex patterns",
+ "main": "index.js",
+ "types": "index.d.ts",
+ "scripts": {
+ "test": "jake test"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/mde/filelist.git"
+ },
+ "keywords": [
+ "file",
+ "utility",
+ "glob"
+ ],
+ "author": "Matthew Eernisse <mde@fleegix.org> (http://fleegix.org)",
+ "license": "Apache-2.0",
+ "bugs": {
+ "url": "https://github.com/mde/filelist/issues"
+ },
+ "homepage": "https://github.com/mde/filelist",
+ "dependencies": {
+ "minimatch": "^3.0.4"
+ }
+}
© Floofi Systems, Some rights reserved. Powered by cgit.