1 files changed, 72 insertions, 45 deletions
diff --git a/deps/npm/lib/install/inflate-shrinkwrap.js b/deps/npm/lib/install/inflate-shrinkwrap.js
index 1853f2c068..ab1bdd1f19 100644
--- a/deps/npm/lib/install/inflate-shrinkwrap.js
+++ b/deps/npm/lib/install/inflate-shrinkwrap.js
@@ -1,9 +1,9 @@
 'use strict'
-var url = require('url')
 var asyncMap = require('slide').asyncMap
 var validate = require('aproba')
 var iferr = require('iferr')
-var realizePackageSpecifier = require('realize-package-specifier')
+var realizeShrinkwrapSpecifier = require('./realize-shrinkwrap-specifier.js')
+var isRegistrySpecifier = require('./is-registry-specifier.js')
 var fetchPackageMetadata = require('../fetch-package-metadata.js')
 var annotateMetadata = require('../fetch-package-metadata.js').annotateMetadata
 var addShrinkwrap = require('../fetch-package-metadata.js').addShrinkwrap
@@ -14,53 +14,80 @@ var createChild = require('./node.js').create
 var moduleName = require('../utils/module-name.js')
 var childPath = require('../utils/child-path.js')
 
-var inflateShrinkwrap = module.exports = function (tree, swdeps, finishInflating) {
-  validate('OOF', arguments)
+module.exports = function (tree, swdeps, finishInflating) {
   if (!npm.config.get('shrinkwrap')) return finishInflating()
+  return inflateShrinkwrap(tree.path, tree, swdeps, finishInflating)
+}
+
+function inflateShrinkwrap (topPath, tree, swdeps, finishInflating) {
+  validate('SOOF', arguments)
   var onDisk = {}
   tree.children.forEach(function (child) { onDisk[moduleName(child)] = child })
   tree.children = []
-  asyncMap(Object.keys(swdeps), function (name, next) {
-    var sw = swdeps[name]
-    var spec = sw.resolved
-             ? name + '@' + sw.resolved
-             : (sw.from && url.parse(sw.from).protocol)
-             ? name + '@' + sw.from
-             : name + '@' + sw.version
-    var child = onDisk[name]
-    if (child && (child.fromShrinkwrap ||
-                  (sw.resolved && child.package._resolved === sw.resolved) ||
-                  (sw.from && url.parse(sw.from).protocol && child.package._from === sw.from) ||
-                  child.package.version === sw.version)) {
-      if (!child.fromShrinkwrap) child.fromShrinkwrap = spec
-      tree.children.push(child)
+  var dev = npm.config.get('dev') || (!/^prod(uction)?$/.test(npm.config.get('only')) && !npm.config.get('production')) || /^dev(elopment)?$/.test(npm.config.get('only'))
+  var prod = !/^dev(elopment)?$/.test(npm.config.get('only'))
+  return asyncMap(Object.keys(swdeps), doRealizeAndInflate, finishInflating)
+
+  function doRealizeAndInflate (name, next) {
+    return realizeShrinkwrapSpecifier(name, swdeps[name], topPath, iferr(next, andInflate(name, next)))
+  }
 
-      return realizePackageSpecifier(spec, tree.path, iferr(next, function (requested) {
-        annotateMetadata(child.package, requested, spec, tree.path)
-        return inflateShrinkwrap(child, sw.dependencies || {}, next)
-      }))
+  function andInflate (name, next) {
+    return function (requested) {
+      var sw = swdeps[name]
+      var dependencies = sw.dependencies || {}
+      if ((!prod && !sw.dev) || (!dev && sw.dev)) return next()
+      var child = onDisk[name]
+      if (childIsEquivalent(sw, requested, child)) {
+        if (!child.fromShrinkwrap) child.fromShrinkwrap = requested.raw
+        tree.children.push(child)
+        annotateMetadata(child.package, requested, requested.raw, topPath)
+        return inflateShrinkwrap(topPath, child, dependencies || {}, next)
+      } else {
+        var from = sw.from || requested.raw
+        return fetchPackageMetadata(requested, topPath, iferr(next, andAddShrinkwrap(from, dependencies, next)))
+      }
     }
-    fetchPackageMetadata(spec, tree.path, iferr(next, function (pkg) {
-      pkg._from = sw.from || spec
-      addShrinkwrap(pkg, iferr(next, function () {
-        addBundled(pkg, iferr(next, function () {
-          var child = createChild({
-            package: pkg,
-            loaded: false,
-            parent: tree,
-            fromShrinkwrap: spec,
-            path: childPath(tree.path, pkg),
-            realpath: childPath(tree.realpath, pkg),
-            children: pkg._bundled || []
-          })
-          tree.children.push(child)
-          if (pkg._bundled) {
-            delete pkg._bundled
-            inflateBundled(child, child.children)
-          }
-          inflateShrinkwrap(child, sw.dependencies || {}, next)
-        }))
-      }))
-    }))
-  }, finishInflating)
+  }
+
+  function andAddShrinkwrap (from, dependencies, next) {
+    return function (pkg) {
+      pkg._from = from
+      addShrinkwrap(pkg, iferr(next, andAddBundled(pkg, dependencies, next)))
+    }
+  }
+
+  function andAddBundled (pkg, dependencies, next) {
+    return function () {
+      return addBundled(pkg, iferr(next, andAddChild(pkg, dependencies, next)))
+    }
+  }
+
+  function andAddChild (pkg, dependencies, next) {
+    return function () {
+      var child = createChild({
+        package: pkg,
+        loaded: false,
+        parent: tree,
+        fromShrinkwrap: pkg._from,
+        path: childPath(tree.path, pkg),
+        realpath: childPath(tree.realpath, pkg),
+        children: pkg._bundled || []
+      })
+      tree.children.push(child)
+      if (pkg._bundled) {
+        delete pkg._bundled
+        inflateBundled(child, child.children)
+      }
+      inflateShrinkwrap(topPath, child, dependencies || {}, next)
+    }
+  }
+}
+
+function childIsEquivalent (sw, requested, child) {
+  if (!child) return false
+  if (child.fromShrinkwrap) return true
+  if (sw.resolved) return child.package._resolved === sw.resolved
+  if (!isRegistrySpecifier(requested) && sw.from) return child.package._from === sw.from
+  return child.package.version === sw.version
 }