152 lines
4.1 KiB
JavaScript
152 lines
4.1 KiB
JavaScript
'use strict';
|
|
|
|
/**
|
|
* Contains `lookupFiles`, which takes some globs/dirs/options and returns a list of files.
|
|
* @module
|
|
* @private
|
|
*/
|
|
|
|
var fs = require('fs');
|
|
var path = require('path');
|
|
var glob = require('glob');
|
|
var {format} = require('util');
|
|
var errors = require('../errors');
|
|
var createNoFilesMatchPatternError = errors.createNoFilesMatchPatternError;
|
|
var createMissingArgumentError = errors.createMissingArgumentError;
|
|
var {sQuote, dQuote} = require('../utils');
|
|
|
|
/**
|
|
* Determines if pathname would be a "hidden" file (or directory) on UN*X.
|
|
*
|
|
* @description
|
|
* On UN*X, pathnames beginning with a full stop (aka dot) are hidden during
|
|
* typical usage. Dotfiles, plain-text configuration files, are prime examples.
|
|
*
|
|
* @see {@link http://xahlee.info/UnixResource_dir/writ/unix_origin_of_dot_filename.html|Origin of Dot File Names}
|
|
*
|
|
* @private
|
|
* @param {string} pathname - Pathname to check for match.
|
|
* @return {boolean} whether pathname would be considered a hidden file.
|
|
* @example
|
|
* isHiddenOnUnix('.profile'); // => true
|
|
*/
|
|
function isHiddenOnUnix(pathname) {
|
|
return path.basename(pathname)[0] === '.';
|
|
}
|
|
|
|
/**
|
|
* Determines if pathname has a matching file extension.
|
|
*
|
|
* @private
|
|
* @param {string} pathname - Pathname to check for match.
|
|
* @param {string[]} exts - List of file extensions (sans period).
|
|
* @return {boolean} whether file extension matches.
|
|
* @example
|
|
* hasMatchingExtname('foo.html', ['js', 'css']); // => false
|
|
*/
|
|
function hasMatchingExtname(pathname, exts) {
|
|
var suffix = path.extname(pathname).slice(1);
|
|
return exts.some(function(element) {
|
|
return suffix === element;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Lookup file names at the given `path`.
|
|
*
|
|
* @description
|
|
* Filenames are returned in _traversal_ order by the OS/filesystem.
|
|
* **Make no assumption that the names will be sorted in any fashion.**
|
|
*
|
|
* @public
|
|
* @alias module:lib/cli.lookupFiles
|
|
* @param {string} filepath - Base path to start searching from.
|
|
* @param {string[]} [extensions=[]] - File extensions to look for.
|
|
* @param {boolean} [recursive=false] - Whether to recurse into subdirectories.
|
|
* @return {string[]} An array of paths.
|
|
* @throws {Error} if no files match pattern.
|
|
* @throws {TypeError} if `filepath` is directory and `extensions` not provided.
|
|
*/
|
|
module.exports = function lookupFiles(filepath, extensions, recursive) {
|
|
extensions = extensions || [];
|
|
recursive = recursive || false;
|
|
var files = [];
|
|
var stat;
|
|
|
|
if (!fs.existsSync(filepath)) {
|
|
var pattern;
|
|
if (glob.hasMagic(filepath)) {
|
|
// Handle glob as is without extensions
|
|
pattern = filepath;
|
|
} else {
|
|
// glob pattern e.g. 'filepath+(.js|.ts)'
|
|
var strExtensions = extensions
|
|
.map(function(v) {
|
|
return '.' + v;
|
|
})
|
|
.join('|');
|
|
pattern = filepath + '+(' + strExtensions + ')';
|
|
}
|
|
files = glob.sync(pattern, {nodir: true});
|
|
if (!files.length) {
|
|
throw createNoFilesMatchPatternError(
|
|
'Cannot find any files matching pattern ' + dQuote(filepath),
|
|
filepath
|
|
);
|
|
}
|
|
return files;
|
|
}
|
|
|
|
// Handle file
|
|
try {
|
|
stat = fs.statSync(filepath);
|
|
if (stat.isFile()) {
|
|
return filepath;
|
|
}
|
|
} catch (err) {
|
|
// ignore error
|
|
return;
|
|
}
|
|
|
|
// Handle directory
|
|
fs.readdirSync(filepath).forEach(function(dirent) {
|
|
var pathname = path.join(filepath, dirent);
|
|
var stat;
|
|
|
|
try {
|
|
stat = fs.statSync(pathname);
|
|
if (stat.isDirectory()) {
|
|
if (recursive) {
|
|
files = files.concat(lookupFiles(pathname, extensions, recursive));
|
|
}
|
|
return;
|
|
}
|
|
} catch (err) {
|
|
// ignore error
|
|
return;
|
|
}
|
|
if (!extensions.length) {
|
|
throw createMissingArgumentError(
|
|
format(
|
|
'Argument %s required when argument %s is a directory',
|
|
sQuote('extensions'),
|
|
sQuote('filepath')
|
|
),
|
|
'extensions',
|
|
'array'
|
|
);
|
|
}
|
|
|
|
if (
|
|
!stat.isFile() ||
|
|
!hasMatchingExtname(pathname, extensions) ||
|
|
isHiddenOnUnix(pathname)
|
|
) {
|
|
return;
|
|
}
|
|
files.push(pathname);
|
|
});
|
|
|
|
return files;
|
|
};
|