implab/implabjs-core Commit - r172:3969a8fb8049

Added CancelledError, fixed lint warnings

cin -

parent child

Context file:

r172:3969a8fb8049

Collapse all files

src/main/ts/CancelledError.ts created 644 +12 0

@@ -0,0 +1,12
	1	import { Cancellation } from "./Cancellation";
	2	import { ICancellation } from "./interfaces";
	3
	4	export class CancelledError extends Error {
	5	readonly cancellationToken: ICancellation;
	6
	7	constructor(message = "The operation is cancelled", ct = Cancellation.none) {
	8	super(message);
	9	this.cancellationToken = ct;
	10	this.name = "CancelledError";
	11	}
	12	}

src/main/ts/Cancellation.ts +7 -6

             import { CancellationAggregate } from "./CancellationAggregate";
+            import { CancelledError } from "./CancelledError";
             import { ICancellation, IDestroyable } from "./interfaces";
             import { argumentNotNull, destroyed } from "./safe";
             export class Cancellation implements ICancellation {
                 private _reason: any;
                 private _cbs: Array<(e: any) => void> | undefined;
                 constructor(action: (cancel: (e?: any) => void) => void) {
                     argumentNotNull(action, "action");
                     action(this._cancel.bind(this));
                 }
                 isSupported(): boolean {
                     return true;
                 }
                 throwIfRequested(): void {
                     if (this._reason)
                         throw this._reason;
                 }
                 isRequested(): boolean {
                     return !!this._reason;
                 }
                 register(cb: (e: any) => void): IDestroyable {
                     argumentNotNull(cb, "cb");
                     if (this._reason) {
                         cb(this._reason);
                         return destroyed;
                     } else {
                         if (!this._cbs)
                             this._cbs = [cb];
                         else
                             this._cbs.push(cb);
                         const me = this;
                         return {
                             destroy() {
                                 me._unregister(cb);
                             }
                         };
                     }
                 }
                 private _unregister(cb: any) {
                     if (this._cbs) {
                         const i = this._cbs.indexOf(cb);
                         if (i >= 0)
                             this._cbs.splice(i, 1);
                     }
                 }
                 private _cancel(reason: any) {
                     if (this._reason)
                         return;
-                    this._reason = (reason = reason || new Error("Operation cancelled"));
+                    this._reason = (reason = reason || new CancelledError(undefined, this));
                     if (this._cbs) {
                         this._cbs.forEach(cb => cb(reason));
                         this._cbs = undefined;
                     }
                 }
                 static readonly none: ICancellation = {
                     isSupported(): boolean {
                         return false;
                     },
                     throwIfRequested(): void {
                     },
                     isRequested(): boolean {
                         return false;
                     },
                     register(_cb: (e: any) => void): IDestroyable {
                         return destroyed;
                     }
                 };
                 /**
                  * Combines multiple cancellation tokens to the single aggregated token.
+                 *
                  * Aggregated token will be considered as signalled when some tokens are
                  * signalled. The cancellation callback can be registered with the `register`
                  * method, it will be fired once with the first signalled token, all other
                  * tokens will be ignored.
+                 *
                  * The tokens which don't support cancellation are filtered out, if there are
                  * no tokens left in the list the method returns `Cancellation.none`.
+                 *
                  * @param args The list of cancellation tokens to combine
-                 * @returns
+                 * @returns Aggregated cancellation token
                  */
                 static combine(...args: ICancellation[]) {
                     const tokens = args.filter(ct => ct.isSupported());
                     return tokens.length > 1 ?
                         new CancellationAggregate(tokens) :
-                        tokens.length == 1 ? tokens[0] :
+                        tokens.length === 1 ? tokens[0] :
                             this.none;
                 }
             }

src/main/ts/CancellationAggregate.ts +4 -4

             import { ICancellation, IDestroyable } from "./interfaces";
             export class CancellationAggregate implements ICancellation {
                 private readonly _tokens: ICancellation[];
                 constructor(tokens: ICancellation[]) {
                     this._tokens = tokens || [];
                 }
                 throwIfRequested() {
                     this._tokens.forEach(ct => ct.throwIfRequested());
                 }
                 isRequested() {
                     return this._tokens.some(ct => ct.isRequested());
                 }
                 isSupported() {
                     return !!this._tokens.length;
                 }
                 register(cb: (e: any) => void): IDestroyable {
                     let fired = false;
                     const once = (e: any) => {
                         if (!fired) {
                             fired = true;
                             destroy();
                             cb(e);
                         }
+                    };
                     const destroy = () => subscriptions
-                        .splice(0,subscriptions.length) // empty array
+                        .splice(0, subscriptions.length) // empty array
                         .forEach(subscription => subscription.destroy()); // cleanup
-                    const subscriptions = this._tokens.map(ct => ct.register(once))
+                    const subscriptions = this._tokens.map(ct => ct.register(once));
                     return {
                         destroy
                     };
                 }
             }

src/main/ts/components/AsyncComponent.ts +4 -1

             import { Cancellation } from "../Cancellation";
             import { IAsyncComponent, ICancellation, ICancellable } from "../interfaces";
             const noop = () => void (0);
             export class AsyncComponent implements IAsyncComponent, ICancellable {
                 _cancel: ((e: any) => void) = noop;
                 _completion: Promise<void> = Promise.resolve();
                 getCompletion() { return this._completion; }
                 runOperation(op: (ct: ICancellation) => any, ct: ICancellation = Cancellation.none) {
                     // create inner cancellation bound to the passed cancellation token
                     const inner = new Cancellation(cancel => {
                         this._cancel = cancel;
                     });
                     const guard = async () => {
                         try {
-                            return op(Cancellation.combine(ct, inner));
+                            const combined = Cancellation.combine(ct, inner);
+                            const result = await op(combined);
+                            combined.throwIfRequested();
+                            return result;
                         } finally {
                             // after the operation is complete we need to cleanup the
                             // resources
                             this._cancel = noop;
                         }
                     };
                     return this._completion = guard();
                 }
                 cancel(reason: any) {
                     this._cancel(reason);
                 }
             }

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

             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());
                             }
                         }
                     };
                 }
                 destroy() {
                     if (!this._destroyed) {
                         this._destroyed = true;
                         this._cleanup.forEach(safeCall);
                         this._cleanup.length = 0;
                     }
                 }
                 static empty(): ILifetime {
                     return emptyLifetime;
                 }
                 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() {
                     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) {
                     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()}]`
+                            return `[object ContainerLifetime, has=${_lifetime.has()}]`;
                         }
                     };
                 }
             }

src/main/ts/interfaces.ts +38 0

             export interface Constructor<T = {}> {
                 new(...args: any[]): T;
                 prototype: T;
             }
             export type PromiseOrValue<T> = T | PromiseLike<T>;
             export type Factory<T = {}> = (...args: any[]) => T;
             export type Predicate<T = any> = (x: T) => boolean;
             export type MatchingMemberKeys<T, U> = { [K in keyof T]: T[K] extends U ? K : never}[keyof T];
             export type NotMatchingMemberKeys<T, U> = { [K in keyof T]: T[K] extends U ? never : K}[keyof T];
             export type ExtractMembers<T, U> = Pick<T, MatchingMemberKeys<T, U>>;
             export type ExcludeMembers<T, U> = Pick<T, NotMatchingMemberKeys<T, U>>;
             export interface MapOf<T> {
                 [key: string]: T;
             }
             export interface IDestroyable {
                 destroy(): void;
             }
             export interface IRemovable {
                 remove(): void;
             }
+            /**
+             * Interface for the cancellation token. Cancellation token is
+             * a marker indicating that the cancellation was requested, it
+             * is up to the operation to decide whether to interrupt or
+             * to complete its execution.
+             *
+             * This interface defines several methods of interaction with
+             * the cancellation i.e. either to poll its status or to react
+             * through the callback.
+             */
             export interface ICancellation {
+                /**
+                 * Throws an exception if the cancellation has been requested,
+                 * otherwise does nothing.
+                 */
                 throwIfRequested(): void;
+                /**
+                 * Checks whether the cancellation is requested.
+                 * @returns true is the cancellation has been requested,
+                 *   otherwise returns false.
+                 */
                 isRequested(): boolean;
+                /**
+                 * Checks the ability of the token to be signaled.
+                 *
+                 * @returns true if the token is able to request
+                 *   the cancellation, false otherwise.
+                 */
                 isSupported(): boolean;
+                /**
+                 * Registers the callback to be called when the cancellation
+                 * is requested.
+                 *
+                 * @param cb The callback which receives the reason of the
+                 *   cancellation.
+                 * @returns The subscription, after the operation is completed
+                 *   it should unregister the callback to free resources by
+                 *   calling the `destroy()` method of the subscription.
+                 */
                 register(cb: (e: any) => void): IDestroyable;
             }
             /**
              * Интерфейс поддерживающий асинхронную активацию
              */
             export interface IActivatable {
                 /**
                  * @returns Boolean indicates the current state
                  */
                 isActive(): boolean;
                 /**
                  * Starts the component activation
                  * @param ct cancellation token for this operation
                  */
                 activate(ct?: ICancellation): Promise<void>;
                 /**
                  * Starts the component deactivation
                  * @param ct cancellation token for this operation
                  */
                 deactivate(ct?: ICancellation): Promise<void>;
                 /**
                  * Sets the activation controller for this component
                  * @param controller The activation controller
                  *
                  * Activation controller checks whether this component
                  * can be activated and manages the active state of the
                  * component
                  */
                 setActivationController(controller: IActivationController): void;
                 /** Indicates whether this component has an activation controller */
                 hasActivationController(): boolean;
                 /**
                  * Gets the current activation controller for this component
                  */
                 getActivationController(): IActivationController;
             }
             export interface IActivationController {
                 activating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 activated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivate(ct?: ICancellation): Promise<void>;
                 activate(component: IActivatable, ct?: ICancellation): Promise<void>;
                 hasActive(): boolean;
                 getActive(): IActivatable;
             }
             export interface IAsyncComponent {
                 getCompletion(): Promise<void>;
             }
             export interface ICancellable {
                 cancel(reason?: any): void;
             }
             export interface IObservable<T> {
                 on(next: (x: T) => void, error?: (e: any) => void, complete?: () => void): IDestroyable;
                 next(ct?: ICancellation): Promise<T>;
             }
             export interface IObserver<T> {
                 next(event: T): void;
                 error(e: any): void;
                 complete(): void;
             }
             export interface TextWriter {
                 write(obj: any): void;
                 write(format: string, ...args: any[]): void;
                 writeLine(obj?: any): void;
                 writeLine(format: string, ...args: any[]): void;
                 writeValue(value: any, spec?: string): void;
             }

src/test/ts/tests/FluentContainerTests.ts +2 -2

             import { test } from "./TestTraits";
             import { fluent } from "../di/traits";
             import { Bar } from "../mock/Bar";
             import { Container } from "../di/Container";
             import { Foo } from "../mock/Foo";
             import { Box } from "../mock/Box";
             import { delay } from "../safe";
             import { FooServices, Services } from "../mock/services";
             import { ContainerConfiguration } from "../di/fluent/interfaces";
             test("Simple fluent config", async t => {
                 const config = fluent<{ host: string; bar: Bar; foo: Foo }>()
                     .register({
                         host: it => it.value("example.com"),
                         bar: it => it.factory(resolve => new Bar({ host: resolve("host") }, "s-bar")),
                         foo: it => import("../mock/Foo").then(m => it.lifetime("container").factory(() => new m.Foo()))
                     });
                 const c1 = new Container<{}>();
                 const container = await config.apply(c1);
                 t.equal(container.resolve("host"), "example.com", "The value should be resolved");
                 t.assert(container.resolve("bar"), "The service should de activated");
                 t.equal(container.resolve("foo"), container.resolve("foo"), "The service should be activated once");
             });
             test("Nested async configuration", async t => {
                 const container = await new Container<{
                     foo: Foo;
                     box: Box<Foo>
                 }>().fluent({
                     foo: it => delay(0).then(() => it.factory(() => new Foo())),
                     box: it => it.lifetime("context").factory($dependency => new Box($dependency("foo")))
                 });
                 t.assert(container.resolve("box").getValue(), "The dependency should be set");
-                t.equals(container.resolve("box").getValue(), container.resolve("box").getValue(), "The service should be activated once")
+                t.equals(container.resolve("box").getValue(), container.resolve("box").getValue(), "The service should be activated once");
             });
             test("Bad fluent config", async t => {
                 try {
                     await new Container<{
                         foo: Foo;
                         box: Box<Foo>
                     }>().fluent({
                         foo: it => delay(0).then(() => it.factory(() => new Foo())),
                         box: it => it.lifetime("context")
                             .override("foo", () => { throw new Error("bad override"); })
                             .factory($dependency => new Box($dependency("foo")))
                     });
                     t.fail("Should throw");
                 } catch (e) {
                     t.pass("The configuration should fail");
                     t.equal(e.message, "bad override", "the error should pass");
                 }
             });
             test("Load fluent config", async t => {
                 const container = new Container<Services>();
                 await container.configure("../mock/config", { contextRequire: require });
                 t.assert(container.resolve("host"), "Should resolve simple value");
             });
             test("Container applyConfig", async t => {
                 const container = await new Container<{}>().applyConfig(import("../mock/config"));
                 t.assert(container.resolve("host"), "Should resolve simple value");
             });
             test("Child container config", async t => {
                 const container = await new Container<{}>().applyConfig(import("../mock/config"));
                 const fooServices: ContainerConfiguration<FooServices> = (await import("../mock/config2")).default;
                 const child = await fooServices.apply(container.createChildContainer());
                 t.assert(child.resolve("foo"), "foo should be resolved");
             });

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