First pass at coverage

Author: jdesrosiers

README.md

@@ -1,3 +1,16 @@
 # Hyperjump - JSON Schema Test Coverage
 
-TODO
+## Usage
+
+```bash
+rm ./.nyc_output/*
+npm test
+npx nyc report --reporter=html --extension .schema.json
+npx http-server coverage
+```
+## Legend
+
+Statements = Keywords
+Branches = true/false for each keyword
+Functions = Subschemas
+

package.json

@@ -16,7 +16,8 @@
   },
   "type": "module",
   "exports": {
-    ".": "./src/index.js"
+    ".": "./src/index.js",
+    "./vitest": "./src/vitest/index.js"
   },
   "scripts": {
     "lint": "eslint src",
@@ -26,14 +27,21 @@
   },
   "devDependencies": {
     "@stylistic/eslint-plugin": "*",
+    "@types/istanbul-lib-coverage": "^2.0.6",
+    "@types/moo": "^0.5.10",
     "@types/node": "*",
+    "@types/unist": "^3.0.3",
     "eslint-import-resolver-typescript": "*",
     "eslint-plugin-import": "*",
     "typedoc": "*",
     "typescript-eslint": "*",
     "vitest": "*"
   },
   "dependencies": {
-    "@hyperjump/json-schema": "^1.16.0"
+    "@hyperjump/json-schema": "^1.16.0",
+    "@hyperjump/uri": "^1.3.1",
+    "istanbul-lib-coverage": "^3.2.2",
+    "moo": "^0.5.2",
+    "vfile": "^6.0.3"
   }
 }

src/index.d.ts

@@ -0,0 +1 @@
+export { TestCoverageEvaluationPlugin } from "./test-coverage-evaluation-plugin.d.ts";

src/index.js

@@ -0,0 +1 @@
+export { TestCoverageEvaluationPlugin } from "./test-coverage-evaluation-plugin.js";

src/json-lexer.js

@@ -0,0 +1,103 @@
+import moo from "moo";
+import { VFileMessage } from "vfile-message";
+
+/**
+ * @import { Lexer, Token } from "moo"
+ */
+
+/**
+ * @typedef {"null" | "boolean" | "number" | "string" | "{" | "}" | "[" | "]" | ":" | ","} JsonTokenType
+ */
+
+/**
+ * @template {JsonTokenType} [T=JsonTokenType]
+ * @typedef {{ [K in T]: Token & { type: K }; }[T]} JsonToken
+ */
+
+// String
+const unescaped = `[\\x20-\\x21\\x23-\\x5b\\x5d-\\u{10ffff}]`;
+const escape = `\\\\`;
+const hexdig = `[0-9a-fA-F]`;
+const escaped = `${escape}(?:["\\/\\\\brfnt]|u${hexdig}{4})`;
+const char = `(?:${unescaped}|${escaped})`;
+const string = `"${char}*"`;
+
+// Number
+const digit = `[0-9]`;
+const digit19 = `[1-9]`;
+const int = `(?:0|${digit19}${digit}*)`;
+const frac = `\\.${digit}+`;
+const e = `[eE]`;
+const exp = `${e}[-+]?${digit}+`;
+const number = `-?${int}(?:${frac})?(?:${exp})?`;
+
+// Whitespace
+const whitespace = `(?:(?:\\r?\\n)|[ \\t])+`;
+
+export class JsonLexer {
+  /** @type Lexer */
+  #lexer;
+
+  /** @type Generator<JsonToken<JsonTokenType>, void, undefined> */
+  #iterator;
+
+  /**
+   * @param {string} json
+   */
+  constructor(json) {
+    this.#lexer = moo.compile({
+      WS: { match: new RegExp(whitespace, "u"), lineBreaks: true },
+      boolean: ["true", "false"],
+      null: "null",
+      number: { match: new RegExp(number, "u") },
+      string: { match: new RegExp(string, "u") },
+      "{": "{",
+      "}": "}",
+      "[": "[",
+      "]": "]",
+      ":": ":",
+      ",": ",",
+      error: moo.error
+    });
+
+    this.#iterator = (function* (lexer) {
+      for (const token of lexer.reset(json)) {
+        if (token.type === "WS") {
+          continue;
+        }
+
+        yield /** @type JsonToken */ (token);
+      }
+    }(this.#lexer));
+  }
+
+  /** @type () => JsonToken */
+  nextToken() {
+    const result = this.#iterator.next();
+    if (result.done) {
+      throw this.syntaxError("No more tokens");
+    }
+
+    return result.value;
+  };
+
+  done() {
+    if (!this.#iterator.next().done) {
+      throw this.syntaxError("Additional tokens found");
+    }
+  }
+
+  /** @type (message: string, token?: JsonToken) => VFileMessage */
+  syntaxError(message, token) {
+    throw new VFileMessage(message, {
+      source: "json",
+      ruleId: "syntax-error",
+      place: {
+        // @ts-expect-error Line exists in the lexer but isn't included in the type
+        line: token?.line ?? this.#lexer.line, // eslint-disable-line @typescript-eslint/no-unsafe-assignment
+        // @ts-expect-error Line exists in the lexer but isn't included in the type
+        column: token?.col ?? this.#lexer.col // eslint-disable-line @typescript-eslint/no-unsafe-assignment
+      }
+    });
+  };
+}

src/json-util.js

@@ -0,0 +1,197 @@
+import * as JsonPointer from "@hyperjump/json-pointer";
+import { JsonLexer } from "./json-lexer.js";
+
+/**
+ * @import { Node, Position } from "unist"
+ * @import { JsonToken } from "./json-lexer.js"
+ * @import {
+ *   JsonArrayNode,
+ *   JsonNode,
+ *   JsonObjectNode,
+ *   JsonPropertyNameNode,
+ *   JsonPropertyNode
+ * } from "./jsonast.d.ts"
+ */
+
+/** @type (json: string, location?: string) => JsonNode */
+export const fromJson = (json, location = "") => {
+  const lexer = new JsonLexer(json);
+
+  const token = lexer.nextToken();
+  const jsonValue = parseValue(token, lexer, undefined, `${location}#`);
+
+  lexer.done();
+
+  return jsonValue;
+};
+
+/** @type (token: JsonToken, lexer: JsonLexer, key: string | undefined, location: string) => JsonNode */
+const parseValue = (token, lexer, _key, location) => {
+  switch (token.type) {
+    case "null":
+    case "boolean":
+    case "number":
+    case "string":
+      return parseScalar(token, location);
+    case "[":
+      return parseArray(token, lexer, location);
+    case "{":
+      return parseObject(token, lexer, location);
+    default:
+      throw lexer.syntaxError("Expected a JSON value", token);
+  }
+};
+
+/** @type (token: JsonToken<"null" | "boolean" | "number" | "string">, location: string) => JsonNode */
+const parseScalar = (token, location) => {
+  return {
+    type: "json",
+    jsonType: token.type,
+    value: JSON.parse(token.value), // eslint-disable-line @typescript-eslint/no-unsafe-assignment
+    location: location,
+    position: tokenPosition(token)
+  };
+};
+
+/** @type (token: JsonToken, lexer: JsonLexer, key: string, location: string) => JsonPropertyNode */
+const parseProperty = (token, lexer, _key, location) => {
+  if (token.type !== "string") {
+    throw lexer.syntaxError("Expected a propertry", token);
+  }
+
+  /** @type JsonPropertyNameNode */
+  const keyNode = {
+    type: "json-property-name",
+    jsonType: "string",
+    value: JSON.parse(token.value), // eslint-disable-line @typescript-eslint/no-unsafe-assignment
+    position: tokenPosition(token)
+  };
+
+  if (lexer.nextToken().type !== ":") {
+    throw lexer.syntaxError("Expected :", token);
+  }
+
+  const valueNode = parseValue(lexer.nextToken(), lexer, keyNode.value, JsonPointer.append(keyNode.value, location));
+
+  return {
+    type: "json-property",
+    children: [keyNode, valueNode],
+    position: {
+      start: keyNode.position.start,
+      end: valueNode.position.end
+    }
+  };
+};
+
+/**
+ * @template A
+ * @typedef {Node & { children: A[] }} ParentNode
+ */
+
+/**
+ * @type <P extends ParentNode<C>, C extends JsonNode | JsonPropertyNode>(
+ *   parseChild: (token: JsonToken, lexer: JsonLexer, key: string, location: string) => C,
+ *   endToken: string
+ * ) => (lexer: JsonLexer, node: P, location: string) => P
+ */
+const parseCommaSeparated = (parseChild, endToken) => (lexer, node, location) => {
+  for (let index = 0; true; index++) {
+    let token = lexer.nextToken();
+
+    if (token.type === endToken) {
+      /** @type Position */ (node.position).end = tokenPosition(token).end;
+      return node;
+    }
+
+    if (index > 0) {
+      if (token.type === ",") {
+        token = lexer.nextToken();
+      } else {
+        throw lexer.syntaxError(`Expected , or ${endToken}`, token);
+      }
+    }
+
+    const childNode = parseChild(token, lexer, `${index}`, location);
+    if (childNode) {
+      node.children.push(childNode);
+    }
+  }
+};
+
+/** @type (openToken: JsonToken, lexer: JsonLexer, location: string) => JsonArrayNode */
+const parseArray = (openToken, lexer, location) => {
+  return parseItems(lexer, {
+    type: "json",
+    jsonType: "array",
+    children: [],
+    location: location,
+    position: tokenPosition(openToken)
+  }, location);
+};
+
+/** @type (token: JsonToken, lexer: JsonLexer, key: string, location: string) => JsonNode */
+const parseItem = (token, lexer, key, location) => {
+  return parseValue(token, lexer, key, JsonPointer.append(key, location));
+};
+
+/** @type (lexer: JsonLexer, node: { type: "json" } & JsonArrayNode, location: string) => JsonArrayNode */
+const parseItems = parseCommaSeparated(parseItem, "]");
+
+/** @type (openToken: JsonToken, lexer: JsonLexer, location: string) => JsonObjectNode */
+const parseObject = (openToken, lexer, location) => {
+  return parseProperties(lexer, {
+    type: "json",
+    jsonType: "object",
+    children: [],
+    location: location,
+    position: tokenPosition(openToken)
+  }, location);
+};
+
+/** @type (lexer: JsonLexer, node: { type: "json" } & JsonObjectNode, location: string) => JsonObjectNode */
+const parseProperties = parseCommaSeparated(parseProperty, "}");
+
+/** @type (startToken: JsonToken, endToken?: JsonToken) => Position */
+const tokenPosition = (startToken, endToken) => {
+  endToken ??= startToken;
+
+  return {
+    start: {
+      line: startToken.line,
+      column: startToken.col,
+      offset: startToken.offset
+    },
+    end: {
+      line: endToken.line,
+      column: endToken.col + endToken.text.length - 1,
+      offset: endToken.offset + endToken.text.length
+    }
+  };
+};
+
+/** @type (tree: JsonNode, pointer: string) => JsonNode | JsonPropertyNode */
+export const getNodeFromPointer = (tree, pointer) => {
+  /** @type JsonNode | JsonPropertyNode | undefined */
+  let node = tree;
+
+  for (const segment of JsonPointer.pointerSegments(pointer)) {
+    if (node.type === "json-property") {
+      node = node.children[1];
+    }
+
+    switch (node.jsonType) {
+      case "object":
+        node = node.children.find((property) => property.children[0].value === segment);
+        break;
+      case "array":
+        node = node.children[parseInt(segment, 10)];
+        break;
+    }
+
+    if (!node) {
+      throw Error("Invalid pointer");
+    }
+  }
+
+  return node;
+};