@learnpack/learnpack 1.0.0

package/src/commands/init.js

@@ -0,0 +1,133 @@
+const {flags} = require('@oclif/command')
+const BaseCommand = require('../utils/BaseCommand')
+
+const fs = require('fs-extra')
+const prompts = require('prompts')
+const cli = require("cli-ux").default
+const eta = require("eta")
+
+const Console = require('../utils/console')
+const { ValidationError } = require('../utils/errors')
+let defaults = require('../managers/config/defaults.js')
+
+const path = require('path')
+const { resolve } = require('path')
+
+class InitComand extends BaseCommand {
+  async run() {
+    const {flags} = this.parse(InitComand)
+
+    try{
+      // if the folder/file .learn or .breathecode aleady exists
+      await alreadyInitialized();
+    }
+    catch(error){
+      Console.error(error.message)
+      return false
+    }
+
+    let choices = await prompts([
+        {
+          type: 'select',
+          name: 'grading',
+          message: 'Is the auto-grading going to be isolated or incremental?',
+          choices: [
+            { title: 'Incremental: Build on top of each other like a tutorial', value: 'incremental' },
+            { title: 'Isolated: Small isolated exercises', value: 'isolated' },
+            { title: 'No grading: No feedback or testing whatsoever', value: null },
+          ],
+        },{
+          type: 'text',
+          name: 'title',
+          initial: 'My Interactive Tutorial',
+          message: 'Title for your tutorial? Press enter to leave as it is'
+        },{
+          type: 'text',
+          name: 'description',
+          initial: '',
+          message: 'Description for your tutorial? Press enter to leave blank'
+        },{
+          type: 'select',
+          name: 'difficulty',
+          message: 'How difficulty will be to complete the tutorial?',
+          choices: [
+            { title: 'Begginer (no previous experience)', value: 'beginner' },
+            { title: 'Easy (just a bit of experience required)', value: 'easy' },
+            { title: 'Intermediate (you need experience)', value: 'intermediate' },
+            { title: 'Hard (master the topic)', value: 'hard' },
+          ],
+        },{
+          type: 'text',
+          name: 'duration',
+          initial: "1",
+          message: 'How many hours avg it takes to complete (number)?',
+          validate: value => {
+            var n = Math.floor(Number(value))
+            return n !== Infinity && String(n) === value && n >= 0
+          }
+        }
+    ])
+
+    const packageInfo = {
+      ...defaults.config,
+      grading: choices.grading,
+      difficulty: choices.difficulty,
+      duration: parseInt(choices.duration),
+      description: choices.description,
+      title: choices.title,
+      slug: choices.title.toLowerCase().replace(/ /g,'-').replace(/[^\w-]+/g,'')
+    }
+
+    cli.action.start('Initializing package')
+
+    const languages = ['en', 'es']
+    
+    try{
+      const templatesDir = path.resolve(__dirname,"../utils/templates/"+choices.grading || "no-grading")
+      if(!fs.existsSync(templatesDir)) throw ValidationError(`Template ${templatesDir} does not exists`)
+      await fs.copySync(templatesDir, './')
+      
+      // Creating README files
+      languages.forEach((language) => {
+        const readmeFilename = `README${language !== 'en' ? `.${language}` : ''}`
+        fs.writeFileSync(`./${readmeFilename}.md`, eta.render(fs.readFileSync(path.resolve(__dirname,`${templatesDir}/${readmeFilename}.ejs`),'utf-8'), packageInfo))
+        if(fs.existsSync(`./${readmeFilename}.ejs`)) fs.removeSync(`./${readmeFilename}.ejs`)
+      })
+
+      if(!fs.existsSync('./.gitignore')) fs.copyFile(path.resolve(__dirname,'../utils/templates/gitignore.txt'), './.gitignore')
+      fs.writeFileSync('./learn.json', JSON.stringify(packageInfo, null, 2))
+    }
+    catch(error){
+      Console.error(error.message || error)
+      return false
+    }
+
+    cli.action.stop()                
+    Console.success(`😋 Package initialized successfully`)
+    Console.help(`Start the exercises by running the following command on your terminal: $ learnpack start`)
+
+  }
+}
+
+InitComand.description = 'Create a new learning package: Book, Tutorial or Exercise'
+InitComand.flags = {
+  ...BaseCommand.flags,
+  grading: flags.help({char:'h'}),
+}
+
+const alreadyInitialized = () => new Promise((resolve, reject) => {
+  fs.readdir('./', function(err, files) {
+    files = files.filter(f => ['.learn', 'learn.json', 'bc.json', '.breathecode', '.gitignore'].includes(f))
+    if (err) {
+      reject(ValidationError(err.message))
+      return true
+    } else if (files.length > 0){
+      reject(ValidationError("It seems the package is already initialized because we've found the following files: "+files.join(',')))
+      return true
+    } 
+
+    resolve(false)
+  })
+})
+
+module.exports = InitComand

package/src/commands/login.js

@@ -0,0 +1,45 @@
+const {Command, flags} = require('@oclif/command')
+const { prompt } = require("enquirer")
+const fetch = require('node-fetch');
+const SessionCommand = require('../utils/SessionCommand')
+const SessionManager = require('../managers/session.js')
+const Console = require('../utils/console');
+const { replace } = require('node-emoji');
+const { validURL } = require("../utils/validators")
+// const BaseCommand = require('../utils/BaseCommand');
+
+class PublishCommand extends SessionCommand {
+  async init() {
+    const {flags} = this.parse(PublishCommand)
+    await this.initSession(flags)
+  }
+  async run() {
+    const {flags, args} = this.parse(PublishCommand)
+
+    try{
+      await SessionManager.login();
+    }
+    catch(error){
+      Console.error("Error trying to authenticate")
+      Console.error(error.message || error)
+    }
+  }
+}
+
+PublishCommand.description = `Describe the command here
+...
+Extra documentation goes here
+`
+PublishCommand.flags = {
+  // name: flags.string({char: 'n', description: 'name to print'}),
+}
+PublishCommand.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 = PublishCommand

package/src/commands/logout.js

@@ -0,0 +1,39 @@
+const {Command, flags} = require('@oclif/command')
+const { prompt } = require("enquirer")
+const fetch = require('node-fetch');
+const SessionCommand = require('../utils/SessionCommand')
+const SessionManager = require('../managers/session.js')
+const Console = require('../utils/console');
+const { replace } = require('node-emoji');
+const { validURL } = require("../utils/validators")
+// const BaseCommand = require('../utils/BaseCommand');
+
+class PublishCommand extends SessionCommand {
+  async init() {
+    const {flags} = this.parse(PublishCommand)
+    await this.initSession(flags)
+  }
+  async run() {
+    const {flags, args} = this.parse(PublishCommand)
+
+    SessionManager.destroy();
+  }
+}
+
+PublishCommand.description = `Describe the command here
+...
+Extra documentation goes here
+`
+PublishCommand.flags = {
+  // name: flags.string({char: 'n', description: 'name to print'}),
+}
+PublishCommand.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 = PublishCommand

package/src/commands/publish.js

@@ -0,0 +1,78 @@
+const {Command, flags} = require('@oclif/command')
+const { prompt } = require("enquirer")
+const fetch = require('node-fetch');
+const SessionCommand = require('../utils/SessionCommand')
+const Console = require('../utils/console');
+const api = require('../utils/api');
+const { replace } = require('node-emoji');
+const { validURL } = require("../utils/validators")
+// const BaseCommand = require('../utils/BaseCommand');
+
+class PublishCommand extends SessionCommand {
+  async init() {
+    const {flags} = this.parse(PublishCommand)
+    await this.initSession(flags, true)
+  }
+  async run() {
+    const {flags, args} = this.parse(PublishCommand)
+
+    // avoid annonymus sessions
+    if(!this.session) return;
+    Console.info(`Session found for ${this.session.payload.email}, publishing the package...`)
+
+    const configObject = this.configManager.get()
+    if(configObject.slug === undefined || !configObject.slug)
+      throw new Error("The package is missing a slug (unique name identifier), please check your learn.json file and make sure it has a 'slug'")
+    if(!validURL(configObject.repository))
+      throw new Error("The package has a missing or invalid 'repository' on the configuration file, it needs to be a Github URL")
+    else{
+      const validateResp = await fetch(configObject.repository);
+      if(validateResp.status !== 200)
+        throw new Error(`The specified repository URL on the configuration file does not exist or its private, only public repositories are allowed at the moment: ${configObject.repository}`)
+    }
+
+    // start watching for file changes
+    try{
+      const data = await api.publish({
+        ...configObject,
+        author: this.session.payload.user_id
+      });
+      Console.success(`Package updated and published successfully: ${configObject.slug}`)
+    }catch(error){
+      if(error.status === 404){
+        const answer = await prompt([{
+            type: 'confirm',
+            name: 'create',
+            message: `Package with slug ${configObject.slug} does not exist, do you want to create it?`,
+        }])
+        if(answer){
+          const data2 = await api.update({
+              ...configObject,
+              author: this.session.payload.user_id
+          })
+          Console.success(`Package created and published successfully: ${configObject.slug}`)
+        }
+        else Console.error("No answer from server")
+      }
+      else Console.error(error.message)
+    }
+  }
+}
+
+PublishCommand.description = `Describe the command here
+...
+Extra documentation goes here
+`
+PublishCommand.flags = {
+  // name: flags.string({char: 'n', description: 'name to print'}),
+}
+PublishCommand.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 = PublishCommand

package/src/commands/start.js

@@ -0,0 +1,169 @@
+const path = require("path")
+const {flags} = require('@oclif/command')
+const SessionCommand = require('../utils/SessionCommand')
+const Console = require('../utils/console')
+const socket = require('../managers/socket.js')
+const queue = require("../utils/fileQueue")
+const { download, decompress, downloadEditor } = require('../managers/file.js')
+const { prioritizeHTMLFile } = require('../utils/misc')
+
+const createServer = require('../managers/server')
+
+class StartCommand extends SessionCommand {
+  constructor(...params){
+    super(...params)
+  }
+
+  // 🛑 IMPORTANT:
+  // Every command that will use the configManager needs this init method
+  async init() {
+    const {flags} = this.parse(StartCommand)
+    await this.initSession(flags)
+  }
+
+  async run() {
+
+    // const {flags} = this.parse(StartCommand)
+
+    // get configuration object
+    const configObject = this.configManager.get()
+    const { config } = configObject;
+
+    // build exercises
+    this.configManager.buildIndex()
+
+    Console.debug(`Grading: ${config.grading} ${config.disableGrading ? "(disabled)" : ""}, editor: ${config.editor.mode} ${config.editor.version}, for ${Array.isArray(config.exercises) ? config.exercises.length : 0} exercises found`)
+
+    // download app and decompress
+    let resp = await downloadEditor(config.editor.version, `${config.dirPath}/app.tar.gz`)
+
+    Console.info("Decompressing LearnPack UI, this may take a minute...")
+    await decompress(`${config.dirPath}/app.tar.gz`, `${config.dirPath}/_app/`)
+
+    const server = await createServer(configObject, this.configManager)
+
+    const dispatcher = queue.dispatcher({ create: true, path: `${config.dirPath}/vscode_queue.json` })
+
+    // listen to socket commands
+    socket.start(config, server)
+    
+    socket.on("open", (data) => {
+      Console.debug("Opening these files: ", data)
+      
+      let files = prioritizeHTMLFile(data.files);
+      
+      dispatcher.enqueue(dispatcher.events.OPEN_FILES, files);
+      socket.ready('Ready to compile...')
+    })
+
+    socket.on("open_window", (data) => {
+      Console.debug("Opening window: ", data)
+      dispatcher.enqueue(dispatcher.events.OPEN_WINDOW, data)
+      socket.ready('Ready to compile...')
+    })
+    
+    socket.on("reset", (exercise) => {
+      try{
+        this.configManager.reset(exercise.exerciseSlug)
+        dispatcher.enqueue(dispatcher.events.RESET_EXERCISE, exercise.exerciseSlug)
+        socket.ready('Ready to compile...')
+      }
+      catch(error){
+        socket.error('compiler-error', error.message || "There was an error reseting the exercise")
+        setTimeout(() => socket.ready('Ready to compile...'), 2000)
+      }
+    })
+    // socket.on("preview", (data) => {
+    //   Console.debug("Preview triggered, removing the 'preview' action ")
+    //   socket.removeAllowed("preview")
+    //   socket.log('ready',['Ready to compile...'])
+    // })
+
+    socket.on("build", async (data) => {
+      const exercise = this.configManager.getExercise(data.exerciseSlug)
+      
+      if(!exercise.language){
+        socket.error('compiler-error','Impossible to detect language to build for '+data.exerciseSlug+'...')
+        return;
+      }
+
+      // validate plugins installation for compiler
+      //if(!this.configManager.validateEngine(exercise.language, server, socket)) return false;
+
+      socket.log('compiling','Building exercise '+data.exerciseSlug+' with '+exercise.language+'...')
+      const stdout = await this.config.runHook('action', {
+        action: 'compile',
+        socket, configuration: config,
+        exercise,
+      })
+
+      
+    })
+
+    socket.on("test", async (data) => {
+        const exercise = this.configManager.getExercise(data.exerciseSlug)
+
+        if(!exercise.language){
+          socket.error('compiler-error','Impossible to detect engine language for testing for '+data.exerciseSlug+'...')
+          return;
+        } 
+
+        if(config.disableGrading){
+          socket.ready('Grading is disabled on configuration')
+          return true;
+        }
+
+        // validate plugins installation for compiler
+        //if(!this.configManager.validateEngine(exercise.language, server, socket)) return false;
+
+        socket.log('testing','Testing your exercise using the '+exercise.language+' engine.')
+
+        const stdout = await this.config.runHook('action', {
+          action: 'test',
+          socket, configuration: config,
+          exercise,
+        })
+        this.configManager.save()
+
+        return true;
+    })
+
+    const terminate = () => {
+      Console.debug("Terminating Learnpack...")
+      server.terminate(() => {
+        this.configManager.noCurrentExercise()
+        dispatcher.enqueue(dispatcher.events.END)
+        process.exit();
+      })
+    }
+
+    server.on('close', terminate);
+    process.on('SIGINT', terminate);
+    process.on('SIGTERM', terminate);
+    process.on('SIGHUP', terminate);
+
+
+    // finish the server startup
+    setTimeout(() => dispatcher.enqueue(dispatcher.events.RUNNING), 1000)
+
+    // start watching for file changes
+    if(flags.watch) this.configManager.watchIndex((_exercises) => socket.reload(null, _exercises));
+
+  }
+
+}
+
+StartCommand.description = `Runs a small server with all the exercise instructions`
+
+StartCommand.flags = {
+  ...SessionCommand.flags,
+  port: flags.string({char: 'p', description: 'server port' }),
+  host: flags.string({char: 'h', description: 'server host' }),
+  disableGrading: flags.boolean({char: 'dg', description: 'disble grading functionality' }),
+  watch: flags.boolean({char: 'w', description: 'Watch for file changes', default: false }),
+  mode: flags.string({ char: 'm', description: 'Load a standalone editor or just the preview to be embeded in another editor: Choices: [standalone, preview]', options: ['standalone', 'preview'] }),
+  version: flags.string({ char: 'v', description: 'E.g: 1.0.1', default: null }),
+  grading: flags.string({ char: 'g', description: '[isolated, incremental]', options: ['isolated', 'incremental'] }),
+  debug: flags.boolean({char: 'd', description: 'debugger mode for more verbage', default: false })
+}
+module.exports = StartCommand

package/src/commands/test.js

@@ -0,0 +1,85 @@
+const Console = require("../utils/console");
+const SessionCommand = require("../utils/SessionCommand");
+const socket = require("../managers/socket.js");
+
+const createServer = require("../managers/server");
+const ExercisesQueue = require("../utils/exercisesQueue");
+
+class TestCommand extends SessionCommand {
+  async init() {
+    const { flags } = this.parse(TestCommand);
+    await this.initSession(flags);
+  }
+  async run() {
+    const {
+      args: { exerciseSlug },
+    } = this.parse(TestCommand);
+
+    // Build exercises index
+    this.configManager.buildIndex();
+
+    let exercises = [];
+
+    // test all exercises
+    if (!exerciseSlug) {
+      exercises = this.configManager.getAllExercises();
+    } else {
+      exercises = [this.configManager.getExercise(exerciseSlug)];
+    }
+
+    const exercisesQueue = new ExercisesQueue(exercises);
+
+    const configObject = this.configManager.get();
+
+    let hasFailed = false;
+    let failedTestsCount = 0;
+    let successTestsCount = 0;
+    let testsToRunCount = exercisesQueue.size();
+
+    configObject.config.testingFinishedCallback = ({ result }) => {
+      if (result === "failed") {
+        hasFailed = true;
+        failedTestsCount++;
+      } else {
+        successTestsCount++;
+      }
+
+      if (exercisesQueue.isEmpty()) {
+        Console.info(
+          `${testsToRunCount} test${testsToRunCount > 1 ? "s" : ""} runned`
+        );
+        Console.success(
+          `${successTestsCount} test${successTestsCount > 1 ? "s" : ""} passed`
+        );
+        Console.error(
+          `${failedTestsCount} test${failedTestsCount > 1 ? "s" : ""} failed`
+        );
+
+        process.exit(hasFailed ? 1 : 0);
+      } else {
+        exercisesQueue.pop().test(this.config, config, socket);
+      }
+    };
+
+    const { config } = configObject;
+
+    const server = await createServer(configObject, this.configManager, true);
+
+    socket.start(config, server, true);
+
+    exercisesQueue.pop().test(this.config, config, socket);
+  }
+}
+
+TestCommand.description = `Test exercises`;
+
+TestCommand.args = [
+  {
+    name: "exerciseSlug",
+    required: false,
+    description: "The name of the exercise to test",
+    hidden: false,
+  },
+];
+
+module.exports = TestCommand;

package/src/index.js

@@ -0,0 +1 @@
+module.exports = require('@oclif/command')

package/src/managers/config/allowed_files.js

@@ -0,0 +1,12 @@
+module.exports = {
+    extensions: [
+        'py', 'java','py','ruby', 'html', 'css', 'htm', 'php', //images
+        'js','jsx', 'ts', //images
+        'sh','bash', //images
+        'json', 'yml', 'yaml', 'csv', 'xml', // file storage extensions
+        'txt', 'text', 'markdown', 'readme', // compressed files
+    ],
+    names: [
+        'package.json', 'package-lock.json'
+    ]
+}

package/src/managers/config/defaults.js

@@ -0,0 +1,32 @@
+module.exports = {
+    config: {
+        port: 3000,
+        address: "http://localhost",
+        editor: {
+            mode: null, //[standalone, preview]
+            agent: null, //[vscode, theia]
+            version: null
+        },
+        dirPath: './.learn',
+        configPath: './learn.json',
+        outputPath: './.learn/dist',
+        publicPath: '/preview',
+        publicUrl: null,
+        language: "auto",
+        grading: 'isolated', // [isolated, incremental]
+        exercisesPath: './', // path to the folder that contains the exercises
+        webpackTemplate: null, // if you want webpack to use an HTML template
+        disableGrading: false,
+        disabledActions: [], //Possible: 'build', 'test' or 'reset'
+        actions: [], // ⚠️ deprecated, leave empty )
+        entries: {
+            html: "index.html",
+            vanillajs: "index.js",
+            react: "app.jsx",
+            node: "app.js",
+            python3: "app.py",
+            java: "app.java",
+        }
+    },
+    currentExercise: null
+}