@learnpack/learnpack 1.0.0

package/src/managers/server/index.js

@@ -0,0 +1,62 @@
+const express = require("express");
+const Console = require("../../utils/console");
+const cors = require("cors");
+const shell = require("shelljs");
+const addRoutes = require("./routes.js");
+const cli = require("cli-ux").default;
+
+module.exports = async function (
+  configObj,
+  configManager,
+  isTestingEnvironment = false
+) {
+  const { config } = configObj;
+  var app = express();
+  var server = require("http").Server(app);
+  app.use(cors());
+  // app.use(function(req, res, next) {
+  //     res.header("Access-Control-Allow-Origin", "*")
+  //     res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
+  //     res.header("Access-Control-Allow-Methods", "GET,PUT")
+  //     next()
+  // })
+
+  // add all needed endpoints
+  await addRoutes(app, configObj, configManager);
+
+  server.listen(isTestingEnvironment ? 5000 : config.port, function () {
+    if (!isTestingEnvironment) {
+      Console.success(
+        `Exercises are running 😃 Open your browser to start practicing!`
+      );
+      Console.success(`\n            Open the exercise on this link:`);
+      Console.log(`            ${config.publicUrl}`);
+      if (config.editor.mode === "standalone") cli.open(`${config.publicUrl}`);
+    }
+  });
+
+  const sockets = new Set();
+
+  server.on("connection", (socket) => {
+    sockets.add(socket);
+
+    server.once("close", () => {
+      sockets.delete(socket);
+    });
+  });
+
+  /**
+   * Forcefully terminates HTTP server.
+   */
+  server.terminate = (callback) => {
+    for (const socket of sockets) {
+      socket.destroy();
+
+      sockets.delete(socket);
+    }
+
+    server.close(callback);
+  };
+
+  return server;
+};

package/src/managers/server/routes.js

@@ -0,0 +1,151 @@
+const Console = require('../../utils/console')
+const express = require('express')
+const fs = require('fs')
+const bodyParser = require('body-parser')
+const socket = require('../socket.js');
+const queue = require("../../utils/fileQueue")
+const { detect, filterFiles } = require("../config/exercise");
+
+const withHandler = (func) => (req, res) => {
+    try{
+      func(req, res)
+    }
+    catch(err){
+      Console.debug(err)
+      const _err = {
+        message: err.message || 'There has been an error' ,
+        status: err.status || 500,
+        type: err.type || null
+      }
+      Console.error(_err.message)
+
+      //send rep to the server
+      res.status(_err.status)
+      res.json(_err)
+    }
+}
+
+module.exports = async function(app, configObject, configManager){
+
+    const { config } = configObject;
+
+    // Dispatcher will communicate events to 3rd party apps that
+    // subscribe to the queue, you can read documentation about this queue here:
+    // https://github.com/alesanchezr/text-queue/blob/main/README.md
+    const dispatcher = queue.dispatcher({ create: true, path: `${config.dirPath}/vscode_queue.json` })
+
+    app.get('/config', withHandler((req, res)=>{
+        res.json(configObject)
+    }))
+
+    /**
+     * TODO: replicate a socket action, the request payload must be passed to the socket as well
+     */
+    const jsonBodyParser = bodyParser.json()
+    app.post('/socket/:actionName', jsonBodyParser, withHandler((req, res)=>{
+        if(socket[req.params.actionName] instanceof Function){
+            socket[req.params.actionName](req.body ? req.body.data : null)
+            res.json({ "details": "Socket call executed sucessfully"})
+        }else res.status(400).json({ "details": `Socket action ${req.params.actionName} not found`})
+    }))
+
+    //symbolic link to maintain path compatiblity
+    const fetchStaticAsset = withHandler((req, res) => {
+        let filePath = `${config.dirPath}/assets/${req.params.filePath}`
+        if (!fs.existsSync(filePath)) throw Error('File not found: '+filePath)
+        const content = fs.readFileSync(filePath)
+        res.write(content);
+        res.end();
+    })
+    app.get(`${config.dirPath.indexOf("./") === 0 ? config.dirPath.substring(1) : config.dirPath}/assets/:filePath`, fetchStaticAsset);
+    app.get('/assets/:filePath', fetchStaticAsset);
+
+    app.get('/exercise', withHandler((req, res) => {
+        res.json(configObject.exercises)
+    }))
+
+    app.get('/exercise/:slug/readme', withHandler((req, res) => {
+        const readme = configManager.getExercise(req.params.slug).getReadme(req.query.lang || null)
+        res.json(readme)
+    }))
+
+    app.get('/exercise/:slug/report', withHandler((req, res) => {
+        const report = configManager.getExercise(req.params.slug).getTestReport()
+        res.json(JSON.stringify(report))
+    }))
+
+    app.get('/exercise/:slug', withHandler((req, res) => {
+
+        // no need to re-start exercise if it's already started
+        if(configObject.currentExercise && req.params.slug === configObject.currentExercise){
+            let exercise = configManager.getExercise(req.params.slug)
+            res.json(exercise)
+            return;
+        }
+
+        let exercise = configManager.startExercise(req.params.slug)
+        dispatcher.enqueue(dispatcher.events.START_EXERCISE, req.params.slug)
+
+        const entries = Object.keys(config.entries).map(lang => config.entries[lang]);
+        
+        // if we are in incremental grading, the entry file can by dinamically detected
+        // based on the changes the student is making during the exercise
+        if(config.grading === "incremental"){
+            const scanedFiles = fs.readdirSync(`./`);
+            
+            // update the file hierarchy with updates
+            exercise.files = exercise.files.filter(f => f.name.includes("test.")).concat(filterFiles(scanedFiles))
+            Console.debug(`Exercise updated files: `, exercise.files)
+            
+        }
+        // detect lang
+        const detected = detect(configObject, exercise.files.filter(fileName => entries.includes(fileName.name || fileName)).map(f => f.name || f));
+        
+        //if a new language for the testing engine is detected, we replace it
+        // if not we leave it as it was before
+        if(configObject.language && !["", "auto"].includes(configObject.language)){
+            Console.debug(`Exercise language ignored, instead imported from configuration ${configObject.language}`)
+            exercise.language = detected.language;
+        }
+        else if(detected.language && (!configObject.language || configObject.language === "auto")){
+            Console.debug(`Switching to ${detected.language} engine in this exercise`)
+            exercise.language = detected.language;
+        } 
+
+        // WARNING: has to be the FULL PATH to the entry path
+        // We need to detect entry in both gradings: Incremental and Isolate
+        exercise.entry = detected.entry;
+        Console.debug(`Exercise detected entry: ${detected.entry} and language ${exercise.language}`)
+
+        if(!exercise.graded || config.disableGrading || config.disabledActions.includes("test")) socket.removeAllowed("test")
+        else socket.addAllowed('test')
+
+        if(!exercise.entry || config.disabledActions.includes("build")){
+            socket.removeAllowed("build")
+            Console.debug(`No entry was found for this exercise ${req.params.slug}, looking for the following entries from the config: `, config.entries)
+        }
+        else socket.addAllowed('build')
+
+        if(exercise.files.filter(f => !f.name.toLowerCase().includes("readme.") && !f.name.toLowerCase().includes("test.")).length === 0) socket.removeAllowed("reset")
+        else if(!config.disabledActions.includes("reset")) socket.addAllowed('reset')
+
+        socket.log('ready')
+
+        res.json(exercise)
+    }))
+
+    app.get('/exercise/:slug/file/:fileName', withHandler((req, res) => {
+        res.write(configManager.getExercise(req.params.slug).getFile(req.params.fileName))
+        res.end()
+    }))
+
+    const textBodyParser = bodyParser.text()
+    app.put('/exercise/:slug/file/:fileName', textBodyParser, withHandler((req, res) => {
+        const result = configManager.getExercise(req.params.slug).saveFile(req.params.fileName, req.body)
+        res.end()
+    }))
+
+    if(config.outputPath) app.use('/preview', express.static(config.outputPath))
+
+    app.use('/',express.static(config.dirPath+'/_app'))
+}

package/src/managers/session.js

@@ -0,0 +1,83 @@
+const Console = require('../utils/console');
+const api = require('../utils/api');
+
+const v = require('validator');
+const { ValidationError, InternalError } = require('../utils/errors');
+const moment = require('moment');
+const fs = require('fs');
+const cli = require("cli-ux").default
+const storage = require('node-persist');
+
+module.exports = {
+    sessionStarted: false,
+    token: null,
+    config: null,
+    currentCohort: null,
+    initialize: async function(){
+      if(!this.sessionStarted){
+
+        if(!this.config) throw InternalError('Configuration not found')
+        if(!fs.existsSync(this.config.dirPath)) fs.mkdirSync(this.config.dirPath)
+        await storage.init({ dir: `${this.config.dirPath}/.session` });
+        this.sessionStarted = true;
+      }
+      return true
+    },
+    setPayload: async function(value){
+      await this.initialize();
+      await storage.setItem('bc-payload', { token: this.token, ...value });
+      Console.debug("Payload successfuly found and set for "+value.email);
+      return true;
+    },
+    getPayload: async function(){
+      await this.initialize();
+      let payload = null;
+      try{
+         payload = await storage.getItem('bc-payload');
+      }
+      catch(err){
+        Console.debug("Error retriving session payload");
+      }
+      return payload;
+    },
+    isActive: function(){
+      if(this.token) return true;
+      else return false;
+    },
+    get: async function(configObj=null){
+      if(configObj) this.config = configObj.config;
+
+      await this.sync();
+      if(!this.isActive()) return null;
+
+      const payload = await this.getPayload();
+      return {
+        payload, token: this.token,
+      };
+    },
+    login: async function(){
+
+      var email = await cli.prompt('What is your email?')
+      if(!v.isEmail(email)) throw ValidationError('Invalid email');
+
+      var password = await cli.prompt('What is your password?', {type: 'hide'})
+
+      const data = await api.login(email, password);
+      if(data) this.start({ token: data.token, payload: data });
+
+    },
+    sync: async function(){
+      const payload = await this.getPayload();
+      if(payload) this.token = payload.token;
+    },
+    start: async function({ token, payload=null }){
+      if(!token) throw new Error("A token and email is needed to start a session");
+      this.token = token;
+      if(payload) if(await this.setPayload(payload)) Console.success(`Successfully logged in as ${payload.email}`);
+    },
+    destroy: async function(){
+        await storage.clear();
+        this.token = null;
+        Console.success('You have logged out');
+    }
+};

package/src/managers/socket.js

@@ -0,0 +1,185 @@
+let connect = require("socket.io");
+let Console = require("../utils/console");
+const queue = require("../utils/fileQueue");
+
+module.exports = {
+  socket: null,
+  config: null,
+  allowedActions: null,
+  isTestingEnvironment: false,
+  actionCallBacks: {
+    clean: (data, s) => {
+      s.logs = [];
+    },
+  },
+  addAllowed: function (actions) {
+    if (!Array.isArray(actions)) actions = [actions];
+
+    //avoid adding the "test" action if grading is disabled
+    if (actions.includes("test") && this.config.disable_grading)
+      actions = actions.filter((a) => a != "test");
+
+    //remove duplicates
+    this.allowedActions = this.allowedActions
+      .filter((a) => !actions.includes(a))
+      .concat(actions);
+  },
+  removeAllowed: function (actions) {
+    if (!Array.isArray(actions)) actions = [actions];
+    this.allowedActions = this.allowedActions.filter(
+      (a) => !actions.includes(a)
+    );
+  },
+  start: function (config, server, isTestingEnvironment = false) {
+    this.config = config;
+    this.isTestingEnvironment = isTestingEnvironment;
+
+    // remove test action if grading is disabled
+    this.allowedActions = config.actions.filter((act) =>
+      config.disable_grading ? act !== "test" : true
+    );
+
+    this.socket = connect(server);
+    this.socket.on("connection", (socket) => {
+      Console.debug(
+        "Connection with client successfully established",
+        this.allowedActions
+      );
+
+      if (!this.isTestingEnvironment) {
+        this.log("ready", ["Ready to compile or test..."]);
+      }
+
+      socket.on("compiler", ({ action, data }) => {
+        this.emit("clean", "pending", ["Working..."]);
+
+        if (typeof data.exerciseSlug == "undefined") {
+          this.log("internal-error", ["No exercise slug specified"]);
+          Console.error("No exercise slug especified");
+          return;
+        }
+
+        if (typeof this.actionCallBacks[action] == "function")
+          this.actionCallBacks[action](data);
+        else this.log("internal-error", ["Uknown action " + action]);
+      });
+    });
+  },
+  on: function (action, callBack) {
+    this.actionCallBacks[action] = callBack;
+  },
+  clean: function (status = "pending", logs = []) {
+    this.emit("clean", "pending", logs);
+  },
+  ask: function (questions = []) {
+    return new Promise((resolve, reject) => {
+      this.emit("ask", "pending", ["Waiting for input..."], questions);
+      this.on("input", ({ inputs }) => {
+        // Workaround to fix issue because null inputs
+        let isNull = false;
+        inputs.forEach((input) => {
+          if (input === null) {
+            isNull = true;
+          }
+        });
+
+        if (!isNull) {
+          resolve(inputs);
+        }
+      });
+    });
+  },
+  reload: function (files = null, exercises = null) {
+    this.emit("reload", files, exercises);
+  },
+  openWindow: function (url = "") {
+    queue.dispatcher().enqueue(queue.events.OPEN_WINDOW, url);
+    this.emit(
+      queue.events.OPEN_WINDOW,
+      (status = "ready"),
+      (logs = [`Opening ${url}`]),
+      (inputs = []),
+      (report = []),
+      (data = url)
+    );
+  },
+  log: function (status, messages = [], report = [], data = null) {
+    this.emit("log", status, messages, [], report, data);
+    Console.log(messages);
+  },
+  emit: function (
+    action,
+    status = "ready",
+    logs = [],
+    inputs = [],
+    report = [],
+    data = null
+  ) {
+    if (
+      ["webpack", "vanillajs", "vue", "react", "css", "html"].includes(
+        this.config.compiler
+      )
+    ) {
+      if (["compiler-success", "compiler-warning"].includes(status))
+        this.addAllowed("preview");
+      if (["compiler-error"].includes(status) || action == "ready")
+        this.removeAllowed("preview");
+    }
+
+    if (this.config.grading === "incremental") {
+      this.removeAllowed("reset");
+    }
+
+    Console.debug("dactions", this.config)
+    this.config.disabledActions.forEach(a => this.removeAllowed(a))
+
+    this.socket.emit("compiler", {
+      action,
+      status,
+      logs,
+      allowed: this.allowedActions,
+      inputs,
+      report,
+      data,
+    });
+  },
+
+  ready: function (message) {
+    this.log("ready", [message]);
+  },
+  success: function (type, stdout = "") {
+    const types = ["compiler", "testing"];
+    if (!types.includes(type))
+      this.fatal(`Invalid socket success type "${type}" on socket`);
+    else {
+      if (stdout === "")
+        this.log(type + "-success", ["No stdout to display on the console"]);
+      else this.log(type + "-success", [stdout]);
+    }
+
+    if (this.isTestingEnvironment) {
+      this.onTestingFinised({
+        result: "success",
+      });
+    }
+  },
+  error: function (type, stdout) {
+    console.error("Socket error: " + type, stdout);
+    this.log(type, [stdout]);
+
+    if (this.isTestingEnvironment) {
+      this.onTestingFinised({
+        result: "failed",
+      });
+    }
+  },
+  fatal: function (msg) {
+    this.log("internal-error", [msg]);
+    throw msg;
+  },
+  onTestingFinised: function (result) {
+    if (this.config.testingFinishedCallback) {
+      this.config.testingFinishedCallback(result);
+    }
+  },
+};

package/src/managers/test.js

@@ -0,0 +1,77 @@
+const path = require('path');
+let shell = require('shelljs');
+const fs = require('fs');
+let { TestingError } = require('./errors');
+let Console = require('../utils/console');
+const color = require('colors');
+const bcActivity = require('./bcActivity.js');
+
+module.exports = async function({ socket, files, config, slug }){
+
+  const configPath = path.resolve(__dirname,`./config/tester/${config.tester}/${config.language}.config.js`);
+  if (!fs.existsSync(configPath)) throw CompilerError(`Uknown testing engine for compiler: '${config.language}'`);
+
+      const testingConfig = require(configPath)(files, config, slug);
+      testingConfig.validate();
+
+      if(config.ignoreTests) throw TestingError('Grading is disabled on learn.json file.');
+
+      if (!fs.existsSync(`${config.dirPath}/reports`)){
+        fs.mkdirSync(`${config.dirPath}/reports`);
+        Console.debug(`Creating the ${config.dirPath}/reports directory`);
+      }
+
+      Console.info('Running tests...');
+
+      const command = await testingConfig.getCommand(socket)
+      const { stdout, stderr, code } = shell.exec(command);
+
+      if(code != 0){
+        const errors = typeof(testingConfig.getErrors === 'function') ? testingConfig.getErrors(stdout || stderr) : [];
+        socket.log('testing-error', errors);
+        console.log(errors.join('\n'))
+
+        Console.error("There was an error while testing");
+        bcActivity.error('exercise_error', {
+          message: errors,
+          name: `${config.tester}-error`,
+          framework: config.tester,
+          language: config.language,
+          data: slug,
+          compiler: config.compiler
+        });
+      }
+      else{
+        socket.log('testing-success',[ stdout || stderr ].concat(["😁Everything is amazing!"]));
+        Console.success("Everything is amazing!");
+
+
+        bcActivity.activity('exercise_success', {
+          language: config.language,
+          slug: slug,
+          editor: config.editor,
+          compiler: config.compiler
+        });
+        config.exercises = config.exercises.map(e => {
+          if(e.slug === slug) e.done = true;
+          return e;
+        });
+      }
+
+
+      if(typeof testingConfig.cleanup !== "undefined"){
+        if(typeof testingConfig.cleanup === 'function' || typeof testingConfig.cleanup === 'object'){
+          const clean = await testingConfig.cleanup(socket);
+          if(clean){
+            const { stdout, stderr, code } = shell.exec(clean);
+            if(code == 0){
+              Console.debug("The cleanup command runned successfully");
+            }
+            else Console.warning("There is an error on the cleanup command for the test");
+          }
+
+        }
+      }
+
+      return true;
+};

package/src/ui/download.js

@@ -0,0 +1,48 @@
+const { prompt } = require("enquirer")
+const Console = require('../utils/console')
+const api = require('../utils/api')
+const fetch = require('node-fetch')
+
+const askPackage = () => new Promise(async (resolve, reject) => {
+    Console.info(`No package was specified`)
+    const languages = await api.getLangs()
+    if(languages.length === 0){
+        reject(new Error("No categories available"))
+        return null;
+    }
+    let packages = []
+    prompt([{
+            type: 'select',
+            name: 'lang',
+            message: 'What language do you want to practice?',
+            choices: languages.map(l => ({ message: l.title, name: l.slug })),
+        }])
+        .then(({ lang }) => {
+            return (async() => {
+                const response = await api.getAllPackages({ lang })
+                const packages = response.results
+                if(packages.length === 0){
+                    const error = new Error(`No packages found for language ${lang}`)
+                    Console.error(error)
+                    return error
+                }
+                return await prompt([{
+                    type: 'select',
+                    name: 'pack',
+                    message: 'Choose one of the packages available',
+                    choices: packages.map(l => ({ 
+                        message: `${l.title}, difficulty: ${l.difficulty}, downloads: ${l.downloads} ${l.skills.length > 0 ? `(Skills: ${l.skills.join(",")})` : ""}`, 
+                        value: l
+                    })),
+                }])
+            })()
+        })
+        .then(resp => {
+            if(!resp) reject(resp.message || resp)
+            else resolve(resp)
+        })
+        .catch(error => {
+            Console.error(error.message || error)
+        })
+})
+module.exports = { askPackage }

package/src/utils/BaseCommand.js

@@ -0,0 +1,34 @@
+const {Command, flags} = require('@oclif/command')
+const Console = require('./console')
+const SessionManager = require('../managers/session.js')
+
+
+class BaseCommand extends Command {
+  constructor(...params){
+    super(...params)
+  }
+  async catch(err) {
+    Console.debug("COMMAND CATCH", err)
+
+    throw err
+  }
+  async init() {
+    const {flags, args} = this.parse(BaseCommand)
+    Console.debug("COMMAND INIT")
+    Console.debug("These are your flags: ",flags);
+    Console.debug("These are your args: ",args);
+
+    // quick fix for listening to the process termination on windows
+    process.on('SIGINT', function() {
+      Console.debug("Terminated (SIGINT)")
+      process.exit();
+    });
+
+  }
+  async finally() {
+    Console.debug("COMMAND FINALLY")
+    // called after run and catch regardless of whether or not the command errored
+  }
+}
+
+module.exports = BaseCommand

package/src/utils/SessionCommand.js

@@ -0,0 +1,46 @@
+const {flags} = require('@oclif/command')
+const BaseCommand = require("./BaseCommand")
+const Console = require('./console')
+const SessionManager = require('../managers/session.js')
+const ConfigManager = require('../managers/config/index.js')
+const { AuthError } = require('./errors.js')
+
+class SessionCommand extends BaseCommand {
+    constructor(...args){
+        super(...args)
+        this.configManager = null
+        this.session = null
+    }
+
+    async initSession(flags, _private){
+      try{
+        if(!this.configManager) await this.buildConfig(flags)
+
+        this.session = await SessionManager.get(this.configManager.get())
+        if(this.session) Console.debug(`Session open for ${this.session.payload.email}.`)
+        else{
+          if(_private) throw AuthError("You need to log in, run the following command to continue: $ learnpack login");
+          Console.debug("No active session available", _private)
+        }
+      }
+      catch(error){
+        Console.error(error.message)
+      }
+    }
+    async buildConfig(flags){
+        Console.debug("Building configuration for the first time")
+        Console.debug("Flags", flags)
+        this.configManager = await ConfigManager(flags)
+    }
+    async catch(err) {
+        Console.debug("COMMAND CATCH", err)
+        throw err
+    }
+}
+
+// SessionCommand.description = `Describe the command here
+// ...
+// Extra documentation goes here
+// `
+
+module.exports = SessionCommand