implab/implabjs-core Commit - r76:a193ba786ffc

Added safe.delay...

cin -

r76:a193ba786ffc default

parent child

Context file:

r76:a193ba786ffc

Collapse all files

src/test/ts/SafeTests.ts created 644 +86 0

			@@ -0,0 +1,86
		1	import tape = require("tape");
		2	import { delay } from "./TestTraits";
		3	import { Cancellation } from "@implab/core/Cancellation";
		4	import { first, isPromise } from "@implab/core/safe";
		5
		6	tape("await delay test", async t => {
		7	// schedule delay
		8	let resolved = false;
		9	let res = delay(0).then(() => resolved = true);
		10
		11	t.false(resolved, "the delay should be async");
		12
		13	await res;
		14	t.pass("await delay");
		15
		16	// create cancellation token
		17	let cancel: (e?: any) => void;
		18	const ct = new Cancellation(c => cancel = c);
		19
		20	// schedule delay
		21	resolved = false;
		22	res = delay(0, ct).then(() => resolved = true);
		23
		24	t.false(resolved, "created delay with ct");
		25
		26	// cancel
		27	cancel();
		28
		29	try {
		30	await res;
		31	t.fail("the delay should fail when it is cancelled");
		32	} catch {
		33	t.pass("the delay is cancelled");
		34	}
		35
		36	let died = false;
		37
		38	// try schedule delay after the cancellation is requested
		39	res = delay(0, ct).then(x => true, () => died = true);
		40
		41	t.false(died, "The delay should be scheduled even if the cancellation is requested");
		42
		43	await res;
		44	t.true(died, "the delay should fail when cancelled");
		45
		46	t.end();
		47	});
		48
		49	tape("sequemce test", async t => {
		50	const sequence = ["a", "b", "c"];
		51	const empty = [];
		52
		53	// synchronous tests
		54	t.equals(first(sequence), "a", "Should return the first element");
		55
		56	let v: string;
		57	let e: Error;
		58	first(sequence, x => v = x);
		59	t.equal(v, "a", "The callback should be called for the first element");
		60
		61	t.throws(() => {
		62	first(empty);
		63	}, "Should throw when the sequence is empty");
		64
		65	t.throws(() => {
		66	first(empty, x => v = x);
		67	}, "Should throw when the sequence is empty");
		68
		69	first(empty, null, x => e = x);
		70	t.true(e, "The errorback should be called for the empty sequence");
		71
		72	// async tests
		73	const asyncSequence = Promise.resolve(sequence);
		74	const asyncEmptySequence = Promise.resolve(empty);
		75
		76	const promise = first(asyncSequence);
		77	t.true(isPromise(promise), "Should return promise");
		78
		79	v = await promise;
		80	t.equal(v, "a", "Should return the first element");
		81
		82	v = await new Promise(resolve => first(asyncSequence, resolve));
		83	t.equal(v, "a", "The callback should be called for the first element");
		84
		85	t.end();
		86	});

build.md +1 -1

              ```shell
              ./gradlew test pack -Pjsmodule=commonjs -Ptarget=es2017
-             ```
  No newline at end of file
+             ```

src/main/ts/Cancellation.ts +3 -8

              import { ICancellation, IDestroyable } from "./interfaces";
-             import { argumentNotNull } from "./safe";
-             const destroyed = {
-                 destroy() {
+                 }
-             };
+             import { argumentNotNull, destroyed } from "./safe";
              export class Cancellation implements ICancellation {
                  private _reason: any;
-                 private _cbs: Array<(e) => void>;
+                 private _cbs: Array<(e: any) => void>;
-                 constructor(action: (cancel: (e) => void) => void) {
+                 constructor(action: (cancel: (e?: any) => void) => void) {
                      argumentNotNull(action, "action");
                      action(this._cancel.bind(this));

src/main/ts/Observable.ts +35 -11

-             import { IObservable, IDestroyable, ICancellation } from "./interfaces";
+             import { IObservable, IDestroyable, ICancellation, IObserver } from "./interfaces";
              import { Cancellation } from "./Cancellation";
-             import { argumentNotNull } from "./safe";
+             import { argumentNotNull, destroyed } from "./safe";
              type Handler<T> = (x: T) => void;
              type Initializer<T> = (notify: Handler<T>, error?: (e: any) => void, complete?: () => void) => void;
-             // TODO: think about to move this interfaces.ts and make it public
-             interface IObserver<T> {
-                 next(event: T): void;
+             const noop = () => { };
-                 error(e: any): void;
-                 complete(): void;
+             function isObserver(val: any): val is IObserver<any> {
+                 return val && (typeof val.next === "function");
              }
-             const noop = () => { };
              export class Observable<T> implements IObservable<T> {
                  private _once = new Array<IObserver<T>>();
                      return observer;
                  }
+                 subscribe(next: IObserver<T> | Handler<T>, error?: Handler<any>, complete?: () => void): IDestroyable {
+                     if (isObserver(next)) {
+                         const me = this;
+                         const subscription = {
+                             destroy() {
+                                 me._removeObserver(next);
+                             }
+                         };
+                         this._addObserver(next);
+                         return subscription;
+                     } else if (next) {
+                         const observer = {
+                             next,
+                             error,
+                             complete
+                         };
+                         const me = this;
+                         const subscription = {
+                             destroy() {
+                                 me._removeObserver(observer);
+                             }
+                         };
+                         this._addObserver(observer);
+                         return subscription;
+                     } else {
+                         return destroyed;
+                     }
+                 }
                  private _addObserver(observer: IObserver<T>) {
                      if (this._complete) {
                          try {
                   *
                   * @param ct a cancellation token
                   */
-                 next(ct: ICancellation = Cancellation.none): Promise<T> {
+                 next(ct: ICancellation = Cancellation.none) {
                      return new Promise<T>((resolve, reject) => {
                          const observer: IObserver<T> = {
                              next: resolve,

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

                  _require: ModuleResolver;
                  constructor(container: Container) {
-                     argumentNotNull(container, container);
+                     argumentNotNull(container, "container");
                      this._container = container;
                      this._path = [];
                  }

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

                  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;
+             }

src/main/ts/safe.ts +31 -3

              import { ICancellable, Constructor } from "./interfaces";
+             import { Cancellation } from "./Cancellation";
              let _nextOid = 0;
              const _oid = typeof Symbol === "function" ?
                  };
              }
+             export function delay(timeMs: number, ct = Cancellation.none) {
+                 return new Promise((resolve, reject) => {
+                     if (ct.isRequested()) {
+                         ct.register(reject);
+                     } else {
+                         const h = ct.register(e => {
+                             clearTimeout(id);
+                             reject(e);
+                             // we don't nedd to unregister h, since ct is already disposed
+                         });
+                         const id = setTimeout(() => {
+                             h.destroy();
+                             resolve();
+                         }, timeMs);
+                     }
+                 });
+             }
              /**
               * Для каждого элемента массива вызывает указанную функцию и сохраняет
               * возвращенное значение в массиве результатов.
              export function firstWhere<T>(
                  sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
                  predicate?: (x: T) => boolean,
-                 cb?: (x: T) => void,
-                 err?: (x: Error) => void
+                 cb?: (x: T) => any,
+                 err?: (x: Error) => any
              ) {
                  if (isPromise(sequence)) {
                      return sequence.then(res => firstWhere(res, predicate, cb, err));
                              throw new Error("The sequence is empty");
                      } else {
                          if (!predicate) {
-                             return cb ? cb(sequence[0]) : sequence[0];
+                             return cb ? cb(sequence[0]) && void (0) : sequence[0];
                          } else {
                              for (let i = 0; i < sequence.length; i++) {
                                  const v = sequence[i];
               */
              export function nowait(p: Promise<any>) {
              }
+             /** represents already destroyed object.
+              */
+             export const destroyed = {
+                 /** Calling to this method doesn't affect anything, noop.
+                  */
+                 destroy() {
+                 }
+             };

src/testAmd/js/plan.js +2 -1

                  "./TraceSourceTests",
                  "./CancellationTests",
                  "./ObservableTests",
-                 "./ContainerTests"
+                 "./ContainerTests",
+                 "./SafeTests"
              ]);
  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