@learnpack/learnpack 2.0.2 → 2.0.5

package/src/managers/test.ts

@@ -1,83 +1,83 @@
-/*
-
-import * as path from 'path'
-import * as shell from 'shelljs'
-import * as fs from 'fs'
-import { TestingError } from './errors'
-import Console from '../utils/console'
-import * as color from 'colors'
-import bcActivity from './bcActivity.js'
-import { CompilerError } from '../utils/errors'
-import { ISocket } from '../models/socket'
-import { IFile } from '../models/file'
-import { IConfig } from '@oclif/config'
-
-module.exports = async function ({ socket, files, config, slug }: {socket: ISocket, files: IFile[], config: IConfig, slug: string}) {
-
-  const configPath = path.resolve(__dirname, `./config/tester/${config.tester}/${config.language}.config.js`);
-  if (!fs.existsSync(configPath)) throw CompilerError(`Uknown testing engine for compiler: '${config.language}'`);
-
-  const testingConfig = require(configPath)(files, config, slug);
-  testingConfig.validate();
-
-  if (config.ignoreTests) throw TestingError('Grading is disabled on learn.json file.');
-
-  if (!fs.existsSync(`${config.dirPath}/reports`)) {
-    fs.mkdirSync(`${config.dirPath}/reports`);
-    Console.debug(`Creating the ${config.dirPath}/reports directory`);
-  }
-
-  Console.info('Running tests...');
-
-  const command = await testingConfig.getCommand(socket)
-  const { stdout, stderr, code } = shell.exec(command);
-
-  if (code != 0) {
-    const errors = typeof (testingConfig.getErrors === 'function') ? testingConfig.getErrors(stdout || stderr) : [];
-    socket.log('testing-error', errors);
-    console.log(errors.join('\n'))
-
-    Console.error("There was an error while testing");
-    bcActivity.error('exercise_error', {
-      message: errors,
-      name: `${config.tester}-error`,
-      framework: config.tester,
-      language: config.language,
-      data: slug,
-      compiler: config.compiler
-    });
-  }
-  else {
-    socket.log('testing-success', [stdout || stderr].concat(["😁Everything is amazing!"]));
-    Console.success("Everything is amazing!");
-
-    bcActivity.activity('exercise_success', {
-      language: config.language,
-      slug: slug,
-      editor: config.editor,
-      compiler: config.compiler
-    });
-    config.exercises = config.exercises.map(e => {
-      if (e.slug === slug) e.done = true;
-      return e;
-    });
-  }
-
-  if (typeof testingConfig.cleanup !== "undefined") {
-    if (typeof testingConfig.cleanup === 'function' || typeof testingConfig.cleanup === 'object') {
-      const clean = await testingConfig.cleanup(socket);
-      if (clean) {
-        const { stdout, stderr, code } = shell.exec(clean);
-        if (code == 0) {
-          Console.debug("The cleanup command runned successfully");
-        }
-        else Console.warning("There is an error on the cleanup command for the test");
-      }
-
-    }
-  }
-
-  return true;
-};
-
-*/
+/*
+
+import * as path from 'path'
+import * as shell from 'shelljs'
+import * as fs from 'fs'
+import { TestingError } from './errors'
+import Console from '../utils/console'
+import * as color from 'colors'
+import bcActivity from './bcActivity.js'
+import { CompilerError } from '../utils/errors'
+import { ISocket } from '../models/socket'
+import { IFile } from '../models/file'
+import { IConfig } from '@oclif/config'
+
+module.exports = async function ({ socket, files, config, slug }: {socket: ISocket, files: IFile[], config: IConfig, slug: string}) {
+
+  const configPath = path.resolve(__dirname, `./config/tester/${config.tester}/${config.language}.config.js`);
+  if (!fs.existsSync(configPath)) throw CompilerError(`Uknown testing engine for compiler: '${config.language}'`);
+
+  const testingConfig = require(configPath)(files, config, slug);
+  testingConfig.validate();
+
+  if (config.ignoreTests) throw TestingError('Grading is disabled on learn.json file.');
+
+  if (!fs.existsSync(`${config.dirPath}/reports`)) {
+    fs.mkdirSync(`${config.dirPath}/reports`);
+    Console.debug(`Creating the ${config.dirPath}/reports directory`);
+  }
+
+  Console.info('Running tests...');
+
+  const command = await testingConfig.getCommand(socket)
+  const { stdout, stderr, code } = shell.exec(command);
+
+  if (code != 0) {
+    const errors = typeof (testingConfig.getErrors === 'function') ? testingConfig.getErrors(stdout || stderr) : [];
+    socket.log('testing-error', errors);
+    console.log(errors.join('\n'))
+
+    Console.error("There was an error while testing");
+    bcActivity.error('exercise_error', {
+      message: errors,
+      name: `${config.tester}-error`,
+      framework: config.tester,
+      language: config.language,
+      data: slug,
+      compiler: config.compiler
+    });
+  }
+  else {
+    socket.log('testing-success', [stdout || stderr].concat(["😁Everything is amazing!"]));
+    Console.success("Everything is amazing!");
+
+    bcActivity.activity('exercise_success', {
+      language: config.language,
+      slug: slug,
+      editor: config.editor,
+      compiler: config.compiler
+    });
+    config.exercises = config.exercises.map(e => {
+      if (e.slug === slug) e.done = true;
+      return e;
+    });
+  }
+
+  if (typeof testingConfig.cleanup !== "undefined") {
+    if (typeof testingConfig.cleanup === 'function' || typeof testingConfig.cleanup === 'object') {
+      const clean = await testingConfig.cleanup(socket);
+      if (clean) {
+        const { stdout, stderr, code } = shell.exec(clean);
+        if (code == 0) {
+          Console.debug("The cleanup command runned successfully");
+        }
+        else Console.warning("There is an error on the cleanup command for the test");
+      }
+
+    }
+  }
+
+  return true;
+};
+
+*/

package/src/plugin/plugin.ts

@@ -1,94 +1,94 @@
-import * as shell from "shelljs";
-import { IPluginConfig } from "../models/plugin-config";
-/**
- * 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.
- */
-export default (pluginConfig: IPluginConfig) => {
-  return async (args: any) => {
-    const { action, exercise, socket, configuration } = args;
-
-    if (pluginConfig.language === undefined)
-      throw new Error(`Missing language on the plugin configuration object`);
-
-    if (typeof action !== "string") {
-      throw new TypeError("Missing action property on hook details");
-    }
-
-    if (!exercise || exercise === undefined) {
-      throw new Error("Missing exercise information");
-    }
-
-    type actionType = "compile" | "test";
-
-    // if the action does not exist I don't do anything
-    if (pluginConfig[action as actionType] === 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 new Error(`No files to process`);
-    }
-
-    try {
-      const _action = pluginConfig[action as actionType];
-
-      if (_action === null || typeof _action !== "object")
-        throw new Error(
-          `The ${pluginConfig.language} ${action} module must export an object configuration`
-        );
-      if (_action.validate === undefined)
-        throw new Error(
-          `Missing validate method for ${pluginConfig.language} ${action}`
-        );
-      if (_action.run === undefined)
-        throw new Error(
-          `Missing run method for ${pluginConfig.language} ${action}`
-        );
-      if (_action.dependencies !== undefined) {
-        if (!Array.isArray(_action.dependencies))
-          throw new Error(
-            `${action}.dependencies must be an array of package names`
-          );
-
-        for (const packageName of _action.dependencies) {
-          if (!shell.which(packageName)) {
-            throw new 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 as actionType], stdout);
-        return stdout;
-      }
-    } catch (error: any) {
-      if (error.type === undefined) 
-socket.fatal(error);
-      else 
-socket.error(error.type, error.stdout);
-    }
-  };
-};
+import * as shell from "shelljs";
+import { IPluginConfig } from "../models/plugin-config";
+/**
+ * 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.
+ */
+export default (pluginConfig: IPluginConfig) => {
+  return async (args: any) => {
+    const { action, exercise, socket, configuration } = args;
+
+    if (pluginConfig.language === undefined)
+      throw new Error(`Missing language on the plugin configuration object`);
+
+    if (typeof action !== "string") {
+      throw new TypeError("Missing action property on hook details");
+    }
+
+    if (!exercise || exercise === undefined) {
+      throw new Error("Missing exercise information");
+    }
+
+    type actionType = "compile" | "test";
+
+    // if the action does not exist I don't do anything
+    if (pluginConfig[action as actionType] === 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 new Error(`No files to process`);
+    }
+
+    try {
+      const _action = pluginConfig[action as actionType];
+
+      if (_action === null || typeof _action !== "object")
+        throw new Error(
+          `The ${pluginConfig.language} ${action} module must export an object configuration`
+        );
+      if (_action.validate === undefined)
+        throw new Error(
+          `Missing validate method for ${pluginConfig.language} ${action}`
+        );
+      if (_action.run === undefined)
+        throw new Error(
+          `Missing run method for ${pluginConfig.language} ${action}`
+        );
+      if (_action.dependencies !== undefined) {
+        if (!Array.isArray(_action.dependencies))
+          throw new Error(
+            `${action}.dependencies must be an array of package names`
+          );
+
+        for (const packageName of _action.dependencies) {
+          if (!shell.which(packageName)) {
+            throw new 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 as actionType], stdout);
+        return stdout;
+      }
+    } catch (error: any) {
+      if (error.type === undefined) 
+socket.fatal(error);
+      else 
+socket.error(error.type, error.stdout);
+    }
+  };
+};

package/src/plugin/utils.ts

@@ -1,87 +1,87 @@
-import * as chalk from "chalk";
-
-const getMatches = (reg: RegExp, content: string) => {
-  const 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: string, inputs: string[]) => {
-  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: string, options: any, count = 1) => {
-  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: string, ...args: any[]) => console.log(chalk.gray(msg), ...args),
-  error: (msg: string, ...args: any[]) =>
-    console.log(chalk.red("⨉ " + msg), ...args),
-  success: (msg: string, ...args: any[]) =>
-    console.log(chalk.green("✓ " + msg), ...args),
-  info: (msg: string, ...args: any[]) =>
-    console.log(chalk.blue("ⓘ " + msg), ...args),
-  help: (msg: string) =>
-    console.log(`${chalk.white.bold("⚠ help:")} ${chalk.white(msg)}`),
-  debug(...args: any[]) {
-    this._debug && console.log(chalk.magentaBright(`⚠ debug: `), args);
-  },
-};
-
-export default { getMatches, cleanStdout, indent, Console };
+import * as chalk from "chalk";
+
+const getMatches = (reg: RegExp, content: string) => {
+  const 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: string, inputs: string[]) => {
+  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: string, options: any, count = 1) => {
+  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: string, ...args: any[]) => console.log(chalk.gray(msg), ...args),
+  error: (msg: string, ...args: any[]) =>
+    console.log(chalk.red("⨉ " + msg), ...args),
+  success: (msg: string, ...args: any[]) =>
+    console.log(chalk.green("✓ " + msg), ...args),
+  info: (msg: string, ...args: any[]) =>
+    console.log(chalk.blue("ⓘ " + msg), ...args),
+  help: (msg: string) =>
+    console.log(`${chalk.white.bold("⚠ help:")} ${chalk.white(msg)}`),
+  debug(...args: any[]) {
+    this._debug && console.log(chalk.magentaBright(`⚠ debug: `), args);
+  },
+};
+
+export default { getMatches, cleanStdout, indent, Console };

package/src/utils/BaseCommand.ts

@@ -1,48 +1,48 @@
-import { Command } from "@oclif/command";
-import Console from "./console";
-import { createInterface } from "readline";
-// import SessionManager from '../managers/session'
-
-class BaseCommand extends Command {
-  async catch(err: any) {
-    Console.debug("COMMAND CATCH", err);
-
-    throw err;
-  }
-
-  async init() {
-    const { flags, args } = this.parse(BaseCommand);
-    Console.debug("COMMAND INIT");
-    Console.debug("These are your flags: ", flags);
-    Console.debug("These are your args: ", args);
-
-    // quick fix for listening to the process termination on windows
-    if (process.platform === "win32") {
-      const rl = createInterface({
-        input: process.stdin,
-        output: process.stdout,
-      });
-
-      rl.on("SIGINT", function () {
-        // process.emit('SIGINT')
-        // process.emit('SIGINT')
-      });
-    }
-
-    process.on("SIGINT", function () {
-      Console.debug("Terminated (SIGINT)");
-      process.exit();
-    });
-  }
-
-  async finally() {
-    Console.debug("COMMAND FINALLY");
-    // called after run and catch regardless of whether or not the command errored
-  }
-
-  async run() {
-    // console.log('running my command')
-  }
-}
-
-export default BaseCommand;
+import { Command } from "@oclif/command";
+import Console from "./console";
+import { createInterface } from "readline";
+// import SessionManager from '../managers/session'
+
+class BaseCommand extends Command {
+  async catch(err: any) {
+    Console.debug("COMMAND CATCH", err);
+
+    throw err;
+  }
+
+  async init() {
+    const { flags, args } = this.parse(BaseCommand);
+    Console.debug("COMMAND INIT");
+    Console.debug("These are your flags: ", flags);
+    Console.debug("These are your args: ", args);
+
+    // quick fix for listening to the process termination on windows
+    if (process.platform === "win32") {
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      rl.on("SIGINT", function () {
+        // process.emit('SIGINT')
+        // process.emit('SIGINT')
+      });
+    }
+
+    process.on("SIGINT", function () {
+      Console.debug("Terminated (SIGINT)");
+      process.exit();
+    });
+  }
+
+  async finally() {
+    Console.debug("COMMAND FINALLY");
+    // called after run and catch regardless of whether or not the command errored
+  }
+
+  async run() {
+    // console.log('running my command')
+  }
+}
+
+export default BaseCommand;