jazz-jss 0.0.2 → 0.0.3

data/templates/app_root/scripts/r.js/build/tests/lib/amdefine/node_modules/amdefine/amdefine.js

@@ -0,0 +1,188 @@
+/** vim: et:ts=4:sw=4:sts=4
+ * @license amdefine 0.0.1 Copyright (c) 2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/amdefine for details
+ */
+
+/*jslint strict: false, nomen: false, plusplus: false */
+/*global module, process, require: true */
+
+var path = require('path'),
+    loaderCache = {},
+    makeRequire;
+
+// Null out require for this file so that it is not accidentally used
+// below, where module.require should be used instead.
+require = null;
+
+/**
+ * Given a relative module name, like ./something, normalize it to
+ * a real name that can be mapped to a path.
+ * @param {String} name the relative name
+ * @param {String} baseName a real name that the name arg is relative
+ * to.
+ * @returns {String} normalized name
+ */
+function normalize(name, baseName) {
+    return path.normalize(path.join(baseName, name));
+}
+
+/**
+ * Create the normalize() function passed to a loader plugin's
+ * normalize method.
+ */
+function makeNormalize(relName) {
+    return function (name) {
+        return normalize(name, relName);
+    };
+}
+
+function makeLoad(id) {
+    function load(value) {
+        loaderCache[id] = value;
+    }
+
+    load.fromText = function (id, text) {
+        //This one is difficult because the text can/probably uses
+        //define, and any relative paths and requires should be relative
+        //to that id was it would be found on disk. But this would require
+        //bootstrapping a module/require fairly deeply from node core.
+        //Not sure how best to go about that yet.
+        throw new Error('amdefine does not implement load.fromText');
+    };
+
+    return load;
+}
+
+function stringRequire(module, id) {
+    //Split the ID by a ! so that
+    var index = id.indexOf('!'),
+        relId = path.dirname(module.filename),
+        prefix, plugin;
+
+    if (index === -1) {
+        //Straight module lookup. If it is one of the special dependencies,
+        //deal with it, otherwise, delegate to node.
+        if (id === 'require') {
+            return makeRequire(module);
+        } else if (id === 'exports') {
+            return module.exports;
+        } else if (id === 'module') {
+            return module;
+        } else {
+            return module.require(id);
+        }
+    } else {
+        //There is a plugin in play.
+        prefix = id.substring(0, index);
+        id = id.substring(index + 1, id.length);
+
+        plugin = module.require(prefix);
+
+        if (plugin.normalize) {
+            id = plugin.normalize(id, makeNormalize(relId));
+        } else {
+            //Normalize the ID normally.
+            id = normalize(id, relId);
+        }
+
+        if (loaderCache[id]) {
+            return loaderCache[id];
+        } else {
+            plugin.load(id, makeRequire(module), makeLoad(id), {});
+
+            return loaderCache[id];
+        }
+    }
+}
+
+makeRequire = function (module) {
+    function amdRequire(deps, callback) {
+        if (typeof deps === 'string') {
+            //Synchronous, single module require('')
+            return stringRequire(module, deps);
+        } else {
+            //Array of dependencies with a callback.
+
+            //Convert the dependencies to modules.
+            deps = deps.map(function (depName) {
+                return stringRequire(module, depName);
+            });
+
+            //Wait for next tick to call back the require call.
+            process.nextTick(function () {
+                callback.apply(null, deps);
+            });
+
+            //Keeps strict checking in komodo happy.
+            return undefined;
+        }
+    }
+
+    amdRequire.toUrl = function (filePath) {
+        if (filePath.indexOf('.') === 0) {
+            return normalize(filePath, path.dirname(module.filename));
+        } else {
+            return filePath;
+        }
+    };
+
+    return amdRequire;
+};
+
+function amdefine(module) {
+    var alreadyCalled = false;
+
+    //Create a define function specific to the module asking for amdefine.
+    function define() {
+
+        var args = arguments,
+            factory = args[args.length - 1],
+            isFactoryFunction = (typeof factory === 'function'),
+            deps, result;
+
+        //Only support one define call per file
+        if (alreadyCalled) {
+            throw new Error('amdefine cannot be called more than once per file.');
+        }
+        alreadyCalled = true;
+
+        //Grab array of dependencies if it is there.
+        if (args.length > 1) {
+            deps = args[args.length - 2];
+            if (!Array.isArray(deps)) {
+                //deps is not an array, may be an ID. Discard it.
+                deps = null;
+            }
+        }
+
+        //If there are dependencies, they are strings, so need
+        //to convert them to dependency values.
+        if (deps) {
+            deps = deps.map(function (depName) {
+                return stringRequire(module, depName);
+            });
+        } else if (isFactoryFunction) {
+            //Pass in the standard require, exports, module
+            deps = [makeRequire(module), module.exports, module];
+        }
+
+        if (!isFactoryFunction) {
+            //Factory is an object that should just be used for the define call.
+            module.exports = factory;
+        } else {
+            //Call the factory with the right dependencies.
+            result = factory.apply(module.exports, deps);
+
+            if (result !== undefined) {
+                module.exports = result;
+            }
+        }
+    }
+
+    define.amd = {};
+
+    return define;
+}
+
+module.exports = amdefine;

data/templates/app_root/scripts/r.js/build/tests/lib/amdefine/node_modules/amdefine/package.json

@@ -0,0 +1,21 @@
+{
+    "name": "amdefine",
+    "description": "Provide AMD's define() API for declaring modules in the AMD format",
+    "version": "0.0.1",
+    "homepage": "http://github.com/jrburke/amdefine.js",
+    "author": "James Burke <jrburke@gmail.com> (http://github.com/jrburke)",
+    "licenses": [
+        {
+            "type": "BSD",
+            "url": "https://github.com/jrburke/amdefine/blob/master/LICENSE"
+        },
+        {
+            "type": "MIT",
+            "url": "https://github.com/jrburke/amdefine/blob/master/LICENSE"
+        }
+    ],
+    "main": "./amdefine.js",
+    "engines": {
+        "node": ">=0.6.0"
+    }
+}

data/templates/app_root/scripts/r.js/build/tests/lib/comments/bang.js

@@ -0,0 +1,10 @@
+/*!
+ * this is a BANG LICENSE COMMENT
+ */
+
+define(function () {
+    /* This comment should be IGNORED */
+    return {
+        name: 'bang'
+    };
+});

data/templates/app_root/scripts/r.js/build/tests/lib/comments/build.js

@@ -0,0 +1,6 @@
+({
+    baseUrl: '.',
+    name: 'bang',
+    include: ['license'],
+    out: 'built.js'
+})

data/templates/app_root/scripts/r.js/build/tests/lib/comments/expected.js

@@ -0,0 +1,9 @@
+/*!
+ * this is a BANG LICENSE COMMENT
+ */
+/** vim: et:ts=4:sw=4:sts=4
+ * @license This is a  LICENSE COMMENT that should be preserved.
+ * Available via the MIT or new BSD license.
+ * see: http://example.com/license for details
+ */
+define("bang",[],function(){return{name:"bang"}}),define("license",{name:"license"})

data/templates/app_root/scripts/r.js/build/tests/lib/comments/license.js

@@ -0,0 +1,13 @@
+/** vim: et:ts=4:sw=4:sts=4
+ * @license This is a  LICENSE COMMENT that should be preserved.
+ * Available via the MIT or new BSD license.
+ * see: http://example.com/license for details
+ */
+
+define({
+    //@license comment to be IGNORED
+    name: 'license'
+    /**
+     * A license fake-out, should be IGNORED
+     */
+});

data/templates/app_root/scripts/r.js/build/tests/lib/dotpackage/scripts/app.build.js

@@ -0,0 +1,15 @@
+({
+    appDir: '..',
+    baseUrl: 'scripts',
+    dir: '../built',
+    optimize: 'none',
+    dirExclusionRegExp: null,
+    packagePaths: {
+        '.packages': ['sample']
+    },
+    modules: [
+        {
+            name: 'main'
+        }
+    ]
+})

data/templates/app_root/scripts/r.js/build/tests/lib/dotpackage/scripts/main-expected.js

@@ -0,0 +1,13 @@
+
+define('sample',{
+    name: 'sample'
+});
+
+
+define('main',['sample'], function (sample) {
+    return {
+        name: 'main',
+        sampleName: sample.name
+    };
+});
+

data/templates/app_root/scripts/r.js/build/tests/lib/dotpackage/scripts/main.js

@@ -0,0 +1,7 @@
+define(['sample'], function (sample) {
+    return {
+        name: 'main',
+        sampleName: sample.name
+    };
+});
+

data/templates/app_root/scripts/r.js/build/tests/lib/empty/build.js

@@ -0,0 +1,13 @@
+({
+    baseUrl: '.',
+    dir: 'built',
+    optimize: 'none',
+    paths: {
+        'empty1': 'empty:',
+        'empty2': 'empty:'
+    },
+    modules: [{
+        name: 'main',
+        include: ['sub2']
+    }]
+})

data/templates/app_root/scripts/r.js/build/tests/lib/empty/expected.js

@@ -0,0 +1,8 @@
+
+define('sub1',['empty1'], function () {});
+
+require(['sub1'], function () {});
+
+define("main", function(){});
+
+define('sub2',['empty2'], function () {});

data/templates/app_root/scripts/r.js/build/tests/lib/empty/main.js

@@ -0,0 +1 @@
+require(['sub1'], function () {});

data/templates/app_root/scripts/r.js/build/tests/lib/empty/sub1.js

@@ -0,0 +1 @@
+define(['empty1'], function () {});

data/templates/app_root/scripts/r.js/build/tests/lib/empty/sub2.js

@@ -0,0 +1 @@
+define(['empty2'], function () {});

data/templates/app_root/scripts/r.js/build/tests/lib/nameInsertion/build.js

@@ -0,0 +1,6 @@
+({
+    baseUrl: '.',
+    name: 'main',
+    out: 'built.js',
+    optimize: 'none'
+})

data/templates/app_root/scripts/r.js/build/tests/lib/nameInsertion/expected.js

@@ -0,0 +1,12 @@
+
+
+define('foo',[], function () {
+
+});
+
+require(['foo'], function () {
+
+});
+
+
+define("main", function(){});

data/templates/app_root/scripts/r.js/build/tests/lib/nameInsertion/main.js

@@ -0,0 +1,9 @@
+
+define('foo', function () {
+
+});
+
+require(['foo'], function () {
+
+});
+

data/templates/app_root/scripts/r.js/build/tests/lib/namespace/build.js

@@ -0,0 +1,8 @@
+({
+    baseUrl: '.',
+    optimize: 'none',
+    namespace: 'foo',
+    name: 'main',
+    out: 'foo.js'
+})
+

data/templates/app_root/scripts/r.js/build/tests/lib/namespace/expected.js

@@ -0,0 +1,47 @@
+
+(function (define) {
+    foo.define('modules/one',[],function ( ){
+       return { name: 'one' };
+    });
+
+}(typeof foo.define === 'function' && foo.define.amd ? foo.define : function () {
+
+
+}));
+
+if (typeof foo.define === 'function' && foo.define.amd && foo.define.jQuery) {
+    foo.define('modules/two',[],function () {
+       return { name: 'two' };
+    });
+}
+;
+if(false){
+
+}else if(typeof foo.define === 'function' && typeof foo.define.amd === 'object' && foo.define.amd){
+    foo.define('modules/four',{
+        name: 'four'
+    });
+};
+(function (define) {
+    foo.define('modules/three',[], function (require) {
+        //If have dependencies, get them here
+        var four = foo.require('./four');
+
+        //Return the module definition.
+        return {
+            name: 'three',
+            fourName: four.name
+        };
+    });
+}(typeof foo.define === 'function' && foo.define.amd ? foo.define : function (id, factory) {
+
+}));
+
+foo.require(['modules/one', 'modules/two', 'modules/three'], function (one, two, three) {
+    console.log("One's name is: " + one.name);
+    console.log("Two's name is: " + two.name);
+    console.log("Two's name is: " + three.name);
+    console.log("Three's fourName is: " + three.fourName);
+});
+
+foo.define("main", function(){});

data/templates/app_root/scripts/r.js/build/tests/lib/namespace/main.js

@@ -0,0 +1,6 @@
+require(['modules/one', 'modules/two', 'modules/three'], function (one, two, three) {
+    console.log("One's name is: " + one.name);
+    console.log("Two's name is: " + two.name);
+    console.log("Two's name is: " + three.name);
+    console.log("Three's fourName is: " + three.fourName);
+});

data/templates/app_root/scripts/r.js/build/tests/lib/namespace/modules/four.js

@@ -0,0 +1,7 @@
+if(false){
+
+}else if(typeof define == "function" && typeof define.amd == "object" && define.amd){
+    define({
+        name: 'four'
+    });
+}

data/templates/app_root/scripts/r.js/build/tests/lib/namespace/modules/one.js

@@ -0,0 +1,9 @@
+(function (define) {
+    define( function ( ){
+       return { name: 'one' };
+    });
+
+}(typeof define === 'function' && define.amd ? define : function () {
+
+
+}));