@learnpack/learnpack 5.0.7 → 5.0.8

package/src/plugin/command/test.ts

@@ -1,30 +1,30 @@
-import * as fs from "fs"
-import { IError } from "../../models/errors"
-
-const TestingError = (messages: string) => {
-  const _err: IError = new Error(messages)
-  _err.status = 400
-  _err.stdout = messages
-  _err.type = "testing-error"
-  return _err
-}
-
-export default {
-  TestingError,
-  default: async function (args: any) {
-    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
-  },
-}
+import * as fs from "fs"
+import { IError } from "../../models/errors"
+
+const TestingError = (messages: string) => {
+  const _err: IError = new Error(messages)
+  _err.status = 400
+  _err.stdout = messages
+  _err.type = "testing-error"
+  return _err
+}
+
+export default {
+  TestingError,
+  default: async function (args: any) {
+    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/src/plugin/index.ts

@@ -1,6 +1,6 @@
-import CompilationError from "./command/compile"
-import TestingError from "./command/test"
-import utils from "./utils"
-import plugin from "./plugin"
-
-export default { CompilationError, TestingError, Utils: utils, plugin }
+import CompilationError from "./command/compile"
+import TestingError from "./command/test"
+import utils from "./utils"
+import plugin from "./plugin"
+
+export default { CompilationError, TestingError, Utils: utils, plugin }

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}