@learnpack/learnpack 1.0.0

package/src/utils/api.js

@@ -0,0 +1,164 @@
+const Console = require('../utils/console');
+const _fetch = require('node-fetch');
+const storage = require('node-persist');
+const cli = require("cli-ux").default
+const HOST = "https://learnpack.herokuapp.com";
+
+const fetch = async (url, options={}) => {
+
+  let headers = { "Content-Type": "application/json" }
+  let session = null;
+  try{
+      session = await storage.getItem('bc-payload');
+      if(session.token && session.token != "" && !url.includes("/token")) headers["Authorization"] = "Token "+session.token;
+  }
+  catch(err){}
+
+  try{
+    const resp = await _fetch(url, {
+      ...options,
+      headers: { ...headers, ...options.headers }
+    })
+
+    if(resp.status >= 200 && resp.status < 300) return await resp.json()
+    else if(resp.status === 401) throw APIError("Invalid authentication credentials", 401)
+    else if(resp.status === 404) throw APIError("Package not found", 404)
+    else if(resp.status >= 500) throw APIError("Impossible to connect with the server", 500)
+    else if(resp.status >= 400){
+      const error = await resp.json()
+      if(error.detail || error.error){
+        throw APIError(error.detail || error.error)
+      }else if(error.non_field_errors){
+        throw APIError(non_field_errors[0], error)
+      }else if (typeof error === "object"){
+        for(let key in error){
+          throw APIError(`${key}: ${error[key][0]}`, error)
+        }
+      }else{
+        throw APIError("Uknown error")
+      }
+    }
+    else throw APIError("Uknown error")
+  }
+  catch(error){
+    Console.error(error.message);
+    throw error;
+  }
+}
+const login = async (identification, password) => {
+
+  try{
+    cli.action.start('Looking for credentials...')
+    await cli.wait(1000)
+    const data = await fetch(`${HOST}/v1/auth/token/`, {
+      body: JSON.stringify({ identification, password }),
+      method: 'post'
+    });
+    cli.action.stop('ready')
+    return data
+  }
+  catch(err){
+    Console.error(err.message);
+    Console.debug(err);
+  }
+}
+const publish = async (config) => {
+  
+  const keys = ['difficulty', 'language', 'skills', 'technologies', 'slug', 'repository', 'author', 'title'];
+
+  let payload = {}
+  keys.forEach(k => config[k] ? payload[k] = config[k] : null);
+  try{
+    Console.log("Package to publish: ", payload)
+    cli.action.start('Updating package information...')
+    await cli.wait(1000)
+    const data = await fetch(`${HOST}/v1/package/${config.slug}`,{
+      method: 'PUT',
+      body: JSON.stringify(payload)
+    })
+    cli.action.stop('ready')
+    return data
+  }
+  catch(err){
+    Console.log("payload", payload)
+    Console.error(err.message);
+    Console.debug(err);
+    throw err;
+  }
+}
+
+const update = async (config) => {
+
+  try{
+    cli.action.start('Updating package information...')
+    await cli.wait(1000)
+    const data = await fetch(`${HOST}/v1/package/`,{
+      method: 'POST',
+      body: JSON.stringify(config)
+    })
+    cli.action.stop('ready')
+    return data
+  }
+  catch(err){
+    Console.error(err.message);
+    Console.debug(err);
+    throw err;
+  }
+}
+
+const getPackage = async (slug) => {
+  try{
+    cli.action.start('Downloading package information...')
+    await cli.wait(1000)
+    const data = await fetch(`${HOST}/v1/package/${slug}`)
+    cli.action.stop('ready')
+    return data
+  }
+  catch(err){
+    if(err.status == 404) Console.error(`Package ${slug} does not exist`);
+    else Console.error(`Package ${slug} does not exist`);
+    Console.debug(err);
+    throw err;
+  }
+}
+
+const getLangs = async () => {
+  try{
+    cli.action.start('Downloading language options...')
+    await cli.wait(1000)
+    const data = await fetch(`${HOST}/v1/package/language`)
+    cli.action.stop('ready')
+    return data;
+  }
+  catch(err){
+    if(err.status == 404) Console.error(`Package ${slug} does not exist`);
+    else Console.error(`Package ${slug} does not exist`);
+    Console.debug(err);
+    throw err;
+  }
+}
+
+
+const getAllPackages = async ({ lang='', slug='' }) => {
+  try{
+    cli.action.start('Downloading packages...')
+    await cli.wait(1000)
+    const data = await fetch(`${HOST}/v1/package/all?limit=100&language=${lang}&slug=${slug}`)
+    cli.action.stop('ready')
+    return data;
+  }
+  catch(err){
+    Console.error(`Package ${slug} does not exist`);
+    Console.debug(err);
+    throw err;
+  }
+}
+
+const APIError = (error, code) => {
+  const message = error.message || error;
+  const _err = new Error(message);
+  _err.status = code || 400;
+  return _err;
+}
+
+module.exports = {login, publish, update, getPackage, getLangs, getAllPackages }

package/src/utils/audit.js

@@ -0,0 +1,114 @@
+const Console = require('./console')
+const fetch = require('node-fetch')
+const fs = require('fs')
+
+module.exports = {
+    // This function checks if a url is valid.
+    isUrl: async (url, errors, counter) => {
+        let regex_url = /(https?:\/\/[a-zA-Z_\-.\/0-9]+)/gm
+        counter.links.total++
+        if (!regex_url.exec(url)) {
+            counter.links.error++
+            errors.push({ exercise: null, msg: `The repository value of the configuration file is not a link: ${url}` })
+            return false;
+        }
+        let res = await fetch(url, { method: "HEAD" });
+        if (!res.ok) {
+            counter.links.error++
+            errors.push({ exercise: null, msg: `The link of the repository is broken: ${url}` })
+        }
+        return true;
+    },
+    checkForEmptySpaces: (str) => {
+        let isEmpty = true;
+        for(let letter of str){
+            if (letter !== " ") {
+                isEmpty = false;
+                return isEmpty;
+            }
+        }
+        return isEmpty;
+    },
+    checkLearnpackClean: (configObj, errors) => {
+        if(fs.existsSync(configObj.config.outputPath) || fs.existsSync(configObj.config.dirPath + "/_app") || fs.existsSync(configObj.config.dirPath + "/reports") || fs.existsSync(configObj.config.dirPath + "/resets")  || fs.existsSync(configObj.config.dirPath + "/app.tar.gz")  || fs.existsSync(configObj.config.dirPath + "/config.json")  || fs.existsSync(configObj.config.dirPath + "/vscode_queue.json")) {
+            errors.push({ exercise: null, msg: `You have to run learnpack clean command` })
+        }
+    },
+    findInFile: (types, content) => {
+        const regex = {
+            relative_images: /!\[.*\]\s*\((((\.\/)?(\.{2}\/){1,5})(.*\/)*(.[^\/\s]*\.[a-zA-Z]{2,4})[^\s]*)\)/gm,
+            external_images: /!\[.*\]\((https?:\/(\/{1}[^/)]+)+\/?)\)/gm,
+            markdown_links: /(\s)+\[.*\]\((https?:\/(\/{1}[^/)]+)+\/?)\)/gm,
+            url: /(https?:\/\/[a-zA-Z_\-.\/0-9]+)/gm,
+            uploadcare: /https:\/\/ucarecdn.com\/(?:.*\/)*([a-zA-Z_\-.\/0-9]+)/gm
+        }
+
+        const validTypes = Object.keys(regex);
+        if (!Array.isArray(types)) types = [types];
+
+        let findings = {}
+
+        types.forEach(type => {
+            if (!validTypes.includes(type)) throw Error("Invalid type: " + type)
+            else findings[type] = {};
+        });
+
+        types.forEach(type => {
+
+            let count = 0;
+            let m;
+            while ((m = regex[type].exec(content)) !== null) {
+                // This is necessary to avoid infinite loops with zero-width matches
+                if (m.index === regex.lastIndex) {
+                    regex.lastIndex++;
+                }
+
+                // The result can be accessed through the `m`-variable.
+                // m.forEach((match, groupIndex) => values.push(match));
+                count++;
+
+                findings[type][m[0]] = {
+                    content: m[0],
+                    absUrl: m[1],
+                    mdUrl: m[2],
+                    relUrl: m[6]
+                }
+            }
+        })
+
+        return findings;
+    },
+    // This function checks if there are errors, and show them in the console at the end.
+    showErrors: (errors, counter) => {
+        return new Promise((resolve, reject) => {
+            if (errors) {
+                if (errors.length > 0) {
+                    Console.log("Checking for errors...")
+                    errors.forEach((error, i) => Console.error(`${i + 1}) ${error.msg} ${error.exercise != null ? `(Exercise: ${error.exercise})` : ""}`))
+                    Console.error(` We found ${errors.length} errors among ${counter.images.total} images, ${counter.links.total} link, ${counter.readmeFiles} README files and ${counter.exercises} exercises.`)
+                    process.exit(1)
+                } else {
+                    Console.success(`We didn't find any errors in this repository among ${counter.images.total} images, ${counter.links.total} link, ${counter.readmeFiles} README files and ${counter.exercises} exercises.`)
+                    process.exit(0)
+                }
+                resolve("SUCCESS")
+            } else {
+                reject("Failed")
+            }
+        })
+    },
+    // This function checks if there are warnings, and show them in the console at the end.
+    showWarnings: (warnings) => {
+        return new Promise((resolve, reject) => {
+            if (warnings) {
+                if (warnings.length > 0) {
+                    Console.log("Checking for warnings...")
+                    warnings.forEach((warning, i) => Console.warning(`${i + 1}) ${warning.msg} ${warning.exercise ? `File: ${warning.exercise}` : ""}`))
+                }
+                resolve("SUCCESS")
+            } else {
+                reject("Failed")
+            }
+        })
+    }
+}

package/src/utils/console.js

@@ -0,0 +1,16 @@
+const chalk = require("chalk")
+
+module.exports = {
+    // _debug: true,
+    _debug: process.env.DEBUG == 'true',
+    startDebug: function(){ this._debug = true; },
+    log: (msg, ...args) => console.log(chalk.gray(msg), ...args),
+    error: (msg, ...args) => console.log(chalk.red('⨉ '+msg), ...args),
+    success: (msg, ...args) => console.log(chalk.green('✓ '+msg), ...args),
+    info: (msg, ...args) => console.log(chalk.blue('ⓘ '+msg), ...args),
+    help: (msg) => console.log(`${chalk.white.bold('⚠ help:')} ${chalk.white(msg)}`),
+    warning: (msg) => console.log(`${chalk.yellow('⚠ warning:')} ${chalk.yellow(msg)}`),
+    debug(...args){
+        this._debug && console.log(chalk.magentaBright(`⚠ debug: `), args)
+    }
+}

package/src/utils/errors.js

@@ -0,0 +1,90 @@
+const fetch = require("node-fetch");
+const Console = require("./console");
+let solutions = null;
+const uknown = {
+  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"
+};
+
+const getSolution = (slug=null) => {
+
+  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 => r.json()).then(_s => solutions = _s);
+    return uknown;
+  }
+  if(typeof solutions[slug] === "undefined" || !slug) return uknown;
+  else return solutions[slug];
+}
+const ValidationError = (error) => {
+  const message = error.message || error;
+  const _err = new Error(message);
+  _err.status = 400;
+  _err.type = 'validation-error';
+
+  const sol = getSolution(error.slug);
+  _err.video = sol.video;
+  _err.gif = sol.gif;
+  _err.message = typeof message === "string" ? message : sol.message;
+  return _err;
+}
+const NotFoundError = (error) => {
+  const message = error.message || error;
+  const _err = new Error(message);
+  _err.status = 400;
+  _err.type = 'not-found-error';
+
+  const sol = getSolution(error.slug);
+  _err.video = sol.video;
+  _err.gif = sol.gif;
+  _err.message = typeof message === "string" ? message : sol.message;
+  return _err;
+}
+const CompilerError = (error) => {
+  const message = error.message || error;
+  const _err = new Error(message);
+  _err.status = 400;
+  _err.type = 'compiler-error';
+
+  const sol = getSolution(error.slug);
+  _err.video = sol.video;
+  _err.gif = sol.gif;
+  _err.message = typeof message === "string" ? message : sol.message;
+  return _err;
+}
+const TestingError = (error) => {
+  const message = error.message || error;
+  const _err = new Error(message);
+  _err.status = 400;
+  _err.type = 'testing-error';
+  return _err;
+}
+const AuthError = (error) => {
+  const message = error.message || error;
+  const _err = new Error(message);
+  _err.status = 403;
+  _err.type = 'auth-error';
+  return _err;
+}
+const InternalError = (error) => {
+  const message = error.message || error;
+  const _err = new Error(message);
+  _err.status = 500;
+  _err.type = 'internal-error';
+
+  const sol = getSolution(error.slug);
+  _err.video = sol.video;
+  _err.gif = sol.gif;
+  _err.message = typeof message === "string" ? message : sol.message;
+  return _err;
+}
+
+getSolution();
+module.exports = { ValidationError, CompilerError, TestingError, NotFoundError, InternalError, AuthError };

package/src/utils/exercisesQueue.js

@@ -0,0 +1,45 @@
+class Exercise {
+  constructor(exercise) {
+    this.exercise = exercise;
+  }
+
+  test(sessionConfig, config, socket) {
+    if (this.exercise.language) {
+      socket.log(
+        "testing",
+        `Testing exercise ${this.exercise.slug} using ${this.exercise.language} engine`
+      );
+
+      sessionConfig.runHook("action", {
+        action: "test",
+        socket,
+        configuration: config,
+        exercise: this.exercise,
+      });
+    } else {
+      socket.onTestingFinised({ result: "success" });
+    }
+  }
+}
+
+class ExercisesQueue {
+  constructor(exercises) {
+    this.exercises = exercises.map((exercise) => {
+      return new Exercise(exercise);
+    });
+  }
+
+  pop() {
+    return this.exercises.shift();
+  }
+
+  isEmpty() {
+    return this.size() === 0;
+  }
+
+  size() {
+    return this.exercises.length;
+  }
+}
+
+module.exports = ExercisesQueue;

package/src/utils/fileQueue.js

@@ -0,0 +1,194 @@
+const logger = require('../utils/console')
+const fs = require("fs")
+const em = require('events')
+const XXH = require('xxhashjs')
+
+// possible events to dispatch
+let 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 = null
+let watcher = null // subscribe to file and listen to changes
+let actions = null // action queue
+
+const loadDispatcher = (opts) => {
+
+    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 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(error){
+        incomingActions = []
+        logger.debug(`Error loading VSCode Actions file`)
+    }
+
+    logger.debug(`Actions load `, incomingActions)
+    return incomingActions
+}
+
+
+const enqueue = (name, data) => {
+
+    
+    if(!Object.values(events).includes(name)){
+        logger.debug(`Invalid event ${name}`)
+        throw 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()
+    return hrTime[0] * 1000000 + hrTime[1] / 1000
+}
+const loadFile = (filePath) => {
+    
+    if(!fs.existsSync(filePath)) throw Error(`No queue.json file to load on ${filePath}`);
+
+    const content = fs.readFileSync(filePath, 'utf8')
+    const newHash = XXH.h32( content, 0xABCD ).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, 'utf8')
+
+    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 = []
+    } 
+
+    let action = incomingActions[actions.length]
+    logger.debug("Dequeing action ", action)
+    actions.push(action)
+    return action
+}
+
+const pull = (callback) => {
+    logger.debug("Pulling actions")
+    let incoming = dequeue()
+    while(incoming){
+        callback(incoming)
+        incoming = dequeue()
+    }
+}
+
+const reset = (callback) => {
+    logger.debug("Queue reseted")
+    actions = []
+    if(fs.existsSync(options.path)){
+        const success = fs.writeFileSync(options.path, "[]") 
+        if(success) callback()
+    }
+}
+
+const onPull = (callback) => {
+
+    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', path => pull(callback))
+        .on('change', path => pull(callback))
+
+    return true
+}
+
+const onReset = (callback) => {
+
+    const chokidar = require('chokidar')
+
+    if(!watcher){
+        logger.debug(`Watching ${options.path}`)
+        watcher = chokidar.watch(`${options.path}`, {
+            persistent: true
+        })
+    }
+
+    watcher.on('unlink', path => reset(callback))
+
+    return true
+}
+
+
+module.exports = { 
+    events,
+    dispatcher: (opts = {}) => {
+        if(!actions){
+            options = { ...options, ...opts }
+            logger.debug("Initializing queue dispatcher", options)
+            actions = loadDispatcher(options)
+        }
+        return { enqueue, events }
+    },
+    listener: (opts = {}) => {
+        if(!actions){
+            options = { ...options, ...opts }
+            logger.debug("Initializing queue listener", options)
+        }
+        return { onPull, onReset, events }
+    } 
+}

package/src/utils/misc.js

@@ -0,0 +1,26 @@
+const prioritizeHTMLFile = (entryFiles) => {
+  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 (let i = 0; i < entryFiles.length; i++) {
+      if (i !== index) {
+        files.push(entryFiles[i]);
+      }
+    }
+    files.push(entryFiles[index]);
+  } else {
+    files = entryFiles;
+  }
+
+  return files;
+};
+
+module.exports = {
+  prioritizeHTMLFile,
+};

package/src/utils/templates/gitignore.txt

@@ -0,0 +1,20 @@
+# configuration and readme
+!.gitignore
+!.gitpod.yml
+!.gitpod.Dockerfile
+!learn.json
+!README.md
+
+# exercises
+!.learn/
+!.learn/*
+.learn/_app
+.learn/.session
+.learn/dist
+.learn/app.tar.gz
+.learn/config.json
+
+# python compiled files
+*.pyc
+__pycache__/
+.pytest_cache/

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

@@ -0,0 +1,26 @@
+# `01` Hola Mundo
+
+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:
+
+```markdown
+---
+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"
+---
+```