@learnpack/learnpack 1.0.0 → 2.0.0

package/src/managers/config/index.js

@@ -1,342 +0,0 @@
-const path = require("path");
-const fs = require("fs");
-const shell = require("shelljs");
-const Console = require("../../utils/console");
-const watch = require("../../utils/watcher");
-const chalk = require("chalk");
-const fetch = require("node-fetch");
-const {
-  ValidationError,
-  NotFoundError,
-  InternalError,
-} = require("../../utils/errors.js");
-
-let defaults = require("./defaults.js");
-let { exercise } = require("./exercise.js");
-
-const { rmSync } = require("../file.js");
-/* exercise folder name standard */
-
-const getConfigPath = () => {
-  const possibleFileNames = [
-    "learn.json",
-    ".learn/learn.json",
-    "bc.json",
-    ".breathecode/bc.json",
-  ];
-  let config = possibleFileNames.find((file) => fs.existsSync(file)) || null;
-  if (config && fs.existsSync(".breathecode"))
-    return { config, base: ".breathecode" };
-  else if (config === null)
-    throw NotFoundError(
-      "learn.json file not found on current folder, is this a learnpack package?"
-    );
-  return { config, base: ".learn" };
-};
-
-const getExercisesPath = (base) => {
-  const possibleFileNames = ["./exercises", base + "/exercises", "./"];
-  return possibleFileNames.find((file) => fs.existsSync(file)) || null;
-};
-
-const getGitpodAddress = () => {
-  if (shell.exec(`gp -h`, { silent: true }).code == 0) {
-    return shell
-      .exec(`gp url`, { silent: true })
-      .stdout.replace(/(\r\n|\n|\r)/gm, "");
-  } else {
-    Console.debug(`Gitpod command line tool not found`);
-    return "http://localhost";
-  }
-};
-
-module.exports = async ({ grading, mode, disableGrading, version }) => {
-  let confPath = getConfigPath();
-  Console.debug("This is the config path: ", confPath);
-
-  let configObj = {};
-  if (confPath) {
-    const bcContent = fs.readFileSync(confPath.config);
-
-    let hiddenBcContent = {};
-    if (fs.existsSync(confPath.base + "/config.json")) {
-      hiddenBcContent = fs.readFileSync(confPath.base + "/config.json");
-      hiddenBcContent = JSON.parse(hiddenBcContent);
-      if (!hiddenBcContent)
-        throw Error(
-          `Invalid ${confPath.base}/config.json syntax: Unable to parse.`
-        );
-    }
-
-    const jsonConfig = JSON.parse(bcContent);
-    if (!jsonConfig)
-      throw Error(`Invalid ${confPath.config} syntax: Unable to parse.`);
-
-    //add using id to the installation
-    if (!jsonConfig.session)
-      jsonConfig.session = Math.floor(Math.random() * 10000000000000000000);
-
-    configObj = deepMerge(hiddenBcContent, { config: jsonConfig }, {
-      config: { disableGrading },
-    });
-    Console.debug("Content form the configuration .json ", configObj);
-  } else {
-    throw ValidationError(
-      "No learn.json file has been found, make sure you are in the folder"
-    );
-  }
-
-  configObj = deepMerge(defaults || {}, configObj, {
-    config: {
-      grading: grading || configObj.grading,
-      configPath: confPath.config,
-    },
-  });
-  configObj.config.outputPath = confPath.base + "/dist";
-
-  Console.debug("This is your configuration object: ", {
-    ...configObj,
-    exercises: configObj.exercises
-      ? configObj.exercises.map((e) => e.slug)
-      : [],
-  });
-
-  // auto detect agent (if possible)
-  if (shell.which("gp")) {
-    configObj.config.editor.agent = "gitpod";
-    configObj.config.address = getGitpodAddress();
-    configObj.config.publicUrl = `https://${
-      configObj.config.port
-    }-${configObj.config.address.substring(8)}`;
-  } else if (!configObj.config.editor.agent) {
-    configObj.config.editor.agent = "localhost";
-  }
-
-  if (!configObj.config.publicUrl)
-    configObj.config.publicUrl = `${configObj.config.address}:${configObj.config.port}`;
-
-  // Assign default editor mode if not set already
-  if (mode != null) {
-    configObj.config.editor.mode = mode;
-  }
-
-  if (!configObj.config.mode)
-    configObj.config.editor.mode =
-      configObj.config.editor.agent === "localhost" ? "standalone" : "preview";
-
-  if (version) configObj.config.editor.version = version;
-  else if (configObj.config.editor.version === null) {
-    const resp = await fetch(
-      "https://raw.githubusercontent.com/learnpack/coding-ide/learnpack/package.json"
-    );
-    const packageJSON = await resp.json();
-    configObj.config.editor.version = packageJSON.version || "1.0.61";
-  }
-
-  configObj.config.dirPath = "./" + confPath.base;
-  configObj.config.exercisesPath = getExercisesPath(confPath.base) || "./";
-
-  return {
-    validLanguages: {},
-    get: () => configObj,
-    validateEngine: function (language, server, socket) {
-      const alias = (_l) => {
-        let map = {
-          python3: "python",
-        };
-        if (map[_l]) return map[_l];
-        else return _l;
-      };
-
-      // decode aliases
-      language = alias(language);
-
-      if (this.validLanguages[language]) return true;
-
-      Console.debug(`Validating engine for ${language} compilation`);
-      let result = shell.exec("learnpack plugins", { silent: true });
-
-      if (result.code == 0 && result.stdout.includes(`learnpack-${language}`)) {
-        this.validLanguages[language] = true;
-        return true;
-      }
-
-      Console.info(`Language engine for ${language} not found, installing...`);
-      result = shell.exec(`learnpack plugins:install learnpack-${language}`, {
-        silent: true,
-      });
-      if (result.code === 0) {
-        socket.log(
-          "compiling",
-          "Installing the python compiler, you will have to reset the exercises after installation by writing on your terminal: $ learnpack run"
-        );
-        Console.info(
-          `Successfully installed the ${language} exercise engine, \n please start learnpack again by running the following command: \n ${chalk.white(
-            `$ learnpack start`
-          )}\n\n `
-        );
-        server.terminate();
-        return false;
-      } else {
-        this.validLanguages[language] = false;
-        socket.error(`Error installing ${language} exercise engine`);
-        Console.error(`Error installing ${language} exercise engine`);
-        Console.log(result.stdout);
-        throw InternalError(`Error installing ${language} exercise engine`);
-      }
-    },
-    clean: () => {
-      rmSync(configObj.config.outputPath);
-      rmSync(configObj.config.dirPath + "/_app");
-      rmSync(configObj.config.dirPath + "/reports");
-      rmSync(configObj.config.dirPath + "/.session");
-      rmSync(configObj.config.dirPath + "/resets");
-
-      // clean tag gz
-      if (fs.existsSync(configObj.config.dirPath + "/app.tar.gz"))
-        fs.unlinkSync(configObj.config.dirPath + "/app.tar.gz");
-
-      if (fs.existsSync(configObj.config.dirPath + "/config.json"))
-        fs.unlinkSync(configObj.config.dirPath + "/config.json");
-
-      if (fs.existsSync(configObj.config.dirPath + "/vscode_queue.json"))
-        fs.unlinkSync(configObj.config.dirPath + "/vscode_queue.json");
-    },
-    getExercise: (slug) => {
-      const exercise = configObj.exercises.find((ex) => ex.slug == slug);
-      if (!exercise) throw ValidationError(`Exercise ${slug} not found`);
-
-      return exercise;
-    },
-    getAllExercises: () => {
-      return configObj.exercises;
-    },
-    startExercise: function (slug) {
-      const exercise = this.getExercise(slug);
-
-      // set config.json with current exercise
-      configObj.currentExercise = exercise.slug;
-
-      this.save();
-
-      exercise.files.forEach((f) => {
-        const _path = configObj.config.outputPath + "/" + f.name;
-        if (f.hidden === false && fs.existsSync(_path)) fs.unlinkSync(_path);
-      });
-
-      return exercise;
-    },
-    noCurrentExercise: function () {
-      configObj.currentExercise = null;
-      this.save();
-    },
-    reset: (slug) => {
-      if (!fs.existsSync(`${configObj.config.dirPath}/resets/` + slug))
-        throw ValidationError("Could not find the original files for " + slug);
-
-      const exercise = configObj.exercises.find((ex) => ex.slug == slug);
-      if (!exercise)
-        throw ValidationError(
-          `Exercise ${slug} not found on the configuration`
-        );
-
-      fs.readdirSync(`${configObj.config.dirPath}/resets/${slug}/`).forEach(
-        (fileName) => {
-          const content = fs.readFileSync(
-            `${configObj.config.dirPath}/resets/${slug}/${fileName}`
-          );
-          fs.writeFileSync(`${exercise.path}/${fileName}`, content);
-        }
-      );
-    },
-    buildIndex: function () {
-      Console.info("Building the exercise index...");
-
-      const isDirectory = (source) => {
-        const name = path.basename(source);
-        if (name === path.basename(configObj.config.dirPath)) return false;
-        //ignore folders that start with a dot
-        if (name.charAt(0) === "." || name.charAt(0) === "_") return false;
-
-        return fs.lstatSync(source).isDirectory();
-      };
-      const getDirectories = (source) =>
-        fs
-          .readdirSync(source)
-          .map((name) => path.join(source, name))
-          .filter(isDirectory);
-      // add the .learn folder
-      if (!fs.existsSync(confPath.base)) fs.mkdirSync(confPath.base);
-      // add the outout folder where webpack will publish the the html/css/js files
-      if (
-        configObj.config.outputPath &&
-        !fs.existsSync(configObj.config.outputPath)
-      )
-        fs.mkdirSync(configObj.config.outputPath);
-
-      // TODO: we could use npm library front-mater to read the title of the exercises from the README.md
-      const grupedByDirectory = getDirectories(configObj.config.exercisesPath);
-      if (grupedByDirectory.length > 0)
-        configObj.exercises = grupedByDirectory.map((path, position) =>
-          exercise(path, position, configObj)
-        );
-      // else means the exercises are not in a folder
-      else
-        configObj.exercises = [
-          exercise(configObj.config.exercisesPath, 0, configObj),
-        ];
-      this.save();
-    },
-    watchIndex: function (onChange = null) {
-      if (!configObj.config.exercisesPath)
-        throw ValidationError(
-          "No exercises directory to watch: " + configObj.config.exercisesPath
-        );
-
-      this.buildIndex();
-      watch(configObj.config.exercisesPath)
-        .then((eventname, filename) => {
-          Console.debug("Changes detected on your exercises");
-          this.buildIndex();
-          if (onChange) onChange();
-        })
-        .catch((error) => {
-          throw error;
-        });
-    },
-    save: (config = null) => {
-      Console.debug("Saving configuration with: ", configObj);
-
-      //remove the duplicates form the actions array
-      // configObj.config.actions = [...new Set(configObj.config.actions)];
-      configObj.config.translations = [
-        ...new Set(configObj.config.translations),
-      ];
-
-      fs.writeFileSync(
-        configObj.config.dirPath + "/config.json",
-        JSON.stringify(configObj, null, 4)
-      );
-    },
-  };
-};
-
-function deepMerge(...sources) {
-  let acc = {};
-  for (const source of sources) {
-    if (source instanceof Array) {
-      if (!(acc instanceof Array)) {
-        acc = [];
-      }
-      acc = [...source];
-    } else if (source instanceof Object) {
-      for (let [key, value] of Object.entries(source)) {
-        if (value instanceof Object && key in acc) {
-          value = deepMerge(acc[key], value);
-        }
-        if (value !== undefined) acc = { ...acc, [key]: value };
-      }
-    }
-  }
-  return acc;
-}

package/src/managers/file.js

@@ -1,137 +0,0 @@
-var fs = require('fs')
-var p = require('path')
-let shell = require('shelljs')
-const {cli} = require('cli-ux')
-var targz = require('targz')
-let Console = require('../utils/console')
-var https = require('https')
-var fetch = require('node-fetch')
-const { InternalError } = require('../utils/errors');
-
-const decompress = (sourcePath, destinationPath) => new Promise((resolve, reject) => {
-    Console.debug("Decompressing "+sourcePath)
-    targz.decompress({
-        src: sourcePath,
-        dest: destinationPath
-    }, function(err){
-        if(err) {
-            Console.error("Error when trying to decompress")
-            reject(err)
-        } else {
-            Console.info("Decompression finished successfully")
-            resolve()
-        }
-    })
-})
-
-const downloadEditor = async (version, destination) => {
-  //https://raw.githubusercontent.com/learnpack/coding-ide/master/dist/app.tar.gz
-  //if(versions[version] === undefined) throw new Error(`Invalid editor version ${version}`)
-  const resp2 = await fetch(`https://github.com/learnpack/coding-ide/blob/${version}/dist`)
-  if(!resp2.ok) throw InternalError(`Coding Editor v${version} was not found on learnpack repository, check the config.editor.version property on learn.json`)
-
-  Console.info(`Downloading the LearnPack coding UI v${version}, this may take a minute...`)
-  return await download(`https://github.com/learnpack/coding-ide/blob/${version}/dist/app.tar.gz?raw=true`, destination)
-}
-
-const download = (url, dest) =>{
-  Console.debug("Downloading "+url)
-  return new Promise((resolve, reject) => {
-    const request = https.get(url, response => {
-      if (response.statusCode === 200) {
-        const file = fs.createWriteStream(dest, { flags: 'wx' })
-        file.on('finish', () => {
-          resolve(true)
-        })
-        file.on('error', err => {
-          file.close()
-          if (err.code === 'EEXIST'){
-            Console.debug("File already exists")
-            resolve("File already exists")
-          }
-          else{
-            Console.debug("Error ",err.message)
-            fs.unlink(dest, () => reject(err.message)) // Delete temp file
-          }
-
-        })
-        response.pipe(file)
-      } else if (response.statusCode === 302 || response.statusCode === 301) {
-        //Console.debug("Servers redirected to "+response.headers.location)
-        //Recursively follow redirects, only a 200 will resolve.
-        download(response.headers.location, dest)
-        .then(() => resolve())
-        .catch(error => {
-          Console.error(error)
-          reject(error)
-        })
-      } else {
-        Console.debug(`Server responded with ${response.statusCode}: ${response.statusMessage}`)
-        reject(`Server responded with ${response.statusCode}: ${response.statusMessage}`)
-      }
-    })
-
-    request.on('error', err => {
-      reject(err.message)
-    })
-  })
-}
-
-const clone = (repository=null, folder='./') => new Promise((resolve, reject)=>{
-
-  if(!repository){
-    reject("Missing repository url for this package")
-    return false
-  }
-
-  cli.action.start('Verifying GIT...')
-  if (!shell.which('git')) {
-    reject('Sorry, this script requires git')
-    return false
-  }
-  cli.action.stop()
-  
-  let fileName = p.basename(repository)
-  if(!fileName){
-    reject('Invalid repository information on package: '+repository)
-    return false
-  }
-  
-  fileName = fileName.split('.')[0];
-  if(fs.existsSync("./"+fileName)){
-    reject(`Directory ${fileName} already exists; Did you download this package already?`)
-    return false
-  }
-
-  cli.action.start(`Cloning repository ${repository}...`)
-  if (shell.exec(`git clone ${repository}`).code !== 0) {
-    reject('Error: Installation failed')
-  }
-  cli.action.stop()
-
-  cli.action.start('Cleaning installation...')
-  if (shell.exec(`rm -R -f ${folder}${fileName}/.git`).code !== 0) {
-    reject('Error: removing .git directory')
-  }
-  cli.action.stop()
-
-  resolve("Done")
-})
-
-const rmSync = function(path) {
-  var files = [];
-  if( fs.existsSync(path) ) {
-      files = fs.readdirSync(path);
-      files.forEach(function(file,index){
-          var curPath = path + "/" + file;
-          if(fs.lstatSync(curPath).isDirectory()) { // recurse
-              rmSync(curPath);
-          } else { // delete file
-              fs.unlinkSync(curPath);
-          }
-      });
-      fs.rmdirSync(path);
-  }
-};
-
-module.exports = { download, decompress, downloadEditor, clone, rmSync }

package/src/managers/server/routes.js

@@ -1,151 +0,0 @@
-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'))
-}