path: root/node_modules/montage/core/deserializer.js

/* <copyright>
 This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
 No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
 (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
 </copyright> */

/**
    @module montage/core/deserializer
    @requires montage/core/core
    @requires montage/core/core/logger
    @requires montage/core/promise
*/

var Montage = require("montage").Montage,
    logger = require("core/logger").logger("deserializer"),
    Promise = require("core/promise").Promise;

// By rebinding eval to a new name, it loses its ability to
// capture the calling scope.
var globalEval = eval;
var canEval = true;

// CSP doesn't let you eval
try {
    eval("");
} catch(ex) {
    canEval = false;
}

/**
 @class module:montage/core/deserializer.Deserializer
 @extends module:montage/core/core.Montage
 */
var Deserializer = Montage.create(Montage, /** @lends module:montage/core/deserializer.Deserializer# */ {
    _MONTAGE_ID_ATTRIBUTE: {value: "data-montage-id"},

    _objects: {value: null},
   /**
  @private
*/
    _objectStack: {value: []},
    _modules: {value: {}},
 /**
  @private
*/
    _requiredModuleIds: {value: null},
    _objectLabels: {value: null},
/**
  @private
*/
    _serializationString: {value: null, enumerable: false},
 /**
  @private
*/
    _serialization: {value: null, enumerable: false},
 /**
  @private
*/
    _parseFunction: {value: null, enumerable: false},
 /**
  @private
*/
    _deserializationUnits: {value: []},
    // name -> function
/**
  @private
*/

    /**
      @private
    */
    // list of ids that were just created for optimization
    _optimizedIds: {value: Object.create(null)},

    _indexedDeserializationUnits: {value: {}},

    __sharedDocument: {
        value: null
    },

    _sharedDocument: {
        get: function() {
            return this.__cachedDoc ? this.__cachedDoc : (this.__cachedDoc = window.document.implementation.createHTMLDocument(""));
        }
    },
/**
  @private
*/
    _reset: {value: function() {
        this._serializationString = null;
        this._requiredModuleIds = null;
        this._areModulesLoaded = false;
        this._parseFunction = null;
        this._serialization = null;
        this._compiledDeserializationFunction = null;
        this._compiledDeserializationFunctionString = null;
        this._origin = null;
    }},

    /**
     Initializes the deserializer with a string
     @param {String|Object} serialization A string or JSON-style object
     describing the serialized objects.
     @param {Function} require The module loader for the containing package.
     @param {String} origin Usually a file name.
     */
    init: {
        value: function (serialization, require, origin) {
            if (typeof serialization !== "string") {
                serialization = JSON.stringify(serialization);
            }
            this._reset();
            this._serializationString = serialization;
            this._require = require;
            this._origin = origin;
            return this;
        }
    },

    /**
     Initializes the deserializer with a string of serialized objects.
     @function
     @param {String} string A string of serialized objects.
     @param {String} origin The origin of the serialization, usually a filename.
     @returns itself
     */
    initWithString: {value: function(string, origin) {
        this._reset();
        this._serializationString = string;
        this._origin = origin;
        return this;
    }},
    /**
    Initializes the deserializer object with an object representing a serialization. Since the serialization is a JSON string it is also possible to represent it in a JavaScript object.
    @function
    @param {object} object The serialization in JavaScript object form.
    @returns itself
    */
    initWithObject: {value: function(object) {
        this._reset();
        this._serializationString = JSON.stringify(object);
        return this;
    }},

    initWithObjectAndRequire: {value: function(object, require, origin) {
        this._reset();
        this._serializationString = JSON.stringify(object);
        this._require = require;
        this._origin = origin;
        return this;
    }},

    /**
     Initializes the deserializer object with a serialization string and the require object used to load the modules containing the object's prototypes.
     @function
     @param {string} string The serialization string.
     @param {function} require The require function to load the modules.
     @param {string} origin The origin of the serialization, usually a filename.
     @returns itself
     */
    initWithStringAndRequire: {value: function(string, require, origin) {
        this._reset();
        this._serializationString = string;
        this._require = require;
        this._origin = origin;
        return this;
    }},

    /**
     Defines a deserialization unit for an object.
     @function
     @param {string} name The unit name.
     @param {function} funktion The delegate function that reads the serialization unit and deserializes its content into the object being deserialized. This function accepts the object being deserialized and the serialized unit as arguments.
     */
    defineDeserializationUnit: {value: function(name, funktion) {
        this._deserializationUnits.push({
            name: name,
            funktion: this._indexedDeserializationUnits[name] = funktion
        });
    }},

    /**
     Returns an array with all the objects that were created or used during the call to deserializeWith* functions.
     @function
     @returns {Array} The array of objects.
     */
    getObjectsFromLastDeserialization: {value: function() {
        var objects = this._objects;
        var objectsArray = [];

        for (var key in objects) {
            if (objects.hasOwnProperty(key)) {
                objectsArray.push(objects[key]);
            }
        }

        return objectsArray;
    }},

    chainDeserializer: {
        value: function(deserializer) {
            var chainedSerializations = this._chainedSerializations,
                optimizedIds, chainedOptimizedIds;

            if (!chainedSerializations) {
                this._chainedSerializations = chainedSerializations = [];
            }

            chainedSerializations.push({
                string: deserializer._serializationString,
                compiledFunction: deserializer._compiledDeserializationFunction,
                compiledFunctionString: deserializer._compiledDeserializationFunctionString
            });

            // need to copy the optimized ids too, ideally all chained templates are optimized for the same document
            chainedOptimizedIds = deserializer._optimizedIds;
            if (chainedOptimizedIds) {
                if (!optimizedIds) {
                    this._optimizedIds = optimizedIds = {};
                }
                for (var id in chainedOptimizedIds) {
                    optimizedIds[id] = chainedOptimizedIds[id];
                }
            }
        }
    },

    /**
     This function is to be used in the context of deserializeProperties delegate used for custom object deserializations.
     It reads an entry from the "properties" serialization unit of the object being deserialized.
     @function
     @param {string} name The name of the entry to be read.
     @returns {*} The value of the entry
     */
    get: {value: function(name) {
        var stack = this._objectStack;
        var ix = stack.length - 1;

        return stack[ix][name];
    }},

    deserializeProperties: {
        value: function() {
            var stack = this._objectStack,
                ix = stack.length - 1,
                object = stack[ix-1],
                desc = stack[ix];

            this._deserializeProperties(object, desc.properties, false);
        }
    },

    getProperty: {
        value: function(name) {
            var stack = this._objectStack,
                ix = stack.length - 1,
                desc = stack[ix];

            return desc.properties[name];
        }
    },

    deserializeUnits: {
        value: function() {
            var stack = this._objectStack,
                ix = stack.length - 1,
                desc = stack[ix];

            desc._units = this._indexedDeserializationUnits;
        }
    },

    deserializeUnit: {
        value: function(name) {
            var stack = this._objectStack,
                ix = stack.length - 1,
                desc = stack[ix],
                units;

            if (desc._units) {
                units = desc._units;
            } else {
                desc._units = units = {};
            }

            units[name] = this._indexedDeserializationUnits[name];
        }
    },

    getType: {
        value: function() {
            var stack = this._objectStack,
                ix = stack.length - 1,
                desc = stack[ix];

            return "object" in desc ? "object" : ("prototype" in desc ? "prototype" : null);
        }
    },

    getTypeValue: {
        value: function() {
            var stack = this._objectStack,
                ix = stack.length - 1,
                desc = stack[ix];

            return desc.object || desc.prototype;
        }
    },

    getObjectByLabel: {
        value: function(label) {
            return this._objects[label] || this._objectLabels[label];
        }
    },

    _customDeserialization: {
        enumerable: false,
        value: function(object, desc) {
            this._pushContextObject(object);
            this._pushContextObject(desc);
            object.deserializeSelf(this);
            this._popContextObject();
            this._popContextObject();
        }
    },

    /**
    This function is to be used in the context of deserializeProperties delegate used for custom object deserializations.
     It deserializes all the named properties of a serialized object into the object given.
    @function
    @param {Object} object The target of the properties.
    @param {Array} properties The property names to be deserialized.
    */
    deserializePropertiesForObject: {value: function(object, properties, checkSerializableAttribute) {
        if (checkSerializableAttribute) {
            for (var key in properties) {
                if (!Montage.getPropertyAttribute(object, key, "serializable")) {
                    if (Object.getPropertyDescriptor(object, key)) {
                        console.warn("Unserializable property \"" + key + "\" found in the serialization of " + (object._montage_metadata ? object._montage_metadata.objectName : object) + " (" + (this._origin || window.location) + ")");
                    } else {
                        console.warn("Nonexistent (and therefore unserializable) property \"" + key + "\" found in the serialization of " + (object._montage_metadata ? object._montage_metadata.objectName : object) + " (" + (this._origin || window.location) + ")");
                    }
                };
                object[key] = properties[key];
            }
        } else {
            for (var key in properties) {
                object[key] = properties[key];
            }
        }
    }},

    /**
    The function works on the top most object of an object stack.<br>
    This method pushes an object to that stack making it the target of future calls.
    @function
    @param {object} object The object to push into the stack.
    @private
     */
    _pushContextObject: {value: function(object) {
        this._objectStack.push(object);
    }},

    /**
     The function works on the top most object of an object stack.<br>
     This method pops the top most object out of that stack making future calls to target the next object in the stack.
     @function
     @returns {object} The top most object in the stack.
     @private
     */
    _popContextObject: {value: function() {
        return this._objectStack.pop();
    }},
/**
  @private
*/
    _require: {
        enumerable: false,
        value: null
    },
/**
  @private
*/
    _defaultModuleLoader: {
        enumerable: false,
        value: function(moduleIds, callback) {
            if (typeof require !== "function") {
                logger.error("Deserializer: The default module loader needs the global require function to be defined.");
                return;
            }

            var modulesLoaded = 0,
                modules = {},
                _require = this._require;

            moduleIds.forEach(function(moduleId) {
                if (callback) {
                    Promise.when(_require.async(moduleId),
                        function(module) {
                            modules[moduleId] = module;
                            if (++modulesLoaded === moduleIds.length) {
                                callback(modules);
                            }
                        },
                        function(reason, error) {
                            console.log(error.stack);
                        }
                    );
                } else {
                    modules[moduleId] = _require(moduleId);
                }
            });

            if (!callback) {
                return modules;
            }
        }
    },

    /**
     Load modules.
     @param {Array} moduleIds The module ids to be loaded.
     @param {Function} callback The function to invoke when the modules are all loaded, passing this parameter makes this function asynchronous.
     @private
     */
    _areModulesLoaded: {value: false},
 /**
  @private
*/
    _areModulesLoading: {value: false},
/**
  @private
*/
    ___loadModulesCallbacks: {value: null},
/**
  @private
*/
    _loadModules: {
        enumerable: false,
        value: function(moduleIds, callback) {
            if (this._areModulesLoaded || moduleIds.length === 0) {
                if (callback) {
                    callback();
                }
            } else if (this._areModulesLoading) {
                this.___loadModulesCallbacks.push(callback);
            } else {
                var self = this;
                var moduleLoader = this._moduleLoader || this._defaultModuleLoader;

                this.___loadModulesCallbacks = [callback];
                this._areModulesLoading = true;
                // will add it as a Deserializer property if it's needed in the future (saves a closure creation for setting the "this")
                function addModules(newModules) {
                    var modules = self._modules;

                    if (!modules) {
                        modules = self._modules = {};
                    }
                    for (var moduleId in newModules) {
                        if (newModules.hasOwnProperty(moduleId)) {
                            modules[moduleId] = newModules[moduleId];
                        }
                    }

                    self._areModulesLoaded = true;
                    self._areModulesLoading = false;
                    self.___loadModulesCallbacks.forEach(function(callback) {
                        if (callback) {
                            callback();
                        }
                    });
                    self.___loadModulesCallbacks = null;
                }

                if (callback) {
                    moduleLoader.call(this, moduleIds, addModules);
                } else {
                    addModules(moduleLoader.call(this, moduleIds));
                }
            }
        }
    },
/**
  @private
*/
    _prepareForDeserialization: {value: function(callback) {
        if (this._areModulesLoaded) {
            return callback();
        }

        if (!this._compiledDeserializationFunctionString) {
            try {
                this._serialization = JSON.parse(this._serializationString);
            } catch (ex) {
                if (logger.isError) {
                    this._reportParseError(this._serializationString, this._origin);
                    return callback();
                }
            }
            this._parseForModules();
        }

        if (this._requiredModuleIds.length > 0) {
            this._loadModules(this._requiredModuleIds, callback);
        } else {
            this._areModulesLoaded = true;
            return callback();
        }
    }},

    /**
     Sets the module loader used during deserialization.
     @function
     @param {Function} loader The function that will load all module's found in the Array. The Array is composed of module id's to be loaded. When all modules are loaded the callback function should be invoked with an object that maps each module id to its corresponding module object, (e.g.: {"montage/ui/component": <the component module>}).
     */
    setModuleLoader: {value: function(loader) {
        this._moduleLoader = loader;
    }},
/**
  @private
*/
    _findObjectNameRegExp: {
        value: /([^\/]+?)(\.reel)?$/
    },
    _toCamelCaseRegExp: {
        value: /(?:^|-)([^-])/g
    },
    _replaceToCamelCase: {
        value: function(_, g1) { return g1.toUpperCase() }
    },
    _parseForModules: {value: function() {
        var serialization = this._serialization,
            moduleIds = this._requiredModuleIds = [],
            modules = this._modules,
            desc, moduleId, name, objectLocation;

        for (var label in serialization) {
            desc = serialization[label];
            moduleId = null;

            if ("module" in desc) {
                moduleId = desc.module;
            } else if ("prototype" in desc || "object" in desc) {
                name = desc.prototype || desc.object
                objectLocation = name.split("[");
                moduleId = objectLocation[0];
                desc.module = moduleId;
                if (objectLocation.length == 2) {
                    desc.name = objectLocation[1].slice(0, -1);
                } else {
                    this._findObjectNameRegExp.test(moduleId);
                    desc.name = RegExp.$1.replace(this._toCamelCaseRegExp, this._replaceToCamelCase);
                }
            }

            if (moduleId && !modules[moduleId] && moduleIds.indexOf(moduleId) == -1) {
                moduleIds.push(moduleId);
            }
        }
    }},
/**
  @private
*/
    _compile: {value: function() {
        this._prepareForDeserialization();
        this._compileAndDeserialize();
        return this._compiledDeserializationFunctionString;
    }},

    /**
     * Optimizes the current serialization for a specific document.
     * @function
     * @param {Document} doc The document to optimize against, this document can be modified during optimization.
    */
    optimizeForDocument: {
        value: function(doc) {
            var idAttributeName = Deserializer._MONTAGE_ID_ATTRIBUTE,
                elements = doc.querySelectorAll('*[' + idAttributeName + ']'),
                ids = this._optimizedIds = Object.create(null);

            for (var i = 0, element; (element = elements[i]); i++) {
                if (!element.id) {
                    var attribute = element.getAttribute(idAttributeName);
                    element.setAttribute("id", ids[attribute] = "_" + idAttributeName + "_" + attribute);
                }
            }
        }
    },

    _labelRegexp: {
        enumerable: false,
        value: /^[a-zA-Z_$][0-9a-zA-Z_$]*$/
    },

/**
  @private
*/
    _compileAndDeserialize: {value: function(element, serialization, exports, deserialize) {
        var self = this,
            exportsStrings = "",
            unitsStrings = "",
            objectsStrings = "",
            cleanupStrings = "",
            valueString,
            deserialized = {},
            modules = this._modules,
            idsToRemove = [],
            optimizedIds = this._optimizedIds,
            compiledDeserializationFunctionString,
            requireStrings = [],
            objectNamesCounter = {},
            label,
            labelRegexp = this._labelRegexp;

        if (canEval) {
            serialization = this._serialization;
        } else {
            serialization = JSON.parse(this._serializationString);
        }

        for (label in serialization) {
            if (!labelRegexp.test(label)) {
                logger.error("Invalid label format '" + label + "' " + (this._origin ? " in " + this._origin : ""));
                throw "Invalid label format: " + label;
            }
            var objectDesc = serialization[label];

            if (label in deserialized) {
                // already deserialized, in a reference most likely
                continue;
            }

            if ("value" in objectDesc) {
                valueString = deserializeValue(objectDesc.value, objectDesc, "value");
                exportsStrings += 'var ' + label + ' = exports.' + label + ' = ' + valueString + ';\n';
                if (deserialize) {
                    exports[label] = objectDesc.value;
                    deserialized[label] = true;
                }
                // kind of lame but it's just to prevent the need to check whether it's a value or an object in the next serialization loop to deserialize the units.
                delete serialization[label];
            } else {
                deserializeObject(label, objectDesc);
            }
        }

        if (deserialize) {
            for (label in serialization) {
                self._deserializeUnits(exports[label], serialization[label]);
            }
            for (label in serialization) {
                delete exports[label].isDeserializing;
            }
        }

        if (idsToRemove.length > 0) {
            cleanupStrings += 'element.getElementById("' + idsToRemove.join('").removeAttribute("id");\nelement.getElementById("') + '").removeAttribute("id");';
            for (var i = 0, id; (id = idsToRemove[i]); i++) {
                element.getElementById(idsToRemove[i]).removeAttribute("id");
            }
        }

        if (canEval) {
            compiledDeserializationFunctionString = "(function() {\n" + requireStrings.join("\n") + "\nreturn function(element, exports) {\n" + exportsStrings + "\n\n" + objectsStrings + "\n\n" + unitsStrings + "\n\n" + cleanupStrings + "\nreturn exports;\n}}).call(this)";
        }
        if (logger.isDebug) {
            logger.debug(compiledDeserializationFunctionString);
        }

        return compiledDeserializationFunctionString;