implab/implabjs-core Commit - r158:7e27596a76a8

Added test: Optional dependency with child container...

cin -

r158:7e27596a76a8 default

parent child

Context file:

r158:7e27596a76a8

Collapse all files

src/main/ts/di/ActivationContext.ts +1 -1

             import { TraceSource } from "../log/TraceSource";
             import { argumentNotEmptyString } from "../safe";
             import { Descriptor, ContainerServiceMap, ContainerKeys, TypeOfService, ILifetime, ServiceContainer } from "./interfaces";
             import { MapOf } from "../interfaces";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
             export interface ActivationContextInfo {
                 name: string;
                 service: string;
             }
             let nextId = 1;
             /** This class is created once per `Container.resolve` method call and used to
              * cache dependencies and to track created instances. The activation context
              * tracks services with `context` activation type.
              */
             export class ActivationContext<S extends object> {
                 _cache: MapOf<any>;
                 _services: ContainerServiceMap<S>;
                 _visited: MapOf<any>;
                 _name: string;
                 _service: Descriptor<S, any>;
                 _container: ServiceContainer<S>;
                 _parent: ActivationContext<S> | undefined;
                 /** Creates a new activation context with the specified parameters.
                  * @param container the container which starts the activation process
                  * @param services the initial service registrations
                  * @param name the name of the service being activated, this parameter is
                  *  used for the debug purpose.
                  * @param service the service to activate, this parameter is used for the
                  *  debug purpose.
                  */
                 constructor(container: ServiceContainer<S>, services: ContainerServiceMap<S>, name: string, service: Descriptor<S, any>) {
                     this._name = name;
                     this._service = service;
                     this._visited = {};
                     this._cache = {};
                     this._services = services;
                     this._container = container;
                 }
                 /** the name of the current resolving dependency */
                 getName() {
                     return this._name;
                 }
                 /** Returns the container for which 'resolve' method was called */
                 getContainer() {
                     return this._container;
                 }
                 /** Resolves the specified dependency in the current context
                  * @param name The name of the dependency being resolved
                  */
                 resolve<K extends ContainerKeys<S>>(name: K): TypeOfService<S, K>;
                 /** Resolves the specified dependency with the specified default value if
                  * the dependency is missing.
                  *
                  * @param name The name of the dependency being resolved
                  * @param def A default value to return in case of the specified dependency
                  *   is missing.
                  */
                 resolve<K extends ContainerKeys<S>, T>(name: K, def: T): TypeOfService<S, K> | T;
                 /** Resolves the specified dependency and returns undefined in case if the
                  * dependency is missing.
                  *
                  * @param name The name of the dependency being resolved
                  */
                 resolve<K extends ContainerKeys<S>>(name: K, def: undefined): TypeOfService<S, K> | undefined;
                 resolve<K extends ContainerKeys<S>, T>(name: K, def?: T): TypeOfService<S, K> | T | undefined {
                     const d = this._services[name];
                     if (d !== undefined) {
                         return this.activate(d, name.toString());
                     } else {
                         if (arguments.length > 1)
                             return def;
                         else
                             throw new Error(`Service ${name} not found`);
                     }
                 }
                 /**
                  * registers services local to the the activation context
                  *
                  * @name{string} the name of the service
                  * @service{string} the service descriptor to register
                  */
                 register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>) {
                     argumentNotEmptyString(name, "name");
                     this._services[name] = service as any;
                 }
                 createLifetime(): ILifetime {
                     const id = nextId++;
                     const me = this;
                     return {
                         initialize() {
                         },
                         has() {
                             return id in me._cache;
                         },
                         get() {
                             return me._cache[id];
                         },
                         store(item: any) {
                             me._cache[id] = item;
                         }
                     };
                 }
                 activate<T>(d: Descriptor<S, T>, name: string) {
                     if (trace.isLogEnabled())
-                        trace.log(`enter ${name} ${d}`);
+                        trace.log("enter {0} {1}", name, d);
                     const ctx = this.enter(d, name);
                     const v = d.activate(ctx);
                     if (trace.isLogEnabled())
                         trace.log(`leave ${name}`);
                     return v;
                 }
                 visit(id: string) {
                     const count = this._visited[id] || 0;
                     this._visited[id] = count + 1;
                     return count;
                 }
                 getStack(): ActivationContextInfo[] {
                     const stack = [{
                         name: this._name,
                         service: this._service.toString()
                     }];
                     return this._parent ?
                         stack.concat(this._parent.getStack()) :
                         stack;
                 }
                 private enter(service: Descriptor<S, any>, name: string): this {
                     const clone = Object.create(this);
                     clone._name = name;
                     clone._services = Object.create(this._services);
                     clone._parent = this;
                     clone._service = service;
                     return clone;
                 }
                 /** Creates a clone for the current context, used to protect it from modifications */
                 clone(): this {
                     const clone = Object.create(this);
                     clone._services = Object.create(this._services);
                     return clone;
                 }
             }

src/main/ts/di/LifetimeManager.ts +22 -3

             import { IDestroyable, MapOf } from "../interfaces";
             import { argumentNotNull, isDestroyable, argumentNotEmptyString, isRemovable } from "../safe";
             import { ILifetime, ServiceContainer } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
             function safeCall(item: () => void) {
                 try {
                     item();
                 } catch {
                     // silence!
                 }
             }
             const emptyLifetime: ILifetime = Object.freeze({
                 has() {
                     return false;
                 },
                 initialize() {
                 },
                 get() {
                     throw new Error("The specified item isn't registered with this lifetime manager");
                 },
                 store() {
                     // does nothing
+                },
+                toString() {
+                    return `[object EmptyLifetime]`;
                 }
             });
             const unknownLifetime: ILifetime = Object.freeze({
                 has() {
                     return false;
                 },
                 initialize() {
                     throw new Error("Can't call initialize on the unknown lifetime object");
                 },
                 get() {
                     throw new Error("The lifetime object isn't initialized");
                 },
                 store() {
                     throw new Error("Can't store a value in the unknown lifetime object");
+                },
+                toString() {
+                    return `[object UnknownLifetime]`;
                 }
             });
             let nextId = 0;
             const singletons: any = {};
             export class LifetimeManager implements IDestroyable {
                 private _cleanup: (() => void)[] = [];
                 private _cache: MapOf<any> = {};
                 private _destroyed = false;
                 private _pending: MapOf<boolean> = {};
                 create(): ILifetime {
                     const self = this;
                     const id = ++nextId;
                     return {
                         has() {
                             return (id in self._cache);
                         },
                         get() {
                             const t = self._cache[id];
                             if (t === undefined)
                                 throw new Error(`The item with with the key ${id} isn't found`);
                             return t;
                         },
                         initialize() {
                             if (self._pending[id])
                                 throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
                             self._pending[id] = true;
                         },
                         store(item: any, cleanup?: (item: any) => void) {
                             argumentNotNull(id, "id");
                             argumentNotNull(item, "item");
                             if (this.has())
                                 throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
                             delete self._pending[id];
                             self._cache[id] = item;
                             if (self._destroyed)
                                 throw new Error("Lifetime manager is destroyed");
                             if (cleanup) {
                                 self._cleanup.push(() => cleanup(item));
                             } else if (isDestroyable(item)) {
                                 self._cleanup.push(() => item.destroy());
                             } else if (isRemovable(item)) {
                                 self._cleanup.push(() => item.remove());
                             }
                         }
                     };
                 }
                 destroy() {
                     if (!this._destroyed) {
                         this._destroyed = true;
                         this._cleanup.forEach(safeCall);
                         this._cleanup.length = 0;
                     }
                 }
                 static empty(): ILifetime {
                     return emptyLifetime;
                 }
-                static hierarchyLifetime(): ILifetime {
+                static hierarchyLifetime() {
                     let _lifetime = unknownLifetime;
                     return {
                         initialize(context: ActivationContext<any>) {
                             if (_lifetime !== unknownLifetime)
                                 throw new Error("Cyclic reference activation detected");
                             _lifetime = context.getContainer().getLifetimeManager().create();
                         },
                         get() {
                             return _lifetime.get();
                         },
                         has() {
                             return _lifetime.has();
                         },
                         store(item: any, cleanup?: (item: any) => void) {
                             return _lifetime.store(item, cleanup);
+                        },
+                        toString() {
+                            return `[object HierarchyLifetime, has=${this.has()}]`;
                         }
                     };
                 }
-                static contextLifetime(): ILifetime {
+                static contextLifetime() {
                     let _lifetime = unknownLifetime;
                     return {
                         initialize(context: ActivationContext<any>) {
                             if (_lifetime !== unknownLifetime)
                                 throw new Error("Cyclic reference detected");
                             _lifetime = context.createLifetime();
                         },
                         get() {
                             return _lifetime.get();
                         },
                         has() {
                             return _lifetime.has();
                         },
                         store(item: any) {
                             _lifetime.store(item);
+                        },
+                        toString() {
+                            return `[object ContextLifetime, has=${this.has()}]`;
                         }
                     };
                 }
-                static singletonLifetime(typeId: string): ILifetime {
+                static singletonLifetime(typeId: string) {
                     argumentNotEmptyString(typeId, "typeId");
                     let pending = false;
                     return {
                         has() {
                             return typeId in singletons;
                         },
                         get() {
                             if (!this.has())
                                 throw new Error(`The instance ${typeId} doesn't exists`);
                             return singletons[typeId];
                         },
                         initialize() {
                             if (pending)
                                 throw new Error("Cyclic reference detected");
                             pending = true;
                         },
                         store(item: any) {
                             singletons[typeId] = item;
                             pending = false;
+                        },
+                        toString() {
+                            return `[object SingletonLifetime, has=${this.has()}, typeId=${typeId}]`;
                         }
                     };
                 }
                 static containerLifetime(container: ServiceContainer<any>) {
                     let _lifetime = unknownLifetime;
                     return {
                         initialize(context: ActivationContext<any>) {
                             if (_lifetime !== unknownLifetime)
                                 throw new Error("Cyclic reference detected");
                             _lifetime = container.getLifetimeManager().create();
                         },
                         get() {
                             return _lifetime.get();
                         },
                         has() {
                             return _lifetime.has();
                         },
                         store(item: any) {
                             _lifetime.store(item);
+                        },
+                        toString() {
+                            return `[object ContainerLifetime, has=${_lifetime.has()}]`
                         }
                     };
                 }
             }

src/main/ts/di/fluent/DescriptorImpl.ts +3 0

             import { Descriptor, PartialServiceMap, ILifetime, ContainerKeys } from "../interfaces";
             import { ActivationContext } from "../ActivationContext";
             import { each } from "../../safe";
             import { DependencyOptions, LazyDependencyOptions, Resolver } from "./interfaces";
             export interface DescriptorImplArgs<S extends object, T> {
                 lifetime: ILifetime;
                 factory: (resolve: Resolver<S>) => T;
                 cleanup?: (item: T) => void;
                 overrides?: PartialServiceMap<S>;
             }
             export class DescriptorImpl<S extends object, T> implements Descriptor<S, T> {
                 private readonly _overrides?: PartialServiceMap<S>;
                 private readonly _lifetime: ILifetime;
                 private readonly _factory: (resolve: Resolver<S>) => T;
                 private readonly _cleanup?: (item: T) => void;
                 constructor(args: DescriptorImplArgs<S, T>) {
                     this._lifetime = args.lifetime;
                     this._factory = args.factory;
                     if (args.cleanup)
                         this._cleanup = args.cleanup;
                     if (args.overrides)
                         this._overrides = args.overrides;
                 }
                 activate(context: ActivationContext<S>): T {
                     if (this._lifetime.has())
                         return this._lifetime.get();
                     this._lifetime.initialize(context);
                     if (this._overrides)
                         each(this._overrides, (v, k) => context.register(k, v));
                     const resolve = (name: ContainerKeys<S>, opts?: DependencyOptions | LazyDependencyOptions) => {
                         if (opts && "lazy" in opts && opts.lazy) {
                             const c2 = context.clone();
                             return () => {
                                 return opts.optional ? c2.resolve(name, opts.default) : c2.resolve(name);
                             };
                         } else {
                             return opts && opts.optional ? context.resolve(name, opts.default) : context.resolve(name);
                         }
                     };
                     const instance = this._factory.call(undefined, resolve);
                     this._lifetime.store(instance, this._cleanup);
                     return instance;
                 }
+                toString() {
+                    return `[object DescriptorImpl, lifetime=${this._lifetime}]`;
                 }
+            }

src/test/ts/tests/ContainerTests.ts +19 0

             import { test } from "./TestTraits";
             import { Container } from "../di/Container";
             import { ReferenceDescriptor } from "../di/ReferenceDescriptor";
             import { AggregateDescriptor } from "../di/AggregateDescriptor";
             import { ValueDescriptor } from "../di/ValueDescriptor";
             import { Foo } from "../mock/Foo";
             import { Bar } from "../mock/Bar";
             import { isNull } from "../safe";
+            import { Box } from "../mock/Box";
             test("Container register/resolve tests", async t => {
                 const container = new Container<{
                     "bla-bla": string;
                     "connection": string;
                     "dbParams": {
                         timeout: number;
                         connection: string;
                     }
                 }>();
                 const connection1 = "db://localhost";
                 t.throws(
                     () => container.register("bla-bla", "bla-bla" as any),
                     "Do not allow to register anything other than descriptors"
                 );
                 t.doesNotThrow(
                     () => container.register("connection", new ValueDescriptor(connection1)),
                     "register ValueDescriptor"
                 );
                 t.equals(container.resolve("connection"), connection1, "resolve string value");
                 t.doesNotThrow(
                     () => container.register(
                         "dbParams",
                         new AggregateDescriptor({
                             timeout: 10,
                             connection: new ReferenceDescriptor({ name: "connection" })
                         })
                     ),
                     "register AggregateDescriptor"
                 );
                 const dbParams = container.resolve("dbParams");
                 t.equals(dbParams.connection, connection1, "should get string value 'dbParams.connection'");
             });
             test("Container configure/resolve tests", async t => {
                 const container = new Container<{
                     foo: Foo;
                     box: Bar;
                     bar: Bar;
                     db: any;
                 }>();
                 await container.configure({
                     foo: {
                         $type: Foo
                     },
                     box: {
                         $type: Bar,
                         params: {
                             $dependency: "foo"
                         }
                     },
                     bar: {
                         $type: Bar,
                         params: [{
                             db: {
                                 provider: {
                                     $dependency: "db"
                                 }
                             }
                         }]
                     }
                 });
                 t.pass("should configure from js object");
                 const f1 = container.resolve("foo");
                 t.assert(!isNull(f1), "foo should be not null");
                 t.throws(() => container.resolve("bar"), "should not resolve dependency 'db'");
             });
             test("Load configuration from module", async t => {
                 const container = new Container();
                 await container.configure("../mock/config1", { contextRequire: require });
                 t.pass("The configuration should load");
                 const f1 = container.resolve("foo");
                 t.assert(!isNull(f1), "foo should be not null");
                 const b1 = container.resolve("bar") as Bar;
                 t.assert(!isNull(b1), "bar should not be null");
                 t.assert(!isNull(b1._v), "bar.foo should not be null");
             });
+            test("Optional dependency with child container", async t => {
+                const container = new Container<{
+                    foo?: Foo;
+                    box: Box<Foo>;
+                }>();
+                await container.fluent({
+                    box: it => it.factory($ => new Box($("foo")))
+                });
+                const child = await container.createChildContainer()
+                    .fluent({
+                        foo: it => it.factory(() => new Foo())
+                    })
+                const box = child.resolve("box");
+                t.assert(!isNull(box.getValue()), "'foo' dependency is declared in child container");
+            });
  No newline at end of file

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages