[FEATURE ember-htmlbars-local-lookup]

FEATURES.md

@@ -52,3 +52,10 @@ for a detailed explanation.
   ```
 
   Implements RFC [#64](https://github.com/emberjs/rfcs/blob/master/text/0064-contextual-component-lookup.md)
+
+* `ember-htmlbars-local-lookup`
+
+  Provides the ability for component lookup to be relative to the source template.
+
+  When the proper API's are implemented by the resolver in use this feature allows `{{x-foo}}` in a
+  given routes template (say the `post` route) to lookup a component nested under `post`.

features.json

@@ -9,6 +9,7 @@
     "ember-routing-routable-components": null,
     "ember-metal-ember-assign": null,
     "ember-contextual-components": true,
-    "ember-container-inject-owner": true
+    "ember-container-inject-owner": true,
+    "ember-htmlbars-local-lookup": null
   }
 }

packages/container/lib/container.js

@@ -108,7 +108,8 @@ Container.prototype = {
    @private
    @method lookup
    @param {String} fullName
-   @param {Object} options
+   @param {Object} [options]
+   @param {String} [options.source] The fullname of the request source (used for local lookup)
    @return {any}
    */
   lookup(fullName, options) {
@@ -122,11 +123,13 @@ Container.prototype = {
    @private
    @method lookupFactory
    @param {String} fullName
+   @param {Object} [options]
+   @param {String} [options.source] The fullname of the request source (used for local lookup)
    @return {any}
    */
-  lookupFactory(fullName) {
+  lookupFactory(fullName, options) {
     assert('fullName must be a proper full name', this.registry.validateFullName(fullName));
-    return factoryFor(this, this.registry.normalize(fullName));
+    return factoryFor(this, this.registry.normalize(fullName), options);
   },
 
   /**
@@ -178,8 +181,18 @@ function isSingleton(container, fullName) {
   return container.registry.getOption(fullName, 'singleton') !== false;
 }
 
-function lookup(container, fullName, options) {
-  options = options || {};
+function lookup(container, _fullName, _options) {
+  let options = _options || {};
+  let fullName = _fullName;
+
+  if (isEnabled('ember-htmlbars-local-lookup')) {
+    if (options.source) {
+      fullName = container.registry.expandLocalLookup(fullName, options);
+
+      // if expandLocalLookup returns falsey, we do not support local lookup
+      if (!fullName) { return; }
+    }
+  }
 
   if (container.cache[fullName] && options.singleton !== false) {
     return container.cache[fullName];
@@ -232,12 +245,24 @@ function buildInjections(/* container, ...injections */) {
   return hash;
 }
 
-function factoryFor(container, fullName) {
+function factoryFor(container, _fullName, _options) {
+  let options = _options || {};
+  let registry = container.registry;
+  let fullName = _fullName;
+
+  if (isEnabled('ember-htmlbars-local-lookup')) {
+    if (options.source) {
+      fullName = registry.expandLocalLookup(fullName, options);
+
+      // if expandLocalLookup returns falsey, we do not support local lookup
+      if (!fullName) { return; }
+    }
+  }
+
   var cache = container.factoryCache;
   if (cache[fullName]) {
     return cache[fullName];
   }
-  var registry = container.registry;
   var factory = registry.resolve(fullName);
   if (factory === undefined) { return; }
 

packages/container/lib/registry.js

@@ -1,5 +1,7 @@
+import isEnabled from 'ember-metal/features';
 import { assert, deprecate } from 'ember-metal/debug';
 import dictionary from 'ember-metal/dictionary';
+import EmptyObject from 'ember-metal/empty_object';
 import assign from 'ember-metal/assign';
 import Container from './container';
 
@@ -36,6 +38,7 @@ function Registry(options) {
   this._factoryTypeInjections = dictionary(null);
   this._factoryInjections     = dictionary(null);
 
+  this._localLookupCache      = new EmptyObject();
   this._normalizeCache        = dictionary(null);
   this._resolveCache          = dictionary(null);
   this._failCache             = dictionary(null);
@@ -205,6 +208,8 @@ Registry.prototype = {
 
     var normalizedName = this.normalize(fullName);
 
+    this._localLookupCache = new EmptyObject();
+
     delete this.registrations[normalizedName];
     delete this._resolveCache[normalizedName];
     delete this._failCache[normalizedName];
@@ -242,13 +247,15 @@ Registry.prototype = {
    @private
    @method resolve
    @param {String} fullName
+   @param {Object} [options]
+   @param {String} [options.source] the fullname of the request source (used for local lookups)
    @return {Function} fullName's factory
    */
-  resolve(fullName) {
+  resolve(fullName, options) {
     assert('fullName must be a proper full name', this.validateFullName(fullName));
-    var factory = resolve(this, this.normalize(fullName));
+    let factory = resolve(this, this.normalize(fullName), options);
     if (factory === undefined && this.fallback) {
-      factory = this.fallback.resolve(fullName);
+      factory = this.fallback.resolve(...arguments);
     }
     return factory;
   },
@@ -333,11 +340,19 @@ Registry.prototype = {
    @private
    @method has
    @param {String} fullName
+   @param {Object} [options]
+   @param {String} [options.source] the fullname of the request source (used for local lookups)
    @return {Boolean}
    */
-  has(fullName) {
+  has(fullName, options) {
     assert('fullName must be a proper full name', this.validateFullName(fullName));
-    return has(this, this.normalize(fullName));
+
+    let source;
+    if (isEnabled('ember-htmlbars-local-lookup')) {
+      source = options && options.source && this.normalize(options.source);
+    }
+
+    return has(this, this.normalize(fullName), source);
   },
 
   /**
@@ -387,8 +402,8 @@ Registry.prototype = {
    @param {String} fullName
    @param {Object} options
    */
-  options(fullName, options) {
-    options = options || {};
+  options(fullName, _options) {
+    let options = _options || {};
     var normalizedName = this.normalize(fullName);
     this._options[normalizedName] = options;
   },
@@ -758,8 +773,73 @@ function deprecateResolverFunction(registry) {
   };
 }
 
-function resolve(registry, normalizedName) {
-  let cached = registry._resolveCache[normalizedName];
+if (isEnabled('ember-htmlbars-local-lookup')) {
+  /**
+    Given a fullName and a source fullName returns the fully resolved
+    fullName. Used to allow for local lookup.
+
+    ```javascript
+    var registry = new Registry();
+
+    // the twitter factory is added to the module system
+    registry.expandLocalLookup('component:post-title', { source: 'template:post' }) // => component:post/post-title
+    ```
+
+    @private
+    @method expandLocalLookup
+    @param {String} fullName
+    @param {Object} [options]
+    @param {String} [options.source] the fullname of the request source (used for local lookups)
+    @return {String} fullName
+  */
+  Registry.prototype.expandLocalLookup = function Registry_expandLocalLookup(fullName, options) {
+    if (this.resolver && this.resolver.expandLocalLookup) {
+      assert('fullName must be a proper full name', this.validateFullName(fullName));
+      assert('options.source must be provided to expandLocalLookup', options && options.source);
+      assert('options.source must be a proper full name', this.validateFullName(options.source));
+
+      let normalizedFullName = this.normalize(fullName);
+      let normalizedSource = this.normalize(options.source);
+
+      return expandLocalLookup(this, normalizedFullName, normalizedSource);
+    } else if (this.fallback) {
+      return this.fallback.expandLocalLookup(fullName, options);
+    } else {
+      return null;
+    }
+  };
+}
+
+function expandLocalLookup(registry, normalizedName, normalizedSource) {
+  let cache = registry._localLookupCache;
+  let normalizedNameCache = cache[normalizedName];
+
+  if (!normalizedNameCache) {
+    normalizedNameCache = cache[normalizedName] = new EmptyObject();
+  }
+
+  let cached = normalizedNameCache[normalizedSource];
+
+  if (cached !== undefined) { return cached; }
+
+  let expanded = registry.resolver.expandLocalLookup(normalizedName, normalizedSource);
+
+  return normalizedNameCache[normalizedSource] = expanded;
+}
+
+function resolve(registry, normalizedName, options) {
+  if (isEnabled('ember-htmlbars-local-lookup')) {
+    if (options && options.source) {
+      // when `source` is provided expand normalizedName
+      // and source into the full normalizedName
+      normalizedName = registry.expandLocalLookup(normalizedName, options);
+
+      // if expandLocalLookup returns falsey, we do not support local lookup
+      if (!normalizedName) { return; }
+    }
+  }
+
+  var cached = registry._resolveCache[normalizedName];
   if (cached) { return cached; }
   if (registry._failCache[normalizedName]) { return; }
 
@@ -780,8 +860,8 @@ function resolve(registry, normalizedName) {
   return resolved;
 }
 
-function has(registry, fullName) {
-  return registry.resolve(fullName) !== undefined;
+function has(registry, fullName, source) {
+  return registry.resolve(fullName, { source }) !== undefined;
 }
 
 export default Registry;

packages/container/tests/container_test.js

@@ -610,3 +610,45 @@ if (isEnabled('ember-container-inject-owner')) {
     strictEqual(postController.container, container, '');
   });
 }
+
+if (isEnabled('ember-htmlbars-local-lookup')) {
+  QUnit.test('lookupFactory passes options through to expandlocallookup', function(assert) {
+    let registry = new Registry();
+    let container = registry.container();
+    let PostController = factory();
+
+    registry.register('controller:post', PostController);
+
+    registry.expandLocalLookup = function(fullName, options) {
+      assert.ok(true, 'expandLocalLookup was called');
+      assert.equal(fullName, 'foo:bar');
+      assert.deepEqual(options, { source: 'baz:qux' });
+
+      return 'controller:post';
+    };
+
+    let PostControllerFactory = container.lookupFactory('foo:bar', { source: 'baz:qux' });
+
+    assert.ok(PostControllerFactory.create() instanceof  PostController, 'The return of factory.create is an instance of PostController');
+  });
+
+  QUnit.test('lookup passes options through to expandlocallookup', function(assert) {
+    let registry = new Registry();
+    let container = registry.container();
+    let PostController = factory();
+
+    registry.register('controller:post', PostController);
+
+    registry.expandLocalLookup = function(fullName, options) {
+      assert.ok(true, 'expandLocalLookup was called');
+      assert.equal(fullName, 'foo:bar');
+      assert.deepEqual(options, { source: 'baz:qux' });
+
+      return 'controller:post';
+    };
+
+    let PostControllerLookupResult = container.lookup('foo:bar', { source: 'baz:qux' });
+
+    assert.ok(PostControllerLookupResult instanceof PostController);
+  });
+}