jazz-jss 0.0.2 → 0.0.3

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

@@ -0,0 +1,11 @@
+({
+    baseUrl: '.',
+    optimize: 'none',
+    paths: {
+        fs: 'blank',
+        path: 'blank'
+    },
+    skipModuleInsertion: true,
+    name: '../build',
+    out: 'optotext.js'
+})

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

@@ -0,0 +1,590 @@
+/**
+ * @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(['uglifyjs/index'], function (uglify) {
+    var parser = uglify.parser,
+        processor = uglify.uglify,
+        ostring = Object.prototype.toString,
+        isArray;
+
+    if (Array.isArray) {
+        isArray = Array.isArray;
+    } else {
+        isArray = function (it) {
+            return ostring.call(it) === "[object Array]";
+        };
+    }
+
+    /**
+     * Determines if the AST node is an array literal
+     */
+    function isArrayLiteral(node) {
+        return node[0] === 'array';
+    }
+
+    /**
+     * Determines if the AST node is an object literal
+     */
+    function isObjectLiteral(node) {
+        return node[0] === 'object';
+    }
+
+    /**
+     * Converts a regular JS array of strings to an AST node that
+     * represents that array.
+     * @param {Array} ary
+     * @param {Node} an AST node that represents an array of strings.
+     */
+    function toAstArray(ary) {
+        var output = [
+            'array',
+            []
+        ],
+        i, item;
+
+        for (i = 0; (item = ary[i]); i++) {
+            output[1].push([
+                'string',
+                item
+            ]);
+        }
+
+        return output;
+    }
+
+    /**
+     * Validates a node as being an object literal (like for i18n bundles)
+     * or an array literal with just string members. If an array literal,
+     * only return array members that are full strings. So the caller of
+     * this function should use the return value as the new value for the
+     * node.
+     *
+     * This function does not need to worry about comments, they are not
+     * present in this AST.
+     *
+     * @param {Node} node an AST node.
+     *
+     * @returns {Node} an AST node to use for the valid dependencies.
+     * If null is returned, then it means the input node was not a valid
+     * dependency.
+     */
+    function validateDeps(node) {
+        var newDeps = ['array', []],
+            arrayArgs, i, dep;
+
+        if (!node) {
+            return null;
+        }
+
+        if (isObjectLiteral(node) || node[0] === 'function') {
+            return node;
+        }
+
+        //Dependencies can be an object literal or an array.
+        if (!isArrayLiteral(node)) {
+            return null;
+        }
+
+        arrayArgs = node[1];
+
+        for (i = 0; i < arrayArgs.length; i++) {
+            dep = arrayArgs[i];
+            if (dep[0] === 'string') {
+                newDeps[1].push(dep);
+            }
+        }
+        return newDeps[1].length ? newDeps : null;
+    }
+
+    /**
+     * Gets dependencies from a node, but only if it is an array literal,
+     * and only if the dependency is a string literal.
+     *
+     * This function does not need to worry about comments, they are not
+     * present in this AST.
+     *
+     * @param {Node} node an AST node.
+     *
+     * @returns {Array} of valid dependencies.
+     * If null is returned, then it means the input node was not a valid
+     * array literal, or did not have any string literals..
+     */
+    function getValidDeps(node) {
+        var newDeps = [],
+            arrayArgs, i, dep;
+
+        if (!node) {
+            return null;
+        }
+
+        if (isObjectLiteral(node) || node[0] === 'function') {
+            return null;
+        }
+
+        //Dependencies can be an object literal or an array.
+        if (!isArrayLiteral(node)) {
+            return null;
+        }
+
+        arrayArgs = node[1];
+
+        for (i = 0; i < arrayArgs.length; i++) {
+            dep = arrayArgs[i];
+            if (dep[0] === 'string') {
+                newDeps.push(dep[1]);
+            }
+        }
+        return newDeps.length ? newDeps : null;
+    }
+
+    /**
+     * Main parse function. Returns a string of any valid require or define/require.def
+     * calls as part of one JavaScript source string.
+     * @param {String} moduleName the module name that represents this file.
+     * It is used to create a default define if there is not one already for the file.
+     * This allows properly tracing dependencies for builds. Otherwise, if
+     * the file just has a require() call, the file dependencies will not be
+     * properly reflected: the file will come before its dependencies.
+     * @param {String} moduleName
+     * @param {String} fileName
+     * @param {String} fileContents
+     * @param {Object} options optional options. insertNeedsDefine: true will
+     * add calls to require.needsDefine() if appropriate.
+     * @returns {String} JS source string or null, if no require or define/require.def
+     * calls are found.
+     */
+    function parse(moduleName, fileName, fileContents, options) {
+        options = options || {};
+
+        //Set up source input
+        var moduleDeps = [],
+            result = '',
+            moduleList = [],
+            needsDefine = true,
+            astRoot = parser.parse(fileContents),
+            i, moduleCall, depString;
+
+        parse.recurse(astRoot, function (callName, config, name, deps) {
+            //If name is an array, it means it is an anonymous module,
+            //so adjust args appropriately. An anonymous module could
+            //have a FUNCTION as the name type, but just ignore those
+            //since we just want to find dependencies.
+            if (name && isArrayLiteral(name)) {
+                deps = name;
+                name = null;
+            }
+
+            if (!(deps = getValidDeps(deps))) {
+                deps = [];
+            }
+
+            //Get the name as a string literal, if it is available.
+            if (name && name[0] === 'string') {
+                name = name[1];
+            } else {
+                name = null;
+            }
+
+            if (callName === 'define' && (!name || name === moduleName)) {
+                needsDefine = false;
+            }
+
+            if (!name) {
+                //If there is no module name, the dependencies are for
+                //this file/default module name.
+                moduleDeps = moduleDeps.concat(deps);
+            } else {
+                moduleList.push({
+                    name: name,
+                    deps: deps
+                });
+            }
+
+            //If define was found, no need to dive deeper, unless
+            //the config explicitly wants to dig deeper.
+            return !options.findNestedDependencies;
+        }, options);
+
+        if (options.insertNeedsDefine && needsDefine) {
+            result += 'require.needsDefine("' + moduleName + '");';
+        }
+
+        if (moduleDeps.length || moduleList.length) {
+            for (i = 0; (moduleCall = moduleList[i]); i++) {
+                if (result) {
+                    result += '\n';
+                }
+
+                //If this is the main module for this file, combine any
+                //"anonymous" dependencies (could come from a nested require
+                //call) with this module.
+                if (moduleCall.name === moduleName) {
+                    moduleCall.deps = moduleCall.deps.concat(moduleDeps);
+                    moduleDeps = [];
+                }
+
+                depString = moduleCall.deps.length ? '["' + moduleCall.deps.join('","') + '"]' : '[]';
+                result += 'define("' + moduleCall.name + '",' + depString + ');';
+            }
+            if (moduleDeps.length) {
+                if (result) {
+                    result += '\n';
+                }
+                depString = moduleDeps.length ? '["' + moduleDeps.join('","') + '"]' : '[]';
+                result += 'define("' + moduleName + '",' + depString + ');';
+            }
+        }
+
+        return result ? result : null;
+    }
+
+    //Add some private methods to object for use in derived objects.
+    parse.isArray = isArray;
+    parse.isObjectLiteral = isObjectLiteral;
+    parse.isArrayLiteral = isArrayLiteral;
+
+    /**
+     * Handles parsing a file recursively for require calls.
+     * @param {Array} parentNode the AST node to start with.
+     * @param {Function} onMatch function to call on a parse match.
+     * @param {Object} [options] This is normally the build config options if
+     * it is passed.
+     */
+    parse.recurse = function (parentNode, onMatch, options) {
+        var hasHas = options && options.has,
+            i, node;
+
+        if (isArray(parentNode)) {
+            for (i = 0; i < parentNode.length; i++) {
+                node = parentNode[i];
+                if (isArray(node)) {
+                    //If has config is in play, if calls have been converted
+                    //by this point to be true/false values. So, if
+                    //options has a 'has' value, skip if branches that have
+                    //literal false values.
+
+                    //uglify returns if constructs in an array:
+                    //[0]: 'if'
+                    //[1]: the condition, ['name', true | false] for the has replaced case.
+                    //[2]: the block to process if true
+                    //[3]: the block to process if false
+                    //For if/else if/else, the else if is in the [3],
+                    //so only ever have to deal with this structure.
+                    if (hasHas && node[0] === 'if' && node[1] && node[1][0] === 'name' &&
+                        (node[1][1] === 'true' || node[1][1] === 'false')) {
+                        if (node[1][1] === 'true') {
+                            this.recurse([node[2]], onMatch, options);
+                        } else {
+                            this.recurse([node[3]], onMatch, options);
+                        }
+                    } else {
+                        if (this.parseNode(node, onMatch)) {
+                            //The onMatch indicated parsing should
+                            //stop for children of this node.
+                            continue;
+                        }
+                        this.recurse(node, onMatch, options);
+                    }
+                }
+            }
+        }
+    };
+
+    /**
+     * Determines if the file defines require().
+     * @param {String} fileName
+     * @param {String} fileContents
+     * @returns {Boolean}
+     */
+    parse.definesRequire = function (fileName, fileContents) {
+        var astRoot = parser.parse(fileContents);
+        return this.nodeHasRequire(astRoot);
+    };
+
+    /**
+     * Finds require("") calls inside a CommonJS anonymous module wrapped in a
+     * define(function(require, exports, module){}) wrapper. These dependencies
+     * will be added to a modified define() call that lists the dependencies
+     * on the outside of the function.
+     * @param {String} fileName
+     * @param {String} fileContents
+     * @returns {Array} an array of module names that are dependencies. Always
+     * returns an array, but could be of length zero.
+     */
+    parse.getAnonDeps = function (fileName, fileContents) {
+        var astRoot = parser.parse(fileContents),
+            defFunc = this.findAnonDefineFactory(astRoot);
+
+        return parse.getAnonDepsFromNode(defFunc);
+    };
+
+    /**
+     * Finds require("") calls inside a CommonJS anonymous module wrapped
+     * in a define function, given an AST node for the definition function.
+     * @param {Node} node the AST node for the definition function.
+     * @returns {Array} and array of dependency names. Can be of zero length.
+     */
+    parse.getAnonDepsFromNode = function (node) {
+        var deps = [],
+            funcArgLength;
+
+        if (node) {
+            this.findRequireDepNames(node, deps);
+
+            //If no deps, still add the standard CommonJS require, exports, module,
+            //in that order, to the deps, but only if specified as function args.
+            //In particular, if exports is used, it is favored over the return
+            //value of the function, so only add it if asked.
+            funcArgLength = node[2] && node[2].length;
+            if (funcArgLength) {
+                deps = (funcArgLength > 1 ? ["require", "exports", "module"] :
+                        ["require"]).concat(deps);
+            }
+        }
+        return deps;
+    };
+
+    /**
+     * Finds the function in define(function (require, exports, module){});
+     * @param {Array} node
+     * @returns {Boolean}
+     */
+    parse.findAnonDefineFactory = function (node) {
+        var callback, i, n, call, args;
+
+        if (isArray(node)) {
+            if (node[0] === 'call') {
+                call = node[1];
+                args = node[2];
+                if ((call[0] === 'name' && call[1] === 'define') ||
+                           (call[0] === 'dot' && call[1][1] === 'require' && call[2] === 'def')) {
+
+                    //There should only be one argument and it should be a function,
+                    //or a named module with function as second arg
+                    if (args.length === 1 && args[0][0] === 'function') {
+                        return args[0];
+                    } else if (args.length === 2 && args[0][0] === 'string' &&
+                               args[1][0] === 'function') {
+                        return args[1];
+                    }
+                }
+            }
+
+            //Check child nodes
+            for (i = 0; i < node.length; i++) {
+                n = node[i];
+                if ((callback = this.findAnonDefineFactory(n))) {
+                    return callback;
+                }
+            }
+        }
+
+        return null;
+    };
+
+    /**
+     * Finds all dependencies specified in dependency arrays and inside
+     * simplified commonjs wrappers.
+     * @param {String} fileName
+     * @param {String} fileContents
+     *
+     * @returns {Array} an array of dependency strings. The dependencies
+     * have not been normalized, they may be relative IDs.
+     */
+    parse.findDependencies = function (fileName, fileContents) {
+        //This is a litle bit inefficient, it ends up with two uglifyjs parser
+        //calls. Can revisit later, but trying to build out larger functional
+        //pieces first.
+        var dependencies = parse.getAnonDeps(fileName, fileContents),
+            astRoot = parser.parse(fileContents);
+
+        parse.recurse(astRoot, function (callName, config, name, deps) {
+            //Normalize the input args.
+            if (name && isArrayLiteral(name)) {
+                deps = name;
+                name = null;
+            }
+
+            if ((deps = getValidDeps(deps))) {
+                dependencies = dependencies.concat(deps);
+            }
+        });
+
+        return dependencies;
+    };
+
+    parse.findRequireDepNames = function (node, deps) {
+        var moduleName, i, n, call, args;
+
+        if (isArray(node)) {
+            if (node[0] === 'call') {
+                call = node[1];
+                args = node[2];
+
+                if (call && call[0] === 'name' && call[1] === 'require') {
+                    moduleName = args[0];
+                    if (moduleName[0] === 'string') {
+                        deps.push(moduleName[1]);
+                    }
+                }
+
+
+            }
+
+            //Check child nodes
+            for (i = 0; i < node.length; i++) {
+                n = node[i];
+                this.findRequireDepNames(n, deps);
+            }
+        }
+    };
+
+    /**
+     * Determines if a given node contains a require() definition.
+     * @param {Array} node
+     * @returns {Boolean}
+     */
+    parse.nodeHasRequire = function (node) {
+        if (this.isDefineNode(node)) {
+            return true;
+        }
+
+        if (isArray(node)) {
+            for (var i = 0, n; i < node.length; i++) {
+                n = node[i];
+                if (this.nodeHasRequire(n)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    };
+
+    /**
+     * Is the given node the actual definition of define(). Actually uses
+     * the definition of define.amd to find require.
+     * @param {Array} node
+     * @returns {Boolean}
+     */
+    parse.isDefineNode = function (node) {
+        //Actually look for the define.amd = assignment, since
+        //that is more indicative of RequireJS vs a plain require definition.
+        var assign;
+        if (!node) {
+            return null;
+        }
+
+        if (node[0] === 'assign' && node[1] === true) {
+            assign = node[2];
+            if (assign[0] === 'dot' && assign[1][0] === 'name' &&
+                assign[1][1] === 'define' && assign[2] === 'amd') {
+                return true;
+            }
+        }
+        return false;
+    };
+
+    /**
+     * Determines if a specific node is a valid require or define/require.def call.
+     * @param {Array} node
+     * @param {Function} onMatch a function to call when a match is found.
+     * It is passed the match name, and the config, name, deps possible args.
+     * The config, name and deps args are not normalized.
+     *
+     * @returns {String} a JS source string with the valid require/define call.
+     * Otherwise null.
+     */
+    parse.parseNode = function (node, onMatch) {
+        var call, name, config, deps, args, cjsDeps;
+
+        if (!isArray(node)) {
+            return false;
+        }
+
+        if (node[0] === 'call') {
+            call = node[1];
+            args = node[2];
+
+            if (call) {
+                if (call[0] === 'name' &&
+                   (call[1] === 'require' || call[1] === 'requirejs')) {
+
+                    //It is a plain require() call.
+                    config = args[0];
+                    deps = args[1];
+                    if (isArrayLiteral(config)) {
+                        deps = config;
+                        config = null;
+                    }
+
+                    if (!(deps = validateDeps(deps))) {
+                        return null;
+                    }
+
+                    return onMatch("require", null, null, deps);
+
+                } else if (call[0] === 'name' && call[1] === 'define') {
+
+                    //A define call
+                    name = args[0];
+                    deps = args[1];
+                    //Only allow define calls that match what is expected
+                    //in an AMD call:
+                    //* first arg should be string, array, function or object
+                    //* second arg optional, or array, function or object.
+                    //This helps weed out calls to a non-AMD define, but it is
+                    //not completely robust. Someone could create a define
+                    //function that still matches this shape, but this is the
+                    //best that is possible, and at least allows UglifyJS,
+                    //which does create its own internal define in one file,
+                    //to be inlined.
+                    if (((name[0] === 'string' || isArrayLiteral(name) ||
+                          name[0] === 'function' || isObjectLiteral(name))) &&
+                        (!deps || isArrayLiteral(deps) ||
+                         deps[0] === 'function' || isObjectLiteral(deps) ||
+                         // allow define(['dep'], factory) pattern
+                         (isArrayLiteral(name) && deps[0] === 'name' && args.length === 2))) {
+
+                        //If first arg is a function, could be a commonjs wrapper,
+                        //look inside for commonjs dependencies.
+                        //Also, if deps is a function look for commonjs deps.
+                        if (name && name[0] === 'function') {
+                            cjsDeps = parse.getAnonDepsFromNode(name);
+                            if (cjsDeps.length) {
+                                name = toAstArray(cjsDeps);
+                            }
+                        } else if (deps && deps[0] === 'function') {
+                            cjsDeps = parse.getAnonDepsFromNode(deps);
+                            if (cjsDeps.length) {
+                                deps = toAstArray(cjsDeps);
+                            }
+                        }
+
+                        return onMatch("define", null, name, deps);
+                    }
+                }
+            }
+        }
+
+        return false;
+    };
+
+    /**
+     * Converts an AST node into a JS source string. Does not maintain formatting
+     * or even comments from original source, just returns valid JS source.
+     * @param {Array} node
+     * @returns {String} a JS source string.
+     */
+    parse.nodeToString = function (node) {
+        return processor.gen_code(node, true);
+    };
+
+    return parse;
+});