implab/implabjs-core Commit - r82:025f02eff3b2

StringBuilder, TextWriter, ConsoleWriter tests

cin -

r82:025f02eff3b2 v1.3.0 default

parent child

Context file:

r82:025f02eff3b2

Expand all files

src/main/ts/log/ConsoleWriter.ts created 644 +100 0

@@ -0,0 +1,100
	1	import { TextWriterBase } from "../text/TextWriterBase";
	2	import { isNull, isNullOrEmptyString, isPrimitive } from "../safe";
	3	import { NullConsole } from "./NullConsole";
	4
	5	interface LogConsole {
	6	debug(...args: any[]): void;
	7	log(...args: any[]): void;
	8	warn(...args: any[]): void;
	9	error(...args: any[]): void;
	10	}
	11
	12	function hasConsole() {
	13	try {
	14	// tslint:disable-next-line:no-console
	15	return (typeof console !== "undefined" && typeof console.log === "function");
	16	} catch {
	17	return false;
	18	}
	19	}
	20
	21	function getConsole() {
	22	return hasConsole() ? console : NullConsole.instance;
	23	}
	24
	25	export class ConsoleWriter extends TextWriterBase {
	26	static readonly default = new ConsoleWriter(getConsole());
	27
	28	private _buffer: any[];
	29
	30	private _out: LogConsole;
	31	private _level: keyof LogConsole;
	32
	33	constructor(out?: LogConsole) {
	34	super();
	35	this._out = out \|\| NullConsole.instance;
	36	this._buffer = [];
	37	this._level = "log";
	38	}
	39
	40	getLogLevel() {
	41	return this._level;
	42	}
	43
	44	setLogLevel(level: keyof LogConsole) {
	45	this._level = level;
	46	}
	47
	48	/** Flushes the buffer to the console
	49	*/
	50	writeNewLine() {
	51	// group text chunks together, and let objects as is
	52	// ['a', 'b', {foo: 'bar'}, 'c', 'd'] -> ['ab', {foo: 'bar'}, 'cd']
	53	// this will prevent from additional spaces to occur in the console
	54	// ['a', 'b'] will be printed as 'a b' rather then 'ab'.
	55
	56	// console.log("writeLine", this._buffer);
	57
	58	let offset = 0;
	59	const args = [];
	60	this._buffer.forEach((v, i) => {
	61	if (!isPrimitive(v)) {
	62	if (offset < i)
	63	args.push(i - offset > 1 ? this._buffer.slice(offset, i).join("") : this._buffer[offset]);
	64	args.push(v);
	65	offset = i + 1;
	66	}
	67	});
	68	if (offset < this._buffer.length)
	69	args.push(this._buffer.slice(offset).join(""));
	70
	71	// console.log("WriteLine", args);
	72
	73	this._out[this._level].apply(this._out, args);
	74
	75	this._buffer = [];
	76	}
	77
	78	/** Adds a text chunk to the buffer. Buffer contents will be flushed when
	79	* the end of line will be printed.
	80	*
	81	* @param text The text to be added to the buffer.
	82	*/
	83	writeText(text: string) {
	84	this._buffer.push(text);
	85	}
	86
	87	/** Wrotes the specified value to the buffer.
	88	*
	89	* @param value The value to be added to the buffer
	90	* @param spec The instructions how to format the value, is this parameter
	91	* is ommited the raw value will be added to the buffer and
	92	* passed directly to the console out.
	93	*/
	94	writeValue(value: any, spec?: string) {
	95	if (isNullOrEmptyString(spec))
	96	this._buffer.push(value);
	97	else
	98	super.writeValue(value);
	99	}
	100	}

src/main/ts/log/NullConsole.ts created 644 +52 0

@@ -0,0 +1,52
	1	export class NullConsole {
	2	static readonly instance = new NullConsole();
	3
	4	assert(condition?: boolean, message?: string, ...data: any[]): void {
	5	}
	6	clear(): void {
	7	}
	8	count(label?: string): void {
	9	}
	10	debug(message?: any, ...optionalParams: any[]): void {
	11	}
	12	dir(value?: any, ...optionalParams: any[]): void {
	13	}
	14	dirxml(value: any): void {
	15	}
	16	error(message?: any, ...optionalParams: any[]): void {
	17	}
	18	exception(message?: string, ...optionalParams: any[]): void {
	19	}
	20	group(groupTitle?: string, ...optionalParams: any[]): void {
	21	}
	22	groupCollapsed(groupTitle?: string, ...optionalParams: any[]): void {
	23	}
	24	groupEnd(): void {
	25	}
	26	info(message?: any, ...optionalParams: any[]): void {
	27	}
	28	log(message?: any, ...optionalParams: any[]): void {
	29	}
	30	markTimeline(label?: string): void {
	31	}
	32	profile(reportName?: string): void {
	33	}
	34	profileEnd(reportName?: string): void {
	35	}
	36	table(...tabularData: any[]): void {
	37	}
	38	time(label?: string): void {
	39	}
	40	timeEnd(label?: string): void {
	41	}
	42	timeStamp(label?: string): void {
	43	}
	44	timeline(label?: string): void {
	45	}
	46	timelineEnd(label?: string): void {
	47	}
	48	trace(message?: any, ...optionalParams: any[]): void {
	49	}
	50	warn(message?: any, ...optionalParams: any[]): void {
	51	}
	52	}

src/main/ts/log/TraceEventData.ts created 644 +20 0

@@ -0,0 +1,20
	1	import { TraceEvent, TraceSource } from "./TraceSource";
	2	import { format } from "../text/StringBuilder";
	3
	4	export class TraceEventData implements TraceEvent {
	5	source: TraceSource;
	6	level: number;
	7	message: any;
	8	args?: any[];
	9
	10	constructor(source: TraceSource, level: number, message: any, args: any[]) {
	11	this.source = source;
	12	this.level = level;
	13	this.message = message;
	14	this.args = args;
	15	}
	16
	17	toString() {
	18	return format(this.message, ...this.args);
	19	}
	20	}

src/main/ts/log/writers/ConsoleLogger.ts created 644 +41 0

@@ -0,0 +1,41
	1	import { IObservable, IDestroyable, ICancellation } from "../../interfaces";
	2	import { TraceEvent, LogLevel, WarnLevel, DebugLevel } from "../TraceSource";
	3	import { Cancellation } from "../../Cancellation";
	4	import { destroy, argumentNotNull } from "../../safe";
	5	import { ConsoleWriter } from "../ConsoleWriter";
	6
	7	export class ConsoleLogger implements IDestroyable {
	8	private readonly _subscriptions = new Array<IDestroyable>();
	9	private readonly _writer: ConsoleWriter;
	10
	11	constructor(writer = ConsoleWriter.default) {
	12	argumentNotNull(writer, "writer");
	13	this._writer = writer;
	14	}
	15
	16	writeEvents(source: IObservable<TraceEvent>, ct: ICancellation = Cancellation.none) {
	17	const subscription = source.on(this.writeEvent.bind(this));
	18	if (ct.isSupported()) {
	19	ct.register(subscription.destroy.bind(subscription));
	20	}
	21	this._subscriptions.push(subscription);
	22	}
	23
	24	writeEvent(next: TraceEvent) {
	25	if (next.level >= DebugLevel) {
	26	this._writer.setLogLevel("debug");
	27	} else if (next.level >= LogLevel) {
	28	this._writer.setLogLevel("log");
	29	} else if (next.level >= WarnLevel) {
	30	this._writer.setLogLevel("warn");
	31	} else {
	32	this._writer.setLogLevel("error");
	33	}
	34	this._writer.write("{0}: ", next.source.id);
	35	this._writer.writeLine(next.message, ...next.args);
	36	}
	37
	38	destroy() {
	39	this._subscriptions.forEach(destroy);
	40	}
	41	}

src/main/ts/text/Converter.ts created 644 +30 0

@@ -0,0 +1,30
	1	import { isPrimitive, isNull } from "../safe";
	2
	3	export class Converter {
	4	static readonly default = new Converter();
	5
	6	convert(value: any, pattern: string) {
	7	if (pattern && pattern.toLocaleLowerCase() === "json") {
	8	const seen = [];
	9	return JSON.stringify(value, (k, v) => {
	10	if (!isPrimitive(v)) {
	11	const id = seen.indexOf(v);
	12	if (id >= 0)
	13	return "@ref-" + id;
	14	else {
	15	seen.push(v);
	16	return v;
	17	}
	18	} else {
	19	return v;
	20	}
	21	}, 2);
	22	} else if (isNull(value)) {
	23	return "";
	24	} else if (value instanceof Date) {
	25	return value.toISOString();
	26	} else {
	27	return value.toString();
	28	}
	29	}
	30	}

src/main/ts/text/NullTextWriter.ts created 644 +19 0

@@ -0,0 +1,19
	1	import { TextWriter } from "../interfaces";
	2
	3	export class NullTextWriter implements TextWriter {
	4	static readonly instance = new NullTextWriter();
	5
	6	write(obj: any): void;
	7	write(format: string, ...args: any[]): void;
	8	write() {
	9	}
	10
	11	writeLine(obj: any): void;
	12	writeLine(format: string, ...args: any[]): void;
	13	writeLine() {
	14	}
	15
	16	writeValue(value: any, spec?: string): void;
	17	writeValue() {
	18	}
	19	}

src/main/ts/text/TextWriterBase.ts created 644 +48 0

@@ -0,0 +1,48
	1	import { TextWriter } from "../interfaces";
	2	import { FormatCompiler } from "./FormatCompiler";
	3	import { isString, argumentNotNull } from "../safe";
	4	import { Converter } from "./Converter";
	5
	6	const compiler = new FormatCompiler();
	7
	8	export abstract class TextWriterBase implements TextWriter {
	9	private _converter: Converter;
	10
	11	constructor(converter = Converter.default) {
	12	argumentNotNull(converter, "converter");
	13	this._converter = converter;
	14	}
	15
	16	writeNewLine() {
	17	this.writeValue("\n");
	18	}
	19
	20	write(obj: any): void;
	21	write(format: string, ...args: any[]): void;
	22	write(format: any, ...args: any[]): void {
	23	if (args.length) {
	24	const compiled = compiler.compile(format);
	25	compiled(this, args);
	26	} else {
	27	this.writeValue(format);
	28	}
	29	}
	30
	31	writeLine(obj?: any): void;
	32	writeLine(format: string, ...args: any[]): void;
	33	writeLine(): void {
	34	if (arguments.length)
	35	this.write.apply(this, arguments);
	36	this.writeNewLine();
	37	}
	38
	39	writeValue(value: any, spec?: string): void {
	40	this.writeText(
	41	isString(value) ?
	42	value :
	43	this._converter.convert(value, spec)
	44	);
	45	}
	46
	47	abstract writeText(text: string);
	48	}

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

@@ -0,0 +1,86
	1	import { StringBuilder } from "@implab/core/text/StringBuilder";
	2	import { test } from "./TestTraits";
	3	import { MockConsole } from "./mock/MockConsole";
	4	import { ConsoleWriter } from "@implab/core/log/ConsoleWriter";
	5
	6	test("String builder", async t => {
	7	const sb = new StringBuilder();
	8
	9	sb.write("hello");
	10	t.equals(sb.toString(), "hello", "Write simple text");
	11
	12	sb.write(", ");
	13	sb.write("world!");
	14	t.equals(sb.toString(), "hello, world!", "Append text");
	15
	16	sb.clear();
	17	t.equals(sb.toString(), "", "Clear");
	18
	19	sb.write(1);
	20	t.equals(sb.toString(), "1", "Write number");
	21
	22	sb.clear();
	23	sb.writeValue(0.123);
	24	t.equals(sb.toString(), "0.123", "Format number");
	25
	26	sb.clear();
	27	sb.writeValue(new Date("2019-01-02T00:00:00.000Z"));
	28	t.equals(sb.toString(), "2019-01-02T00:00:00.000Z", "Format date (ISO)");
	29
	30	sb.clear();
	31	sb.write("{0}", "hello");
	32	t.equals(sb.toString(), "hello", "Simple format text");
	33
	34	sb.write(", {0}!", "world");
	35	t.equals(sb.toString(), "hello, world!", "Append formatted text");
	36
	37	sb.clear();
	38	sb.write("abc: {0:json}; {0.length}; {0.1} {{olo}}", ["a", "b", "c"]);
	39	t.equals(sb.toString(), 'abc: [\n "a",\n "b",\n "c"\n]; 3; b {olo}', "Format string with spec");
	40
	41	sb.clear();
	42	t.throws(() => sb.write("}", 0), "Should die on bad format: '}'");
	43	t.throws(() => sb.write("{", 0), "Should die on bad format: '{'");
	44	t.throws(() => sb.write("{}", 0), "Should die on bad format: '{}'");
	45	t.throws(() => sb.write("{:}", 0), "Should die on bad format: '{:}'");
	46	t.throws(() => sb.write("{{0}", 0), "Should die on bad format: '{{0}'");
	47
	48	});
	49
	50	test("ConsoleWriter", t => {
	51	const mockConsole = new MockConsole();
	52	const writer = new ConsoleWriter(mockConsole);
	53
	54	writer.setLogLevel("log");
	55
	56	writer.writeLine("Hello, world!");
	57
	58	t.equals(mockConsole.getBuffer().length, 1, "One line should be written");
	59	t.equals(mockConsole.getBuffer()[0].level, "log", "LogLevel should be 'log'");
	60	t.deepEqual(mockConsole.getBuffer()[0].data, ["Hello, world!"], "The buffer should contain single string");
	61
	62	mockConsole.clear();
	63	writer.setLogLevel("debug");
	64	writer.write("Bring ");
	65	writer.write("the {0}!", "light");
	66	t.equals(mockConsole.getBuffer().length, 0, "No line should be written");
	67	writer.writeLine();
	68
	69	t.equals(mockConsole.getBuffer().length, 1, "One line should be written");
	70	t.equals(mockConsole.getBuffer()[0].level, "debug", "LogLevel should be 'log'");
	71	t.deepEqual(mockConsole.getBuffer()[0].data, ["Bring the light!"], "Should concatenate string parts together");
	72
	73	mockConsole.clear();
	74	writer.writeLine("It's {0} o'clock, lets have some {1}!", { h: 5}, { title: "tee" });
	75
	76	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");
	77
	78	mockConsole.clear();
	79	writer.writeLine("{0} or {1} to {2}", {i: 25}, 6, 4);
	80	t.deepEqual(mockConsole.getBuffer()[0].data, [{i: 25}, " or 6 to 4"], "25 or 6 to 4");
	81
	82	mockConsole.clear();
	83	writer.writeLine("{0} or {1} to {2}! Let's have some {3}", 25, 6, 4, { product: "tee" } );
	84	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");
	85
	86	});

src/test/ts/mock/MockConsole.ts created 644 +52 0

@@ -0,0 +1,52
	1	import {NullConsole} from "@implab/core/log/NullConsole";
	2
	3	interface ConsoleLineData {
	4	level: string;
	5	data: any[];
	6	}
	7
	8	export class MockConsole extends NullConsole {
	9	_buffer: ConsoleLineData[] = [];
	10
	11	debug(...args: any[]) {
	12	this._buffer.push({
	13	level: "debug",
	14	data: args
	15	});
	16	}
	17
	18	log(...args: any[]) {
	19	this._buffer.push({
	20	level: "log",
	21	data: args
	22	});
	23	}
	24
	25	warn(...args: any[]) {
	26	this._buffer.push({
	27	level: "warn",
	28	data: args
	29	});
	30	}
	31
	32	error(...args: any[]) {
	33	this._buffer.push({
	34	level: "error",
	35	data: args
	36	});
	37	}
	38
	39	getBuffer() {
	40	return this._buffer;
	41	}
	42
	43	getLine(i: number) {
	44	if (i >= this._buffer.length)
	45	throw new Error(`Line number ${i} is out of range, buffer.length = ${this._buffer.length}`);
	46	return this._buffer[i].data;
	47	}
	48
	49	clear() {
	50	this._buffer = [];
	51	}
	52	}

build.gradle +2 0

             // если версия явно не заданы вычисляем ее из тэга ревизии v.{num}***
             // результатом будет версия '{num}.{distance}' где distance - расстояние от
             // текущей ревизии до ревизии с тэгом
             def tagDistance = 0;
             def isRelease = false;
             if (!version) {
                 def rev = ["hg", "log", "-r", ".", "--template", "{latesttag('re:^v') % '{tag}-{distance}'}"].execute().text.trim();
                 def tagVersion;
                 def match = (rev =~ /^v(\d+\.\d+\.\d+).*-(\d+)$/);
                 if (match.size()) {
                     tagVersion = match[0][1];
                     tagDistance = match[0][2].toInteger();
                 } else {
                     throw new Exception("A version must be specied");
                 }
                 version = tagVersion;
                 if (tagDistance > 0)
                     version++;
             } else {
                 println "explicit version: $version";
             }
             if (hasProperty('versionSuffix') && versionSuffix) {
                 version += "-$versionSuffix"
             }
             if(!npmName)
                 npmName = name;
             if (hasProperty('release')) {
                 isRelease = (release != 'false')
             } else {
                 isRelease = (tagDistance == 0);
             }
             if(!["amd", "commonjs", "system", "umd", "es6", "esnext"].contains(jsmodule))
                 throw new Exception("Invalid jsmodule specified: $jsmodule");
             if(!["es3", "es5", "es6", "es2016", "es2017", "esnext"].contains(target))
                 throw new Exception("Invalid target specified: $target")
             def targetLibs = [
                 "es3" : "es5,es2015.promise,es2015.symbol,dom,scripthost",
                 "es5" : "es5,es2015.promise,es2015.symbol,dom,scripthost"
             ];
             ext.packageName="@$npmScope/$npmName";
             def srcDir = "$projectDir/src"
             def typingsDir = "$srcDir/typings"
             def distDir = "$buildDir/dist"
             def testDir = "$buildDir/test"
             def lib = targetLibs[target] ?: "${target},dom";
             println "lib: $lib";
             def sourceSets = ["main", "amd", "cjs"];
             def testSets = ["test", "testAmd", "testCjs"];
             task beforeBuild {
             }
             def createSoursetTasks = { String name, String outDir ->
                 def setName = name.capitalize();
                 def compileDir = "$buildDir/compile/$name"
                 def declDir = "$typingsDir/$name"
                 def setDir = "$projectDir/src/$name"
                 def jsDir = outDir;
                 def beforeBuildTask = task "beforeBuild$setName"(dependsOn: beforeBuild) {
                 }
                 def copyJsTask = task "copyJs$setName"(dependsOn: beforeBuildTask, type: Copy) {
                     from "$setDir/js"
                     into jsDir
                 }
                 def lintJsTask = task "lintJs$setName"(dependsOn: beforeBuildTask, type: Exec) {
                     inputs.dir("$setDir/js/").skipWhenEmpty();
                     commandLine "eslint", '--format', 'stylish', "$setDir/js/"
                 }
                 def compileTsTask = task "compileTs$setName"(dependsOn: beforeBuildTask, type: Exec) {
                     inputs.dir("$setDir/ts").skipWhenEmpty()
                     inputs.file("$srcDir/tsconfig.json")
                     inputs.file("$setDir/tsconfig.json")
                     outputs.dir(compileDir)
                     outputs.dir(declDir)
                     commandLine 'node_modules/.bin/tsc',
                         '-p', "$setDir/tsconfig.json",
                         '-t', target,
                         '-m', jsmodule,
                         '-d',
+                        '--sourceMap',
+                        '--sourceRoot', "file://$setDir/ts",
                         '--outDir', compileDir,
                         '--declarationDir', declDir
                     if (lib)
                         args '--lib', lib
                 }
                 def copyTsOutputTask = task "copyTsOutput$setName"(dependsOn: compileTsTask, type: Copy) {
                     from compileDir
                     into jsDir
                 }
                 def copyTypingsTask = task "copyTypings$setName"(dependsOn: compileTsTask, type: Copy) {
                     from declDir
                     into jsDir
                 }
                 def copyResourcesTask = task "copyResources$setName"(dependsOn: beforeBuildTask, type: Copy) {
                     from "$setDir/resources"
                     into outDir
                 }
                 task "build$setName" {
                     dependsOn copyTypingsTask,
                         copyTsOutputTask,
                         copyJsTask,
                         copyResourcesTask,
                         lintJsTask
                 }
             }
             task printVersion {
                 doLast {
                     println "version: $version";
                     println "isRelease: $isRelease, tagDistance: $tagDistance";
                     println "packageName: $packageName";
                     println "bundle: ${pack.outputs.files.join(',')}";
                     println "target: $target";
                     println "module: $jsmodule";
                 }
             }
             task clean {
                 doLast {
                     delete buildDir
                     delete typingsDir
                 }
             }
             task _initBuild {
                 mustRunAfter clean
                 def buildInfoFile = "$buildDir/platform";
                 inputs.property('target',target);
                 inputs.property('jsmodule',jsmodule);
                 outputs.file(buildInfoFile);
                 doLast {
                     delete buildDir
                     mkdir buildDir
                     def f = new File(buildInfoFile);
                     f << "$target-$jsmodule";
                 }
             }
             task cleanNpm {
                 doLast {
                     delete 'node_modules'
                 }
             }
             task _npmInstall() {
                 inputs.file("package.json")
                 outputs.dir("node_modules")
                 doLast {
                     exec {
                         commandLine 'npm', 'install'
                     }
                 }
             }
             beforeBuild {
                 dependsOn _initBuild
                 dependsOn _npmInstall
             }
             sourceSets.each { createSoursetTasks(it, distDir) }
             testSets.each { createSoursetTasks(it, testDir) }
             compileTsAmd {
                 dependsOn compileTsMain
             }
             compileTsCjs {
                 dependsOn compileTsMain
             }
             task build(dependsOn: buildMain) {
                 if (jsmodule == "amd")
                     dependsOn buildAmd
                 if (jsmodule == "commonjs")
                     dependsOn buildCjs
             }
             compileTsTest {
                 dependsOn build
             }
             compileTsTestAmd {
                 dependsOn compileTsTest
             }
             compileTsTestCjs {
                 dependsOn compileTsTest
             }
             task _installLocalCjsDependency(dependsOn: [buildTestCjs, "_packageMeta"], type: Exec) {
                 inputs.file("$distDir/package.json")
                 outputs.upToDateWhen {
                     new File("$testDir/$packageName").exists()
                 }
                 workingDir testDir
                 commandLine 'npm', 'install', '--no-save', '--force', distDir
             }
             task test(dependsOn: [buildTest], type: Exec) {
                 if (jsmodule == "amd")
                     dependsOn buildTestAmd
                 if (jsmodule == "commonjs") {
                     dependsOn buildTestCjs
                     dependsOn _installLocalCjsDependency
                 }
                 commandLine 'node', "$testDir/run-tests.js"
             }
             task _packageMeta(type: Copy) {
                 mustRunAfter build
                 inputs.property("version", version)
                 from('.') {
                     include '.npmignore', 'readme.md', 'license', 'history.md'
                 }
                 from("$srcDir/package.${jsmodule}.tmpl.json") {
                     expand project.properties
                     rename { "package.json" }
                 }
                 into distDir
             }
             task pack(dependsOn: [build, _packageMeta], type: Exec) {
                 workingDir distDir
                 outputs.file("$npmScope-$npmName-${version}.tgz")
                 commandLine 'npm', 'pack'
             }
             task publish(dependsOn: [build, _packageMeta], type: Exec) {
                 doFirst {
                     if (!isRelease)
                         throw new Exception("Can't publish an unreleased version");
                 }
                 workingDir distDir
                 commandLine 'npm', 'publish', '--access', 'public'
             }
             task markRelease(type: Exec) {
                 onlyIf { tagDistance > 1 }
                 commandLine "hg", "tag", "v$version";
             }

gradle.properties +1 -1

             version=
             author=Implab team
             jsmodule=amd
             target=es5
             description=Dependency injection, logging, simple and fast text template engine
             license=BSD-2-Clause
             repository=https://bitbucket.org/implab/implabjs-core
             npmScope=implab
-            npmName=core
  No newline at end of file
+            npmName=core-amd
  No newline at end of file

package-lock.json +6 -6

             {
               "name": "@implab/core",
               "version": "0.0.1-dev",
               "lockfileVersion": 1,
               "requires": true,
               "dependencies": {
                 "@types/node": {
                   "version": "10.12.18",
                   "resolved": "https://registry.npmjs.org/@types/node/-/node-10.12.18.tgz",
                   "integrity": "sha512-fh+pAqt4xRzPfqA6eh3Z2y6fyZavRIumvjhaCL753+TVkGKGhpPeyrJG2JftD0T9q4GF00KjefsQ+PQNDdWQaQ==",
                   "dev": true
                 },
                 "@types/requirejs": {
                   "version": "2.1.31",
                   "resolved": "https://registry.npmjs.org/@types/requirejs/-/requirejs-2.1.31.tgz",
                   "integrity": "sha512-b2soeyuU76rMbcRJ4e0hEl0tbMhFwZeTC0VZnfuWlfGlk6BwWNsev6kFu/twKABPX29wkX84wU2o+cEJoXsiTw==",
                   "dev": true
                 },
                 "@types/tape": {
                   "version": "4.2.33",
                   "resolved": "https://registry.npmjs.org/@types/tape/-/tape-4.2.33.tgz",
                   "integrity": "sha512-ltfyuY5BIkYlGuQfwqzTDT8f0q8Z5DGppvUnWGs39oqDmMd6/UWhNpX3ZMh/VYvfxs3rFGHMrLC/eGRdLiDGuw==",
                   "dev": true,
                   "requires": {
                     "@types/node": "*"
                   }
                 },
                 "balanced-match": {
                   "version": "1.0.0",
                   "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
                   "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=",
                   "dev": true
                 },
                 "brace-expansion": {
                   "version": "1.1.11",
                   "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
                   "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
                   "dev": true,
                   "requires": {
                     "balanced-match": "^1.0.0",
                     "concat-map": "0.0.1"
                   }
                 },
                 "concat-map": {
                   "version": "0.0.1",
                   "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
                   "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
                   "dev": true
                 },
                 "core-util-is": {
                   "version": "1.0.2",
                   "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
                   "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=",
                   "dev": true
                 },
                 "deep-equal": {
                   "version": "0.1.2",
                   "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-0.1.2.tgz",
                   "integrity": "sha1-skbCuApXCkfBG+HZvRBw7IeLh84=",
                   "dev": true
                 },
                 "define-properties": {
                   "version": "1.1.3",
                   "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz",
                   "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==",
                   "dev": true,
                   "requires": {
                     "object-keys": "^1.0.12"
                   },
                   "dependencies": {
                     "object-keys": {
                       "version": "1.0.12",
                       "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.12.tgz",
                       "integrity": "sha512-FTMyFUm2wBcGHnH2eXmz7tC6IwlqQZ6mVZ+6dm6vZ4IQIHjs6FdNsQBuKGPuUUUY6NfJw2PshC08Tn6LzLDOag==",
                       "dev": true
                     }
                   }
                 },
                 "defined": {
                   "version": "0.0.0",
                   "resolved": "https://registry.npmjs.org/defined/-/defined-0.0.0.tgz",
                   "integrity": "sha1-817qfXBekzuvE7LwOz+D2SFAOz4=",
                   "dev": true
                 },
                 "dojo": {
                   "version": "1.14.2",
                   "resolved": "https://registry.npmjs.org/dojo/-/dojo-1.14.2.tgz",
                   "integrity": "sha512-TI+Ytgfh/VfmHWERp45Jte6NFMdoJTPsvUP/uzJUvAXET8FP2h442LePWWJ/q/xZ4V0V8OtdJhx8It/GB+Zbxg==",
                   "dev": true
                 },
                 "duplexer": {
                   "version": "0.1.1",
-                  "resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.1.tgz",
+                  "resolved": "http://registry.npmjs.org/duplexer/-/duplexer-0.1.1.tgz",
                   "integrity": "sha1-rOb/gIwc5mtX0ev5eXessCM0z8E=",
                   "dev": true
                 },
                 "es-abstract": {
                   "version": "1.13.0",
                   "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.13.0.tgz",
                   "integrity": "sha512-vDZfg/ykNxQVwup/8E1BZhVzFfBxs9NqMzGcvIJrqg5k2/5Za2bWo40dK2J1pgLngZ7c+Shh8lwYtLGyrwPutg==",
                   "dev": true,
                   "requires": {
                     "es-to-primitive": "^1.2.0",
                     "function-bind": "^1.1.1",
                     "has": "^1.0.3",
                     "is-callable": "^1.1.4",
                     "is-regex": "^1.0.4",
                     "object-keys": "^1.0.12"
                   },
                   "dependencies": {
                     "object-keys": {
                       "version": "1.0.12",
                       "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.12.tgz",
                       "integrity": "sha512-FTMyFUm2wBcGHnH2eXmz7tC6IwlqQZ6mVZ+6dm6vZ4IQIHjs6FdNsQBuKGPuUUUY6NfJw2PshC08Tn6LzLDOag==",
                       "dev": true
                     }
                   }
                 },
                 "es-to-primitive": {
                   "version": "1.2.0",
                   "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.0.tgz",
                   "integrity": "sha512-qZryBOJjV//LaxLTV6UC//WewneB3LcXOL9NP++ozKVXsIIIpm/2c13UDiD9Jp2eThsecw9m3jPqDwTyobcdbg==",
                   "dev": true,
                   "requires": {
                     "is-callable": "^1.1.4",
                     "is-date-object": "^1.0.1",
                     "is-symbol": "^1.0.2"
                   }
                 },
                 "faucet": {
                   "version": "0.0.1",
                   "resolved": "https://registry.npmjs.org/faucet/-/faucet-0.0.1.tgz",
                   "integrity": "sha1-WX3PHSGJosBiMhtZHo8VHtIDnZw=",
                   "dev": true,
                   "requires": {
                     "defined": "0.0.0",
                     "duplexer": "~0.1.1",
                     "minimist": "0.0.5",
                     "sprintf": "~0.1.3",
                     "tap-parser": "~0.4.0",
                     "tape": "~2.3.2",
                     "through2": "~0.2.3"
                   },
                   "dependencies": {
                     "tape": {
                       "version": "2.3.3",
-                      "resolved": "https://registry.npmjs.org/tape/-/tape-2.3.3.tgz",
+                      "resolved": "http://registry.npmjs.org/tape/-/tape-2.3.3.tgz",
                       "integrity": "sha1-Lnzgox3wn41oUWZKcYQuDKUFevc=",
                       "dev": true,
                       "requires": {
                         "deep-equal": "~0.1.0",
                         "defined": "~0.0.0",
                         "inherits": "~2.0.1",
                         "jsonify": "~0.0.0",
                         "resumer": "~0.0.0",
                         "through": "~2.3.4"
                       }
                     }
                   }
                 },
                 "for-each": {
                   "version": "0.3.3",
                   "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz",
                   "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==",
                   "dev": true,
                   "requires": {
                     "is-callable": "^1.1.3"
                   }
                 },
                 "fs.realpath": {
                   "version": "1.0.0",
                   "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
                   "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
                   "dev": true
                 },
                 "function-bind": {
                   "version": "1.1.1",
                   "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
                   "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
                   "dev": true
                 },
                 "glob": {
                   "version": "7.1.3",
                   "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz",
                   "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==",
                   "dev": true,
                   "requires": {
                     "fs.realpath": "^1.0.0",
                     "inflight": "^1.0.4",
                     "inherits": "2",
                     "minimatch": "^3.0.4",
                     "once": "^1.3.0",
                     "path-is-absolute": "^1.0.0"
                   }
                 },
                 "has": {
                   "version": "1.0.3",
                   "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
                   "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
                   "dev": true,
                   "requires": {
                     "function-bind": "^1.1.1"
                   }
                 },
                 "has-symbols": {
                   "version": "1.0.0",
                   "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.0.tgz",
                   "integrity": "sha1-uhqPGvKg/DllD1yFA2dwQSIGO0Q=",
                   "dev": true
                 },
                 "inflight": {
                   "version": "1.0.6",
                   "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
                   "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
                   "dev": true,
                   "requires": {
                     "once": "^1.3.0",
                     "wrappy": "1"
                   }
                 },
                 "inherits": {
                   "version": "2.0.3",
                   "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
                   "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=",
                   "dev": true
                 },
                 "is-callable": {
                   "version": "1.1.4",
                   "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.4.tgz",
                   "integrity": "sha512-r5p9sxJjYnArLjObpjA4xu5EKI3CuKHkJXMhT7kwbpUyIFD1n5PMAsoPvWnvtZiNz7LjkYDRZhd7FlI0eMijEA==",
                   "dev": true
                 },
                 "is-date-object": {
                   "version": "1.0.1",
                   "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.1.tgz",
                   "integrity": "sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=",
                   "dev": true
                 },
                 "is-regex": {
                   "version": "1.0.4",
                   "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.4.tgz",
                   "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=",
                   "dev": true,
                   "requires": {
                     "has": "^1.0.1"
                   }
                 },
                 "is-symbol": {
                   "version": "1.0.2",
                   "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.2.tgz",
                   "integrity": "sha512-HS8bZ9ox60yCJLH9snBpIwv9pYUAkcuLhSA1oero1UB5y9aiQpRA8y2ex945AOtCZL1lJDeIk3G5LthswI46Lw==",
                   "dev": true,
                   "requires": {
                     "has-symbols": "^1.0.0"
                   }
                 },
                 "isarray": {
                   "version": "0.0.1",
                   "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz",
                   "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=",
                   "dev": true
                 },
                 "jsonify": {
                   "version": "0.0.0",
                   "resolved": "https://registry.npmjs.org/jsonify/-/jsonify-0.0.0.tgz",
                   "integrity": "sha1-LHS27kHZPKUbe1qu6PUDYx0lKnM=",
                   "dev": true
                 },
                 "minimatch": {
                   "version": "3.0.4",
                   "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
                   "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
                   "dev": true,
                   "requires": {
                     "brace-expansion": "^1.1.7"
                   }
                 },
                 "minimist": {
                   "version": "0.0.5",
-                  "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.5.tgz",
+                  "resolved": "http://registry.npmjs.org/minimist/-/minimist-0.0.5.tgz",
                   "integrity": "sha1-16oye87PUY+RBqxrjwA/o7zqhWY=",
                   "dev": true
                 },
                 "object-inspect": {
                   "version": "1.6.0",
                   "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.6.0.tgz",
                   "integrity": "sha512-GJzfBZ6DgDAmnuaM3104jR4s1Myxr3Y3zfIyN4z3UdqN69oSRacNK8UhnobDdC+7J2AHCjGwxQubNJfE70SXXQ==",
                   "dev": true
                 },
                 "object-keys": {
                   "version": "0.4.0",
                   "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-0.4.0.tgz",
                   "integrity": "sha1-KKaq50KN0sOpLz2V8hM13SBOAzY=",
                   "dev": true
                 },
                 "once": {
                   "version": "1.4.0",
                   "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
                   "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
                   "dev": true,
                   "requires": {
                     "wrappy": "1"
                   }
                 },
                 "path-is-absolute": {
                   "version": "1.0.1",
                   "resolved": "http://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
                   "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
                   "dev": true
                 },
                 "path-parse": {
                   "version": "1.0.6",
                   "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz",
                   "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==",
                   "dev": true
                 },
                 "readable-stream": {
                   "version": "1.1.14",
-                  "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz",
+                  "resolved": "http://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz",
                   "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=",
                   "dev": true,
                   "requires": {
                     "core-util-is": "~1.0.0",
                     "inherits": "~2.0.1",
                     "isarray": "0.0.1",
                     "string_decoder": "~0.10.x"
                   }
                 },
                 "requirejs": {
                   "version": "2.3.6",
                   "resolved": "https://registry.npmjs.org/requirejs/-/requirejs-2.3.6.tgz",
                   "integrity": "sha512-ipEzlWQe6RK3jkzikgCupiTbTvm4S0/CAU5GlgptkN5SO6F3u0UD0K18wy6ErDqiCyP4J4YYe1HuAShvsxePLg==",
                   "dev": true
                 },
                 "resolve": {
                   "version": "1.7.1",
                   "resolved": "http://registry.npmjs.org/resolve/-/resolve-1.7.1.tgz",
                   "integrity": "sha512-c7rwLofp8g1U+h1KNyHL/jicrKg1Ek4q+Lr33AL65uZTinUZHe30D5HlyN5V9NW0JX1D5dXQ4jqW5l7Sy/kGfw==",
                   "dev": true,
                   "requires": {
                     "path-parse": "^1.0.5"
                   }
                 },
                 "resumer": {
                   "version": "0.0.0",
                   "resolved": "https://registry.npmjs.org/resumer/-/resumer-0.0.0.tgz",
                   "integrity": "sha1-8ej0YeQGS6Oegq883CqMiT0HZ1k=",
                   "dev": true,
                   "requires": {
                     "through": "~2.3.4"
                   }
                 },
                 "sprintf": {
                   "version": "0.1.5",
                   "resolved": "https://registry.npmjs.org/sprintf/-/sprintf-0.1.5.tgz",
                   "integrity": "sha1-j4PjmpMXwaUCy324BQ5Rxnn27c8=",
                   "dev": true
                 },
                 "string.prototype.trim": {
                   "version": "1.1.2",
                   "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.1.2.tgz",
                   "integrity": "sha1-0E3iyJ4Tf019IG8Ia17S+ua+jOo=",
                   "dev": true,
                   "requires": {
                     "define-properties": "^1.1.2",
                     "es-abstract": "^1.5.0",
                     "function-bind": "^1.0.2"
                   }
                 },
                 "string_decoder": {
                   "version": "0.10.31",
-                  "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
+                  "resolved": "http://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
                   "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=",
                   "dev": true
                 },
                 "tap-parser": {
                   "version": "0.4.3",
                   "resolved": "https://registry.npmjs.org/tap-parser/-/tap-parser-0.4.3.tgz",
                   "integrity": "sha1-pOrhkMENdsehEZIf84u+TVjwnuo=",
                   "dev": true,
                   "requires": {
                     "inherits": "~2.0.1",
                     "readable-stream": "~1.1.11"
                   }
                 },
                 "tape": {
                   "version": "4.9.2",
                   "resolved": "https://registry.npmjs.org/tape/-/tape-4.9.2.tgz",
                   "integrity": "sha512-lPXKRKILZ1kZaUy5ynWKs8ATGSUO7HAFHCFnBam6FaGSqPdOwMWbxXHq4EXFLE8WRTleo/YOMXkaUTRmTB1Fiw==",
                   "dev": true,
                   "requires": {
                     "deep-equal": "~1.0.1",
                     "defined": "~1.0.0",
                     "for-each": "~0.3.3",
                     "function-bind": "~1.1.1",
                     "glob": "~7.1.2",
                     "has": "~1.0.3",
                     "inherits": "~2.0.3",
                     "minimist": "~1.2.0",
                     "object-inspect": "~1.6.0",
                     "resolve": "~1.7.1",
                     "resumer": "~0.0.0",
                     "string.prototype.trim": "~1.1.2",
                     "through": "~2.3.8"
                   },
                   "dependencies": {
                     "deep-equal": {
                       "version": "1.0.1",
                       "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-1.0.1.tgz",
                       "integrity": "sha1-9dJgKStmDghO/0zbyfCK0yR0SLU=",
                       "dev": true
                     },
                     "defined": {
                       "version": "1.0.0",
                       "resolved": "https://registry.npmjs.org/defined/-/defined-1.0.0.tgz",
                       "integrity": "sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=",
                       "dev": true
                     },
                     "minimist": {
                       "version": "1.2.0",
                       "resolved": "http://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
                       "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
                       "dev": true
                     }
                   }
                 },
                 "through": {
                   "version": "2.3.8",
                   "resolved": "http://registry.npmjs.org/through/-/through-2.3.8.tgz",
                   "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=",
                   "dev": true
                 },
                 "through2": {
                   "version": "0.2.3",
-                  "resolved": "https://registry.npmjs.org/through2/-/through2-0.2.3.tgz",
+                  "resolved": "http://registry.npmjs.org/through2/-/through2-0.2.3.tgz",
                   "integrity": "sha1-6zKE2k6jEbbMis42U3SKUqvyWj8=",
                   "dev": true,
                   "requires": {
                     "readable-stream": "~1.1.9",
                     "xtend": "~2.1.1"
                   }
                 },
                 "tslib": {
                   "version": "1.9.3",
                   "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.9.3.tgz",
                   "integrity": "sha512-4krF8scpejhaOgqzBEcGM7yDIEfi0/8+8zDRZhNZZ2kjmHJ4hv3zCbQWxoJGz1iw5U0Jl0nma13xzHXcncMavQ==",
                   "dev": true
                 },
                 "typescript": {
                   "version": "3.2.2",
                   "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.2.2.tgz",
                   "integrity": "sha512-VCj5UiSyHBjwfYacmDuc/NOk4QQixbE+Wn7MFJuS0nRuPQbof132Pw4u53dm264O8LPc2MVsc7RJNml5szurkg==",
                   "dev": true
                 },
                 "wrappy": {
                   "version": "1.0.2",
                   "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
                   "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
                   "dev": true
                 },
                 "xtend": {
                   "version": "2.1.2",
                   "resolved": "https://registry.npmjs.org/xtend/-/xtend-2.1.2.tgz",
                   "integrity": "sha1-bv7MKk2tjmlixJAbM3znuoe10os=",
                   "dev": true,
                   "requires": {
                     "object-keys": "~0.4.0"
                   }
                 }
               }
             }

src/amd/ts/text/TemplateCompiler.ts +33 -2

             import * as format from "./format";
             import { TraceSource, DebugLevel } from "../log/TraceSource";
             import { ITemplateParser, TokenType } from "./TemplateParser";
             import m = require("module");
             const trace = TraceSource.get(m.id);
             type TemplateFn = (obj: object) => string;
+            const htmlEscapes = {
+                "&": "&amp;",
+                "<": "&lt;",
+                ">": "&gt;",
+                '"': "&quot;",
+                "'": "&#x27;",
+                "/": "&#x2F;"
+            };
+            // Regex containing the keys listed immediately above.
+            const htmlEscaper = /[&<>"'\/]/g;
+            // Escape a string for HTML interpolation.
+            function escapeHtml(string: any) {
+                return ("" + string).replace(htmlEscaper, match => htmlEscapes[match]);
+            }
             export class TemplateCompiler {
                 _data: string[];
                 _code: string[];
                 _wrapWith = true;
                 constructor() {
                     this._code = [];
                     this._data = [];
                 }
                 compile(parser: ITemplateParser): TemplateFn {
                     this.preamble();
                     this.visitTemplate(parser);
                     this.postamble();
                     const text = this._code.join("\n");
                     try {
                         // tslint:disable-next-line:function-constructor
-                        const compiled = new Function("obj, format, $data", text);
+                        const compiled = new Function("obj, format, $data, escapeHtml", text);
                         /**
                          * Функция форматирования по шаблону
                          *
                          * @type{Function}
                          * @param{Object} obj объект с параметрами для подстановки
                          */
-                        return (obj: object) => compiled(obj || {}, format, this._data);
+                        return (obj: object) => compiled(obj || {}, format, this._data, escapeHtml);
                     } catch (e) {
                         trace.traceEvent(DebugLevel, [e, text, this._data]);
                         throw e;
                     }
                 }
                 preamble() {
                     this._code.push(
                         "var $p = [];",
                         "var print = function(){",
                         "   $p.push(format.apply(null,arguments));",
                         "};"
                     );
                     if (this._wrapWith)
                         this._code.push("with(obj){");
                 }
                 postamble() {
                     if (this._wrapWith)
                         this._code.push("}");
                     this._code.push("return $p.join('');");
                 }
                 visitTemplate(parser: ITemplateParser) {
                     while (parser.next()) {
                         switch (parser.token()) {
                             case TokenType.OpenBlock:
                                 this.visitCode(parser);
                                 break;
                             case TokenType.OpenInlineBlock:
                                 this.visitInline(parser);
                                 break;
+                            case TokenType.OpenFilterBlock:
+                                this.visitFilter(parser);
+                                break;
                             default:
                                 this.visitTextFragment(parser);
                                 break;
                         }
                     }
                 }
                 visitInline(parser: ITemplateParser) {
                     const code = ["$p.push("];
                     while (parser.next()) {
                         if (parser.token() === TokenType.CloseBlock)
                             break;
                         code.push(parser.value());
                     }
                     code.push(");");
                     this._code.push(code.join(""));
                 }
+                visitFilter(parser: ITemplateParser) {
+                    const code = ["$p.push(escapeHtml("];
+                    while (parser.next()) {
+                        if (parser.token() === TokenType.CloseBlock)
+                            break;
+                        code.push(parser.value());
+                    }
+                    code.push("));");
+                    this._code.push(code.join(""));
+                }
                 visitCode(parser: ITemplateParser) {
                     const code = [];
                     while (parser.next()) {
                         if (parser.token() === TokenType.CloseBlock)
                             break;
                         code.push(parser.value());
                     }
                     this._code.push(code.join(""));
                 }
                 visitTextFragment(parser: ITemplateParser) {
                     const i = this._data.push(parser.value()) - 1;
                     this._code.push("$p.push($data[" + i + "]);");
                 }
             }

src/amd/ts/text/TemplateParser.ts +4 -1

             import { argumentNotEmptyString } from "../safe";
             import { MapOf } from "../interfaces";
             import { TraceSource, DebugLevel } from "../log/TraceSource";
             import m = require("module");
             const trace = TraceSource.get(m.id);
-            const splitRx = /(<%=|\[%=|<%|\[%|%\]|%>)/;
+            const splitRx = /(<%=|<%~|\[%~|\[%=|<%|\[%|%\]|%>)/;
             export enum TokenType {
                 None,
                 Text,
                 OpenInlineBlock,
+                OpenFilterBlock,
                 OpenBlock,
                 CloseBlock
             }
             const tokenMap: MapOf<TokenType> = {
                 "<%": TokenType.OpenBlock,
                 "[%": TokenType.OpenBlock,
                 "<%=": TokenType.OpenInlineBlock,
                 "[%=": TokenType.OpenInlineBlock,
+                "<%~": TokenType.OpenFilterBlock,
+                "[%~": TokenType.OpenFilterBlock,
                 "%>": TokenType.CloseBlock,
                 "%]": TokenType.CloseBlock
             };
             export interface ITemplateParser {
                 next(): boolean;
                 token(): TokenType;
                 value(): string;
             }
             export class TemplateParser implements ITemplateParser {
                 _tokens: string[];
                 _pos = -1;
                 _type: TokenType;
                 _value: string;
                 constructor(text: string) {
                     argumentNotEmptyString(text, "text");
                     this._tokens = text.split(splitRx);
                     this._type = TokenType.None;
                 }
                 next() {
                     this._pos++;
                     if (this._pos < this._tokens.length) {
                         this._value = this._tokens[this._pos];
                         this._type = tokenMap[this._value] || TokenType.Text;
                         return true;
                     } else {
                         this._type = TokenType.None;
                         this._value = undefined;
                         return false;
                     }
                 }
                 token() {
                     return this._type;
                 }
                 value() {
                     return this._value;
                 }
             }

src/main/ts/interfaces.ts +5 -5

             export interface Constructor<T = {}> {
                 new(...args: any[]): T;
                 prototype: T;
             }
             export type Factory<T = {}> = (...args: any[]) => T;
             export type Predicate<T = any> = (x: T) => boolean;
             export interface MapOf<T> {
                 [key: string]: T;
             }
             export interface IDestroyable {
                 destroy(): void;
             }
             export interface IRemovable {
                 remove(): void;
             }
             export interface ICancellation {
                 throwIfRequested(): void;
                 isRequested(): boolean;
                 isSupported(): boolean;
                 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);
                 /**
                  * 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>;
                 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(obj: any): void;
-                Write(format: string, ...args: any[]): void;
+                write(format: string, ...args: any[]): void;
-                WriteLine(obj: any): void;
+                writeLine(obj?: any): void;
-                WriteLine(format: string, ...args: any[]): void;
+                writeLine(format: string, ...args: any[]): void;
-                WriteValue(value: any, spec?: string): void;
+                writeValue(value: any, spec?: string): void;
             }

src/main/ts/log/TraceSource.ts +23 -16

             import { Observable } from "../Observable";
             import { Registry } from "./Registry";
-            import { format as _format } from "../text/StringFormat";
+            import { TraceEventData } from "./TraceEventData";
             export const DebugLevel = 400;
             export const LogLevel = 300;
             export const WarnLevel = 200;
             export const ErrorLevel = 100;
             export const SilentLevel = 0;
             export interface TraceEvent {
                 readonly source: TraceSource;
                 readonly level: number;
-                readonly arg: any;
+                readonly message: any;
-            function format(msg) {
+                readonly args?: any[];
-                if (typeof(msg) !== "string" || arguments.length === 1)
-                    return msg;
-                return _format.apply(null, arguments);
             }
             export class TraceSource {
                 readonly id: any;
                 level: number;
                 readonly events: Observable<TraceEvent>;
                 _notifyNext: (arg: TraceEvent) => void;
                 constructor(id: any) {
                     this.id = id || new Object();
                     this.events = new Observable(next => {
                         this._notifyNext = next;
                     });
                 }
-                protected emit(level: number, arg: any) {
+                protected emit(level: number, message: any, args?: any[]) {
-                    this._notifyNext({ source: this, level, arg });
+                    this._notifyNext(new TraceEventData(this, level, message, args));
                 }
                 isDebugEnabled() {
                     return this.level >= DebugLevel;
                 }
+                debug(data: any): void;
+                debug(msg: string, ...args: any[]): void;
                 debug(msg: string, ...args: any[]) {
                     if (this.isEnabled(DebugLevel))
-                        this.emit(DebugLevel, format.apply(null, arguments));
+                        this.emit(DebugLevel, msg, args);
                 }
                 isLogEnabled() {
                     return this.level >= LogLevel;
                 }
+                log(data: any): void;
+                log(msg: string, ...args: any[]): void;
                 log(msg: string, ...args: any[]) {
                     if (this.isEnabled(LogLevel))
-                        this.emit(LogLevel, format.apply(null, arguments));
+                        this.emit(LogLevel, msg, args);
                 }
                 isWarnEnabled() {
                     return this.level >= WarnLevel;
                 }
+                warn(data: any): void;
+                warn(msg: string, ...args: any[]): void;
                 warn(msg: string, ...args: any[]) {
                     if (this.isEnabled(WarnLevel))
-                        this.emit(WarnLevel, format.apply(null, arguments));
+                        this.emit(WarnLevel, msg, args);
                 }
                 /**
                  * returns true if errors will be recorded.
                  */
                 isErrorEnabled() {
                     return this.level >= ErrorLevel;
                 }
+                /** Traces a error
+                 * @param data The object which will be passed to the underlying listeners
+                 */
+                error(data: any): void;
                 /**
                  * Traces a error.
                  *
                  * @param msg the message.
                  * @param args parameters which will be substituted in the message.
                  */
+                error(msg: string, ...args: any[]): void;
                 error(msg: string, ...args: any[]) {
                     if (this.isEnabled(ErrorLevel))
-                        this.emit(ErrorLevel, format.apply(null, arguments));
+                        this.emit(ErrorLevel, msg, args);
                 }
                 /**
                  * Checks whether the specified level is enabled for this
                  * trace source.
                  *
                  * @param level the trace level which should be checked.
                  */
                 isEnabled(level: number) {
                     return (this.level >= level);
                 }
                 /**
                  * Traces a raw event, passing data as it is to the underlying listeners
                  *
                  * @param level the level of the event
-                 * @param arg the data of the event, can be a simple string or any object.
+                 * @param msg the data of the event, can be a simple string or any object.
                  */
-                traceEvent(level: number, arg: any) {
+                traceEvent(level: number, msg: any, ...args: any[]) {
                     if (this.isEnabled(level))
-                        this.emit(level, arg);
+                        this.emit(level, msg, args);
                 }
                 /**
                  * Register the specified handler to be called for every new and already
                  * created trace source.
                  *
                  * @param handler the handler which will be called for each trace source
                  */
                 static on(handler: (source: TraceSource) => void) {
                     return Registry.instance.on(handler);
                 }
                 /**
                  * Creates or returns already created trace source for the specified id.
                  *
                  * @param id the id for the trace source
                  */
                 static get(id: any) {
                     return Registry.instance.get(id);
                 }
             }

src/main/ts/log/writers/ConsoleWriter.ts +1 -49

@@ -1,49 +1,1
1	import { IObservable, IDestroyable, ICancellation } from "../../interfaces";	1	export { ConsoleLogger as ConsoleWriter } from "./ConsoleLogger"; No newline at end of file
2	import { TraceEvent, LogLevel, WarnLevel, DebugLevel } from "../TraceSource";
3	import { Cancellation } from "../../Cancellation";
4	import { destroy } from "../../safe";
5
6	function hasConsole() {
7	try {
8	// tslint:disable-next-line:no-console
9	return (typeof console !== "undefined" && typeof console.log === "function");
10	} catch {
11	return false;
12	}
13	}
14
15	export class ConsoleWriter implements IDestroyable {
16	readonly _subscriptions = new Array<IDestroyable>();
17
18	writeEvents(source: IObservable<TraceEvent>, ct: ICancellation = Cancellation.none) {
19	const subscription = source.on(this.writeEvent.bind(this));
20	if (ct.isSupported()) {
21	ct.register(subscription.destroy.bind(subscription));
22	}
23	this._subscriptions.push(subscription);
24	}
25
26	writeEvent(next: TraceEvent) {
27	// IE will create console only when devepoler tools are activated
28	if (!hasConsole())
29	return;
30
31	if (next.level >= DebugLevel) {
32	// tslint:disable-next-line:no-console
33	console.debug(next.source.id.toString(), next.arg);
34	} else if (next.level >= LogLevel) {
35	// tslint:disable-next-line:no-console
36	console.log(next.source.id.toString(), next.arg);
37	} else if (next.level >= WarnLevel) {
38	// tslint:disable-next-line:no-console
39	console.warn(next.source.id.toString(), next.arg);
40	} else {
41	// tslint:disable-next-line:no-console
42	console.error(next.source.id.toString(), next.arg);
43	}
44	}
45
46	destroy() {
47	this._subscriptions.forEach(destroy);
48	}
49	}

src/main/ts/text/FormatCompiler.ts +45 -20

             import { FormatScanner, TokeType } from "./FormatScanner";
-            import { isNullOrEmptyString } from "../safe";
+            import { isNullOrEmptyString, isPrimitive, get } from "../safe";
-            import { TextWriter } from "../interfaces";
+            import { TextWriter, MapOf } from "../interfaces";
+            type CompiledPattern = (writer: TextWriter, args: any) => void;
             export class FormatCompiler {
                 _scanner: FormatScanner;
+                _cache: MapOf<CompiledPattern> = {};
-                _parts: [];
+                _parts: Array<string | { name: string; format: string; }>;
+                compile(pattern: string) {
+                    let compiledPattern = this._cache && this._cache[pattern];
+                    if (!compiledPattern) {
+                        this._scanner = new FormatScanner(pattern);
+                        this._parts = [];
+                        this.visitText();
+                        const parts = this._parts;
-                compile() {
+                        compiledPattern = (writer: TextWriter, args: any) => {
-                    return (writer: TextWriter, args: any) => {
+                            parts.forEach(x => {
-                        this._parts.forEach(x => writer.WriteValue(x))
+                                if (isPrimitive(x))
-                    };
+                                    writer.writeValue(x);
+                                else
+                                    writer.writeValue(get(x.name, args), x.format);
+                            });
+                        };
+                        if (this._cache)
+                            this._cache[pattern] = compiledPattern;
+                    }
+                    return compiledPattern;
                 }
                 visitText() {
                     while (this._scanner.next()) {
+                        // console.log(this._scanner.getTokenType(), this._scanner.getTokenValue());
                         switch (this._scanner.getTokenType()) {
                             case TokeType.CurlOpen:
                                 this.visitCurlOpen();
                                 break;
                             case TokeType.CurlClose:
                                 this.visitCurlClose();
                                 break;
                             default:
                                 this.pushText(this._scanner.getTokenValue());
                         }
-                        if (this._scanner.getTokenType() === TokeType.CurlOpen)
-                            this.visitCurlOpen();
                     }
                 }
                 visitCurlClose() {
                     if (!this._scanner.next())
                         this.dieUnexpectedEnd("}");
                     if (this._scanner.getTokenType() !== TokeType.CurlClose)
                         this.dieUnexpectedToken("}");
                     this.pushText("}");
                 }
                 visitCurlOpen() {
-                    if (this._scanner.next()) {
+                    if (!this._scanner.next())
-                        if (this._scanner.getTokenType() === TokeType.CurlOpen)
+                        this.dieUnexpectedEnd("{ | TEXT");
-                            this.pushText("{");
-                        else
+                    if (this._scanner.getTokenType() === TokeType.CurlOpen)
-                            this.visitTemplateSubst();
+                        this.pushText("{");
+                    else
+                        this.visitTemplateSubst();
                 }
                 visitTemplateSubst() {
                     if (this._scanner.getTokenType() !== TokeType.Text)
                         this.dieUnexpectedToken("TEXT");
                     const fieldName = this._scanner.getTokenValue();
-                    const filedFormat = this.readColon() && this.readFieldFormat();
+                    const filedFormat = this.readColon() ? this.readFieldFormat() : null;
+                    if (this._scanner.getTokenType() !== TokeType.CurlClose)
+                        this.dieUnexpectedToken("}");
                     this.pushSubst(fieldName, filedFormat);
                 }
                 readFieldFormat() {
                     const parts = new Array<string>();
-                    while (this._scanner.next()) {
+                    do {
                         if (this._scanner.getTokenType() === TokeType.CurlClose) {
                             return parts.join("");
                         } else {
                             parts.push(this._scanner.getTokenValue());
                         }
+                    } while (this._scanner.next());
                     this.dieUnexpectedEnd("}");
                 }
                 readColon() {
                     if (!this._scanner.next())
                         this.dieUnexpectedEnd();
                     if (this._scanner.getTokenType() !== TokeType.Colon)
                         return false;
                     if (!this._scanner.next())
                         this.dieUnexpectedEnd();
                     return true;
                 }
                 pushSubst(fieldName: string, filedFormat: string) {
+                    // console.log("pushSubst ", fieldName, filedFormat);
+                    this._parts.push({ name: fieldName, format: filedFormat });
                 }
                 pushText(text: string) {
+                    this._parts.push(text);
                 }
                 dieUnexpectedToken(expected?: string) {
                     throw new Error(isNullOrEmptyString(expected) ?
                         `Unexpected token ${this._scanner.getTokenValue()}` :
                         `Unexpected token ${this._scanner.getTokenValue()}, expected ${expected}`
                     );
                 }
                 dieUnexpectedEnd(expected?: string) {
                     throw new Error(isNullOrEmptyString(expected) ? "Unexpected end of the string" : `Unexpected end of the string, expected ${expected}`);
                 }
             }

src/main/ts/text/FormatScanner.ts +4 -6

             import { argumentNotEmptyString } from "../safe";
             import { MapOf } from "../interfaces";
             export const enum TokeType {
-                CurlOpen,
+                CurlOpen = 1,
-                CurlClose,
+                CurlClose = 2,
-                Colon,
+                Colon = 3,
-                Text
+                Text = 4
             }
             const typeMap = {
                 "{": TokeType.CurlOpen,
                 "}": TokeType.CurlClose,
                 ":": TokeType.Colon
             } as MapOf<TokeType>;
             export class FormatScanner {
                 private _text: string;
-                private _pos: number;
                 private _tokenType: TokeType;
                 private _tokenValue: string;
                 private _rx = /[^{}:]+|(.)/g;
                 constructor(text: string) {
                     argumentNotEmptyString(text, text);
                     this._text = text;
                 }
                 next() {
                     if (this._rx.lastIndex >= this._text.length)
                         return false;
-                    this._pos = this._rx.lastIndex;
                     const match = this._rx.exec(this._text);
                     this._tokenType = typeMap[match[1]] || TokeType.Text;
                     this._tokenValue = match[0];
                     return true;
                 }
                 getTokenValue() {
                     return this._tokenValue;
                 }
                 getTokenType() {
                     return this._tokenType;
                 }
             }

src/main/ts/text/StringBuilder.ts +23 -10

@@ -1,18 +1,31
1	export class StringBuilder {	1	import { TextWriterBase } from "./TextWriterBase";
2	private _data: string[];	2	import { Converter } from "./Converter";
3	private _newLine = "\n";	3
		4	export class StringBuilder extends TextWriterBase {
		5	private _data = new Array<string>();
4		6
5	Write(obj: any);	7	constructor(converter = Converter.default) {
6	Write(format: string, ...args: any[]) {	8	super(converter);
		9	}
7		10
		11	writeText(text: string) {
		12	this._data.push(text);
8	}	13	}
9		14
10	WriteLine(obj: any);	15	toString() {
11	WriteLine(format: string, ...args: any[]) {	16	return this._data.join("");
12
13	}	17	}
14		18
15	WriteValue(value: any, spec?: string) {	19	clear() {
16		20	this._data.length = 0;
17	}	21	}
18	}	22	}
		23
		24	const sb = new StringBuilder();
		25
		26	export function format(format: string, ...args: any): string;
		27	export function format() {
		28	sb.clear();
		29	sb.write.apply(sb, arguments);
		30	return sb.toString();
		31	}

src/test/ts/ActivatableTests.ts +4 -10

-            import * as tape from "tape";
             import { MockActivationController } from "./mock/MockActivationController";
             import { SimpleActivatable } from "./mock/SimpleActivatable";
+            import { test } from "./TestTraits";
-            tape("simple activation", async t => {
+            test("simple activation", async t => {
                 const 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 t => {
+            test("controller activation", async t => {
                 const a = new SimpleActivatable();
                 const 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.equal(c.getActive(), a, "The controller should point to the activated component");
                 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.equal(c.getActive(), null, "The controller shouldn't point to any component");
                 t.equal(a.getActivationController(), c, "The componet should point to it's controller");
-                t.end();
             });
-            tape("handle error in onActivating", async t => {
+            test("handle error in onActivating", async t => {
                 const a = new SimpleActivatable();
                 a.onActivating = async () => {
                     throw new Error("Should fail");
                 };
                 try {
                     await a.activate();
                     t.fail("activation should fail");
                 } catch {
                 }
                 t.false(a.isActive(), "the component should remain inactive");
-                t.end();
             });

src/test/ts/CancellationTests.ts +5 -13

-            import * as tape from "tape";
             import { Cancellation } from "@implab/core/Cancellation";
             import { delay } from "@implab/core/safe";
+            import { test } from "./TestTraits";
-            tape("standalone cancellation", async t => {
+            test("standalone cancellation", async t => {
                 let doCancel: (e) => void;
                 const ct = new Cancellation(cancel => {
                     doCancel = cancel;
                 });
                 let counter = 0;
                 const reason = "BILL";
                 t.true(ct.isSupported(), "Cancellation must be supported");
                 t.false(ct.isRequested(), "Cancellation shouldn't be requested");
                 ct.throwIfRequested();
                 t.pass("The exception shouldn't be thrown unless the cancellation is requested");
                 ct.register(() => counter++);
                 t.equals(counter, 0, "counter should be zero");
                 ct.register(() => counter++).destroy();
                 doCancel(reason);
                 t.true(ct.isRequested(), "Cancellation should be requested");
                 t.equals(counter, 1, "The registered callback should be triggered");
                 ct.register(() => counter++);
                 t.equals(counter, 2, "The callback should be triggered immediately");
                 let msg;
                 ct.register(e => msg = e);
                 t.equals(msg, reason, "The cancellation reason should be passed to callback");
                 try {
                     msg = null;
                     ct.throwIfRequested();
                     t.fail("The exception should be thrown");
                 } catch (e) {
                     msg = e;
                 }
                 t.equals(msg, reason, "The cancellation reason should be catched");
-                t.end();
             });
-            tape("async cancellation", async t => {
+            test("async cancellation", async t => {
                 const ct = new Cancellation(cancel => {
                     cancel("STOP!");
                 });
                 try {
                     await delay(0, ct);
                     t.fail("Should thow the exception");
                 } catch (e) {
                     t.equals(e, "STOP!", "Should throw the cancellation reason");
                 }
-                t.end();
             });
-            tape("cancel with external event", async t => {
+            test("cancel with external event", async t => {
                 const ct = new Cancellation(cancel => {
                     setTimeout(x => cancel("STOP!"), 0);
                 });
                 try {
                     await delay(10000, ct);
                     t.fail("Should thow the exception");
                 } catch (e) {
                     t.equals(e, "STOP!", "Should throw the cancellation reason");
                 }
-                t.end();
             });
-            tape("operation normal flow", async t => {
+            test("operation normal flow", async t => {
                 let htimeout;
                 const ct = new Cancellation(cancel => {
                     htimeout = setTimeout(() => cancel("STOP!"), 1000);
                 });
                 try {
                     await delay(0, ct);
                     t.pass("Should pass");
                 } finally {
                     clearTimeout(htimeout);
                 }
-                t.end();
             });

src/test/ts/ObservableTests.ts +3 -7

             import { TraceSource, DebugLevel } from "@implab/core/log/TraceSource";
-            import * as tape from "tape";
             import { Observable } from "@implab/core/Observable";
             import { IObservable } from "@implab/core/interfaces";
             import { delay } from "@implab/core/safe";
+            import { test } from "./TestTraits";
             const trace = TraceSource.get("ObservableTests");
-            tape("events sequence example", async t => {
+            test("events sequence example", async t => {
                 let events: IObservable<number>;
                 const done = new Promise<void>(resolve => {
                     events = new Observable<number>(async (notify, fail, finish) => {
                         for (let i = 0; i < 10; i++) {
                             await delay(0);
                             notify(i);
                         }
                         finish();
                         resolve();
                     });
                 });
                 let count = 0;
                 let complete = false;
                 events.on(x => count = count + x, null, () => complete = true);
                 const first = await events.next();
                 t.equals(first, 0, "the first event");
                 t.false(complete, "the sequence is not complete");
                 await done;
                 t.equals(count, 45, "the summ of the evetns");
                 t.true(complete, "the sequence is complete");
-                t.end();
             });
-            tape("event sequence termination", async t => {
+            test("event sequence termination", async t => {
                 let events: IObservable<number>;
                 const done = new Promise<void>(resolve => {
                     events = new Observable<number>(async (notify, fail, complete) => {
                         await delay(0);
                         notify(1);
                         complete();
                         notify(2);
                         complete();
                         fail("Sequence terminated");
                         resolve();
                     });
                 });
                 let count = 0;
                 events.on(() => {}, e => count++, () => count++);
                 const first = await events.next();
                 t.equals(first, 1, "the first message");
                 try {
                     await events.next();
                     t.fail("shoud throw an exception");
                 } catch (e) {
                     t.pass("the sequence is terminated");
                 }
                 await done;
                 t.equals(count, 1, "the sequence must be terminated once");
-                t.end();
             });

src/test/ts/SafeTests.ts +3 -7

-            import tape = require("tape");
             import { Cancellation } from "@implab/core/Cancellation";
             import { first, isPromise, firstWhere, delay, nowait } from "@implab/core/safe";
+            import { test } from "./TestTraits";
-            tape("await delay test", async t => {
+            test("await delay test", async t => {
                 // schedule delay
                 let resolved = false;
                 let res = delay(0).then(() => resolved = true);
                 t.false(resolved, "the delay should be async");
                 await res;
                 t.pass("await delay");
                 // create cancellation token
                 let cancel: (e?: any) => void;
                 const ct = new Cancellation(c => cancel = c);
                 // schedule delay
                 resolved = false;
                 res = delay(0, ct).then(() => resolved = true);
                 t.false(resolved, "created delay with ct");
                 // cancel
                 cancel();
                 try {
                     await res;
                     t.fail("the delay should fail when it is cancelled");
                 } catch {
                     t.pass("the delay is cancelled");
                 }
                 t.throws(() => {
                     // try schedule delay after the cancellation is requested
                     nowait(delay(0, ct));
                 }, "Should throw if cancelled before start");
-                t.end();
             });
-            tape("sequemce test", async t => {
+            test("sequemce test", async t => {
                 const sequence = ["a", "b", "c"];
                 const empty = [];
                 // synchronous tests
                 t.equals(first(sequence), "a", "Should return the first element");
                 t.equals(firstWhere(sequence, x => x === "b"), "b", "Should get the second element");
                 let v: string;
                 let e: Error;
                 first(sequence, x => v = x);
                 t.equal(v, "a", "The callback should be called for the first element");
                 firstWhere(sequence, x => x === "b", x => v = x);
                 t.equal(v, "b", "The callback should be called for the second element");
                 t.throws(() => {
                     first(empty);
                 }, "Should throw when the sequence is empty");
                 t.throws(() => {
                     firstWhere(empty, x => x === "b");
                 }, "Should throw when the sequence is empty");
                 t.throws(() => {
                     first(empty, x => v = x);
                 }, "Should throw when the sequence is empty");
                 t.throws(() => {
                     firstWhere(empty, x => x === "b", x => v = x);
                 }, "Should throw when the sequence is empty");
                 t.throws(() => {
                     firstWhere(sequence, x => x === "z");
                 }, "Should throw when the element isn't found");
                 t.throws(() => {
                     firstWhere(sequence, x => x === "z", x => v = x);
                 }, "Should throw when the element isn't found");
                 first(empty, null, x => e = x);
                 t.true(e, "The errorback should be called for the empty sequence");
                 // async tests
                 const asyncSequence = Promise.resolve(sequence);
                 const asyncEmptySequence = Promise.resolve(empty);
                 const promise = first(asyncSequence);
                 t.true(isPromise(promise), "Should return promise");
                 v = await promise;
                 t.equal(v, "a", "Should return the first element");
                 v = await new Promise(resolve => first(asyncSequence, resolve));
                 t.equal(v, "a", "The callback should be called for the first element");
-                t.end();
             });

src/test/ts/TestTraits.ts +22 -13

             import { IObservable, ICancellation, IDestroyable } from "@implab/core/interfaces";
             import { Cancellation } from "@implab/core/Cancellation";
             import { TraceEvent, LogLevel, WarnLevel, DebugLevel, TraceSource } from "@implab/core/log/TraceSource";
             import * as tape from "tape";
             import { argumentNotNull, destroy } from "@implab/core/safe";
             export class TapeWriter implements IDestroyable {
-                readonly _tape: tape.Test;
+                private readonly _tape: tape.Test;
-                _subscriptions = new Array<IDestroyable>();
+                private readonly _subscriptions = new Array<IDestroyable>();
+                private _destroyed;
                 constructor(t: tape.Test) {
                     argumentNotNull(t, "tape");
                     this._tape = t;
                 }
                 writeEvents(source: IObservable<TraceEvent>, ct: ICancellation = Cancellation.none) {
-                    const subscription = source.on(this.writeEvent.bind(this));
+                    if (!this._destroyed) {
-                    if (ct.isSupported()) {
+                        const subscription = source.on(this.writeEvent.bind(this));
-                        ct.register(subscription.destroy.bind(subscription));
+                        if (ct.isSupported()) {
+                            ct.register(subscription.destroy.bind(subscription));
+                        }
+                        this._subscriptions.push(subscription);
                     }
-                    this._subscriptions.push(subscription);
                 }
                 writeEvent(next: TraceEvent) {
                     if (next.level >= DebugLevel) {
-                        this._tape.comment(`DEBUG ${next.source.id} ${next.arg}`);
+                        this._tape.comment(`DEBUG ${next.source.id} ${next}`);
                     } else if (next.level >= LogLevel) {
-                        this._tape.comment(`LOG   ${next.source.id} ${next.arg}`);
+                        this._tape.comment(`LOG   ${next.source.id} ${next}`);
                     } else if (next.level >= WarnLevel) {
-                        this._tape.comment(`WARN  ${next.source.id} ${next.arg}`);
+                        this._tape.comment(`WARN  ${next.source.id} ${next}`);
                     } else {
-                        this._tape.comment(`ERROR ${next.source.id} ${next.arg}`);
+                        this._tape.comment(`ERROR ${next.source.id} ${next}`);
                     }
                 }
                 destroy() {
                     this._subscriptions.forEach(destroy);
                 }
             }
-            export function test(name: string, cb: (t: tape.Test) => any) {
+            export function test(name: string, cb: (t: tape.Test, trace: TraceSource) => any) {
                 tape(name, async t => {
                     const writer = new TapeWriter(t);
-                    TraceSource.on(ts => {
+                    // this trace is not announced through the TraceSource global registry
+                    const trace = new TraceSource(name);
+                    trace.level = DebugLevel;
+                    writer.writeEvents(trace.events);
+                    const h = TraceSource.on(ts => {
                         ts.level = DebugLevel;
                         writer.writeEvents(ts.events);
                     });
                     try {
-                        await cb(t);
+                        await cb(t, trace);
                     } catch (e) {
                         // verbose error information
                         // tslint:disable-next-line
                         console.error(e);
                         t.fail(e);
                     } finally {
                         t.end();
                         destroy(writer);
+                        destroy(h);
                     }
                 });
             }

src/test/ts/TraceSourceTests.ts +20 -3

             import { TraceSource, DebugLevel } from "@implab/core/log/TraceSource";
             import * as tape from "tape";
-            import { TapeWriter } from "./TestTraits";
+            import { TapeWriter, test } from "./TestTraits";
+            import { MockConsole } from "./mock/MockConsole";
+            import { ConsoleLog } from "@implab/core/log/writers/ConsoleLog";
+            import { ConsoleWriter } from "@implab/core/log/ConsoleWriter";
             const sourceId = "test/TraceSourceTests";
             tape("trace message", t => {
                 const trace = TraceSource.get(sourceId);
                 trace.level = DebugLevel;
                 const h = trace.events.on(ev => {
                     t.equal(ev.source, trace, "sender should be the current trace source");
                     t.equal(ev.level, DebugLevel, "level should be debug level");
-                    t.equal(ev.arg, "Hello, World!", "The message should be a formatted message");
+                    t.equal(ev.toString(), "Hello, World!", "The message should be a formatted message");
                     t.end();
                 });
                 trace.debug("Hello, {0}!", "World");
                 h.destroy();
             });
             tape("trace event", t => {
                 const trace = TraceSource.get(sourceId);
                 trace.level = DebugLevel;
                 const event = {
                     name: "custom event"
                 };
                 const h = trace.events.on(ev => {
                     t.equal(ev.source, trace, "sender should be the current trace source");
                     t.equal(ev.level, DebugLevel, "level should be debug level");
-                    t.equal(ev.arg, event, "The message should be the specified object");
+                    t.equal(ev.message, event, "The message should be the specified object");
                     t.end();
                 });
                 trace.traceEvent(DebugLevel, event);
                 h.destroy();
             });
             tape("tape comment writer", async t => {
                 const writer = new TapeWriter(t);
                 TraceSource.on(ts => {
                     writer.writeEvents(ts.events);
                 });
                 const trace = TraceSource.get(sourceId);
                 trace.level = DebugLevel;
                 trace.log("Hello, {0}!", "World");
                 trace.log("Multi\n  line");
                 trace.warn("Look at me!");
                 trace.error("DIE!");
                 writer.destroy();
                 trace.log("You shouldn't see it!");
                 t.comment("DONE");
                 t.end();
             });
+            test("console writer", (t, trace) => {
+                const mockConsole = new MockConsole();
+                const writer = new ConsoleWriter(mockConsole);
+                const consoleLog = new ConsoleLog(writer);
+                consoleLog.writeEvents(trace.events);
+                trace.log("Hello, world!");
+                t.deepEqual(mockConsole.getLine(0), ["console writer: Hello, world!"], "Log one string");
+                trace.log({ foo: "bar" });
+                t.deepEqual(mockConsole.getLine(1), ["console writer: ", { foo: "bar" }], "Log an object");
+            });

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

             define([
                 "./ActivatableTests",
                 "./trace-test",
                 "./TraceSourceTests",
                 "./CancellationTests",
                 "./ObservableTests",
                 "./ContainerTests",
-                "./SafeTests"
+                "./SafeTests",
+                "./TextTests"
             ]);

src/testCjs/ts/plan.ts +2 0

             import "./ActivatableTests";
             import "./TraceSourceTests";
             import "./CancellationTests";
             import "./ObservableTests";
             import "./ContainerTests";
+            import "./SafeTests";
+            import "./TextTests";

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