skir-codemirror-plugin 1.0.2 → 1.0.3

package/src/json/json_parser.ts

@@ -33,6 +33,7 @@ export function parseJsonValue(input: string): JsonParseResult {
 interface JsonToken {
   segment: Segment;
   jsonCode: string;
+  indent: number;
 }
 
 interface JsonTokens {
@@ -43,16 +44,29 @@ interface JsonTokens {
 function tokenize(input: string): JsonTokens | JsonError {
   const tokens: JsonToken[] = [];
   let pos = 0;
+  let lineIndent = 0;
+  let lineHasContent = false;
 
   const whitespaceRegex = /[ \t\r\n]*/y;
   const tokenRegex =
     /([[\]{}:,]|(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|false|true|null|("(((?=\\)\\(["\\/ bfnrt]|u[0-9a-fA-F]{4}))|[^"\\\0-\x1F\x7F]+)*")|$)/y;
 
   while (true) {
+    const beforeWhitespacePos = pos;
     whitespaceRegex.lastIndex = pos;
     whitespaceRegex.exec(input);
     pos = whitespaceRegex.lastIndex;
 
+    for (let i = beforeWhitespacePos; i < pos; ++i) {
+      const ch = input[i];
+      if (ch === "\n") {
+        lineIndent = 0;
+        lineHasContent = false;
+      } else if (!lineHasContent && (ch === " " || ch === "\t")) {
+        lineIndent++;
+      }
+    }
+
     tokenRegex.lastIndex = pos;
     const tokenMatch = tokenRegex.exec(input);
     if (tokenMatch) {
@@ -61,9 +75,16 @@ function tokenize(input: string): JsonTokens | JsonError {
         start: pos,
         end: pos + tokenText.length,
       };
-      const token: JsonToken = { segment, jsonCode: tokenText };
+      const token: JsonToken = {
+        segment,
+        jsonCode: tokenText,
+        indent: lineIndent,
+      };
       pos = tokenRegex.lastIndex;
       tokens.push(token);
+      if (tokenText !== "") {
+        lineHasContent = true;
+      }
       if (tokenText === "") {
         return {
           kind: "tokens",
@@ -96,6 +117,8 @@ class JsonParser {
     const token = this.peekToken();
     const firstChar = token.jsonCode ? token.jsonCode[0] : "";
 
+    const { indent } = token;
+
     switch (firstChar) {
       case "[":
         return this.parseArray();
@@ -109,6 +132,7 @@ class JsonParser {
           segment: token.segment,
           jsonCode: "null",
           type: "null",
+          indent,
         };
       case "f":
         this.nextToken();
@@ -118,6 +142,7 @@ class JsonParser {
           segment: token.segment,
           jsonCode: "false",
           type: "boolean",
+          indent,
         };
       case "t":
         this.nextToken();
@@ -127,6 +152,7 @@ class JsonParser {
           segment: token.segment,
           jsonCode: "true",
           type: "boolean",
+          indent,
         };
       case '"':
         this.nextToken();
@@ -136,6 +162,7 @@ class JsonParser {
           segment: token.segment,
           jsonCode: token.jsonCode,
           type: "string",
+          indent,
         };
       case "0":
       case "1":
@@ -155,6 +182,7 @@ class JsonParser {
           segment: token.segment,
           jsonCode: token.jsonCode,
           type: "number",
+          indent,
         };
     }
 
@@ -169,6 +197,7 @@ class JsonParser {
 
   private parseArray(): JsonArray {
     const leftBracket = this.nextToken();
+    const { indent } = leftBracket;
     const values: JsonValue[] = [];
     while (true) {
       if (this.peekToken().jsonCode === "]") {
@@ -181,6 +210,7 @@ class JsonParser {
             end: rightBracket.segment.end,
           },
           values,
+          indent,
         };
       }
       if (this.peekToken().jsonCode === "}") {
@@ -198,6 +228,7 @@ class JsonParser {
             end: wrongBracket.segment.end,
           },
           values,
+          indent,
         };
       }
       if (this.peekToken().jsonCode === "") {
@@ -211,6 +242,7 @@ class JsonParser {
             end: this.peekToken().segment.start,
           },
           values,
+          indent,
         };
       }
       const value = this.parseValueOrSkip();
@@ -233,6 +265,7 @@ class JsonParser {
 
   private parseObject(): JsonObject {
     const leftBracket = this.nextToken();
+    const { indent } = leftBracket;
     const keyValues: { [key: string]: JsonKeyValue } = {};
     const allKeys: JsonKey[] = [];
     while (true) {
@@ -247,6 +280,7 @@ class JsonParser {
           },
           keyValues,
           allKeys,
+          indent,
         };
       }
       if (this.peekToken().jsonCode === "]") {
@@ -265,6 +299,7 @@ class JsonParser {
           },
           keyValues,
           allKeys,
+          indent,
         };
       }
       if (this.peekToken().jsonCode === "") {
@@ -279,6 +314,7 @@ class JsonParser {
           },
           keyValues,
           allKeys,
+          indent,
         };
       }
       const keyToken = this.peekToken();

package/src/json/schema_validator.test.ts

@@ -189,6 +189,81 @@ describe("schema_validator", () => {
     ]);
   });
 
+  it("stores enum definition in type hint for UNKNOWN enum literal", () => {
+    const schema: TypeDefinition = {
+      type: { kind: "record", value: "MyEnum" },
+      records: [
+        {
+          kind: "enum",
+          id: "MyEnum",
+          variants: [
+            { name: "First", number: 1 },
+            { name: "Second", number: 2 },
+          ],
+        },
+      ],
+    };
+
+    const result = validateSchema(parse('"UNKNOWN"'), schema);
+    expect(result.errors).toMatch([]);
+    if (!result.rootTypeHint) {
+      throw new Error("Expected root type hint");
+    }
+    expect(result.rootTypeHint.enumDefinition).toMatch({
+      kind: "enum",
+      id: "MyEnum",
+      variants: [
+        { name: "First", number: 1 },
+        { name: "Second", number: 2 },
+      ],
+    });
+  });
+
+  it("stores enum definition in nested UNKNOWN enum field hint", () => {
+    const schema: TypeDefinition = {
+      type: { kind: "record", value: "MyStruct" },
+      records: [
+        {
+          kind: "struct",
+          id: "MyStruct",
+          fields: [
+            {
+              name: "status",
+              number: 1,
+              type: { kind: "record", value: "MyEnum" },
+            },
+          ],
+        },
+        {
+          kind: "enum",
+          id: "MyEnum",
+          variants: [
+            { name: "First", number: 1 },
+            { name: "Second", number: 2 },
+          ],
+        },
+      ],
+    };
+
+    const result = validateSchema(parse('{"status": "UNKNOWN"}'), schema);
+    expect(result.errors).toMatch([]);
+    if (!result.rootTypeHint) {
+      throw new Error("Expected root type hint");
+    }
+    if (result.rootTypeHint.childHints.length !== 1) {
+      throw new Error("Expected one child type hint");
+    }
+    const statusHint = result.rootTypeHint.childHints[0];
+    expect(statusHint.enumDefinition).toMatch({
+      kind: "enum",
+      id: "MyEnum",
+      variants: [
+        { name: "First", number: 1 },
+        { name: "Second", number: 2 },
+      ],
+    });
+  });
+
   it("validates enum (object with kind)", () => {
     const schema: TypeDefinition = {
       type: { kind: "record", value: "MyEnum" },

package/src/json/schema_validator.ts

@@ -1,6 +1,7 @@
 import { primitiveSerializer } from "skir-client";
 import { toJson } from "./to_json";
 import type {
+  EnumDefinition,
   FieldDefinition,
   Hint,
   JsonError,
@@ -60,7 +61,9 @@ class SchemaValidator {
     const { idToRecordDef, typeHintStack } = this;
     value.expectedType = schema;
     // For every call to pushTypeHint() there emust be one call to typeHintStack.pop()
-    const pushTypeHint = (): void => {
+    const pushTypeHint = (options?: {
+      enumDefinition?: EnumDefinition;
+    }): void => {
       const typeDesc = getTypeDesc(optionalSchema ?? schema);
       const typeDoc = getTypeDoc(schema, idToRecordDef);
       const message = [typeDesc];
@@ -78,6 +81,7 @@ class SchemaValidator {
         message: message.length === 1 ? message[0] : message,
         valueContext: { value, path },
         childHints: [],
+        enumDefinition: options?.enumDefinition,
       };
       if (typeHintStack.length) {
         const topOfStack = typeHintStack[typeHintStack.length - 1];
@@ -196,8 +200,14 @@ class SchemaValidator {
           } else if (value.kind === "literal" && value.type === "string") {
             const name = JSON.parse(value.jsonCode);
             const fieldDef = nameToVariantDef[name];
-            if (name === "UNKNOWN" || fieldDef) {
-              pushTypeHint();
+            if (fieldDef && fieldDef.type) {
+              this.errors.push({
+                kind: "error",
+                segment: value.segment,
+                message: "Expected: uppercase variant name",
+              });
+            } else if (name === "UNKNOWN" || fieldDef) {
+              pushTypeHint({ enumDefinition: recordDef });
               typeHintStack.pop();
             } else {
               this.errors.push({
@@ -492,13 +502,13 @@ function isFloat(value: JsonValue): boolean {
   }
   if (value.type === "number") {
     return true;
-  } else if (value.type === "string") {
-    try {
-      primitiveSerializer("float64").fromJsonCode(value.jsonCode);
-      return true;
-    } catch {
-      return false;
-    }
+  } else if (
+    value.type === "string" &&
+    (value.jsonCode === '"NaN"' ||
+      value.jsonCode === '"Infinity"' ||
+      value.jsonCode === '"-Infinity"')
+  ) {
+    return true;
   } else {
     return false;
   }

package/src/json/to_json.ts

@@ -22,7 +22,7 @@ export function toJson(value: JsonValue): Json {
 export function makeJsonTemplate(
   type: TypeSignature,
   idToRecordDef: { [id: string]: RecordDefinition },
-  depth?: "depth",
+  nested?: "nested",
 ): Json {
   switch (type.kind) {
     case "array": {
@@ -34,13 +34,13 @@ export function makeJsonTemplate(
     case "record": {
       const recordDef = idToRecordDef[type.value]!;
       if (recordDef.kind === "struct") {
-        if (depth) {
+        if (nested) {
           return {};
         }
         return Object.fromEntries(
           recordDef.fields.map((field) => [
             field.name,
-            makeJsonTemplate(field.type!, idToRecordDef, "depth"),
+            makeJsonTemplate(field.type!, idToRecordDef, "nested"),
           ]),
         );
       } else {

package/src/json/types.ts

@@ -39,6 +39,7 @@ export interface JsonArray {
   /// From '[' to ']' included.
   readonly segment: Segment;
   readonly values: JsonValue[];
+  readonly indent: number;
   expectedType?: TypeSignature;
 }
 
@@ -63,6 +64,7 @@ export interface JsonObject {
   readonly keyValues: { [key: string]: JsonKeyValue };
   /// Includes "broken" keys which produced a parsing error.
   readonly allKeys: readonly JsonKey[];
+  readonly indent: number;
   expectedType?: TypeSignature;
 }
 
@@ -73,6 +75,7 @@ export interface JsonLiteral {
   readonly segment: Segment;
   readonly jsonCode: string;
   readonly type: "boolean" | "null" | "number" | "string";
+  readonly indent: number;
   expectedType?: TypeSignature;
 }
 
@@ -223,6 +226,10 @@ export interface TypeHint {
   readonly valueContext: JsonValueContext;
   /// In order. All are included in 'valueContext.value.segment'.
   readonly childHints: readonly TypeHint[];
+  /// Set if the expected type is an enum and the value is a literal string.
+  /// In that case, the editor can show a dropdown with the possible variants
+  /// of the enum.
+  readonly enumDefinition?: EnumDefinition;
 }
 
 export type Hint =