Support regular relations as well WIP.

Author: marcus-nl

ember-schema-loader.js

@@ -4,6 +4,12 @@ var SchemaLoader;
   var STATE_NEW =      'new';
   var STATE_CREATING = 'creating';
   var STATE_DONE =     'done';
+  
+  var KIND_ONE =       'one';
+  var KIND_MANY =      'many';
+
+  var MODE_NORMAL =    'normal';
+  var MODE_FRAGMENT =  'fragment';
 
   SchemaLoader = Ember.Object.extend({
 
@@ -13,17 +19,24 @@ var SchemaLoader;
 
     index: Ember.Map.create(),
 
+    /**
+     * @method init
+     */
     init: function() {
       this._super();
       this.target = this.target || this;
     },
 
+    /**
+     * @method load
+     */
     load: function(schema) {
       var loader = this;
 
       var classes = schema.EmberSchema.classes;
       classes.forEach(function(def) {
         def.state = STATE_NEW;
+        def.mode = loader.getClassMode(def);
         loader.index.set(def.name, def);
       });
 
@@ -32,6 +45,10 @@ var SchemaLoader;
       });
     },
 
+    /** 
+     * @private
+     * @method getClass 
+     **/
     getClass: function(name) {
       if (!this.target[name]) {
         var def = this.index.get(name); 
@@ -45,6 +62,10 @@ var SchemaLoader;
       return result;
     },
 
+    /** 
+     * @private
+     * @method registerClass 
+     **/
     registerClass: function(def) {
       Ember.assert("Circular dependency: " + name, def.state != STATE_CREATING);
       if (def.state == STATE_DONE) return;
@@ -59,51 +80,106 @@ var SchemaLoader;
         this.container.register('model:' + alias, cls);
       }
 
-//      printClass(cls);
+      printClass(cls);
       def.state = STATE_DONE;
     },
 
+    /** 
+     * @private
+     * @method createClass 
+     **/
     createClass: function(def) {
       var loader = this;
       var props = {
         '$type': DS.attr('string'),
       };
       def.props.forEach(function(prop) {
         if (loader.includeProperty(def, prop)) {
-          props[prop.name] = loader.createProperty(prop.type);
+          props[prop.name] = loader.createProperty(def, prop);
         }
       });
 
       var baseType = loader.getBaseClass(def);
       return baseType.extend(props);
     },
 
+    /** 
+     * @private
+     * @method getBaseClass 
+     **/
     getBaseClass: function(def) {
       var loader = this;
 
-      if (def.name == 'Spec') {
-        return DS.Model;
-      }
       if (def.superType) {
         var superType = loader.getClass(def.superType);
         Ember.assert('Super type "' + def.superType + '" does not exist', superType);
 
         return superType;
       }
-      return DS.ModelFragment;
+      
+      if (def.mode == 'fragment') {
+        return DS.ModelFragment;
+      }
+      else {
+        return DS.Model;
+      }
     },
 
-    includeProperty: function(def, prop) {
+    /** 
+     * @protected
+     * @method includeProperty 
+     **/
+    getClassMode: function(def) {
+      return MODE_NORMAL;
+    },
+    
+    /** 
+     * @protected
+     * @method includeProperty 
+     **/
+    includeProperty: function(owner, prop) {
       return prop.name != 'id';
     },
 
-    createProperty: function(type) {
+    /** 
+     * @private
+     * @method createProperty 
+     **/
+    createProperty: function(owner, prop) {
+      if (prop.type.kind == 'attr') {
+        return this.createAttributeProperty(owner, prop);
+      }
+      var typeDef = this.index.get(prop.type.name);
+      if (typeDef.mode == MODE_FRAGMENT) {
+        return this.createFragmentProperty(owner, prop);
+      }
+      else if (typeDef.mode == MODE_NORMAL) {
+        return this.createDefaultProperty(owner, prop);
+      }
+      else {
+        throw 'unsupported: ' + typeDef.mode;
+      }
+    },
+    
+    createAttributeProperty: function(owner, prop) {
+      return DS.attr(prop.type.name);
+    },
+    
+    createDefaultProperty: function(owner, prop) {
+      var opts = {}; // polymorphic: true, typeKey: '$type' };
+      switch (prop.type.kind) {
+        case KIND_ONE:  return DS.belongsTo(prop.type.name, opts);
+        case KIND_MANY: return DS.hasMany(prop.type.name, opts);
+        default:        throw 'unsupported: ' + prop.type.kind;
+      }
+    },
+    
+    createFragmentProperty: function(owner, prop) {
       var opts = { polymorphic: true, typeKey: '$type' };
-      switch (type.kind) {
-        case 'attr': return DS.attr(type.name);
-        case 'one':  return DS.hasOneFragment(type.name, opts);
-        case 'many': return DS.hasManyFragments(type.name, opts);
-        default:     throw 'unsupported: ' + type.kind;
+      switch (prop.type.kind) {
+        case KIND_ONE:  return DS.hasOneFragment(prop.type.name, opts);
+        case KIND_MANY: return DS.hasManyFragments(prop.type.name, opts);
+        default:        throw 'unsupported: ' + prop.type.kind;
       }
     },
   });