implab/implabjs-core Commit - r131:674555892e14

Refactoring, working on services lifetime

cin -

r131:674555892e14 ioc ts support

parent child

Context file:

r131:674555892e14

Collapse all files

src/main/ts/di/ActivationContext.ts +34 -49

             import { TraceSource } from "../log/TraceSource";
             import { argumentNotNull, argumentNotEmptyString } from "../safe";
-            import { Descriptor, ContainerProvided, ContainerServiceMap, ContainerKeys, ContainerResolve } from "./interfaces";
+            import { Descriptor, ContainerServiceMap, ContainerKeys, ContainerResolve } from "./interfaces";
             import { Container } from "./Container";
             import { MapOf } from "../interfaces";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
-            export interface ActivationContextInfo<S extends object> {
+            export interface ActivationContextInfo {
                 name: string;
                 service: string;
-                scope: ContainerServiceMap<S>;
             }
             export class ActivationContext<S extends object> {
                 _cache: MapOf<any>;
                 _services: ContainerServiceMap<S>;
-                _stack: ActivationContextInfo<S>[];
                 _visited: MapOf<any>;
                 _name: string;
-                _localized: boolean = false;
+                _service: Descriptor<S, any>;
-                container: Container<S>;
+                _container: Container<S>;
+                _parent: ActivationContext<S> | undefined;
-                constructor(container: Container<S>, services: ContainerServiceMap<S>, name?: string, cache?: object, visited?: MapOf<any>) {
+                constructor(container: Container<S>, services: ContainerServiceMap<S>, name: string, service: Descriptor<S, any>) {
-                    argumentNotNull(container, "container");
+                    this._name = name;
-                    argumentNotNull(services, "services");
+                    this._service = service;
+                    this._visited = {};
-                    this._name = name || "<unnamed>";
+                    this._cache = {};
-                    this._visited = visited || {};
-                    this._stack = [];
-                    this._cache = cache || {};
                     this._services = services;
-                    this.container = container;
+                    this._container = container;
                 }
                 getName() {
                     return this._name;
                 }
+                getContainer() {
+                    return this._container;
+                }
                 resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>) {
                     const d = this._services[name];
                     if (d !== undefined) {
                         return this.activate(d, name.toString());
                     } else {
                         if (def !== undefined && def !== null)
                             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;
                 }
-                clone() {
-                    return new ActivationContext<S>(
-                        this.container,
-                        this._services,
-                        this._name,
-                        this._cache,
-                        this._visited
-                    );
                 has(id: string) {
                     return id in this._cache;
                 }
                 get<T>(id: string) {
                     return this._cache[id];
                 }
                 store(id: string, value: any) {
                     return (this._cache[id] = value);
                 }
                 activate<T>(d: Descriptor<S, T>, name: string) {
                     if (trace.isLogEnabled())
                         trace.log(`enter ${name} ${d}`);
-                    this.enter(name, d.toString());
+                    const ctx = this.enter(d, name);
-                    const v = d.activate(this);
+                    const v = d.activate(ctx);
-                    this.leave();
                     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() {
+                getStack(): ActivationContextInfo[] {
-                    return this._stack.slice().reverse();
+                    const stack = [{
+                        name: this._name,
+                        service: this._service.toString()
+                    }];
+                    return this._parent ?
+                        stack.concat(this._parent.getStack()) :
+                        stack;
                 }
-                private enter(name: string, service: string) {
+                private enter(service: Descriptor<S, any>, name: string): this {
-                    this._stack.push({
+                    const clone = Object.create(this);
-                        name,
+                    clone._name = name;
-                        service,
+                    clone._services = Object.create(this._services);
-                        scope: this._services
+                    clone._parent = this;
-                    });
+                    clone._service = service;
-                    this._name = name;
+                    return clone;
-                    this._services = Object.create(this._services);
-                private leave() {
-                    const ctx = this._stack.pop();
-                    if (ctx) {
-                        this._services = ctx.scope;
-                        this._name = ctx.name;
-                    } else {
-                        trace.error("Trying to leave the last activation scope");
                 }
             }

src/main/ts/di/Container.ts +13 -21

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
-            import { ServiceMap, Descriptor, PartialServiceMap, ContainerProvided, Resolver, ContainerServiceMap, ContainerKeys, ContainerResolve } from "./interfaces";
+            import { ServiceMap, Descriptor, PartialServiceMap, ContainerProvided, Resolver, ContainerServiceMap, ContainerKeys, ContainerResolve, ILifetimeManager } from "./interfaces";
             import { TraceSource } from "../log/TraceSource";
             import { Configuration, RegistrationMap } from "./Configuration";
             import { Cancellation } from "../Cancellation";
             import { MapOf, IDestroyable } from "../interfaces";
             import { isDescriptor } from "./traits";
+            import { LifetimeManager } from "./LifetimeManager";
+            import { each } from "../safe";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
             export class Container<S extends object = any> implements Resolver<S>, IDestroyable {
                 readonly _services: ContainerServiceMap<S>;
                 readonly _cache: MapOf<any>;
+                readonly _lifetimeManager: ILifetimeManager;
                 readonly _cleanup: (() => void)[];
                 readonly _root: Container<S>;
                 readonly _parent?: Container<S>;
                 _disposed: boolean;
                 constructor(parent?: Container<S>) {
                     this._parent = parent;
                     this._services = parent ? Object.create(parent._services) : {};
                     this._cache = {};
                     this._cleanup = [];
                     this._root = parent ? parent.getRootContainer() : this;
                     this._services.container = new ValueDescriptor(this) as any;
                     this._disposed = false;
+                    this._lifetimeManager = new LifetimeManager();
                 }
                 getRootContainer() {
                     return this._root;
                 }
                 getParent() {
                     return this._parent;
                 }
+                getLifetimeManager() {
+                    return this._lifetimeManager;
+                }
                 resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>): ContainerResolve<S, K> {
                     trace.debug("resolve {0}", name);
                     const d = this._services[name];
                     if (d === undefined) {
                         if (def !== undefined)
                             return def;
                         else
                             throw new Error("Service '" + name + "' isn't found");
                     } else {
-                        const context = new ActivationContext<S>(this, this._services);
+                        const context = new ActivationContext<S>(this, this._services, String(name), d);
                         try {
-                            return context.activate(d, name.toString());
+                            return d.activate(context);
                         } catch (error) {
                             throw new ActivationError(name.toString(), context.getStack(), error);
                         }
                     }
                 }
                 /**
                  * @deprecated use resolve() method
                  */
                 getService<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>) {
                     return this.resolve(name, def);
                 }
                 register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>): this;
                 register(services: PartialServiceMap<S>): this;
                 register<K extends keyof S>(nameOrCollection: K | ServiceMap<S>, service?: Descriptor<S, S[K]>) {
                     if (arguments.length === 1) {
                         const data = nameOrCollection as ServiceMap<S>;
-                        for (const name in data) {
+                        each(data, (v, k) => this.register(k, v));
-                            if (Object.prototype.hasOwnProperty.call(data, name)) {
-                                this.register(name, data[name] as Descriptor<S, S[keyof S]>);
                     } else {
                         if (!isDescriptor(service))
                             throw new Error("The service parameter must be a descriptor");
                         this._services[nameOrCollection as K] = service as any;
                     }
                     return this;
                 }
                 onDispose(callback: () => void) {
                     if (!(callback instanceof Function))
                         throw new Error("The callback must be a function");
                     this._cleanup.push(callback);
                 }
                 destroy() {
                     return this.dispose();
                 }
                 dispose() {
                     if (this._disposed)
                         return;
                     this._disposed = true;
                     for (const f of this._cleanup)
                         f();
                 }
                 /**
                  * @param{String|Object} config
                  *  The configuration of the contaier. Can be either a string or an object,
                  *  if the configuration is an object it's treated as a collection of
                  *  services which will be registed in the contaier.
                  *
                  * @param{Function} opts.contextRequire
                  *  The function which will be used to load a configuration or types for services.
                  *
                  */
                 async configure(config: string | RegistrationMap<S>, opts?: any, ct = Cancellation.none) {
                     const c = new Configuration<S>(this);
                     if (typeof (config) === "string") {
                         return c.loadConfiguration(config, opts && opts.contextRequire, ct);
                     } else {
                         return c.applyConfiguration(config, opts && opts.contextRequire, ct);
                     }
                 }
                 createChildContainer<S2 extends object = S>(): Container<S & S2> {
                     return new Container<S & S2>(this as any);
                 }
-                has(id: string | number) {
-                    return id in this._cache;
-                get(id: string | number) {
-                    return this._cache[id];
-                store(id: string | number, value: any) {
-                    return (this._cache[id] = value);
             }

src/main/ts/di/LifetimeManager.ts +64 -15

             import { IDestroyable, MapOf } from "../interfaces";
             import { argumentNotNull, isDestroyable } from "../safe";
             import { ILifetimeManager, ILifetime } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
             function safeCall(item: () => void) {
                 try {
                     item();
                 } catch {
-                    // silence
+                    // silence!
                 }
             }
+            const emptyLifetime: ILifetime = {
+                has() {
+                    return false;
+                },
+                enter() {
+                },
+                get() {
+                    throw new Error("The specified item isn't registered with this lifetime manager");
+                },
+                store() {
+                    // does nothing
+                }
+            };
             export class LifetimeManager implements IDestroyable, ILifetimeManager {
                 private _cleanup: (() => void)[] = [];
                 private _cache: MapOf<any> = {};
                 private _destroyed = false;
-                initialize(id: string, context: ActivationContext<any>): ILifetime {
+                initialize(id: string): ILifetime {
                     const self = this;
                     let pending = false;
                     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;
                         },
                         enter() {
                             if (pending)
                                 throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
                             pending = 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`);
                             pending = false;
                             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());
                             }
                         }
                     };
                 }
                 destroy() {
                     if (!this._destroyed) {
                         this._destroyed = true;
                         this._cleanup.forEach(safeCall);
                         this._cleanup.length = 0;
                     }
                 }
                 static readonly empty: ILifetimeManager = {
-                    has() {
+                    initialize(): ILifetime {
-                        return false;
+                        return emptyLifetime;
                     },
+                    destroy() {
+                        throw new Error("Trying to destroy empty lifetime manager, this is a bug.");
+                    }
+                };
+                static readonly hierarchyLifetime: ILifetimeManager = {
+                    initialize(id: string, context: ActivationContext<any>): ILifetime {
+                        return context.getContainer().getLifetimeManager().initialize(id, context);
+                    },
+                    destroy() {
+                        throw new Error("Trying to destroy hierarchy lifetime manager, this is a bug.");
+                    }
+                };
-                    get() {
+                static readonly singletonLifetime: ILifetimeManager = {
-                        throw new Error("The specified item isn't registered with this lifetime manager");
+                    initialize(id: string): ILifetime {
+                        return singletonLifetimeManager.initialize(id);
                     },
+                    destroy() {
+                        throw new Error("Trying to destroy singleton lifetime manager, this is a bug.");
+                    }
+                };
-                    register() {
+                static readonly contextLifetime: ILifetimeManager = {
-                        // does nothing
+                    initialize(id: string, context: ActivationContext<any>): ILifetime {
+                        return {
+                            enter() {
+                                if (context.visit(id))
+                                    throw new Error("Cyclic reference detected");
+                            },
+                            get() {
+                                return context.get(id);
+                            },
+                            has() {
+                                return context.has(id);
+                            },
+                            store(item: any) {
+                                context.store(id, item);
+                            }
+                        };
                     },
                     destroy() {
                         throw new Error("Trying to destroy empty lifetime manager, this is a bug.");
                     }
                 };
             }
+            const singletonLifetimeManager = new LifetimeManager();

src/main/ts/di/ServiceDescriptor.ts +10 -3

             import { ActivationContext } from "./ActivationContext";
-            import { Descriptor, ServiceMap, PartialServiceMap, ActivationType, ILifetimeManager } from "./interfaces";
+            import { Descriptor, ServiceMap, PartialServiceMap, ILifetimeManager } from "./interfaces";
             import { argumentNotNull, isPrimitive, keys, isNull } from "../safe";
             import { TraceSource } from "../log/TraceSource";
             import { isDescriptor } from "./traits";
             import { LifetimeManager } from "./LifetimeManager";
             import { MatchingMemberKeys } from "../interfaces";
+            import { Container } from "./Container";
             let cacheId = 0;
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
             function injectMethod<T, M extends keyof T, S extends object, A>(target: T, method: M, context: ActivationContext<S>, args: A) {
                 const m = target[method];
                 if (!m || typeof m !== "function")
                     throw new Error("Method '" + method + "' not found");
                 if (args instanceof Array)
                     return m.apply(target, _parse(args, context, "." + method));
                 else
                     return m.call(target, _parse(args, context, "." + method));
             }
             function makeCleanupCallback<T>(method: Cleaner<T>) {
                 if (typeof (method) === "function") {
                     return (target: T) => {
                         method(target);
                     };
                 } else {
                     return (target: T) => {
                         const m = target[method] as any;
                         m.apply(target);
                     };
                 }
             }
             function _parse(value: any, context: ActivationContext<any>, path: string): any {
                 if (isPrimitive(value))
                     return value as any;
                 trace.debug("parse {0}", path);
                 if (isDescriptor(value))
                     return context.activate(value, path);
                 if (value instanceof Array)
                     return value.map((x, i) => _parse(x, context, `${path}[${i}]`)) as any;
                 const t: any = {};
                 keys(value).forEach(p => t[p] = _parse(value[p], context, `${path}.${p}`));
                 return t;
             }
             export type Cleaner<T> = ((x: T) => void) | MatchingMemberKeys<() => void, T>;
             export type InjectionSpec<T> = {
                 [m in keyof T]?: any;
             };
             export interface ServiceDescriptorParams<S extends object, T, P extends any[]> {
-                lifetime: ILifetimeManager;
+                owner: Container<S>;
+                lifetime?: ILifetimeManager;
                 params?: P;
                 inject?: InjectionSpec<T>[];
                 services?: PartialServiceMap<S>;
                 cleanup?: Cleaner<T>;
             }
             export class ServiceDescriptor<S extends object, T, P extends any[]> implements Descriptor<S, T> {
                 _services: ServiceMap<S>;
                 _params: P | undefined;
                 _inject: InjectionSpec<T>[];
                 _cleanup: ((item: T) => void) | undefined;
                 _cacheId = String(++cacheId);
                 _lifetime = LifetimeManager.empty;
+                _owner: Container<S>;
                 constructor(opts: ServiceDescriptorParams<S, T, P>) {
-                    argumentNotNull(opts, "opts");
+                    argumentNotNull(opts && opts.owner, "opts.owner");
+                    this._owner = opts.owner;
                     if (opts.lifetime)
                         this._lifetime = opts.lifetime;
                     if (!isNull(opts.params))
                         this._params = opts.params;
                     this._inject = opts.inject || [];
                     this._services = (opts.services || {}) as ServiceMap<S>;
                     if (opts.cleanup) {
                         if (!(typeof (opts.cleanup) === "string" || opts.cleanup instanceof Function))
                             throw new Error(
                                 "The cleanup parameter must be either a function or a function name");
                         this._cleanup = makeCleanupCallback(opts.cleanup);
                     }
                 }
                 activate(context: ActivationContext<S>) {
                     const lifetime = this._lifetime.initialize(this._cacheId, context);
                     if (lifetime.has()) {
                         return lifetime.get();
                     } else {
                         lifetime.enter();
                         const instance = this._create(context);
                         lifetime.store(this._cacheId, this._cleanup);
                         return instance;
                     }
                 }
                 _factory(...params: any[]): T {
                     throw Error("Not implemented");
                 }
                 _create(context: ActivationContext<S>) {
                     trace.debug(`constructing ${context._name}`);
                     if (this._services) {
                         keys(this._services).forEach(p => context.register(p, this._services[p]));
                     }
                     let instance: T;
                     if (this._params === undefined) {
                         instance = this._factory();
                     } else if (this._params instanceof Array) {
                         instance = this._factory.apply(this, _parse(this._params, context, "args"));
                     } else {
                         instance = this._factory(_parse(this._params, context, "args"));
                     }
                     if (this._inject) {
                         this._inject.forEach(spec => {
                             for (const m in spec)
                                 injectMethod(instance, m, context, spec[m]);
                         });
                     }
                     return instance;
                 }
                 clone() {
                     return Object.create(this);
                 }
             }

src/main/ts/di/interfaces.ts 0 -2

             import { ActivationContext } from "./ActivationContext";
             import { IDestroyable } from "../interfaces";
             export interface Descriptor<S extends object = any, T = any> {
                 activate(context: ActivationContext<S>): T;
-                clone(): this;
             }
             export type ServiceMap<S extends object> = {
                 [k in keyof S]: Descriptor<S, S[k]>;
             };
             export type ContainerKeys<S extends object> = keyof S | keyof ContainerProvided<S>;
             export type ContainerResolve<S extends object, K> =
                 K extends keyof ContainerProvided<S> ? ContainerProvided<S>[K] :
                 K extends keyof S ? S[K] : never;
             export type ContainerServiceMap<S extends object> = {
                 [K in ContainerKeys<S>]: Descriptor<S, ContainerResolve<S, K>>;
             };
             export type PartialServiceMap<S extends object> = {
                 [k in keyof S]?: Descriptor<S, S[k]>;
             };
             export interface Resolver<S extends object> {
                 resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>): ContainerResolve<S, K>;
             }
             export interface ContainerProvided<S extends object> {
                 container: Resolver<S>;
             }
             export type ContainerRegistered<S extends object> = /*{
                 [K in Exclude<keyof S, keyof ContainerProvided<S>>]: S[K];
             };*/
                 Exclude<S, ContainerProvided<S>>;
             export type ActivationType = "singleton" | "container" | "hierarchy" | "context" | "call";
             export interface ILifetimeManager extends IDestroyable {
                 initialize(id: string, context: ActivationContext<any>): ILifetime;
             }
             export interface ILifetime {
                 has(): boolean;
                 get(): any;
                 enter(): void;
                 store(item: any, cleanup?: (item: any) => void): void;
             }

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