jazz-jss 0.0.2 → 0.0.3

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

@@ -0,0 +1,23 @@
+/**
+ * @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
+ */
+
+/*jslint strict: false */
+/*global Packages: false */
+
+var commandLine = {};
+(function () {
+    var runtime = Packages.java.lang.Runtime.getRuntime();
+
+    /**
+     * Executes a command on the command line. May not work right in
+     * Windows environments, except maybe via something like cygwin.
+     * @param {String} command the command to run on the command line.
+     */
+    commandLine.exec = function (command) {
+        var process = runtime.exec(["/bin/sh", "-c", command]);
+        process.waitFor();
+    };
+}());

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

@@ -0,0 +1,152 @@
+/**
+ * @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
+ */
+
+/*jslint plusplus: false, regexp: false, strict: false */
+/*global define: false, console: false */
+
+define(['env!env/file', 'uglifyjs/index'], function (file, uglify) {
+    var commonJs = {
+        depRegExp: /require\s*\(\s*["']([\w-_\.\/]+)["']\s*\)/g,
+
+        //Set this to false in non-rhino environments. If rhino, then it uses
+        //rhino's decompiler to remove comments before looking for require() calls,
+        //otherwise, it will use a crude regexp approach to remove comments. The
+        //rhino way is more robust, but he regexp is more portable across environments.
+        useRhino: true,
+
+        //Set to false if you do not want this file to log. Useful in environments
+        //like node where you want the work to happen without noise.
+        useLog: true,
+
+        convertDir: function (commonJsPath, savePath) {
+            var fileList, i,
+                jsFileRegExp = /\.js$/,
+                fileName, convertedFileName, fileContents;
+
+            //Get list of files to convert.
+            fileList = file.getFilteredFileList(commonJsPath, /\w/, true);
+
+            //Normalize on front slashes and make sure the paths do not end in a slash.
+            commonJsPath = commonJsPath.replace(/\\/g, "/");
+            savePath = savePath.replace(/\\/g, "/");
+            if (commonJsPath.charAt(commonJsPath.length - 1) === "/") {
+                commonJsPath = commonJsPath.substring(0, commonJsPath.length - 1);
+            }
+            if (savePath.charAt(savePath.length - 1) === "/") {
+                savePath = savePath.substring(0, savePath.length - 1);
+            }
+
+            //Cycle through all the JS files and convert them.
+            if (!fileList || !fileList.length) {
+                if (commonJs.useLog) {
+                    if (commonJsPath === "convert") {
+                        //A request just to convert one file.
+                        console.log('\n\n' + commonJs.convert(savePath, file.readFile(savePath)));
+                    } else {
+                        console.log("No files to convert in directory: " + commonJsPath);
+                    }
+                }
+            } else {
+                for (i = 0; (fileName = fileList[i]); i++) {
+                    convertedFileName = fileName.replace(commonJsPath, savePath);
+
+                    //Handle JS files.
+                    if (jsFileRegExp.test(fileName)) {
+                        fileContents = file.readFile(fileName);
+                        fileContents = commonJs.convert(fileName, fileContents);
+                        file.saveUtf8File(convertedFileName, fileContents);
+                    } else {
+                        //Just copy the file over.
+                        file.copyFile(fileName, convertedFileName, true);
+                    }
+                }
+            }
+        },
+
+        /**
+         * Removes the comments from a string.
+         *
+         * @param {String} fileContents
+         * @param {String} fileName mostly used for informative reasons if an error.
+         *
+         * @returns {String} a string of JS with comments removed.
+         */
+        removeComments: function (fileContents, fileName) {
+            //Uglify's ast generation removes comments, so just convert to ast,
+            //then back to source code to get rid of comments.
+            return uglify.uglify.gen_code(uglify.parser.parse(fileContents), true);
+        },
+
+        /**
+         * Regexp for testing if there is already a require.def call in the file,
+         * in which case do not try to convert it.
+         */
+        defRegExp: /define\s*\(\s*("|'|\[|function)/,
+
+        /**
+         * Regexp for testing if there is a require([]) or require(function(){})
+         * call, indicating the file is already in requirejs syntax.
+         */
+        rjsRegExp: /require\s*\(\s*(\[|function)/,
+
+        /**
+         * Does the actual file conversion.
+         *
+         * @param {String} fileName the name of the file.
+         *
+         * @param {String} fileContents the contents of a file :)
+         *
+         * @param {Boolean} skipDeps if true, require("") dependencies
+         * will not be searched, but the contents will just be wrapped in the
+         * standard require, exports, module dependencies. Only usable in sync
+         * environments like Node where the require("") calls can be resolved on
+         * the fly.
+         *
+         * @returns {String} the converted contents
+         */
+        convert: function (fileName, fileContents, skipDeps) {
+            //Strip out comments.
+            try {
+                var deps = [], depName, match,
+                    //Remove comments
+                    tempContents = commonJs.removeComments(fileContents, fileName);
+
+                //First see if the module is not already RequireJS-formatted.
+                if (commonJs.defRegExp.test(tempContents) || commonJs.rjsRegExp.test(tempContents)) {
+                    return fileContents;
+                }
+
+                //Reset the regexp to start at beginning of file. Do this
+                //since the regexp is reused across files.
+                commonJs.depRegExp.lastIndex = 0;
+
+                if (!skipDeps) {
+                    //Find dependencies in the code that was not in comments.
+                    while ((match = commonJs.depRegExp.exec(tempContents))) {
+                        depName = match[1];
+                        if (depName) {
+                            deps.push('"' + depName + '"');
+                        }
+                    }
+                }
+
+                //Construct the wrapper boilerplate.
+                fileContents = 'define(["require", "exports", "module"' +
+                       (deps.length ? ', ' + deps.join(",") : '') + '], ' +
+                       'function(require, exports, module) {\n' +
+                       fileContents +
+                       '\n});\n';
+            } catch (e) {
+                console.log("COULD NOT CONVERT: " + fileName + ", so skipping it. Error was: " + e);
+                return fileContents;
+            }
+
+            return fileContents;
+        }
+    };
+
+    return commonJs;
+});

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

@@ -0,0 +1,47 @@
+/**
+ * @license 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
+ */
+
+/*jslint strict: false */
+/*global Packages: false, process: false, window: false, navigator: false,
+  document: false, define: false */
+
+/**
+ * A plugin that modifies any /env/ path to be the right path based on
+ * the host environment. Right now only works for Node, Rhino and browser.
+ */
+(function () {
+    var pathRegExp = /(\/|^)env\/|\{env\}/,
+        env = 'unknown';
+
+    if (typeof Packages !== 'undefined') {
+        env = 'rhino';
+    } else if (typeof process !== 'undefined') {
+        env = 'node';
+    } else if (typeof window !== "undefined" && navigator && document) {
+        env = 'browser';
+    }
+
+    define({
+        load: function (name, req, load, config) {
+            //Allow override in the config.
+            if (config.env) {
+                env = config.env;
+            }
+
+            name = name.replace(pathRegExp, function (match, prefix) {
+                if (match.indexOf('{') === -1) {
+                    return prefix + env + '/';
+                } else {
+                    return env;
+                }
+            });
+
+            req([name], function (mod) {
+                load(mod);
+            });
+        }
+    });
+}());

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

@@ -0,0 +1,49 @@
+/**
+ * @license 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
+ */
+
+/*jslint plusplus: false, strict: false */
+/*global define: false */
+
+define(function () {
+    var lang = {
+        backSlashRegExp: /\\/g,
+        ostring: Object.prototype.toString,
+
+        isArray: Array.isArray ? Array.isArray : function (it) {
+            return lang.ostring.call(it) === "[object Array]";
+        },
+
+        /**
+         * Simple function to mix in properties from source into target,
+         * but only if target does not already have a property of the same name.
+         */
+        mixin: function (target, source, override) {
+            //Use an empty object to avoid other bad JS code that modifies
+            //Object.prototype.
+            var empty = {}, prop;
+            for (prop in source) {
+                if (override || !(prop in target)) {
+                    target[prop] = source[prop];
+                }
+            }
+        },
+
+        delegate: (function () {
+            // boodman/crockford delegation w/ cornford optimization
+            function TMP() {}
+            return function (obj, props) {
+                TMP.prototype = obj;
+                var tmp = new TMP();
+                TMP.prototype = null;
+                if (props) {
+                    lang.mixin(tmp, props);
+                }
+                return tmp; // Object
+            };
+        }())
+    };
+    return lang;
+});

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

@@ -0,0 +1,58 @@
+/**
+ * @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
+ */
+
+/*jslint nomen: false, strict: false */
+/*global define: false */
+
+define(['env!env/print'], function (print) {
+    var logger = {
+        TRACE: 0,
+        INFO: 1,
+        WARN: 2,
+        ERROR: 3,
+        SILENT: 4,
+        level: 0,
+        logPrefix: "",
+
+        logLevel: function( level ) {
+            this.level = level;
+        },
+
+        trace: function (message) {
+            if (this.level <= this.TRACE) {
+                this._print(message);
+            }
+        },
+
+        info: function (message) {
+            if (this.level <= this.INFO) {
+                this._print(message);
+            }
+        },
+
+        warn: function (message) {
+            if (this.level <= this.WARN) {
+                this._print(message);
+            }
+        },
+
+        error: function (message) {
+            if (this.level <= this.ERROR) {
+                this._print(message);
+            }
+        },
+
+        _print: function (message) {
+            this._sysPrint((this.logPrefix ? (this.logPrefix + " ") : "") + message);
+        },
+
+        _sysPrint: function (message) {
+            print(message);
+        }
+    };
+
+    return logger;
+});

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

@@ -0,0 +1,106 @@
+/**
+ * @license RequireJS node 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
+ */
+
+/*jslint regexp: false, strict: false */
+/*global require: false, define: false, requirejsVars: false, process: false */
+
+/**
+ * This adapter assumes that x.js has loaded it and set up
+ * some variables. This adapter just allows limited RequireJS
+ * usage from within the requirejs directory. The general
+ * node adapater is r.js.
+ */
+
+(function () {
+    var nodeReq = requirejsVars.nodeRequire,
+        req = requirejsVars.require,
+        def = requirejsVars.define,
+        fs = nodeReq('fs'),
+        path = nodeReq('path'),
+        vm = nodeReq('vm');
+
+    //Supply an implementation that allows synchronous get of a module.
+    req.get = function (context, moduleName, relModuleMap) {
+        if (moduleName === "require" || moduleName === "exports" || moduleName === "module") {
+            req.onError(new Error("Explicit require of " + moduleName + " is not allowed."));
+        }
+
+        var ret,
+            moduleMap = context.makeModuleMap(moduleName, relModuleMap);
+
+        //Normalize module name, if it contains . or ..
+        moduleName = moduleMap.fullName;
+
+        if (moduleName in context.defined) {
+            ret = context.defined[moduleName];
+        } else {
+            if (ret === undefined) {
+                //Try to dynamically fetch it.
+                req.load(context, moduleName, moduleMap.url);
+                //The above call is sync, so can do the next thing safely.
+                ret = context.defined[moduleName];
+            }
+        }
+
+        return ret;
+    };
+
+    //Add wrapper around the code so that it gets the requirejs
+    //API instead of the Node API, and it is done lexically so
+    //that it survives later execution.
+    req.makeNodeWrapper = function (contents) {
+        return '(function (require, requirejs, define) { ' +
+                contents +
+                '\n}(requirejsVars.require, requirejsVars.requirejs, requirejsVars.define));';
+    };
+
+    req.load = function (context, moduleName, url) {
+        var contents, err;
+
+        //Indicate a the module is in process of loading.
+        context.scriptCount += 1;
+
+        if (path.existsSync(url)) {
+            contents = fs.readFileSync(url, 'utf8');
+
+            contents = req.makeNodeWrapper(contents);
+            try {
+                vm.runInThisContext(contents, fs.realpathSync(url));
+            } catch (e) {
+                err = new Error('Evaluating ' + url + ' as module "' +
+                                moduleName + '" failed with error: ' + e);
+                err.originalError = e;
+                err.moduleName = moduleName;
+                err.fileName = url;
+                return req.onError(err);
+            }
+        } else {
+            def(moduleName, function () {
+                try {
+                    return (context.config.nodeRequire || req.nodeRequire)(moduleName);
+                } catch (e) {
+                    err = new Error('Calling node\'s require("' +
+                                        moduleName + '") failed with error: ' + e);
+                    err.originalError = e;
+                    err.moduleName = moduleName;
+                    return req.onError(err);
+                }
+            });
+        }
+
+        //Support anonymous modules.
+        context.completeLoad(moduleName);
+
+        return undefined;
+    };
+
+    //Override to provide the function wrapper for define/require.
+    req.exec = function (text) {
+        /*jslint evil: true */
+        text = req.makeNodeWrapper(text);
+        return eval(text);
+    };
+}());

data/templates/app_root/scripts/r.js/build/jslib/node/args.js

@@ -0,0 +1,20 @@
+/**
+ * @license 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
+ */
+
+/*jslint strict: false */
+/*global define: false, process: false */
+
+define(function () {
+    //Do not return the "node" or "r.js" arguments
+    var args = process.argv.slice(2);
+
+    //Ignore any command option used for rq.js
+    if (args[0] && args[0].indexOf('-' === 0)) {
+        args = args.slice(1);
+    }
+
+    return args;
+});