{"_id":"tromp","_rev":"61-c8d40a7068bc4b3951bef945379df5e8","name":"tromp","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","dist-tags":{"latest":"0.10.1"},"versions":{"0.2.0":{"name":"tromp","version":"0.2.0","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering. For use with `minimatch` or other filtering tools.\n\n## Use\n\n```javascript\n\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (node) {\n    console.log({\n      base: node.base(),\n      files: node.files(),\n      dirs: node.dirs()})\n  })\n\n```\n","_id":"tromp@0.2.0","dist":{"shasum":"3606abe209efc7a42ffdb70dc0610b864a3ca937","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.2.0.tgz","integrity":"sha512-3Jm+hZ25DlOrwuOVjHLqKxUvfgo6Vz/4zkctEul+Y1TS2JDfuWxQc4WrFndY18n/1oBwwJ9plKcnNHgywOjhgA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIDE4ulTnlvJ3YAMUl01bjgfavgeYnF5EtDs8NPC+1h6uAiEA4kTZcbui+96Byw3RfqDeXTa31XTfqu5rheKB7BIfEv0="}]},"_from":".","_npmVersion":"1.2.2","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.2.1":{"name":"tromp","version":"0.2.1","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering. For use with `minimatch` or other filtering tools.\n\n## Use\n\n```javascript\n\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (node) {\n    console.log({\n      base: node.base(),\n      files: node.files(),\n      dirs: node.dirs()})\n  })\n\n```\n","_id":"tromp@0.2.1","dist":{"shasum":"4a5aba1c025c48ef76c47c24252411d759cbd91b","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.2.1.tgz","integrity":"sha512-86ntAmIFr2RXsb50QbRyEIcyDhGNkxXTVC0QyLOkmMHDOeun1fAz327Zkltw4a2T/0fpOmehrI7RqKM3VddMMw==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEQCICri9MZo8bCDhaz2bd9NyRg4vGQBr/0/mEQNjV+dlO5uAiAzlozfB6EACd62EAlUPHgFHHBQuC4WNxOmKTuxfY2cZg=="}]},"_from":".","_npmVersion":"1.2.2","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.3.0":{"name":"tromp","version":"0.3.0","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering. For use with `minimatch` or other filtering tools.\n\n## Use\n\n```javascript\n\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (node) {\n    console.log({\n      base: node.base(),\n      files: node.files(),\n      dirs: node.dirs()})\n  })\n\n```\n\n## API\n\n### `class WalkRoot`\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent       | args          | desc\n-----       | ----          | ----\n`'active'`  | count, delta  | When `WalkRoot` starts and stops walk a root\n`'listing'` | node          | When entries have been received, but before entries have started `fs.stat`\n`'listed'`  | node          | After all entries have completed `fs.stat`\n`'entry'`   | entry, node   | After each `WalkEntry`'s completes `fs.stat`\n`'file'`    | entry, node   | After `'entry'` event, but filtered for files\n`'dir'`     | entry, node   | After `'entry'` event, but filtered for directories\n\n#### `WalkRoot::walk(path)`\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::filter(rx, ctx)`\nCalls `entry.filter(rx,ctx)` for each `entry` event occurance\n\n#### `WalkRoot::accept(rx, ctx)`\nCalls `entry.accept(rx,ctx)` for each `entry` event occurance\n\n#### `WalkRoot::reject(rx, ctx)`\nCalls `entry.accept(rx,ctx)` for each `entry` event occurance\n\n#### `WalkRoot::autoWalk(entry)`\nDouble dispatch mechanism, defaulting to `entry.walk()`\n\n\n### `class WalkListing`\n\n#### `WalkListing::select(fnList)`\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)`\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)`\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)`\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)`\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::walk(opts...)`\nInvokes `entry.walk()` for all directories returned by `this.dirs(opts...)`\n\n#### `WalkListing::filter(rx, ctx)`\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)`\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)`\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n### `class WalkEntry`\n\n","_id":"tromp@0.3.0","dist":{"shasum":"962fd056b2e1d441f4f6a921aab5002d6d400103","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.3.0.tgz","integrity":"sha512-wqcLtEFOGDNRaN38VTd/PXk8YPNBHGHG7kxB9GPp/J/nzrW6JWcrAP/ghH9Xb3HDinjU4JuO7YKF64aLZ2QF6A==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQCpwCT/19Cifd+BpTk9vVQJ2dxr2FYt4W5flTBz16s3FgIgZODHzRceOEYLl5iwhk53AxkPx7rYUf8BHoEAW5vBmng="}]},"_from":".","_npmVersion":"1.2.2","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.3.1":{"name":"tromp","version":"0.3.1","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering. For use with `minimatch` or other filtering tools.\n\n## Use\n\n```javascript\n\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (node) {\n    console.log({\n      base: node.base(),\n      files: node.files(),\n      dirs: node.dirs()})\n  })\n\n```\n\n## API\n\n### `class WalkRoot`\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent       | args          | desc\n-----       | ----          | ----\n`'active'`  | count, delta  | When `WalkRoot` starts and stops walk a root\n`'listing'` | node          | When entries have been received, but before entries have started `fs.stat`\n`'listed'`  | node          | After all entries have completed `fs.stat`\n`'entry'`   | entry, node   | After each `WalkEntry`'s completes `fs.stat`\n`'file'`    | entry, node   | After `'entry'` event, but filtered for files\n`'dir'`     | entry, node   | After `'entry'` event, but filtered for directories\n\n#### `WalkRoot::walk(path)`\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::filter(rx, ctx)`\nCalls `entry.filter(rx,ctx)` for each `entry` event occurance\n\n#### `WalkRoot::accept(rx, ctx)`\nCalls `entry.accept(rx,ctx)` for each `entry` event occurance\n\n#### `WalkRoot::reject(rx, ctx)`\nCalls `entry.accept(rx,ctx)` for each `entry` event occurance\n\n#### `WalkRoot::autoWalk(entry)`\nDouble dispatch mechanism, defaulting to `entry.walk()`\n\n\n\n### `class WalkListing`\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\nproperty  | description\n----------|-------------\nlisting   | `this`\npath      | string path being listed\nroot      | connected `WalkRoot` instance via `listing` property\nrootPath  | path initially responsible for causing this listing\nrelPath   | `path.relative(this.rootPath, this.path)`\n\n\n#### `WalkListing::select(fnList)`\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)`\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)`\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)`\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)`\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::walk(opts...)`\nInvokes `entry.walk()` for all directories returned by `this.dirs(opts...)`\n\n#### `WalkListing::filter(rx, ctx)`\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)`\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)`\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### `class WalkEntry`\nAn manipulable object representing and entry of the `WalkListing`.\n\nproperty  | description\n----------|-------------\nname      | entry basename\nlisting   | connected `WalkListing` instance\npath      | `path.resolve(this.listing.path, this.name)`\nroot      | connected `WalkRoot` instance via `listing` property\nrootPath  | path initially responsible for causing this listing\nrelPath   | `path.relative(this.rootPath, this.path)`\n\n#### `WalkEntry::modeKey()`\nReturns a string constant depending upon the entry file mode.\n\n#### `WalkEntry::isFile()`\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()`\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()`\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)`\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)`\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)`\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)`\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)`\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)`\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.3.1","dist":{"shasum":"174432107cd3906db36e9cf1cbc3437ea3947a70","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.3.1.tgz","integrity":"sha512-1NtBhn6EVrwy36o4DPpqmgiQAGV/8/R+NMTNy2xSTOdQPiLAeRvGXt83/c9j0jwGVk8ZHG7KSYjY1oBIxNcU6A==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIC2jgkDMaVj3RnmE2msQSWTJ2k9uDU/C2SiDfaQdJofeAiEAgMA7PwN4pl9n7si6JMHF/hKgXhK+LjrjO2LPRSIolh8="}]},"_from":".","_npmVersion":"1.2.2","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.3.2":{"name":"tromp","version":"0.3.2","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering. For use with `minimatch` or other filtering tools.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### `class WalkRoot`\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent       | args          | desc\n-----       | ----          | ----\n`'active'`  | count, delta  | When `WalkRoot` starts and stops walk a root\n`'listing'` | node          | When entries have been received, but before entries have started `fs.stat`\n`'listed'`  | node          | After all entries have completed `fs.stat`\n`'entry'`   | entry, node   | After each `WalkEntry`'s completes `fs.stat`\n`'file'`    | entry, node   | After `'entry'` event, but filtered for files\n`'dir'`     | entry, node   | After `'entry'` event, but filtered for directories\n\n#### `WalkRoot::walk(path)`\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::filter(rx, ctx)`\nCalls `entry.filter(rx,ctx)` for each `entry` event occurance\n\n#### `WalkRoot::accept(rx, ctx)`\nCalls `entry.accept(rx,ctx)` for each `entry` event occurance\n\n#### `WalkRoot::reject(rx, ctx)`\nCalls `entry.accept(rx,ctx)` for each `entry` event occurance\n\n#### `WalkRoot::autoWalk(entry)`\nDouble dispatch mechanism, defaulting to `entry.walk()`\n\n\n\n### `class WalkListing`\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\nproperty  | description\n----------|-------------\nlisting   | `this`\npath      | string path being listed\nroot      | connected `WalkRoot` instance via `listing` property\nrootPath  | path initially responsible for causing this listing\n\n\n#### `WalkListing::relPath(from)`\nReturns `path.relative(from||this.rootPath, this.path)`\n\n#### `WalkListing::select(fnList)`\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)`\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)`\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)`\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)`\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::walk(opts...)`\nInvokes `entry.walk()` for all directories returned by `this.dirs(opts...)`\n\n#### `WalkListing::filter(rx, ctx)`\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)`\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)`\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### `class WalkEntry`\nAn manipulable object representing and entry of the `WalkListing`.\n\nproperty  | description\n----------|-------------\nname      | entry basename\nlisting   | connected `WalkListing` instance\npath      | `path.resolve(this.listing.path, this.name)`\nroot      | connected `WalkRoot` instance via `listing` property\nrootPath  | path initially responsible for causing this listing\n\n#### `WalkEntry::relPath(from)`\nReturns `path.relative(from||this.rootPath, this.path)`\n\n#### `WalkEntry::modeKey()`\nReturns a string constant depending upon the entry file mode.\n\n#### `WalkEntry::isFile()`\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()`\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()`\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)`\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)`\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)`\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)`\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)`\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)`\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.3.2","dist":{"shasum":"54e57abaa5d9b1bd5f9b7c939af5a2af319f843b","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.3.2.tgz","integrity":"sha512-s7MN36v+4Ys/EA+EsleHCV/WF2ayfoIbBLYLL6MjkQdL4j7QZnaxCV+DmiKq5bIxniX1CDVhYxN4nLDdEnKfpw==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIHrTGQ7fjBbrM3sFthfmGBYqo8L39XQrmZdWWlcirGfnAiEAyySgFogj1wG7rfJ5ENnYU067YQ2CXGzIVZLFrge9g8Q="}]},"_from":".","_npmVersion":"1.2.2","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.4.0":{"name":"tromp","version":"0.4.0","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering. For use with `minimatch` or other filtering tools.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent       | args          | desc\n-----       | ----          | ----\n`'active'`  | count, delta  | When `WalkRoot` starts and stops walk a root\n`'listing'` | node          | When entries have been received, but before entries have started `fs.stat`\n`'listed'`  | node          | After all entries have completed `fs.stat`\n`'entry'`   | entry, node   | After each `WalkEntry`'s completes `fs.stat`\n`'file'`    | entry, node   | After `'entry'` event, but filtered for files\n`'dir'`     | entry, node   | After `'entry'` event, but filtered for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `entry` event occurance\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `entry` event occurance\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `entry` event occurance\n\n#### `WalkRoot::autoWalk(entry)` method\nDouble dispatch mechanism, defaulting to `entry.walk()`\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n#### `WalkEntry::path()` method\nReturns resolved path this listing represents\n#### `WalkEntry::rootPath()` method\nReturns the path initially responsible for this listing\n#### `WalkEntry::relPath()` method\nReturns `path()` relative to `rootPath()`\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::walk(opts...)` method\nInvokes `entry.walk()` for all directories returned by `this.dirs(opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n#### `WalkEntry::path()` method\nReturns resolved path this entry represents\n#### `WalkEntry::rootPath()` method\nReturns the path initially responsible for listing this entry\n#### `WalkEntry::relPath()` method\nReturns `path()` relative to `rootPath()`\n\n#### `WalkEntry::modeKey()` method\nReturns a string constant depending upon the entry file mode.\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.4.0","dist":{"shasum":"7b521f199a72db117dc3e2bff54c3d97f79eeb6d","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.4.0.tgz","integrity":"sha512-+/Wih+oV6HoFAO7bcCV7HJqAWXpJZq/DKmCq+qX2hEtl/64X3C9T+a4ERoa45p5Beb0g4NGboitGiQye2sPTfQ==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIAt2c8XRqw05Jg0y94RoZ3vS0Q1LkuBrbZxGW9YUzmuuAiEAt2fBnPxywQ08k4hZrVoYF9lO3AbX0b5AvHmSVoHNUq8="}]},"_from":".","_npmVersion":"1.2.2","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.4.1":{"name":"tromp","version":"0.4.1","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent       | args          | desc\n-----       | ----          | ----\n`'active'`  | count, delta  | When `WalkRoot` starts and stops walk a root\n`'listing'` | node          | When entries have been received, but before entries have started `fs.stat`\n`'listed'`  | node          | After all entries have completed `fs.stat`\n`'entry'`   | entry, node   | After each `WalkEntry`'s completes `fs.stat`\n`'file'`    | entry, node   | After `'entry'` event, but filtered for files\n`'dir'`     | entry, node   | After `'entry'` event, but filtered for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `entry` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `entry` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `entry` event occurence\n\n#### `WalkRoot::autoWalk(entry)` method\nDouble dispatch mechanism, defaulting to `entry.walk()`\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n#### `WalkEntry::path()` method\nReturns resolved path this listing represents\n#### `WalkEntry::rootPath()` method\nReturns the path initially responsible for this listing\n#### `WalkEntry::relPath()` method\nReturns `path()` relative to `rootPath()`\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::walk(opts...)` method\nInvokes `entry.walk()` for all directories returned by `this.dirs(opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n#### `WalkEntry::path()` method\nReturns resolved path this entry represents\n#### `WalkEntry::rootPath()` method\nReturns the path initially responsible for listing this entry\n#### `WalkEntry::relPath()` method\nReturns `path()` relative to `rootPath()`\n\n#### `WalkEntry::modeKey()` method\nReturns a string constant depending upon the entry file mode.\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.4.1","dist":{"shasum":"b37c3f5831877ea2528c611d5273128aebf2457a","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.4.1.tgz","integrity":"sha512-w7lToFYz2d8WO+9+CCYOQUF1tg3r1Yy2498prsRIfVhl6gUTjVSeEbf2RdhDaf6AVl413983A1MJe6fLT63XNg==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQD6N2HL85rVr0LKG1+4LVtGckXZ/9PmhnwqdbEY/32Q9wIhAITp3l5jf6EINzupJpfnJUD3i5e3p93f9GQ90WUYk8Oj"}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.4.2":{"name":"tromp","version":"0.4.2","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args          | desc\n-----             | ----          | ----\n`'active'`        | count, delta  | When `WalkRoot` starts and stops walk a root\n`'listing'`       | node          | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | node          | After all entries have completed `fs.stat`\n`'entry:filter'`  | entry, node   | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, node   | After each `WalkEntry`'s completes `fs.stat`\n`'file'`          | entry, node   | After `'entry'` event, but filtered for files\n`'dir'`           | entry, node   | After `'entry'` event, but filtered for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `entry:filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `entry:filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `entry:filter` event occurence\n\n#### `WalkRoot::autoWalk(entry)` method\nDouble dispatch mechanism, defaulting to `entry.walk()`\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n#### `WalkEntry::path()` method\nReturns resolved path this listing represents\n#### `WalkEntry::rootPath()` method\nReturns the path initially responsible for this listing\n#### `WalkEntry::relPath()` method\nReturns `path()` relative to `rootPath()`\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::walk(opts...)` method\nInvokes `entry.walk()` for all directories returned by `this.dirs(opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n#### `WalkEntry::path()` method\nReturns resolved path this entry represents\n#### `WalkEntry::rootPath()` method\nReturns the path initially responsible for listing this entry\n#### `WalkEntry::relPath()` method\nReturns `path()` relative to `rootPath()`\n\n#### `WalkEntry::modeKey()` method\nReturns a string constant depending upon the entry file mode.\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.4.2","dist":{"shasum":"177ca69ddac86a7a6d42de6e8a4f925a2243a679","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.4.2.tgz","integrity":"sha512-QaAfL/f+SfBpnU0lLRNlLQ7u4ZyuQJy+PM5OFFaWFFcml5B3WCPA9jQFPH0EuZuK7c4HnPak924ooQV0Wx6FnQ==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEQCIEY+YMQ+7Cr3NgaPWbHAq96+Jx7uZ1lZocW2qC9w2DwzAiAua/+nGn1PvudvancZF76yG8Fy6xiL7ZYUsabcd+DNVA=="}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.4.3":{"name":"tromp","version":"0.4.3","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args          | desc\n-----             | ----          | ----\n`'active'`        | count, delta  | When `WalkRoot` starts and stops walk a root\n`'listing'`       | node          | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | node          | After all entries have completed `fs.stat`\n`'filter'`        | entry, node   | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, node   | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, node   | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, node   | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `entry:filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `entry:filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `entry:filter` event occurence\n\n#### `WalkRoot::autoWalk(entry)` method\nDouble dispatch mechanism, defaulting to `entry.walk()`\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n#### `WalkEntry::path()` method\nReturns resolved path this listing represents\n#### `WalkEntry::rootPath()` method\nReturns the path initially responsible for this listing\n#### `WalkEntry::relPath()` method\nReturns `path()` relative to `rootPath()`\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::walk(opts...)` method\nInvokes `entry.walk()` for all directories returned by `this.dirs(opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n#### `WalkEntry::path()` method\nReturns resolved path this entry represents\n#### `WalkEntry::rootPath()` method\nReturns the path initially responsible for listing this entry\n#### `WalkEntry::relPath()` method\nReturns `path()` relative to `rootPath()`\n\n#### `WalkEntry::modeKey()` method\nReturns a string constant depending upon the entry file mode.\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.4.3","dist":{"shasum":"612e29d122f22c0712093334c52281375844f102","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.4.3.tgz","integrity":"sha512-EhsLqjmcDB0olwuFRa7QJhwhuxsY+T/feoOIgtgXUDd7MPA/RdE8+RmPNRnSO+eRwYuzktJJfEx7H7rgZDf9YA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQCmwqmo2Tv23WxrwZxtXcZXhg1JnGC8wTdFzm1dXmoGrAIgKn1+AdG2fwDayyK9teaVZEt5CuV0ABs5SWizvUTd368="}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.5.0":{"name":"tromp","version":"0.5.0","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args          | desc\n-----             | ----          | ----\n`'active'`        | count, delta  | When `WalkRoot` starts and stops walk a root\n`'start'`         |               | Emitted when `active` is greater than 0\n`'done'`          |               | Emitted when `active` returns to 0\n`'listing'`       | node          | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | node          | After all entries have completed `fs.stat`\n`'filter'`        | entry, node   | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, node   | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, node   | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, node   | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `entry:filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `entry:filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `entry:filter` event occurence\n\n#### `WalkRoot::autoWalk(entry)` method\nDouble dispatch mechanism, defaulting to `entry.walk()`\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n#### `WalkEntry::path()` method\nReturns resolved path this listing represents\n#### `WalkEntry::rootPath()` method\nReturns the path initially responsible for this listing\n#### `WalkEntry::relPath()` method\nReturns `path()` relative to `rootPath()`\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::walk(opts...)` method\nInvokes `entry.walk()` for all directories returned by `this.dirs(opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n#### `WalkEntry::path()` method\nReturns resolved path this entry represents\n#### `WalkEntry::rootPath()` method\nReturns the path initially responsible for listing this entry\n#### `WalkEntry::relPath()` method\nReturns `path()` relative to `rootPath()`\n\n#### `WalkEntry::modeKey()` method\nReturns a string constant depending upon the entry file mode.\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.5.0","dist":{"shasum":"0d05c704ba32b774c8c075b7406b6f7923afb326","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.5.0.tgz","integrity":"sha512-odNvtWL8naE8CV2C0rqBd03UTTbWSCigf2g2V8cRyxMHlL78iLP/S1YM2ltLhxmXsVVdtJAs+DjsbeRD6JRpgg==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQDbQSZTZwdRvrQyNFSnae0pSUcX9QOj+J3wGSpASd4G3gIgC5Golpw2r4xxboNxYFFaE4eWzAC9g55Alg9kP+Msx6E="}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.6.0":{"name":"tromp","version":"0.6.0","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args          | desc\n-----             | ----          | ----\n`'active'`        | count, delta  | When `WalkRoot` starts and stops walk a root\n`'start'`         |               | Emitted when `active` is greater than 0\n`'done'`          |               | Emitted when `active` returns to 0\n`'listing'`       | node          | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | node          | After all entries have completed `fs.stat`\n`'filter'`        | entry, node   | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, node   | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, node   | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, node   | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `entry:filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `entry:filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `entry:filter` event occurence\n\n#### `WalkRoot::autoWalk(entry)` method\nDouble dispatch mechanism, defaulting to `entry.walk()`\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::walk(opts...)` method\nInvokes `entry.walk()` for all directories returned by `this.dirs(opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkEntry::modeKey()` method\nReturns a string constant depending upon the entry file mode.\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.6.0","dist":{"shasum":"edb0ed2caf5df03d4132b48aa8d4f60cc19c5ac6","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.6.0.tgz","integrity":"sha512-vqJp99hFrWDioUPUQeh4XeK3yG9jKAKWEnDZsdZmCWyx2tEXB8XJlPY6MB99hbyD3pO5U2gCG/Cp5v19M+B4Zg==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQD0lBePRHsHkUk89zjN+iwI//40OkUOW40G8UM8hLIWpwIhANCPUhSnPGqol3p5C4YuNnXjTG/1O6DB0HF4bSjxA0I8"}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.7.0":{"name":"tromp","version":"0.7.0","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args          | desc\n-----             | ----          | ----\n`'done'`          |               | Emitted all walks have completed\n`'listing'`       | node          | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | node          | After all entries have completed `fs.stat`\n`'filter'`        | entry, node   | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, node   | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, node   | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, node   | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.7.0","dist":{"shasum":"0837430ec222644a304aa3af8484ce152c0759b6","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.7.0.tgz","integrity":"sha512-nyGR3gRHKKeP29pq9+IGlMKsKzTrrv3+oEbfzdOzSuMDoGPJg8cVXm3kb8c4FAHn+BZEctL6UgH9hhPqaL6KUQ==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIDhBLF8tKNX5l/64r3YuPsBzYcOvZ6Y41h8atp7j7xm5AiEA7JJZsf0XV5ChWF6XFjAppUR9o9nnrQ/kgvMQB3wsYu4="}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.7.1":{"name":"tromp","version":"0.7.1","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.7.1","dist":{"shasum":"02fcd3932117cf5812fc00fb187ad045dd8e0c19","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.7.1.tgz","integrity":"sha512-UCe7GXKspzwa8zJWbbBm0LhXeYqERJ4o2jtazPeKrn7Y2mUT3G1IoTjzpSU4EpusWXUfbIZER/DX3kvUtzveCg==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQDL63XHrSYW3b3YiLbRTWUmPBNXXbiQafXg7Tm+39BSYQIgP7Vx/V6xspVFtzHV2lYdirK5zjNxcr45tyO0UXVFkYc="}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.7.2":{"name":"tromp","version":"0.7.2","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.7.2","dist":{"shasum":"1dc6c2df20632dcd3c1a9c741607bc2541e4f3bc","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.7.2.tgz","integrity":"sha512-XJmKZA/l54vpK3D++KFVMLwEvjfTwY+wQOhv6Xi8Lx5nPYc7pmWh6c2XExSAu3rZY3yEJoEsxBKf6uYO9u60Ug==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQCidW/0nA33qGFLOW3cOG1wrA14m5JUQnX6sGS9+58qVwIhAI3dDfEoDvoyRI70Ag1zB+/6PG49dxI/DCsuLRS7cpQe"}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.7.3":{"name":"tromp","version":"0.7.3","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.7.3","dist":{"shasum":"b3ab9f18d79bed919f39609143b4a1f541270c53","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.7.3.tgz","integrity":"sha512-byqTF87W6q9wThbMiUDgBxLS29lQlnvD872kL+BIWGM9aMS37Ty4wi0RCmHNNjP3BAJEnXOZEcgfmekGQFTCPA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEQCIAji/w23f+o7WErm09rUNzSE8ib8Uxc3WMQxaaVhVX6KAiB0CBHG4zyOyMhN+nOIpWGY+KOj7cScM9YNanZZ5hnpSg=="}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.7.4":{"name":"tromp","version":"0.7.4","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.7.4","dist":{"shasum":"5a33c90d0872eb332b45f3e5a5fe9f8dcc284fe0","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.7.4.tgz","integrity":"sha512-DNrqcZzG7sjyeB4zu0YR4YfptQ1br6/pq4rjNmVCO98BmNQGIKW2NoUSNqOYA9b+wQXXA7DrYqTwq3x3CMiGEg==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIH6WHbFNWInwL9T3NcrQSCQQ/EQCz65DgnnrDWy5hJSAAiEA6kYhmGOhUe13HMPKRirxK9Jw8a6wJhPcUtMPV4JzWJA="}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.7.5":{"name":"tromp","version":"0.7.5","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.7.5","dist":{"shasum":"1c5d2d19a64e6de03feb74d9545fb7af736a389e","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.7.5.tgz","integrity":"sha512-hO6ITsXpWYaGDO+o+ZNgfoadTzDvvJaVJrAnBmDHw9UxVFMGmcVX8wbwV3dsrIeZuO/rG13j6i42l/UBsKm1WA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQChHUAZe4BWZlo/1NX4ze9PkJFRjkqqHSARh5zixKZvggIgV8QRGvbf26avb+QU8+PNt2RNH20Gx+9CvZh468hibFU="}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.7.6":{"name":"tromp","version":"0.7.6","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.7.6","dist":{"shasum":"3da48fe849b79e764a26afc2a0a5a0043a1909c8","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.7.6.tgz","integrity":"sha512-ISu65XUdhIfIJQXr6gErHbpcKveZeM75qunNHB5fQK71261umgj2UacJKBJpdu1qDlniJcGE71j/IqH+9+/wWg==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQDICezn8z9O08O23DBAHWd/Lr6JvAJkqhmDEYbCI/vLFwIgH7yqB9D22HvzjDXrTM7Y5UYZ+/cj58hDhDmTp/Ux3qo="}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.8.0":{"name":"tromp","version":"0.8.0","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.8.0","dist":{"shasum":"4e62e03061b3ce5aa287567e63322dfdded6db42","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.8.0.tgz","integrity":"sha512-1bqLoSSof4vuYNlLCSl5LjUh7rk9QdJrgsBdOQ1Pl4wmWoGGPLJeIkfUvv5EsgkSHTrLKobFU4gWMNPzQH4jvg==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQCu2H17Bm2qtx2mHZY44aq0YTN7KQ/aliLQCp5QYK0snAIhAKETSs0MLro4JB8QwCqPtC+aC5FBWlnyakwHOJJ9Ozsg"}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.8.1":{"name":"tromp","version":"0.8.1","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.8.1","dist":{"shasum":"4a7e551a11e86ced3b28f893668e17a2d1c343da","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.8.1.tgz","integrity":"sha512-U6LsoSLAEdpatH8PLrpKRubuEiK1QNMRepwnXqqXBzxZeRCsgF6F4A9Es8aJqIMvOGuyMKWNDINWA4m71w/MTA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEQCIGMLUiOAqDCLX9kU/qqWmH0+YZXDW/D8vZVMgvbpZyF+AiBKYmnxxl6k0vSLeSyFZ0XF61zW0rTGsYQHPPDwM7Ws3g=="}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.8.2":{"name":"tromp","version":"0.8.2","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.8.2","dist":{"shasum":"9bd3382892b8729f1da50877df875cb931fb6996","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.8.2.tgz","integrity":"sha512-VsSzsPX/AQ3eATLUi7bn8SNZONBjyBvdjH8au8Qxrs3bEL8LtKxN8deXxaYo3D7OjjRXuGF53pZKGPZRris1KA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQDOmjcHRj3ZRm01R2+AT0bE5454J8Bds+aLMYNQwkh2qgIgOLiSqIgTaDVlDxxwkbELSnhASP2AzfZPQMhL30fQ6qg="}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.8.3":{"name":"tromp","version":"0.8.3","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.8.3","dist":{"shasum":"04be31e725f8973365f75ef6f5bee76a7ffb4049","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.8.3.tgz","integrity":"sha512-D3FvLuSAuCmvQl2bhl5lk8p3cFGJHM7gSm1d+wNkxKKS7kws40A9W24v0TCsd1V+6AXoy+p5S16dval4zd9Jww==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQDI/GmcPg0iIzBX1Ilsq9XnXl/RQAoZHfDp7vr90kW8eQIhAM4kZdNMKQLwJz7rQ38/TYXWUBkgBhk3BpK616Qefy7v"}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.9.0":{"name":"tromp","version":"0.9.0","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.9.0","dist":{"shasum":"46af8ed6d8bc4e57db1d4037084ebdedcf215c71","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.9.0.tgz","integrity":"sha512-rPg2K9H5PYFEcOvL8DRt19JRUH3A3bK9uq/GIWX3rB65Ymle5RCN1P42nV9FepgNiDLbQBgZ+1Zie8YpDfeNSg==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIDSjwkEugvttt/+zXcpbGMzyQ4PKUbruaGJdvjbd5WG0AiEA4GNOTeTJMEMiGtQf5wmOe13t/L4rwneSJNKLwzcXx00="}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.9.2":{"name":"tromp","version":"0.9.2","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"devDependencies":{"coffee-script":"~1.6"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.9.2","dist":{"shasum":"6ce6900da8389eb2a5e05c9bbb9595fe6004eae8","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.9.2.tgz","integrity":"sha512-XA9deCqktMoa2kUuE8KDK1R7hicRxfnu/0nMB+yMPgKKzR5YWB8X7HrVE7qVeS+hbHdx3/+b1X3JetxHlpjhwQ==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQCX53JvB5Ci0hP0rWmPS8UOEaJtWmqnVXRahFOd81uTVwIhALtBDeduuqtJealqTBnXt0YbIHvl8Px8ZKySv9jw75pC"}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.9.3":{"name":"tromp","version":"0.9.3","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"devDependencies":{"coffee-script":"~1.6"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.9.3","dist":{"shasum":"861e772a03a3dbbc7218ab088bdff28d3d037e55","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.9.3.tgz","integrity":"sha512-jwhm/+Ei4qHWTkXp0ci84Gd9bE+IogVorGfSVWb2ZU1Ey4LcXU1AGXGVSVoZ7QWrPoi1AVLbpghylMZ/m1QEvA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIB+5SOg+swpeeC1Yb6bA9sZ7qoLGiYGShUBdBpJuOfcuAiEApKDM838eKKBWwbacxPqlfwk+yHOWzO8Vi5nYyJZZweU="}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.9.5":{"name":"tromp","version":"0.9.5","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"devDependencies":{"coffee-script":"~1.6"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.9.5","dist":{"shasum":"72e99ed2280e8b5f627f7cb0492a46aa1b1668f8","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.9.5.tgz","integrity":"sha512-QJcA0iwQqUL3Gw71aDNTdjYigZ/saGb4ieFHqlXibhP/0iqx/u3vJ0nv8uk9s3msunkfHpWs7Hi9/joXD1suJQ==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIDLUIrO1Cq2Vt9ZcnEXcuPP/AkOkfZ3p997h0GD9VWbTAiEAsAQekvvNt6KqFKYI/w7NkhG3+oFUp4Uf0yOyeDU9XfM="}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.9.6":{"name":"tromp","version":"0.9.6","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"devDependencies":{"coffee-script":"~1.6"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.9.6","dist":{"shasum":"4e1a4c03daae5cc017e26b3411ccc5799814b787","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.9.6.tgz","integrity":"sha512-iFGJeMEB7sybsy/X5JLqjXyuuGcgym9jnxFW1RpJM6qczAHXu/zRgi2F4aO58Xm912V1JvcIBPWM5o1KvsbBxQ==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQDNxM5GyraiQ4rSygYPTFFywynIFcZkLYufETsj+bCvtwIgQfsUhQZ+Ig+ehZHsvf6dexbn5Hf/Q/9py0xZt0nU53g="}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.10.0":{"name":"tromp","version":"0.10.0","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"devDependencies":{"coffee-script":"~1.6"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.10.0","dist":{"shasum":"8a2163f19c4ee73926b53de54f20b1eb0253982c","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.10.0.tgz","integrity":"sha512-SaHPPHVoIINiO5kQmmn45w18IXb8/mEit/2CXLTiDv+FzcdTcK1qr/PPiSsnet6d47Q2XjwK0Ji6/aEAOwzU2A==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQCRcNUh+aXnmZFuKpVSPj/OcmlxKd+4iuREE7OYEL1EzwIgEK2o2f+2AjSyxgVgtrBihZeY6EJ0s3aPMThwf3tkIhM="}]},"_from":".","_npmVersion":"1.2.11","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]},"0.10.1":{"name":"tromp","version":"0.10.1","license":"MIT","readmeFilename":"README.md","description":"Asynchronous filesystem directory walk with events and accept/reject filtering. For use with minimatch or other filtering tools.","keywords":["fs.readdir","minimatch","glob","walk","os.walk","walktree"],"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"main":"tromp.js","repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"},"scripts":{"test":"make test"},"devDependencies":{"coffee-script":"~1.6"},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering, designed to be used modules like `minimatch`.\n\n## Use\n\n```javascript\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (listing) {\n    console.log(listing.inspect()) })\n```\n\n## API\n\n### WalkRoot\nInstantiate using `function tromp(path, options, callback)`,\nreturning an instance of `WalkRoot` extending from `EventEmitter`.\n\narg                   | desc\n---                   | ----\n`path`                | string path reference for where to start walking\n`options.showHidden`  | if falsy, names beginning with `.` will be masked. default `false` \n`options.autoWalk`    | pluggable `function(entry)` called when directories are traversed; default calls `entry.walk()`\n`options.schedule`    | callable to schedule functions for later execution. default `process.nextTick`\n`options.tasks`       | number of concurrent filesystem operations in flight at once\n`callback`            | when provided, the function is added to `.on('listed', callback)`\n\nevent             | args            | desc\n-----             | ----            | ----\n`'done'`          |                 | Emitted all walks have completed\n`'listing'`       | listing         | When entries have been received, but before entries have started `fs.stat`\n`'listed'`        | listing         | After all entries have completed `fs.stat`\n`'filter'`        | entry, listing  | After each `WalkEntry`'s completes `fs.stat`, but before `entry` event\n`'entry'`         | entry, listing  | After each `WalkEntry`'s completes `fs.stat` and is not excluded during `filter` event\n`'file'`          | entry, listing  | After `'entry'` event, but only emitted for files\n`'dir'`           | entry, listing  | After `'entry'` event, but only emitted for directories\n\n#### `WalkRoot::walk(path)` method\nStarts a new walk rooted at path, creating a `WalkListing` instance if not already in progress for that path. Emits `active` events when listings are initiated or completed.\n\n#### `WalkRoot::autoWalk(entry, target)` method\nDouble dispatch mechanism, defaulting to `entry.walk(target)`\n\n#### `WalkRoot::filter(rx, ctx)` method\nCalls `entry.filter(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::accept(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n#### `WalkRoot::reject(rx, ctx)` method\nCalls `entry.accept(rx,ctx)` for each `filter` event occurence\n\n\n### WalkNode\nShared context between `WalkRoot`, `WalkListing` and `WalkEntry` instances.\n\n* `root` is the managing `WalkRoot` instance.\n* `rootPath` is the path walking initiates from\n* `listPath` is the directory path of the listing\n\n\n### WalkListing\nEncapsulates the active process of listing a directory and stating all of the entries so they can be categorized.\n\n* `rootPath` is the path walking initiates from\n* `path` is the directory path of the listing\n* `relPath` is `path` as relative to `rootPath`\n\n\n#### `WalkListing::select(fnList)` method\nReturns all entries not already excluded matching every function in `fnList`\n#### `WalkListing::selectEx(fnList)` method\nReturns all entries matching every function in `fnList`\n\n#### `WalkListing::matching(rx, opts...)` method\nInvokes `select({match:rx}, opts...)`\n#### `WalkListing::files(opts...)` method\nInvokes `select({isFile:true}, opts...)`\n#### `WalkListing::dirs(opts...)` method\nInvokes `select({isDirectory:true}, opts...)`\n\n#### `WalkListing::filter(rx, ctx)` method\nInvokes `entry.filter(rx, ctx)` against all listing entries.\n#### `WalkListing::accept(opts...)` method\nInvokes `entry.accept(rx, ctx)` against all listing entries.\n#### `WalkListing::reject(opts...)` method\nInvokes `entry.reject(rx, ctx)` against all listing entries.\n\n\n\n### WalkEntry\nAn manipulable object representing and entry of the `WalkListing`.\n\n* `rootPath` is the path initially responsible for listing this entry\n* `path` is the resolved path this entry represents\n* `relPath` is `path` as relative to `rootPath`\n* `stat` is an `fs.stat` instance, once initialized\n* `modeKey` is a string enum from `['unknown', 'file', 'dir', 'other']`\n\n\n#### `WalkEntry::isFile()` method\nReturns `true` if the entry is a file.\n\n#### `WalkEntry::isDirectory()` method\nReturns `true` if the entry is a directory.\n\n#### `WalkEntry::isWalkable()` method\nReturns `true` if not excluded and is a directory\n\n#### `WalkEntry::walk(force)` method\nStarts a new walk using the entry's path if it is walkable. See `WalkRoot::walk`.\n\n#### `WalkEntry::match(rx, ctx)` method\nIf `rx` is callable, then `return rx.call(this.name, ctx)`\nOtherwise use String::match as `return this.name.match(rx)`.\n\n#### `WalkEntry::exclude(value)` method\nMark as excluded if `!!value`, otherwise mark as included.\n\n#### `WalkEntry::accept(rx, ctx)` method\nWith no parameters, marks entry as included.\nOtherwise, if `match(rx, ctx)`, then `exclude(false)`\n\n#### `WalkEntry::reject(rx, ctx)` method\nWith no parameters, marks entry as excluded.\nOtherwise, if `match(rx, ctx)`, then `exclude(true)`\n\n#### `WalkEntry::filter(rx, ctx)` method\nInvokes `exclude(match(rx, ctx))`\n","_id":"tromp@0.10.1","dist":{"shasum":"a88fc5bd8cbe7057d593f8744e83364c823ee813","tarball":"https://registry.npmjs.org/tromp/-/tromp-0.10.1.tgz","integrity":"sha512-U8JDp37Vs0yoq6XszdTbYF8DUa6v1PUeTCWvHfSULN2nogYYJSoie5uuSKG1pt3LJomw/5AeSPnbZoG/lERcbA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQDx0dFWdsTyJRyE8ww/A+ObhK/UIF38DTR82eVdX4ZhmQIgZpWFNVD9c+iVJLt77+mEtACIURwI2d1cmFhr4Wl2buE="}]},"_from":".","_npmVersion":"1.2.18","_npmUser":{"name":"shanewholloway","email":"shane.holloway@ieee.org"},"maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}]}},"readme":"Tromp is an asynchronous filesystem directory walking algorithm with events and accept/reject filtering. For use with `minimatch` or other filtering tools.\n\n## Use\n\n```javascript\n\nvar tromp = require('tromp')\n\ntromp('.')\n  .reject(/node_modules/)\n  .on('listed', function (node) {\n    console.log({\n      base: node.base(),\n      files: node.files(),\n      dirs: node.dirs()})\n  })\n\n```\n","maintainers":[{"name":"shanewholloway","email":"shane.holloway@ieee.org"}],"time":{"modified":"2022-06-27T21:36:32.075Z","created":"2013-02-20T19:34:50.030Z","0.2.0":"2013-02-20T19:34:50.514Z","0.2.1":"2013-02-20T19:38:32.280Z","0.3.0":"2013-02-21T00:04:20.669Z","0.3.1":"2013-02-21T00:24:21.817Z","0.3.2":"2013-02-21T13:55:12.992Z","0.4.0":"2013-02-21T15:09:14.970Z","0.4.1":"2013-02-21T17:23:28.767Z","0.4.2":"2013-02-21T18:06:35.569Z","0.4.3":"2013-02-21T18:18:24.044Z","0.5.0":"2013-02-26T15:11:51.027Z","0.6.0":"2013-02-26T16:43:53.919Z","0.7.0":"2013-02-27T14:50:44.432Z","0.7.1":"2013-02-27T16:33:34.235Z","0.7.2":"2013-02-27T17:24:46.345Z","0.7.3":"2013-02-27T19:06:50.677Z","0.7.4":"2013-02-28T17:39:47.845Z","0.7.5":"2013-02-28T22:46:45.759Z","0.7.6":"2013-03-02T01:03:38.222Z","0.8.0":"2013-03-02T01:21:31.146Z","0.8.1":"2013-03-02T11:17:47.443Z","0.8.2":"2013-03-03T18:33:32.926Z","0.8.3":"2013-03-05T13:13:02.307Z","0.9.0":"2013-03-05T13:28:48.498Z","0.9.2":"2013-03-07T21:13:40.987Z","0.9.3":"2013-03-08T21:24:18.676Z","0.9.5":"2013-03-12T17:49:25.438Z","0.9.6":"2013-03-13T16:17:03.141Z","0.10.0":"2013-03-19T13:11:09.235Z","0.10.1":"2013-05-30T13:21:34.374Z"},"author":{"name":"Shane Holloway","email":"shane.holloway@ieee.org"},"repository":{"type":"git","url":"git://github.com/shanewholloway/node-tromp.git"}}