Skip to content

Latest commit

 

History

History
145 lines (111 loc) · 3.82 KB

creating-controller.md

File metadata and controls

145 lines (111 loc) · 3.82 KB
Raw

Create Controller

Content Table

Currently all the controllers must be implemented inside of the everdev package.

To create a new controller:

  • Clone [email protected]:everx-labs/everdev.git.
  • Create and checkout branch for the new controller.
  • Create a folder under src/controllers.
  • Implement the controller code.
  • Include the new controller in file src/controllers/index.js.
  • Create pull request.

What a controller should and what it shouldn't to do

Controller should:

  • Expose functionality to the user as a list of commands.
  • Install the required tool components on demand (on first usage).
  • Start and stop the tool components that acts like a demons.
  • Define three commands to control the tool version:
    • version to show the currently installed tool version;
    • update to update the tool to the latest available version;
    • use to select the specified tool version as the current version.

Controller shouldn't:

  • Implement tool functionality itself. Controller is a connector between the user and the existing development tool.
  • Implement user interaction itself. All user interaction must be implemented exactly in the terms of everdev extensibility.

How to implement a Controller

Create a folder for a new controller:

mkdir src/controllers/foo
cd src/controllers/foo

Create index.ts with the controller's definition:

import { ToolController } from "../../core";
import { versionCommand } from "./version";
import { updateCommand } from "./update";
import { runCommand } from "./run";

export const Foo: ToolController = {
    name: "foo",
    title: "Foo Tool",
    commands: [
        versionCommand,
        updateCommand,
        runCommand,
    ],
};

Create installer.ts to implement all the code related to the tool installation:

import path from "path";
import fs from "fs";
import { Terminal, everdevHome } from "../../core";

function fooHome() {
    return path.resolve(everdevHome(), "foo");
}

async function ensureInstalled(terminal: Terminal) {
}

export async function getVersion(): Promise<string> {
    return "1.0.0";
}

export async function updateVersion(terminal: Terminal) {
    if (fs.existsSync(fooHome())) {
        fs.rmdirSync(fooHome(), { recursive: true });
    }
    ensureInstalled(terminal);
}

export async function runFoo(terminal: Terminal, workDir: string, args: string[]): Promise<void> {
    ensureInstalled(terminal);
    terminal.log("Foo succeeded");
};

Create version.ts command handler:

import { getVersion } from "./installer";
import { Command, Terminal } from "../../core";

export const versionCommand: Command = {
    name: "version",
    title: "Show Foo Version",
    async run(terminal: Terminal, _args: {}): Promise<void> {
        terminal.log(await getVersion());
    },
};

Create update.ts command handler:

import { updateVersion } from "./installer";
import { Command, Terminal } from "../../core";

export const versionCommand: Command = {
    name: "update",
    title: "Update Foo Version",
    async run(terminal: Terminal, _args: {}): Promise<void> {
        await updateVersion(terminal);
    },
};

Create run.ts command handler:

import { runFoo } from "./installer";
import { Command, Terminal } from "../../core";

export const runCommand: Command = {
    name: "run",
    title: "Run Foo",
    async run(terminal: Terminal, args: {}): Promise<void> {
        await runFoo(terminal, args);
    },
};

Controller API Reference

You can find API reference in form of TSDoc in src/core/index.ts.