@learnpack/learnpack 2.1.25 → 2.1.26

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/types/node-fetch.d.ts

@@ -1 +1 @@
-declare module '*';
+declare module '*';

package/src/ui/download.ts

@@ -1,71 +1,71 @@
-import {prompt} from 'enquirer'
-import Console from '../utils/console'
-import api from '../utils/api'
-// import fetch from 'node-fetch'
-
-import {ILanguage} from '../models/language'
-import {IPackage} from '../models/package'
-
-export const askPackage = async () => {
-  Console.info('No package was specified')
-  const languages = await api.getLangs()
-
-  return new Promise((resolve, reject) => {
-    if (languages.length === 0) {
-      // reject(new Error('No categories available'))
-      reject('No categories available')
-      // return null;
-    }
-
-    // let packages = []
-    prompt([
-      {
-        type: 'select',
-        name: 'lang',
-        message: 'What language do you want to practice?',
-        choices: languages.map((l: ILanguage) => ({
-          message: l.title,
-          name: l.slug,
-        })),
-      },
-    ])
-    .then(({lang}: any) => {
-      return (async () => {
-        const response = await api.getAllPackages({lang})
-        const packages = response.results
-        if (packages.length === 0) {
-          const error = new Error(`No packages found for language ${lang}`)
-          Console.error(error.message) // TODO: Look this
-          return error
-        }
-
-        return prompt([
-          {
-            type: 'select',
-            name: 'pack',
-            message: 'Choose one of the packages available',
-            choices: packages.map((l: IPackage) => ({
-              message: `${l.title}, difficulty: ${l.difficulty}, downloads: ${
-                l.downloads
-              } ${
-                l.skills.length > 0 ? `(Skills: ${l.skills.join(',')})` : ''
-              }`,
-              name: l.slug,
-            })),
-          },
-        ])
-      })()
-    })
-    .then((resp: any) => {
-      if (!resp)
-        reject(resp.message || resp)
-      else
-        resolve(resp.pack)
-    })
-    .catch(error => {
-      Console.error(error.message || error)
-    })
-  })
-}
-
-export default {askPackage}
+import {prompt} from 'enquirer'
+import Console from '../utils/console'
+import api from '../utils/api'
+// import fetch from 'node-fetch'
+
+import {ILanguage} from '../models/language'
+import {IPackage} from '../models/package'
+
+export const askPackage = async () => {
+  Console.info('No package was specified')
+  const languages = await api.getLangs()
+
+  return new Promise((resolve, reject) => {
+    if (languages.length === 0) {
+      // reject(new Error('No categories available'))
+      reject('No categories available')
+      // return null;
+    }
+
+    // let packages = []
+    prompt([
+      {
+        type: 'select',
+        name: 'lang',
+        message: 'What language do you want to practice?',
+        choices: languages.map((l: ILanguage) => ({
+          message: l.title,
+          name: l.slug,
+        })),
+      },
+    ])
+    .then(({lang}: any) => {
+      return (async () => {
+        const response = await api.getAllPackages({lang})
+        const packages = response.results
+        if (packages.length === 0) {
+          const error = new Error(`No packages found for language ${lang}`)
+          Console.error(error.message) // TODO: Look this
+          return error
+        }
+
+        return prompt([
+          {
+            type: 'select',
+            name: 'pack',
+            message: 'Choose one of the packages available',
+            choices: packages.map((l: IPackage) => ({
+              message: `${l.title}, difficulty: ${l.difficulty}, downloads: ${
+                l.downloads
+              } ${
+                l.skills.length > 0 ? `(Skills: ${l.skills.join(',')})` : ''
+              }`,
+              name: l.slug,
+            })),
+          },
+        ])
+      })()
+    })
+    .then((resp: any) => {
+      if (!resp)
+        reject(resp.message || resp)
+      else
+        resolve(resp.pack)
+    })
+    .catch(error => {
+      Console.error(error.message || error)
+    })
+  })
+}
+
+export default {askPackage}

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;