Merge pull request #1 from vim-denops/first

Initial impl

Author: lambdalisue

autocmd.ts

@@ -0,0 +1,203 @@
+import { Denops } from "./deps.ts";
+import { execute } from "./execute.ts";
+
+export async function autocmd(
+  denops: Denops,
+  group: string,
+  main: (helper: AutocmdHelper) => void,
+): Promise<void> {
+  const commands: string[] = [];
+  const helper = new AutocmdHelper(commands);
+  main(helper);
+  if (group) {
+    commands.unshift(`aug ${group}`);
+    commands.push("aug END");
+  }
+  await execute(denops, commands);
+}
+
+export class AutocmdHelper {
+  #commands: string[];
+
+  constructor(commands: string[]) {
+    this.#commands = commands;
+  }
+
+  define(
+    event: AutocmdEvent | AutocmdEvent[],
+    pat: string | string[],
+    cmd: string,
+    options: AutocmdOptions = {},
+  ): void {
+    const terms = ["au"];
+    if (Array.isArray(event)) {
+      terms.push(event.join(","));
+    } else {
+      terms.push(event);
+    }
+    if (Array.isArray(pat)) {
+      terms.push(pat.join(","));
+    } else {
+      terms.push(pat);
+    }
+    if (options.once) {
+      terms.push("++once");
+    }
+    if (options.nested) {
+      terms.push("++nested");
+    }
+    terms.push(cmd);
+    this.#commands.push(terms.join(" "));
+  }
+
+  remove(
+    event?: AutocmdEvent | AutocmdEvent[],
+    pat?: string | string[],
+    options: AutocmdOptions = {},
+  ): void {
+    const terms = ["au!"];
+    if (event) {
+      if (Array.isArray(event)) {
+        terms.push(event.join(","));
+      } else {
+        terms.push(event);
+      }
+      if (pat) {
+        if (Array.isArray(pat)) {
+          terms.push(pat.join(","));
+        } else {
+          terms.push(pat);
+        }
+        if (options.once) {
+          terms.push("++once");
+        }
+        if (options.nested) {
+          terms.push("++nested");
+        }
+      }
+    }
+    this.#commands.push(terms.join(" "));
+  }
+}
+
+export interface AutocmdOptions {
+  once?: boolean;
+  nested?: boolean;
+}
+
+export type AutocmdEvent =
+  | "*"
+  | "BufAdd"
+  | "BufDelete"
+  | "BufEnter"
+  | "BufFilePost"
+  | "BufFilePre"
+  | "BufHidden"
+  | "BufLeave"
+  | "BufModifiedSet"
+  | "BufNew"
+  | "BufNewFile"
+  | "BufRead"
+  | "BufReadPost"
+  | "BufReadCmd"
+  | "BufReadPre"
+  | "BufUnload"
+  | "BufWinEnter"
+  | "BufWinLeave"
+  | "BufWipeout"
+  | "BufWrite"
+  | "BufWritePre"
+  | "BufWriteCmd"
+  | "BufWritePost"
+  | "ChanInfo"
+  | "ChanOpen"
+  | "CmdUndefined"
+  | "CmdlineChanged"
+  | "CmdlineEnter"
+  | "CmdlineLeave"
+  | "CmdwinEnter"
+  | "CmdwinLeave"
+  | "ColorScheme"
+  | "ColorSchemePre"
+  | "CompleteChanged"
+  | "CompleteDonePre"
+  | "CompleteDone"
+  | "CursorHold"
+  | "CursorHoldI"
+  | "CursorMoved"
+  | "CursorMovedI"
+  | "DiffUpdated"
+  | "DirChanged"
+  | "FileAppendCmd"
+  | "FileAppendPost"
+  | "FileAppendPre"
+  | "FileChangedRO"
+  | "ExitPre"
+  | "FileChangedShell"
+  | "FileChangedShellPost"
+  | "FileReadCmd"
+  | "FileReadPost"
+  | "FileReadPre"
+  | "FileType"
+  | "FileWriteCmd"
+  | "FileWritePost"
+  | "FileWritePre"
+  | "FilterReadPost"
+  | "FilterReadPre"
+  | "FilterWritePost"
+  | "FilterWritePre"
+  | "FocusGained"
+  | "FocusLost"
+  | "FuncUndefined"
+  | "UIEnter"
+  | "UILeave"
+  | "InsertChange"
+  | "InsertCharPre"
+  | "TextYankPost"
+  | "InsertEnter"
+  | "InsertLeavePre"
+  | "InsertLeave"
+  | "MenuPopup"
+  | "OptionSet"
+  | "QuickFixCmdPre"
+  | "QuickFixCmdPost"
+  | "QuitPre"
+  | "RemoteReply"
+  | "SessionLoadPost"
+  | "ShellCmdPost"
+  | "Signal"
+  | "ShellFilterPost"
+  | "SourcePre"
+  | "SourcePost"
+  | "SourceCmd"
+  | "SpellFileMissing"
+  | "StdinReadPost"
+  | "StdinReadPre"
+  | "SwapExists"
+  | "Syntax"
+  | "TabEnter"
+  | "TabLeave"
+  | "TabNew"
+  | "TabNewEntered"
+  | "TabClosed"
+  | "TermOpen"
+  | "TermEnter"
+  | "TermLeave"
+  | "TermClose"
+  | "TermResponse"
+  | "TextChanged"
+  | "TextChangedI"
+  | "TextChangedP"
+  | "User"
+  | "UserGettingBored"
+  | "VimEnter"
+  | "VimLeave"
+  | "VimLeavePre"
+  | "VimResized"
+  | "VimResume"
+  | "VimSuspend"
+  | "WinClosed"
+  | "WinEnter"
+  | "WinLeave"
+  | "WinNew"
+  | "WinScrolled";

deps.ts

@@ -0,0 +1,5 @@
+export type {
+  Context,
+  Dispatcher,
+} from "https://deno.land/x/denops@v0.7/mod.ts";
+export { Denops } from "https://deno.land/x/denops@v0.7/mod.ts";

execute.ts

@@ -0,0 +1,20 @@
+import { Denops } from "./deps.ts";
+
+/**
+ * Execute Vim script directly
+ */
+export async function execute(
+  denops: Denops,
+  command: string | string[],
+): Promise<void> {
+  if (Array.isArray(command)) {
+    await denops.cmd("call execute(l:command, '')", {
+      command: command
+        .map((x) => x.replace(/^\s+|\s+$/g, ""))
+        .filter((x) => !!x),
+    });
+    return;
+  }
+  command = command.replace(/\r?\n\s*\\/g, "");
+  await execute(denops, command.split(/\r?\n/g));
+}

mod.ts

@@ -0,0 +1,4 @@
+export * from "./autocmd.ts";
+export * from "./execute.ts";
+export * from "./variable.ts";
+export * from "./vim.ts";

variable.ts

@@ -0,0 +1,67 @@
+import { Denops } from "./deps.ts";
+
+/**
+ * Vim variable groups
+ *
+ * g - Global variables
+ * b - Buffer local variables
+ * w - Window local variables
+ * t - Tab page local variables
+ * v - Vim's variables
+ * env - Environment variables
+ *
+ */
+export type VariableGroups = "g" | "b" | "w" | "t" | "v" | "env";
+
+export async function getVar<T = unknown>(
+  denops: Denops,
+  group: VariableGroups,
+  prop: string,
+): Promise<T> {
+  const name = group === "env" ? `\$${prop}` : `${group}:${prop}`;
+  // deno-lint-ignore no-explicit-any
+  return (await denops.eval(name)) as any;
+}
+
+export async function setVar<T = unknown>(
+  denops: Denops,
+  group: VariableGroups,
+  prop: string,
+  value: T,
+): Promise<void> {
+  const name = group === "env" ? `\$${prop}` : `${group}:${prop}`;
+  await denops.cmd(`let ${name} = value`, {
+    value,
+  });
+}
+
+export async function removeVar(
+  denops: Denops,
+  group: VariableGroups,
+  prop: string,
+): Promise<void> {
+  const name = group === "env" ? `\$${prop}` : `${group}:${prop}`;
+  await denops.cmd(`unlet ${name}`);
+}
+
+export class VariableHelper {
+  #denops: Denops;
+  #group: VariableGroups;
+
+  constructor(denops: Denops, group: VariableGroups) {
+    this.#denops = denops;
+    this.#group = group;
+  }
+
+  async get<T = unknown>(prop: string): Promise<T> {
+    return await getVar(this.#denops, this.#group, prop);
+  }
+
+  async set<T = unknown>(prop: string, value: T): Promise<void> {
+    await setVar(this.#denops, this.#group, prop, value);
+  }
+
+  async remove(prop: string): Promise<void> {
+    await removeVar(this.#denops, this.#group, prop);
+  }
+}

vim.ts

@@ -0,0 +1,63 @@
+import { Context, Denops, Dispatcher } from "./deps.ts";
+import { execute } from "./execute.ts";
+import { autocmd, AutocmdHelper } from "./autocmd.ts";
+import { VariableHelper } from "./variable.ts";
+
+export class Vim {
+  #denops: Denops;
+
+  readonly g: VariableHelper;
+  readonly b: VariableHelper;
+  readonly w: VariableHelper;
+  readonly t: VariableHelper;
+  readonly v: VariableHelper;
+  readonly env: VariableHelper;
+
+  constructor(denops: Denops) {
+    this.#denops = denops;
+    this.g = new VariableHelper(denops, "g");
+    this.b = new VariableHelper(denops, "b");
+    this.w = new VariableHelper(denops, "w");
+    this.t = new VariableHelper(denops, "t");
+    this.v = new VariableHelper(denops, "v");
+    this.env = new VariableHelper(denops, "env");
+  }
+
+  get name(): string {
+    return this.#denops.name;
+  }
+
+  async call(func: string, ...args: unknown[]): Promise<unknown> {
+    return await this.#denops.call(func, ...args);
+  }
+
+  async cmd(cmd: string, context: Context = {}): Promise<void> {
+    await this.#denops.cmd(cmd, context);
+  }
+
+  async eval(expr: string, context: Context = {}): Promise<void> {
+    await this.#denops.eval(expr, context);
+  }
+
+  async execute(command: string | string[]): Promise<void> {
+    await execute(this.#denops, command);
+  }
+
+  async autocmd(
+    group: string,
+    main: (helper: AutocmdHelper) => void,
+  ): Promise<void> {
+    await autocmd(this.#denops, group, main);
+  }
+
+  register(dispatcher: Dispatcher): void {
+    this.#denops.extendDispatcher(dispatcher);
+  }
+}
+
+export function start(main: (vim: Vim) => Promise<void>) {
+  Denops.start(async (denops) => {
+    const vim = new Vim(denops);
+    await main(vim);
+  });
+}