mirror of https://github.com/atom/atom.git
115 lines
4.7 KiB
JavaScript
115 lines
4.7 KiB
JavaScript
const Task = require('./task');
|
|
|
|
// Searches local files for lines matching a specified regex. Implements `.then()`
|
|
// so that it can be used with `Promise.all()`.
|
|
class DirectorySearch {
|
|
constructor(rootPaths, regex, options) {
|
|
const scanHandlerOptions = {
|
|
ignoreCase: regex.ignoreCase,
|
|
inclusions: options.inclusions,
|
|
includeHidden: options.includeHidden,
|
|
excludeVcsIgnores: options.excludeVcsIgnores,
|
|
globalExclusions: options.exclusions,
|
|
follow: options.follow
|
|
};
|
|
const searchOptions = {
|
|
leadingContextLineCount: options.leadingContextLineCount,
|
|
trailingContextLineCount: options.trailingContextLineCount
|
|
};
|
|
this.task = new Task(require.resolve('./scan-handler'));
|
|
this.task.on('scan:result-found', options.didMatch);
|
|
this.task.on('scan:file-error', options.didError);
|
|
this.task.on('scan:paths-searched', options.didSearchPaths);
|
|
this.promise = new Promise((resolve, reject) => {
|
|
this.task.on('task:cancelled', reject);
|
|
this.task.start(
|
|
rootPaths,
|
|
regex.source,
|
|
scanHandlerOptions,
|
|
searchOptions,
|
|
() => {
|
|
this.task.terminate();
|
|
resolve();
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
then(...args) {
|
|
return this.promise.then.apply(this.promise, args);
|
|
}
|
|
|
|
cancel() {
|
|
// This will cause @promise to reject.
|
|
this.task.cancel();
|
|
}
|
|
}
|
|
|
|
// Default provider for the `atom.directory-searcher` service.
|
|
module.exports = class DefaultDirectorySearcher {
|
|
// Determines whether this object supports search for a `Directory`.
|
|
//
|
|
// * `directory` {Directory} whose search needs might be supported by this object.
|
|
//
|
|
// Returns a `boolean` indicating whether this object can search this `Directory`.
|
|
canSearchDirectory(directory) {
|
|
return true;
|
|
}
|
|
|
|
// Performs a text search for files in the specified `Directory`, subject to the
|
|
// specified parameters.
|
|
//
|
|
// Results are streamed back to the caller by invoking methods on the specified `options`,
|
|
// such as `didMatch` and `didError`.
|
|
//
|
|
// * `directories` {Array} of {Directory} objects to search, all of which have been accepted by
|
|
// this searcher's `canSearchDirectory()` predicate.
|
|
// * `regex` {RegExp} to search with.
|
|
// * `options` {Object} with the following properties:
|
|
// * `didMatch` {Function} call with a search result structured as follows:
|
|
// * `searchResult` {Object} with the following keys:
|
|
// * `filePath` {String} absolute path to the matching file.
|
|
// * `matches` {Array} with object elements with the following keys:
|
|
// * `lineText` {String} The full text of the matching line (without a line terminator character).
|
|
// * `lineTextOffset` {Number} If > 0, the provided line text is truncated and starts at this offset
|
|
// * `matchText` {String} The text that matched the `regex` used for the search.
|
|
// * `range` {Range} Identifies the matching region in the file. (Likely as an array of numeric arrays.)
|
|
// * `didError` {Function} call with an Error if there is a problem during the search.
|
|
// * `didSearchPaths` {Function} periodically call with the number of paths searched thus far.
|
|
// * `inclusions` {Array} of glob patterns (as strings) to search within. Note that this
|
|
// array may be empty, indicating that all files should be searched.
|
|
//
|
|
// Each item in the array is a file/directory pattern, e.g., `src` to search in the "src"
|
|
// directory or `*.js` to search all JavaScript files. In practice, this often comes from the
|
|
// comma-delimited list of patterns in the bottom text input of the ProjectFindView dialog.
|
|
// * `includeHidden` {boolean} whether to ignore hidden files.
|
|
// * `excludeVcsIgnores` {boolean} whether to exclude VCS ignored paths.
|
|
// * `exclusions` {Array} similar to inclusions
|
|
// * `follow` {boolean} whether symlinks should be followed.
|
|
//
|
|
// Returns a *thenable* `DirectorySearch` that includes a `cancel()` method. If `cancel()` is
|
|
// invoked before the `DirectorySearch` is determined, it will resolve the `DirectorySearch`.
|
|
search(directories, regex, options) {
|
|
const rootPaths = directories.map(directory => directory.getPath());
|
|
let isCancelled = false;
|
|
const directorySearch = new DirectorySearch(rootPaths, regex, options);
|
|
const promise = new Promise(function(resolve, reject) {
|
|
directorySearch.then(resolve, function() {
|
|
if (isCancelled) {
|
|
resolve();
|
|
} else {
|
|
reject(); // eslint-disable-line prefer-promise-reject-errors
|
|
}
|
|
});
|
|
});
|
|
return {
|
|
then: promise.then.bind(promise),
|
|
catch: promise.catch.bind(promise),
|
|
cancel() {
|
|
isCancelled = true;
|
|
directorySearch.cancel();
|
|
}
|
|
};
|
|
}
|
|
};
|