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

                         '-t', target,
                         '-m', jsmodule,
                         '-d',
+                        '--sourceMap',
+                        '--sourceRoot', "file://$setDir/ts",
                         '--outDir', compileDir,
                         '--declarationDir', declDir

gradle.properties +1 -1

             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

                 },
                 "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
                 },
                   "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": {
                 },
                 "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
                 },
                 },
                 "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": {
                 },
                 "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
                 },
                 },
                 "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": {

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

             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[];
                     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;
                             case TokenType.OpenInlineBlock:
                                 this.visitInline(parser);
                                 break;
+                            case TokenType.OpenFilterBlock:
+                                this.visitFilter(parser);
+                                break;
                             default:
                                 this.visitTextFragment(parser);
                                 break;
                     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()) {

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

             const trace = TraceSource.get(m.id);
-            const splitRx = /(<%=|\[%=|<%|\[%|%\]|%>)/;
+            const splitRx = /(<%=|<%~|\[%~|\[%=|<%|\[%|%\]|%>)/;
             export enum TokenType {
                 None,
                 Text,
                 OpenInlineBlock,
+                OpenFilterBlock,
                 OpenBlock,
                 CloseBlock
             }
                 "[%": TokenType.OpenBlock,
                 "<%=": TokenType.OpenInlineBlock,
                 "[%=": TokenType.OpenInlineBlock,
+                "<%~": TokenType.OpenFilterBlock,
+                "[%~": TokenType.OpenFilterBlock,
                 "%>": TokenType.CloseBlock,
                 "%]": TokenType.CloseBlock
             };

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

             }
             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;
                 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 {
                     });
                 }
-                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);
                 }
                 /**
                     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);
                 }
                 /**
                  * 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);
                 }
                 /**

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();
                             default:
                                 this.pushText(this._scanner.getTokenValue());
                         }
-                        if (this._scanner.getTokenType() === TokeType.CurlOpen)
-                            this.visitCurlOpen();
                     }
                 }
                 }
                 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() {
                         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("}");
                 }
                 }
                 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) {

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

             import { MapOf } from "../interfaces";
             export const enum TokeType {
-                CurlOpen,
+                CurlOpen = 1,
-                CurlClose,
+                CurlClose = 2,
-                Colon,
+                Colon = 3,
-                Text
+                Text = 4
             }
             const typeMap = {
             export class FormatScanner {
                 private _text: string;
-                private _pos: number;
                 private _tokenType: TokeType;
                 private _tokenValue: string;
                 private _rx = /[^{}:]+|(.)/g;
                 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;

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.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 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 () => {
                 }
                 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;
                     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!");
                 } 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);
                 });
                 } 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 => {
                 } 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>;
                 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 => {
                 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);
                     // 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 = [];
                 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 { 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");
                 }
                 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}`);
                     }
                 }
                 }
             }
-            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
                     } 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";
                 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();
                 });
                 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();
                 });
                 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

                 "./CancellationTests",
                 "./ObservableTests",
                 "./ContainerTests",
-                "./SafeTests"
+                "./SafeTests",
+                "./TextTests"
             ]);

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

             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