tutorialModel progress

src/editor/commands/index.ts

@@ -22,11 +22,9 @@ const COMMANDS = {
 }
 
 interface CreateCommandProps {
-	context: vscode.ExtensionContext
+	vscodeExt: vscode.ExtensionContext
 	machine: CR.StateMachine
-	storage: any
 	git: any
-	position: any
 }
 
 const resetLayout = () => {
@@ -36,7 +34,7 @@ const resetLayout = () => {
 	})
 }
 
-export const createCommands = ({context, machine, storage, git, position}: CreateCommandProps) => {
+export const createCommands = ({vscodeExt, machine, git}: CreateCommandProps) => {
 	// React panel webview
 	let webview: any
 
@@ -55,10 +53,10 @@ export const createCommands = ({context, machine, storage, git, position}: Creat
 				webviewState = 'RESTARTING'
 			}
 
-			setStorage(context.workspaceState)
+			setStorage(vscodeExt.workspaceState)
 
 			// activate machine
-			webview = new ReactWebView(context.extensionPath)
+			webview = new ReactWebView(vscodeExt.extensionPath)
 			if (webviewState === 'INITIALIZING') {
 				machine.activate()
 			} else if (webviewState === 'RESTARTING') {
@@ -80,32 +78,30 @@ export const createCommands = ({context, machine, storage, git, position}: Creat
 		},
 		// launch a new tutorial
 		// NOTE: may be better to move into action as logic is primarily non-vscode
-		[COMMANDS.TUTORIAL_LAUNCH]: async (tutorial: G.Tutorial) => {
+		[COMMANDS.TUTORIAL_LAUNCH]: async (repo: G.TutorialRepo) => {
 			console.log('launch tutorial')
 
 			await isEmptyWorkspace()
 
 			await git.gitInitIfNotExists()
 
-			if (!tutorial.repo || !tutorial.repo.uri) {
+			if (!repo || !repo.uri) {
 				throw new Error('Tutorial repo uri not found')
 			}
 
-			// TODO: use actual tutorial repo
-			await Promise.all([git.gitSetupRemote(tutorial.repo.uri), storage.setTutorial(tutorial), storage.resetProgress()])
+			await git.gitSetupRemote(repo.uri)
 
 			machine.send('TUTORIAL_LOADED')
 		},
-		[COMMANDS.TUTORIAL_SETUP]: async (tutorial: G.Tutorial) => {
+		[COMMANDS.TUTORIAL_SETUP]: async (codingLanguage: G.EnumCodingLanguage) => {
 
 			// TODO: allow multiple coding languages in a tutorial
-			console.log('tutorial setup', tutorial)
+
 			// setup onSave hook
-			const languageId = tutorial.codingLanguage
 			// console.log(`languageIds: ${languageIds.join(', ')}`)
 			vscode.workspace.onDidSaveTextDocument((document: vscode.TextDocument) => {
 				console.log('save document', document)
-				if (document.uri.scheme === 'file' && languageId === document.languageId) {
+				if (document.uri.scheme === 'file' && codingLanguage === document.languageId) {
 					// do work
 					machine.send('TEST_RUN')
 				}

src/editor/commands/loadSolution.ts

@@ -1,21 +1,32 @@
 import * as CR from 'typings'
+import * as G from 'typings/graphql'
 import * as storage from '../../services/storage'
-import { gitLoadCommits, gitClear } from '../../services/git'
+import {gitLoadCommits, gitClear} from '../../services/git'
 
 export default async function loadSolution(dispatch: CR.EditorDispatch): Promise<void> {
-  const [position, tutorial]: [CR.Position, CR.Tutorial | undefined] = await Promise.all([
-    storage.getPosition(),
-    storage.getTutorial(),
-  ])
-  if (!position) {
-    throw new Error('No tutorial position state found')
-  }
-  if (!tutorial) {
-    throw new Error('Local tutorial not found')
-  }
-  // eslint-disable-next-line
-  const { solution } = tutorial.data.steps[position.stepId].actions
+	const [position, tutorial]: [CR.Position, G.Tutorial | undefined] = await Promise.all([
+		storage.getPosition(),
+		storage.getTutorial(),
+	])
+	if (!position) {
+		throw new Error('No tutorial position state found')
+	}
+	if (!tutorial || !tutorial.version || !tutorial.version.levels) {
+		throw new Error('Local tutorial not found')
+	}
+	// eslint-disable-next-line
+
+	try {
+		const solution = tutorial.version
+			.levels.find((l: G.Level) => l.id === position.levelId)
+			.stages.find((s: G.Stage) => s.id === position.stageId)
+			.steps.find((s: G.Step) => s.id === position.stepId)
+			.solution
+
+		await gitClear()
+		await gitLoadCommits(solution, dispatch)
+	} catch (error) {
+		throw new Error(error)
+	}
 
-  await gitClear()
-  await gitLoadCommits(solution, dispatch)
 }

src/editor/index.ts

@@ -1,69 +1,67 @@
 import * as vscode from 'vscode'
 import * as CR from 'typings'
-import { createCommands } from './commands'
+import {createCommands} from './commands'
 import * as storage from '../services/storage'
 import * as git from '../services/git'
 import * as position from '../services/position'
 
 interface Props {
-  machine: CR.StateMachine
-  setWorkspaceRoot(rootPath: string): void
+	machine: CR.StateMachine
+	setWorkspaceRoot(rootPath: string): void
 }
 
 class Editor {
-  // extension context set on activation
-  // @ts-ignore
-  private context: vscode.ExtensionContext
-  private machine: CR.StateMachine
+	// extension context set on activation
+	// @ts-ignore
+	private vscodeExt: vscode.ExtensionContext
+	private machine: CR.StateMachine
 
-  constructor({ machine, setWorkspaceRoot }: Props) {
-    this.machine = machine
+	constructor({machine, setWorkspaceRoot}: Props) {
+		this.machine = machine
 
-    // set workspace root for node executions
-    const { workspace } = vscode
-    const { rootPath } = workspace
-    if (!rootPath) {
-      throw new Error('Requires a workspace. Please open a folder')
-    }
-    setWorkspaceRoot(rootPath)
-  }
-  public activate = (context: vscode.ExtensionContext): void => {
-    console.log('ACTIVATE!')
-    this.context = context
-    // commands
-    this.activateCommands()
+		// set workspace root for node executions
+		const {workspace} = vscode
+		const {rootPath} = workspace
+		if (!rootPath) {
+			throw new Error('Requires a workspace. Please open a folder')
+		}
+		setWorkspaceRoot(rootPath)
+	}
+	public activate = (vscodeExt: vscode.ExtensionContext): void => {
+		console.log('ACTIVATE!')
+		this.vscodeExt = vscodeExt
+		// commands
+		this.activateCommands()
 
-    // setup tasks or views here
-  }
-  public deactivate = (): void => {
-    console.log('DEACTIVATE!')
-    // cleanup subscriptions/tasks
-    for (const disposable of this.context.subscriptions) {
-      disposable.dispose()
-    }
-    // shut down state machine
-    console.log('deactivate machine')
-    this.machine.deactivate()
-  }
+		// setup tasks or views here
+	}
+	public deactivate = (): void => {
+		console.log('DEACTIVATE!')
+		// cleanup subscriptions/tasks
+		for (const disposable of this.vscodeExt.subscriptions) {
+			disposable.dispose()
+		}
+		// shut down state machine
+		console.log('deactivate machine')
+		this.machine.deactivate()
+	}
 
-  // execute vscode command
-  public dispatch = (type: string, payload?: any) => {
-    vscode.commands.executeCommand(type, payload)
-  }
+	// execute vscode command
+	public dispatch = (type: string, payload?: any) => {
+		vscode.commands.executeCommand(type, payload)
+	}
 
-  private activateCommands = (): void => {
-    const commands = createCommands({
-      context: this.context,
-      machine: this.machine,
-      storage,
-      git,
-      position,
-    })
-    for (const cmd in commands) {
-      const command: vscode.Disposable = vscode.commands.registerCommand(cmd, commands[cmd])
-      this.context.subscriptions.push(command)
-    }
-  }
+	private activateCommands = (): void => {
+		const commands = createCommands({
+			vscodeExt: this.vscodeExt,
+			machine: this.machine,
+			git,
+		})
+		for (const cmd in commands) {
+			const command: vscode.Disposable = vscode.commands.registerCommand(cmd, commands[cmd])
+			this.vscodeExt.subscriptions.push(command)
+		}
+	}
 }
 
 export default Editor

src/extension.ts

@@ -1,10 +1,10 @@
 import * as vscode from 'vscode'
 import {setWorkspaceRoot} from './services/node'
-import Tutorial from './services/tutorial'
+import Tutorial, {TutorialModel} from './services/tutorial'
 import StateMachine from './state'
 import Editor from './editor'
 
-export const tutorial = new Tutorial()
+export const tutorial: TutorialModel = new Tutorial()
 // state machine that governs application logic
 export const machine = new StateMachine({dispatch: vscode.commands.executeCommand, tutorial})
 

src/services/storage.ts

@@ -1,77 +1,78 @@
 import * as CR from 'typings'
+import * as G from 'typings/graphql'
 import * as storage from '../editor/storage'
 
 // TUTORIAL
 const STORE_TUTORIAL = 'coderoad:tutorial'
 
-export async function getTutorial(): Promise<CR.Tutorial | undefined> {
-  return storage.get<CR.Tutorial>(STORE_TUTORIAL)
+export async function getTutorial(): Promise<G.Tutorial | undefined> {
+	return storage.get<G.Tutorial>(STORE_TUTORIAL)
 }
 
-export async function setTutorial(tutorial: CR.Tutorial): Promise<void> {
-  await storage.update<CR.Tutorial>(STORE_TUTORIAL, tutorial)
+export async function setTutorial(tutorial: G.Tutorial): Promise<void> {
+	await storage.update<G.Tutorial>(STORE_TUTORIAL, tutorial)
 }
 
 // POSITION
 const STORE_POSITION = 'coderoad:position'
 
-const defaultPosition = { levelId: '', stageId: '', stepId: '' }
+const defaultPosition = {levelId: '', stageId: '', stepId: ''}
 
 export async function getPosition(): Promise<CR.Position> {
-  const position: CR.Position | undefined = storage.get<CR.Position>(STORE_POSITION)
-  return position || defaultPosition
+	const position: CR.Position | undefined = storage.get<CR.Position>(STORE_POSITION)
+	return position || defaultPosition
 }
 
 export async function setPosition(position: CR.Position): Promise<void> {
-  await storage.update<CR.Position>(STORE_POSITION, position)
+	await storage.update<CR.Position>(STORE_POSITION, position)
 }
 
 // PROGRESS
 const STORE_PROGRESS = 'coderoad:progress'
 
-const defaultProgress = { levels: {}, stages: {}, steps: {}, hints: {}, complete: false }
+const defaultProgress = {levels: {}, stages: {}, steps: {}, hints: {}, complete: false}
 
 export async function getProgress(): Promise<CR.Progress> {
-  const progress: CR.Progress | undefined = await storage.get<CR.Progress>(STORE_PROGRESS)
-  return progress || defaultProgress
+	const progress: CR.Progress | undefined = await storage.get<CR.Progress>(STORE_PROGRESS)
+	return progress || defaultProgress
 }
 
 export async function resetProgress(): Promise<void> {
-  await storage.update<CR.Progress>(STORE_PROGRESS, defaultProgress)
+	await storage.update<CR.Progress>(STORE_PROGRESS, defaultProgress)
 }
 
 interface ProgressUpdate {
-  levels?: {
-    [levelId: string]: boolean
-  }
-  stages?: {
-    [stageid: string]: boolean
-  }
-  steps?: {
-    [stepId: string]: boolean
-  }
+	levels?: {
+		[levelId: string]: boolean
+	}
+	stages?: {
+		[stageid: string]: boolean
+	}
+	steps?: {
+		[stepId: string]: boolean
+	}
 }
 
 export async function setProgress(record: ProgressUpdate): Promise<void> {
-  const progress = await getProgress()
-  if (record.levels) {
-    progress.levels = {
-      ...progress.levels,
-      ...record.levels,
-    }
-  }
-  if (record.stages) {
-    progress.stages = {
-      ...progress.stages,
-      ...record.stages,
-    }
-  }
-  if (record.steps) {
-    progress.steps = {
-      ...progress.steps,
-      ...record.steps,
-    }
-  }
+	const progress = await getProgress()
+	if (record.levels) {
+		progress.levels = {
+			...progress.levels,
+			...record.levels,
+		}
+	}
+	if (record.stages) {
+		progress.stages = {
+			...progress.stages,
+			...record.stages,
+		}
+	}
+	if (record.steps) {
+		progress.steps = {
+			...progress.steps,
+			...record.steps,
+		}
+	}
 
-  await storage.update<CR.Progress>(STORE_PROGRESS, progress)
+	await storage.update<CR.Progress>(STORE_PROGRESS, progress)
 }