remove passing factories to store methods

Previously, we allowed users to either pass factories (subclasses of
DS.Model), or a string to store methods. For more consistency in the
container-based world where things are looked up through strings,
support for looking up via passing a factory has been removed.

This is part of a refactor that will remove state (like the store)
from Ember Data's factories in order to remove
Ember.MODEL_FACTORY_INJECTIONS.

packages/activemodel-adapter/lib/system/active-model-serializer.js

@@ -117,12 +117,12 @@ var ActiveModelSerializer = RESTSerializer.extend({
     relationship keys.
 
     @method keyForRelationship
-    @param {String} relationshipTypeKey
+    @param {String} relationshipModelName
     @param {String} kind
     @return String
   */
-  keyForRelationship: function(relationshipTypeKey, kind) {
-    var key = decamelize(relationshipTypeKey);
+  keyForRelationship: function(relationshipModelName, kind) {
+    var key = decamelize(relationshipModelName);
     if (kind === "belongsTo") {
       return key + "_id";
     } else if (kind === "hasMany") {

packages/activemodel-adapter/tests/integration/active-model-serializer-namespaced-modelname-test.js

@@ -6,34 +6,35 @@ module("integration/active_model - AMS-namespaced-model-names", {
     SuperVillain = DS.Model.extend({
       firstName:     DS.attr('string'),
       lastName:      DS.attr('string'),
-      evilMinions:   DS.hasMany("evilMinion")
+      evilMinions:   DS.hasMany('evil-minion')
     });
 
     EvilMinion = DS.Model.extend({
-      superVillain: DS.belongsTo('superVillain'),
+      superVillain: DS.belongsTo('super-villain'),
       name:         DS.attr('string')
     });
     YellowMinion = EvilMinion.extend();
     DoomsdayDevice = DS.Model.extend({
       name:         DS.attr('string'),
-      evilMinion:   DS.belongsTo('evilMinion', { polymorphic: true })
+      evilMinion:   DS.belongsTo('evil-minion', { polymorphic: true })
     });
     MediocreVillain = DS.Model.extend({
       name:         DS.attr('string'),
-      evilMinions:  DS.hasMany('evilMinion', { polymorphic: true })
+      evilMinions:  DS.hasMany('evil-minion', { polymorphic: true })
     });
     env = setupStore({
       superVillain:   SuperVillain,
       evilMinion:     EvilMinion,
       'evilMinions/yellowMinion':   YellowMinion,
       doomsdayDevice: DoomsdayDevice,
-      mediocreVillain: MediocreVillain
+      mediocreVillain: MediocreVillain,
+      yellowMinion: YellowMinion
     });
-    env.store.modelFor('superVillain');
-    env.store.modelFor('evilMinion');
-    env.store.modelFor('evilMinions/yellowMinion');
-    env.store.modelFor('doomsdayDevice');
-    env.store.modelFor('mediocreVillain');
+    env.store.modelFor('super-villain');
+    env.store.modelFor('evil-minion');
+    env.store.modelFor('evil-minions/yellow-minion');
+    env.store.modelFor('doomsday-device');
+    env.store.modelFor('mediocre-villain');
     env.registry.register('serializer:application', DS.ActiveModelSerializer);
     env.registry.register('serializer:-active-model', DS.ActiveModelSerializer);
     env.registry.register('adapter:-active-model', DS.ActiveModelAdapter);
@@ -49,8 +50,8 @@ module("integration/active_model - AMS-namespaced-model-names", {
 test("serialize polymorphic", function() {
   var tom, ray;
   run(function() {
-    tom = env.store.createRecord('evilMinions/yellowMinion', { name: "Alex", id: "124" });
-    ray = env.store.createRecord(DoomsdayDevice, { evilMinion: tom, name: "DeathRay" });
+    tom = env.store.createRecord('evil-minions/yellow-minion', { name: "Alex", id: "124" });
+    ray = env.store.createRecord('doomsday-device', { evilMinion: tom, name: "DeathRay" });
   });
 
   var json = env.amsSerializer.serialize(ray._createSnapshot());
@@ -66,8 +67,8 @@ test("serialize polymorphic when type key is not camelized", function() {
   YellowMinion.modelName = 'evil-minions/yellow-minion';
   var tom, ray;
   run(function() {
-    tom = env.store.createRecord(YellowMinion, { name: "Alex", id: "124" });
-    ray = env.store.createRecord(DoomsdayDevice, { evilMinion: tom, name: "DeathRay" });
+    tom = env.store.createRecord('yellow-minion', { name: "Alex", id: "124" });
+    ray = env.store.createRecord('doomsday-device', { evilMinion: tom, name: "DeathRay" });
   });
 
   var json = env.amsSerializer.serialize(ray._createSnapshot());

packages/activemodel-adapter/tests/integration/active-model-serializer-test.js

@@ -7,25 +7,25 @@ module("integration/active_model - ActiveModelSerializer", {
     SuperVillain = DS.Model.extend({
       firstName:     DS.attr('string'),
       lastName:      DS.attr('string'),
-      homePlanet:    DS.belongsTo("homePlanet"),
-      evilMinions:   DS.hasMany("evilMinion")
+      homePlanet:    DS.belongsTo('home-planet'),
+      evilMinions:   DS.hasMany('evil-minion')
     });
     HomePlanet = DS.Model.extend({
       name:          DS.attr('string'),
-      superVillains: DS.hasMany('superVillain', { async: true })
+      superVillains: DS.hasMany('super-villain', { async: true })
     });
     EvilMinion = DS.Model.extend({
-      superVillain: DS.belongsTo('superVillain'),
+      superVillain: DS.belongsTo('super-villain'),
       name:         DS.attr('string')
     });
     YellowMinion = EvilMinion.extend();
     DoomsdayDevice = DS.Model.extend({
       name:         DS.attr('string'),
-      evilMinion:   DS.belongsTo('evilMinion', { polymorphic: true })
+      evilMinion:   DS.belongsTo('evil-minion', { polymorphic: true })
     });
     MediocreVillain = DS.Model.extend({
       name:         DS.attr('string'),
-      evilMinions:  DS.hasMany('evilMinion', { polymorphic: true })
+      evilMinions:  DS.hasMany('evil-minion', { polymorphic: true })
     });
     env = setupStore({
       superVillain:   SuperVillain,
@@ -35,12 +35,12 @@ module("integration/active_model - ActiveModelSerializer", {
       doomsdayDevice: DoomsdayDevice,
       mediocreVillain: MediocreVillain
     });
-    env.store.modelFor('superVillain');
-    env.store.modelFor('homePlanet');
-    env.store.modelFor('evilMinion');
-    env.store.modelFor('yellowMinion');
-    env.store.modelFor('doomsdayDevice');
-    env.store.modelFor('mediocreVillain');
+    env.store.modelFor('super-villain');
+    env.store.modelFor('home-planet');
+    env.store.modelFor('evil-minion');
+    env.store.modelFor('yellow-minion');
+    env.store.modelFor('doomsday-device');
+    env.store.modelFor('mediocre-villain');
     env.registry.register('serializer:application', DS.ActiveModelSerializer);
     env.registry.register('serializer:-active-model', DS.ActiveModelSerializer);
     env.registry.register('adapter:-active-model', DS.ActiveModelAdapter);
@@ -56,8 +56,8 @@ module("integration/active_model - ActiveModelSerializer", {
 test("serialize", function() {
   var tom;
   run(function() {
-    league = env.store.createRecord(HomePlanet, { name: "Villain League", id: "123" });
-    tom           = env.store.createRecord(SuperVillain, { firstName: "Tom", lastName: "Dale", homePlanet: league });
+    league = env.store.createRecord('home-planet', { name: "Villain League", id: "123" });
+    tom           = env.store.createRecord('super-villain', { firstName: "Tom", lastName: "Dale", homePlanet: league });
   });
 
   var json = env.amsSerializer.serialize(tom._createSnapshot());
@@ -71,7 +71,7 @@ test("serialize", function() {
 
 test("serializeIntoHash", function() {
   run(function() {
-    league = env.store.createRecord(HomePlanet, { name: "Umber", id: "123" });
+    league = env.store.createRecord('home-planet', { name: "Umber", id: "123" });
   });
   var json = {};
 
@@ -87,7 +87,7 @@ test("serializeIntoHash", function() {
 test("serializeIntoHash with decamelized types", function() {
   HomePlanet.modelName = 'home-planet';
   run(function() {
-    league = env.store.createRecord(HomePlanet, { name: "Umber", id: "123" });
+    league = env.store.createRecord('home-planet', { name: "Umber", id: "123" });
   });
   var json = {};
 
@@ -103,7 +103,7 @@ test("serializeIntoHash with decamelized types", function() {
 
 test("normalize", function() {
   SuperVillain.reopen({
-    yellowMinion: DS.belongsTo('yellowMinion')
+    yellowMinion: DS.belongsTo('yellow-minion')
   });
 
   var superVillain_hash = { first_name: "Tom", last_name: "Dale", home_planet_id: "123", evil_minion_ids: [1,2] };
@@ -156,7 +156,7 @@ test("extractSingle", function() {
   });
 
   run(function() {
-    env.store.find("superVillain", 1).then(function(minion) {
+    env.store.find('super-villain', 1).then(function(minion) {
       equal(minion.get('firstName'), "Tom");
     });
   });
@@ -182,7 +182,7 @@ test("extractArray", function() {
   }]);
 
   run(function() {
-    env.store.find("superVillain", 1).then(function(minion) {
+    env.store.find('super-villain', 1).then(function(minion) {
       equal(minion.get('firstName'), "Tom");
     });
   });
@@ -191,8 +191,8 @@ test("extractArray", function() {
 test("serialize polymorphic", function() {
   var tom, ray;
   run(function() {
-    tom = env.store.createRecord(YellowMinion, { name: "Alex", id: "124" });
-    ray = env.store.createRecord(DoomsdayDevice, { evilMinion: tom, name: "DeathRay" });
+    tom = env.store.createRecord('yellow-minion', { name: "Alex", id: "124" });
+    ray = env.store.createRecord('doomsday-device', { evilMinion: tom, name: "DeathRay" });
   });
 
   var json = env.amsSerializer.serialize(ray._createSnapshot());
@@ -208,8 +208,8 @@ test("serialize polymorphic when type key is not camelized", function() {
   YellowMinion.modelName = 'yellow-minion';
   var tom, ray;
   run(function() {
-    tom = env.store.createRecord(YellowMinion, { name: "Alex", id: "124" });
-    ray = env.store.createRecord(DoomsdayDevice, { evilMinion: tom, name: "DeathRay" });
+    tom = env.store.createRecord('yellow-minion', { name: "Alex", id: "124" });
+    ray = env.store.createRecord('doomsday-device', { evilMinion: tom, name: "DeathRay" });
   });
 
   var json = env.amsSerializer.serialize(ray._createSnapshot());
@@ -220,7 +220,7 @@ test("serialize polymorphic when type key is not camelized", function() {
 test("serialize polymorphic when associated object is null", function() {
   var ray, json;
   run(function() {
-    ray = env.store.createRecord(DoomsdayDevice, { name: "DeathRay" });
+    ray = env.store.createRecord('doomsday-device', { name: "DeathRay" });
     json = env.amsSerializer.serialize(ray._createSnapshot());
   });
 

packages/ember-data/lib/serializers/embedded-records-mixin.js

@@ -336,7 +336,7 @@ var EmbeddedRecordsMixin = Ember.Mixin.create({
       var parentRecord = snapshot.type.inverseFor(relationship.key);
       if (parentRecord) {
         var name = parentRecord.name;
-        var embeddedSerializer = this.store.serializerFor(embeddedSnapshot.type);
+        var embeddedSerializer = this.store.serializerFor(embeddedSnapshot.modelName);
         var parentKey = embeddedSerializer.keyForRelationship(name, parentRecord.kind, 'deserialize');
         if (parentKey) {
           delete json[parentKey];
@@ -423,7 +423,7 @@ function extractEmbeddedHasMany(store, key, embeddedTypeClass, hash) {
   var embeddedSerializer = store.serializerFor(embeddedTypeClass.modelName);
   forEach(hash[key], function(data) {
     var embeddedRecord = embeddedSerializer.normalize(embeddedTypeClass, data, null);
-    store.push(embeddedTypeClass, embeddedRecord);
+    store.push(embeddedTypeClass.modelName, embeddedRecord);
     ids.push(embeddedRecord.id);
   });
 
@@ -445,7 +445,7 @@ function extractEmbeddedHasManyPolymorphic(store, key, hash) {
     var primaryKey = get(embeddedSerializer, 'primaryKey');
 
     var embeddedRecord = embeddedSerializer.normalize(embeddedTypeClass, data, null);
-    store.push(embeddedTypeClass, embeddedRecord);
+    store.push(embeddedTypeClass.modelName, embeddedRecord);
     ids.push({ id: embeddedRecord[primaryKey], type: modelName });
   });
 
@@ -460,7 +460,7 @@ function extractEmbeddedBelongsTo(store, key, embeddedTypeClass, hash) {
 
   var embeddedSerializer = store.serializerFor(embeddedTypeClass.modelName);
   var embeddedRecord = embeddedSerializer.normalize(embeddedTypeClass, hash[key], null);
-  store.push(embeddedTypeClass, embeddedRecord);
+  store.push(embeddedTypeClass.modelName, embeddedRecord);
 
   hash[key] = embeddedRecord.id;
   //TODO Need to add a reference to the parent later so relationship works between both `belongsTo` records
@@ -479,7 +479,7 @@ function extractEmbeddedBelongsToPolymorphic(store, key, hash) {
   var primaryKey = get(embeddedSerializer, 'primaryKey');
 
   var embeddedRecord = embeddedSerializer.normalize(embeddedTypeClass, data, null);
-  store.push(embeddedTypeClass, embeddedRecord);
+  store.push(embeddedTypeClass.modelName, embeddedRecord);
 
   hash[key] = embeddedRecord[primaryKey];
   hash[key + 'Type'] = modelName;

packages/ember-data/lib/serializers/json-serializer.js

@@ -729,7 +729,7 @@ export default Serializer.extend({
     @return {Object} json The deserialized payload
   */
   extract: function(store, typeClass, payload, id, requestType) {
-    this.extractMeta(store, typeClass, payload);
+    this.extractMeta(store, typeClass.modelName, payload);
 
     var specificExtract = "extract" + requestType.charAt(0).toUpperCase() + requestType.substr(1);
     return this[specificExtract](store, typeClass, payload, id, requestType);

packages/ember-data/lib/serializers/rest-serializer.js

@@ -267,14 +267,14 @@ var RESTSerializer = JSONSerializer.extend({
     var primaryRecord;
 
     for (var prop in payload) {
-      var typeName  = this.modelNameFromPayloadKey(prop);
+      var modelName = this.modelNameFromPayloadKey(prop);
 
-      if (!store.modelFactoryFor(typeName)) {
-        Ember.warn(this.warnMessageNoModelForKey(prop, typeName), false);
+      if (!store.modelFactoryFor(modelName)) {
+        Ember.warn(this.warnMessageNoModelForKey(prop, modelName), false);
         continue;
       }
-      var type = store.modelFor(typeName);
-      var isPrimary = type.modelName === primaryTypeClassName;
+      var typeClass = store.modelFor(modelName);
+      var isPrimary = typeClass.modelName === primaryTypeClassName;
       var value = payload[prop];
 
       if (value === null) {
@@ -290,10 +290,9 @@ var RESTSerializer = JSONSerializer.extend({
       /*jshint loopfunc:true*/
       forEach.call(value, function(hash) {
         var typeName = this.modelNameFromPayloadKey(prop);
-        var type = store.modelFor(typeName);
-        var typeSerializer = store.serializerFor(type);
+        var typeSerializer = store.serializerFor(typeName);
 
-        hash = typeSerializer.normalize(type, hash, prop);
+        hash = typeSerializer.normalize(typeClass, hash, prop);
 
         var isFirstCreatedRecord = isPrimary && !recordId && !primaryRecord;
         var isUpdatedRecord = isPrimary && coerceId(hash.id) === recordId;
@@ -307,7 +306,7 @@ var RESTSerializer = JSONSerializer.extend({
         if (isFirstCreatedRecord || isUpdatedRecord) {
           primaryRecord = hash;
         } else {
-          store.push(typeName, hash);
+          store.push(modelName, hash);
         }
       }, this);
     }
@@ -435,7 +434,7 @@ var RESTSerializer = JSONSerializer.extend({
         continue;
       }
       var type = store.modelFor(typeName);
-      var typeSerializer = store.serializerFor(type);
+      var typeSerializer = store.serializerFor(typeName);
       var isPrimary = (!forcedSecondary && (type.modelName === primaryTypeClassName));
 
       /*jshint loopfunc:true*/
@@ -493,12 +492,12 @@ var RESTSerializer = JSONSerializer.extend({
         Ember.warn(this.warnMessageNoModelForKey(prop, modelName), false);
         continue;
       }
-      var type = store.modelFor(modelName);
-      var typeSerializer = store.serializerFor(type);
+      var typeClass = store.modelFor(modelName);
+      var typeSerializer = store.serializerFor(modelName);
 
       /*jshint loopfunc:true*/
       var normalizedArray = map.call(Ember.makeArray(payload[prop]), function(hash) {
-        return typeSerializer.normalize(type, hash, prop);
+        return typeSerializer.normalize(typeClass, hash, prop);
       }, this);
 
       store.pushMany(modelName, normalizedArray);

packages/ember-data/lib/system/debug/debug-adapter.js

@@ -42,7 +42,11 @@ export default Ember.DataAdapter.extend({
     return columns;
   },
 
-  getRecords: function(modelName) {
+  getRecords: function(modelNameOrFactory) {
+    // TODO: Ask Teddy what we should do here.
+    // Ideally this should always get passed a string.
+
+    var modelName = typeof modelNameOrFactory === 'string' ? modelNameOrFactory : modelNameOrFactory.modelName;
     return this.get('store').all(modelName);
   },
 

packages/ember-data/lib/system/many-array.js

@@ -228,7 +228,7 @@ export default Ember.Object.extend(Ember.MutableArray, Ember.Evented, {
 
     Ember.assert("You cannot add '" + type.modelName + "' records to this polymorphic relationship.", !get(this, 'isPolymorphic'));
 
-    record = store.createRecord(type, hash);
+    record = store.createRecord(type.modelName, hash);
     this.pushObject(record);
 
     return record;

packages/ember-data/lib/system/model/model.js

@@ -29,13 +29,13 @@ var _splitOnDotCache = Ember.create(null);
 
 function splitOnDot(name) {
   return _splitOnDotCache[name] || (
-    _splitOnDotCache[name] = name.split('.')
+    (_splitOnDotCache[name] = name.split('.'))
   );
 }
 
 function extractPivotName(name) {
   return _extractPivotNameCache[name] || (
-    _extractPivotNameCache[name] = splitOnDot(name)[0]
+    (_extractPivotNameCache[name] = splitOnDot(name)[0])
   );
 }
 

packages/ember-data/lib/system/normalize-type-key.js

@@ -0,0 +1,16 @@
+import {singularize} from 'ember-inflector/lib/system/string';
+
+var dasherize = Ember.String.dasherize;
+var camelize  = Ember.String.camelize;
+
+/**
+  All modelNames are dasherized internally. Changing this function may
+  require changes to other normalization hooks (such as typeForRoot).
+  @method normalizeModelName
+  @private
+  @param {String} type
+  @return {String} if the adapter can generate one, an ID
+*/
+export default function normalizeModelName(modelName) {
+  return singularize(dasherize(camelize(modelName)));
+}