Correctly indent completion options

languageservice/src/complete.test.ts

@@ -4,8 +4,8 @@ import {complete} from "./complete";
 import {registerLogger} from "./log";
 import {getPositionFromCursor} from "./test-utils/cursor-position";
 import {TestLogger} from "./test-utils/logger";
-import {ValueProviderConfig, ValueProviderKind} from "./value-providers/config";
 import {clearCache} from "./utils/workflow-cache";
+import {ValueProviderConfig, ValueProviderKind} from "./value-providers/config";
 
 registerLogger(new TestLogger());
 
@@ -475,7 +475,7 @@ jobs:
     });
   });
 
-  it("adds a new line and indentation for mapping keys", async () => {
+  it("adds a new line and indentation for mapping keys when the key is given", async () => {
     const input = "concurrency: |";
 
     const result = await complete(...getPositionFromCursor(input));
@@ -485,4 +485,12 @@ jobs:
     ]);
     expect(result.filter(x => x.label === "group").map(x => x.textEdit?.newText)).toEqual(["\n  group: "]);
   });
+
+  it("does not add new line if no key in line", async () => {
+    const input = "run-n|";
+
+    const result = await complete(...getPositionFromCursor(input));
+
+    expect(result.filter(x => x.label === "run-name").map(x => x.textEdit?.newText)).toEqual(["run-name: "]);
+  });
 });

languageservice/src/complete.ts

@@ -24,7 +24,7 @@ import {isPlaceholder, transform} from "./utils/transform";
 import {fetchOrConvertWorkflowTemplate, fetchOrParseWorkflow} from "./utils/workflow-cache";
 import {Value, ValueProviderConfig} from "./value-providers/config";
 import {defaultValueProviders} from "./value-providers/default";
-import {definitionValues} from "./value-providers/definition";
+import {DefinitionValueMode, definitionValues} from "./value-providers/definition";
 
 export function getExpressionInput(input: string, pos: number): string {
   // Find start marker around the cursor position
@@ -180,7 +180,7 @@ async function getValues(
     return [];
   }
 
-  const values = definitionValues(def, indentation);
+  const values = definitionValues(def, indentation, keyToken ? DefinitionValueMode.Key : DefinitionValueMode.Parent);
   return filterAndSortCompletionOptions(values, existingValues);
 }
 

languageservice/src/value-providers/definition.ts

@@ -9,15 +9,30 @@ import {getWorkflowSchema} from "@actions/workflow-parser/workflows/workflow-sch
 import {Value} from "./config";
 import {stringsToValues} from "./strings-to-values";
 
-export function definitionValues(def: Definition, indentation: string): Value[] {
+export enum DefinitionValueMode {
+  /**
+   * We're getting completion options for a parent token
+   * foo:
+   *   ba|
+   */
+  Parent,
+
+  /**
+   * We're getting completion options for a key token. For example:
+   * foo: |
+   */
+  Key
+}
+
+export function definitionValues(def: Definition, indentation: string, mode: DefinitionValueMode): Value[] {
   const schema = getWorkflowSchema();
 
   if (def instanceof MappingDefinition) {
-    return mappingValues(def, schema.definitions, indentation);
+    return mappingValues(def, schema.definitions, indentation, mode);
   }
 
   if (def instanceof OneOfDefinition) {
-    return oneOfValues(def, schema.definitions, indentation);
+    return oneOfValues(def, schema.definitions, indentation, mode);
   }
 
   if (def instanceof BooleanDefinition) {
@@ -36,7 +51,7 @@ export function definitionValues(def: Definition, indentation: string): Value[]
   if (def instanceof SequenceDefinition) {
     const itemDef = schema.getDefinition(def.itemType);
     if (itemDef) {
-      return definitionValues(itemDef, indentation);
+      return definitionValues(itemDef, indentation, mode);
     }
   }
 
@@ -46,7 +61,8 @@ export function definitionValues(def: Definition, indentation: string): Value[]
 function mappingValues(
   mappingDefinition: MappingDefinition,
   definitions: {[key: string]: Definition},
-  indentation: string
+  indentation: string,
+  mode: DefinitionValueMode
 ): Value[] {
   const properties: Value[] = [];
   for (const [key, value] of Object.entries(mappingDefinition.properties)) {
@@ -73,8 +89,13 @@ function mappingValues(
 
           case DefinitionType.String:
           case DefinitionType.Boolean:
-            insertText = `\n${indentation}${key}: `;
+            if (mode == DefinitionValueMode.Key) {
+              insertText = `\n${indentation}${key}: `;
+            } else {
+              insertText = `${key}: `;
+            }
             break;
+
           default:
             insertText = `${key}: `;
         }
@@ -93,11 +114,12 @@ function mappingValues(
 function oneOfValues(
   oneOfDefinition: OneOfDefinition,
   definitions: {[key: string]: Definition},
-  indentation: string
+  indentation: string,
+  mode: DefinitionValueMode
 ): Value[] {
   const values: Value[] = [];
   for (const key of oneOfDefinition.oneOf) {
-    values.push(...definitionValues(definitions[key], indentation));
+    values.push(...definitionValues(definitions[key], indentation, mode));
   }
   return distinctValues(values);
 }