all files / montage/core/meta/ object-descriptor-reference.js

52% Statements 13/25
36.84% Branches 7/19
66.67% Functions 4/6
52% Lines 13/25
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79                 16×                                                     16×     16×       16× 16× 16× 16× 16×   16× 16× 16×                                                    
var Promise = require("../promise").Promise,
    ObjectDescriptorModule = require("./object-descriptor"),
    ModelModule = require("./model"),
    RemoteReference = require("./remote-reference").RemoteReference,
    ModelReference = require("./model-reference").ModelReference;
 
exports.ObjectDescriptorReference = RemoteReference.specialize( {
 
    constructor: {
        value: function ObjectDescriptorReference() {
            this.superForValue("constructor")();
        }
    },
 
    /**
     * The identifier is the name of the model and is used to make the
     * serialization of models more readable.
     * @type {string}
     * @default this.name
     */
    identifier: {
        get: function () {
            if (!this._reference) {
                this._reference = this.referenceFromValue(this._value);
            }
            return [
                "objectDescriptor",
                (this._reference.objectDescriptorName || this._reference.blueprintName || "unnamed").toLowerCase(),
                "reference"
            ].join("_");
        }
    },
 
    valueFromReference: {
        value: function (references) {
 
            // TODO: references.blueprintModule && references.binderReference are deprecated.
            var objectDescriptorModule = references.objectDescriptorModule || references.blueprintModule,
                modelReference = references.modelReference || references.binderReference,
                modelPromise = Promise.resolve(ModelModule.Model.group.defaultModel);
            Iif (modelReference) {
                modelPromise = ModelReference.prototype.valueFromReference(modelReference, require);
            }
 
            return modelPromise.then(function (model) {
                var ModuleObjectDescriptorModule;
                Eif (model) {
                    ModuleObjectDescriptorModule = require("./module-object-descriptor");
                    return ModuleObjectDescriptorModule.ModuleObjectDescriptor.getObjectDescriptorWithModuleId(objectDescriptorModule.id, objectDescriptorModule.require)
                        .then(function (objectDescriptor) {
                        Eif (objectDescriptor) {
                            model.addObjectDescriptor(objectDescriptor);
                            return objectDescriptor;
                        } else {
                            throw new Error("Error cannot find Object Descriptor " + objectDescriptorModule);
                        }
                    });
                } else {
                    return ObjectDescriptorModule.ObjectDescriptor.getObjectDescriptorWithModuleId(objectDescriptorModule, require);
                }
            });
        }
    },
 
    referenceFromValue: {
        value: function (value) {
            // the value is an object descriptor we need to serialize the object model and the object descriptor reference
            var references = {};
            references.objectDescriptorName = value.name;
            references.objectDescriptorModule = value.objectDescriptorInstanceModule;
            if (value.model && !value.model.isDefault) {
                references.modelReference = ModelReference.prototype.referenceFromValue(value.model);
            }
            return references;
        }
    }
 
});