Merge pull request #414 from coderoad/feature/remove-progress

Feature/remove progress

Author: ShMcK

CHANGELOG.md

@@ -236,3 +236,8 @@ Adds a review page for viewing tutorial content. The review page should be espec
 - Launch from URL fixes
 - Move styles into a central theme
 - Prevent multiple versions of CodeRoad from launching
+
+### [0.13.0]
+
+- Significant internal refactor to remove recording progress
+- Admin mode to allow creators to jump between tutorial levels/steps during development

src/actions/index.ts

@@ -1,6 +1,6 @@
 export { default as onStartup } from './onStartup'
-export { default as onTutorialConfig } from './onTutorialConfig'
-export { default as onTutorialContinueConfig } from './onTutorialContinueConfig'
+export { default as onTutorialConfigNew } from './onTutorialConfigNew'
+export { default as onTutorialConfigContinue } from './onTutorialConfigContinue'
 export { default as onValidateSetup } from './onValidateSetup'
 export { default as onRunReset } from './onRunReset'
 export { default as onErrorPage } from './onErrorPage'

src/actions/onStartup.ts

@@ -41,32 +41,26 @@ const onStartup = async (
     // no stored tutorial, must start new tutorial
     if (!tutorial || !tutorial.id) {
       if (TUTORIAL_URL) {
-        // launch from a url env variable
+        // NEW_FROM_URL
         try {
           const tutorialRes = await fetch(TUTORIAL_URL)
           const tutorial = await tutorialRes.json()
           send({ type: 'START_TUTORIAL_FROM_URL', payload: { tutorial } })
+          return
         } catch (e) {
+          // on failure to load a tutorial url fallback to NEW
           console.log(`Failed to load tutorial from url ${TUTORIAL_URL} with error "${e.message}"`)
         }
-      } else {
-        // launch from a selected tutorial
-        send({ type: 'START_NEW_TUTORIAL', payload: { env } })
       }
+      // NEW
+      send({ type: 'START_NEW_TUTORIAL', payload: { env } })
       return
     }
 
-    // load continued tutorial position & progress
-    const { position, progress } = await context.setTutorial(workspaceState, tutorial)
-    logger('CONTINUE STATE', position, progress)
-
-    if (progress.complete) {
-      // tutorial is already complete
-      send({ type: 'TUTORIAL_ALREADY_COMPLETE', payload: { env } })
-      return
-    }
+    // CONTINUE_FROM_PROGRESS
+    const { position } = await context.onContinue(tutorial)
     // communicate to client the tutorial & stepProgress state
-    send({ type: 'LOAD_STORED_TUTORIAL', payload: { env, tutorial, progress, position } })
+    send({ type: 'LOAD_STORED_TUTORIAL', payload: { env, tutorial, position } })
   } catch (e) {
     const error = {
       type: 'UnknownError',

src/actions/onTest.ts

@@ -5,13 +5,7 @@ import { COMMANDS } from '../commands'
 import Context from '../services/context/context'
 
 export const onTestPass = (action: T.Action, context: Context) => {
-  const tutorial = context.tutorial.get()
-  if (!tutorial) {
-    throw new Error('Error with current tutorial. Tutorial may be missing an id.')
-  }
-  // update local storage stepProgress
-  const progress = context.progress.setStepComplete(tutorial, action.payload.position.stepId)
-  context.position.setPositionFromProgress(tutorial, progress)
+  context.position.set({ ...action.payload.position, complete: true })
   git.saveCommit('Save progress')
 }
 

src/actions/onTutorialContinueConfig.ts renamed to src/actions/onTutorialConfigContinue.ts

@@ -5,7 +5,7 @@ import Context from '../services/context/context'
 import tutorialConfig from './utils/tutorialConfig'
 import { COMMANDS } from '../commands'
 
-const onTutorialContinueConfig = async (action: T.Action, context: Context, send: any) => {
+const onTutorialConfigContinue = async (action: T.Action, context: Context, send: any) => {
   try {
     const tutorialContinue: TT.Tutorial | null = context.tutorial.get()
     if (!tutorialContinue) {
@@ -26,4 +26,4 @@ const onTutorialContinueConfig = async (action: T.Action, context: Context, send
   }
 }
 
-export default onTutorialContinueConfig
+export default onTutorialConfigContinue

src/actions/onTutorialConfig.ts renamed to src/actions/onTutorialConfigNew.ts

@@ -8,7 +8,7 @@ import { version, compareVersions } from '../services/dependencies'
 import Context from '../services/context/context'
 import tutorialConfig from './utils/tutorialConfig'
 
-const onTutorialConfig = async (action: T.Action, context: Context, workspaceState: vscode.Memento, send: any) => {
+const onTutorialConfigNew = async (action: T.Action, context: Context, send: any) => {
   try {
     const data: TT.Tutorial = action.payload.tutorial
 
@@ -37,7 +37,7 @@ const onTutorialConfig = async (action: T.Action, context: Context, workspaceSta
     }
 
     // setup tutorial config (save watcher, test runner, etc)
-    await context.setTutorial(workspaceState, data)
+    await context.onNew(data)
 
     // validate dependencies
     const dependencies = data.config.dependencies
@@ -118,4 +118,4 @@ const onTutorialConfig = async (action: T.Action, context: Context, workspaceSta
   }
 }
 
-export default onTutorialConfig
+export default onTutorialConfigNew

src/channel.ts

@@ -40,16 +40,12 @@ class Channel implements Channel {
         actions.onStartup(this.context, this.workspaceState, this.send)
         return
       // clear tutorial local storage
-      case 'TUTORIAL_CLEAR':
-        // clear current progress/position/tutorial
-        this.context.reset()
-        return
       // configure test runner, language, git
       case 'EDITOR_TUTORIAL_CONFIG':
-        actions.onTutorialConfig(action, this.context, this.workspaceState, this.send)
+        actions.onTutorialConfigNew(action, this.context, this.send)
         return
       case 'EDITOR_TUTORIAL_CONTINUE_CONFIG':
-        actions.onTutorialContinueConfig(action, this.context, this.send)
+        actions.onTutorialConfigContinue(action, this.context, this.send)
         return
       case 'EDITOR_VALIDATE_SETUP':
         actions.onValidateSetup(this.send)
@@ -69,9 +65,9 @@ class Channel implements Channel {
         // run test following solution to update position
         actions.onRunTest()
         return
-      case 'EDITOR_SYNC_PROGRESS':
+      case 'EDITOR_SYNC_POSITION':
         // update progress when a level is deemed complete in the client
-        await this.context.progress.syncProgress(action.payload.progress)
+        await this.context.position.set(action.payload.position)
         return
       case 'EDITOR_OPEN_LOGS':
         actions.onOpenLogs(action)

src/commands.ts

@@ -54,7 +54,7 @@ export const createCommands = ({ extensionPath, workspaceState }: CreateCommandP
         onSuccess: (position: T.Position) => {
           logger('test pass position', position)
           // send test pass message back to client
-          webview.send({ type: 'TEST_PASS', payload: { position } })
+          webview.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
@@ -82,13 +82,6 @@ export const createCommands = ({ extensionPath, workspaceState }: CreateCommandP
       subtasks,
       callbacks,
     }: { subtasks?: boolean; callbacks?: { onSuccess: () => void } } = {}) => {
-      logger('run test current', currentPosition)
-      // use stepId from client, or last set stepId
-      // const position: T.Position = {
-      //   ...current,
-      //   stepId: current && current.position.stepId?.length ? current.position.stepId : currentPosition.stepId,
-      // }
-      logger('currentPosition', currentPosition)
       testRunner({ position: currentPosition, onSuccess: callbacks?.onSuccess, subtasks })
     },
     [COMMANDS.ENTER]: () => {

src/services/context/context.ts

@@ -1,33 +1,27 @@
-import * as CR from 'typings'
+import * as T from 'typings'
 import * as TT from 'typings/tutorial'
 import * as vscode from 'vscode'
 import Position from './state/Position'
-import Progress from './state/Progress'
 import Tutorial from './state/Tutorial'
 
 class Context {
   public tutorial: Tutorial
   public position: Position
-  public progress: Progress
+  private workspaceState: vscode.Memento
   constructor(workspaceState: vscode.Memento) {
     // state held in one place
+    this.workspaceState = workspaceState
     this.tutorial = new Tutorial(workspaceState)
     this.position = new Position()
-    this.progress = new Progress()
   }
-  public setTutorial = async (
-    workspaceState: vscode.Memento,
-    tutorial: TT.Tutorial,
-  ): Promise<{ progress: CR.Progress; position: CR.Position }> => {
+  public onNew = async (tutorial: TT.Tutorial): Promise<{ position: T.Position }> => {
     this.tutorial.set(tutorial)
-    const progress: CR.Progress = await this.progress.setTutorial(workspaceState, tutorial)
-    const position: CR.Position = this.position.setPositionFromProgress(tutorial, progress)
-    return { progress, position }
+    const position: T.Position = await this.position.initPosition(this.workspaceState, tutorial)
+    return { position }
   }
-  public reset = (): void => {
-    this.tutorial.reset()
-    this.progress.reset()
-    this.position.reset()
+  public onContinue = async (tutorial: TT.Tutorial): Promise<{ position: T.Position }> => {
+    const position: T.Position = await this.position.continuePosition(this.workspaceState, tutorial)
+    return { position }
   }
 }
 

src/services/context/state/Position.ts

@@ -1,78 +1,54 @@
-import * as CR from 'typings'
+import * as vscode from 'vscode'
+import * as T from 'typings'
 import * as TT from 'typings/tutorial'
+import Storage from '../../storage'
 
-const defaultValue: CR.Position = {
+const defaultValue: T.Position = {
   levelId: '',
   stepId: null,
+  complete: false,
 }
 
 // position
 class Position {
-  private value: CR.Position
+  private value: T.Position
+  private storage: Storage<T.Position> | undefined
   constructor() {
     this.value = defaultValue
   }
+  setTutorial(workspaceState: vscode.Memento, tutorial: TT.Tutorial) {
+    this.storage = new Storage<T.Position>({
+      key: `coderoad:position:${tutorial.id}:${tutorial.version}`,
+      storage: workspaceState,
+      defaultValue,
+    })
+  }
+  async initPosition(workspaceState: vscode.Memento, tutorial: TT.Tutorial): Promise<T.Position> {
+    // set value from storage
+    this.setTutorial(workspaceState, tutorial)
+    // find first level & step id
+    let initLevel = tutorial.levels.length ? tutorial.levels[0] : null
+    return this.set({
+      levelId: initLevel?.id || '',
+      stepId: initLevel?.steps.length ? initLevel.steps[0].id : null,
+      complete: false,
+    })
+  }
+  async continuePosition(workspaceState: vscode.Memento, tutorial: TT.Tutorial): Promise<T.Position> {
+    this.setTutorial(workspaceState, tutorial)
+    let position: T.Position = (await this.storage?.get()) || defaultValue
+    return this.set(position)
+  }
   public get = () => {
     return this.value
   }
-  public set = (value: CR.Position) => {
+  public set = (value: T.Position) => {
     this.value = value
+    this.storage?.set(value)
+    return this.value
   }
   public reset = () => {
-    this.value = defaultValue
-  }
-  // calculate the current position based on the saved progress
-  public setPositionFromProgress = (tutorial: TT.Tutorial, progress: CR.Progress): CR.Position => {
-    // tutorial already completed
-    // TODO handle start again?
-    if (progress.complete) {
-      return this.value
-    }
-
-    if (!tutorial || !tutorial.levels) {
-      throw new Error('Error setting position from progress')
-    }
-
-    // get level
-    const { levels } = tutorial
-    const lastLevelIndex: number | undefined = levels.findIndex((l: TT.Level) => !progress.levels[l.id])
-    if (lastLevelIndex >= levels.length) {
-      throw new Error('Error setting progress level')
-    }
-
-    // get step
-    const currentLevel: TT.Level = levels[lastLevelIndex]
-    if (!currentLevel) {
-      // tutorial complete but not reached completed view
-      const finalLevel = levels[levels.length - 1]
-      return {
-        levelId: finalLevel.id,
-        stepId: finalLevel.steps.length ? finalLevel.steps[finalLevel.steps.length - 1].id : null,
-        complete: true,
-      }
-    }
-    let currentStepId: string | null
-    if (!currentLevel.steps.length) {
-      // no steps available for level
-      currentStepId = null
-    } else {
-      // find current step id
-      const { steps } = currentLevel
-      const lastStepIndex: number | undefined = steps.findIndex((s: TT.Step) => !progress.steps[s.id])
-      if (lastStepIndex >= steps.length) {
-        throw new Error('Error setting progress step')
-      }
-      // handle position when last step is complete but "continue" not yet selected
-      const adjustedLastStepIndex = lastStepIndex === -1 ? steps.length - 1 : lastStepIndex
-      currentStepId = steps[adjustedLastStepIndex].id
-    }
-
-    this.value = {
-      levelId: currentLevel.id,
-      stepId: currentStepId,
-    }
-
-    return this.value
+    return this.set(defaultValue)
   }
 }