sketch: initial design

Author: chase-moskal

s/example.test.ts

@@ -1,14 +1,52 @@
 
-import {Science, test, expect} from "@e280/science"
 import {Logger} from "./logger.js"
+import {MockTarget} from "./targets/mock.js"
+import {Science, test, expect} from "@e280/science"
 
 await Science.run({
-	"addition works": test(async() => {
-		expect(2 + 2).is(4)
-  	// const logger = new Logger()
-  	//  	.target(Logger.node)
-  	//  	.palette(Logger.colorful)
-  	//  	.transform(Logger.timestamp)
+	"basics": Science.suite({
+		"create a logger": test(async() => {
+			void new Logger()
+		}),
+		"logger with mock": test(async() => {
+			const mock = new MockTarget()
+			void new Logger().setTarget(mock)
+		}),
+		"logger stdout": test(async() => {
+			const mock = new MockTarget()
+			const logger = new Logger().setTarget(mock)
+			expect(mock.stdout.spy.calls.length).is(0)
+			logger.log("hello world!")
+			expect(mock.stdout.spy.calls.length).is(1)
+			expect(mock.getSpyStdout(0)).is("hello world!")
+			expect(mock.stderr.spy.calls.length).is(0)
+		}),
+		"logger stderr": test(async() => {
+			const mock = new MockTarget()
+			const logger = new Logger().setTarget(mock)
+			expect(mock.stderr.spy.calls.length).is(0)
+			logger.error("hello world!")
+			expect(mock.stderr.spy.calls.length).is(1)
+			expect(mock.getSpyStderr(0)).is("hello world!")
+			expect(mock.stdout.spy.calls.length).is(0)
+		}),
+	}),
+
+	"transforms": Science.suite({
+		"custom prefix": test(async() => {
+			const mock = new MockTarget()
+			const logger = new Logger()
+				.setTarget(mock)
+				.setPalette(Logger.palettes.plain())
+				.addTransform(() => ({
+					stdout: items => ["stdout:", ...items],
+					stderr: items => ["stderr:", ...items],
+				}))
+			logger.log("hello world!")
+			console.log(mock.getSpyStdout(0))
+			expect(mock.stdout.spy.calls.length).is(1)
+			expect(mock.getSpyStdout(0)).is("stdout: hello world!")
+		}),
 	}),
 })
 

s/logger.ts

@@ -1,3 +1,55 @@
 
-export class Logger {}
+import {Target} from "./targets/target.js"
+import {nodeTarget} from "./targets/node.js"
+import {Palette} from "./palettes/palette.js"
+import {plainPalette} from "./palettes/plain.js"
+import {consoleTarget} from "./targets/console.js"
+import {Transformer} from "./transforms/transform.js"
+import {timestampTransform} from "./transforms/timestamp.js"
+
+export class Logger {
+	static palettes = {
+		plain: plainPalette,
+	}
+
+	static targets = {
+		node: nodeTarget,
+		console: consoleTarget,
+	}
+
+	static transforms = {
+		timestamp: timestampTransform,
+	}
+
+	palette: Palette = {}
+	target = consoleTarget()
+	transformers: Transformer[] = []
+
+	log(...items: any[]) {
+		for (const transform of this.transformers)
+			items = transform(this).stdout(items)
+		this.target.stdout(items)
+	}
+
+	error(...items: any[]) {
+		for (const transform of this.transformers)
+			items = transform(this).stderr(items)
+		this.target.stderr(items)
+	}
+
+	setPalette(palette: Palette) {
+		this.palette = palette
+		return this
+	}
+
+	setTarget(target: Target) {
+		this.target = target
+		return this
+	}
+
+	addTransform(transformer: Transformer) {
+		this.transformers.push(transformer)
+		return this
+	}
+}
 

s/palettes/palette.ts

@@ -0,0 +1,3 @@
+
+export type Palette = {}
+

s/palettes/plain.ts

@@ -0,0 +1,5 @@
+
+import {Palette} from "./palette.js"
+
+export const plainPalette = (): Palette => ({})
+

s/targets/console.ts

@@ -0,0 +1,8 @@
+
+import {Target} from "./target.js"
+
+export const consoleTarget = (): Target => ({
+	stdout: (items: any[]) => console.log(...items),
+	stderr: (items: any[]) => console.error(...items),
+})
+

s/targets/mock.ts

@@ -0,0 +1,40 @@
+
+import {Target} from "./target.js"
+
+export function spy<Fn extends (...args: any[]) => any>(fn: Fn) {
+	const calls: {args: Parameters<Fn>, ret: ReturnType<Fn>}[] = []
+
+	function spyFn(...args: Parameters<Fn>) {
+		const ret = fn()
+		calls.push({args, ret})
+		return ret
+	}
+
+	spyFn.spy = {
+		calls,
+		get args() {
+			return calls.map(c => c.args)
+		},
+		get rets() {
+			return calls.map(c => c.ret)
+		},
+	}
+
+	return spyFn
+}
+
+export class MockTarget implements Target {
+	stdout = spy((_items: any[]) => {})
+	stderr = spy((_items: any[]) => {})
+
+	getSpyStdout(index: number) {
+		const [items] = this.stdout.spy.args.at(index)!
+		return items.join(" ")
+	}
+
+	getSpyStderr(index: number) {
+		const [items] = this.stderr.spy.args.at(index)!
+		return items.join(" ")
+	}
+}
+

s/targets/node.ts

@@ -0,0 +1,8 @@
+
+import {Target} from "./target.js"
+
+export const nodeTarget = (): Target => ({
+	stdout: (items: any[]) => void process.stdout.write(items.join(" ")),
+	stderr: (items: any[]) => void process.stderr.write(items.join(" ")),
+})
+

s/targets/target.ts

@@ -0,0 +1,6 @@
+
+export type Target = {
+	stdout(items: any[]): void
+	stderr(items: any[]): void
+}
+

s/transforms/timestamp.ts

@@ -0,0 +1,27 @@
+
+import {Transformer} from "./transform.js"
+
+export type TimestampOptions = {
+	now: () => number
+}
+
+function defaultTimestampOptions(): TimestampOptions {
+	return {
+		now: () => Date.now(),
+	}
+}
+
+export const timestampTransform = (options?: Partial<TimestampOptions>): Transformer => ({palette}) => {
+	const opts = {...defaultTimestampOptions(), ...options}
+	return {
+		stdout: items => [
+			`[${Math.round(opts.now())}]`,
+			...items,
+		],
+		stderr: items => [
+			`[${Math.round(opts.now())}]`,
+			...items,
+		],
+	}
+}
+

s/transforms/transform.ts

@@ -0,0 +1,14 @@
+
+import {Palette} from "../palettes/palette.js"
+
+export type TransformerContext = {
+	palette: Palette
+}
+
+export type Transformer = (context: TransformerContext) => Transform
+
+export type Transform = {
+	stdout: (items: any[]) => any[]
+	stderr: (items: any[]) => any[]
+}
+