all tests running

6 files changed, 207 insertions, 10 deletions

diff --git a/lib/browserify/appendix.js b/lib/browserify/appendix.js
new file mode 100644
index 0000000..02fd9c1
--- /dev/null
+++ b/lib/browserify/appendix.js
@@ -0,0 +1,44 @@
+/**

+ * This code gets injected at the end of the browserify bundle via b.append().

+ */

+

+if (typeof window.browserifyRequire !== "undefined") {

+    throw new Error("Naming collision detected: window.browserifyRequire seems to be occupied.");

+}

+

+// Saves the browserifyRequire under a new name. Necessary to call the original browserifyRequire within

+// a module where the variable name "require" is overridden by the module's internal require.

+window.browserifyRequire = require;

+

+/**

+ * Provides a special require-proxy. Every module calls window.browserifyRequire.getProxy(require, __filename) at the

+ * beginning and overrides its own require with this proxy.

+ *

+ * This is necessary to call rewire() with the original __filename. Thus you can use rewire() like require().

+ *

+ * @param {!Function} internalRequire the module's own require

+ * @param {String} filename the __filename of the module

+ * @return {Function} requireProxy

+ */

+window.browserifyRequire.getProxy = function (internalRequire, filename) {

+    var rewireModule = internalRequire("rewire"),

+        key;

+

+    function rewireProxy(path, cache) {

+        return rewireModule(filename, path, cache);

+    }

+

+    for (key in rewireModule) {

+        if (rewireModule.hasOwnProperty(key)) {

+            rewireProxy[key] = rewireModule[key];

+        }

+    }

+

+    return function requireProxy(path) {

+        if (path === "rewire") {

+            return rewireProxy;

+        } else {

+            return internalRequire(path);

+        }

+    };

+};
\ No newline at end of file
diff --git a/lib/browserify/browserifyMiddleware.js b/lib/browserify/browserifyMiddleware.js
new file mode 100644
index 0000000..5b5e042
--- /dev/null
+++ b/lib/browserify/browserifyMiddleware.js
@@ -0,0 +1,61 @@
+var setterSrc = require("../__set__.js").toString(),

+    getterSrc = require("../__get__.js").toString(),

+    fs = require("fs"),

+    path = require("path"),

+    getImportGlobalsSrc = require("../getImportGlobalsSrc.js"),

+    getRewireRequires = require("./getRewireRequires.js"),

+    detectStrictMode = require("../detectStrictMode.js"),

+

+    appendix = fs.readFileSync(__dirname + "/appendix.js", "utf8"),

+    importGlobalsSrc = getImportGlobalsSrc(),

+    injectionSrc = getInjectionSrc().replace(/\s+/g, " ");   // strip out unnecessary spaces to be unobtrusive in the debug view

+

+function getInjectionSrc() {

+    return  'require("rewire").register(__filename, ' + setterSrc + ', ' + getterSrc + ');' +

+            'process = require("__browserify_process");' +

+            'require = window.browserifyRequire.getProxy(require, __filename);';

+}

+

+function browserifyMiddleware(b) {

+    var strictMode;

+

+    b.register(".js", function injectRewire(src, filename) {

+        var rewireRequires = getRewireRequires(src),

+            strictMode = "";

+

+        // Add all modules that are loaded by rewire() manually to browserify because browserify's

+        // require-sniffing doesn't work here.

+        rewireRequires.forEach(function forEachRewireRequire(requirePath) {

+

+            if (requirePath.charAt(0) === ".") {

+                requirePath = path.resolve(path.dirname(filename), requirePath);

+            }

+            b.require(requirePath);

+

+        });

+

+        if (detectStrictMode(src) === true) {

+            strictMode = ' "use strict"; ';

+        }

+

+        filename = filename.replace(/\\/g, "/");

+        if (filename.indexOf("/rewire/lib") === -1) {

+            src =

+                strictMode +

+                "var global = window; " +

+                importGlobalsSrc +

+                injectionSrc +

+                // For a better debugging experience we're adding a comment with the filename

+                "\n//// " + filename + " /////////////////////////////////////////////////////////////////////////////////////////////////////////////\n\n" +

+                src +

+                "\n\n////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n";

+        }

+

+        return src;

+    });

+    b.append(appendix);

+

+    return b;

+}

+

+module.exports = browserifyMiddleware;
\ No newline at end of file
diff --git a/lib/browserify/browserifyRewire.js b/lib/browserify/browserifyRewire.js
new file mode 100644
index 0000000..59ba8cf
--- /dev/null
+++ b/lib/browserify/browserifyRewire.js
@@ -0,0 +1,76 @@
+var pathUtil = require("path"),

+    browserifyRequire = window.browserifyRequire;

+

+var registry = {},

+    rewiredModules = [];    // cache for all rewired modules so it can be reset anytime

+

+function rewire(parentModulePath, targetPath, cache) {

+    var originalModule,

+        rewiredModule = {},

+        registeredTargetModule;

+

+    if (cache === undefined) {

+        cache = true;

+    }

+

+    // Make absolute paths

+    if (targetPath.charAt(0) === ".") {

+        targetPath = pathUtil.resolve(pathUtil.dirname(parentModulePath), targetPath);

+    }

+

+     // Normalize path with file extensions

+    targetPath = require.resolve(targetPath);

+

+    // Deleting module from cache to trigger execution again

+    delete browserifyRequire.modules[targetPath]._cached;

+

+    // Require module to trigger rewire.register() if it hasnt been required yet

+    // Putting (require) within brackets is a hack to disable browserifys require sniffing

+    // @see https://github.com/substack/node-browserify/issues/132#issuecomment-5281470

+    originalModule = (require)(targetPath);

+

+    for (var key in originalModule) {

+        if (originalModule.hasOwnProperty(key)) {

+            rewiredModule[key] = originalModule[key];

+        }

+    }

+

+    if (cache) {

+        browserifyRequire.modules[targetPath]._cached = rewiredModule;

+    }

+

+    // Get registry entry of the target module

+    registeredTargetModule = registry[targetPath];

+

+    // Apply setter and getters

+    rewiredModule.__set__ = registeredTargetModule.setter;

+    rewiredModule.__get__ = registeredTargetModule.getter;

+

+    // Store rewired modules for rewire.reset()

+    rewiredModules.push(targetPath);

+

+    return rewiredModule;

+}

+

+rewire.register = function (filename, setter, getter) {

+    registry[filename] = {

+        setter: setter,

+        getter: getter

+    };

+};

+

+/**

+ * Deletes all rewired modules from the cache

+ */

+rewire.reset = function () {

+    var modules = browserifyRequire.modules,

+        i;

+

+    for (i = 0; i < rewiredModules.length; i++) {

+        delete modules[rewiredModules[i]]._cached;

+    }

+

+    rewiredModules = [];

+};

+

+module.exports = rewire;
\ No newline at end of file
diff --git a/lib/browserify/getRewireRequires.js b/lib/browserify/getRewireRequires.js
new file mode 100644
index 0000000..c8b0f01
--- /dev/null
+++ b/lib/browserify/getRewireRequires.js
@@ -0,0 +1,16 @@
+function getRewireRequires(src) {

+    var result = [],

+        regExp = /[^a-zA-Z0-9_]rewire\(["'](.+?)["']\)/g,

+        match;

+

+    src = " " + src;    // ensure that rewire() is not at index 0 otherwise the regexp won't work in this case

+    match = regExp.exec(src);

+    while (match !== null) {

+        result.push(match[1]);

+        match = regExp.exec(src);

+    }

+

+    return result;

+}

+

+module.exports = getRewireRequires;
\ No newline at end of file
diff --git a/lib/index.js b/lib/index.js
index 0960dd6..6763399 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -22,7 +22,7 @@ function rewire(request, cache) {
 if (process.title === "browser") {

     module.exports = require("./browserify/browserifyRewire.js");

 } else {

-    // Putting (require) within brackets is a hack to disable browserify require sniffing

+    // Putting (require) within brackets is a hack to disable browserify's require sniffing

     // @see https://github.com/substack/node-browserify/issues/132#issuecomment-5281470

     rewireModule = (require)("./rewire.js");

 

diff --git a/lib/rewire.js b/lib/rewire.js
index 2a51e26..080847f 100644
--- a/lib/rewire.js
+++ b/lib/rewire.js
@@ -17,7 +17,7 @@ function restoreOriginalWrappers() {
 /**

  * Does actual rewiring the module. For further documentation @see index.js

  */

-function rewire(parentModule, filename, cache) {

+function rewire(parentModulePath, targetPath, cache) {

     var testModule,

         nodeRequire,

         prepend,

@@ -37,21 +37,21 @@ function rewire(parentModule, filename, cache) {
     }

 

     // Checking params

-    if (typeof filename !== "string") {

+    if (typeof targetPath !== "string") {

         throw new TypeError("Filename must be a string");

     }

 

     // Resolve full filename relative to the parent module

-    filename = Module._resolveFilename(filename, parentModule);

+    targetPath = Module._resolveFilename(targetPath, parentModulePath);

 

     // Special support for older node versions that returned an array on Module._resolveFilename

     // @see https://github.com/joyent/node/blob/865b077819a9271a29f982faaef99dc635b57fbc/lib/module.js#L319

-    if (Array.isArray(filename)) {

-        filename = filename[1];

+    if (Array.isArray(targetPath)) {

+        targetPath = targetPath[1];

     }

 

     // Create testModule as it would be created by require()

-    testModule = new Module(filename, parentModule);

+    testModule = new Module(targetPath, parentModulePath);

 

     // Patching requireProxy

     nodeRequire = testModule.require;

@@ -66,7 +66,7 @@ function rewire(parentModule, filename, cache) {
 

     // Check if the module uses the strict mode.

     // If so we must ensure that "use strict"; stays at the beginning of the module.

-    src = fs.readFileSync(filename, "utf8");

+    src = fs.readFileSync(targetPath, "utf8");

     if (detectStrictMode(src) === true) {

         prepend = ' "use strict"; ' + prepend;

     }

@@ -82,8 +82,8 @@ function rewire(parentModule, filename, cache) {
 

     // Store the rewired module in the cache when enabled

     if (cache) {

-        rewiredModules.push(filename);  // save in private cache for .reset()

-        require.cache[filename] = testModule;

+        rewiredModules.push(targetPath);  // save in private cache for .reset()

+        require.cache[targetPath] = testModule;

     }

 

     // This is only necessary if nothing has been required within the module