implab/implabjs-core Commit - r146:f3f5c56d3b3e

Added childContainer service to container services, ServiceContaier is destroyable, fixed browser Uuid version

cin -

r146:f3f5c56d3b3e v1.4.0-rc5 default

parent child

Context file:

r146:f3f5c56d3b3e

Collapse all files

build.gradle +1 -1

             plugins {
               id "org.implab.gradle-typescript" version "1.3.3"
               id "org.implab.gradle-hg"
               id "ivy-publish"
             }
             if (!symbols in ['local', 'pack', 'none'])
                 throw new Exception("The symbols property value is invalid: $symbols");
             if (!flavour in ['browser', 'node'])
                 throw new Exception("The flavour property value is invalid: $flavour");
             ext {
                 packageName = flavour == 'browser' ? "@$npmScope/$name-amd" : "@$npmScope/$name"
                 lint = project.hasProperty('lint') ? project.lint ?: true : false
             }
             sources {
                 amd {
                     typings {
                         srcDir main.output.typingsDir
                     }
                 }
                 cjs {
                     typings {
                         srcDir main.output.typingsDir
                     }
                 }
                 testAmd {
                     typings {
                         srcDir main.output.typingsDir
                         srcDir amd.output.typingsDir
                         srcDir test.output.typingsDir
                     }
                 }
                 testCjs {
                     typings {
                         srcDir main.output.typingsDir
                         srcDir cjs.output.typingsDir
                         srcDir test.output.typingsDir
                     }
                 }
             }
             typescript {
                 compilerOptions {
                     types = []
                     declaration = true
                     experimentalDecorators = true
                     strict = true
                     // dojo-typings are sick
                     skipLibCheck = true
                     if(symbols != 'none') {
                         sourceMap = true
-                        sourceRoot = packageName
+                        sourceRoot = "pack:${packageName}"
                     }
                     if (flavour == 'node') {
                         module = "commonjs"
                         target = "es2017"
                         lib = ["es2017", "dom", "scripthost"]
                     } else if (flavour == 'browser') {
                         module = "amd"
                         target = "es5"
                         lib = ["es5", "dom", "scripthost", "es2015.promise", "es2015.symbol", "es2015.iterable" ]
                     }
                 }
                 tscCmd = "$projectDir/node_modules/.bin/tsc"
                 tsLintCmd = "$projectDir/node_modules/.bin/tslint"
             	esLintCmd = "$projectDir/node_modules/.bin/eslint"
             }
             tasks.matching{ it.name =~ /^lint/ }.configureEach {
                 onlyIf { lint }
             }
             if (symbols == 'local') {
                 tasks.matching{ it.name =~ /^configureTs/ }.configureEach {
                     compilerOptions {
                         sourceRoot = "file://" + it.rootDir
                     }
                 }
             }
             task printVersion {
                 doLast {
                     println "packageName: $packageName";
                     println "version: $version";
                     println "flavour: $flavour";
                     println "target: $typescript.compilerOptions.target";
                     println "module: $typescript.compilerOptions.module";
                     println "lint: $lint";
                     println "symbols: $symbols";
                 }
             }
             npmPackMeta {
                 meta {
                     name = packageName
                 }
             }
             configureTsCjs {
                 dependsOn sources.main.output
                 compilerOptions {
                     types += [ "node" ]
                 }
             }
             configureTsAmd {
                 dependsOn sources.main.output
                 compilerOptions {
                     types += [ "requirejs", "dojo-typings" ]
                 }
             }
             test {
                 workingDir layout.buildDirectory.dir("test");
                 commandLine "node", "tests/index.js"
             }
             assemble {
                 if (flavour == 'browser') {
                     dependsOn sources.amd.output
                     from sources.amd.output.compiledDir
                     from sources.amd.resources
                 }
                 if (flavour == 'node') {
                     dependsOn sources.cjs.output
                     from sources.cjs.output.compiledDir
                     from sources.cjs.resources
                 }
             }
             assembleTest {
                 if (flavour == 'browser') {
                     dependsOn sources.amd.output, sources.testAmd.output
                     from sources.amd.output.compiledDir
                     from sources.testAmd.output.compiledDir
                     from sources.amd.resources
                     from sources.testAmd.resources
                 }
                 if (flavour == 'node') {
                     dependsOn sources.cjs.output, sources.testCjs.output
                     from sources.cjs.output.compiledDir
                     from sources.testCjs.output.compiledDir
                     from sources.cjs.resources
                     from sources.testCjs.resources
                 }
             }
             typings {
                 if (flavour == 'browser') {
                     dependsOn sources.amd.output
                     from sources.amd.output.typingsDir
                 }
                 if (flavour == 'node') {
                     dependsOn sources.cjs.output
                     from sources.cjs.output.typingsDir
                 }
             }
             task npmPackTypings(type: Copy) {
                 npmPackContents.dependsOn it
                 dependsOn sources.main.output
                 from sources.main.output.typingsDir
                 if (flavour == 'browser') {
                     dependsOn sources.amd.output
                     from sources.amd.output.typingsDir
                 }
                 if (flavour == 'node') {
                     dependsOn sources.cjs.output
                     from sources.cjs.output.typingsDir
                 }
                 into npm.packageDir
             }
             task npmPackSources(type: Copy) {
                 from sources.main.ts
                 if (symbols == 'pack') {
                    npmPackContents.dependsOn npmPackSources
                 }
                 if (flavour == 'browser') {
                     from sources.amd.ts
                 }
                 if (flavour == 'node') {
                     from sources.cjs.ts
                 }
                 into npm.packageDir.dir("_src")
             }
             task packJsTar(type: Tar) {
                 dependsOn assemble;
                 archiveBaseName = provider { packageName }
                 destinationDirectory = buildDir
                 archiveClassifier = provider { typescript.compilerOptions.module }
                 compression = Compression.GZIP
                 from(assemble.outputs)
                 doLast {
                     println archiveName;
                 }
             }
             task packTypingsTar(type: Tar) {
             }
             publishing {
                 publications {
                     local(IvyPublication) {
                         artifact(packJsTar) {
                             type = "js"
                         }
                     }
                 }
                 repositories {
                     ivy {
                         url "ivy-repo"
                     }
                 }
             }

src/main/ts/Uuid.ts +7 -3

             // Typescript port of the uuid.js
             //  Copyright (c) 2018 Sergey Smirnov
             //  BSD-2-Clause License https://opensource.org/licenses/BSD-2-Clause
             //
             // uuid.js
             //     Copyright (c) 2010-2012 Robert Kieffer
             //     MIT License - http://opensource.org/licenses/mit-license.php
             import { MapOf } from "./interfaces";
             declare const window: any;
             declare const require: any;
             declare const Buffer: any;
             const _window: any = "undefined" !== typeof window ? window : null;
+            function noop(): never {
+                throw new Error();
+            }
             interface WritableArrayLike<T> {
                 length: number;
                 [n: number]: T;
             }
             // Unique ID creation requires a high quality random # generator. We
             // feature
             // detect to determine the best RNG source, normalizing to a function
             // that
             // returns 128-bits of randomness, since that's what's usually required
-            let _rng: () => WritableArrayLike<number> = () => [];
+            let _rng: () => WritableArrayLike<number> = noop;
             function setupBrowser() {
                 // Allow for MSIE11 msCrypto
                 const _crypto = _window.crypto || _window.msCrypto;
-                if (!_rng && _crypto && _crypto.getRandomValues) {
+                if (_rng === noop && _crypto && _crypto.getRandomValues) {
                     // WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto
                     //
                     // Moderately fast, high quality
                     try {
                         const _rnds8 = new Uint8Array(16);
                         _rng = function whatwgRNG() {
                             _crypto.getRandomValues(_rnds8);
                             return _rnds8;
                         };
                         _rng();
                     } catch (e) { /**/ }
                 }
-                if (!_rng) {
+                if (_rng === noop) {
                     // Math.random()-based (RNG)
                     //
                     // If all else fails, use Math.random(). It's fast, but is of
                     // unspecified
                     // quality.
                     const _rnds = new Array<number>(16);
                     _rng = () => {
                         for (let i = 0, r = 0; i < 16; i++) {
                             if ((i & 0x03) === 0) {
                                 r = Math.random() * 0x100000000;
                             }
                             _rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
                         }
                         return _rnds;
                     };
                     // if ("undefined" !== typeof console && console.warn) {
                     //    console.warn("[SECURITY] node-uuid: crypto not usable, falling back to insecure Math.random()");
                     // }
                 }
             }
             function setupNode() {
                 // Node.js crypto-based RNG -
                 // http://nodejs.org/docs/v0.6.2/api/crypto.html
                 //
                 // Moderately fast, high quality
                 if ("function" === typeof require) {
                     try {
                         const _rb = require("crypto").randomBytes;
                         _rng = _rb && (() => _rb(16));
                         _rng();
                     } catch (e) { /**/ }
                 }
             }
             if (_window) {
                 setupBrowser();
             } else {
                 setupNode();
             }
             // Buffer class to use
             const BufferClass = ("function" === typeof Buffer) ? Buffer : Array;
             // Maps for number <-> hex string conversion
             const _byteToHex: string[] = [];
             const _hexToByte: MapOf<number> = {};
             for (let i = 0; i < 256; i++) {
                 _byteToHex[i] = (i + 0x100).toString(16).substr(1);
                 _hexToByte[_byteToHex[i]] = i;
             }
             // **`parse()` - Parse a UUID into it's component bytes**
             function _parse(s: string, buf: number[] = [], offset?: number): number[] {
                 const i = (buf && offset) || 0; let ii = 0;
                 s.toLowerCase().replace(/[0-9a-f]{2}/g, oct => {
                     if (ii < 16) { // Don't overflow!
                         buf[i + ii++] = _hexToByte[oct];
                     }
                     return "";
                 });
                 // Zero out remaining bytes if string was short
                 while (ii < 16) {
                     buf[i + ii++] = 0;
                 }
                 return buf;
             }
             // **`unparse()` - Convert UUID byte array (ala parse()) into a string**
             function _unparse(buf: ArrayLike<number>, offset?: number): string {
                 let i = offset || 0; const bth = _byteToHex;
                 return bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] +
                     bth[buf[i++]] + "-" + bth[buf[i++]] + bth[buf[i++]] + "-" +
                     bth[buf[i++]] + bth[buf[i++]] + "-" + bth[buf[i++]] +
                     bth[buf[i++]] + "-" + bth[buf[i++]] + bth[buf[i++]] +
                     bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]] + bth[buf[i++]];
             }
             // **`v1()` - Generate time-based UUID**
             //
             // Inspired by https://github.com/LiosK/UUID.js
             // and http://docs.python.org/library/uuid.html
             // random #'s we need to init node and clockseq
             const _seedBytes = _rng();
             // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit =
             // 1)
             const _nodeId = [
                 _seedBytes[0] | 0x01,
                 _seedBytes[1],
                 _seedBytes[2],
                 _seedBytes[3],
                 _seedBytes[4],
                 _seedBytes[5]
             ];
             // Per 4.2.2, randomize (14 bit) clockseq
             let _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
             // Previous uuid creation time
             let _lastMSecs = 0; let _lastNSecs = 0;
             interface V1Options {
                 clockseq?: number;
                 msecs?: number;
                 nsecs?: number;
                 node?: number[];
             }
             // See https://github.com/broofa/node-uuid for API details
             function _v1(options?: V1Options): string;
             function _v1(options: V1Options, buf: number[], offset?: number): number[];
             function _v1(options: V1Options = {}, buf?: number[], offset?: number): string | number[] {
                 let i = buf && offset || 0;
                 const b = buf || [];
                 let clockseq = (options.clockseq != null) ? options.clockseq : _clockseq;
                 // UUID timestamps are 100 nano-second units since the Gregorian
                 // epoch,
                 // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
                 // time is handled internally as 'msecs' (integer milliseconds) and
                 // 'nsecs'
                 // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01
                 // 00:00.
                 let msecs = (options.msecs != null) ? options.msecs : new Date()
                     .getTime();
                 // Per 4.2.1.2, use count of uuid's generated during the current
                 // clock
                 // cycle to simulate higher resolution clock
                 let nsecs = (options.nsecs != null) ? options.nsecs : _lastNSecs + 1;
                 // Time since last uuid creation (in msecs)
                 const dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs) / 10000;
                 // Per 4.2.1.2, Bump clockseq on clock regression
                 if (dt < 0 && options.clockseq == null) {
                     clockseq = clockseq + 1 & 0x3fff;
                 }
                 // Reset nsecs if clock regresses (new clockseq) or we've moved onto
                 // a new
                 // time interval
                 if ((dt < 0 || msecs > _lastMSecs) && options.nsecs == null) {
                     nsecs = 0;
                 }
                 // Per 4.2.1.2 Throw error if too many uuids are requested
                 if (nsecs >= 10000) {
                     throw new Error(
                         "uuid.v1(): Can't create more than 10M uuids/sec");
                 }
                 _lastMSecs = msecs;
                 _lastNSecs = nsecs;
                 _clockseq = clockseq;
                 // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
                 msecs += 12219292800000;
                 // `time_low`
                 const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
                 b[i++] = tl >>> 24 & 0xff;
                 b[i++] = tl >>> 16 & 0xff;
                 b[i++] = tl >>> 8 & 0xff;
                 b[i++] = tl & 0xff;
                 // `time_mid`
                 const tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
                 b[i++] = tmh >>> 8 & 0xff;
                 b[i++] = tmh & 0xff;
                 // `time_high_and_version`
                 b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
                 b[i++] = tmh >>> 16 & 0xff;
                 // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
                 b[i++] = clockseq >>> 8 | 0x80;
                 // `clock_seq_low`
                 b[i++] = clockseq & 0xff;
                 // `node`
                 const node = options.node || _nodeId;
                 for (let n = 0; n < 6; n++) {
                     b[i + n] = node[n];
                 }
                 return buf ? buf : _unparse(b);
             }
             interface V4Opptions {
                 rng?: () => WritableArrayLike<number>;
                 random?: number[];
             }
             // **`v4()` - Generate random UUID**
             // See https://github.com/broofa/node-uuid for API details
             function _v4(options?: V4Opptions): string;
             function _v4(options: V4Opptions, buf: number[], offset?: number): number[];
             function _v4(options: V4Opptions = {}, buf?: number[], offset?: number): string | number[] {
                 // Deprecated - 'format' argument, as supported in v1.2
                 const i = buf && offset || 0;
                 const rnds = options.random || (options.rng || _rng)();
                 // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
                 rnds[6] = (rnds[6] & 0x0f) | 0x40;
                 rnds[8] = (rnds[8] & 0x3f) | 0x80;
                 // Copy bytes to buffer, if provided
                 if (buf) {
                     for (let ii = 0; ii < 16; ii++) {
                         buf[i + ii] = rnds[ii];
                     }
                 }
                 return buf || _unparse(rnds);
             }
             function _Uuid() {
                 return _v4();
             }
             namespace _Uuid {
                 export const v4 = _v4;
                 export const v1 = _v1;
                 export const empty = "00000000-0000-0000-0000-000000000000";
                 export const parse = _parse;
                 export const Uuid = _v4;
             }
             export = _Uuid;

src/main/ts/di/Container.ts +4 -3

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
             import { ServiceMap, Descriptor, PartialServiceMap, ContainerServiceMap, ContainerKeys, TypeOfService, ServiceContainer } from "./interfaces";
             import { TraceSource } from "../log/TraceSource";
             import { Configuration, RegistrationMap } from "./Configuration";
             import { Cancellation } from "../Cancellation";
-            import { IDestroyable, ICancellation } from "../interfaces";
+            import { ICancellation } from "../interfaces";
             import { isDescriptor } from "./traits";
             import { LifetimeManager } from "./LifetimeManager";
             import { each, isString } from "../safe";
             import { ContainerConfiguration, FluentRegistrations } from "./fluent/interfaces";
             import { FluentConfiguration } from "./fluent/FluentConfiguration";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
-            export class Container<S extends object = any> implements ServiceContainer<S>, IDestroyable {
+            export class Container<S extends object = any> implements ServiceContainer<S> {
                 readonly _services: ContainerServiceMap<S>;
                 readonly _lifetimeManager: LifetimeManager;
                 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._services = Object.create(parent ? parent._services : null);
                     this._cleanup = [];
                     this._root = parent ? parent.getRootContainer() : this;
                     this._services.container = new ValueDescriptor(this) as any;
+                    this._services.childContainer = { activate: () => this.createChildContainer() };
                     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?: TypeOfService<S, K>): TypeOfService<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, String(name), d);
                         try {
                             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?: TypeOfService<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>;
                         each(data, (v, k) => this.register(k, v));
                     } else {
                         if (!isDescriptor(service))
                             throw new Error("The service parameter must be a descriptor");
                         this._services[nameOrCollection as K] = service as any;
                     }
                     return this;
                 }
                 /** @deprecated use getLifetimeManager() */
                 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 container. 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 registered in the container.
                  *
                  * @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?: { contextRequire: any; baseModule?: string }, ct = Cancellation.none) {
                     const _opts = Object.create(opts || null);
                     if (typeof (config) === "string") {
                         _opts.baseModule = config;
                         const module = await import(config);
                         if (module && module.default && typeof (module.default.apply) === "function")
                             return module.default.apply(this);
                         else
                             return this._applyLegacyConfig(module, _opts, ct);
                     } else {
                         return this._applyLegacyConfig(config, _opts, ct);
                     }
                 }
                 applyConfig<S2 extends object>(config: Promise<{ default: ContainerConfiguration<S2>; }>, ct?: ICancellation): Promise<ServiceContainer<S & S2>>;
                 applyConfig<S2 extends object, P extends string>(config: Promise<{ [p in P]: ContainerConfiguration<S2>; }>, prop: P, ct?: ICancellation): Promise<ServiceContainer<S & S2>>;
                 async applyConfig<S2 extends object, P extends string>(
                     config: Promise<{ [p in P | "default"]: ContainerConfiguration<S2>; }>,
                     propOrCt?: P | ICancellation,
                     ct?: ICancellation
                 ): Promise<ServiceContainer<S & S2>> {
                     const mod = await config;
                     let _ct: ICancellation;
                     let _prop: P | "default";
                     if (isString(propOrCt)) {
                         _prop = propOrCt;
                         _ct = ct || Cancellation.none;
                     } else {
                         _ct = propOrCt || Cancellation.none;
                         _prop = "default";
                     }
                     return mod[_prop].apply(this, _ct);
                 }
                 async _applyLegacyConfig(config: RegistrationMap<S>, opts: { contextRequire: any; baseModule?: string }, ct = Cancellation.none) {
                     return new Configuration<S>(this).applyConfiguration(config, opts);
                 }
                 async fluent<K extends keyof S>(config: FluentRegistrations<K, S>, ct = Cancellation.none): Promise<this> {
                     await new FluentConfiguration<S>().register(config).apply(this, ct);
                     return this;
                 }
                 createChildContainer<S2 extends object = S>(): Container<S & S2> {
                     return new Container<S & S2>(this as any);
                 }
             }

src/main/ts/di/interfaces.ts +4 -1

+            import { IDestroyable } from "../interfaces";
             import { ActivationContext } from "./ActivationContext";
             import { LifetimeManager } from "./LifetimeManager";
             export interface Descriptor<S extends object = any, T = any> {
                 activate(context: ActivationContext<S>): T;
             }
             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 TypeOfService<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, TypeOfService<S, K>>;
             };
             export type PartialServiceMap<S extends object> = {
                 [k in keyof S]?: Descriptor<S, S[k]>;
             };
             export interface ServiceLocator<S extends object> {
                 resolve<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>): TypeOfService<S, K>;
             }
-            export interface ServiceContainer<S extends object> extends ServiceLocator<S> {
+            export interface ServiceContainer<S extends object> extends ServiceLocator<S>, IDestroyable {
                 getLifetimeManager(): LifetimeManager;
                 register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>): this;
                 register(services: PartialServiceMap<S>): this;
                 createChildContainer(): ServiceContainer<S>;
             }
             export interface ContainerProvided<S extends object> {
                 container: ServiceLocator<S>;
+                childContainer: ServiceContainer<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";
             /**
              * Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет
              * свой собственный объект `ILifetime`, который создается при первой активации
              */
             export interface ILifetime {
                 /** Проверяет, что уже создан экземпляр объекта */
                 has(): boolean;
                 get(): any;
                 initialize(context: ActivationContext<any>): void;
                 store(item: any, cleanup?: (item: any) => void): void;
             }

src/test/ts/tests/TextTests.ts +9 0

             import { StringBuilder } from "../text/StringBuilder";
             import { test } from "./TestTraits";
             import { MockConsole } from "../mock/MockConsole";
             import { ConsoleWriter } from "../log/ConsoleWriter";
+            import { Uuid } from "../Uuid";
             test("String builder", async t => {
                 const sb = new StringBuilder();
                 sb.write("hello");
                 t.equals(sb.toString(), "hello", "Write simple text");
                 sb.write(", ");
                 sb.write("world!");
                 t.equals(sb.toString(), "hello, world!", "Append text");
                 sb.clear();
                 t.equals(sb.toString(), "", "Clear");
                 sb.write(1);
                 t.equals(sb.toString(), "1", "Write number");
                 sb.clear();
                 sb.writeValue(0.123);
                 t.equals(sb.toString(), "0.123", "Format number");
                 sb.clear();
                 sb.writeValue(new Date("2019-01-02T00:00:00.000Z"));
                 t.equals(sb.toString(), "2019-01-02T00:00:00.000Z", "Format date (ISO)");
                 sb.clear();
                 sb.write("{0}", "hello");
                 t.equals(sb.toString(), "hello", "Simple format text");
                 sb.write(", {0}!", "world");
                 t.equals(sb.toString(), "hello, world!", "Append formatted text");
                 sb.clear();
                 sb.write("abc: {0:json}; {0.length}; {0.1} {{olo}}", ["a", "b", "c"]);
                 t.equals(sb.toString(), 'abc: [\n  "a",\n  "b",\n  "c"\n]; 3; b {olo}', "Format string with spec");
                 sb.clear();
                 t.throws(() => sb.write("}", 0), "Should die on bad format: '}'");
                 t.throws(() => sb.write("{", 0), "Should die on bad format: '{'");
                 t.throws(() => sb.write("{}", 0), "Should die on bad format: '{}'");
                 t.throws(() => sb.write("{:}", 0), "Should die on bad format: '{:}'");
                 t.throws(() => sb.write("{{0}", 0), "Should die on bad format: '{{0}'");
             });
             test("ConsoleWriter", t => {
                 const mockConsole = new MockConsole();
                 const writer = new ConsoleWriter(mockConsole);
                 writer.setLogLevel("log");
                 writer.writeLine("Hello, world!");
                 t.equals(mockConsole.getBuffer().length, 1, "One line should be written");
                 t.equals(mockConsole.getBuffer()[0].level, "log", "LogLevel should be 'log'");
                 t.deepEqual(mockConsole.getBuffer()[0].data, ["Hello, world!"], "The buffer should contain single string");
                 mockConsole.clear();
                 writer.setLogLevel("debug");
                 writer.write("Bring ");
                 writer.write("the {0}!", "light");
                 t.equals(mockConsole.getBuffer().length, 0, "No line should be written");
                 writer.writeLine();
                 t.equals(mockConsole.getBuffer().length, 1, "One line should be written");
                 t.equals(mockConsole.getBuffer()[0].level, "debug", "LogLevel should be 'log'");
                 t.deepEqual(mockConsole.getBuffer()[0].data, ["Bring the light!"], "Should concatenate string parts together");
                 mockConsole.clear();
                 writer.writeLine("It's {0} o'clock, lets have some {1}!", { h: 5}, { title: "tee" });
                 t.deepEqual(mockConsole.getBuffer()[0].data, ["It's ", { h: 5}, " o'clock, lets have some ", { title: "tee" }, "!"], "Non string parts should be psassed as is");
                 mockConsole.clear();
                 writer.writeLine("{0} or {1} to {2}", {i: 25}, 6, 4);
                 t.deepEqual(mockConsole.getBuffer()[0].data, [{i: 25}, " or 6 to 4"], "25 or 6 to 4");
                 mockConsole.clear();
                 writer.writeLine("{0} or {1} to {2}! Let's have some {3}", 25, 6, 4, { product: "tee" } );
                 t.deepEqual(mockConsole.getBuffer()[0].data, ["25 or 6 to 4! Let's have some ", { product: "tee" }], "Should handle many text chunks and object at the end");
             });
+            test("Uuid test", (t, log) => {
+                const id = Uuid();
+                log.log("uuid = {0}", id);
+                t.assert(id, "Should generate uuid");
+                t.notEqual(id, Uuid(), "uuid should never match");
+            });

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