Don't use a class for SchemaDocument

jdesrosiers · jdesrosiers · commit 3b308163bae1 · 2024-06-07T18:53:56.000-07:00
diff --git a/language-server/src/features/hover.js b/language-server/src/features/hover.js
@@ -1,4 +1,5 @@
 import { MarkupKind } from "vscode-languageserver";
+import * as SchemaDocument from "../json-schema-document.js";
 import * as JsonNode from "../json-node.js";
 import { getSchemaDocument } from "./schema-registry.js";
 
@@ -17,7 +18,7 @@ export default {
       const document = documents.get(textDocument.uri);
       const schemaDocument = await getSchemaDocument(connection, document);
       const offset = document.offsetAt(position);
-      const keyword = schemaDocument.findNodeAtOffset(offset);
+      const keyword = SchemaDocument.findNodeAtOffset(schemaDocument, offset);
 
       // This is a little wierd because we want the hover to be on the keyword, but
       // the annotation is actually on the value not the keyword.
diff --git a/language-server/src/features/schema-completion.js b/language-server/src/features/schema-completion.js
@@ -1,5 +1,6 @@
-import { getDialectIds } from "@hyperjump/json-schema/experimental";
 import { CompletionItemKind } from "vscode-languageserver";
+import { getDialectIds } from "@hyperjump/json-schema/experimental";
+import * as SchemaDocument from "../json-schema-document.js";
 import { subscribe } from "../pubsub.js";
 
 
@@ -17,7 +18,7 @@ export default {
     const shouldHaveTrailingHash = (uri) => trailingHashDialects.has(uri);
 
     subscribe("completions", async (_message, { schemaDocument, offset, completions }) => {
-      const currentProperty = schemaDocument.findNodeAtOffset(offset);
+      const currentProperty = SchemaDocument.findNodeAtOffset(schemaDocument, offset);
       if (currentProperty && currentProperty.pointer.endsWith("/$schema")) {
         completions.push(...getDialectIds().map((uri) => ({
           label: shouldHaveTrailingHash(uri) ? `${uri}#` : uri,
diff --git a/language-server/src/features/schema-registry.js b/language-server/src/features/schema-registry.js
@@ -1,5 +1,5 @@
 import { getDocumentSettings } from "./document-settings.js";
-import { JsonSchemaDocument } from "../json-schema-document.js";
+import * as SchemaDocument from "../json-schema-document.js";
 
 
 export default {
@@ -21,7 +21,7 @@ export const getSchemaDocument = async (connection, textDocument) => {
 
   if (version === -1 || version !== textDocument.version) {
     const settings = await getDocumentSettings(connection, textDocument.uri);
-    schemaDocument = await JsonSchemaDocument.fromTextDocument(textDocument, settings.defaultDialect);
+    schemaDocument = await SchemaDocument.fromTextDocument(textDocument, settings.defaultDialect);
 
     schemaDocuments.set(textDocument.uri, { version: textDocument.version, schemaDocument });
   }
diff --git a/language-server/src/json-schema-document.js b/language-server/src/json-schema-document.js
@@ -6,177 +6,168 @@ import * as JsonNode from "./json-node.js";
 import { uriFragment } from "./util.js";
 
 
-export class JsonSchemaDocument {
-  constructor(textDocument) {
-    this.textDocument = textDocument;
-    this.schemaResources = [];
-    this.errors = [];
-  }
-
-  static async fromTextDocument(textDocument, contextDialectUri) {
-    const document = new JsonSchemaDocument(textDocument);
-
-    const json = textDocument.getText();
-    if (json) {
-      const root = parseTree(json, [], {
-        disallowComments: false,
-        allowTrailingComma: true,
-        allowEmptyContent: true
-      });
-
-      document.#buildSchemaResources(root, textDocument.uri, contextDialectUri);
-
-      for (const { dialectUri, schemaResource } of document.schemaResources) {
-        if (!hasDialect(dialectUri)) {
-          const $schema = JsonNode.get("#/$schema", schemaResource);
-          if ($schema && JsonNode.typeOf($schema) === "string") {
-            document.errors.push({
-              keyword: "https://json-schema.org/keyword/schema",
-              instanceNode: $schema,
-              message: "Unknown dialect"
-            });
-          } else if (dialectUri) {
-            document.errors.push({
-              keyword: "https://json-schema.org/keyword/schema",
-              instanceNode: schemaResource,
-              message: "Unknown dialect"
-            });
-          } else {
-            document.errors.push({
-              keyword: "https://json-schema.org/keyword/schema",
-              instanceNode: schemaResource,
-              message: "No dialect"
-            });
-          }
+const cons = (textDocument) => {
+  return {
+    textDocument: textDocument,
+    schemaResources: [],
+    errors: []
+  };
+};
 
-          continue;
+export const fromTextDocument = async (textDocument, contextDialectUri) => {
+  const document = cons(textDocument);
+
+  const json = textDocument.getText();
+  if (json) {
+    const root = parseTree(json, [], {
+      disallowComments: false,
+      allowTrailingComma: true,
+      allowEmptyContent: true
+    });
+
+    buildSchemaResources(document, root, textDocument.uri, contextDialectUri);
+
+    for (const { dialectUri, schemaResource } of document.schemaResources) {
+      if (!hasDialect(dialectUri)) {
+        const $schema = JsonNode.get("#/$schema", schemaResource);
+        if ($schema && JsonNode.typeOf($schema) === "string") {
+          document.errors.push({
+            keyword: "https://json-schema.org/keyword/schema",
+            instanceNode: $schema,
+            message: "Unknown dialect"
+          });
+        } else if (dialectUri) {
+          document.errors.push({
+            keyword: "https://json-schema.org/keyword/schema",
+            instanceNode: schemaResource,
+            message: "Unknown dialect"
+          });
+        } else {
+          document.errors.push({
+            keyword: "https://json-schema.org/keyword/schema",
+            instanceNode: schemaResource,
+            message: "No dialect"
+          });
         }
 
-        const schema = await getSchema(dialectUri);
-        const compiled = await compile(schema);
-        const output = interpret(compiled, schemaResource, BASIC);
-        if (!output.valid) {
-          for (const error of output.errors) {
-            document.errors.push({
-              keyword: error.keyword,
-              keywordNode: await getSchema(error.absoluteKeywordLocation),
-              instanceNode: JsonNode.get(error.instanceLocation, schemaResource)
-            });
-          }
+        continue;
+      }
+
+      const schema = await getSchema(dialectUri);
+      const compiled = await compile(schema);
+      const output = interpret(compiled, schemaResource, BASIC);
+      if (!output.valid) {
+        for (const error of output.errors) {
+          document.errors.push({
+            keyword: error.keyword,
+            keywordNode: await getSchema(error.absoluteKeywordLocation),
+            instanceNode: JsonNode.get(error.instanceLocation, schemaResource)
+          });
         }
       }
     }
-
-    return document;
   }
 
-  #buildSchemaResources(node, uri = "", dialectUri = "", pointer = "", parent = undefined, anchors = {}) {
-    const jsonNode = JsonNode.cons(uri, pointer, getNodeValue(node), node.type, [], parent, node.offset, node.length);
-
-    switch (node.type) {
-      case "array":
-        jsonNode.children = node.children.map((child, index) => {
-          const itemPointer = JsonPointer.append(index, pointer);
-          return this.#buildSchemaResources(child, uri, dialectUri, itemPointer, jsonNode, anchors);
-        });
-        break;
-
-      case "object":
-        if (pointer === "") {
-          // Resource root
-          const $schema = nodeStep(node, "$schema");
-          if ($schema?.type === "string") {
-            try {
-              dialectUri = toAbsoluteIri(getNodeValue($schema));
-            } catch (error) {
-              // Ignore
-            }
-          }
-
-          const idToken = keywordNameFor("https://json-schema.org/keyword/id", dialectUri);
-          const $idNode = idToken && nodeStep(node, idToken);
-          if ($idNode) {
-            uri = toAbsoluteIri(resolveIri(getNodeValue($idNode), uri));
-            jsonNode.baseUri = uri;
-          }
+  return document;
+};
 
-          const legacyIdToken = keywordNameFor("https://json-schema.org/keyword/draft-04/id", dialectUri);
-          const legacy$idNode = legacyIdToken && nodeStep(node, legacyIdToken);
-          if (legacy$idNode?.type === "string") {
-            const legacy$id = getNodeValue(legacy$idNode);
-            if (legacy$id[0] !== "#") {
-              uri = toAbsoluteIri(resolveIri(legacy$id, uri));
-              jsonNode.baseUri = uri;
-            }
-          }
-        } else {
-          // Check for embedded schema
-          const embeddedDialectUri = getEmbeddedDialectUri(node, dialectUri);
-          if (embeddedDialectUri) {
-            this.#buildSchemaResources(node, uri, embeddedDialectUri);
+const buildSchemaResources = (document, node, uri = "", dialectUri = "", pointer = "", parent = undefined, anchors = {}) => {
+  const jsonNode = JsonNode.cons(uri, pointer, getNodeValue(node), node.type, [], parent, node.offset, node.length);
 
-            return JsonNode.cons(uri, pointer, true, "boolean", [], parent, node.offset, node.length);
+  switch (node.type) {
+    case "array":
+      jsonNode.children = node.children.map((child, index) => {
+        const itemPointer = JsonPointer.append(index, pointer);
+        return buildSchemaResources(document, child, uri, dialectUri, itemPointer, jsonNode, anchors);
+      });
+      break;
+
+    case "object":
+      if (pointer === "") {
+        // Resource root
+        const $schema = nodeStep(node, "$schema");
+        if ($schema?.type === "string") {
+          try {
+            dialectUri = toAbsoluteIri(getNodeValue($schema));
+          } catch (error) {
+            // Ignore
           }
         }
 
-        const anchorToken = keywordNameFor("https://json-schema.org/keyword/anchor", dialectUri);
-        const $anchorNode = anchorToken && nodeStep(node, anchorToken);
-        if ($anchorNode) {
-          const anchor = getNodeValue($anchorNode);
-          anchors[anchor] = pointer;
+        const idToken = keywordNameFor("https://json-schema.org/keyword/id", dialectUri);
+        const $idNode = idToken && nodeStep(node, idToken);
+        if ($idNode) {
+          uri = toAbsoluteIri(resolveIri(getNodeValue($idNode), uri));
+          jsonNode.baseUri = uri;
         }
 
-        const legacyAnchorToken = keywordNameFor("https://json-schema.org/keyword/draft-04/id", dialectUri);
-        const legacyAnchorNode = legacyAnchorToken && nodeStep(node, legacyAnchorToken);
-        if (legacyAnchorNode) {
-          const anchor = getNodeValue(legacyAnchorNode);
-          if (anchor[0] === "#") {
-            anchors[uriFragment(anchor)] = pointer;
+        const legacyIdToken = keywordNameFor("https://json-schema.org/keyword/draft-04/id", dialectUri);
+        const legacy$idNode = legacyIdToken && nodeStep(node, legacyIdToken);
+        if (legacy$idNode?.type === "string") {
+          const legacy$id = getNodeValue(legacy$idNode);
+          if (legacy$id[0] !== "#") {
+            uri = toAbsoluteIri(resolveIri(legacy$id, uri));
+            jsonNode.baseUri = uri;
           }
         }
+      } else {
+        // Check for embedded schema
+        const embeddedDialectUri = getEmbeddedDialectUri(node, dialectUri);
+        if (embeddedDialectUri) {
+          buildSchemaResources(document, node, uri, embeddedDialectUri);
 
-        for (const child of node.children) {
-          const propertyPointer = JsonPointer.append(getNodeValue(child.children[0]), pointer);
-          const propertyNode = this.#buildSchemaResources(child, uri, dialectUri, propertyPointer, jsonNode, anchors);
+          return JsonNode.cons(uri, pointer, true, "boolean", [], parent, node.offset, node.length);
+        }
+      }
 
-          if (propertyNode) {
-            jsonNode.children.push(propertyNode);
-          }
+      const anchorToken = keywordNameFor("https://json-schema.org/keyword/anchor", dialectUri);
+      const $anchorNode = anchorToken && nodeStep(node, anchorToken);
+      if ($anchorNode) {
+        const anchor = getNodeValue($anchorNode);
+        anchors[anchor] = pointer;
+      }
+
+      const legacyAnchorToken = keywordNameFor("https://json-schema.org/keyword/draft-04/id", dialectUri);
+      const legacyAnchorNode = legacyAnchorToken && nodeStep(node, legacyAnchorToken);
+      if (legacyAnchorNode) {
+        const anchor = getNodeValue(legacyAnchorNode);
+        if (anchor[0] === "#") {
+          anchors[uriFragment(anchor)] = pointer;
         }
-        break;
+      }
+
+      for (const child of node.children) {
+        const propertyPointer = JsonPointer.append(getNodeValue(child.children[0]), pointer);
+        const propertyNode = buildSchemaResources(document, child, uri, dialectUri, propertyPointer, jsonNode, anchors);
 
-      case "property":
-        if (node.children.length !== 2) {
-          return;
+        if (propertyNode) {
+          jsonNode.children.push(propertyNode);
         }
+      }
+      break;
 
-        jsonNode.children = node.children.map((child) => {
-          return this.#buildSchemaResources(child, uri, dialectUri, pointer, jsonNode, anchors);
-        });
-        break;
-    }
+    case "property":
+      if (node.children.length !== 2) {
+        return;
+      }
 
-    if (jsonNode.pointer === "") {
-      this.schemaResources.push({
-        schemaResource: jsonNode,
-        dialectUri: dialectUri,
-        baseUri: uri,
-        anchors: anchors
+      jsonNode.children = node.children.map((child) => {
+        return buildSchemaResources(document, child, uri, dialectUri, pointer, jsonNode, anchors);
       });
-    }
-
-    return jsonNode;
+      break;
   }
 
-  findNodeAtOffset(offset) {
-    for (const { schemaResource } of this.schemaResources) {
-      const node = _findNodeAtOffset(schemaResource, offset);
-      if (node) {
-        return node;
-      }
-    }
+  if (jsonNode.pointer === "") {
+    document.schemaResources.push({
+      schemaResource: jsonNode,
+      dialectUri: dialectUri,
+      baseUri: uri,
+      anchors: anchors
+    });
   }
-}
+
+  return jsonNode;
+};
 
 const getEmbeddedDialectUri = (node, dialectUri) => {
   const $schema = nodeStep(node, "$schema");
@@ -202,6 +193,15 @@ const getEmbeddedDialectUri = (node, dialectUri) => {
   }
 };
 
+export const findNodeAtOffset = (document, offset) => {
+  for (const { schemaResource } of document.schemaResources) {
+    const node = _findNodeAtOffset(schemaResource, offset);
+    if (node) {
+      return node;
+    }
+  }
+};
+
 const _findNodeAtOffset = (node, offset, includeRightBound = false) => {
   if (contains(node, offset, includeRightBound)) {
     for (let i = 0; i < node.children.length && node.children[i].offset <= offset; i++) {
