@learnpack/learnpack 1.0.0 → 2.0.0

package/src/plugin/utils.ts

@@ -0,0 +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 };

package/src/types/node-fetch.d.ts

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

package/src/ui/download.ts

@@ -0,0 +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}

package/src/utils/BaseCommand.ts

@@ -0,0 +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;

package/src/utils/SessionCommand.ts

@@ -0,0 +1,48 @@
+// import { flags } from "@oclif/command";
+import BaseCommand from './BaseCommand'
+import Console from './console'
+import SessionManager from '../managers/session'
+import configManager from '../managers/config/index'
+import {AuthError} from './errors'
+import {IConfigManager} from '../models/config-manager'
+
+export default class SessionCommand extends BaseCommand {
+  session: any = null
+  configManager: IConfigManager | null = null
+  static flags: any
+
+  async initSession(flags: any, _private = false) {
+    try {
+      if (!this.configManager) {
+        await this.buildConfig(flags)
+      }
+
+      this.session = await SessionManager.get(this.configManager?.get())
+      if (this.session) {
+        Console.debug(`Session open for ${this.session.payload.email}.`)
+      } else {
+        if (_private)
+          throw AuthError(
+            'You need to log in, run the following command to continue: $ learnpack login',
+          )
+        Console.debug('No active session available', _private)
+      }
+    } catch (error) {
+      Console.error((error as TypeError).message)
+    }
+  }
+
+  async buildConfig(flags: any) {
+    this.configManager = await configManager(flags)
+  }
+
+  async catch(err: any) {
+    Console.debug('COMMAND CATCH', err)
+    throw err
+  }
+}
+
+// SessionCommand.description = `Describe the command here
+// ...
+// Extra documentation goes here
+// `

package/src/utils/api.ts

@@ -0,0 +1,194 @@
+import Console from "../utils/console";
+import * as storage from "node-persist";
+import cli from "cli-ux";
+const HOST = "https://learnpack.herokuapp.com";
+
+// eslint-disable-next-line
+const _fetch = require("node-fetch");
+
+interface IHeaders {
+  "Content-Type"?: string;
+  Authorization?: string;
+}
+
+interface IOptions {
+  headers?: IHeaders;
+  method?: string;
+  body?: string;
+}
+
+const fetch = async (url: string, options: IOptions = {}) => {
+  const headers: IHeaders = { "Content-Type": "application/json" };
+  let session = null;
+  try {
+    session = await storage.getItem("bc-payload");
+    if (session.token && session.token !== "" && !url.includes("/token"))
+      headers.Authorization = "Token " + session.token;
+  } catch {}
+
+  try {
+    const resp = await _fetch(url, {
+      ...options,
+      headers: { ...headers, ...options.headers },
+    } as any);
+
+    if (resp.status >= 200 && resp.status < 300) 
+return await resp.json();
+    if (resp.status === 401)
+      throw APIError("Invalid authentication credentials", 401);
+    else if (resp.status === 404) 
+throw APIError("Package not found", 404);
+    else if (resp.status >= 500)
+      throw APIError("Impossible to connect with the server", 500);
+    else if (resp.status >= 400) {
+      const error = await resp.json();
+      if (error.detail || error.error) {
+        throw APIError(error.detail || error.error);
+      } else if (error.nonFieldErrors) {
+        throw APIError(error.nonFieldErrors[0], error);
+      } else if (typeof error === "object") {
+        if (Object.keys(error).length > 0) {
+          const key = error[Object.keys(error)[0]];
+          throw APIError(`${key}: ${error[key][0]}`, error);
+        }
+      } else {
+        throw APIError("Uknown error");
+      }
+    } else 
+throw APIError("Uknown error");
+  } catch (error) {
+    Console.error((error as TypeError).message);
+    throw error;
+  }
+};
+
+const login = async (identification: string, password: string) => {
+  try {
+    cli.action.start("Looking for credentials...");
+    await cli.wait(1000);
+    const data = await fetch(`${HOST}/v1/auth/token/`, {
+      body: JSON.stringify({ identification, password }),
+      method: "post",
+    });
+    cli.action.stop("ready");
+    return data;
+  } catch (error) {
+    Console.error((error as TypeError).message);
+    Console.debug(error);
+  }
+};
+
+const publish = async (config: any) => {
+  const keys = [
+    "difficulty",
+    "language",
+    "skills",
+    "technologies",
+    "slug",
+    "repository",
+    "author",
+    "title",
+  ];
+
+  const payload: { [key: string]: string } = {};
+  for (const k of keys) 
+config[k] ? (payload[k] = config[k]) : null;
+  try {
+    console.log("Package to publish:", payload);
+    cli.action.start("Updating package information...");
+    await cli.wait(1000);
+    const data = await fetch(`${HOST}/v1/package/${config.slug}`, {
+      method: "PUT",
+      body: JSON.stringify(payload),
+    });
+    cli.action.stop("ready");
+    return data;
+  } catch (error) {
+    console.log("payload", payload);
+    Console.error((error as TypeError).message);
+    Console.debug(error);
+    throw error;
+  }
+};
+
+const update = async (config: any) => {
+  try {
+    cli.action.start("Updating package information...");
+    await cli.wait(1000);
+    const data = await fetch(`${HOST}/v1/package/`, {
+      method: "POST",
+      body: JSON.stringify(config),
+    });
+    cli.action.stop("ready");
+    return data;
+  } catch (error) {
+    Console.error((error as any).message);
+    Console.debug(error);
+    throw error;
+  }
+};
+
+const getPackage = async (slug: string) => {
+  try {
+    cli.action.start("Downloading package information...");
+    await cli.wait(1000);
+    const data = await fetch(`${HOST}/v1/package/${slug}`);
+    cli.action.stop("ready");
+    return data;
+  } catch (error) {
+    if ((error as any).status === 404)
+      Console.error(`Package ${slug} does not exist`);
+    else 
+Console.error(`Package ${slug} does not exist`);
+    Console.debug(error);
+    throw error;
+  }
+};
+
+const getLangs = async () => {
+  try {
+    cli.action.start("Downloading language options...");
+    await cli.wait(1000);
+    const data = await fetch(`${HOST}/v1/package/language`);
+    cli.action.stop("ready");
+    return data;
+  } catch (error) {
+    if ((error as any).status === 404)
+      Console.error("Package slug does not exist");
+    else 
+Console.error("Package slug does not exist");
+    Console.debug(error);
+    throw error;
+  }
+};
+
+const getAllPackages = async ({
+  lang = "",
+  slug = "",
+}: {
+  lang?: string;
+  slug?: string;
+}) => {
+  try {
+    cli.action.start("Downloading packages...");
+    await cli.wait(1000);
+    const data = await fetch(
+      `${HOST}/v1/package/all?limit=100&language=${lang}&slug=${slug}`
+    );
+    cli.action.stop("ready");
+    return data;
+  } catch (error) {
+    Console.error(`Package ${slug} does not exist`);
+    Console.debug(error);
+    throw error;
+  }
+};
+
+const APIError = (error: TypeError | string, code?: number) => {
+  const message: string = (error as TypeError).message || (error as string);
+  const _err = new Error(message) as any;
+  _err.status = code || 400;
+  return _err;
+};
+
+export default { login, publish, update, getPackage, getLangs, getAllPackages };

package/src/utils/audit.ts

@@ -0,0 +1,162 @@
+import {IAuditErrors} from '../models/audit-errors'
+import {IConfigObj} from '../models/config'
+import {ICounter} from '../models/counter'
+import {IFindings} from '../models/findings'
+import Console from './console'
+
+// eslint-disable-next-line
+const fetch = require("node-fetch");
+import * as fs from 'fs'
+
+export default {
+  // This function checks if a url is valid.
+  isUrl: async (url: string, errors: IAuditErrors[], counter: ICounter) => {
+    const regexUrl = /(https?:\/\/[\w./-]+)/gm
+    counter.links.total++
+    if (!regexUrl.test(url)) {
+      counter.links.error++
+      errors.push({
+        exercise: undefined,
+        msg: `The repository value of the configuration file is not a link: ${url}`,
+      })
+      return false
+    }
+
+    const res = await fetch(url, {method: 'HEAD'})
+    if (!res.ok) {
+      counter.links.error++
+      errors.push({
+        exercise: undefined,
+        msg: `The link of the repository is broken: ${url}`,
+      })
+    }
+
+    return true
+  },
+  checkForEmptySpaces: (str: string) => {
+    const isEmpty = true
+    for (const letter of str) {
+      if (letter !== ' ') {
+        return false
+      }
+    }
+
+    return isEmpty
+  },
+  checkLearnpackClean: (configObj: IConfigObj, errors: IAuditErrors[]) => {
+    if (
+      (configObj.config?.outputPath &&
+        fs.existsSync(configObj.config?.outputPath)) ||
+      fs.existsSync(`${configObj.config?.dirPath}/_app`) ||
+      fs.existsSync(`${configObj.config?.dirPath}/reports`) ||
+      fs.existsSync(`${configObj.config?.dirPath}/resets`) ||
+      fs.existsSync(`${configObj.config?.dirPath}/app.tar.gz`) ||
+      fs.existsSync(`${configObj.config?.dirPath}/config.json`) ||
+      fs.existsSync(`${configObj.config?.dirPath}/vscode_queue.json`)
+    ) {
+      errors.push({
+        exercise: undefined,
+        msg: 'You have to run learnpack clean command',
+      })
+    }
+  },
+  findInFile: (types: string[], content: string) => {
+    const regex: any = {
+      relativeImages:
+        /!\[.*]\s*\((((\.\/)?(\.{2}\/){1,5})(.*\/)*(.[^\s/]*\.[A-Za-z]{2,4})\S*)\)/gm,
+      externalImages: /!\[.*]\((https?:\/(\/[^)/]+)+\/?)\)/gm,
+      markdownLinks: /(\s)+\[.*]\((https?:\/(\/[^)/]+)+\/?)\)/gm,
+      url: /(https?:\/\/[\w./-]+)/gm,
+      uploadcare: /https:\/\/ucarecdn.com\/(?:.*\/)*([\w./-]+)/gm,
+    }
+
+    const validTypes = Object.keys(regex)
+    if (!Array.isArray(types))
+      types = [types]
+
+    const findings: IFindings = {}
+    type findingsType =
+      | 'relativeImages'
+      | 'externalImages'
+      | 'markdownLinks'
+      | 'url'
+      | 'uploadcare';
+
+    for (const type of types) {
+      if (!validTypes.includes(type))
+        throw new Error('Invalid type: ' + type)
+      else
+        findings[type as findingsType] = {}
+    }
+
+    for (const type of types) {
+      let m: RegExpExecArray
+      while ((m = regex[type].exec(content)) !== null) {
+        // This is necessary to avoid infinite loops with zero-width matches
+        if (m.index === regex.lastIndex) {
+          regex.lastIndex++
+        }
+
+        // The result can be accessed through the `m`-variable.
+        // m.forEach((match, groupIndex) => values.push(match));
+
+        findings[type as findingsType]![m[0]] = {
+          content: m[0],
+          absUrl: m[1],
+          mdUrl: m[2],
+          relUrl: m[6],
+        }
+      }
+    }
+
+    return findings
+  },
+  // This function checks if there are errors, and show them in the console at the end.
+  showErrors: (errors: IAuditErrors[], counter: ICounter) => {
+    return new Promise((resolve, reject) => {
+      if (errors) {
+        if (errors.length > 0) {
+          Console.log('Checking for errors...')
+          for (const [i, error] of errors.entries())
+            Console.error(
+              `${i + 1}) ${error.msg} ${
+                error.exercise ? `(Exercise: ${error.exercise})` : ''
+              }`,
+            )
+
+          Console.error(
+            ` We found ${errors.length} errors among ${counter.images.total} images, ${counter.links.total} link, ${counter.readmeFiles} README files and ${counter.exercises} exercises.`,
+          )
+          process.exit(1)
+        } else {
+          Console.success(
+            `We didn't find any errors in this repository among ${counter.images.total} images, ${counter.links.total} link, ${counter.readmeFiles} README files and ${counter.exercises} exercises.`,
+          )
+          process.exit(0)
+        }
+      } else {
+        reject('Failed')
+      }
+    })
+  },
+  // This function checks if there are warnings, and show them in the console at the end.
+  showWarnings: (warnings: IAuditErrors[]) => {
+    return new Promise((resolve, reject) => {
+      if (warnings) {
+        if (warnings.length > 0) {
+          Console.log('Checking for warnings...')
+          for (const [i, warning] of warnings.entries())
+            Console.warning(
+              `${i + 1}) ${warning.msg} ${
+                warning.exercise ? `File: ${warning.exercise}` : ''
+              }`,
+            )
+        }
+
+        resolve('SUCCESS')
+      } else {
+        reject('Failed')
+      }
+    })
+  },
+}

package/src/utils/console.ts

@@ -0,0 +1,24 @@
+import * as chalk from 'chalk'
+
+export default {
+  // _debug: true,
+  _debug: process.env.DEBUG === 'true',
+  startDebug: function () {
+    this._debug = true
+  },
+  log: (msg: string | Array<string>, ...args: Array<any>) =>
+    console.log(chalk.gray(msg), ...args),
+  error: (msg: string, ...args: Array<any>) =>
+    console.log(chalk.red('⨉ ' + msg), ...args),
+  success: (msg: string, ...args: Array<any>) =>
+    console.log(chalk.green('✓ ' + msg), ...args),
+  info: (msg: string, ...args: Array<any>) =>
+    console.log(chalk.blue('ⓘ ' + msg), ...args),
+  help: (msg: string) =>
+    console.log(`${chalk.white.bold('⚠ help:')} ${chalk.white(msg)}`),
+  debug(...args: Array<any>) {
+    this._debug && console.log(chalk.magentaBright('⚠ debug: '), args)
+  },
+  warning: (msg: string) =>
+    console.log(`${chalk.yellow('⚠ warning:')} ${chalk.yellow(msg)}`),
+}