feat: use a custom result validation filter

Author: aradzie

packages/keybr-result/lib/result.test.ts

@@ -1,54 +1,96 @@
-import { test } from "node:test";
+import { describe, it, test } from "node:test";
 import { Layout } from "@keybr/keyboard";
 import { Histogram } from "@keybr/textinput";
 import { assert } from "chai";
 import { Result, speedToTime, timeToSpeed } from "./result.ts";
 import { TextType } from "./texttype.ts";
 
-test("validate", () => {
-  assert.isFalse(
-    new Result(
-      /* layout= */ Layout.EN_US,
-      /* textType= */ TextType.GENERATED,
-      /* timeStamp= */ Date.parse("2001-02-03T03:05:06Z"),
-      /* length= */ 9,
-      /* time= */ 999,
-      /* errors= */ 0,
-      /* histogram= */ new Histogram([]),
-    ).validate(),
+describe("validate", () => {
+  const result = new Result(
+    /* layout= */ Layout.EN_US,
+    /* textType= */ TextType.GENERATED,
+    /* timeStamp= */ Date.parse("2001-02-03T03:05:06Z"),
+    /* length= */ 10,
+    /* time= */ 1000,
+    /* errors= */ 0,
+    /* histogram= */ new Histogram([
+      { codePoint: 0x0061, hitCount: 11, missCount: 1, timeToType: 111 },
+      { codePoint: 0x0062, hitCount: 22, missCount: 2, timeToType: 222 },
+      { codePoint: 0x0063, hitCount: 33, missCount: 3, timeToType: 333 },
+    ]),
   );
 
-  assert.isFalse(
-    new Result(
-      /* layout= */ Layout.EN_US,
-      /* textType= */ TextType.GENERATED,
-      /* timeStamp= */ Date.parse("2001-02-03T03:05:06Z"),
-      /* length= */ 9,
-      /* time= */ 999,
-      /* errors= */ 0,
-      /* histogram= */ new Histogram([
-        { codePoint: 0x0061, hitCount: 11, missCount: 1, timeToType: 111 },
-        { codePoint: 0x0062, hitCount: 22, missCount: 2, timeToType: 222 },
-        { codePoint: 0x0063, hitCount: 33, missCount: 3, timeToType: 333 },
-      ]),
-    ).validate(),
-  );
+  describe("using the default filter", () => {
+    it("should accept a valid result", () => {
+      assert.isTrue(result.validate());
+      assert.isTrue(result.validate({}));
+      assert.isTrue(result.validate(Result.filter));
+    });
 
-  assert.isTrue(
-    new Result(
-      /* layout= */ Layout.EN_US,
-      /* textType= */ TextType.GENERATED,
-      /* timeStamp= */ Date.parse("2001-02-03T03:05:06Z"),
-      /* length= */ 10,
-      /* time= */ 1000,
-      /* errors= */ 0,
-      /* histogram= */ new Histogram([
-        { codePoint: 0x0061, hitCount: 11, missCount: 1, timeToType: 111 },
-        { codePoint: 0x0062, hitCount: 22, missCount: 2, timeToType: 222 },
-        { codePoint: 0x0063, hitCount: 33, missCount: 3, timeToType: 333 },
-      ]),
-    ).validate(),
-  );
+    it("should reject if the length is too short", () => {
+      assert.isFalse(
+        new Result(
+          /* layout= */ result.layout,
+          /* textType= */ result.textType,
+          /* timeStamp= */ result.timeStamp,
+          /* length= */ 9,
+          /* time= */ result.time,
+          /* errors= */ result.errors,
+          /* histogram= */ result.histogram,
+        ).validate(),
+      );
+    });
+
+    it("should reject if the time is too short", () => {
+      assert.isFalse(
+        new Result(
+          /* layout= */ result.layout,
+          /* textType= */ result.textType,
+          /* timeStamp= */ result.timeStamp,
+          /* length= */ result.length,
+          /* time= */ 999,
+          /* errors= */ result.errors,
+          /* histogram= */ result.histogram,
+        ).validate(),
+      );
+    });
+
+    it("should reject if the complexity is too small", () => {
+      assert.isFalse(
+        new Result(
+          /* layout= */ result.layout,
+          /* textType= */ result.textType,
+          /* timeStamp= */ result.timeStamp,
+          /* length= */ result.length,
+          /* time= */ result.time,
+          /* errors= */ result.errors,
+          /* histogram= */ new Histogram([]),
+        ).validate(),
+      );
+    });
+  });
+
+  describe("using a custom filter", () => {
+    it("should reject if the length is too short", () => {
+      assert.isFalse(result.validate({ minLength: 100 }));
+    });
+
+    it("should reject if the time is too short", () => {
+      assert.isFalse(result.validate({ minTime: 60000 }));
+    });
+
+    it("should reject if the complexity is too small", () => {
+      assert.isFalse(result.validate({ minComplexity: 10 }));
+    });
+
+    it("should reject if the speed is too slow", () => {
+      assert.isFalse(result.validate({ minSpeed: 1000 }));
+    });
+
+    it("should reject if the speed is too fast", () => {
+      assert.isFalse(result.validate({ maxSpeed: 1 }));
+    });
+  });
 });
 
 test("serialize as JSON", () => {

packages/keybr-result/lib/result.ts

@@ -2,7 +2,23 @@ import { type Layout } from "@keybr/keyboard";
 import { type Histogram, type Stats } from "@keybr/textinput";
 import { type TextType } from "./texttype.ts";
 
+export type Filter = {
+  readonly minLength: number;
+  readonly minTime: number;
+  readonly minComplexity: number;
+  readonly minSpeed: number;
+  readonly maxSpeed: number;
+};
+
 export class Result {
+  static readonly filter = {
+    minLength: 10,
+    minTime: 1000,
+    minComplexity: 1,
+    minSpeed: 1,
+    maxSpeed: Infinity,
+  } as const satisfies Filter;
+
   static fromStats(
     layout: Layout,
     textType: TextType,
@@ -51,8 +67,21 @@ export class Result {
     this.score = score;
   }
 
-  validate(): boolean {
-    return this.length >= 10 && this.time >= 1000 && this.histogram.validate();
+  validate({
+    minLength = Result.filter.minLength,
+    minTime = Result.filter.minTime,
+    minComplexity = Result.filter.minComplexity,
+    minSpeed = Result.filter.minSpeed,
+    maxSpeed = Result.filter.maxSpeed,
+  }: Partial<Filter> = {}): boolean {
+    return (
+      this.length >= minLength &&
+      this.time >= minTime &&
+      this.complexity >= minComplexity &&
+      this.speed >= minSpeed &&
+      this.speed <= maxSpeed &&
+      this.histogram.validate()
+    );
   }
 
   toJSON() {

packages/keybr-result/lib/speedunit.ts

@@ -4,31 +4,31 @@ import { defineMessage, type MessageDescriptor } from "react-intl";
 export class SpeedUnit implements EnumItem {
   static readonly WPM = new SpeedUnit(
     "wpm",
-    (cpm) => cpm / 5,
+    1 / 5,
     defineMessage({
       id: "speedUnit.wpm.name",
       defaultMessage: "Words per minute",
     }),
   );
   static readonly WPS = new SpeedUnit(
     "wps",
-    (cpm) => cpm / 300,
+    1 / 300,
     defineMessage({
       id: "speedUnit.wps.name",
       defaultMessage: "Words per second",
     }),
   );
   static readonly CPM = new SpeedUnit(
     "cpm",
-    (cpm) => cpm,
+    1,
     defineMessage({
       id: "speedUnit.cpm.name",
       defaultMessage: "Characters per minute",
     }),
   );
   static readonly CPS = new SpeedUnit(
     "cps",
-    (cpm) => cpm / 60,
+    1 / 60,
     defineMessage({
       id: "speedUnit.cps.name",
       defaultMessage: "Characters per second",
@@ -43,12 +43,16 @@ export class SpeedUnit implements EnumItem {
 
   private constructor(
     readonly id: string,
-    readonly measure: (cpm: number) => number,
+    readonly factor: number,
     readonly name: MessageDescriptor,
   ) {
     Object.freeze(this);
   }
 
+  measure = (cpm: number): number => {
+    return cpm * this.factor;
+  };
+
   toString() {
     return this.id;
   }

packages/server-cli/lib/command/stats/argument.test.ts

@@ -1,6 +1,6 @@
 import { test } from "node:test";
 import { assert } from "chai";
-import { parseUserIdRange } from "./argument.ts";
+import { parseSpeed, parseUserIdRange } from "./argument.ts";
 
 test("parse user id range", () => {
   assert.deepStrictEqual([...parseUserIdRange("1")], [1]);
@@ -20,3 +20,17 @@ test("parse user id range", () => {
     parseUserIdRange("2-1");
   });
 });
+
+test("parse speed", () => {
+  assert.strictEqual(parseSpeed("100"), 500);
+  assert.strictEqual(parseSpeed("100wpm"), 500);
+  assert.strictEqual(parseSpeed("100cpm"), 100);
+
+  assert.throws(() => {
+    parseSpeed("-100");
+    parseSpeed("+100");
+    parseSpeed("100.0");
+    parseSpeed("100xyz");
+    parseSpeed("100.0xyz");
+  });
+});

packages/server-cli/lib/command/stats/argument.ts

@@ -1,10 +1,11 @@
+import { SpeedUnit } from "@keybr/result";
 import { InvalidArgumentError } from "commander";
 import { parseISO, parseJSON } from "date-fns";
 import { UserIdRange, type UserIdRangeItem } from "./userid-range.ts";
 
-export function parseUserIdRange(value: string): UserIdRange {
+export function parseUserIdRange(arg: string): UserIdRange {
   const items: UserIdRangeItem[] = [];
-  for (const item of value.split(/,/)) {
+  for (const item of arg.split(/,/)) {
     const parts = item.split(/-/, 2);
     if (parts.length === 1) {
       const n = parseUserId(parts[0]);
@@ -21,23 +22,33 @@ export function parseUserIdRange(value: string): UserIdRange {
   return new UserIdRange(items);
 }
 
-function parseUserId(s: string): number {
-  const n = Number.parseInt(s, 10);
+function parseUserId(arg: string): number {
+  const n = Number.parseInt(arg, 10);
   if (!Number.isInteger(n) || n <= 0 || n >= 0xffffffff) {
     throw new InvalidArgumentError(`Invalid user id.`);
   }
   return n;
 }
 
-export function parseTimestamp(value: string): Date {
+export function parseTimestamp(arg: string): Date {
   let date;
-  date = parseJSON(value);
-  if (Number.isFinite(date.getTime())) {
+  if (Number.isFinite((date = parseJSON(arg)).getTime())) {
     return date;
   }
-  date = parseISO(value);
-  if (Number.isFinite(date.getTime())) {
+  if (Number.isFinite((date = parseISO(arg)).getTime())) {
     return date;
   }
   throw new InvalidArgumentError(`Invalid timestamp.`);
 }
+
+export function parseSpeed(arg: string): number {
+  const m = /^(?<value>[0-9]+)(?<unit>wpm|cpm)?$/.exec(arg);
+  if (m) {
+    const { value, unit } = m.groups!;
+    const { factor } = (
+      { wpm: SpeedUnit.WPM, cpm: SpeedUnit.CPM } as Record<string, SpeedUnit>
+    )[unit || "wpm"];
+    return Number.parseInt(value, 10) / factor;
+  }
+  throw new InvalidArgumentError(`Invalid speed.`);
+}

packages/server-cli/lib/command/stats/check-file.ts

@@ -1,5 +1,5 @@
 import { Reader } from "@keybr/binary";
-import { type Result } from "@keybr/result";
+import { type Filter, type Result } from "@keybr/result";
 import { readResult, validateHeader } from "@keybr/result-io";
 
 export type FileStatus =
@@ -16,11 +16,11 @@ export type FileStatus =
       readonly results: readonly Result[];
     };
 
-export function checkFile(buffer: Uint8Array): FileStatus {
-  return checkFile0(new Reader(buffer));
-}
-
-function checkFile0(reader: Reader): FileStatus {
+export function checkFile(
+  buffer: Uint8Array,
+  filter: Partial<Filter> = {},
+): FileStatus {
+  const reader = new Reader(buffer);
   const results: Result[] = [];
   const invalid: Result[] = [];
   if (!validateHeader(reader)) {
@@ -33,14 +33,13 @@ function checkFile0(reader: Reader): FileStatus {
     } catch {
       return { type: "bad", results, invalid };
     }
-    if (result.validate()) {
+    if (result.validate(filter)) {
       results.push(result);
     } else {
       invalid.push(result);
     }
   }
-  if (results.length === 0 || invalid.length > 0) {
-    return { type: "bad", results, invalid };
-  }
-  return { type: "good", results };
+  return results.length === 0 || invalid.length > 0
+    ? { type: "bad", results, invalid }
+    : { type: "good", results };
 }