From 473d15ae6e6f94ff2b2ba40b2fb89389b26664fd Mon Sep 17 00:00:00 2001 From: Chris Garrett Date: Wed, 28 Oct 2020 17:42:09 -0700 Subject: [PATCH] [CLEANUP] Removes the `expandLocalLookup` API `expandLocalLookup` was a experimental API that was tied closely to Module Unification. The API was shipped, but was never fully released. It was primarily used for experimentation in general. Currently, 3 addons use it, all of which are experimental addons that try to establish MU like file structures. This PR removes the API to simplify resolution as a whole, so we can continue the work toward strict mode. --- FEATURES.md | 15 - .../-internals/container/lib/container.ts | 24 +- .../-internals/container/lib/registry.ts | 126 +------- .../container/tests/container_test.js | 21 -- .../container/tests/registry_test.js | 221 -------------- .../@ember/-internals/glimmer/lib/resolver.ts | 30 +- .../@ember/-internals/glimmer/lib/syntax.ts | 7 +- .../components/local-lookup-test.js | 283 ------------------ .../-internals/metal/lib/injected_property.ts | 11 +- packages/@ember/-internals/owner/index.ts | 2 - .../lib/test-resolver.js | 19 -- tests/docs/expected.js | 1 - 12 files changed, 20 insertions(+), 740 deletions(-) delete mode 100644 packages/@ember/-internals/glimmer/tests/integration/components/local-lookup-test.js diff --git a/FEATURES.md b/FEATURES.md index 7c8728e1ad9..823f87c6202 100644 --- a/FEATURES.md +++ b/FEATURES.md @@ -21,18 +21,3 @@ for a detailed explanation. * `ember-testing-resume-test` Introduces the `resumeTest` testing helper to complement the `pauseTest` helper. - -* `ember-module-unification` - - Introduces support for Module Unification - ([RFC](https://github.com/dgeb/rfcs/blob/module-unification/text/0000-module-unification.md)) - to Ember. This includes: - - - Passing the `source` of a `lookup`/`factoryFor` call as an argument to - `expandLocalLookup` on the resolver. - - Making `lookupComponentPair` friendly to local/private resolutions. The - new code ensures a local resolution is not paired with a global resolution. - - This feature is paired with the - [`EMBER_RESOLVER_MODULE_UNIFICATION`](https://github.com/ember-cli/ember-resolver#ember_resolver_module_unification) - flag on the ember-resolver package. diff --git a/packages/@ember/-internals/container/lib/container.ts b/packages/@ember/-internals/container/lib/container.ts index d3c2c5032b9..5d10fb8f106 100644 --- a/packages/@ember/-internals/container/lib/container.ts +++ b/packages/@ember/-internals/container/lib/container.ts @@ -214,7 +214,7 @@ export default class Container { @param {String} [options.source] The fullname of the request source (used for local lookup) @return {any} */ - factoryFor(fullName: string, options: LookupOptions = {}): Factory | undefined { + factoryFor(fullName: string): Factory | undefined { if (this.isDestroyed) { throw new Error(`Can not call \`.factoryFor\` after the owner has been destroyed`); } @@ -222,13 +222,6 @@ export default class Container { assert('fullName must be a proper full name', this.registry.isValidFullName(normalizedName)); - if (options.source || options.namespace) { - normalizedName = this.registry.expandLocalLookup(fullName, options); - if (!normalizedName) { - return; - } - } - return factoryFor(this, normalizedName, fullName) as Factory | undefined; } } @@ -279,13 +272,6 @@ function isInstantiatable(container: Container, fullName: string) { function lookup(container: Container, fullName: string, options: LookupOptions = {}) { let normalizedName = fullName; - if (options.source || options.namespace) { - normalizedName = container.registry.expandLocalLookup(fullName, options); - if (!normalizedName) { - return; - } - } - if (options.singleton !== false) { let cached = container.cache[normalizedName]; if (cached !== undefined) { @@ -439,13 +425,9 @@ function processInjections( let hash = result.injections; for (let i = 0; i < injections.length; i++) { - let { property, specifier, source } = injections[i]; + let { property, specifier } = injections[i]; - if (source) { - hash[property] = lookup(container, specifier, { source }); - } else { - hash[property] = lookup(container, specifier); - } + hash[property] = lookup(container, specifier); if (!result.isDynamic) { result.isDynamic = !isSingleton(container, specifier); diff --git a/packages/@ember/-internals/container/lib/registry.ts b/packages/@ember/-internals/container/lib/registry.ts index e133219069d..4e657e5544e 100644 --- a/packages/@ember/-internals/container/lib/registry.ts +++ b/packages/@ember/-internals/container/lib/registry.ts @@ -1,26 +1,17 @@ -import { Factory, LookupOptions } from '@ember/-internals/owner'; +import { Factory } from '@ember/-internals/owner'; import { dictionary, intern } from '@ember/-internals/utils'; import { assert } from '@ember/debug'; import { assign } from '@ember/polyfills'; import { DEBUG } from '@glimmer/env'; import Container, { ContainerOptions, LazyInjection } from './container'; -interface HasOptions { - source?: string; - namespace?: string; -} - export interface Injection { - namespace?: string; property: string; - source?: string; specifier: string; } export type ResolveOptions = { specifier?: string; - source?: string | undefined; - namespace?: string | undefined; }; export interface TypeOptions { @@ -34,7 +25,6 @@ export interface KnownForTypeResult { export interface IRegistry { describe(fullName: string): string; - expandLocalLookup(fullName: string, options: LookupOptions): string; getInjections(fullName: string): Injection[]; getOption( fullName: string, @@ -50,7 +40,6 @@ export interface IRegistry { } export type NotResolver = { - expandLocalLookup: never; knownForType: never; lookupDescription: never; makeToString: never; @@ -61,11 +50,6 @@ export type NotResolver = { export type Resolve = (name: string) => Factory | undefined; export interface Resolver { - expandLocalLookup?: ( - normalizedName: string, - normalizedSource: string, - namespace?: string | undefined - ) => string; knownForType?: (type: string) => KnownForTypeResult; lookupDescription?: (fullName: string) => string; makeToString?: (factory: Factory, fullName: string) => string; @@ -300,8 +284,8 @@ export default class Registry implements IRegistry { @param {String} [options.source] the fullname of the request source (used for local lookups) @return {Function} fullName's factory */ - resolve(fullName: string, options?: ResolveOptions): Factory | undefined { - let factory = resolve(this, this.normalize(fullName), options); + resolve(fullName: string): Factory | undefined { + let factory = resolve(this, this.normalize(fullName)); if (factory === undefined && this.fallback !== null) { factory = (this.fallback as any).resolve(...arguments); } @@ -393,15 +377,12 @@ export default class Registry implements IRegistry { @param {String} [options.source] the fullname of the request source (used for local lookups) @return {Boolean} */ - has(fullName: string, options?: HasOptions) { + has(fullName: string) { if (!this.isValidFullName(fullName)) { return false; } - let source = options && options.source && this.normalize(options.source); - let namespace = (options && options.namespace) || undefined; - - return has(this, this.normalize(fullName), source, namespace); + return has(this, this.normalize(fullName)); } /** @@ -660,43 +641,6 @@ export default class Registry implements IRegistry { return injections; } - - /** - Given a fullName and a source fullName returns the fully resolved - fullName. Used to allow for local lookup. - - ```javascript - let 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 - */ - expandLocalLookup(fullName: string, options: LookupOptions) { - if (this.resolver !== null && this.resolver.expandLocalLookup) { - assert('fullName must be a proper full name', this.isValidFullName(fullName)); - assert( - 'options.source must be a proper full name', - !options.source || this.isValidFullName(options.source) - ); - - let normalizedFullName = this.normalize(fullName); - let normalizedSource = this.normalize(options.source!); - - return expandLocalLookup(this, normalizedFullName, normalizedSource, options.namespace); - } else if (this.fallback !== null) { - return this.fallback.expandLocalLookup(fullName, options); - } else { - return null; - } - } } export declare class DebugRegistry extends Registry { @@ -711,7 +655,7 @@ if (DEBUG) { for (let key in hash) { if (Object.prototype.hasOwnProperty.call(hash, key)) { - let { specifier, source, namespace } = hash[key]; + let { specifier } = hash[key]; assert( `Expected a proper full name, given '${specifier}'`, this.isValidFullName(specifier) @@ -720,8 +664,6 @@ if (DEBUG) { injections.push({ property: key, specifier, - source, - namespace, }); } } @@ -735,56 +677,15 @@ if (DEBUG) { } for (let i = 0; i < injections.length; i++) { - let { specifier, source, namespace } = injections[i]; + let { specifier } = injections[i]; - assert( - `Attempting to inject an unknown injection: '${specifier}'`, - this.has(specifier, { source, namespace }) - ); + assert(`Attempting to inject an unknown injection: '${specifier}'`, this.has(specifier)); } }; } -function expandLocalLookup( - registry: Registry, - normalizedName: string, - normalizedSource: string, - namespace: string | undefined -) { - let cache = registry._localLookupCache; - let normalizedNameCache = cache[normalizedName]; - - if (!normalizedNameCache) { - normalizedNameCache = cache[normalizedName] = Object.create(null); - } - - let cacheKey = namespace || normalizedSource; - - let cached = normalizedNameCache[cacheKey]; - - if (cached !== undefined) { - return cached; - } - - let expanded = registry.resolver!.expandLocalLookup!(normalizedName, normalizedSource, namespace); - - return (normalizedNameCache[cacheKey] = expanded); -} - -function resolve( - registry: Registry, - _normalizedName: string, - options?: ResolveOptions -): Factory | undefined { +function resolve(registry: Registry, _normalizedName: string): Factory | undefined { let normalizedName = _normalizedName; - // when `source` is provided expand normalizedName - // and source into the full normalizedName - if (options !== undefined && (options.source || options.namespace)) { - normalizedName = registry.expandLocalLookup(_normalizedName, options as LookupOptions); - if (!normalizedName) { - return; - } - } let cached = registry._resolveCache[normalizedName]; if (cached !== undefined) { @@ -813,13 +714,8 @@ function resolve( return resolved; } -function has( - registry: Registry, - fullName: string, - source: string | undefined, - namespace: string | undefined -) { - return registry.resolve(fullName, { source, namespace }) !== undefined; +function has(registry: Registry, fullName: string) { + return registry.resolve(fullName) !== undefined; } const privateNames: { [key: string]: string } = dictionary(null); diff --git a/packages/@ember/-internals/container/tests/container_test.js b/packages/@ember/-internals/container/tests/container_test.js index 26efba17fd2..e6d84453de6 100644 --- a/packages/@ember/-internals/container/tests/container_test.js +++ b/packages/@ember/-internals/container/tests/container_test.js @@ -513,27 +513,6 @@ moduleFor( Service.create(result); } - ['@test lookup passes options through to expandlocallookup'](assert) { - let registry = new Registry(); - let container = registry.container(); - let PostController = factory(); - - registry.register('controller:post', PostController); - registry.expandLocalLookup = (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); - } - ['@test #factoryFor class is registered class'](assert) { let registry = new Registry(); let container = registry.container(); diff --git a/packages/@ember/-internals/container/tests/registry_test.js b/packages/@ember/-internals/container/tests/registry_test.js index bfb2503075e..9981c6e32be 100644 --- a/packages/@ember/-internals/container/tests/registry_test.js +++ b/packages/@ember/-internals/container/tests/registry_test.js @@ -576,227 +576,6 @@ moduleFor( 'foo:bar-baz': true, }); } - - ['@test resolver.expandLocalLookup is not required'](assert) { - let registry = new Registry({ - resolver: {}, - }); - - let result = registry.expandLocalLookup('foo:bar', { - source: 'baz:qux', - }); - - assert.equal(result, null); - } - - ['@test expandLocalLookup is called on the resolver if present'](assert) { - assert.expect(4); - - let resolver = { - expandLocalLookup: (targetFullName, sourceFullName) => { - assert.ok(true, 'expandLocalLookup is called on the resolver'); - assert.equal(targetFullName, 'foo:bar', 'the targetFullName was passed through'); - assert.equal(sourceFullName, 'baz:qux', 'the sourceFullName was passed through'); - - return 'foo:qux/bar'; - }, - }; - - let registry = new Registry({ - resolver, - }); - - let result = registry.expandLocalLookup('foo:bar', { - source: 'baz:qux', - }); - - assert.equal(result, 'foo:qux/bar'); - } - - ['@test `expandLocalLookup` is handled by the resolver, then by the fallback registry, if available']( - assert - ) { - assert.expect(9); - - let fallbackResolver = { - expandLocalLookup: (targetFullName, sourceFullName) => { - assert.ok(true, 'expandLocalLookup is called on the fallback resolver'); - assert.equal(targetFullName, 'foo:bar', 'the targetFullName was passed through'); - assert.equal(sourceFullName, 'baz:qux', 'the sourceFullName was passed through'); - - return 'foo:qux/bar-fallback'; - }, - }; - - let resolver = { - expandLocalLookup: (targetFullName, sourceFullName) => { - assert.ok(true, 'expandLocalLookup is called on the resolver'); - assert.equal(targetFullName, 'foo:bar', 'the targetFullName was passed through'); - assert.equal(sourceFullName, 'baz:qux', 'the sourceFullName was passed through'); - - return 'foo:qux/bar-resolver'; - }, - }; - - let fallbackRegistry = new Registry({ - resolver: fallbackResolver, - }); - - let registry = new Registry({ - fallback: fallbackRegistry, - resolver, - }); - - let result = registry.expandLocalLookup('foo:bar', { - source: 'baz:qux', - }); - - assert.equal(result, 'foo:qux/bar-resolver', 'handled by the resolver'); - - registry.resolver = null; - - result = registry.expandLocalLookup('foo:bar', { - source: 'baz:qux', - }); - - assert.equal(result, 'foo:qux/bar-fallback', 'handled by the fallback registry'); - - registry.fallback = null; - - result = registry.expandLocalLookup('foo:bar', { - source: 'baz:qux', - }); - - assert.equal( - result, - null, - 'null is returned by default when no resolver or fallback registry is present' - ); - } - - ['@test resolver.expandLocalLookup result is cached'](assert) { - assert.expect(3); - let result; - - let resolver = { - expandLocalLookup: () => { - assert.ok(true, 'expandLocalLookup is called on the resolver'); - - return 'foo:qux/bar'; - }, - }; - - let registry = new Registry({ - resolver, - }); - - result = registry.expandLocalLookup('foo:bar', { - source: 'baz:qux', - }); - - assert.equal(result, 'foo:qux/bar'); - - result = registry.expandLocalLookup('foo:bar', { - source: 'baz:qux', - }); - - assert.equal(result, 'foo:qux/bar'); - } - - ['@test resolver.expandLocalLookup cache is busted when any unregister is called'](assert) { - assert.expect(4); - let result; - - let resolver = { - expandLocalLookup: () => { - assert.ok(true, 'expandLocalLookup is called on the resolver'); - - return 'foo:qux/bar'; - }, - }; - - let registry = new Registry({ - resolver, - }); - - result = registry.expandLocalLookup('foo:bar', { - source: 'baz:qux', - }); - - assert.equal(result, 'foo:qux/bar'); - - registry.unregister('foo:bar'); - - result = registry.expandLocalLookup('foo:bar', { - source: 'baz:qux', - }); - - assert.equal(result, 'foo:qux/bar'); - } - - ['@test resolve calls expandLocallookup when it receives options.source'](assert) { - assert.expect(3); - - let resolver = { - resolve() {}, - expandLocalLookup: (targetFullName, sourceFullName) => { - assert.ok(true, 'expandLocalLookup is called on the resolver'); - assert.equal(targetFullName, 'foo:bar', 'the targetFullName was passed through'); - assert.equal(sourceFullName, 'baz:qux', 'the sourceFullName was passed through'); - - return 'foo:qux/bar'; - }, - }; - - let registry = new Registry({ - resolver, - }); - - registry.resolve('foo:bar', { - source: 'baz:qux', - }); - } - - ['@test has uses expandLocalLookup'](assert) { - assert.expect(5); - let resolvedFullNames = []; - let result; - - let resolver = { - resolve(name) { - resolvedFullNames.push(name); - return 'yippie!'; - }, - - expandLocalLookup: (targetFullName) => { - assert.ok(true, 'expandLocalLookup is called on the resolver'); - - if (targetFullName === 'foo:bar') { - return 'foo:qux/bar'; - } else { - return null; - } - }, - }; - - let registry = new Registry({ - resolver, - }); - - result = registry.has('foo:bar', { - source: 'baz:qux', - }); - - assert.ok(result, 'found foo:bar/qux'); - - result = registry.has('foo:baz', { - source: 'baz:qux', - }); - - assert.ok(!result, 'foo:baz/qux not found'); - - assert.deepEqual(['foo:qux/bar'], resolvedFullNames); - } } ); diff --git a/packages/@ember/-internals/glimmer/lib/resolver.ts b/packages/@ember/-internals/glimmer/lib/resolver.ts index 0f27fc62974..94557d94188 100644 --- a/packages/@ember/-internals/glimmer/lib/resolver.ts +++ b/packages/@ember/-internals/glimmer/lib/resolver.ts @@ -60,13 +60,6 @@ function instrumentationPayload(name: string) { return { object: `component:${name}` }; } -function makeOptions(moduleName: string, namespace?: string): LookupOptions { - return { - source: moduleName !== undefined ? `template:${moduleName}` : undefined, - namespace, - }; -} - function componentFor( name: string, owner: Owner, @@ -120,17 +113,6 @@ function lookupComponentPair( } } -function lookupComponent(owner: Owner, name: string, options: LookupOptions): Option { - if (options.source || options.namespace) { - let pair = lookupComponentPair(owner, name, options); - - if (pair !== null) { - return pair; - } - } - return lookupComponentPair(owner, name); -} - let lookupPartial: { templateName: string; owner: Owner } | any; let templateFor: { owner: Owner; underscored: string; name: string } | any; let parseUnderscoredName: { templateName: string } | any; @@ -356,18 +338,12 @@ export default class RuntimeResolverImpl implements RuntimeResolver>( - `helper:${name}`, - options + `helper:${name}` ) || owner.factoryFor(`helper:${name}`); if (factory === undefined || factory.class === undefined) { @@ -422,11 +398,9 @@ export default class RuntimeResolverImpl implements RuntimeResolver { let name = _name; - let namespace = undefined; let owner = meta.owner; - let { moduleName } = meta; - let pair = lookupComponent(owner, name, makeOptions(moduleName, namespace)); + let pair = lookupComponentPair(owner, name); if (pair === null) { return null; } diff --git a/packages/@ember/-internals/glimmer/lib/syntax.ts b/packages/@ember/-internals/glimmer/lib/syntax.ts index 6caa7759b2e..9988b23296b 100644 --- a/packages/@ember/-internals/glimmer/lib/syntax.ts +++ b/packages/@ember/-internals/glimmer/lib/syntax.ts @@ -62,14 +62,11 @@ function refineBlockSyntax( `Helpers may not be used in the block form, for example {{#${name}}}{{/${name}}}. Please use a component, or alternatively use the helper in combination with a built-in Ember helper, for example {{#if (${name})}}{{/if}}.`, !(() => { const resolver = context.resolver['resolver']; - const { moduleName, owner } = context.meta.referrer as OwnedTemplateMeta; + const { owner } = context.meta.referrer as OwnedTemplateMeta; if (name === 'component' || resolver['builtInHelpers'][name]) { return true; } - let options = { source: `template:${moduleName}` }; - return ( - owner.hasRegistration(`helper:${name}`, options) || owner.hasRegistration(`helper:${name}`) - ); + return owner.hasRegistration(`helper:${name}`); })() ); diff --git a/packages/@ember/-internals/glimmer/tests/integration/components/local-lookup-test.js b/packages/@ember/-internals/glimmer/tests/integration/components/local-lookup-test.js deleted file mode 100644 index 0d3124c6997..00000000000 --- a/packages/@ember/-internals/glimmer/tests/integration/components/local-lookup-test.js +++ /dev/null @@ -1,283 +0,0 @@ -import { moduleFor, RenderingTestCase, runTask } from 'internal-test-helpers'; -import { Component } from '../../utils/helpers'; - -class LocalLookupTest extends RenderingTestCase { - ['@test it can lookup a local template']() { - this.registerComponent('x-outer/x-inner', { - template: 'Nested template says: {{yield}}', - }); - this.registerComponent('x-outer', { - template: '{{#x-inner}}Hi!{{/x-inner}}', - }); - - this.render('{{x-outer}}'); - - this.assertText('Nested template says: Hi!', 'Initial render works'); - - runTask(() => this.rerender()); - - this.assertText('Nested template says: Hi!', 'Re-render works'); - } - - ['@test tagless blockless component can lookup local template']() { - this.registerComponent('x-outer/x-inner', { - template: 'Nested template says: {{yield}}', - }); - this.registerTemplate('components/x-outer', '{{#x-inner}}Hi!{{/x-inner}}'); - this.registerComponent('x-outer', { - ComponentClass: Component.extend({ tagName: '' }), - }); - - this.render('{{x-outer}}'); - - this.assertText('Nested template says: Hi!', 'Re-render works'); - - runTask(() => this.rerender()); - - this.assertText('Nested template says: Hi!', 'Re-render works'); - } - - ['@test it can lookup a local component template']() { - this.registerTemplate('components/x-outer/x-inner', 'Nested template says: {{yield}}'); - this.registerTemplate('components/x-outer', '{{#x-inner}}Hi!{{/x-inner}}'); - - this.render('{{x-outer}}'); - - this.assertText('Nested template says: Hi!', 'Initial render works'); - - runTask(() => this.rerender()); - - this.assertText('Nested template says: Hi!', 'Re-render works'); - } - - ['@test it can local lookup a dynamic component']() { - this.registerComponent('foo-bar', { - template: 'yall finished {{component child}}', - }); - this.registerComponent('foo-bar/biz-baz', { template: 'or yall done?' }); - - this.render('{{foo-bar child=child}}', { child: 'biz-baz' }); - - this.assertText('yall finished or yall done?'); - - runTask(() => this.rerender()); - - this.assertText('yall finished or yall done?'); - } - - ['@test it can local lookup a dynamic component from a dynamic component']() { - this.registerComponent('foo-bar', { - template: 'yall finished {{component child}}', - }); - this.registerComponent('foo-bar/biz-baz', { template: 'or yall done?' }); - - this.render('{{component componentName child=child}}', { - componentName: 'foo-bar', - child: 'biz-baz', - }); - - this.assertText('yall finished or yall done?'); - - runTask(() => this.rerender()); - - this.assertText('yall finished or yall done?'); - } - - ['@test it can local lookup a dynamic component from a passed named argument']() { - this.registerComponent('parent-foo', { - template: `yall finished {{global-biz baz=(component 'local-bar')}}`, - }); - this.registerComponent('global-biz', { template: 'or {{component baz}}' }); - this.registerComponent('parent-foo/local-bar', { template: 'yall done?' }); - - this.render('{{parent-foo}}'); - - this.assertText('yall finished or yall done?'); - - runTask(() => this.rerender()); - - this.assertText('yall finished or yall done?'); - } - - ['@test it can local lookup a re-wrapped dynamic component from a passed named argument']() { - this.registerComponent('parent-foo', { - template: `yall finished {{global-x comp=(component 'local-bar')}}`, - }); - this.registerComponent('global-x', { - template: `or {{global-y comp=(component comp phrase='done')}}`, - }); - this.registerComponent('global-y', { template: `{{component comp}}?` }); - this.registerComponent('parent-foo/local-bar', { - template: 'yall {{phrase}}', - }); - - this.render('{{parent-foo}}'); - - this.assertText('yall finished or yall done?'); - - runTask(() => this.rerender()); - - this.assertText('yall finished or yall done?'); - } - - ['@test it can nest local lookups of dynamic components from a passed named argument']() { - this.registerComponent('parent-foo', { - template: `yall finished {{global-x comp=(component 'local-bar')}}`, - }); - this.registerComponent('global-x', { - template: `or {{global-y comp=(component comp phrase='done')}}`, - }); - this.registerComponent('global-y', { - template: `{{component comp}}{{component 'local-bar'}}`, - }); - this.registerComponent('parent-foo/local-bar', { - template: 'yall {{phrase}}', - }); - this.registerComponent('global-y/local-bar', { template: `?` }); - - this.render('{{parent-foo}}'); - - this.assertText('yall finished or yall done?'); - - runTask(() => this.rerender()); - - this.assertText('yall finished or yall done?'); - } - - ['@test it can switch from local to global lookups of dynamic components from a passed named argument']() { - this.registerComponent('parent-foo', { - template: `yall finished {{global-x comp=(component bar)}}`, - }); - this.registerComponent('global-x', { - template: `or yall {{component comp}}`, - }); - this.registerComponent('parent-foo/local-bar', { template: 'done?' }); - this.registerComponent('global-bar', { template: `ready?` }); - - this.render('{{parent-foo bar=bar}}', { bar: 'local-bar' }); - - this.assertText('yall finished or yall done?'); - - runTask(() => this.context.set('bar', 'global-bar')); - - runTask(() => this.rerender()); - - this.assertText('yall finished or yall ready?'); - } - - ['@test it can lookup a local helper']() { - this.registerHelper('x-outer/x-helper', () => { - return 'Who dis?'; - }); - this.registerComponent('x-outer', { template: 'Who dat? {{x-helper}}' }); - - this.render('{{x-outer}}'); - - this.assertText('Who dat? Who dis?', 'Initial render works'); - - runTask(() => this.rerender()); - - this.assertText('Who dat? Who dis?', 'Re-render works'); - } - - ['@test it overrides global helper lookup']() { - this.registerHelper('x-outer/x-helper', () => { - return 'Who dis?'; - }); - - this.registerHelper('x-helper', () => { - return 'I dunno'; - }); - - this.registerComponent('x-outer', { template: 'Who dat? {{x-helper}}' }); - - this.render('{{x-outer}} {{x-helper}}'); - - this.assertText('Who dat? Who dis? I dunno', 'Initial render works'); - - runTask(() => this.rerender()); - - this.assertText('Who dat? Who dis? I dunno', 'Re-render works'); - } - - ['@test lookup without match issues standard assertion (with local helper name)']() { - this.registerComponent('x-outer', { - template: '{{#x-inner}}Hi!{{/x-inner}}', - }); - - expectAssertion(() => { - this.render('{{x-outer}}'); - }, /A component or helper named "x-inner" could not be found/); - } - - ['@test overrides global lookup']() { - this.registerComponent('x-outer', { - template: '{{#x-inner}}Hi!{{/x-inner}}', - }); - this.registerComponent('x-outer/x-inner', { - template: 'Nested template says (from local): {{yield}}', - }); - this.registerComponent('x-inner', { - template: 'Nested template says (from global): {{yield}}', - }); - - this.render( - '{{#x-inner}}Hi!{{/x-inner}} {{x-outer}} {{#x-outer/x-inner}}Hi!{{/x-outer/x-inner}}' - ); - - this.assertText( - 'Nested template says (from global): Hi! Nested template says (from local): Hi! Nested template says (from local): Hi!' - ); - - runTask(() => this.rerender()); - - this.assertText( - 'Nested template says (from global): Hi! Nested template says (from local): Hi! Nested template says (from local): Hi!' - ); - } -} - -// first run these tests with expandLocalLookup - -function buildResolver() { - let resolver = { - resolve() {}, - expandLocalLookup(fullName, sourceFullName) { - if (!sourceFullName) { - return null; - } - - let [sourceType, sourceName] = sourceFullName.split(':'); - let [type, name] = fullName.split(':'); - - sourceName = sourceName.replace('my-app/', ''); - - if (sourceType === 'template' && sourceName.slice(0, 21) === 'templates/components/') { - sourceName = sourceName.slice(21); - } - - name = name.replace('my-app/', ''); - - if (type === 'template' && name.slice(0, 11) === 'components/') { - name = name.slice(11); - sourceName = `components/${sourceName}`; - } - - sourceName = sourceName.replace('.hbs', ''); - - let result = `${type}:${sourceName}/${name}`; - return result; - }, - }; - - return resolver; -} - -moduleFor( - 'Components test: local lookup with expandLocalLookup feature', - class extends LocalLookupTest { - getResolver() { - return buildResolver(); - } - } -); diff --git a/packages/@ember/-internals/metal/lib/injected_property.ts b/packages/@ember/-internals/metal/lib/injected_property.ts index 8fa15c94b33..5462e4b2bc1 100644 --- a/packages/@ember/-internals/metal/lib/injected_property.ts +++ b/packages/@ember/-internals/metal/lib/injected_property.ts @@ -11,10 +11,6 @@ if (DEBUG) { DEBUG_INJECTION_FUNCTIONS = new WeakMap(); } -export interface InjectedPropertyOptions { - source: string; -} - /** @module ember @private @@ -31,7 +27,7 @@ export interface InjectedPropertyOptions { to the property's name @private */ -function inject(type: string, name: string, options?: InjectedPropertyOptions): Decorator; +function inject(type: string, name: string): Decorator; function inject( type: string, target: object, @@ -42,7 +38,6 @@ function inject(type: string, ...args: any[]): Decorator | DecoratorPropertyDesc assert('a string type must be provided to inject', typeof type === 'string'); let calledAsDecorator = isElementDescriptor(args); - let source: string | undefined, namespace: string | undefined; let name = calledAsDecorator ? undefined : args[0]; @@ -54,13 +49,11 @@ function inject(type: string, ...args: any[]): Decorator | DecoratorPropertyDesc Boolean(owner) ); - return owner.lookup(`${type}:${name || propertyName}`, { source, namespace }); + return owner.lookup(`${type}:${name || propertyName}`); }; if (DEBUG) { DEBUG_INJECTION_FUNCTIONS.set(getInjection, { - namespace, - source, type, name, }); diff --git a/packages/@ember/-internals/owner/index.ts b/packages/@ember/-internals/owner/index.ts index 8ea8e0d0e3b..f7c1fe92a67 100644 --- a/packages/@ember/-internals/owner/index.ts +++ b/packages/@ember/-internals/owner/index.ts @@ -5,8 +5,6 @@ export interface LookupOptions { singleton?: boolean; instantiate?: boolean; - source?: string; - namespace?: string; } export interface FactoryClass { diff --git a/packages/internal-test-helpers/lib/test-resolver.js b/packages/internal-test-helpers/lib/test-resolver.js index 4a2d1075599..1290fbc8f49 100644 --- a/packages/internal-test-helpers/lib/test-resolver.js +++ b/packages/internal-test-helpers/lib/test-resolver.js @@ -18,25 +18,6 @@ class Resolver { resolve(specifier) { return this._registered[specifier] || this._registered[serializeKey(specifier)]; } - expandLocalLookup(specifier, source, namespace) { - if (specifier.indexOf('://') !== -1) { - return specifier; // an already expanded specifier - } - - if (source || namespace) { - let key = serializeKey(specifier, source, namespace); - if (this._registered[key]) { - return key; // like local lookup - } - - key = serializeKey(specifier); - if (this._registered[key]) { - return specifier; // top level resolution despite source/namespace - } - } - - return specifier; // didn't know how to expand it - } add(lookup, factory) { let key; switch (typeof lookup) { diff --git a/tests/docs/expected.js b/tests/docs/expected.js index e68d3ccdad1..ee4e360480a 100644 --- a/tests/docs/expected.js +++ b/tests/docs/expected.js @@ -214,7 +214,6 @@ module.exports = { 'every', 'exception', 'exit', - 'expandLocalLookup', 'expandProperties', 'extend', 'factoryFor',