@learnpack/learnpack 1.0.0 → 2.0.0

package/src/commands/init.ts

@@ -0,0 +1,169 @@
+import { flags } from "@oclif/command";
+import BaseCommand from "../utils/BaseCommand";
+
+// eslint-disable-next-line
+import * as fs from "fs-extra";
+import * as prompts from "prompts";
+import cli from "cli-ux";
+import * as eta from "eta";
+
+import Console from "../utils/console";
+import { ValidationError } from "../utils/errors";
+import defaults from "../managers/config/defaults";
+
+import * as path from "path";
+
+class InitComand extends BaseCommand {
+  static description =
+    "Create a new learning package: Book, Tutorial or Exercise";
+
+  static flags = {
+    ...BaseCommand.flags,
+    grading: flags.help({ char: "h" }),
+  };
+
+  async run() {
+    const { flags } = this.parse(InitComand);
+
+    // if the folder/file .learn or .breathecode aleady exists
+    await alreadyInitialized();
+
+    const 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 separated 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: string) => {
+          const n = Math.floor(Number(value));
+          return (
+            n !== Number.POSITIVE_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"];
+
+    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
+    // eslint-disable-next-line
+    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));
+
+    cli.action.stop();
+    Console.success(`😋 Package initialized successfully`);
+    Console.help(
+      `Start the exercises by running the following command on your terminal: $ learnpack start`
+    );
+  }
+}
+
+const alreadyInitialized = () =>
+  new Promise((resolve, reject) => {
+    fs.readdir("./", function (err: any, files: any) {
+      files = files.filter((f: any) =>
+        [".learn", "learn.json", "bc.json", ".breathecode"].includes(f)
+      );
+      if (err) {
+        reject(ValidationError(err.message));
+        throw ValidationError(err.message);
+      } else if (files.length > 0) {
+        reject(
+          ValidationError(
+            "It seems the package is already initialized because we've found the following files: " +
+              files.join(",")
+          )
+        );
+        throw ValidationError(
+          "It seems the package is already initialized because we've found the following files: " +
+            files.join(",")
+        );
+      }
+
+      resolve(false);
+    });
+  });
+
+export default InitComand;

package/src/commands/login.ts

@@ -0,0 +1,42 @@
+import SessionCommand from "../utils/SessionCommand";
+import SessionManager from "../managers/session";
+import Console from "../utils/console";
+
+class LoginCommand extends SessionCommand {
+  static description = `Describe the command here
+  ...
+  Extra documentation goes here
+  `;
+
+  static flags: any = {
+    // name: flags.string({char: 'n', description: 'name to print'}),
+  };
+
+  static 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
+    },
+  ];
+
+  async init() {
+    const { flags } = this.parse(LoginCommand);
+    await this.initSession(flags);
+  }
+
+  async run() {
+    /* const {flags, args} = */ this.parse(LoginCommand);
+
+    try {
+      await SessionManager.login();
+    } catch (error) {
+      Console.error("Error trying to authenticate");
+      Console.error((error as TypeError).message || (error as string));
+    }
+  }
+}
+
+export default LoginCommand;

package/src/commands/logout.ts

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

package/src/commands/publish.ts

@@ -0,0 +1,107 @@
+import { prompt } from "enquirer";
+import SessionCommand from "../utils/SessionCommand";
+import Console from "../utils/console";
+import api from "../utils/api";
+import { validURL } from "../utils/validators";
+
+// eslint-disable-next-line
+const fetch = require("node-fetch");
+
+class PublishCommand extends SessionCommand {
+  static description = `Describe the command here
+  ...
+  Extra documentation goes here
+  `;
+
+  static flags: any = {
+    // name: flags.string({char: 'n', description: 'name to print'}),
+  };
+
+  static 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
+    },
+  ];
+
+  async init() {
+    const { flags } = this.parse(PublishCommand);
+    await this.initSession(flags, true);
+  }
+
+  async run() {
+    const { flags, args } = this.parse(PublishCommand);
+
+    // avoid annonymus sessions
+    // eslint-disable-next-line
+    if (!this.session) return;
+
+    Console.info(
+      `Session found for ${this.session.payload.email}, publishing the package...`
+    );
+
+    const configObject = this.configManager?.get();
+    if (
+      configObject?.config?.slug === undefined ||
+      !configObject.config?.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?.config?.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.config?.repository, {
+        method: "HEAD",
+      });
+      if (!validateResp.ok || 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.config?.repository}`
+        );
+      }
+    }
+
+    // start watching for file changes
+    try {
+      await api.publish({
+        ...configObject,
+        author: this.session.payload.user_id,
+      });
+      Console.success(
+        `Package updated and published successfully: ${configObject.config?.slug}`
+      );
+    } catch (error) {
+      if ((error as any).status === 404) {
+        const answer = await prompt([
+          {
+            type: "confirm",
+            name: "create",
+            message: `Package with slug ${configObject.config?.slug} does not exist, do you want to create it?`,
+          },
+        ]);
+        if (answer) {
+          await api.update({
+            ...configObject,
+            author: this.session.payload.user_id,
+          });
+          Console.success(
+            `Package created and published successfully: ${configObject.config?.slug}`
+          );
+        } else {
+          Console.error("No answer from server");
+        }
+      } else {
+        Console.error((error as TypeError).message);
+      }
+    }
+  }
+}
+
+export default PublishCommand;

package/src/commands/start.ts

@@ -0,0 +1,229 @@
+// import path from "path";
+import { flags } from "@oclif/command";
+import SessionCommand from "../utils/SessionCommand";
+import Console from "../utils/console";
+import socket from "../managers/socket";
+import queue from "../utils/fileQueue";
+import { decompress, downloadEditor } from "../managers/file";
+import { prioritizeHTMLFile } from "../utils/misc";
+
+import createServer from "../managers/server";
+
+import { IGitpodData } from "../models/gitpod-data";
+import { IExercise, IExerciseData } from "../models/exercise-obj";
+
+export default class StartCommand extends SessionCommand {
+  static description = "Runs a small server with all the exercise instructions";
+
+  static flags = {
+    ...SessionCommand.flags,
+    port: flags.string({ char: "p", description: "server port" }),
+    host: flags.string({ char: "h", description: "server host" }),
+    disableGrading: flags.boolean({
+      char: "D",
+      description: "disble grading functionality",
+      default: false,
+    }),
+    // disableGrading: flags.boolean({char: 'dg', description: 'disble grading functionality', default: false }),
+    watch: flags.boolean({
+      char: "w",
+      description: "Watch for file changes",
+      default: false,
+    }),
+    editor: flags.string({
+      char: "e",
+      description: "[standalone, gitpod]",
+      options: ["standalone", "gitpod"],
+    }),
+    version: flags.string({
+      char: "v",
+      description: "E.g: 1.0.1",
+      default: undefined,
+    }),
+    grading: flags.string({
+      char: "g",
+      description: "[isolated, incremental]",
+      options: ["isolated", "incremental"],
+    }),
+    debug: flags.boolean({
+      char: "d",
+      description: "debugger mode for more verbage",
+      default: false,
+    }),
+  };
+
+  // 🛑 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() {
+    // get configuration object
+    const configObject = this.configManager?.get();
+    const config = configObject?.config;
+
+    if (configObject) {
+      const { config } = configObject;
+
+      // build exerises
+      this.configManager?.buildIndex();
+
+      Console.debug(
+        `Grading: ${config?.grading} ${
+          config?.disabledActions?.includes("test") ? "(disabled)" : ""
+        }, editor: ${config?.editor.mode} ${config?.editor.version}, for ${
+          Array.isArray(configObject?.exercises) ? configObject?.exercises.length : 0
+        } exercises found`
+      );
+
+      // download app and decompress
+      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/`
+      );
+
+      // listen to socket commands
+      if (config && this.configManager) {
+        const server = await createServer(configObject, this.configManager);
+
+        const dispatcher = queue.dispatcher({
+          create: true,
+          path: `${config.dirPath}/vscode_queue.json`,
+        });
+
+        socket.start(config, server, false);
+
+        socket.on("open", (data: IGitpodData) => {
+          Console.debug("Opening these files: ", data);
+          const files = prioritizeHTMLFile(data.files);
+          dispatcher.enqueue(dispatcher.events.OPEN_FILES, files);
+          socket.ready("Ready to compile...");
+        });
+
+        socket.on("open_window", (data: IGitpodData) => {
+          Console.debug("Opening window: ", data);
+          dispatcher.enqueue(dispatcher.events.OPEN_WINDOW, data);
+          socket.ready("Ready to compile...");
+        });
+
+        socket.on("reset", (exercise: IExerciseData) => {
+          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 as TypeError).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: IExerciseData) => {
+          const exercise = this.configManager?.getExercise(data.exerciseSlug);
+
+          if (!exercise?.language) {
+            socket.error(
+              "compiler-error",
+              "Impossible to detect language to build for " +
+                data.exerciseSlug +
+                "..."
+            );
+            return;
+          }
+
+          socket.log(
+            "compiling",
+            "Building exercise " +
+              data.exerciseSlug +
+              " with " +
+              exercise.language +
+              "..."
+          );
+          await this.config.runHook("action", {
+            action: "compile",
+            socket,
+            configuration: config,
+            exercise,
+          });
+        });
+
+        socket.on("test", async (data: IExerciseData) => {
+          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?.disabledActions!.includes("test") ||
+            config?.disableGrading
+          ) {
+            socket.ready("Grading is disabled on configuration");
+            return true;
+          }
+
+          socket.log(
+            "testing",
+            "Testing your exercise using the " + exercise.language + " engine."
+          );
+
+          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
+        // eslint-disable-next-line
+        if (StartCommand.flags.watch) this.configManager.watchIndex(_exercises => socket.reload(null, _exercises));
+      }
+    }
+  }
+}

package/src/commands/{test.js → test.ts}

@@ -1,42 +1,40 @@
-const Console = require("../utils/console");
-const SessionCommand = require("../utils/SessionCommand");
-const socket = require("../managers/socket.js");
+import Console from "../utils/console";
+import SessionCommand from "../utils/SessionCommand";
+import socket from "../managers/socket";
 
-const createServer = require("../managers/server");
-const ExercisesQueue = require("../utils/exercisesQueue");
+import createServer from "../managers/server";
+import ExercisesQueue from "../utils/exercisesQueue";
+import { IExercise } from "../models/exercise-obj";
 
 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();
+    this.configManager?.buildIndex();
 
-    let exercises = [];
+    let exercises: IExercise[] | undefined = [];
 
     // test all exercises
-    if (!exerciseSlug) {
-      exercises = this.configManager.getAllExercises();
-    } else {
-      exercises = [this.configManager.getExercise(exerciseSlug)];
-    }
+    !exerciseSlug ? exercises = this.configManager?.getAllExercises() : exercises = [this.configManager!.getExercise(exerciseSlug)];
 
     const exercisesQueue = new ExercisesQueue(exercises);
 
-    const configObject = this.configManager.get();
+    const configObject = this.configManager?.get();
 
     let hasFailed = false;
     let failedTestsCount = 0;
     let successTestsCount = 0;
-    let testsToRunCount = exercisesQueue.size();
+    const testsToRunCount = exercisesQueue.size();
 
-    configObject.config.testingFinishedCallback = ({ result }) => {
+    configObject!.config!.testingFinishedCallback = ({ result }) => {
       if (result === "failed") {
         hasFailed = true;
         failedTestsCount++;
@@ -57,17 +55,17 @@ class TestCommand extends SessionCommand {
 
         process.exit(hasFailed ? 1 : 0);
       } else {
-        exercisesQueue.pop().test(this.config, config, socket);
+        exercisesQueue.pop()!.test!(this.config, config!, socket);
       }
     };
 
-    const { config } = configObject;
+    const config = configObject?.config;
 
-    const server = await createServer(configObject, this.configManager, true);
+    const server = await createServer(configObject!, this.configManager!, true);
 
-    socket.start(config, server, true);
+    socket.start(config!, server, true);
 
-    exercisesQueue.pop().test(this.config, config, socket);
+    exercisesQueue.pop()!.test!(this.config, config!, socket);
   }
 }
 
@@ -82,4 +80,4 @@ TestCommand.args = [
   },
 ];
 
-module.exports = TestCommand;
+export default TestCommand;

package/src/index.ts

@@ -0,0 +1 @@
+export * from '@oclif/command'