Merge pull request #417 from coderoad/feature/hooks

Feature/hooks

Author: ShMcK

src/actions/index.ts

@@ -5,5 +5,4 @@ export { default as onValidateSetup } from './onValidateSetup'
 export { default as onRunReset } from './onRunReset'
 export { default as onErrorPage } from './onErrorPage'
 export { onRunTest, onTestPass } from './onTest'
-export { onSetupActions, onSolutionActions } from './onActions'
 export { onOpenLogs } from './onOpenLogs'

src/actions/onActions.ts

@@ -5,6 +5,7 @@ import Context from './services/context/context'
 import logger from './services/logger'
 import { openWorkspace } from './services/workspace'
 import * as actions from './actions'
+import * as hooks from './services/hooks'
 
 interface Channel {
   receive(action: T.Action): Promise<void>
@@ -56,14 +57,12 @@ class Channel implements Channel {
       // load step actions (git commits, commands, open files)
       case 'SETUP_ACTIONS':
         await vscode.commands.executeCommand(COMMANDS.SET_CURRENT_POSITION, action.payload.position)
-        actions.onSetupActions({ actions: action.payload.actions, send: this.send })
+        hooks.onSetupEnter(action.payload.actions)
         return
       // load solution step actions (git commits, commands, open files)
       case 'SOLUTION_ACTIONS':
         await vscode.commands.executeCommand(COMMANDS.SET_CURRENT_POSITION, action.payload.position)
-        await actions.onSolutionActions({ actions: action.payload.actions, send: this.send })
-        // run test following solution to update position
-        actions.onRunTest()
+        hooks.onSolutionEnter(action.payload.actions)
         return
       case 'EDITOR_SYNC_POSITION':
         // update progress when a level is deemed complete in the client

src/channel.ts

@@ -2,9 +2,9 @@ import * as T from 'typings'
 import * as TT from 'typings/tutorial'
 import * as vscode from 'vscode'
 import createTestRunner from './services/testRunner'
-import { onSetupActions } from './actions/onActions'
 import createWebView from './services/webview'
 import logger from './services/logger'
+import * as hooks from './services/hooks'
 
 export const COMMANDS = {
   START: 'coderoad.start',
@@ -19,6 +19,16 @@ interface CreateCommandProps {
   workspaceState: vscode.Memento
 }
 
+let sendToClient = (action: T.Action): void => {
+  // function is replaced when webclient loads
+}
+
+// This makes it easier to pass the send
+// function throughout the codebase
+export const send = (action: T.Action): void => {
+  sendToClient(action)
+}
+
 export const createCommands = ({ extensionPath, workspaceState }: CreateCommandProps): { [key: string]: any } => {
   // React panel webview
   let webview: any
@@ -36,41 +46,37 @@ export const createCommands = ({ extensionPath, workspaceState }: CreateCommandP
           extensionPath,
           workspaceState,
         })
+        // make send to client function exportable
+        // as "send".
+        sendToClient = webview.send
       }
     },
     [COMMANDS.CONFIG_TEST_RUNNER]: async (data: TT.Tutorial) => {
-      const testRunnerConfig = data.config.testRunner
-      const setup = testRunnerConfig.setup || testRunnerConfig.actions // TODO: deprecate and remove config.actions
-      if (setup) {
-        // setup tutorial test runner commits
-        // assumes git already exists
-        await onSetupActions({
-          actions: setup,
-          send: webview.send,
-          dir: testRunnerConfig.directory || testRunnerConfig.path,
-        }) // TODO: deprecate and remove config.path
+      const setupActions = data.config.setup
+      if (setupActions) {
+        hooks.onInit(setupActions)
       }
       testRunner = createTestRunner(data, {
         onSuccess: (position: T.Position) => {
           logger('test pass position', position)
           // send test pass message back to client
-          webview.send({ type: 'TEST_PASS', payload: { position: { ...position, complete: true } } })
+          send({ type: 'TEST_PASS', payload: { position: { ...position, complete: true } } })
         },
         onFail: (position: T.Position, failSummary: T.TestFail): void => {
           // send test fail message back to client with failure message
-          webview.send({ type: 'TEST_FAIL', payload: { position, fail: failSummary } })
+          send({ type: 'TEST_FAIL', payload: { position, fail: failSummary } })
         },
         onError: (position: T.Position) => {
           // TODO: send test error message back to client
           const message = 'Error with test runner'
-          webview.send({ type: 'TEST_ERROR', payload: { position, message } })
+          send({ type: 'TEST_ERROR', payload: { position, message } })
         },
         onRun: (position: T.Position) => {
           // send test run message back to client
-          webview.send({ type: 'TEST_RUNNING', payload: { position } })
+          send({ type: 'TEST_RUNNING', payload: { position } })
         },
         onLoadSubtasks: ({ summary }) => {
-          webview.send({ type: 'LOAD_SUBTASK_RESULTS', payload: { summary } })
+          send({ type: 'LOAD_SUBTASK_RESULTS', payload: { summary } })
         },
       })
     },
@@ -85,7 +91,7 @@ export const createCommands = ({ extensionPath, workspaceState }: CreateCommandP
       testRunner({ position: currentPosition, onSuccess: callbacks?.onSuccess, subtasks })
     },
     [COMMANDS.ENTER]: () => {
-      webview.send({ type: 'KEY_PRESS_ENTER' })
+      send({ type: 'KEY_PRESS_ENTER' })
     },
   }
 }

src/commands.ts

@@ -0,0 +1,43 @@
+import * as TT from 'typings/tutorial'
+import * as git from '../git'
+import loadCommits from './utils/loadCommits'
+import loadWatchers from './utils/loadWatchers'
+import openFiles from './utils/openFiles'
+import runCommands from './utils/runCommands'
+import runVSCodeCommands from './utils/runVSCodeCommands'
+import { onError as telemetryOnError } from '../telemetry'
+import { onRunTest } from '../../actions/onTest'
+
+export const onInit = async (actions: TT.StepActions): Promise<void> => {
+  await loadCommits(actions.commits)
+  await runCommands(actions.commands)
+  await runVSCodeCommands(actions.vscodeCommands)
+}
+
+export const onLevelEnter = async (actions: TT.StepActions): Promise<void> => {
+  await loadCommits(actions.commits)
+  await runCommands(actions.commands)
+}
+
+export const onSetupEnter = async (actions: TT.StepActions): Promise<void> => {
+  // TODO: set position
+  await loadCommits(actions.commits)
+  await openFiles(actions.files)
+  await loadWatchers(actions.watchers)
+  await runCommands(actions.commands)
+  await runVSCodeCommands(actions.vscodeCommands)
+}
+
+export const onSolutionEnter = async (actions: TT.StepActions): Promise<void> => {
+  // TODO: set position
+  await git.clear()
+  await loadCommits(actions.commits)
+  await openFiles(actions.files)
+  await runCommands(actions.commands)
+  await runVSCodeCommands(actions.vscodeCommands)
+  await onRunTest()
+}
+
+export const onError = async (error: Error): Promise<void> => {
+  telemetryOnError(error)
+}

src/services/hooks/index.ts

@@ -0,0 +1,12 @@
+import * as git from '../../git'
+
+const loadCommits = async (commits: string[]): Promise<void> => {
+  if (commits) {
+    // load the current list of commits for validation
+    for (const commit of commits) {
+      await git.loadCommit(commit)
+    }
+  }
+}
+
+export default loadCommits

src/services/hooks/utils/loadCommits.ts

@@ -1,7 +1,7 @@
 import * as chokidar from 'chokidar'
 import * as vscode from 'vscode'
-import { COMMANDS } from '../../commands'
-import { WORKSPACE_ROOT } from '../../environment'
+import { COMMANDS } from '../../../commands'
+import { WORKSPACE_ROOT } from '../../../environment'
 
 // NOTE: vscode createFileWatcher doesn't seem to detect changes outside of vscode
 // such as `npm install` of a package. Went with chokidar instead
@@ -14,7 +14,7 @@ const disposeWatcher = (watcher: string) => {
   delete watcherObject[watcher]
 }
 
-const loadWatchers = (watchers: string[]): void => {
+const loadWatchers = (watchers: string[] = []): void => {
   if (!watchers.length) {
     // remove all watchers
     for (const watcher of Object.keys(watcherObject)) {

src/actions/utils/loadWatchers.ts renamed to src/services/hooks/utils/loadWatchers.ts

@@ -1,8 +1,7 @@
 import { join } from 'path'
 import * as vscode from 'vscode'
-import { COMMANDS } from '../../commands'
 
-const openFiles = async (files: string[]): Promise<void> => {
+const openFiles = async (files: string[] = []): Promise<void> => {
   if (!files.length) {
     return
   }

src/actions/utils/openFiles.ts renamed to src/services/hooks/utils/openFiles.ts

@@ -1,13 +1,7 @@
-import * as T from 'typings'
-import { exec } from '../../services/node'
+import { exec } from '../../node'
+import { send } from '../../../commands'
 
-interface RunCommands {
-  commands: string[]
-  send: (action: T.Action) => void
-  dir?: string
-}
-
-const runCommands = async ({ commands, send, dir }: RunCommands): Promise<void> => {
+const runCommands = async (commands: string[] = []): Promise<void> => {
   if (!commands.length) {
     return
   }
@@ -19,10 +13,10 @@ const runCommands = async ({ commands, send, dir }: RunCommands): Promise<void>
     send({ type: 'COMMAND_START', payload: { process: { ...process, status: 'RUNNING' } } })
     let result: { stdout: string; stderr: string }
     try {
-      result = await exec({ command, dir })
+      result = await exec({ command })
       console.log(result)
     } catch (error) {
-      console.log(`Test failed: ${error.message}`)
+      console.error(`Command failed: ${error.message}`)
       send({ type: 'COMMAND_FAIL', payload: { process: { ...process, status: 'FAIL' } } })
       return
     }

src/actions/utils/runCommands.ts renamed to src/services/hooks/utils/runCommands.ts

@@ -0,0 +1,26 @@
+import * as vscode from 'vscode'
+import * as TT from 'typings/tutorial'
+
+// what are VSCode commands?
+// - https://code.visualstudio.com/api/references/vscode-api#commands
+// a list of commands:
+// - https://code.visualstudio.com/api/references/commands (note many take params)
+// - https://code.visualstudio.com/docs/getstarted/keybindings (anything keybound is a command)
+
+const runVSCodeCommands = async (commands: TT.VSCodeCommand[] = []): Promise<void> => {
+  if (!commands.length) {
+    return
+  }
+  for (const command of commands) {
+    if (typeof command === 'string') {
+      // string named commands
+      await vscode.commands.executeCommand(command)
+    } else if (Array.isArray(command)) {
+      // array commands with params
+      const [name, params] = command
+      await vscode.commands.executeCommand(name, params)
+    }
+  }
+}
+
+export default runVSCodeCommands