jazz-jss 0.0.2 → 0.0.3

data/templates/app_root/scripts/r.js/build/jslib/uglifyjs/squeeze-more.js

@@ -0,0 +1,55 @@
+define(["require", "exports", "module", "./parse-js", "./process"], function(require, exports, module) {
+
+var jsp = require("./parse-js"),
+    pro = require("./process"),
+    slice = jsp.slice,
+    member = jsp.member,
+    curry = jsp.curry,
+    MAP = pro.MAP,
+    PRECEDENCE = jsp.PRECEDENCE,
+    OPERATORS = jsp.OPERATORS;
+
+function ast_squeeze_more(ast) {
+        var w = pro.ast_walker(), walk = w.walk, scope;
+        function with_scope(s, cont) {
+                var save = scope, ret;
+                scope = s;
+                ret = cont();
+                scope = save;
+                return ret;
+        };
+        function _lambda(name, args, body) {
+                return [ this[0], name, args, with_scope(body.scope, curry(MAP, body, walk)) ];
+        };
+        return w.with_walkers({
+                "toplevel": function(body) {
+                        return [ this[0], with_scope(this.scope, curry(MAP, body, walk)) ];
+                },
+                "function": _lambda,
+                "defun": _lambda,
+                "new": function(ctor, args) {
+                        if (ctor[0] == "name" && ctor[1] == "Array" && !scope.has("Array")) {
+                                if (args.length != 1) {
+                                        return [ "array", args ];
+                                } else {
+                                        return walk([ "call", [ "name", "Array" ], args ]);
+                                }
+                        }
+                },
+                "call": function(expr, args) {
+                        if (expr[0] == "dot" && expr[2] == "toString" && args.length == 0) {
+                                // foo.toString()  ==>  foo+""
+                                return [ "binary", "+", expr[1], [ "string", "" ]];
+                        }
+                        if (expr[0] == "name" && expr[1] == "Array" && args.length != 1 && !scope.has("Array")) {
+                                return [ "array", args ];
+                        }
+                }
+        }, function() {
+                return walk(pro.ast_add_scope(ast));
+        });
+};
+
+exports.ast_squeeze_more = ast_squeeze_more;
+
+});

data/templates/app_root/scripts/r.js/build/jslib/x.js

@@ -0,0 +1,243 @@
+/**
+ * @license r.js 1.0.2+ Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*
+ * This is a bootstrap script to allow running RequireJS in the command line
+ * in either a Java/Rhino or Node environment. It is modified by the top-level
+ * dist.js file to inject other files to completely enable this file. It is
+ * the shell of the r.js file.
+ */
+
+/*jslint strict: false, evil: true, nomen: false */
+/*global readFile: true, process: false, Packages: false, print: false,
+console: false, java: false, module: false */
+
+var requirejs, require, define;
+(function (console, args, readFileFunc) {
+
+    var fileName, env, fs, vm, path, exec, rhinoContext, dir, nodeRequire,
+        nodeDefine, exists, reqMain, loadedOptimizedLib,
+        version = '1.0.2+',
+        jsSuffixRegExp = /\.js$/,
+        commandOption = '',
+        //Used by jslib/rhino/args.js
+        rhinoArgs = args,
+        readFile = typeof readFileFunc !== 'undefined' ? readFileFunc : null;
+
+    function showHelp() {
+        console.log('See https://github.com/jrburke/r.js for usage.');
+    }
+
+    if (typeof Packages !== 'undefined') {
+        env = 'rhino';
+
+        fileName = args[0];
+
+        if (fileName && fileName.indexOf('-') === 0) {
+            commandOption = fileName.substring(1);
+            fileName = args[1];
+        }
+
+        //Set up execution context.
+        rhinoContext = Packages.org.mozilla.javascript.ContextFactory.getGlobal().enterContext();
+
+        exec = function (string, name) {
+            return rhinoContext.evaluateString(this, string, name, 0, null);
+        };
+
+        exists = function (fileName) {
+            return (new java.io.File(fileName)).exists();
+        };
+
+        //Define a console.log for easier logging. Don't
+        //get fancy though.
+        if (typeof console === 'undefined') {
+            console = {
+                log: function () {
+                    print.apply(undefined, arguments);
+                }
+            };
+        }
+    } else if (typeof process !== 'undefined') {
+        env = 'node';
+
+        //Get the fs module via Node's require before it
+        //gets replaced. Used in require/node.js
+        fs = require('fs');
+        vm = require('vm');
+        path = require('path');
+        nodeRequire = require;
+        nodeDefine = define;
+        reqMain = require.main;
+
+        //Temporarily hide require and define to allow require.js to define
+        //them.
+        require = undefined;
+        define = undefined;
+
+        readFile = function (path) {
+            return fs.readFileSync(path, 'utf8');
+        };
+
+        exec = function (string, name) {
+            return vm.runInThisContext(this.requirejsVars.require.makeNodeWrapper(string),
+                                       name ? fs.realpathSync(name) : '');
+        };
+
+        exists = function (fileName) {
+            return path.existsSync(fileName);
+        };
+
+
+        fileName = process.argv[2];
+
+        if (fileName && fileName.indexOf('-') === 0) {
+            commandOption = fileName.substring(1);
+            fileName = process.argv[3];
+        }
+    }
+
+    //INSERT require.js
+
+    if (env === 'rhino') {
+        //INSERT build/jslib/rhino.js
+    } else if (env === 'node') {
+        this.requirejsVars = {
+            require: require,
+            requirejs: require,
+            define: define,
+            nodeRequire: nodeRequire
+        };
+        require.nodeRequire = nodeRequire;
+
+        //INSERT build/jslib/node.js
+
+    }
+
+    //Support a default file name to execute. Useful for hosted envs
+    //like Joyent where it defaults to a server.js as the only executed
+    //script. But only do it if this is not an optimization run.
+    if (commandOption !== 'o' && (!fileName || !jsSuffixRegExp.test(fileName))) {
+        fileName = 'main.js';
+    }
+
+    /**
+     * Loads the library files that can be used for the optimizer, or for other
+     * tasks.
+     */
+    function loadLib() {
+        //INSERT LIB
+    }
+
+
+    /**
+     * Sets the default baseUrl for requirejs to be directory of top level
+     * script.
+     */
+    function setBaseUrl(fileName) {
+        //Use the file name's directory as the baseUrl if available.
+        dir = fileName.replace(/\\/g, '/');
+        if (dir.indexOf('/') !== -1) {
+            dir = dir.split('/');
+            dir.pop();
+            dir = dir.join('/');
+            exec("require({baseUrl: '" + dir + "'});");
+        }
+    }
+
+    //If in Node, and included via a require('requirejs'), just export and
+    //THROW IT ON THE GROUND!
+    if (env === 'node' && reqMain !== module) {
+        setBaseUrl(path.resolve(reqMain ? reqMain.filename : '.'));
+
+        //Create a method that will run the optimzer given an object
+        //config.
+        requirejs.optimize = function (config, callback) {
+            if (!loadedOptimizedLib) {
+                loadLib();
+                loadedOptimizedLib = true;
+            }
+
+            //Create the function that will be called once build modules
+            //have been loaded.
+            var runBuild = function (build, logger) {
+                //Make sure config has a log level, and if not,
+                //make it "silent" by default.
+                config.logLevel = config.hasOwnProperty('logLevel') ?
+                                  config.logLevel : logger.SILENT;
+
+                var result = build(config);
+
+                //Reset build internals on each run.
+                requirejs._buildReset();
+
+                if (callback) {
+                    callback(result);
+                }
+            };
+
+            //Enable execution of this callback in a build setting.
+            //Normally, once requirePatch is run, by default it will
+            //not execute callbacks, unless this property is set on
+            //the callback.
+            runBuild.__requireJsBuild = true;
+
+            requirejs({
+                context: 'build'
+            }, ['build', 'logger'], runBuild);
+        };
+
+        requirejs.define = define;
+
+        module.exports = requirejs;
+        return;
+    }
+
+    if (commandOption === 'o') {
+        //Do the optimizer work.
+        loadLib();
+
+        //INSERT build/build.js
+
+    } else if (commandOption === 'v') {
+        console.log('r.js: ' + version + ', RequireJS: ' + this.requirejsVars.require.version);
+    } else if (commandOption === 'convert') {
+        loadLib();
+
+        this.requirejsVars.require(['env!env/args', 'commonJs', 'env!env/print'],
+        function (args,           commonJs,   print) {
+
+            var srcDir, outDir;
+            srcDir = args[0];
+            outDir = args[1];
+
+            if (!srcDir || !outDir) {
+                print('Usage: path/to/commonjs/modules output/dir');
+                return;
+            }
+
+            commonJs.convertDir(args[0], args[1]);
+        });
+    } else {
+        //Just run an app
+
+        //Load the bundled libraries for use in the app.
+        if (commandOption === 'lib') {
+            loadLib();
+        }
+
+        setBaseUrl(fileName);
+
+        if (exists(fileName)) {
+            exec(readFile(fileName), fileName);
+        } else {
+            showHelp();
+        }
+    }
+
+}((typeof console !== 'undefined' ? console : undefined),
+  (typeof Packages !== 'undefined' ? Array.prototype.slice.call(arguments, 0) : []),
+  (typeof readFile !== 'undefined' ? readFile : undefined)));

data/templates/app_root/scripts/r.js/build/tests/all.js

@@ -0,0 +1,47 @@
+/**
+ * @license RequireJS Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/**
+ * Run the tests in Node with this command:
+ * ../../bin/x all.js
+ */
+
+/*jslint plusplus: false, strict: false */
+/*global require: false, doh: false, skipDohSetup: true */
+
+//A hack to doh to avoid dojo setup stuff in doh/runner.js
+skipDohSetup = true;
+
+//Set baseUrl for default context, but use a different context
+//to run the tests, since at least one test run clears out the
+//default context between each run.
+require({
+    baseUrl: '../jslib/'
+});
+
+//Run the tests in a different context.
+require({
+    baseUrl: '../jslib/',
+    paths: {
+        tests: '../tests'
+    },
+    context: 'test'
+}, [
+    '../../tests/doh/runner.js',
+    'env!../../tests/doh/_{env}Runner.js',
+    'tests/convert',
+    'tests/parse',
+    'tests/buildUtils',
+
+    //Build tests should be last in case they alter the environment
+    //in a weird way.
+    'tests/builds'
+]);
+
+//Show final report. Do this outside the require call, not
+//in a require callback because the builds will modify require.js
+//to not call callbacks.
+doh.run();

data/templates/app_root/scripts/r.js/build/tests/allj.sh

@@ -0,0 +1,3 @@
+set -e
+
+java -classpath ../../lib/rhino/js.jar:../../lib/closure.compiler.jar org.mozilla.javascript.tools.shell.Main ../../r.js all.js

data/templates/app_root/scripts/r.js/build/tests/alln.sh

@@ -0,0 +1,18 @@
+#Stop after any error
+set -e
+
+rm -rf ./builds/
+echo "Running tests embedded in Node"
+echo "=============================="
+node nodeOptimize.js
+rm -rf ./builds/
+
+node nodeOptimizeNoCallback.js
+rm -rf ./builds/
+
+node nodeAll.js
+rm -rf ./builds/
+
+echo "\nRunning tests via bootstrap"
+echo "=============================="
+node ../../r.js all.js

data/templates/app_root/scripts/r.js/build/tests/anonSimple.build.js

@@ -0,0 +1,7 @@
+//A simple build file using the tests directory for requirejs
+{
+    baseUrl: "../../../requirejs/tests/anon",
+    optimize: "none",
+    out: "builds/anonSimple.js",
+    include: ["magenta", "red", "blue", "green", "yellow"]
+}

data/templates/app_root/scripts/r.js/build/tests/buildUtils.js

@@ -0,0 +1,19 @@
+/*jslint plusplus: false, strict: false */
+/*global load: false, doh: false, define:false */
+
+define(['build'], function (build) {
+
+    doh.register("toTransport",
+        [
+            function toTransport(t) {
+                var bad1 = "this.define(field, value, {_resolve: false});",
+                    layer = {
+                        modulesWithNames: {}
+                    };
+
+                t.is(bad1, build.toTransport(build.makeAnonDefRegExp(), '', 'bad/1', 'bad1', bad1, layer));
+            }
+        ]
+    );
+    doh.run();
+});

data/templates/app_root/scripts/r.js/build/tests/builds.js

@@ -0,0 +1,489 @@
+/*jslint plusplus: false, nomen: false, strict: false */
+/*global define: false, require: false, doh: false */
+
+define(['build', 'env!env/file'], function (build, file) {
+    //Remove any old builds
+    file.deleteFile("builds");
+
+    function c(fileName) {
+        return file.readFile(fileName);
+    }
+
+    //Remove line returns to make comparisons easier.
+    function nol(contents) {
+        return contents.replace(/[\r\n]/g, "");
+    }
+
+    //Do a build of the text plugin to get any pragmas processed.
+    build(["name=text", "baseUrl=../../../requirejs", "out=builds/text.js", "optimize=none"]);
+
+    //Reset build state for next run.
+    require._buildReset();
+
+    var requireTextContents = c("builds/text.js"),
+        oneResult = [
+            c("../../../requirejs/tests/dimple.js"),
+            c("../../../requirejs/tests/two.js"),
+            c("../../../requirejs/tests/one.js"),
+            ";"
+        ].join("");
+
+    doh.register("buildOneCssFile",
+        [
+            function buildOneCssFile(t) {
+                build(["cssIn=css/sub/sub1.css", "out=builds/sub1.css"]);
+
+                t.is(nol(c("cssTestCompare.css")), nol(c("builds/sub1.css")));
+
+                //Reset require internal state for the contexts so future
+                //builds in these tests will work correctly.
+                require._buildReset();
+            }
+        ]
+    );
+    doh.run();
+
+    doh.register("buildOneJsFile",
+        [
+            function buildOneJsFile(t) {
+                build(["name=one", "include=dimple", "out=builds/outSingle.js",
+                       "baseUrl=../../../requirejs/tests", "optimize=none"]);
+
+                t.is(nol(oneResult), nol(c("builds/outSingle.js")));
+
+                //Reset require internal state for the contexts so future
+                //builds in these tests will work correctly.
+                require._buildReset();
+            }
+        ]
+    );
+    doh.run();
+
+
+    doh.register("buildOneJsFileWrapped",
+        [
+            function buildOneJsFile(t) {
+                build(["name=one", "include=dimple", "out=builds/outSingleWrap.js",
+                       "baseUrl=../../../requirejs/tests", "optimize=none",
+                       "wrap.start=START", "wrap.end=END"]);
+
+                t.is(nol("START" + oneResult + "END"), nol(c("builds/outSingleWrap.js")));
+
+                //Reset require internal state for the contexts so future
+                //builds in these tests will work correctly.
+                require._buildReset();
+            }
+        ]
+    );
+    doh.run();
+
+    doh.register("buildOneJsFileWrappedTrue",
+        [
+            function buildOneJsFile(t) {
+                build(["name=one", "include=dimple", "out=builds/outSingleWrapTrue.js",
+                       "baseUrl=../../../requirejs/tests", "optimize=none",
+                       "wrap=true"]);
+
+                t.is(nol("(function () {" + oneResult + "}());"), nol(c("builds/outSingleWrapTrue.js")));
+
+                //Reset require internal state for the contexts so future
+                //builds in these tests will work correctly.
+                require._buildReset();
+            }
+        ]
+    );
+    doh.run();
+
+    doh.register("buildOneJsFileWrappedFile",
+        [
+            function buildOneJsFile(t) {
+                build(["name=one", "include=dimple", "out=builds/outSingleWrap.js",
+                       "baseUrl=../../../requirejs/tests", "optimize=none",
+                       "wrap.startFile=start.frag", "wrap.endFile=end.frag"]);
+
+                t.is(nol(c("start.frag") + oneResult + c("end.frag")), nol(c("builds/outSingleWrap.js")));
+
+                //Reset require internal state for the contexts so future
+                //builds in these tests will work correctly.
+                require._buildReset();
+            }
+        ]
+    );
+    doh.run();
+
+    doh.register("buildSimple",
+        [
+            function buildSimple(t) {
+                //Do the build
+                build(["simple.build.js"]);
+
+                t.is(nol(oneResult), nol(c("builds/simple/one.js")));
+
+                //Reset require internal state for the contexts so future
+                //builds in these tests will work correctly.
+                require._buildReset();
+            }
+        ]
+    );
+    doh.run();
+
+    doh.register("buildExcludeShallow",
+        [
+            function buildExcludeShallow(t) {
+                build(["name=uno", "excludeShallow=dos", "out=builds/unoExcludeShallow.js",
+                       "baseUrl=../../../requirejs/tests", "optimize=none"]);
+
+                t.is(nol(c("expected/unoExcludeShallow.js")), nol(c("builds/unoExcludeShallow.js")));
+                require._buildReset();
+            }
+        ]
+    );
+    doh.run();
+
+    doh.register("buildExclude",
+        [
+            function buildExclude(t) {
+                build(["name=uno", "exclude=dos", "out=builds/unoExclude.js",
+                       "baseUrl=../../../requirejs/tests", "optimize=none"]);
+
+                t.is(nol(c("../../../requirejs/tests/uno.js")), nol(c("builds/unoExclude.js")));
+                require._buildReset();
+            }
+        ]
+    );
+    doh.run();
+
+    doh.register("buildTextPluginIncluded",
+        [
+            function buildTextPluginIncluded(t) {
+                build(["name=one", "include=text", "out=builds/oneText.js",
+                       "baseUrl=../../../requirejs/tests", "paths.text=../text", "optimize=none"]);
+
+                t.is(nol(requireTextContents +
+                         nol(c("../../../requirejs/tests/two.js") +
+                         c("../../../requirejs/tests/one.js") + ";")), nol(c("builds/oneText.js")));
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+    doh.register("buildPluginAsModule",
+        [
+            function buildPluginAsModule(t) {
+                build(["name=refine!a", "out=builds/refineATest.js",
+                       "baseUrl=../../../requirejs/tests/plugins/fromText",
+                       "exclude=text,refine",
+                       "paths.text=../../../text", "optimize=none"]);
+
+                t.is(nol(nol((c("../../../requirejs/tests/plugins/fromText/a.refine"))
+                             .replace(/refine/g, 'define')))
+                             .replace(/define\(\{/, "define('refine!a',{"),
+                         nol(c("builds/refineATest.js")));
+
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+
+    doh.register("buildUniversal",
+        [
+            function buildUniversal(t) {
+                build(["baseUrl=../../../requirejs/tests/universal",
+                       "name=universal-tests",
+                       "out=../../../requirejs/tests/universal/universal-tests-built.js",
+                       "optimize=none"]);
+
+                t.is(nol(c("../../../requirejs/tests/universal/universal-tests-built-expected.js")),
+                     nol(c("../../../requirejs/tests/universal/universal-tests-built.js")));
+
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+
+    doh.register("buildNamespace",
+        [
+            function buildNamespace(t) {
+                build(["baseUrl=lib/namespace", "optimize=none", "namespace=foo",
+                       "name=main", "out=lib/namespace/foo.js"]);
+
+                t.is(nol(c("lib/namespace/expected.js")),
+                     nol(c("lib/namespace/foo.js")));
+
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+    doh.register("useDotPackage",
+        [
+            function useDotPackage(t) {
+                file.deleteFile("lib/dotpackage/built");
+
+                build(["lib/dotpackage/scripts/app.build.js"]);
+
+                t.is(nol(c("lib/dotpackage/scripts/main-expected.js")),
+                     nol(c("lib/dotpackage/built/scripts/main.js")));
+
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+    doh.register("multipleEmpty",
+        [
+            function multipleEmpty(t) {
+                file.deleteFile("lib/empty/built");
+
+                build(["lib/empty/build.js"]);
+
+                t.is(nol(c("lib/empty/expected.js")),
+                     nol(c("lib/empty/built/main.js")));
+
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+    doh.register("preserveLicense",
+        [
+            function preserveLicense(t) {
+                file.deleteFile("lib/comments/built.js");
+
+                build(["lib/comments/build.js"]);
+
+                t.is(nol(c("lib/comments/expected.js")),
+                     nol(c("lib/comments/built.js")));
+
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+    doh.register("nestedFind",
+        [
+            function nestedFind(t) {
+                file.deleteFile("lib/nested/main-builtWithCE.js");
+
+                //Clear the cached file contents since the
+                //findNestedDependencies config actually modifies
+                //what the contents could be.
+                require._cachedFileContents = {};
+
+                build(["lib/nested/buildWithCE.js"]);
+
+                t.is(nol(c("lib/nested/expected-builtWithCE.js")),
+                     nol(c("lib/nested/main-builtWithCE.js")));
+
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+    doh.register("nestedSkip",
+        [
+            function nestedSkip(t) {
+                file.deleteFile("lib/nested/main-built.js");
+
+                //Clear the cached file contents since the
+                //findNestedDependencies config actually modifies
+                //what the contents could be.
+                require._cachedFileContents = {};
+
+                build(["lib/nested/build.js"]);
+
+                t.is(nol(c("lib/nested/expected-built.js")),
+                     nol(c("lib/nested/main-built.js")));
+
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+    doh.register("nestedHas",
+        [
+            function nestedHas(t) {
+                file.deleteFile("lib/nestedHas/main-built.js");
+
+                //Clear the cached file contents since the
+                //findNestedDependencies config actually modifies
+                //what the contents could be.
+                require._cachedFileContents = {};
+
+                build(["lib/nestedHas/build.js"]);
+
+                t.is(nol(c("lib/nestedHas/expected-built.js")),
+                     nol(c("lib/nestedHas/main-built.js")));
+
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+    doh.register("nestedHasNeedAll",
+        [
+            function nestedHasNeedAll(t) {
+                file.deleteFile("lib/nestedHas/main-builtNeedAll.js");
+
+                //Clear the cached file contents since the
+                //findNestedDependencies config actually modifies
+                //what the contents could be.
+                require._cachedFileContents = {};
+
+                build(["lib/nestedHas/buildNeedAll.js"]);
+
+                t.is(nol(c("lib/nestedHas/expected-builtNeedAll.js")),
+                     nol(c("lib/nestedHas/main-builtNeedAll.js")));
+
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+    doh.register("nestedHasNeedB",
+        [
+            function nestedHasNeed(t) {
+                file.deleteFile("lib/nestedHas/main-builtNeedB.js");
+
+                //Clear the cached file contents since the
+                //findNestedDependencies config actually modifies
+                //what the contents could be.
+                require._cachedFileContents = {};
+
+                build(["lib/nestedHas/buildNeedB.js"]);
+
+                t.is(nol(c("lib/nestedHas/expected-builtNeedB.js")),
+                     nol(c("lib/nestedHas/main-builtNeedB.js")));
+
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+    doh.register("nestedHasNeedC",
+        [
+            function nestedHasNeed(t) {
+                file.deleteFile("lib/nestedHas/main-builtNeedC.js");
+
+                //Clear the cached file contents since the
+                //findNestedDependencies config actually modifies
+                //what the contents could be.
+                require._cachedFileContents = {};
+
+                build(["lib/nestedHas/buildNeedC.js"]);
+
+                t.is(nol(c("lib/nestedHas/expected-builtNeedC.js")),
+                     nol(c("lib/nestedHas/main-builtNeedC.js")));
+
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+    doh.register("nestedHasNeedD",
+        [
+            function nestedHasNeedD(t) {
+                file.deleteFile("lib/nestedHas/main-builtNeedD.js");
+
+                //Clear the cached file contents since the
+                //findNestedDependencies config actually modifies
+                //what the contents could be.
+                require._cachedFileContents = {};
+
+                build(["lib/nestedHas/buildNeedD.js"]);
+
+                t.is(nol(c("lib/nestedHas/expected-builtNeedD.js")),
+                     nol(c("lib/nestedHas/main-builtNeedD.js")));
+
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+    doh.register("nestedHasNested",
+        [
+            function nestedHasNested(t) {
+                file.deleteFile("lib/nestedHas/main-builtNested.js");
+
+                //Clear the cached file contents since the
+                //findNestedDependencies config actually modifies
+                //what the contents could be.
+                require._cachedFileContents = {};
+
+                build(["lib/nestedHas/buildNested.js"]);
+
+                t.is(nol(c("lib/nestedHas/expected-builtNested.js")),
+                     nol(c("lib/nestedHas/main-builtNested.js")));
+
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+    doh.register("amdefineStrip",
+        [
+            function amdefineStrip(t) {
+                file.deleteFile("lib/amdefine/built.js");
+
+                build(["lib/amdefine/build.js"]);
+
+                t.is(nol(c("lib/amdefine/expected.js")),
+                     nol(c("lib/amdefine/built.js")));
+
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+    doh.register("nameInsertion",
+        [
+            function nameInsertion(t) {
+                file.deleteFile("lib/nameInsertion/built.js");
+
+                build(["lib/nameInsertion/build.js"]);
+
+                t.is(nol(c("lib/nameInsertion/expected.js")),
+                     nol(c("lib/nameInsertion/built.js")));
+
+                require._buildReset();
+            }
+
+        ]
+    );
+    doh.run();
+
+});