"Fossies" - the Fresh Open Source Software Archive

Member "Atom/resources/app/apm/node_modules/fs.realpath/old.js" (11 Apr 2017, 8542 Bytes) of package /windows/misc/atom-windows.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Javascript source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 // Copyright Joyent, Inc. and other Node contributors.
    2 //
    3 // Permission is hereby granted, free of charge, to any person obtaining a
    4 // copy of this software and associated documentation files (the
    5 // "Software"), to deal in the Software without restriction, including
    6 // without limitation the rights to use, copy, modify, merge, publish,
    7 // distribute, sublicense, and/or sell copies of the Software, and to permit
    8 // persons to whom the Software is furnished to do so, subject to the
    9 // following conditions:
   10 //
   11 // The above copyright notice and this permission notice shall be included
   12 // in all copies or substantial portions of the Software.
   13 //
   14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   15 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   16 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
   17 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
   18 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
   19 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
   20 // USE OR OTHER DEALINGS IN THE SOFTWARE.
   21 
   22 var pathModule = require('path');
   23 var isWindows = process.platform === 'win32';
   24 var fs = require('fs');
   25 
   26 // JavaScript implementation of realpath, ported from node pre-v6
   27 
   28 var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
   29 
   30 function rethrow() {
   31   // Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and
   32   // is fairly slow to generate.
   33   var callback;
   34   if (DEBUG) {
   35     var backtrace = new Error;
   36     callback = debugCallback;
   37   } else
   38     callback = missingCallback;
   39 
   40   return callback;
   41 
   42   function debugCallback(err) {
   43     if (err) {
   44       backtrace.message = err.message;
   45       err = backtrace;
   46       missingCallback(err);
   47     }
   48   }
   49 
   50   function missingCallback(err) {
   51     if (err) {
   52       if (process.throwDeprecation)
   53         throw err;  // Forgot a callback but don't know where? Use NODE_DEBUG=fs
   54       else if (!process.noDeprecation) {
   55         var msg = 'fs: missing callback ' + (err.stack || err.message);
   56         if (process.traceDeprecation)
   57           console.trace(msg);
   58         else
   59           console.error(msg);
   60       }
   61     }
   62   }
   63 }
   64 
   65 function maybeCallback(cb) {
   66   return typeof cb === 'function' ? cb : rethrow();
   67 }
   68 
   69 var normalize = pathModule.normalize;
   70 
   71 // Regexp that finds the next partion of a (partial) path
   72 // result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
   73 if (isWindows) {
   74   var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
   75 } else {
   76   var nextPartRe = /(.*?)(?:[\/]+|$)/g;
   77 }
   78 
   79 // Regex to find the device root, including trailing slash. E.g. 'c:\\'.
   80 if (isWindows) {
   81   var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
   82 } else {
   83   var splitRootRe = /^[\/]*/;
   84 }
   85 
   86 exports.realpathSync = function realpathSync(p, cache) {
   87   // make p is absolute
   88   p = pathModule.resolve(p);
   89 
   90   if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
   91     return cache[p];
   92   }
   93 
   94   var original = p,
   95       seenLinks = {},
   96       knownHard = {};
   97 
   98   // current character position in p
   99   var pos;
  100   // the partial path so far, including a trailing slash if any
  101   var current;
  102   // the partial path without a trailing slash (except when pointing at a root)
  103   var base;
  104   // the partial path scanned in the previous round, with slash
  105   var previous;
  106 
  107   start();
  108 
  109   function start() {
  110     // Skip over roots
  111     var m = splitRootRe.exec(p);
  112     pos = m[0].length;
  113     current = m[0];
  114     base = m[0];
  115     previous = '';
  116 
  117     // On windows, check that the root exists. On unix there is no need.
  118     if (isWindows && !knownHard[base]) {
  119       fs.lstatSync(base);
  120       knownHard[base] = true;
  121     }
  122   }
  123 
  124   // walk down the path, swapping out linked pathparts for their real
  125   // values
  126   // NB: p.length changes.
  127   while (pos < p.length) {
  128     // find the next part
  129     nextPartRe.lastIndex = pos;
  130     var result = nextPartRe.exec(p);
  131     previous = current;
  132     current += result[0];
  133     base = previous + result[1];
  134     pos = nextPartRe.lastIndex;
  135 
  136     // continue if not a symlink
  137     if (knownHard[base] || (cache && cache[base] === base)) {
  138       continue;
  139     }
  140 
  141     var resolvedLink;
  142     if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
  143       // some known symbolic link.  no need to stat again.
  144       resolvedLink = cache[base];
  145     } else {
  146       var stat = fs.lstatSync(base);
  147       if (!stat.isSymbolicLink()) {
  148         knownHard[base] = true;
  149         if (cache) cache[base] = base;
  150         continue;
  151       }
  152 
  153       // read the link if it wasn't read before
  154       // dev/ino always return 0 on windows, so skip the check.
  155       var linkTarget = null;
  156       if (!isWindows) {
  157         var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
  158         if (seenLinks.hasOwnProperty(id)) {
  159           linkTarget = seenLinks[id];
  160         }
  161       }
  162       if (linkTarget === null) {
  163         fs.statSync(base);
  164         linkTarget = fs.readlinkSync(base);
  165       }
  166       resolvedLink = pathModule.resolve(previous, linkTarget);
  167       // track this, if given a cache.
  168       if (cache) cache[base] = resolvedLink;
  169       if (!isWindows) seenLinks[id] = linkTarget;
  170     }
  171 
  172     // resolve the link, then start over
  173     p = pathModule.resolve(resolvedLink, p.slice(pos));
  174     start();
  175   }
  176 
  177   if (cache) cache[original] = p;
  178 
  179   return p;
  180 };
  181 
  182 
  183 exports.realpath = function realpath(p, cache, cb) {
  184   if (typeof cb !== 'function') {
  185     cb = maybeCallback(cache);
  186     cache = null;
  187   }
  188 
  189   // make p is absolute
  190   p = pathModule.resolve(p);
  191 
  192   if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
  193     return process.nextTick(cb.bind(null, null, cache[p]));
  194   }
  195 
  196   var original = p,
  197       seenLinks = {},
  198       knownHard = {};
  199 
  200   // current character position in p
  201   var pos;
  202   // the partial path so far, including a trailing slash if any
  203   var current;
  204   // the partial path without a trailing slash (except when pointing at a root)
  205   var base;
  206   // the partial path scanned in the previous round, with slash
  207   var previous;
  208 
  209   start();
  210 
  211   function start() {
  212     // Skip over roots
  213     var m = splitRootRe.exec(p);
  214     pos = m[0].length;
  215     current = m[0];
  216     base = m[0];
  217     previous = '';
  218 
  219     // On windows, check that the root exists. On unix there is no need.
  220     if (isWindows && !knownHard[base]) {
  221       fs.lstat(base, function(err) {
  222         if (err) return cb(err);
  223         knownHard[base] = true;
  224         LOOP();
  225       });
  226     } else {
  227       process.nextTick(LOOP);
  228     }
  229   }
  230 
  231   // walk down the path, swapping out linked pathparts for their real
  232   // values
  233   function LOOP() {
  234     // stop if scanned past end of path
  235     if (pos >= p.length) {
  236       if (cache) cache[original] = p;
  237       return cb(null, p);
  238     }
  239 
  240     // find the next part
  241     nextPartRe.lastIndex = pos;
  242     var result = nextPartRe.exec(p);
  243     previous = current;
  244     current += result[0];
  245     base = previous + result[1];
  246     pos = nextPartRe.lastIndex;
  247 
  248     // continue if not a symlink
  249     if (knownHard[base] || (cache && cache[base] === base)) {
  250       return process.nextTick(LOOP);
  251     }
  252 
  253     if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
  254       // known symbolic link.  no need to stat again.
  255       return gotResolvedLink(cache[base]);
  256     }
  257 
  258     return fs.lstat(base, gotStat);
  259   }
  260 
  261   function gotStat(err, stat) {
  262     if (err) return cb(err);
  263 
  264     // if not a symlink, skip to the next path part
  265     if (!stat.isSymbolicLink()) {
  266       knownHard[base] = true;
  267       if (cache) cache[base] = base;
  268       return process.nextTick(LOOP);
  269     }
  270 
  271     // stat & read the link if not read before
  272     // call gotTarget as soon as the link target is known
  273     // dev/ino always return 0 on windows, so skip the check.
  274     if (!isWindows) {
  275       var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
  276       if (seenLinks.hasOwnProperty(id)) {
  277         return gotTarget(null, seenLinks[id], base);
  278       }
  279     }
  280     fs.stat(base, function(err) {
  281       if (err) return cb(err);
  282 
  283       fs.readlink(base, function(err, target) {
  284         if (!isWindows) seenLinks[id] = target;
  285         gotTarget(err, target);
  286       });
  287     });
  288   }
  289 
  290   function gotTarget(err, target, base) {
  291     if (err) return cb(err);
  292 
  293     var resolvedLink = pathModule.resolve(previous, target);
  294     if (cache) cache[base] = resolvedLink;
  295     gotResolvedLink(resolvedLink);
  296   }
  297 
  298   function gotResolvedLink(resolvedLink) {
  299     // resolve the link, then start over
  300     p = pathModule.resolve(resolvedLink, p.slice(pos));
  301     start();
  302   }
  303 };