@learnpack/learnpack 1.0.0 → 2.0.0

package/src/utils/errors.ts

@@ -0,0 +1,117 @@
+import Console from './console'
+
+import {ISolution, IError} from '../models/errors'
+
+// eslint-disable-next-line
+const fetch = require("node-fetch");
+
+let solutions: { [key: string]: ISolution } | null = null
+
+const uknown: ISolution = {
+  video: 'https://www.youtube.com/watch?v=gD1Sa99GiE4',
+  message: 'Uknown internal error',
+  slug: 'uknown',
+  gif: 'https://github.com/breatheco-de/breathecode-cli/blob/master/docs/errors/uknown.gif?raw=true',
+}
+
+export const getSolution = (slug?: string): ISolution => {
+  if (!slug) {
+    Console.debug('Getting solution templates from the learnpack repository')
+  } else {
+    Console.debug(`Getting solution for ${slug}`, solutions)
+  }
+
+  if (!solutions) {
+    Console.debug('Fetching for errors.json on github')
+    fetch(
+      'https://raw.githubusercontent.com/breatheco-de/breathecode-cli/master/docs/errors/errors.json',
+    )
+    .then((r: Response) => r.json())
+    .then(function (_s: { [key: string]: ISolution }) {
+      solutions = _s
+    })
+    return uknown
+  }
+
+  return typeof solutions[slug || ''] === 'undefined' || !slug ?
+    uknown :
+    solutions[slug]
+}
+
+export const ValidationError = (error: IError | string) => {
+  const message: string = (error as IError).message || (error as string)
+  const _err = new Error(message) as IError
+  _err.status = 400
+  _err.type = 'validation-error'
+
+  const sol: ISolution = getSolution((error as IError).slug)
+  _err.video = sol.video
+  _err.gif = sol.gif
+  _err.message = typeof message === 'string' ? message : sol.message
+  return _err
+}
+
+export const NotFoundError = (error: IError | string) => {
+  const message = (error as IError).message || (error as string)
+  const _err = new Error(message) as IError
+  _err.status = 400
+  _err.type = 'not-found-error'
+
+  const sol = getSolution((error as IError).slug)
+  _err.video = sol.video
+  _err.gif = sol.gif
+  _err.message = typeof message === 'string' ? message : sol.message
+  return _err
+}
+
+export const CompilerError = (error: IError | string) => {
+  const message = (error as IError).message || (error as string)
+  const _err = new Error(message) as IError
+  _err.status = 400
+  _err.type = 'compiler-error'
+
+  const sol = getSolution((error as IError).slug)
+  _err.video = sol.video
+  _err.gif = sol.gif
+  _err.message = typeof message === 'string' ? message : sol.message
+  return _err
+}
+
+export const TestingError = (error: IError | string) => {
+  const message = (error as IError).message || (error as string)
+  const _err = new Error(message) as IError
+  _err.status = 400
+  _err.type = 'testing-error'
+  return _err
+}
+
+export const AuthError = (error: IError | string) => {
+  const message = (error as IError).message || (error as string)
+  const _err = new Error(message) as IError
+  _err.status = 403
+  _err.type = 'auth-error'
+  return _err
+}
+
+export const InternalError = (error: IError | string) => {
+  const message = (error as IError).message || (error as string)
+  const _err = new Error(message) as IError
+  _err.status = 500
+  _err.type = 'internal-error'
+
+  const sol = getSolution((error as IError).slug)
+  _err.video = sol.video
+  _err.gif = sol.gif
+  _err.message = typeof message === 'string' ? message : sol.message
+  return _err
+}
+
+getSolution()
+export default {
+  ValidationError,
+  CompilerError,
+  TestingError,
+  NotFoundError,
+  InternalError,
+  AuthError,
+}

package/src/utils/{exercisesQueue.js → exercisesQueue.ts}

@@ -1,9 +1,14 @@
+import { IConfig } from "../models/config";
+import { IExercise } from "../models/exercise-obj";
+import { ISocket } from "../models/socket";
+
 class Exercise {
-  constructor(exercise) {
+  exercise: IExercise;
+  constructor(exercise: IExercise) {
     this.exercise = exercise;
   }
 
-  test(sessionConfig, config, socket) {
+  test(sessionConfig: IConfig, config: IConfig, socket: ISocket) {
     if (this.exercise.language) {
       socket.log(
         "testing",
@@ -17,14 +22,15 @@ class Exercise {
         exercise: this.exercise,
       });
     } else {
-      socket.onTestingFinised({ result: "success" });
+      socket.onTestingFinished({ result: "success" });
     }
   }
 }
 
 class ExercisesQueue {
-  constructor(exercises) {
-    this.exercises = exercises.map((exercise) => {
+  exercises: IExercise[];
+  constructor(exercises: any) {
+    this.exercises = exercises.map((exercise: IExercise) => {
       return new Exercise(exercise);
     });
   }
@@ -42,4 +48,4 @@ class ExercisesQueue {
   }
 }
 
-module.exports = ExercisesQueue;
+export default ExercisesQueue;

package/src/utils/fileQueue.ts

@@ -0,0 +1,198 @@
+import logger from "../utils/console";
+import * as fs from "fs";
+// import em from "events"
+import * as XXH from "xxhashjs";
+
+// possible events to dispatch
+const events = {
+  START_EXERCISE: "start_exercise",
+  INIT: "initializing",
+  RUNNING: "configuration_loaded",
+  END: "connection_ended",
+  RESET_EXERCISE: "reset_exercise",
+  OPEN_FILES: "open_files",
+  OPEN_WINDOW: "open_window",
+  INSTRUCTIONS_CLOSED: "instructions_closed",
+};
+
+let options = {
+  path: null,
+  create: false,
+};
+let lastHash: any = null;
+let watcher: any = null; // subscribe to file and listen to changes
+let actions: any = null; // action queue
+
+const loadDispatcher = (opts: any) => {
+  actions = [{ name: "initializing", time: now() }];
+  logger.debug(`Loading from ${opts.path}`);
+
+  let exists = fs.existsSync(opts.path);
+  if (opts.create) {
+    if (exists) 
+    actions.push({ name: "reset", time: now() });
+    fs.writeFileSync(opts.path, JSON.stringify(actions), { flag: "w" });
+    exists = true;
+  }
+
+  if (!exists)
+    throw new Error(`Invalid queue path, missing file at: ${opts.path}`);
+
+  let incomingActions = [];
+  try {
+    const content = fs.readFileSync(opts.path, "utf-8");
+    incomingActions = JSON.parse(content);
+    if (!Array.isArray(incomingActions)) 
+incomingActions = [];
+  } catch {
+    incomingActions = [];
+    logger.debug("Error loading VSCode Actions file");
+  }
+
+  logger.debug("Actions load ", incomingActions);
+  return incomingActions;
+};
+
+// eslint-disable-next-line
+const enqueue = (name: string, data: any | undefined = undefined) => {
+  if (!Object.values(events).includes(name)) {
+    logger.debug(`Invalid event ${name}`);
+    throw new Error(`Invalid action ${name}`);
+  }
+
+  if (!actions) 
+actions = [];
+
+  actions.push({ name, time: now(), data: data });
+  logger.debug(`EMIT -> ${name}:Exporting changes to ${options.path}`);
+
+  return fs.writeFileSync(options.path || "", JSON.stringify(actions));
+};
+
+const now = () => {
+  const hrTime = process.hrtime();
+  // eslint-disable-next-line
+  const htTime0 = hrTime[0] * 1000000;
+  return (htTime0 + hrTime[1]) / 1000;
+};
+
+const loadFile = (filePath: string) => {
+  if (!fs.existsSync(filePath))
+    throw new Error(`No queue.json file to load on ${filePath}`);
+
+  const content = fs.readFileSync(filePath, "utf8");
+  const newHash = XXH.h32(content, 0xAB_CD).toString(16);
+  const isUpdated = lastHash !== newHash;
+  lastHash = newHash;
+  const incomingActions = JSON.parse(content);
+  return { isUpdated, incomingActions };
+};
+
+const dequeue = () => {
+  // first time dequeue loads
+  if (!actions) 
+actions = [];
+
+  const { isUpdated, incomingActions } = loadFile(options.path || "");
+
+  if (!isUpdated) {
+    /**
+     * make sure no tasks are executed from the queue by matching both
+     * queues (the incoming with current one)
+     */
+    actions = incomingActions;
+    logger.debug(
+      `No new actions to process: ${actions.length}/${incomingActions.length}`
+    );
+    return null;
+  }
+
+  // do i need to reset actions to zero?
+  if (actions.length > 0 && actions[0].time !== incomingActions[0].time) {
+    actions = [];
+  }
+
+  const action = incomingActions[incomingActions.length - 1];
+  logger.debug("Dequeing action ", action);
+  actions.push(action);
+  return action;
+};
+
+const pull = (callback: (T: any) => any) => {
+  logger.debug("Pulling actions");
+  let incoming = dequeue();
+  while (incoming) {
+    callback(incoming);
+    incoming = dequeue();
+  }
+};
+
+const reset = (callback: (T?: any) => any) => {
+  logger.debug("Queue reseted");
+  actions = [];
+  if (fs.existsSync(options.path || "")) {
+    fs.writeFileSync(options.path || "", "[]");
+    callback();
+  }
+};
+
+const onPull = (callback: (T?: any) => any) => {
+  // eslint-disable-next-line
+  const chokidar = require("chokidar");
+
+  logger.debug("Starting to listen...");
+  try {
+    loadFile(options.path || "");
+  } catch {
+    logger.debug("No previeues queue file, waiting for it to be created...");
+  }
+
+  if (!watcher) {
+    logger.debug(`Watching ${options.path}`);
+    watcher = chokidar.watch(`${options.path}`, {
+      persistent: true,
+    });
+  } else 
+logger.debug("Already watching queue path");
+
+  watcher.on("add", () => pull(callback)).on("change", () => pull(callback));
+
+  return true;
+};
+
+const onReset = (callback: (T?: any) => any) => {
+  // eslint-disable-next-line
+  const chokidar = require("chokidar");
+
+  if (!watcher) {
+    logger.debug(`Watching ${options.path}`);
+    watcher = chokidar.watch(`${options.path}`, {
+      persistent: true,
+    });
+  }
+
+  watcher.on("unlink", () => reset(callback));
+
+  return true;
+};
+
+export default {
+  events,
+  dispatcher: (opts: any = {}) => {
+    if (!actions) {
+      options = { ...options, ...opts };
+      logger.debug("Initializing queue dispatcher", options);
+      actions = loadDispatcher(options);
+    }
+
+    return { enqueue, events };
+  },
+  listener: (opts: any = {}) => {
+    if (!actions) {
+      options = { ...options, ...opts };
+      logger.debug("Initializing queue listener", options);
+    }
+
+    return { onPull, onReset, events };
+  },
+};

package/src/utils/misc.ts

@@ -0,0 +1,23 @@
+export const prioritizeHTMLFile = (entryFiles: string[]) => {
+  let files = []
+
+  // Find the html file and put it as latest in the files array
+  // in order to keep the html file opened in vscode plugin
+  const index = entryFiles.findIndex(file => {
+    return /.*\.html$/.test(file)
+  })
+
+  if (index !== -1) {
+    for (const [i, entryFile] of entryFiles.entries()) {
+      if (i !== index) {
+        files.push(entryFile)
+      }
+    }
+
+    files.push(entryFiles[index])
+  } else {
+    files = entryFiles
+  }
+
+  return files
+}

package/src/utils/templates/incremental/.learn/exercises/01-hello-world/README.es.md

@@ -1,10 +1,9 @@
-# `01` Hola Mundo
+# `01` Hello World
 
 Puedes tener un archivo README el cual será como una página de un libro, sin archivos de código.
 
 También puedes agregar un archivo `README.[lenguaje].md` para traducciones, por ejemplo `README.es.md` para español.
 
-
 ## Inserta videos
 
 Si quieres incluir algún video introductorio para cada ejercicio, agrega la propiedad `intro` en el inicio del README.md para ese ejercicio en particular:
@@ -17,10 +16,9 @@ intro: "https://www.youtube.com/watch?v=YkgkThdzX-8"
 
 Tambien puedes agregar un video explicando la solución para cada ejercicio agregando la propiedad `tutorial` al inicio del markdown del README.md correspondiente:
 
-
 ```markdown
 ---
 intro: "https://www.youtube.com/watch?v=YkgkThdzX-8"
 tutorial: "https://www.youtube.com/watch?v=YkgkThdzX-8"
 ---
-```
+```

package/src/utils/templates/incremental/.learn/exercises/01-hello-world/README.md

@@ -16,10 +16,9 @@ intro: "https://www.youtube.com/watch?v=YkgkThdzX-8"
 
 You can also add a video solution for each exercise by adding a `tutorial` property on the markdown frontmatter of it's README.md:
 
-
 ```markdown
 ---
 intro: "https://www.youtube.com/watch?v=YkgkThdzX-8"
 tutorial: "https://www.youtube.com/watch?v=YkgkThdzX-8"
 ---
-```
+```

package/src/utils/templates/isolated/01-hello-world/README.es.md

@@ -18,10 +18,9 @@ intro: "https://www.youtube.com/watch?v=YkgkThdzX-8"
 
 Tambien puedes agregar un video explicando la solución para cada ejercicio agregando la propiedad `tutorial` al inicio del markdown del README.md correspondiente:
 
-
 ```markdown
 ---
 intro: "https://www.youtube.com/watch?v=YkgkThdzX-8"
 tutorial: "https://www.youtube.com/watch?v=YkgkThdzX-8"
 ---
-```
+```

package/src/utils/templates/isolated/01-hello-world/README.md

@@ -18,10 +18,9 @@ intro: "https://www.youtube.com/watch?v=YkgkThdzX-8"
 
 You can also add a video solution for each exercise by adding a `tutorial` property on the markdown frontmatter of it's README.md:
 
-
 ```markdown
 ---
 intro: "https://www.youtube.com/watch?v=YkgkThdzX-8"
 tutorial: "https://www.youtube.com/watch?v=YkgkThdzX-8"
 ---
-```
+```

package/src/utils/templates/isolated/README.ejs

@@ -1,5 +1,5 @@
 # Welcome to <%= it.title %>
 
-You have initialized the exercises with grading=`isolated`, that basically means that your students will completed one exercise after the other with new files every time.
+You have initialized the exercises with grading=`incremental`; meaning that your students will complete one single tutorial with clear and autograded steps from beginning to end.
 
 Type `$ learnpack start` in your terminal to start the exercises.

package/src/utils/templates/isolated/README.es.ejs

@@ -1,5 +1,5 @@
 # Bienvenido a <%= it.title %>
 
-Has inicializado los ejercicios con grading=`isolated`; lo que signigica que tus estudiantes completarán un ejercicio tras otro, en archivos nuevos cada vez.
+Has inicializado los ejercicios con grading=`incremental`; esto signigica que tus estudiantes completarán un solo tutorial con pasos claros e incrementales, desde el comienzo hasta el final.
 
 Ejecuta `$ learnpack start` en la terminal para comenzar con los ejercicios.

package/src/utils/validators.ts

@@ -0,0 +1,18 @@
+export function validURL(str: string) {
+  if (!str.includes('github.com')) {
+    return false
+  }
+
+  const pattern = new RegExp(
+    '^(https?:\\/\\/)?' + // protocol
+      '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|' + // domain name
+      '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
+      '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*' + // port and path
+      '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
+      '(\\#[-a-z\\d_]*)?$',
+    'i',
+  ) // fragment locator
+  return !!pattern.test(str)
+}
+
+export default {validURL}

package/src/utils/watcher.ts

@@ -0,0 +1,27 @@
+import * as chokidar from "chokidar";
+import * as debounce from "debounce";
+
+export default (path: string) =>
+  new Promise((resolve /* , reject */) => {
+    const watcher = chokidar.watch(path, {
+      // TODO: This watcher is not ready yet
+      // ignored: (_path: string, _stats: any) => {
+      //   return new RegExp(_path)
+      // },
+      persistent: true,
+      depth: 1,
+      ignoreInitial: true,
+    });
+
+    const onChange = (eventname: string, _filename: string) => {
+      resolve(eventname /* , filename */);
+    };
+
+    watcher.on("all", debounce(onChange, 500, true));
+    // watcher.on('all', onChange)
+
+    process.on("SIGINT", function () {
+      watcher.close();
+      process.exit();
+    });
+  });

package/plugin/command/compile.js

@@ -1,17 +0,0 @@
-
-const CompilationError = (messages) => {
-    const _err = new Error(messages)
-    _err.status = 400
-    _err.stdout = messages
-    _err.type = 'compiler-error'
-    return _err
-}
-
-module.exports = {
-    CompilationError,
-    default: async ({ action, ...rest }) => {
-
-        const stdout = await action.run(rest)
-        return stdout
-    }
-}

package/plugin/command/test.js

@@ -1,29 +0,0 @@
-const fs = require('fs')
-
-const TestingError = (messages) => {
-    const _err = new Error(messages)
-    _err.status = 400
-    _err.stdout = messages
-    _err.type = 'testing-error'
-    return _err
-}
-
-module.exports = {
-  TestingError,
-  default: async function(args){
-    const { action, configuration, socket, exercise } = args;
-
-    if (!fs.existsSync(`${configuration.dirPath}/reports`)){
-      // reports directory
-      fs.mkdirSync(`${configuration.dirPath}/reports`);
-    }
-
-    // compile
-    const stdout = await action.run(args)
-
-    // mark exercise as done
-    exercise.done = true;
-
-    return stdout
-  }
-}

package/plugin/index.js

@@ -1,6 +0,0 @@
-const { CompilationError } = require("./command/compile")
-const { TestingError } = require("./command/test")
-const utils = require("./utils")
-const plugin = require("./plugin")
-
-module.exports = { CompilationError, TestingError, Utils: utils, plugin }

package/plugin/plugin.js

@@ -1,71 +0,0 @@
-const shell = require('shelljs')
-/**
- * Main Plugin Runner, it defines the behavior of a learnpack plugin
- * dividing it in "actions" like: Compile, test, etc.
- * @param {object} pluginConfig Configuration object that must defined language and each possible action.
- */
-module.exports = (pluginConfig) => {
-  return async (args) => {
-    const { action, exercise, socket, configuration } = args
-
-    
-    if(pluginConfig.language === undefined) throw Error(`Missing language on the plugin configuration object`)
-    
-    if(typeof action !== "string"){
-      throw Error("Missing action property on hook details")
-    } 
-    
-    if(!exercise || exercise === undefined){
-      throw Error("Missing exercise information")
-    }
-    
-    // if the action does not exist I don't do anything
-    if(pluginConfig[action] === undefined){
-      console.log(`Ignoring ${action}`)
-      return () => null
-    } 
-    
-    // ignore if the plugin language its not the same as the exercise language
-    if(exercise.language !== pluginConfig.language){
-      return () => null
-    }
-    
-    if( !exercise.files || exercise.files.length == 0){
-      throw Error(`No files to process`)
-    } 
-  
-      try{
-        const _action = pluginConfig[action]
-
-        if(_action == null || typeof _action != 'object') throw Error(`The ${pluginConfig.language} ${action} module must export an object configuration`)
-        if(_action.validate === undefined) throw Error(`Missing validate method for ${pluginConfig.language} ${action}`)
-        if(_action.run === undefined) throw Error(`Missing run method for ${pluginConfig.language} ${action}`)
-        if(_action.dependencies !== undefined){
-          if(!Array.isArray(_action.dependencies)) throw Error(`${action}.dependencies must be an array of package names`)
-      
-          _action.dependencies.forEach(packageName => {
-              if (!shell.which(packageName)) {
-              throw Error(`🚫 You need to have ${packageName} installed to run test the exercises`);
-              }
-          })
-      }
-        const valid = await _action.validate(({ exercise, configuration }))
-        if(valid){
-          // look for the command standard implementation and execute it
-          const execute = require("./command/"+action+".js").default
-          // no matter the command, the response must always be a stdout
-          const stdout = await execute({ ...args, action: _action, configuration })
-
-          // Map the action names to socket messaging standards
-          const actionToSuccessMapper = { compile: 'compiler', test: 'testing' }
-
-          socket.success(actionToSuccessMapper[action], stdout)
-          return stdout
-        }
-      }
-      catch(error){
-        if(error.type == undefined) socket.fatal(error)
-        else socket.error(error.type, error.stdout)
-      }
-    }
-  }