smart multi bundles

index.js

@@ -32,6 +32,13 @@ function Browserify (files) {
     this._expose = {};
     this._mapped = {};
     this._transforms = [];
+
+    var self = this;
+    this._ready = false;
+
+    this.once('_ready', function() {
+        self._ready = true;
+    });
 
     [].concat(files).filter(Boolean).forEach(this.add.bind(this));
 }
@@ -43,6 +50,27 @@ Browserify.prototype.add = function (file) {
 
 Browserify.prototype.require = function (id, opts) {
     var self = this;
+
+    if (id instanceof Browserify) {
+        self._pending ++;
+
+        var go = function() {
+            var d = mdeps(id.files);
+            d.pipe(through(function(row) {
+                self._external[row.id] = true;
+            })).once('end', function() {
+                if (--self._pending === 0) self.emit('_ready');
+            });
+        };
+
+        // need to capture all deps so we know what is already avail
+        if (!id._ready) {
+            return id.once('_ready', go);
+        }
+
+        return go();
+    }
+
     if (opts === undefined) opts = { expose: id };
 
     self._pending ++;
@@ -178,6 +206,10 @@ Browserify.prototype.deps = function (opts) {
 
         if (self.exports[row.id]) row.exposed = self.exports[row.id];
 
+        if (self.expose_all) {
+            row.exposed = hash(row.id);
+        }
+
         // skip adding this file if it is external
         if (self._external[row.id]) {
             return;
@@ -211,6 +243,9 @@ Browserify.prototype.pack = function (debug) {
         if (row.exposed) {
             ix = row.exposed;
         }
+        else if (self.expose_all) {
+            ix = hash(row.id);
+        }
         else {
             ix = ids[row.id] !== undefined ? ids[row.id] : idIndex++;
         }
@@ -230,6 +265,12 @@ Browserify.prototype.pack = function (debug) {
                 return acc;
             }
 
+            // if we expose all, just have all hashes available
+            if (self.expose_all) {
+                acc[key] = hash(file);
+                return acc;
+            }
+
             if (self._expose[file]) {
                 acc[key] = self._expose[file];
                 return acc;

package.json

@@ -1,6 +1,6 @@
 {
     "name": "browserify",
-    "version": "2.6.0",
+    "version": "2.6.0-dz0",
     "description": "browser-side require() the node way",
     "main": "index.js",
     "bin": {
@@ -35,7 +35,6 @@
     "devDependencies": {
         "tap": "~0.4.0",
         "mkdirp": "~0.3.3",
-
         "backbone": "~0.9.2",
         "dnode": "~1.0.3",
         "seq": "0.3.3",

test/multi_bundle.js

@@ -42,3 +42,45 @@ test('multi bundle', function (t) {
         });
     });
 });
+
+test('multi bundle', function (t) {
+    t.plan(8);
+
+    var core = browserify();
+    core.expose_all = true;
+    core.require(__dirname + '/multi_bundle/a.js', { expose: true });
+
+    var app = browserify([__dirname + '/multi_bundle/c.js']);
+    // inform this bundle that b exists in another bundle
+    app.require(core);
+
+    core.bundle(function (err, src) {
+        var c = {
+            console: console,
+            t : t,
+            baton: {
+                times: 0
+            }
+        };
+
+        // loading core will cause no require to run
+        vm.runInNewContext(src, c);
+        t.equal(c.baton.times, 0);
+
+        // loading the app will require
+        app.bundle(function (err, src) {
+            vm.runInNewContext(src, c);
+
+            // b required for the first time
+            t.equal(c.baton.times, 1);
+
+            // running the file again
+            // because it is using the same b, no reloading
+            vm.runInNewContext(src, c);
+
+            // b should not have been required again
+            // because it was part of the core bundle
+            t.equal(c.baton.times, 1);
+        });
+    });
+});

test/multi_bundle/a.js

@@ -1,2 +1,4 @@
 var b = require('./b');
 t.equal(b, 'foo');
+
+module.exports = 'bar';

test/multi_bundle/c.js

@@ -0,0 +1,4 @@
+var b = require('./b');
+var a = require('./a');
+t.equal(b, 'foo');
+t.equal(a, 'bar');