implab/implabjs-core Commit - r13:745612edbd74

refactoring, all common interfaces placed to core/interfaces.ts...

cin -

r13:745612edbd74 propose cancellat...

parent child

Context file:

r13:745612edbd74

Collapse all files

src/ts/Cancellation.ts created 644 +33 0

@@ -0,0 +1,33
	1	import { ICancellation } from "./interfaces";
	2
	3	export class Cancellation implements ICancellation {
	4	isSupported(): boolean {
	5	return false;
	6	}
	7	throwIfRequested(): void {
	8	}
	9
	10	isRequested(): boolean {
	11	return false;
	12	}
	13
	14	register(_cb: (e:any) => void): void {
	15
	16	}
	17
	18	static readonly none : Cancellation = {
	19	isSupported(): boolean {
	20	return false;
	21	},
	22
	23	throwIfRequested(): void {
	24	},
	25
	26	isRequested(): boolean {
	27	return false;
	28	},
	29
	30	register(_cb: (e:any) => void): void {
	31	}
	32	};
	33	} No newline at end of file

src/ts/components/Observable.ts created 644 +85 0

@@ -0,0 +1,85
	1	import { IObservable, IObserver, IDestroyable, ICancellation } from '../interfaces';
	2	import { Cancellation } from '../Cancellation'
	3	import * as TraceSource from '../log/TraceSource'
	4	import { argumentNotNull } from '../safe';
	5
	6	const trace = TraceSource.get('@implab/core/components/Observable');
	7
	8
	9	class Observable<T> implements IObservable<T> {
	10	private _once = new Array<IObserver<T>>();
	11
	12	private readonly _observers = new Array<IObserver<T>>();
	13
	14	constructor(func: (notify: IObserver<T>) => void) {
	15	argumentNotNull(func, "func");
	16
	17	func(this._notify.bind(this));
	18	}
	19
	20	on(observer: IObserver<T>): IDestroyable {
	21	argumentNotNull(observer, "observer");
	22
	23	this._observers.push(observer);
	24
	25	let me = this;
	26	return {
	27	destroy() {
	28	me._removeObserver(observer);
	29	}
	30	}
	31	}
	32
	33	wait(ct: ICancellation = Cancellation.none): Promise<T> {
	34	return new Promise<T>((resolve, reject) => {
	35	this._once.push(resolve);
	36	if (ct.isSupported()) {
	37	ct.register((e) => {
	38	this._removeOnce(resolve);
	39	reject(e);
	40	});
	41	}
	42	});
	43	}
	44
	45	onObserverException(e: any) {
	46	trace.error("Unhandled exception in the observer: {0}", e);
	47	}
	48
	49	private _removeOnce(d: IObserver<T>) {
	50	let i = this._once.indexOf(d);
	51	if (i >= 0)
	52	this._once.splice(i);
	53	}
	54
	55	private _removeObserver(d: IObserver<T>) {
	56	let i = this._observers.indexOf(d);
	57	if (i >= 0)
	58	this._observers.splice(i);
	59	}
	60
	61	private _notify(evt: T) {
	62	let guard = (observer: IObserver<T>) => {
	63	try {
	64	observer(evt);
	65	} catch (e) {
	66	this.onObserverException(e);
	67	}
	68	}
	69
	70	if (this._once.length) {
	71	for (let i = 0; i < this._once.length; i++)
	72	guard(this._once[i]);
	73	this._once = [];
	74	}
	75
	76	for (let i = 0; i < this._observers.length; i++)
	77	guard(this._observers[i]);
	78	}
	79	}
	80
	81	namespace Observable {
	82	export const traceSource = trace;
	83	}
	84
	85	export = Observable; No newline at end of file

src/ts/interfaces.ts created 644 +83 0

@@ -0,0 +1,83
	1	import { watchFile } from "fs";
	2
	3	export interface IDestroyable {
	4	destroy();
	5	}
	6
	7	export interface ICancellation {
	8	throwIfRequested(): void;
	9	isRequested(): boolean;
	10	isSupported(): boolean;
	11	register(cb: (e: any) => void): void;
	12	}
	13
	14	/**
	15	* Интерфейс поддерживающий асинхронную активацию
	16	*/
	17	export interface IActivatable {
	18	/**
	19	* @returns Boolean indicates the current state
	20	*/
	21	isActive(): boolean;
	22
	23	/**
	24	* Starts the component activation
	25	* @param ct cancellation token for this operation
	26	*/
	27	activate(ct?: ICancellation) : Promise<void>;
	28
	29	/**
	30	* Starts the component deactivation
	31	* @param ct cancellation token for this operation
	32	*/
	33	deactivate(ct?: ICancellation) : Promise<void>;
	34
	35	/**
	36	* Sets the activation controller for this component
	37	* @param controller The activation controller
	38	*
	39	* Activation controller checks whether this component
	40	* can be activated and manages the active state of the
	41	* component
	42	*/
	43	setActivationController(controller: IActivationController);
	44
	45	/**
	46	* Gets the current activation controller for this component
	47	*/
	48	getActivationController(): IActivationController;
	49	}
	50
	51	export interface IActivationController {
	52	activating(component: IActivatable, ct?: ICancellation): Promise<void>;
	53
	54	activated(component: IActivatable, ct?: ICancellation): Promise<void>;
	55
	56	deactivating(component: IActivatable, ct?: ICancellation): Promise<void>;
	57
	58	deactivated(component: IActivatable, ct?: ICancellation): Promise<void>;
	59
	60	deactivate(ct?: ICancellation): Promise<void>;
	61
	62	activate(component: IActivatable, ct?: ICancellation): Promise<void>;
	63
	64	getActive(): IActivatable;
	65	}
	66
	67	export interface IAsyncComponent {
	68	getCompletion(): Promise<void>;
	69	}
	70
	71	export interface ICancellable {
	72	cancel(reason?: any): void;
	73	}
	74
	75	export interface IObserver<T> {
	76	(x:T): void;
	77	}
	78
	79	export interface IObservable<T> {
	80	on(observer: IObserver<T>): IDestroyable;
	81
	82	wait(ct?: ICancellation) : Promise<T>;
	83	} No newline at end of file

src/ts/components/ActivatableMixin.ts +21 -29

-            import { IActivationController } from './IActivationController';
+            import { IActivationController, IActivatable, ICancellation } from '../interfaces';
-            import { IActivatable } from './IActivatable';
             import { AsyncComponent } from './AsyncComponent';
-            import { ICancellation } from '../ICancellation';
+            import { Cancellation } from '../Cancellation';
-            import { EmptyCancellation } from '../EmptyCancellation';
             import * as TraceSource from '../log/TraceSource';
             type Constructor<T = {}> = new (...args: any[]) => T;
             const log = TraceSource.get('@implab/core/components/ActivatableMixin');
             function ActivatableMixin<TBase extends Constructor<AsyncComponent>>(Base: TBase) {
                 return class extends Base implements IActivatable {
                     _controller: IActivationController;
                     _active: boolean;
                     isActive() {
                         return this._active;
                     }
                     getActivationController() {
                         return this._controller;
                     }
                     setActivationController(controller: IActivationController) {
                         this._controller = controller;
                     }
                     async onActivating(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.activating(this, ct);
                     }
                     async onActivated(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.activated(this, ct);
                     }
-                    async activate(ct: ICancellation = EmptyCancellation.default) {
+                    activate(ct: ICancellation = Cancellation.none) {
+                        return this.runOperation(this._activateAsync.bind(this), ct);
+                    }
+                    async _activateAsync(ct: ICancellation) {
                         if (this.isActive())
                             return;
-                        ct = this.startOperation(ct);
+                        await this.onActivating(ct);
+                        this._active = true;
                         try {
-                            await this.onActivating(ct);
+                            await this.onActivated(ct);
-                            this._active = true;
-                            try {
-                                await this.onActivated(ct);
-                            } catch(e) {
-                                log.error("Suppressed onActivated error: {0}", e);
-                            this.completeSuccess();
                         } catch (e) {
-                            this.completeFail(e);
+                            log.error("Suppressed onActivated error: {0}", e);
                         }
-                        return this.getCompletion();
                     }
                     async onDeactivating(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.deactivating(this, ct);
                     }
                     async onDeactivated(ct: ICancellation) {
                         if (this._controller)
                             await this._controller.deactivated(this, ct);
                     }
-                    async deactivate(ct: ICancellation = EmptyCancellation.default) {
+                    deactivate(ct: ICancellation = Cancellation.none) {
+                        return this.runOperation(this._deactivateAsync.bind(this), ct);
+                    }
+                    async _deactivateAsync(ct: ICancellation) {
                         if (!this.isActive())
                             return;
-                        ct = this.startOperation(ct);
+                        await this.onDeactivating(ct);
+                        this._active = false;
                         try {
-                            await this.onDeactivating(ct);
+                            await this.onDeactivated(ct);
-                            this._active = false;
-                            try {
-                                await this.onDeactivated(ct);
-                            } catch(e) {
-                                log.error("Suppressed onDeactivated error: {0}", e);
-                            this.completeSuccess();
                         } catch (e) {
-                            this.completeFail(e);
+                            log.error("Suppressed onDeactivated error: {0}", e);
                         }
-                        return this.getCompletion();
                     }
                 }
             }
             namespace ActivatableMixin {
                 export const traceSource = log;
             }
             export = ActivatableMixin;

src/ts/components/AsyncComponent.ts +10 -40

@@ -1,47 +1,17
1	import { ICancellation } from "../ICancellation";	1	import { Cancellation } from "../Cancellation";
2	import { ~~Empty~~Cancellation } from "../~~EmptyCancellation~~";	2	import { IAsyncComponent, ICancellation } from "../interfaces";
3		3
4	export class AsyncComponent {	4	export class AsyncComponent implements IAsyncComponent {
5	_completion: Promise<void>;	5	_completion: Promise<void> = Promise.resolve();
6
7	_deferred: {
8	resolve(): void
9	reject(reason: any): void
10	};
11		6
12	getCompletion() { return this._completion };	7	getCompletion() { return this._completion };
13		8
14	~~start~~Operation(ct: ICancellation = ~~Empty~~Cancellation.~~default~~) {	9	runOperation(op: (ct: ICancellation) => any, ct: ICancellation = Cancellation.none) {
15	if (this._deferred)	10	// TODO create cancellation source here
16	throw new Error("The async operation is already pending");	11	async function guard() {
17		12	await op(ct);
18	this._completion = new Promise<void>((resolve, reject) => {	13	}
19	this._deferred = {
20	resolve: resolve,
21	reject: reject
22	}
23	});
24	return ct;
25	}
26		14
27	completeSuccess() {	15	return this._completion = guard();
28	this._deferred.resolve();
29	this._deferred = null;
30	}
31
32	completeFail(reason: any) {
33	this._deferred.reject(reason);
34	this._deferred = null;
35	}
36
37	async runOperation(cb: (ct: ICancellation) => Promise<void>, ct: ICancellation = EmptyCancellation.default) {
38	//safe.argumentNotNull(cb, "cb")
39	ct = this.startOperation(ct);
40	try {
41	await cb(ct);
42	this.completeSuccess();
43	} catch(e) {
44	this.completeFail(e);
45	}
46	}	16	}
47	} No newline at end of file	17	}

test/ts/ActivatableTests.ts +4 -4

             import * as tape from 'tape';
             import * as ActivatableMixin from '@implab/core/components/ActivatableMixin';
             import { AsyncComponent } from '@implab/core/components/AsyncComponent';
             import { IActivationController } from '@implab/core/components/IActivationController';
             import { IActivatable } from '@implab/core/components/IActivatable';
             import { ICancellation } from '@implab/core/ICancellation';
             import { EmptyCancellation } from '@implab/core/EmptyCancellation';
             class SimpleActivatable extends ActivatableMixin(AsyncComponent) {
             }
             class MockActivationController implements IActivationController {
                 _active: IActivatable = null;
                 getActive() : IActivatable {
                     return this._active;
                 }
                 async deactivate() {
                     if (this._active)
                         await this._active.deactivate();
                     this._active = null;
                 }
                 async activate(component: IActivatable) {
                     if (!component || component.isActive())
                         return;
                     component.setActivationController(this);
                     await component.activate();
                 }
                 async activating(component: IActivatable, ct: ICancellation = EmptyCancellation.default) {
                     if (component != this._active)
                         await this.deactivate();
                 }
                 async activated(component: IActivatable, ct: ICancellation = EmptyCancellation.default) {
                     this._active = component;
                 }
                 async deactivating(component: IActivatable, ct: ICancellation = EmptyCancellation.default) {
                 }
                 async deactivated(component: IActivatable, ct: ICancellation = EmptyCancellation.default) {
                     if (this._active == component)
                         this._active = null;
                 }
             }
             tape('simple activation',async function(t){
                 let a = new SimpleActivatable();
                 t.false(a.isActive());
                 await a.activate();
                 t.true(a.isActive());
                 await a.deactivate();
                 t.false(a.isActive());
                 t.end();
             });
             tape('controller activation', async function(t) {
                 let a = new SimpleActivatable();
                 let c = new MockActivationController();
                 t.false(a.isActive(), "the component is not active by default");
                 t.assert(c.getActive() == null, "the activation controller doesn't have an active component by default");
                 t.assert(a.getActivationController() == null, "the component doesn't have an activation controller by default");
                 t.comment("Active the component through the controller");
                 await c.activate(a);
                 t.true(a.isActive(), "The component should successfully activate");
-                t.assert(c.getActive() == a, "The controller should point to the activated component");
+                t.equal(c.getActive(), a, "The controller should point to the activated component");
-                t.assert(a.getActivationController() == c, "The component should point to the controller");
+                t.equal(a.getActivationController(), c, "The component should point to the controller");
                 t.comment("Deactive the component throug the controller");
                 await c.deactivate();
                 t.false(a.isActive(), "The component should successfully deactivate");
-                t.assert(c.getActive() == null, "The controller shouldn't point to any component");
+                t.equal(c.getActive(), null, "The controller shouldn't point to any component");
-                t.assert(a.getActivationController() == c, "The componet should point to it's controller");
+                t.equal(a.getActivationController(), c, "The componet should point to it's controller");
                 t.end();
             });
             tape('handle error in onActivating', async function(t) {
                 let a = new SimpleActivatable();
                 a.onActivating = async function() {
                     throw "Should fail";
                 };
                 try {
                     await a.activate();
                     t.fail("activation should fail");
                 } catch {
                 }
                 t.false(a.isActive(), "the component should remain inactive");
                 t.end();
             });

test/ts/TraceSourceTests.ts +24 -2

             import * as TraceSource from '@implab/core/log/TraceSource'
             import * as tape from 'tape';
             const sourceId = 'test/TraceSourceTests';
-            tape('', t => {
+            tape('trace message', t => {
                 let trace = TraceSource.get(sourceId);
                 trace.level = TraceSource.DebugLevel;
                 let h = trace.on((sender,level,msg) => {
                     t.equal(sender, trace, "sender should be the current trace source");
                     t.equal(TraceSource.DebugLevel, level, "level should be debug level");
-                    t.equal(msg, "Hello, World!", "The message should be formatted correctly");
+                    t.equal(msg, "Hello, World!", "The message should be a formatted message");
                     t.end();
                 });
                 trace.debug("Hello, {0}!", "World");
                 h.destroy();
+            });
+            tape('trace event', t => {
+                let trace = TraceSource.get(sourceId);
+                trace.level = TraceSource.DebugLevel;
+                let event = {
+                    name: "custom event"
+                };
+                let h = trace.on((sender,level,msg) => {
+                    t.equal(sender, trace, "sender should be the current trace source");
+                    t.equal(TraceSource.DebugLevel, level, "level should be debug level");
+                    t.equal(msg, event, "The message should be the specified object");
+                    t.end();
+                });
+                trace.traceEvent(TraceSource.DebugLevel, event);
+                h.destroy();
             });

src/ts/EmptyCancellation.ts removed 0 -20

NO CONTENT: file was removed

src/ts/ICancellation.ts removed 0 -6

NO CONTENT: file was removed

src/ts/components/IActivatable.ts removed 0 -39

NO CONTENT: file was removed

src/ts/components/IActivationController.ts removed 0 -19

NO CONTENT: file was removed

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