v2 implementation

Author: isaacs

index.js

@@ -1,206 +1,45 @@
-'use strict'
-
-const path = require('path')
-const fs = require('graceful-fs')
-const { promisify } = require('util')
-const gentleFs = require('gentle-fs')
-const linkIfExists = promisify(gentleFs.linkIfExists)
-const gentleFsBinLink = promisify(gentleFs.binLink)
-const open = promisify(fs.open)
-const close = promisify(fs.close)
-const read = promisify(fs.read)
-const chmod = promisify(fs.chmod)
-const readFile = promisify(fs.readFile)
-const writeFileAtomic = promisify(require('write-file-atomic'))
-const normalize = require('npm-normalize-package-bin')
-
-module.exports = binLinks
-
-// don't blow up trying to log stuff if we weren't given a logger
-const log = {
-  clearProgress () {},
-  info () {},
-  showProgress () {},
-  silly () {},
-  verbose () {}
-}
-
-function binLinks (pkg, folder, global, opts) {
-  pkg = normalize(pkg)
-  folder = path.resolve(folder)
-
-  // if it's global, and folder is in {prefix}/node_modules,
-  // then bins are in {prefix}/bin
-  // otherwise, then bins are in folder/../.bin
-  var parent = pkg.name && pkg.name[0] === '@' ? path.dirname(path.dirname(folder)) : path.dirname(folder)
-  var gnm = global && opts.globalDir
-  var gtop = parent === gnm
-
-  // use the no-op logger if one is not provided
-  opts = {
-    log,
-    ...opts
-  }
-
-  opts.log.info('linkStuff', opts.pkgId)
-  opts.log.silly('linkStuff', opts.pkgId, 'has', parent, 'as its parent node_modules')
-  if (global) opts.log.silly('linkStuff', opts.pkgId, 'is part of a global install')
-  if (gnm) opts.log.silly('linkStuff', opts.pkgId, 'is installed into a global node_modules')
-  if (gtop) opts.log.silly('linkStuff', opts.pkgId, 'is installed into the top-level global node_modules')
+const {basename, dirname } = require('path')
+const isWindows = require('./lib/is-windows.js')
+
+const linkBins = require('./lib/link-bins.js')
+const linkMans = require('./lib/link-mans.js')
+
+const binLinks = opts => {
+  const { path, pkg, force, global, top } = opts
+  // global top pkgs on windows get bins installed in {prefix}, and no mans
+  //
+  // unix global top pkgs get their bins installed in {prefix}/bin,
+  // and mans in {prefix}/share/man
+  //
+  // non-top pkgs get their bins installed in {prefix}/node_modules/.bin,
+  // and do not install mans
+  //
+  // non-global top pkgs don't have any bins or mans linked.
+  if (top && !global)
+    return Promise.resolve()
+
+  // now we know it's global and/or not top, so the path has to be
+  // {prefix}/node_modules/{name}.  Can't rely on pkg.name, because
+  // it might be installed as an alias.
+  const scopeOrNm = dirname(path)
+  const nm = basename(scopeOrNm) === 'node_modules' ? scopeOrNm
+    : dirname(scopeOrNm)
+  const prefix = dirname(nm)
+
+  const binTarget = !top ? nm + '/.bin'
+    : isWindows ? prefix
+    : dirname(prefix) + '/bin'
+
+  const manTarget = !top || isWindows ? null
+    : dirname(prefix) + '/share/man'
 
   return Promise.all([
-    linkBins(pkg, folder, parent, gtop, opts),
-    linkMans(pkg, folder, parent, gtop, opts)
+    // allow clobbering within the local node_modules/.bin folder.
+    // only global bins are protected in this way, or else it is
+    // yet another vector for excessive dependency conflicts.
+    linkBins({path, binTarget, pkg, force: force || !top}),
+    linkMans({path, manTarget, pkg, force}),
   ])
 }
 
-function isHashbangFile (file) {
-  /* istanbul ignore next */
-  const FALSE = () => false
-  return open(file, 'r').then(fileHandle => {
-    const buf = Buffer.alloc(2)
-    return read(fileHandle, buf, 0, 2, 0).then((...args) => {
-      if (!hasHashbang(buf)) {
-        return []
-      }
-      const line = Buffer.alloc(2048)
-      return read(fileHandle, line, 0, 2048, 0)
-        .then((bytes) => close(fileHandle).then(() => bytes && hasCR(line)))
-    })
-    // don't leak a fd if the read fails
-      .catch(/* istanbul ignore next */ () => close(fileHandle).then(FALSE, FALSE))
-  }).catch(FALSE)
-}
-
-function hasHashbang (buf) {
-  const str = buf.toString()
-  return str.slice(0, 2) === '#!'
-}
-
-function hasCR (buf) {
-  return /^#![^\n]+\r\n/.test(buf)
-}
-
-function dos2Unix (file) {
-  return readFile(file, 'utf8').then(content => {
-    return writeFileAtomic(file, content.replace(/^(#![^\n]+)\r\n/, '$1\n'))
-  })
-}
-
-function getLinkOpts (opts, gently) {
-  return Object.assign({}, opts, { gently: gently })
-}
-
-function linkBins (pkg, folder, parent, gtop, opts) {
-  if (!pkg.bin || (!gtop && path.basename(parent) !== 'node_modules')) {
-    return
-  }
-  var linkOpts = getLinkOpts(opts, gtop && folder)
-  var execMode = parseInt('0777', 8) & (~opts.umask)
-  var binRoot = gtop ? opts.globalBin
-    : path.resolve(parent, '.bin')
-  opts.log.verbose('linkBins', [pkg.bin, binRoot, gtop])
-
-  return Promise.all(Object.keys(pkg.bin).map(bin => {
-    var dest = path.resolve(binRoot, bin)
-    var src = path.resolve(folder, pkg.bin[bin])
-
-    /* istanbul ignore if - that unpossible */
-    if (src.indexOf(folder) !== 0) {
-      return Promise.reject(new Error('invalid bin entry for package ' +
-        pkg._id + '. key=' + bin + ', value=' + pkg.bin[bin]))
-    }
-
-    return linkBin(src, dest, linkOpts).then(() => {
-      // bins should always be executable.
-      // XXX skip chmod on windows?
-      return chmod(src, execMode)
-    }).then(() => {
-      return isHashbangFile(src)
-    }).then(isHashbang => {
-      if (!isHashbang) return
-      opts.log.silly('linkBins', 'Converting line endings of hashbang file:', src)
-      return dos2Unix(src)
-    }).then(() => {
-      if (!gtop) return
-      var dest = path.resolve(binRoot, bin)
-      var out = opts.parseable
-        ? dest + '::' + src + ':BINFILE'
-        : dest + ' -> ' + src
-
-      if (!opts.json && !opts.parseable) {
-        opts.log.clearProgress()
-        console.log(out)
-        opts.log.showProgress()
-      }
-    }).catch(err => {
-      /* istanbul ignore next */
-      if (err.code === 'ENOENT' && opts.ignoreScripts) return
-      throw err
-    })
-  }))
-}
-
-function linkBin (from, to, opts) {
-  // do not clobber global bins
-  if (opts.globalBin && to.indexOf(opts.globalBin) === 0) {
-    opts.clobberLinkGently = true
-  }
-  return gentleFsBinLink(from, to, opts)
-}
-
-function linkMans (pkg, folder, parent, gtop, opts) {
-  if (!pkg.man || !gtop || process.platform === 'win32') return
-
-  var manRoot = path.resolve(opts.prefix, 'share', 'man')
-  opts.log.verbose('linkMans', 'man files are', pkg.man, 'in', manRoot)
-
-  // make sure that the mans are unique.
-  // otherwise, if there are dupes, it'll fail with EEXIST
-  var set = pkg.man.reduce(function (acc, man) {
-    if (typeof man !== 'string') {
-      return acc
-    }
-    const cleanMan = path.join('/', man).replace(/\\|:/g, '/').substr(1)
-    acc[path.basename(man)] = cleanMan
-    return acc
-  }, {})
-  var manpages = pkg.man.filter(function (man) {
-    if (typeof man !== 'string') {
-      return false
-    }
-    const cleanMan = path.join('/', man).replace(/\\|:/g, '/').substr(1)
-    return set[path.basename(man)] === cleanMan
-  })
-
-  return Promise.all(manpages.map(man => {
-    opts.log.silly('linkMans', 'preparing to link', man)
-    var parseMan = man.match(/(.*\.([0-9]+)(\.gz)?)$/)
-    if (!parseMan) {
-      return Promise.reject(new Error(
-        man + ' is not a valid name for a man file.  ' +
-        'Man files must end with a number, ' +
-        'and optionally a .gz suffix if they are compressed.'
-      ))
-    }
-
-    var stem = parseMan[1]
-    var sxn = parseMan[2]
-    var bn = path.basename(stem)
-    var manSrc = path.resolve(folder, man)
-    /* istanbul ignore if - that unpossible */
-    if (manSrc.indexOf(folder) !== 0) {
-      return Promise.reject(new Error('invalid man entry for package ' +
-        pkg._id + '. man=' + manSrc))
-    }
-
-    var manDest = path.join(manRoot, 'man' + sxn, bn)
-
-    // man pages should always be clobbering gently, because they are
-    // only installed for top-level global packages, so never destroy
-    // a link if it doesn't point into the folder we're linking
-    opts.clobberLinkGently = true
-
-    return linkIfExists(manSrc, manDest, getLinkOpts(opts, gtop && folder))
-  }))
-}
+module.exports = binLinks

lib/fix-bin.js

@@ -0,0 +1,44 @@
+// make sure that bins are executable, and that they don't have
+// windows line-endings on the hashbang line.
+const fs = require('fs')
+const { promisify } = require('util')
+
+const execMode = 0o777 & (~process.umask())
+
+const writeFileAtomic = promisify(require('write-file-atomic'))
+const open = promisify(fs.open)
+const close = promisify(fs.close)
+const read = promisify(fs.read)
+const chmod = promisify(fs.chmod)
+const readFile = promisify(fs.readFile)
+
+const isWindowsHashBang = buf =>
+  buf[0] === '#'.charCodeAt(0) &&
+  buf[1] === '!'.charCodeAt(0) &&
+  /^#![^\n]+\r\n/.test(buf.toString())
+
+const isWindowsHashbangFile = file => {
+  const FALSE = () => false
+  return open(file, 'r').then(fd => {
+    const buf = Buffer.alloc(2048)
+    return read(fd, buf, 0, 2048, 0)
+      .then(
+        () => {
+          const isWHB = isWindowsHashBang(buf)
+          return close(fd).then(() => isWHB, () => isWHB)
+        },
+        // don't leak FD if read() fails
+        () => close(fd).then(FALSE, FALSE)
+      )
+  }, FALSE)
+}
+
+const dos2Unix = file =>
+  readFile(file, 'utf8').then(content =>
+    writeFileAtomic(file, content.replace(/^(#![^\n]+)\r\n/, '$1\n')))
+
+const fixBin = file => chmod(file, execMode)
+  .then(() => isWindowsHashbangFile(file))
+  .then(isWHB => isWHB ? dos2Unix(file) : null)
+
+module.exports = fixBin

lib/is-windows.js

@@ -0,0 +1,2 @@
+const platform = process.env.__TESTING_BIN_LINKS_PLATFORM__ || process.platform
+module.exports = platform === 'win32'

lib/link-bin.js

@@ -0,0 +1,9 @@
+const linkGently = require('./link-gently.js')
+const fixBin = require('./fix-bin.js')
+
+// linking bins is simple.  just symlink, and if we linked it, fix the bin up
+const linkBin = ({path, to, from, absFrom, force}) =>
+  linkGently({path, to, from, absFrom, force})
+    .then(linked => linked && fixBin(absFrom))
+
+module.exports = linkBin

lib/link-bins.js

@@ -0,0 +1,20 @@
+const isWindows = require('./is-windows.js')
+const { dirname, resolve, relative } = require('path')
+const linkBin = isWindows ? require('./shim-bin.js') : require('./link-bin.js')
+const normalize = require('npm-normalize-package-bin')
+
+const linkBins = ({path, binTarget, pkg, force}) => {
+  pkg = normalize(pkg)
+  if (!pkg.bin)
+    return Promise.resolve([])
+  const promises = []
+  for (const [key, val] of Object.entries(pkg.bin)) {
+    const to = resolve(binTarget, key)
+    const absFrom = resolve(path, val)
+    const from = relative(dirname(to), absFrom)
+    promises.push(linkBin({path, from, to, absFrom, force}))
+  }
+  return Promise.all(promises)
+}
+
+module.exports = linkBins

lib/link-gently.js

@@ -0,0 +1,57 @@
+// if the thing isn't there, skip it
+// if there's a non-symlink there already, eexist
+// if there's a symlink already, pointing somewhere else, eexist
+// if there's a symlink already, pointing into our pkg, remove it first
+// then create the symlink
+
+const { promisify } = require('util')
+const { resolve, dirname } = require('path')
+const mkdirp = require('mkdirp-infer-owner')
+const fs = require('fs')
+const symlink = promisify(fs.symlink)
+const readlink = promisify(fs.readlink)
+const lstat = promisify(fs.lstat)
+const throwNonEnoent = er => { if (er.code !== 'ENOENT') throw er }
+
+// disable glob in our rimraf calls
+const rimraf = promisify(require('rimraf'))
+const rm = path => rimraf(path, { glob: false })
+
+const SKIP = Symbol('skip - missing or already installed')
+
+const linkGently = ({path, to, from, absFrom, force}) => {
+  // if the script or manpage isn't there, just ignore it.
+  // this arguably *should* be an install error of some sort,
+  // or at least a warning, but npm has always behaved this
+  // way in the past, so it'd be a breaking change
+  return Promise.all([
+    lstat(absFrom).catch(throwNonEnoent),
+    lstat(to).catch(throwNonEnoent),
+  ]).then(([stFrom, stTo]) => {
+    // not present in package, skip it
+    if (!stFrom)
+      return SKIP
+
+    // exists! maybe clobber if we can
+    if (stTo) {
+      if (!stTo.isSymbolicLink())
+        return force ? rm(to) : Promise.resolve()
+
+      return readlink(to).then(target => {
+        if (target === from)
+          return SKIP // skip it, already set up like we want it.
+
+        target = resolve(dirname(to), target)
+        if (target.indexOf(path) === 0 || force)
+          return rm(to)
+      })
+    } else {
+      // doesn't exist, dir might not either
+      return mkdirp(dirname(to))
+    }
+  })
+  // this will fail if we didn't remove it
+  .then(skip => skip !== SKIP && symlink(from, to, 'file').then(() => true))
+}
+
+module.exports = linkGently