You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
168 lines
5.9 KiB
168 lines
5.9 KiB
'use strict';
|
|
|
|
var fs = require('fs'),
|
|
path = require('path'),
|
|
defaults = require('lodash.defaults');
|
|
|
|
var PACKAGE_NAME = require('../package.json').name;
|
|
|
|
/**
|
|
* Factory for find-file with the given <code>options</code> hash.
|
|
* @param {{debug: boolean, attempts:number}} [opt] Optional options hash
|
|
*/
|
|
function findFile(opt) {
|
|
var options = defaults(opt, {
|
|
debug: false,
|
|
attempts: 0
|
|
});
|
|
return {
|
|
absolute: absolute,
|
|
base : base
|
|
};
|
|
|
|
/**
|
|
* Search for the relative file reference from the <code>startPath</code> up to the process
|
|
* working directory, avoiding any other directories with a <code>package.json</code> or <code>bower.json</code>.
|
|
* @param {string} startPath The location of the uri declaration and the place to start the search from
|
|
* @param {string} uri The content of the url() statement, expected to be a relative file path
|
|
* @param {string} [limit] Optional directory to limit the search to
|
|
* @returns {string|null} <code>null</code> where not found else the absolute path to the file
|
|
*/
|
|
function absolute(startPath, uri, limit) {
|
|
var basePath = base(startPath, uri, limit);
|
|
return !!basePath && path.resolve(basePath, uri) || null;
|
|
}
|
|
|
|
/**
|
|
* Search for the relative file reference from the <code>startPath</code> up to the process
|
|
* working directory, avoiding any other directories with a <code>package.json</code> or <code>bower.json</code>.
|
|
* @param {string} startPath The location of the uri declaration and the place to start the search from
|
|
* @param {string} uri The content of the url() statement, expected to be a relative file path
|
|
* @param {string} [limit] Optional directory to limit the search to
|
|
* @returns {string|null} <code>null</code> where not found else the base path upon which the uri may be resolved
|
|
*/
|
|
function base(startPath, uri, limit) {
|
|
var messages = [];
|
|
|
|
// ensure we have some limit to the search
|
|
limit = limit && path.resolve(limit) || process.cwd();
|
|
|
|
// #69 limit searching: make at least one attempt
|
|
var remaining = Math.max(0, options.attempts) || 1E+9;
|
|
|
|
// ignore explicit uris data|http|https and ensure we are at a valid start path
|
|
var absoluteStart = !(/^(data|https?):/.test(uri)) && path.resolve(startPath);
|
|
if (absoluteStart) {
|
|
|
|
// find path to the root, stopping at cwd, package.json or bower.json
|
|
var pathToRoot = [];
|
|
var isWorking;
|
|
do {
|
|
pathToRoot.push(absoluteStart);
|
|
isWorking = testWithinLimit(absoluteStart) && testNotPackage(absoluteStart);
|
|
absoluteStart = path.resolve(absoluteStart, '..');
|
|
} while (isWorking);
|
|
|
|
// start a queue with the path to the root
|
|
var appendLimit = options.includeRoot && pathToRoot.indexOf(limit) === -1 ? limit : [];
|
|
var queue = pathToRoot.concat(appendLimit);
|
|
|
|
// the queue pattern ensures that we favour paths closest the the start path
|
|
// process the queue until empty or until we exhaust our attempts
|
|
while (queue.length && (remaining-- > 0)) {
|
|
|
|
// shift the first item off the queue, consider it the base for our relative uri
|
|
var basePath = queue.shift();
|
|
var fullPath = path.resolve(basePath, uri);
|
|
messages.push(basePath);
|
|
|
|
// file exists so convert to a dataURI and end
|
|
if (fs.existsSync(fullPath)) {
|
|
flushMessages('FOUND');
|
|
return basePath;
|
|
}
|
|
// enqueue subdirectories that are not packages and are not in the root path
|
|
else {
|
|
enqueue(queue, basePath);
|
|
}
|
|
}
|
|
|
|
// interrupted by options.attempts
|
|
if (queue.length) {
|
|
flushMessages('NOT FOUND (INTERRUPTED)');
|
|
}
|
|
// not found
|
|
else {
|
|
flushMessages('NOT FOUND');
|
|
return null;
|
|
}
|
|
}
|
|
// ignored
|
|
else {
|
|
flushMessages('IGNORED');
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Enqueue subdirectories that are not packages and are not in the root path
|
|
* @param {Array} queue The queue to add to
|
|
* @param {string} basePath The path to consider
|
|
*/
|
|
function enqueue(queue, basePath) {
|
|
fs.readdirSync(basePath)
|
|
.filter(function notHidden(filename) {
|
|
return (filename.charAt(0) !== '.');
|
|
})
|
|
.map(function toAbsolute(filename) {
|
|
return path.join(basePath, filename);
|
|
})
|
|
.filter(function directoriesOnly(absolutePath) {
|
|
return fs.existsSync(absolutePath) && fs.statSync(absolutePath).isDirectory();
|
|
})
|
|
.filter(function notInRootPath(absolutePath) {
|
|
return (pathToRoot.indexOf(absolutePath) < 0);
|
|
})
|
|
.filter(testNotPackage)
|
|
.forEach(function enqueue(absolutePath) {
|
|
queue.push(absolutePath);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Test whether the given directory is above but not equal to any of the project root directories.
|
|
* @param {string} absolutePath An absolute path
|
|
* @returns {boolean} True where a package.json or bower.json exists, else False
|
|
*/
|
|
function testWithinLimit(absolutePath) {
|
|
var relative = path.relative(limit, absolutePath);
|
|
return !!relative && (relative.slice(0, 2) !== '..');
|
|
}
|
|
|
|
/**
|
|
* Print verbose debug info where <code>options.debug</code> is in effect.
|
|
* @param {string} result Final text to append to the message
|
|
*/
|
|
function flushMessages(result) {
|
|
if (options.debug) {
|
|
var text = ['\n' + PACKAGE_NAME + ': ' + uri]
|
|
.concat(messages)
|
|
.concat(result)
|
|
.join('\n ');
|
|
console.log(text);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test whether the given directory is the root of its own package.
|
|
* @param {string} absolutePath An absolute path
|
|
* @returns {boolean} True where a package.json or bower.json exists, else False
|
|
*/
|
|
function testNotPackage(absolutePath) {
|
|
return ['package.json', 'bower.json'].every(function fileFound(file) {
|
|
return !fs.existsSync(path.resolve(absolutePath, file));
|
|
});
|
|
}
|
|
}
|
|
|
|
module.exports = findFile;
|