Add impl

Author: yamachu

src/Contract.ts

@@ -0,0 +1,7 @@
+export const preInsertedScript =
+  `export default async ({ context, core, exec, github, glob, io, require }: import('github-script').AsyncFunctionArguments) => {
+` as const;
+export const postInsertedScript = `}` as const;
+
+export const triggerTextYamlToTs = "#```typescript" as const;
+export const triggerTextTsToYaml = "#```" as const;

src/LanguageService.ts

@@ -0,0 +1,62 @@
+import * as fs from "fs";
+import path from "path";
+import * as ts from "typescript";
+
+const scriptSnapshots: { [fileName: string]: ts.IScriptSnapshot } = {};
+const scriptVersions: { [fileName: string]: string } = {};
+
+const extensionRootDir = path.join(__dirname, "..");
+
+export function createLanguageService() {
+  const compilerOptions: ts.CompilerOptions = {
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    lib: ["esnext"],
+    typeRoots: [
+      path.join(extensionRootDir, "node_modules", "@types"),
+      path.join(extensionRootDir, "node_modules"),
+    ],
+  };
+
+  const host: ts.LanguageServiceHost = {
+    getScriptFileNames: () => Object.keys(scriptSnapshots),
+    getScriptVersion: (fileName) => scriptVersions[fileName],
+    getScriptSnapshot: (fileName) => {
+      if (scriptSnapshots[fileName]) {
+        return scriptSnapshots[fileName];
+      }
+      if (fs.existsSync(fileName)) {
+        const content = fs.readFileSync(fileName, "utf8");
+        const snapshot = ts.ScriptSnapshot.fromString(content);
+        scriptSnapshots[fileName] = snapshot;
+        scriptVersions[fileName] = "1";
+        return snapshot;
+      }
+      return undefined;
+    },
+    getCurrentDirectory: () => process.cwd(),
+    getCompilationSettings: () => compilerOptions,
+    getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+    readFile: (fileName) => {
+      if (scriptSnapshots[fileName]) {
+        return scriptSnapshots[fileName].getText(
+          0,
+          scriptSnapshots[fileName].getLength()
+        );
+      }
+      return fs.readFileSync(fileName, "utf8");
+    },
+    fileExists: (fileName) => {
+      return !!scriptSnapshots[fileName] || fs.existsSync(fileName);
+    },
+  };
+
+  return ts.createLanguageService(host);
+}
+
+export function updateScript(fileName: string, content: string) {
+  scriptSnapshots[fileName] = ts.ScriptSnapshot.fromString(content);
+  scriptVersions[fileName] = (
+    parseInt(scriptVersions[fileName] || "0", 10) + 1
+  ).toString();
+}

src/Logger.ts

@@ -0,0 +1,6 @@
+import * as vscode from "vscode";
+
+export const logger = vscode.window.createOutputChannel(
+  "Workflow Script Highlighter",
+  { log: true }
+);

src/Platform.ts

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2018 TypeFox and others.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+import * as ts from "typescript";
+import * as vscode from "vscode";
+
+// https://github.com/typescript-language-server/typescript-language-server/blob/184c60de3308621380469d6632bdff2e10f672fd/src/completion.ts#L271
+export function asCompletionItemKind(
+  kind: ts.ScriptElementKind
+): vscode.CompletionItemKind {
+  switch (kind) {
+    case ts.ScriptElementKind.primitiveType:
+    case ts.ScriptElementKind.keyword:
+      return vscode.CompletionItemKind.Keyword;
+    case ts.ScriptElementKind.constElement:
+    case ts.ScriptElementKind.letElement:
+    case ts.ScriptElementKind.variableElement:
+    case ts.ScriptElementKind.localVariableElement:
+    case ts.ScriptElementKind.alias:
+    case ts.ScriptElementKind.parameterElement:
+      return vscode.CompletionItemKind.Variable;
+    case ts.ScriptElementKind.memberVariableElement:
+    case ts.ScriptElementKind.memberGetAccessorElement:
+    case ts.ScriptElementKind.memberSetAccessorElement:
+      return vscode.CompletionItemKind.Field;
+    case ts.ScriptElementKind.functionElement:
+    case ts.ScriptElementKind.localFunctionElement:
+      return vscode.CompletionItemKind.Function;
+    case ts.ScriptElementKind.memberFunctionElement:
+    case ts.ScriptElementKind.constructSignatureElement:
+    case ts.ScriptElementKind.callSignatureElement:
+    case ts.ScriptElementKind.indexSignatureElement:
+      return vscode.CompletionItemKind.Method;
+    case ts.ScriptElementKind.enumElement:
+      return vscode.CompletionItemKind.Enum;
+    case ts.ScriptElementKind.enumMemberElement:
+      return vscode.CompletionItemKind.EnumMember;
+    case ts.ScriptElementKind.moduleElement:
+    case ts.ScriptElementKind.externalModuleName:
+      return vscode.CompletionItemKind.Module;
+    case ts.ScriptElementKind.classElement:
+    case ts.ScriptElementKind.typeElement:
+      return vscode.CompletionItemKind.Class;
+    case ts.ScriptElementKind.interfaceElement:
+      return vscode.CompletionItemKind.Interface;
+    case ts.ScriptElementKind.warning:
+      return vscode.CompletionItemKind.Text;
+    case ts.ScriptElementKind.scriptElement:
+      return vscode.CompletionItemKind.File;
+    case ts.ScriptElementKind.directory:
+      return vscode.CompletionItemKind.Folder;
+    case ts.ScriptElementKind.string:
+      return vscode.CompletionItemKind.Constant;
+  }
+  return vscode.CompletionItemKind.Property;
+}

src/extension.ts

@@ -1,30 +1,101 @@
-// The module 'vscode' contains the VS Code extensibility API
-// Import the module and reference it with the alias vscode in your code below
+import * as ts from "typescript";
 import * as vscode from "vscode";
+import {
+  postInsertedScript,
+  preInsertedScript,
+  triggerTextTsToYaml,
+  triggerTextYamlToTs,
+} from "./Contract";
+import { logger } from "./Logger";
+import { createLanguageService, updateScript } from "./LanguageService";
+import { asCompletionItemKind } from "./Platform";
 
-// This method is called when your extension is activated
-// Your extension is activated the very first time the command is executed
-export function activate(context: vscode.ExtensionContext) {
-  // Use the console to output diagnostic information (console.log) and errors (console.error)
-  // This line of code will only be executed once when your extension is activated
-  console.log(
-    'Congratulations, your extension "workflow-script-highlighter" is now active!'
+// For debugging
+logger.hide();
+
+let languageService: ts.LanguageService;
+
+function extractTsCodeBlock(
+  text: string,
+  offset: number
+): { content: string; offset: number } | null {
+  const tsBlockStart = text.lastIndexOf(triggerTextYamlToTs, offset);
+  const tsBlockEnd = text.indexOf(
+    triggerTextTsToYaml,
+    tsBlockStart + triggerTextYamlToTs.length
   );
 
-  // The command has been defined in the package.json file
-  // Now provide the implementation of the command with registerCommand
-  // The commandId parameter must match the command field in package.json
-  const disposable = vscode.commands.registerCommand(
-    "workflow-script-highlighter.helloWorld",
-    () => {
-      // The code you place here will be executed every time your command is executed
-      // Display a message box to the user
-      vscode.window.showInformationMessage("Hello World from !");
-    }
+  if (tsBlockStart === -1 || tsBlockEnd === -1 || tsBlockEnd < offset) {
+    return null;
+  }
+
+  const content = text.substring(
+    tsBlockStart + triggerTextYamlToTs.length,
+    tsBlockEnd - postInsertedScript.length
   );
+  const tsOffset = offset - (tsBlockStart + triggerTextYamlToTs.length);
+
+  return { content, offset: tsOffset };
+}
+
+export function activate(context: vscode.ExtensionContext) {
+  languageService = createLanguageService();
+
+  const completionItemProvider: vscode.CompletionItemProvider = {
+    provideCompletionItems(
+      document: vscode.TextDocument,
+      position: vscode.Position
+    ) {
+      const text = document.getText();
+      const offset = document.offsetAt(position);
 
-  context.subscriptions.push(disposable);
+      const tsCodeBlock = extractTsCodeBlock(text, offset);
+      if (!tsCodeBlock) {
+        return [];
+      }
+
+      const scriptFileName = document.uri.fsPath + ".ts";
+      const augmentedContent = `${preInsertedScript}${tsCodeBlock.content}${postInsertedScript}`;
+      updateScript(scriptFileName, augmentedContent);
+
+      const updatedPosition = tsCodeBlock.offset + preInsertedScript.length;
+
+      const completions = languageService.getCompletionsAtPosition(
+        scriptFileName,
+        updatedPosition,
+        {}
+      );
+      if (!completions) {
+        return [];
+      }
+
+      // TODO: More powerful completion
+      const mapped = completions.entries.map((entry) => {
+        const item = new vscode.CompletionItem(
+          entry.name,
+          asCompletionItemKind(entry.kind)
+        );
+        item.sortText = entry.sortText;
+
+        return item;
+      });
+
+      return mapped;
+    },
+  };
+
+  const githubActionsWorkflowProvider =
+    vscode.languages.registerCompletionItemProvider(
+      { language: "github-actions-workflow", scheme: "file" },
+      completionItemProvider,
+      "."
+    );
+
+  context.subscriptions.push(githubActionsWorkflowProvider);
 }
 
-// This method is called when your extension is deactivated
-export function deactivate() {}
+export function deactivate() {
+  if (languageService) {
+    languageService.dispose();
+  }
+}