Merge pull request #66 from pixelhandler/container-deprecation

Use owner API instead of this.container (deprecated in 2.3)

Author: pixelhandler

addon/adapters/application.js

@@ -115,7 +115,8 @@ export default Ember.Object.extend(FetchMixin, Ember.Evented, {
       type = resource.type;
     }
     // use resource's service if in container, otherwise use this service to fetch
-    let service = this.container.lookup('service:' + pluralize(type)) || this;
+    let owner = (typeof Ember.getOwner === 'function') ? Ember.getOwner(this) : this.container;
+    let service = owner.lookup('service:' + pluralize(type)) || this;
     url = this.fetchUrl(url);
     return service.fetch(url, { method: 'GET' });
   },

addon/initializers/model-setup.js

@@ -0,0 +1,21 @@
+/**
+  @module ember-jsonapi-resources
+  @submodule initializers
+**/
+
+/**
+  Initializer for the model factories, registers option to not initialize
+
+  @method initialize
+  @for Resource
+*/
+export function initialize(application) {
+  if (typeof application.registerOptionsForType === 'function') {
+    application.registerOptionsForType('model', { instantiate: false });
+  }
+}
+
+export default {
+  name: 'model-setup',
+  initialize
+};

addon/models/resource.js

@@ -10,6 +10,8 @@ import hasOne from 'ember-jsonapi-resources/utils/has-one';
 import hasMany from 'ember-jsonapi-resources/utils/has-many';
 import { isType } from 'ember-jsonapi-resources/utils/is';
 
+const { computed, Logger } = Ember;
+
 /**
   A Resource class to create JSON API resource objects
 
@@ -230,7 +232,7 @@ const Resource = Ember.Object.extend({
     @method changedAttributes
     @return {Object} the changed attributes
   */
-  changedAttributes: Ember.computed('attributes', {
+  changedAttributes: computed('attributes', {
     get: function () {
       const attrs = {};
       for (let key in this._attributes) {
@@ -248,7 +250,7 @@ const Resource = Ember.Object.extend({
     @method previousAttributes
     @return {Object} the previous attributes
   */
-  previousAttributes: Ember.computed('attributes', {
+  previousAttributes: computed('attributes', {
     get: function () {
       const attrs = {};
       for (let key in this._attributes) {
@@ -347,7 +349,7 @@ const Resource = Ember.Object.extend({
     @property isCacheExpired
     @type Boolean
   */
-  isCacheExpired: Ember.computed('meta.timeStamps.local', 'cacheDuration', function () {
+  isCacheExpired: computed('meta.timeStamps.local', 'cacheDuration', function () {
     const localTime = this.get('meta.timeStamps.local');
     const expiresTime = localTime + this.get('cacheDuration');
     return (localTime) ? Date.now() >= expiresTime : false;
@@ -366,7 +368,8 @@ Resource.reopenClass({
 
     ```
     model() {
-      return this.container.lookupFactory('model:post').create({
+      let owner = (typeof Ember.getOwner === 'function') ? Ember.getOwner(this) : this.container;
+      return owner.lookup('model:post').create({
         attributes: {
           title: 'The JSON API 1.0 Spec Rocks!'
         }
@@ -399,14 +402,16 @@ Resource.reopenClass({
     let msg = (type) ? Ember.String.capitalize(type) : 'Resource';
     let factory = 'model:' + type;
     if (!type) {
-      Ember.Logger.warn(msg + '#create called, instead you should first use ' + msg + '.extend({type:"entity"})');
+      Logger.warn(msg + '#create called, instead you should first use ' + msg + '.extend({type:"entity"})');
     } else {
-      if (instance.container) {
-        useComputedPropsMetaToSetupRelationships(factory, instance);
+      let owner = (typeof Ember.getOwner === 'function') ? Ember.getOwner(instance) : instance.container;
+      if (owner) {
+        useComputedPropsMetaToSetupRelationships(owner, factory, instance);
       } else {
-        msg += '#create should only be called from a container lookup (relationships not setup) ';
-        msg += 'use this.container.lookupFactory("' + factory + '").create() instead.';
-        Ember.Logger.warn(msg);
+        msg += '#create should only be called from a container lookup (relationships not setup), instead use: \n';
+        msg += "`let owner = (typeof Ember.getOwner === 'function') ? Ember.getOwner(this) : this.container; \n";
+        msg += 'owner.lookup("' + factory + '").create()`';
+        Logger.warn(msg);
       }
     }
     return instance;
@@ -420,8 +425,8 @@ export { attr, hasOne, hasMany };
 let _rp = 'service type id attributes relationships links meta _attributes isNew cacheDuration isCacheExpired';
 const ignoredMetaProps = _rp.split(' ');
 
-function useComputedPropsMetaToSetupRelationships(factory, instance) {
-  factory = instance.container.lookupFactory(factory);
+function useComputedPropsMetaToSetupRelationships(owner, factory, instance) {
+  factory = owner.lookup(factory);
   factory.eachComputedProperty(function(prop) {
     if (ignoredMetaProps.indexOf(prop) > -1) { return; }
     try {

addon/serializers/application.js

@@ -155,7 +155,8 @@ export default Ember.Object.extend({
     if (!related) { return; }
     let resource, service;
     for (let i = 0; i < related.length; i++) {
-      service = this.container.lookup('service:' + pluralize(related[i].type));
+      let owner = (typeof Ember.getOwner === 'function') ? Ember.getOwner(this) : this.container;
+      service = owner.lookup('service:' + pluralize(related[i].type));
       if (service && service.cache && service.cache.data) {
         resource = service.serializer.deserializeResource(related[i]);
         service.cacheResource({ meta: resp.meta, data: resource, headers: resp.headers});
@@ -238,7 +239,8 @@ export default Ember.Object.extend({
     @return {Function} factory for creating resource instances
   */
   _lookupFactory(type) {
-    return this.container.lookupFactory('model:' + singularize(type));
+    let owner = (typeof Ember.getOwner === 'function') ? Ember.getOwner(this) : this.container;
+    return owner.lookup('model:' + singularize(type));
   }
 });
 

addon/utils/related-proxy.js

@@ -81,7 +81,8 @@ const RelatedProxyUtil = Ember.Object.extend({
     let relation = this.get('relationship');
     let type = this.get('type');
     let url = this.proxyUrl(resource, relation);
-    let service = resource.container.lookup('service:' + pluralize(type));
+    let owner = (typeof Ember.getOwner === 'function') ? Ember.getOwner(resource) : resource.container;
+    let service = owner.lookup('service:' + pluralize(type));
     let promise = this.promiseFromCache(resource, relation, service);
     promise = promise || service.findRelated({'resource': relation, 'type': type}, url);
     let proxyProto = proxyFactory.extend(Ember.PromiseProxyMixin, {

app/initializers/model-setup.js

@@ -0,0 +1 @@
+export { default, initialize } from 'ember-jsonapi-resources/initializers/model-setup';

blueprints/jsonapi-initializer-test/files/tests/unit/initializers/__name__-test.js

@@ -21,15 +21,12 @@ module('<%= friendlyTestName %>', {
   }
 });
 
-test('it registers <%= resource %> factories: model, service, adapter, serializer; injects: service, serializer', function(assert) {
+test('it registers <%= resource %> factory: model, injects into: service, serializer', function(assert) {
   <%= classifiedModuleName %>Initializer.initialize(registry, application);
 
   let registered = Ember.A(factories.mapBy('name'));
-  assert.ok(registered.contains('model:<%= resource %>'), 'model:<%= resource %> registered');
-  assert.ok(registered.contains('service:<%= resource %>'), 'service:<%= resource %> registered');
-  assert.ok(registered.contains('adapter:<%= resource %>'), 'adapter:<%= resource %> registered');
-  assert.ok(registered.contains('serializer:<%= resource %>'), 'serializer:<%= resource %> registered');
-  let msg = 'briefs injected into service:store';
+  assert.ok(registered.contains('model:<%= entity %>'), 'model:<%= entity %> registered');
+  let msg = '<%= resource %> injected into service:store';
   assert.equal(injections.findBy('factory', 'service:store').property, '<%= resource %>', msg);
   msg = 'serializer injected into service:<%= resource %>';
   assert.equal(injections.findBy('factory', 'service:<%= resource %>').property, 'serializer', msg);

blueprints/jsonapi-initializer/files/__root__/initializers/__name__.js

@@ -1,7 +1,9 @@
+import Resource from '<%= modelPath %>';
+
 export function initialize() {
   // see http://emberjs.com/deprecations/v2.x/#toc_initializer-arity
   let application = arguments[1] || arguments[0];
-
+  application.register('model:<%= entity %>', Resource, { instantiate: false, singleton: false });
   application.inject('service:store', '<%= resource %>', 'service:<%= resource %>');
   application.inject('service:<%= resource %>', 'serializer', 'serializer:<%= entity %>');
 }

blueprints/jsonapi-model-test/files/tests/unit/__path__/__test__.js

@@ -1,22 +1,21 @@
 import { moduleFor, test } from 'ember-qunit';
 import Model from '<%= modelPath %>';
+import Ember from 'ember';
 
 moduleFor('model:<%= dasherizedModuleName %>', '<%= friendlyDescription %>', {
   // Specify the other units that are required for this test.
 <%= typeof needs !== 'undefined' ? needs : '' %>
   beforeEach() {
-    const opts = { instantiate: false, singleton: false };
-    Model.prototype.container = this.container;
-    // Use a non-standard name, i.e. pluralized instead of singular
-    this.registry.register('model:<%= resource %>', Model, opts);
+    let opts = { instantiate: false, singleton: false };
+    this.registry.register('model:<%= entity %>', Model, opts);
   },
   afterEach() {
-    delete Model.prototype.container;
-    this.registry.unregister('model:<%= resource %>');
+    this.registry.unregister('model:<%= entity %>');
   }
 });
 
 test('<%= resource %> has "type" property set to: <%= resource %>', function(assert) {
-  var model = this.container.lookupFactory('model:<%= resource %>').create();
+  let owner = (typeof Ember.getOwner === 'function') ? Ember.getOwner(this) : this.container;
+  let model = owner.lookup('model:<%= entity %>').create();
   assert.equal(model.get('type'), '<%= resource %>', 'resource has expected type');
 });

blueprints/jsonapi-serializer-test/files/tests/unit/__path__/__test__.js

@@ -1,11 +1,16 @@
 import { moduleFor, test } from 'ember-qunit';
 import Resource from '<%= modelPath %>';
+import Ember from 'ember';
 
 moduleFor('serializer:<%= entity %>', '<%= friendlyTestDescription %>', {
   beforeEach() {
-    Resource.prototype.container = this.container;
+    if (typeof Ember.setOwner === 'function') {
+      Ember.setOwner(Resource.prototype, Ember.getOwner(this));
+    } else {
+      Resource.prototype.container = this.container;
+    }
     let opts = { instantiate: false, singleton: false };
-    this.registry.register('model:<%= resource %>', Resource, opts);
+    this.registry.register('model:<%= entity %>', Resource, opts);
   },
   afterEach() {
     delete Resource.prototype.container;
@@ -14,7 +19,8 @@ moduleFor('serializer:<%= entity %>', '<%= friendlyTestDescription %>', {
 
 // Replace this with your real tests.
 test('it serializes resources', function(assert) {
-  let resource = this.container.lookupFactory('model:<%= resource %>').create();
+  let owner = (typeof Ember.getOwner === 'function') ? Ember.getOwner(this) : this.container;
+  let resource = owner.lookup('model:<%= entity %>').create();
   let serializer = this.subject();
   var serializedResource = serializer.serialize(resource);
   assert.equal(serializedResource.data.type, '<%= resource %>', 'serializes a <%= entity %> resource');