Merge pull request #49 from rwjblue/build-registry

Remove isolatedContainer and use Ember.Application.buildRegistry.

lib/ember-test-helpers.js

@@ -1,5 +1,4 @@
 import Ember                  from 'ember';
-import { isolatedContainer }  from 'ember-test-helpers/isolated-container';
 import TestModule             from 'ember-test-helpers/test-module';
 import TestModuleForComponent from 'ember-test-helpers/test-module-for-component';
 import TestModuleForModel     from 'ember-test-helpers/test-module-for-model';
@@ -9,7 +8,6 @@ import { setResolver } from 'ember-test-helpers/test-resolver';
 Ember.testing = true;
 
 export {
-  isolatedContainer,
   TestModule,
   TestModuleForComponent,
   TestModuleForModel,

lib/ember-test-helpers/build-registry.js

@@ -0,0 +1,76 @@
+function exposeRegistryMethodsWithoutDeprecations(container) {
+  var methods = [
+    'register',
+    'unregister',
+    'resolve',
+    'normalize',
+    'typeInjection',
+    'injection',
+    'factoryInjection',
+    'factoryTypeInjection',
+    'has',
+    'options',
+    'optionsForType'
+  ];
+
+  function exposeRegistryMethod(container, method) {
+    container[method] = function() {
+      return container._registry[method].apply(container._registry, arguments);
+    };
+  }
+
+  for (var i = 0, l = methods.length; i < l; i++) {
+    exposeRegistryMethod(container, methods[i]);
+  }
+}
+
+export default function(resolver) {
+  var registry, container;
+  var namespace = Ember.Object.create({
+    Resolver: { create: function() { return resolver; } }
+  });
+
+  function register(name, factory) {
+    var thingToRegisterWith = registry || container;
+
+    thingToRegisterWith.register(name, factory);
+  }
+
+  if (Ember.Application.buildRegistry) {
+    registry = Ember.Application.buildRegistry(namespace);
+    registry.register('component-lookup:main', Ember.ComponentLookup);
+
+    registry = registry;
+    container = registry.container();
+    exposeRegistryMethodsWithoutDeprecations(container);
+  } else {
+    container = Ember.Application.buildContainer(namespace);
+    container.register('component-lookup:main', Ember.ComponentLookup);
+  }
+
+  // Ember 1.10.0 did not properly add `view:toplevel` or `view:default`
+  // to the registry in Ember.Application.buildRegistry :(
+  register('view:toplevel', Ember.View.extend());
+  register('view:default', Ember._MetamorphView);
+
+  var globalContext = typeof global === 'object' && global || self;
+  if (globalContext.DS) {
+    var DS = globalContext.DS;
+    if (DS._setupContainer) {
+      DS._setupContainer(registry || container);
+    } else {
+      register('transform:boolean', DS.BooleanTransform);
+      register('transform:date', DS.DateTransform);
+      register('transform:number', DS.NumberTransform);
+      register('transform:string', DS.StringTransform);
+      register('serializer:-default', DS.JSONSerializer);
+      register('serializer:-rest', DS.RESTSerializer);
+      register('adapter:-rest', DS.RESTAdapter);
+    }
+  }
+
+  return {
+    registry: registry,
+    container: container
+  };
+}

lib/ember-test-helpers/isolated-container.js

@@ -1,109 +0,0 @@
-import { getResolver } from './test-resolver';
-import Ember from 'ember';
-
-function exposeRegistryMethodsWithoutDeprecations(container) {
-  var methods = [
-    'register',
-    'unregister',
-    'resolve',
-    'normalize',
-    'typeInjection',
-    'injection',
-    'factoryInjection',
-    'factoryTypeInjection',
-    'has',
-    'options',
-    'optionsForType'
-  ];
-
-  function exposeRegistryMethod(container, method) {
-    container[method] = function() {
-      return container._registry[method].apply(container._registry, arguments);
-    };
-  }
-
-  for (var i = 0, l = methods.length; i < l; i++) {
-    exposeRegistryMethod(container, methods[i]);
-  }
-}
-
-export function isolatedRegistry(fullNames) {
-  var resolver = getResolver();
-  var container;
-  var registry;
-
-  var normalize = function(fullName) {
-    return resolver.normalize(fullName);
-  };
-
-  if (Ember.Registry) {
-    registry = new Ember.Registry();
-    registry.normalizeFullName = normalize;
-
-    container = registry.container();
-    exposeRegistryMethodsWithoutDeprecations(container);
-
-  } else {
-    container = new Ember.Container();
-
-    //normalizeFullName only exists since Ember 1.9
-    if (Ember.typeOf(container.normalizeFullName) === 'function') {
-      container.normalizeFullName = normalize;
-    } else {
-      container.normalize = normalize;
-    }
-  }
-
-  container.optionsForType('component', { singleton: false });
-  container.optionsForType('view', { singleton: false });
-  container.optionsForType('template', { instantiate: false });
-  container.optionsForType('helper', { instantiate: false });
-  container.register('component-lookup:main', Ember.ComponentLookup);
-  container.register('controller:basic', Ember.Controller, { instantiate: false });
-  container.register('controller:object', Ember.ObjectController, { instantiate: false });
-  container.register('controller:array', Ember.ArrayController, { instantiate: false });
-  container.register('view:default', Ember._MetamorphView);
-  container.register('view:toplevel', Ember.View.extend());
-  container.register('view:select', Ember.Select);
-  container.register('route:basic', Ember.Route, { instantiate: false });
-
-  // added in Glimmer
-  container.register('component:-link-to', Ember.LinkView);
-  container.register('component:-text-field', Ember.TextField);
-  container.register('component:-text-area', Ember.TextArea);
-  container.register('component:-checkbox', Ember.Checkbox);
-
-  if (Ember._LegacyEachView) {
-    container.register('view:-legacy-each', Ember._LegacyEachView);
-  }
-
-  var globalContext = typeof global === 'object' && global || self;
-  if (globalContext.DS) {
-    var DS = globalContext.DS;
-    if (DS._setupContainer) {
-      DS._setupContainer(container);
-    } else {
-      container.register('transform:boolean', DS.BooleanTransform);
-      container.register('transform:date', DS.DateTransform);
-      container.register('transform:number', DS.NumberTransform);
-      container.register('transform:string', DS.StringTransform);
-      container.register('serializer:-default', DS.JSONSerializer);
-      container.register('serializer:-rest', DS.RESTSerializer);
-      container.register('adapter:-rest', DS.RESTAdapter);
-    }
-  }
-
-  for (var i = fullNames.length; i > 0; i--) {
-    var fullName = fullNames[i - 1];
-    var normalizedFullName = resolver.normalize(fullName);
-    container.register(fullName, resolver.resolve(normalizedFullName));
-  }
-  return {
-    container: container,
-    registry: registry
-  };
-}
-
-export function isolatedContainer(fullNames) {
-  return isolatedRegistry(fullNames).container;
-}

lib/ember-test-helpers/test-module.js

@@ -1,8 +1,8 @@
 import Ember from 'ember';
-import { isolatedRegistry } from './isolated-container';
 import { getContext, setContext } from './test-context';
 import { Klass } from 'klassy';
 import { getResolver } from './test-resolver';
+import buildRegistry from './build-registry';
 
 export default Klass.extend({
   init: function(subjectName, description, callbacks) {
@@ -19,7 +19,7 @@ export default Klass.extend({
     this.callbacks = callbacks || {};
 
     if (this.callbacks.integration) {
-      this.isIntegration = callbacks.integration;      
+      this.isIntegration = callbacks.integration;
       delete callbacks.integration;
     }
 
@@ -212,30 +212,36 @@ export default Klass.extend({
     }
   },
 
+  _setupContainer: function() {
+    var resolver = getResolver();
+    var items = buildRegistry(resolver);
 
-  _setupIsolatedContainer: function() {
-    var isolated = isolatedRegistry(this.needs);
-    this.container = isolated.container;
-    this.registry = isolated.registry;
+    this.container = items.container;
+    this.registry = items.registry;
+
+    var thingToRegisterWith = this.registry || this.container;
+    var router = resolver.resolve('router:main');
+    router = router || Ember.Router.extend();
+    thingToRegisterWith.register('router:main', router);
   },
 
-  _setupIntegratedContainer: function() {
+  _setupIsolatedContainer: function() {
     var resolver = getResolver();
-    var namespace = Ember.Object.create({
-      Resolver: { create: function() { return resolver; } }
-    });
+    this._setupContainer();
 
-    if (Ember.Application.buildRegistry) {
-      var registry;
-      registry = Ember.Application.buildRegistry(namespace);
-      registry.register('component-lookup:main', Ember.ComponentLookup);
-      this.registry = registry;
-      this.container = registry.container();
-    } else {
-      this.container = Ember.Application.buildContainer(namespace);
-      this.container.register('component-lookup:main', Ember.ComponentLookup);
+    var thingToRegisterWith = this.registry || this.container;
+
+    for (var i = this.needs.length; i > 0; i--) {
+      var fullName = this.needs[i - 1];
+      var normalizedFullName = resolver.normalize(fullName);
+      thingToRegisterWith.register(fullName, resolver.resolve(normalizedFullName));
     }
+
+    thingToRegisterWith.resolver = function() { };
+  },
+
+  _setupIntegratedContainer: function() {
+    this._setupContainer();
   }
 
 });
-

package.json

@@ -28,7 +28,7 @@
     "broccoli-static-compiler": "^0.1.4",
     "ember-cli": "^0.1.12",
     "ember-cli-release": "^0.2.3",
-    "ember-try": "0.0.3",
+    "ember-try": "0.0.5",
     "testem": "^0.6.19"
   }
 }

tests/test-module-for-component-test.js

@@ -158,10 +158,10 @@ test('can lookup default Ember.Views in its layout', function() {
   expect(1);
   var component = this.subject({
     colors: ['red', 'green', 'blue'],
-    layout: Ember.Handlebars.compile("{{view 'default'}}")
+    layout: Ember.Handlebars.compile("{{view id='foo'}}")
   });
   this.render();
-  equal(component._state, 'inDOM');
+  equal(component.$('#foo').length, 1, 'expected to find `foo` element');
 });
 
 test('can lookup toplevel Ember.Views in its layout', function() {

tests/test-module-for-model-test.js

@@ -146,3 +146,21 @@ test('ApplicationAdapter is registered for model', function() {
   ok(store.adapterFor(model.constructor) instanceof ApplicationAdapter);
   ok(!(store.adapterFor(model.constructor) instanceof WhazzitAdapter));
 });
+
+///////////////////////////////////////////////////////////////////////////////
+
+moduleForModel('whazzit', 'model:whazzit when using integration:true', {
+
+  integration: true,
+
+  beforeSetup: function() {
+    setupRegistry();
+  }
+
+});
+
+test('the store still exists', function() {
+  var store = this.store();
+
+  ok(store instanceof DS.Store);
+});