climb-lookup/lib/index.js

a lookup climbing recursively file like a require.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @module climb-lookup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */

exports.getPaths = getPaths;
exports.lookup = lookup;
exports.lookupSync = lookupSync;

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _objectAssign = require('object-assign');

var _objectAssign2 = _interopRequireDefault(_objectAssign);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
* Get recursively climbing paths.
*
* @function getPaths
* @param {string} filePath - base path
* @return {array} paths - an abosolute file paths from filePath to root
*/
function getPaths(filePath) {
  var paths = [];

  var fileName = _path2.default.basename(filePath);
  var current = _path2.default.resolve(filePath);
  while (current.split(_path2.default.sep).length > 2) {
    // unless `/${file}`
    paths.push(current);

    current = _path2.default.join(_path2.default.join(current, '..', '..'), fileName);
  }
  paths.push(current);

  return paths;
}

/**
* lookup climbing recursively file like a `require`.
*
* @function lookup
* @param {string} file - lookup file name
* @param {object} [options] -
* @param {object} [options.cwd=process.cwd()] - begin path
* @param {object} [options.mode=null] - pass to fs.accessSync as 2nd argument
* @param {lookedupAbsolutePath} callback -
*/
function lookup(file) {
  for (var _len = arguments.length, params = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    params[_key - 1] = arguments[_key];
  }

  var _ref = params.length === 1 ? [{}, params[0]] : params;

  var _ref2 = _slicedToArray(_ref, 2);

  var options = _ref2[0];
  var callback = _ref2[1];

  var opts = (0, _objectAssign2.default)({
    cwd: process.cwd()
  }, options);

  /**
   * Callback for looked up absolute file path.
   *
   * @callback lookedupAbsolutePath
   * @param {error} error - no paths found
   * @param {string} lookedupPath - a found absolute file path
   */
  var paths = getPaths(_path2.default.resolve(opts.cwd, file));
  paths.reduceRight(function (next, filePath) {
    return function () {
      _fs2.default.access(filePath, opts.mode, function (error) {
        if (error) {
          return next();
        }

        return callback(null, filePath);
      });
    };
  }, function () {
    callback(Error('ENOENT: no such paths, access \'' + paths.join("', '") + '\''));
  })();
}

/**
* Synchronous version of lookup
*
* @function lookupSync
* @param {string} file - lookup file name
* @param {object} [options]
* @param {object} [options.cwd=process.cwd()] - begin path
* @param {object} [options.mode=null] - pass to fs.accessSync as 2nd argument
* @return {string} lookedupPath - a found absolute file path
* @throws if no such paths
*/
function lookupSync(file) {
  var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

  var opts = (0, _objectAssign2.default)({
    cwd: process.cwd()
  }, options);

  var paths = getPaths(_path2.default.resolve(opts.cwd, file));
  for (var i = 0; i < paths.length; i++) {
    try {
      _fs2.default.accessSync(paths[i], opts.mode);
      return paths[i];
    } catch (error) {
      // ignore
    }
  }

  throw new Error('ENOENT: no such paths, access \'' + paths.join("', '") + '\'');
}