@davidsouther/jiffies 1.0.0-beta.1

package/src/result.ts

@@ -0,0 +1,107 @@
+export type None = null;
+export type Some<T> = T;
+export type Option<T> = Some<T> | None;
+export type Err<E extends Error> = {
+  err: E;
+  map: <U>(fn: (t: unknown) => Result<U>) => Result<U>;
+};
+export type Ok<T> = { ok: T; map: <U>(fn: (t: T) => Result<U>) => Result<U> };
+export type Result<T, E extends Error = Error> = Ok<T> | Err<E>;
+
+export const isNone = <T>(s: Option<T>): s is None => s == null;
+export const isSome = <T>(s: Option<T>): s is Some<T> => s != null;
+
+export function None<T = unknown>(_?: T): Option<T> {
+  return null;
+}
+
+export function Some<T>(t: Option<T>): Option<T>;
+export function Some<T>(t: T): Option<T>;
+export function Some(t: any): any {
+  return t;
+}
+
+export const isOk = <T, E extends Error>(t: Result<T, E>): t is Ok<T> =>
+  (t as Ok<T>).ok !== undefined;
+export const isErr = <T, E extends Error>(e: Result<T, E>) =>
+  (e as Err<E>).err !== undefined;
+export const isResult = <T, E extends Error>(
+  t: Result<T, E>
+): t is Result<T, E> => isOk(t) || isErr(t);
+
+// Beware: Order matters for correct inference.
+export function Ok<T>(ok: Ok<T>): T;
+export function Ok<T>(t: T): Ok<T>;
+export function Ok<T, E extends Error>(t: any): any {
+  return t.ok
+    ? t.ok
+    : {
+        ok: t,
+        map<U>(fn: (_: typeof t) => Result<U, E>): Result<U, E> {
+          return fn(Ok(this));
+        },
+      };
+}
+
+// Beware: Order matters for correct inference.
+export function Err<E extends Error>(e: Err<E>): E;
+export function Err<E extends Error>(e: E): Err<E>;
+export function Err<E extends Error>(e: string): Err<E>;
+export function Err<T, E extends Error>(e: any): any {
+  return (
+    e.err ?? {
+      err: typeof e === "string" ? new Error(e) : e,
+      map<U>(this: Result<T, E>, fn: (t: unknown) => Result<U>): Result<U, E> {
+        return this as Result<U, E>;
+      },
+    }
+  );
+}
+
+export function unwrap<T, E extends Error>(result: Result<T, E>): T | never;
+export function unwrap<O>(some: Option<O>): O | never;
+export function unwrap(t: any): any {
+  if (isNone(t)) {
+    throw new Error(`Attempted to unwrap None`);
+  }
+  if (isErr(t)) {
+    throw Err(t);
+  }
+  if (isOk(t)) {
+    return Ok(t);
+  }
+  return t;
+}
+
+export function unwrapOr<T, E extends Error>(result: Result<T, E>, def: T): T;
+export function unwrapOr<T>(some: Some<T>, def: T): T;
+export function unwrapOr(t: any, def: any): any {
+  if (isNone(t)) {
+    return def;
+  }
+  if (isErr(t)) {
+    return def;
+  }
+  if (isOk(t)) {
+    return Ok(t);
+  }
+  return t;
+}
+
+export function unwrapOrElse<T, E extends Error>(
+  result: Result<T, Error>,
+  def: () => T
+): T;
+export function unwrapOrElse<T>(some: Some<T>, def: () => T): T;
+export function unwrapOrElse(t: any, def: any): any {
+  if (isNone(t)) {
+    return def();
+  }
+  if (isErr(t)) {
+    return def();
+  }
+  if (isOk(t)) {
+    return Ok(t);
+  }
+  return t;
+}

package/src/safe.ts

@@ -0,0 +1,12 @@
+import { error } from "./log.js";
+
+export const safe =
+  <A extends unknown[], R>(fn: (...args: A) => R, r: R): ((...args: A) => R) =>
+  (...args: A) => {
+    try {
+      return fn(...args);
+    } catch (e: unknown) {
+      error(`${e}`);
+      return r;
+    }
+  };

package/src/scope/describe.ts

@@ -0,0 +1,70 @@
+import { getLogger } from "../log.js";
+import { TestCase } from "./scope.js";
+
+export const beforeall = Symbol("beforeAll");
+export const beforeeach = Symbol("beforeEach");
+export const afterall = Symbol("afterAll");
+export const aftereach = Symbol("afterEach");
+
+const logger = getLogger("scope");
+
+const CASES: TestCase = {};
+let cases = [CASES];
+let totalCases = 0;
+
+function push(title: string) {
+  const next = (cases[0][title] = {});
+  cases.unshift(next);
+}
+
+function pop() {
+  cases.shift();
+}
+
+export function rootCases(): TestCase {
+  return CASES;
+}
+
+export function getTotalCases() {
+  return totalCases;
+}
+
+export function describe(title: string, block: Function) {
+  logger.debug(`describe(${title})`);
+  push(title);
+  block();
+  pop();
+}
+
+export function it(title: string, block: Function) {
+  logger.debug(`it(${title})`);
+  totalCases += 1;
+  cases[0][title] = block;
+}
+
+export function beforeEach(fn: () => void) {
+  cases[0][beforeeach] = fn;
+}
+
+export function beforeAll(fn: () => void) {
+  cases[0][beforeall] = fn;
+}
+
+export function afterEach(fn: () => void) {
+  cases[0][aftereach] = fn;
+}
+
+export function afterAll(fn: () => void) {
+  cases[0][afterall] = fn;
+}
+
+export function cleanState<State extends {}>(
+  init: () => State,
+  runner: (action: () => void) => void = beforeEach
+): State {
+  const state = {};
+  runner(() => {
+    Object.assign(state, init());
+  });
+  return state as State;
+}

package/src/scope/display/console.ts

@@ -0,0 +1,26 @@
+import { getLogger } from "../../log.js";
+import { getTotalCases } from "../describe.js";
+import { flattenResults } from "../execute.js";
+import { TestResult } from "../scope.js";
+
+const logger = getLogger("Scope Test Runner");
+
+export function onConsole(results: TestResult) {
+  const { executed, failed } = results;
+  logger.info("Executed test suite.", {
+    executed,
+    total: getTotalCases(),
+    failed,
+  });
+  const flat = flattenResults(results);
+
+  for (const { test } of flat) {
+    logger.debug(test);
+  }
+
+  for (const { test, stack } of flat) {
+    if (stack) {
+      logger.error(test, { stack });
+    }
+  }
+}

package/src/scope/display/dom.ts

@@ -0,0 +1,36 @@
+import { isHTMLLogger, makeHTMLLogger } from "../../components/logger.js";
+import { DOMElement, Updatable } from "../../dom/dom.js";
+import { DEFAULT_LOGGER, LEVEL } from "../../log.js";
+import { getTotalCases } from "../describe.js";
+import { flattenResults } from "../execute.js";
+import { TestResult } from "../scope.js";
+
+export function displayStatistics(
+  results: TestResult,
+  root: Updatable<DOMElement> = document.body as unknown as Updatable<DOMElement>
+) {
+  const { executed, failed } = results;
+  const logger = (() => {
+    try {
+      return makeHTMLLogger(
+        `Executed ${executed} of ${getTotalCases()}; ${failed} failed.`
+      );
+    } catch (e) {
+      return DEFAULT_LOGGER;
+    }
+  })();
+
+  logger.level = LEVEL.DEBUG;
+
+  const flat = flattenResults(results);
+  for (const { test, stack } of flat) {
+    if (stack) {
+      logger.info(test);
+      logger.debug(`${stack}`);
+    }
+  }
+
+  if (isHTMLLogger(logger)) {
+    root.appendChild(logger.root);
+  }
+}

package/src/scope/display/junit.ts

@@ -0,0 +1,67 @@
+import { xml } from "../../dom/xml.js";
+import { FlatResult, flattenResults } from "../execute.js";
+import { TestResult } from "../scope.js";
+
+const cases = (results: TestResult) =>
+  Object.entries(results).filter(
+    ([key]) => !["executed", "passed", "failed"].includes(key)
+  );
+
+export function asXML(results: TestResult) {
+  return (
+    `<?xml version="1.0" encoding="UTF-8" ?>` +
+    xml(
+      "testsuites",
+      { tests: results.executed, failures: results.failed },
+      cases(results).map(([title, children]) =>
+        testsuite(
+          title,
+          (children as TestResult).executed,
+          (children as TestResult).failed,
+          flattenResults(children as TestResult)
+        )
+      )
+    )
+  );
+}
+
+function testsuite(
+  name: string,
+  tests: number,
+  failures: number,
+  cases: FlatResult[]
+) {
+  const id = name.replace("s+", "_");
+  return xml(
+    "testsuite",
+    { id, name, tests, failures },
+    cases.map(({ test, stack }) =>
+      testcase({ name: `${name} ${test}` }, stack ? [stack as string] : [])
+    )
+  );
+}
+
+function testcase(
+  {
+    name,
+    id = name.replace(/\s+/g, "_"),
+    time = "0.00",
+  }: { name: string; id?: string; time?: string },
+  failures: string[]
+) {
+  return xml(
+    "testcase",
+    { id, name, time },
+    failures.map((stack) => failure({ text: stack }))
+  );
+}
+
+function failure({
+  text,
+  message = text.split("\n")[0],
+}: {
+  text: string;
+  message?: string;
+}) {
+  return xml("failure", { message }, [`<![CDATA[${text}]]>`]);
+}

package/src/scope/execute.ts

@@ -0,0 +1,108 @@
+import {
+  afterall,
+  aftereach,
+  beforeall,
+  beforeeach,
+  rootCases,
+} from "./describe.js";
+import { TestFailed, TestPassed, TestResult, TestSummary } from "./scope.js";
+
+export async function execute(
+  prefix = "",
+  cases = rootCases()
+): Promise<TestResult> {
+  const beforeallfn = cases[beforeall] ?? (() => {});
+  const beforeeachfn = cases[beforeeach] ?? (() => {});
+  const afterallfn = cases[afterall] ?? (() => {});
+  const aftereachfn = cases[aftereach] ?? (() => {});
+
+  const result: TestResult = { executed: 0, passed: 0, failed: 0, total: 0 };
+
+  try {
+    await beforeallfn();
+  } catch (e) {
+    result["_beforeAll"] = { error: e };
+    return result;
+  }
+
+  for (const [title, block] of Object.entries(cases)) {
+    if (typeof title === "symbol") {
+      continue;
+    }
+    if (block instanceof Function) {
+      try {
+        result.executed += 1;
+        await beforeeachfn();
+        await block();
+        await aftereachfn();
+        result.passed += 1;
+        result[title] = { passed: true };
+      } catch (e) {
+        result.failed += 1;
+        result[title] = { error: /** @type Error */ e };
+      }
+    } else if (block) {
+      const run = await execute(title, block);
+      result.executed += run.executed;
+      result.passed += run.passed;
+      result.failed += run.failed;
+      result[title] = run;
+    }
+  }
+
+  try {
+    await afterallfn();
+  } catch (e) {
+    result["_afterAll"] = { error: e };
+  }
+
+  return result;
+}
+
+export function getError({ error }: TestResult) {
+  if (typeof error == "string") {
+    return error;
+  } else if ((error as TestResult).message) {
+    return (error as TestResult).stack;
+  } else {
+    return "unknown error";
+  }
+}
+
+export interface FlatResult {
+  test: string;
+  stack?: string | number | TestResult | TestSummary;
+  stats: { executed: number; failed: number };
+}
+
+function makeResult(
+  test: string,
+  result: TestResult | TestSummary
+): FlatResult[] {
+  if ((result as TestFailed).error)
+    return [
+      {
+        test,
+        stack: getError(result as TestResult),
+        stats: { executed: 1, failed: 1 },
+      },
+    ];
+  if ((result as TestPassed).passed) {
+    return [{ test, stats: { executed: 1, failed: 0 } }];
+  }
+  return flattenResults(result as TestResult, test);
+}
+
+export function flattenResults(results: TestResult, prefix = ""): FlatResult[] {
+  const arrow = prefix == "" ? "" : " -> ";
+  let errorList: FlatResult[] = [];
+  for (const [title, result] of Object.entries(results).filter(
+    ([key]) => !["executed", "passed", "failed"].includes(key)
+  )) {
+    const test = `${prefix}${arrow}${title}`;
+    if (typeof result == "number") continue;
+    const flatResult = makeResult(test, result);
+    errorList = errorList.concat(flatResult);
+  }
+  return errorList;
+}

package/src/scope/expect.ts

@@ -0,0 +1,170 @@
+import { assert } from "../assert.js";
+import { equals } from "../equal.js";
+
+export class Matcher<T> {
+  actual: T;
+  constructor(actual: T) {
+    this.actual = actual;
+  }
+
+  get not(): Matcher<T> {
+    return new NotMatcher(this.actual);
+  }
+
+  toBe(expected: T) {
+    assert(this.actual === expected, () => `${this.actual} !== ${expected}`);
+  }
+
+  toEqual(expected: T) {
+    assert(
+      equals(this.actual, expected),
+      () =>
+        `Objects are not equivalent: ${JSON.stringify(
+          this.actual
+        )}, ${JSON.stringify(expected)}`
+    );
+  }
+
+  toMatch(expected: RegExp | string) {
+    assert(
+      typeof this.actual === "string",
+      () => "Must have string for regexp match"
+    );
+    // @ts-expect-error
+    const actual: string = this.actual;
+    if (typeof expected === "string") {
+      assert(
+        actual.includes(expected),
+        () => `${actual} does not include ${expected}`
+      );
+    } else {
+      assert(
+        expected.test(actual),
+        () => `${actual} does not match ${expected}`
+      );
+    }
+  }
+
+  toMatchObject(expected: Partial<T>) {
+    for (const [k, v] of Object.entries(expected)) {
+      // @ts-expect-error
+      const actual: Partial<T> = this.actual[k];
+      assert(
+        equals(actual, v),
+        () =>
+          `Comparing ${k}, properties not equal: ${JSON.stringify(
+            actual
+          )}, ${JSON.stringify(v)}`
+      );
+    }
+  }
+
+  toBeNull() {
+    assert(
+      this.actual === null,
+      () => `Expected null, got ${JSON.stringify(this.actual)}`
+    );
+  }
+
+  toThrow(message = "") {
+    let didThrow = false;
+
+    let result: unknown = undefined;
+    try {
+      // @ts-expect-error
+      result = this.actual();
+    } catch ({ message: e }) {
+      assert(
+        // @ts-expect-error
+        (e ?? "").match(message),
+        () => `Expected thrown message to match ${message}, got ${e}`
+      );
+      didThrow = true;
+    }
+
+    assert(didThrow, () => `Expected throw but got ${JSON.stringify(result)}`);
+  }
+}
+
+export class NotMatcher<T> {
+  actual: T;
+  constructor(actual: T) {
+    this.actual = actual;
+  }
+
+  get not(): Matcher<T> {
+    return new Matcher(this.actual);
+  }
+
+  toBe(expected: T) {
+    assert(this.actual !== expected, () => `${this.actual} === ${expected}`);
+  }
+
+  toEqual(expected: T) {
+    assert(
+      !equals(this.actual, expected),
+      () =>
+        `Objects are equivalent: ${JSON.stringify(
+          this.actual
+        )}, ${JSON.stringify(expected)}`
+    );
+  }
+
+  toMatch(expected: RegExp | string) {
+    assert(
+      typeof this.actual === "string",
+      () => "Must have string for regexp match"
+    );
+    // @ts-expect-error
+    const actual: string = this.actual;
+    if (typeof expected === "string") {
+      assert(
+        !actual.includes(expected),
+        () => `${actual} includes ${expected}`
+      );
+    } else {
+      assert(!expected.test(actual), () => `${actual} matches ${expected}`);
+    }
+  }
+
+  toMatchObject(expected: Partial<T>) {
+    for (const [k, v] of Object.entries(expected)) {
+      // @ts-expect-error
+      const actual = this.actual[k];
+      assert(
+        !equals(actual, v),
+        () =>
+          `Comparing ${k}, properties equal: ${JSON.stringify(
+            actual
+          )}, ${JSON.stringify(v)}`
+      );
+    }
+  }
+
+  toBeNull() {
+    assert(this.actual !== null, () => `Expected not null`);
+  }
+
+  toThrow(message = "") {
+    let didThrow = false;
+
+    let result: unknown = undefined;
+    try {
+      // @ts-expect-error
+      result = this.actual();
+    } catch ({ message: e }) {
+      assert(
+        // @ts-expect-error
+        (e ?? "").match(message),
+        () => `Expected thrown message to match ${message}, got ${e}`
+      );
+      didThrow = true;
+    }
+
+    assert(!didThrow, () => `Expected throw but got ${JSON.stringify(result)}`);
+  }
+}
+
+export function expect<T>(t: T): Matcher<T> {
+  return new Matcher(t);
+}

package/src/scope/fix.ts

@@ -0,0 +1,29 @@
+/**
+ * Given a value with numbers, attempt to fix all numbers to 1 decimal point.
+ */
+export function fix<T>(n: T): T {
+  if (typeof n === "number") {
+    // @ts-ignore
+    return +n.toFixed(1) as T;
+  }
+  if (n !== Object(n)) {
+    // A primitive
+    return n;
+  }
+  if (n instanceof Array) {
+    // @ts-ignore
+    return n.map(fix) as T;
+  }
+  // @ts-ignore
+  return mapreduce<T>(fix, n as Record<string, T>);
+}
+
+function mapreduce<T, U>(
+  fn: (t: T) => U,
+  iter: Record<string, T>
+): Record<string, U> {
+  return Object.entries(iter).reduce(
+    (acc, [k, v]) => ((acc[k] = fn(v)), acc),
+    {} as Record<string, U>
+  );
+}

package/src/scope/index.ts

@@ -0,0 +1,11 @@
+export { expect } from "./expect.js";
+export { fix } from "./fix.js";
+export {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  cleanState,
+  describe,
+  it,
+} from "./describe.js";

package/src/scope/scope.ts

@@ -0,0 +1,21 @@
+export interface TestCase {
+  [k: string]: Function | TestCase;
+  [k: symbol]: Function;
+}
+
+export interface TestResult {
+  executed: number;
+  passed: number;
+  failed: number;
+  [k: string]: TestResult | TestSummary | number;
+}
+
+export type TestSummary = TestFailed | TestPassed;
+
+export interface TestFailed {
+  error: unknown;
+}
+
+export interface TestPassed {
+  passed: true;
+}

package/src/server/http/apps.ts

@@ -0,0 +1,26 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { MiddlewareFactory } from "./index.js";
+import { fileResponse } from "./response.js";
+
+/**
+ * Searches up the request path until the first index is found.
+ */
+export const findIndex: MiddlewareFactory =
+  async ({ root }) =>
+  async (req) => {
+    let filename = path.join(root, req.url ?? "");
+    if (path.basename(filename).match(/\.[a-z]{1,3}$/)) {
+      return undefined;
+    }
+    while (filename.startsWith(root)) {
+      const index = path.join(filename, "index.html");
+      try {
+        const stat = await fs.stat(index);
+        return fileResponse(index, stat);
+      } catch (e) {
+        filename = path.dirname(filename);
+      }
+    }
+    return undefined;
+  };