@learnpack/learnpack 1.0.0

package/src/managers/config/exercise.js

@@ -0,0 +1,212 @@
+const p = require("path")
+const frontMatter = require('front-matter')
+const fs = require("fs")
+let Console = require('../../utils/console');
+const allowed = require('./allowed_files')
+const { ValidationError } = require('../../utils/errors.js')
+
+const exercise = (path, position, configObject) => {
+
+    const { config, exercises } = configObject;
+    let slug = p.basename(path)
+    
+    if(!validateExerciseDirectoryName(slug)){
+        Console.error('Exercise directory "'+slug+'" has an invalid name, it has to start with two or three digits followed by words separated by underscors or hyphen (no white spaces). e.g: 01.12-hello-world')
+        Console.help('Verify that the folder "'+slug+'" starts with two numbers and it does not contain white spaces or weird characters.')
+        throw ValidationError(`This exercise has a invalid name: ${slug}`)
+    }
+    
+    // get all the files
+    const files = fs.readdirSync(path)
+    
+    /**
+     * build the translation array like:
+        {
+            "us": "path/to/Readme.md",
+            "es": "path/to/Readme.es.md"
+        }
+    */
+    var translations = {}
+    files.filter(file => file.toLowerCase().includes('readme')).forEach(file => {
+        const parts = file.split('.')
+        if(parts.length === 3) translations[parts[1]] = file
+        else translations["us"] = file
+    })
+    
+    // if the slug is a dot, it means there is not "exercises" folder, and its just a single README.md
+    if(slug == ".") slug = "default-index";
+    
+    const detected = detect(configObject, files);
+    return {
+        position, path, slug, translations, 
+        language: detected.language,
+        entry: detected.entry ? path + "/" + detected.entry : null, //full path to the exercise entry
+        title: slug || "Exercise",
+        graded: files.filter(file => file.toLowerCase().startsWith('test.') || file.toLowerCase().startsWith('tests.')).length > 0,
+        files: filterFiles(files, path),
+        //if the exercises was on the config before I may keep the status done
+        done: (Array.isArray(exercises) && typeof exercises[position] !== 'undefined' && path.substring(path.indexOf('exercises/')+10) == exercises[position].slug) ? exercises[position].done : false,
+        getReadme: function(lang=null){
+            if(lang == 'us') lang = null // <-- english is default, no need to append it to the file name
+            if (!fs.existsSync(`${this.path}/README${lang ? "."+lang : ''}.md`)){
+                Console.error(`Language ${lang} not found for exercise ${slug}, switching to default language`)
+                if(lang) lang = null
+                if (!fs.existsSync(`${this.path}/README${lang ? "."+lang : ''}.md`)) throw Error('Readme file not found for exercise: '+this.path+'/README.md')
+            }
+            let content = fs.readFileSync(`${this.path}/README${lang ? "."+lang : ''}.md`,"utf8")
+            // content = content.replace(/!\[.*\](../../assets/script-test.gif)/, "<div>$1</div>")
+            const attr = frontMatter(content)
+            return attr
+        },
+        getFile: function(name){
+            const file = this.files.find(f => f.name === name);
+            if (!fs.existsSync(file.path)) throw Error('File not found: '+file.path)
+            else if(fs.lstatSync(file.path).isDirectory()) return 'Error: This is not a file to be read, but a directory: '+file.path
+
+            // get file content
+            const content = fs.readFileSync(file.path)
+
+            //create reset folder
+            if (!fs.existsSync(`${config.dirPath}/resets`)) fs.mkdirSync(`${config.dirPath}/resets`)
+            if (!fs.existsSync(`${config.dirPath}/resets/`+this.slug)){
+                fs.mkdirSync(`${config.dirPath}/resets/`+this.slug)
+                if (!fs.existsSync(`${config.dirPath}/resets/${this.slug}/${name}`)){
+                    fs.writeFileSync(`${config.dirPath}/resets/${this.slug}/${name}`, content)
+                }
+            }
+
+            return content
+        },
+        saveFile: function(name, content){
+            const file = this.files.find(f => f.name === name);
+            if (!fs.existsSync(file.path)) throw Error('File not found: '+file.path)
+            return fs.writeFileSync(file.path, content, 'utf8')
+        },
+        getTestReport: function(){
+            const _path = `${config.confPath.base}/reports/${this.slug}.json`
+            if (!fs.existsSync(_path)) return {}
+  
+            const content = fs.readFileSync(_path)
+            const data = JSON.parse(content)
+            return data
+        },
+    }
+}
+
+const validateExerciseDirectoryName = (str) => {
+    if(str == "./") return true;
+    const regex = /^(\d{2,3}(\.\d{1,2})?-([A-Za-z0-9]+(-|_)?)+)$/
+    return regex.test(str)
+}
+
+const isCodable = (str) => {
+    const extension = p.extname(str);
+    return allowed.extensions.includes(extension.substring(1).toLowerCase());
+}
+
+const isNotConfiguration = (str) => {
+    return !allowed.names.includes(str);
+}
+
+const shouldBeVisible = function(file){
+    return (
+        // doest not have "test." on their name
+        (file.name.toLocaleLowerCase().indexOf('test.') == -1 && file.name.toLocaleLowerCase().indexOf('tests.') == -1 && file.name.toLocaleLowerCase().indexOf('.hide.') == -1 &&
+        // ignore hidden files
+        (file.name.charAt(0) != '.') &&
+        // ignore learn.json and bc.json
+        (file.name.toLocaleLowerCase().indexOf('learn.json') == -1) && (file.name.toLocaleLowerCase().indexOf('bc.json') == -1) &&
+        // ignore images, videos, vectors, etc.
+        isCodable(file.name) && isNotConfiguration(file.name) &&
+        // readme's and directories
+        !file.name.toLowerCase().includes("readme.") && !isDirectory(file.path) && file.name.charAt(0) != '_')
+    );
+}
+
+const isDirectory = source => {
+    //if(path.basename(source) === path.basename(config.dirPath)) return false
+    return fs.lstatSync(source).isDirectory()
+}
+
+/**
+ * Learnpack must be able to AUTOMATICALLY detect language.
+ * Because learnpack can work with multilang exercises.
+ */
+const detect = (configObject, files) => {
+
+    const { config } = configObject;
+
+    if(!config) throw Error(`No configuration found during the engine detection`)
+    
+    if(!config.entries) throw Error("No configuration found for entries, please add a 'entries' object with the default file name for your exercise entry file that is going to be used while compiling, for example: index.html for html, app.py for python3, etc.")
+    //A language was found on the config object, but this language will only be used as last resort, learnpack will try to guess each exercise language independently based on file extension (js, jsx, html, etc.)
+
+    let hasFiles = files.filter(f => f.includes('.py'))
+    if(hasFiles.length > 0) return {
+        language: "python3",
+        entry: hasFiles.find(f => config.entries["python3"] === f)
+    }
+
+    hasFiles = files.filter(f => f.includes('.java'))
+    if(hasFiles.length > 0) return {
+        language: "java",
+        entry: hasFiles.find(f => config.entries["java"] === f)
+    }
+
+    hasFiles = files.filter(f => f.includes('.jsx'))
+    if(hasFiles.length > 0) return {
+        language: "react",
+        entry: hasFiles.find(f => config.entries["react"] === f)
+    }
+    const hasHTML = files.filter(f => f.includes('index.html'))
+    const hasIndexJS = files.find(f => f.includes('index.js'))
+    const hasJS = files.filter(f => f.includes('.js'))
+    // angular, vue, vanillajs needs to have at least 2 files (html,css,js),
+    // the test.js and the entry file in js
+    // if not its just another HTML
+    
+    if(hasIndexJS && hasHTML.length > 0) return {
+        language: "vanillajs",
+        entry: hasIndexJS
+    }
+    else if(hasHTML.length > 0) return {
+        language: "html",
+        entry: hasHTML.find(f => config.entries["html"] === f)
+    }
+    else if(hasJS.length > 0) return {
+        language: "node",
+        entry: hasJS.find(f => config.entries["node"] === f)
+    }
+    
+    return {
+        language: null,
+        entry: null
+    };
+}
+
+const filterFiles = (files, basePath=".") => files.map(ex => ({ 
+    path: basePath+'/'+ex, 
+    name: ex, 
+    hidden: !shouldBeVisible({ name: ex, path: basePath+'/'+ex })
+}))
+    .sort((f1, f2) => {
+        const score = { // sorting priority
+        "index.html": 1,
+        "styles.css": 2,
+        "styles.scss": 2,
+        "style.css": 2,
+        "style.scss": 2,
+        "index.css": 2,
+        "index.scss": 2,
+        "index.js": 3,
+        "index.jsx": 3,
+        }
+        return score[f1.name] < score[f2.name] ? -1 : 1
+    });
+
+module.exports = {
+    exercise,
+    detect,
+    filterFiles,
+    validateExerciseDirectoryName
+}

package/src/managers/config/index.js

@@ -0,0 +1,342 @@
+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

@@ -0,0 +1,137 @@
+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 }