@learnpack/learnpack 1.0.0

package/package.json

@@ -0,0 +1,111 @@
+{
+  "name": "@learnpack/learnpack",
+  "description": "Seamlessly build or take interactive & auto-graded tutorials, start learning now or build a tutorial.",
+  "version": "1.0.0",
+  "author": "Alejandro Sanchez @alesanchezr",
+  "bin": {
+    "learnpack": "bin/run"
+  },
+  "bugs": {
+    "url": "https://github.com/learnpack/learnpack-cli/issues"
+  },
+  "dependencies": {
+    "@oclif/command": "^1.6.1",
+    "@oclif/config": "^1.15.1",
+    "@oclif/plugin-help": "^3.1.0",
+    "@oclif/plugin-plugins": "^1.8.0",
+    "@oclif/plugin-warn-if-update-available": "^1.7.0",
+    "body-parser": "^1.19.0",
+    "chalk": "^4.1.0",
+    "chokidar": "^3.4.0",
+    "cli-ux": "^5.4.6",
+    "cors": "^2.8.5",
+    "debounce": "^1.2.0",
+    "dotenv": "^8.2.0",
+    "enquirer": "^2.3.6",
+    "eta": "^1.2.0",
+    "express": "^4.17.1",
+    "front-matter": "^4.0.2",
+    "fs-extra": "^9.1.0",
+    "git-repo-info": "^2.1.1",
+    "moment": "^2.27.0",
+    "node-emoji": "^1.10.0",
+    "node-fetch": "^2.6.0",
+    "node-persist": "^3.1.0",
+    "prompts": "^2.3.2",
+    "request": "^2.88.2",
+    "shelljs": "^0.8.4",
+    "socket.io": "^2.3.0",
+    "targz": "^1.0.1",
+    "validator": "^13.1.1",
+    "xxhashjs": "^0.2.2"
+  },
+  "devDependencies": {
+    "@oclif/dev-cli": "^1.22.2",
+    "@oclif/test": "^1.2.6",
+    "chai": "^4.2.0",
+    "eslint": "^5.16.0",
+    "eslint-config-oclif": "^3.1.0",
+    "globby": "^10.0.2",
+    "mocha": "^5.2.0",
+    "nyc": "^14.1.1",
+    "pre-commit": "^1.2.2"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "files": [
+    "/bin",
+    "/npm-shrinkwrap.json",
+    "/oclif.manifest.json",
+    "/plugin",
+    "/src"
+  ],
+  "homepage": "https://learnpack.co",
+  "keywords": [
+    "learn",
+    "learn to code",
+    "tutorial",
+    "tutorials",
+    "coding tutorials",
+    "education",
+    "coding education"
+  ],
+  "license": "UNLICENSED",
+  "main": "src/index.js",
+  "oclif": {
+    "commands": "./src/commands",
+    "bin": "learnpack",
+    "plugins": [
+      "@oclif/plugin-help",
+      "@oclif/plugin-plugins",
+      "@oclif/plugin-warn-if-update-available"
+    ],
+    "permanent_plugins": [
+      "@oclif/plugin-help",
+      "@oclif/plugin-plugins",
+      "@oclif/plugin-warn-if-update-available"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/learnpack/learnpack-cli.git"
+  },
+  "pre-commit": {
+    "silent": true,
+    "run": [
+      "pre"
+    ]
+  },
+  "scripts": {
+    "postpack": "rm -f oclif.manifest.json",
+    "posttest": "eslint .",
+    "pre": "node ./test/precommit/index.js",
+    "prepack": "oclif-dev manifest && oclif-dev readme",
+    "test": "nyc mocha --forbid-only \"test/**/*.test.js\"",
+    "version": "oclif-dev readme && git add README.md"
+  },
+  "directories": {
+    "test": "test"
+  }
+}

package/plugin/command/compile.js

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

package/plugin/command/test.js

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

package/plugin/index.js

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

package/plugin/plugin.js

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

package/plugin/utils.js

@@ -0,0 +1,78 @@
+const chalk = require("chalk")
+
+const getMatches = (reg, content) => {
+    let inputs = [];
+    let m;
+    while ((m = reg.exec(content)) !== null) {
+        // This is necessary to avoid infinite loops with zero-width matches
+        if (m.index === reg.lastIndex) reg.lastIndex++;
+
+        // The result can be accessed through the `m`-variable.
+        inputs.push(m[1] || null);
+    }
+    return inputs;
+}
+
+const cleanStdout = (buffer, inputs) => {
+  if(Array.isArray(inputs))
+    for(let i = 0; i < inputs.length; i++)
+      if(inputs[i]) buffer = buffer.replace(inputs[i],'');
+
+  return buffer;
+}
+
+const indent = (string, count = 1, options) => {
+	options = {
+		indent: ' ',
+		includeEmptyLines: false,
+		...options
+	};
+
+	if (typeof string !== 'string') {
+		throw new TypeError(
+			`Expected \`input\` to be a \`string\`, got \`${typeof string}\``
+		);
+	}
+
+	if (typeof count !== 'number') {
+		throw new TypeError(
+			`Expected \`count\` to be a \`number\`, got \`${typeof count}\``
+		);
+	}
+
+	if (count < 0) {
+		throw new RangeError(
+			`Expected \`count\` to be at least 0, got \`${count}\``
+		);
+	}
+
+	if (typeof options.indent !== 'string') {
+		throw new TypeError(
+			`Expected \`options.indent\` to be a \`string\`, got \`${typeof options.indent}\``
+		);
+	}
+
+	if (count === 0) {
+		return string;
+	}
+
+	const regex = options.includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
+
+	return string.replace(regex, options.indent.repeat(count));
+};
+
+const Console = {
+    // _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)}`),
+    debug(...args){
+        this._debug && console.log(chalk.magentaBright(`⚠ debug: `), args)
+    }
+}
+
+module.exports = { getMatches, cleanStdout, indent, Console };

package/src/commands/audit.js

@@ -0,0 +1,243 @@
+const fs = require('fs')
+const fetch = require('node-fetch')
+const {validateExerciseDirectoryName} = require('../managers/config/exercise.js')
+const { flags } = require('@oclif/command')
+const Console = require('../utils/console')
+const { isUrl, findInFile, checkLearnpackClean, checkForEmptySpaces, showErrors, showWarnings } = require('../utils/audit')
+const SessionCommand = require('../utils/SessionCommand');
+const fm = require("front-matter")
+const path = require('path')
+
+class AuditCommand extends SessionCommand {
+    async init() {
+        const { flags } = this.parse(AuditCommand)
+        await this.initSession(flags)
+    }
+    async run() {
+        const { flags } = this.parse(AuditCommand)
+        
+        Console.log("Running command audit...")
+
+        // Get configuration object.
+        const config = this.configManager.get();
+        
+        let errors = []
+        let warnings = []
+        let counter = {
+            images: {
+                error: 0,
+                total: 0,
+            },
+            links: {
+                error: 0,
+                total: 0,
+            },
+            exercises: 0,
+            readmeFiles: 0
+        }
+        
+        // Checks if learnpack clean has been run
+        checkLearnpackClean(config, errors)
+
+        // Build exercises if they are not built yet.
+        if (!this.configManager.get().exercises) this.configManager.buildIndex()
+        
+        // Check if the exercises folder has some files within any ./exercise
+        const exercisesPath = config.config.exercisesPath
+        fs.readdir(exercisesPath, (err, files) => {
+            if (err) {
+                return console.log('Unable to scan directory: ' + err);
+            }
+            //listing all files using forEach
+            files.forEach(function (file) {
+                // Do whatever you want to do with the file
+                let filePath = path.join(exercisesPath, file)
+                if (fs.statSync(filePath).isFile()) warnings.push({ exercise: file, msg: `This file is not inside any exercise folder.` })
+            });
+        })
+
+        // This function checks that each of the url's are working.
+        const checkUrl = async (file, exercise) => {
+            if (!fs.existsSync(file.path)) return false
+            const content = fs.readFileSync(file.path).toString();
+            let isEmpty = checkForEmptySpaces(content);
+            if (isEmpty === true || content == false) errors.push({ exercise: exercise.title, msg: `This file (${file.name}) doesn't have any content inside.` })
+            const frontmatter = fm(content).attributes
+            for (const attribute in frontmatter) {
+                if (attribute === "intro" || attribute === "tutorial") {
+                    counter.links.total++
+                    try {
+                        let res = await fetch(frontmatter[attribute], { method: "HEAD" });
+                        if (!res.ok) {
+                            counter.links.error++;
+                            errors.push({ exercise: exercise.title, msg: `This link is broken (${res.ok}): ${frontmatter[attribute]}` })
+                        }
+                    }
+                    catch (error) {
+                        counter.links.error++;
+                        errors.push({ exercise: exercise.title, msg: `This link is broken: ${frontmatter[attribute]}` })
+                    }
+                }
+            }
+
+            // Check url's of each README file.
+            const findings = findInFile(["relative_images", "external_images", "markdown_links"], content);
+            for (const finding in findings) {
+                let obj = findings[finding];
+                // Valdites all the relative path images.
+                if (finding === "relative_images" && Object.keys(obj).length > 0) {
+                    for (const img in obj) {
+                        // Validates if the image is in the assets folder.
+                        counter.images.total++
+                        let relativePath = path.relative(exercise.path.replace(/\\/gm, "/"), `${config.config.dirPath}/assets/${obj[img].relUrl}`).replace(/\\/gm, "/")
+                        if (relativePath != obj[img].absUrl.split("?").shift()) {
+                            counter.images.error++;
+                            errors.push({ exercise: exercise.title, msg: `This relative path (${obj[img].relUrl}) is not pointing to the assets folder.` })
+                        }
+                        if (!fs.existsSync(`${config.config.dirPath}/assets/${obj[img].relUrl}`)) {
+                            counter.images.error++;
+                            errors.push({ exercise: exercise.title, msg: `The file ${obj[img].relUrl} doesn't exist in the assets folder.` })
+                        }
+                    }
+                } else if (finding === "external_images" && Object.keys(obj).length > 0) {
+                    // Valdites all the aboslute path images.
+                    for (const img in obj) {
+                        counter.images.total++
+                        try {
+                            let res = await fetch(obj[img].absUrl, { method: "HEAD" });
+                            if (!res.ok) {
+                                counter.images.error++;
+                                errors.push({ exercise: exercise.title, msg: `This link is broken: ${obj[img].absUrl}` })
+                            }
+                        }
+                        catch (error) {
+                            counter.images.error++;
+                            errors.push({ exercise: exercise.title, msg: `This link is broken: ${obj[img].absUrl}` })
+                        }
+                    }
+                } else if (finding === "markdown_links" && Object.keys(obj).length > 0) {
+                    for (const link in obj) {
+                        counter.links.total++
+                        try {
+                            let res = await fetch(obj[link].mdUrl, { method: "HEAD" });
+                            if (res.status > 399 && res.status < 200) {
+                                counter.links.error++;
+                                errors.push({ exercise: exercise.title, msg: `This link is broken: ${obj[link].mdUrl}` })
+                            }
+                        }
+                        catch (error) {
+                            counter.links.error++;
+                            errors.push({ exercise: exercise.title, msg: `This link is broken: ${obj[link].mdUrl}` })
+                        }
+                    }
+                }
+            }
+            return true
+        }
+
+        // This function is being created because the find method doesn't work with promises.
+        const find = async (file, lang, exercise) => {
+            if (file.name === lang) {
+                await checkUrl(file, exercise)
+                return true
+            }
+            return false
+        }
+
+        Console.info(' Checking if the config file is fine...')
+        // These two lines check if the 'slug' property is inside the configuration object.
+        Console.debug("Checking if the slug property is inside the configuration object...")
+        if (!config.config.slug) errors.push({ exercise: null, msg: "The slug property is not in the configuration object" })
+
+        // These two lines check if the 'repository' property is inside the configuration object.
+        Console.debug("Checking if the repository property is inside the configuration object...")
+        if (!config.config.repository) errors.push({ exercise: null, msg: "The repository property is not in the configuration object" })
+        else isUrl(config.config.repository, errors, counter)
+
+        // These two lines check if the 'description' property is inside the configuration object.
+        Console.debug("Checking if the description property is inside the configuration object...")
+        if (!config.config.description) errors.push({ exercise: null, msg: "The description property is not in the configuration object" })
+
+        if (errors.length == 0) Console.log("The config file is ok")
+
+        // Validates if images and links are working at every README file.
+        const exercises = config.exercises
+        let readmeFiles = []
+
+        if (exercises.length > 0) {
+            Console.info(' Checking if the images are working...')
+            for (const index in exercises) {
+                let exercise = exercises[index]
+                if (!validateExerciseDirectoryName(exercise.title)) errors.push({exercise: exercise.title, msg: `The exercise ${exercise.title} has an invalid name.`})
+                let readmeFilesCount = { exercise: exercise.title, count: 0 };
+                if (Object.keys(exercise.translations).length == 0) errors.push({ exercise: exercise.title, msg: `The exercise ${exercise.title} doesn't have a README.md file.` })
+
+                if (exercise.language == "python3" || exercise.language == "python") {
+                    exercise.files.map(f => f).find(f => {
+                        if (f.path.includes('test.py') || f.path.includes('tests.py')) {
+                            const content = fs.readFileSync(f.path).toString();
+                            let isEmpty = checkForEmptySpaces(content);
+                            if (isEmpty === true || content == false) errors.push({ exercise: exercise.title, msg: `This file (${f.name}) doesn't have any content inside.` })
+                        }
+                    });
+                }
+                else {
+                    exercise.files.map(f => f).find(f => {
+                        if (f.path.includes('test.js') || f.path.includes('tests.js')) {
+                            const content = fs.readFileSync(f.path).toString();
+                            let isEmpty = checkForEmptySpaces(content);
+                            if (isEmpty === true || content == false) errors.push({ exercise: exercise.title, msg: `This file (${f.name}) doesn't have any content inside.` })
+                        }
+                    });
+                }
+
+                for (const lang in exercise.translations) {
+                    let files = []
+                    for (const file of exercise.files) {
+                        let found = await find(file, exercise.translations[lang], exercise)
+                        if (found == true) readmeFilesCount = { ...readmeFilesCount, count: readmeFilesCount.count + 1 }
+                        files.push(found)
+                    }
+                    if (!files.includes(true)) errors.push({ exercise: exercise.title, msg: `This exercise doesn't have a README.md file.` })
+
+                }
+                readmeFiles.push(readmeFilesCount)
+            }
+        } else errors.push({ exercise: null, msg: "The exercises array is empty." })
+
+        Console.log(`${counter.images.total - counter.images.error} images ok from ${counter.images.total}`)
+
+        Console.info(" Checking if important files are missing... (README's, translations, gitignore...)")
+        // Check if all the exercises has the same ammount of README's, this way we can check if they have the same ammount of translations.
+        let files = [];
+        readmeFiles.map((item, i, arr) => {
+            if (item.count !== arr[0].count) files.push(` ${item.exercise}`)
+        })
+        if (files.length > 0) {
+            files = files.join()
+            warnings.push({ exercise: null, msg: `These exercises are missing translations: ${files}` })
+        }
+
+        // Checks if the .gitignore file exists.
+        if (!fs.existsSync(`.gitignore`)) warnings.push(".gitignore file doesn't exist")
+
+        counter.exercises = exercises.length;
+        readmeFiles.forEach((readme) => {
+            counter.readmeFiles += readme.count
+        })
+
+        await showWarnings(warnings)
+        await showErrors(errors, counter)
+    }
+}
+
+AuditCommand.description = `Check if the configuration object has slug, description and repository property
+...
+Extra documentation goes here
+`
+
+AuditCommand.flags = {
+    // name: flags.string({char: 'n', description: 'name to print'}),
+}
+
+module.exports = AuditCommand

package/src/commands/clean.js

@@ -0,0 +1,27 @@
+const {flags} = require('@oclif/command')
+const Console = require('../utils/console')
+const SessionCommand = require('../utils/SessionCommand')
+class CleanCommand extends SessionCommand {
+  async init() {
+    const {flags} = this.parse(CleanCommand)
+    await this.initSession(flags)
+  }
+  async run() {
+    const {flags} = this.parse(CleanCommand)
+    
+    this.configManager.clean()
+
+    Console.success("Package cleaned successfully, ready to publish")
+  }
+}
+
+CleanCommand.description = `Clean the configuration object
+...
+Extra documentation goes here
+`
+
+CleanCommand.flags = {
+  // name: flags.string({char: 'n', description: 'name to print'}),
+}
+
+module.exports = CleanCommand

package/src/commands/download.js

@@ -0,0 +1,52 @@
+const {Command, flags} = require('@oclif/command')
+const fetch = require('node-fetch');
+const { clone } = require('../managers/file.js')
+const Console = require('../utils/console')
+const api = require('../utils/api')
+const getRepoInfo = require('git-repo-info')
+const { askPackage } = require('../ui/download')
+
+class DownloadCommand extends Command {
+  // async init() {
+  //   const {flags} = this.parse(DownloadCommand)
+  //   await this.initSession(flags)
+  // }
+  async run() {
+    const {flags, args} = this.parse(DownloadCommand)
+    // start watching for file changes
+    let _package = args.package
+    if(!_package) _package = await askPackage()
+    
+    if(!_package) return null
+
+    try{
+      _package = _package.pack;
+      clone(_package.repository)
+        .then(result => {
+          Console.success(`Successfully downloaded`)
+          const folder = _package.repository.substring(_package.repository.lastIndexOf('/') + 1).split(".")[0];
+          Console.info(`You can now CD into the folder like this: $ cd ${folder}`)
+        })
+        .catch(error => Console.error(error.message || error))
+    }
+    catch(error){}
+  }
+}
+
+DownloadCommand.description = `Describe the command here
+...
+Extra documentation goes here
+`
+DownloadCommand.flags = {
+  // name: flags.string({char: 'n', description: 'name to print'}),
+}
+DownloadCommand.args =[
+  {
+    name: 'package',               // name of arg to show in help and reference with args[name]
+    required: false,            // make the arg required with `required: true`
+    description: 'The unique string that identifies this package on learnpack', // help description
+    hidden: false               // hide this arg from help
+  }
+]
+
+module.exports = DownloadCommand

package/src/commands/hello.js

@@ -0,0 +1,20 @@
+const {Command, flags} = require('@oclif/command')
+
+class HelloCommand extends Command {
+  async run() {
+    const {flags} = this.parse(HelloCommand)
+    const name = flags.name || 'world'
+    this.log(`hello ${name} from ./src/commands/hello.js`)
+  }
+}
+
+HelloCommand.description = `Describe the command here
+...
+Extra documentation goes here
+`
+
+HelloCommand.flags = {
+  name: flags.string({char: 'n', description: 'name to print'}),
+}
+
+module.exports = HelloCommand