@learnpack/learnpack 2.1.43 → 2.1.45

package/src/models/config.ts

@@ -1,91 +1,91 @@
-import { IExercise } from "./exercise-obj"
-import { TTelemetryUrls } from "../managers/telemetry"
-
-export type TGrading = "isolated" | "incremental" | "no-grading";
-
-export type TMode = "preview" | "extension";
-
-export type TConfigAction =
-  | "test"
-  | "build"
-  | "tutorial"
-  | "reset"
-  | "generate";
-
-export type TConfigObjAttributes = "config" | "exercises" | "grading";
-
-export type TCompiler =
-  | "webpack"
-  | "vanillajs"
-  | "react"
-  | "html"
-  | "node"
-  | "python"
-  | "css";
-
-export interface IConfigPath {
-  base: string;
-}
-
-type TAgent = "vscode" | "os";
-
-export interface IEditor {
-  mode?: TMode;
-  version: string;
-  agent?: TAgent;
-}
-
-export interface TEntries {
-  python3?: string;
-  html?: string;
-  node?: string;
-  react?: string;
-  java?: string;
-}
-
-export interface IConfig {
-  os: string;
-  port?: string;
-  repository?: string;
-  description?: string;
-  slug?: string;
-  dirPath: string;
-  preview?: string; // Picture thumbnail
-  entries: TEntries;
-  grading: TGrading;
-  configPath: string;
-  translations: Array<string>;
-  outputPath?: string;
-  editor: IEditor;
-  language: string;
-  title: string;
-  duration: number;
-  difficulty?: string;
-  exercisesPath: string;
-  disableGrading: boolean; // TODO: Deprecate
-  actions: Array<string>; // TODO: Deprecate
-  autoPlay: boolean;
-  projectType?: string;
-  // TODO: nameExerciseValidation
-  contact?: string;
-  disabledActions?: Array<TConfigAction>;
-  compiler: TCompiler;
-  compilers: Array<TCompiler>;
-  publicPath: string;
-  publicUrl?: string;
-  bugsLink?: string;
-  videoSolutions?: boolean;
-  skills: Array<string>;
-  telemetry?: TTelemetryUrls;
-  runHook: (...agrs: Array<any>) => void;
-  testingFinishedCallback: (arg: any | undefined) => void;
-}
-
-export interface IConfigObj {
-  session?: number;
-  currentExercise?: any;
-  config?: IConfig;
-  exercises?: Array<IExercise>;
-  confPath?: IConfigPath;
-  address?: string; // Maybe
-}
+import { IExercise } from "./exercise-obj"
+import { TTelemetryUrls } from "../managers/telemetry"
+
+export type TGrading = "isolated" | "incremental" | "no-grading";
+
+export type TMode = "preview" | "extension";
+
+export type TConfigAction =
+  | "test"
+  | "build"
+  | "tutorial"
+  | "reset"
+  | "generate";
+
+export type TConfigObjAttributes = "config" | "exercises" | "grading";
+
+export type TCompiler =
+  | "webpack"
+  | "vanillajs"
+  | "react"
+  | "html"
+  | "node"
+  | "python"
+  | "css";
+
+export interface IConfigPath {
+  base: string;
+}
+
+type TAgent = "vscode" | "os";
+
+export interface IEditor {
+  mode?: TMode;
+  version: string;
+  agent?: TAgent;
+}
+
+export interface TEntries {
+  python3?: string;
+  html?: string;
+  node?: string;
+  react?: string;
+  java?: string;
+}
+
+export interface IConfig {
+  os: string;
+  port?: string;
+  repository?: string;
+  description?: string;
+  slug?: string;
+  dirPath: string;
+  preview?: string; // Picture thumbnail
+  entries: TEntries;
+  grading: TGrading;
+  configPath: string;
+  translations: Array<string>;
+  outputPath?: string;
+  editor: IEditor;
+  language: string;
+  title: string;
+  duration: number;
+  difficulty?: string;
+  exercisesPath: string;
+  disableGrading: boolean; // TODO: Deprecate
+  actions: Array<string>; // TODO: Deprecate
+  autoPlay: boolean;
+  projectType?: string;
+  // TODO: nameExerciseValidation
+  contact?: string;
+  disabledActions?: Array<TConfigAction>;
+  compiler: TCompiler;
+  compilers: Array<TCompiler>;
+  publicPath: string;
+  publicUrl?: string;
+  bugsLink?: string;
+  videoSolutions?: boolean;
+  skills: Array<string>;
+  telemetry?: TTelemetryUrls;
+  runHook: (...agrs: Array<any>) => void;
+  testingFinishedCallback: (arg: any | undefined) => void;
+}
+
+export interface IConfigObj {
+  session?: number;
+  currentExercise?: any;
+  config?: IConfig;
+  exercises?: Array<IExercise>;
+  confPath?: IConfigPath;
+  address?: string; // Maybe
+}

package/src/models/socket.ts

@@ -1,59 +1,59 @@
-import { IConfig } from "./config"
-import { Server } from "socket.io"
-import { DefaultEventsMap } from "socket.io/dist/typed-events"
-import { TAction, ICallback } from "./action"
-import { TStatus } from "./status"
-
-export type TPossibleActions =
-  | "build"
-  | "test"
-  | "reset"
-  | "tutorial"
-  | "generate";
-
-export interface ISocket {
-  socket: Server<
-    DefaultEventsMap,
-    DefaultEventsMap,
-    DefaultEventsMap,
-    any
-  > | null;
-  config: IConfig | null;
-  allowedActions: Array<TPossibleActions>;
-  actionCallBacks: { [key: string]: ICallback };
-  possibleActions: Array<TPossibleActions>;
-  isTestingEnvironment: boolean;
-  addAllowed: (actions: any) => void;
-  removeAllowed: (actions: any) => void;
-  start: (config: IConfig, server: any, isTestingEnvironment: boolean) => void;
-  on: (action: any, callBack: any) => void;
-  clean: (_: string, logs: Array<any>) => void;
-  complete: () => void;
-  ask: (questions: Array<string>) => void;
-  reload: (files: Array<string> | null, exercises: Array<string>) => void;
-  openWindow: (id: string) => void;
-  log: (
-    status: TStatus,
-    messages?: string | Array<string>,
-    report?: Array<string>,
-    data?: any
-  ) => void;
-  emit: (
-    action: TAction,
-    status: TStatus | string,
-    logs: string | Array<string>,
-    inputs?: Array<string>,
-    report?: Array<string>,
-    data?: any
-  ) => void;
-  ready: (message: string) => void;
-  error: (type: any, stdout: string) => void;
-  fatal: (msg: string) => void;
-  success: (type: any, stdout: string) => void;
-  onTestingFinished: (obj: any) => void;
-}
-
-export type TOpenWindowData = {
-  url: string;
-  exerciseSlug: string;
-};
+import { IConfig } from "./config"
+import { Server } from "socket.io"
+import { DefaultEventsMap } from "socket.io/dist/typed-events"
+import { TAction, ICallback } from "./action"
+import { TStatus } from "./status"
+
+export type TPossibleActions =
+  | "build"
+  | "test"
+  | "reset"
+  | "tutorial"
+  | "generate";
+
+export interface ISocket {
+  socket: Server<
+    DefaultEventsMap,
+    DefaultEventsMap,
+    DefaultEventsMap,
+    any
+  > | null;
+  config: IConfig | null;
+  allowedActions: Array<TPossibleActions>;
+  actionCallBacks: { [key: string]: ICallback };
+  possibleActions: Array<TPossibleActions>;
+  isTestingEnvironment: boolean;
+  addAllowed: (actions: any) => void;
+  removeAllowed: (actions: any) => void;
+  start: (config: IConfig, server: any, isTestingEnvironment: boolean) => void;
+  on: (action: any, callBack: any) => void;
+  clean: (_: string, logs: Array<any>) => void;
+  complete: () => void;
+  ask: (questions: Array<string>) => void;
+  reload: (files: Array<string> | null, exercises: Array<string>) => void;
+  openWindow: (id: string) => void;
+  log: (
+    status: TStatus,
+    messages?: string | Array<string>,
+    report?: Array<string>,
+    data?: any
+  ) => void;
+  emit: (
+    action: TAction,
+    status: TStatus | string,
+    logs: string | Array<string>,
+    inputs?: Array<string>,
+    report?: Array<string>,
+    data?: any
+  ) => void;
+  ready: (message: string) => void;
+  error: (type: any, stdout: string) => void;
+  fatal: (msg: string) => void;
+  success: (type: any, stdout: string) => void;
+  onTestingFinished: (obj: any) => void;
+}
+
+export type TOpenWindowData = {
+  url: string;
+  exerciseSlug: string;
+};

package/src/utils/checkNotInstalled.ts

@@ -1,42 +1,253 @@
 import { IExercise } from "../models/exercise-obj"
-export const checkNotInstalledPlugins = (
+import { promisify } from "util"
+import { exec as execCallback } from "child_process"
+const exec = promisify(execCallback)
+
+import { cli } from "cli-ux"
+import Console from "./console"
+import { TGrading } from "../models/config"
+
+type TNeededPlugins = {
+  needed: string[];
+  notInstalled: string[];
+};
+type TPackageManager = "npm" | "pip";
+
+export const checkNotInstalledPlugins = async (
   exercises: IExercise[],
-  installedPlugins: string[]
-) => {
+  installedPlugins: string[],
+  command: any
+): Promise<TNeededPlugins> => {
+  Console.info("Checking needed plugins...")
   const usefulExtensions = new Set(["py", "js", "jsx", "html"])
   const foundExtensions: string[] = []
+  const testingExtensions = []
+  const neededPlugins: string[] = []
+  let someExerciseWithOnlyTestFile = false // I will suppose that there are not exercises with only readme and test files
 
+  // See the extensions of the files that are not tests files
   for (const e of exercises) {
-    for (const f of e.files) {
+    const notReadmeFiles = e.files.filter(
+      f => !f.name.toLowerCase().includes("readme")
+    )
+
+    if (!someExerciseWithOnlyTestFile) {
+      someExerciseWithOnlyTestFile = notReadmeFiles.every(f =>
+        f.name.includes("test")
+      )
+    }
+
+    for (const f of notReadmeFiles) {
+      // There are some courses with only test files in js  and grading: incremental
+      // TODO: We should know in the incremental exercises which compilers are needed
+
       const ext = f.name.split(".").pop()
+      if (f.name.includes("test")) {
+        testingExtensions.push(ext)
+        continue
+      }
+
       if (ext && usefulExtensions.has(ext) && !foundExtensions.includes(ext)) {
         foundExtensions.push(ext)
       }
     }
   }
 
-  const neededPlugins: string[] = []
-  if (foundExtensions.length > 0) {
-    if (foundExtensions.includes("html") && foundExtensions.includes("js")) {
-      neededPlugins.push("@learnpack/dom")
+  if (foundExtensions.length === 0)
+    return {
+      needed: [],
+      notInstalled: [],
     }
 
-    if (foundExtensions.includes("html") && !foundExtensions.includes("js")) {
-      neededPlugins.push("@learnpack/html")
+  if (foundExtensions.includes("html") && foundExtensions.includes("js")) {
+    neededPlugins.push("@learnpack/dom")
+  }
+
+  if (foundExtensions.includes("html") && !foundExtensions.includes("js")) {
+    neededPlugins.push("@learnpack/html")
+  }
+
+  if (foundExtensions.includes("jsx")) {
+    neededPlugins.push("@learnpack/react")
+  }
+
+  if (foundExtensions.includes("py") || testingExtensions.includes("py")) {
+    neededPlugins.push("@learnpack/python")
+  }
+
+  if (
+    (foundExtensions.includes("js") && !foundExtensions.includes("html")) ||
+    (testingExtensions.includes("js") && someExerciseWithOnlyTestFile)
+  ) {
+    neededPlugins.push("@learnpack/node")
+  }
+
+  const notInstalled = neededPlugins.filter(
+    item => !installedPlugins.includes(item)
+  )
+
+  if (notInstalled.length > 0) {
+    Console.error(
+      "These plugins are not installed but required: ",
+      notInstalled
+    )
+    const confirmInstall = await cli.confirm(
+      "Do you want to install the needed plugins? (y/n)"
+    )
+    if (confirmInstall) {
+      Console.info("Installing the needed plugins...")
+      for await (const p of notInstalled) {
+        await command.config.runCommand(`plugins:install`, [p])
+        Console.log(`Plugin ${p} installed`)
+      }
+
+      Console.log(
+        "All needed plugins installed, please restart LearnPack to load them."
+      )
+      Console.info("Run: $ learnpack start")
+      command.exit(0)
+    } else {
+      Console.error(
+        "You need to install the plugins to complete this exercise"
+      )
+      Console.info(
+        "To install the plugins run each of the following commands: "
+      )
+      for (const p of notInstalled) {
+        Console.log(`learnpack plugins:install ${p}`)
+      }
+
+      command.exit(1)
     }
+  }
 
-    if (foundExtensions.includes("jsx")) {
-      neededPlugins.push("@learnpack/react")
+  return {
+    needed: neededPlugins,
+    notInstalled,
+  }
+}
+
+function includesAll(baseString: string, elementsArray: string[]) {
+  return elementsArray.every(element => baseString.includes(element))
+}
+
+const installDependencies = async (
+  deps: string[],
+  packageManager: TPackageManager
+) => {
+  let command = ""
+  if (packageManager === "npm") {
+    command = `npm install -g ${deps.join(" ")}`
+  } else if (packageManager === "pip") {
+    command = `pip install ${deps.join(" ")}`
+  }
+
+  const { stdout, stderr } = await exec(command)
+  if (stderr && (stderr.includes("npm ERR!") || stderr.includes("Traceback"))) {
+    Console.error(`Error executing ${command}.`)
+    Console.error(stderr)
+    return
+  }
+
+  Console.info(`Dependencies ${deps.join(" ")} installed...`)
+  return true
+}
+
+export const checkNotInstalledDependencies = async (
+  neededPlugins: string[]
+) => {
+  Console.info("Checking needed dependencies...")
+  const jsPluginsDependencies = [
+    "jest@29.7.0",
+    "jest-environment-jsdom@29.7.0",
+  ]
+  const pyPluginsDependencies = ["pytest==6.2.5", "pytest-testdox", "mock"]
+
+  const npmLsCommand = "npm ls jest jest-environment-jsdom -g"
+
+  let pytestNeeded = false
+  let jestNeeded = false
+
+  if (
+    neededPlugins.includes("@learnpack/dom") ||
+    neededPlugins.includes("@learnpack/html") ||
+    neededPlugins.includes("@learnpack/react") ||
+    neededPlugins.includes("@learnpack/node")
+  ) {
+    jestNeeded = true
+  }
+
+  if ("@learnpack/python" in neededPlugins) {
+    pytestNeeded = true
+  }
+
+  if (jestNeeded) {
+    const { stdout, stderr } = await exec(
+      "npm ls jest jest-environment-jsdom -g"
+    )
+    if (stderr) {
+      Console.error(`Error executing ${npmLsCommand}. Use debug for more info`)
+      Console.debug(stderr)
+      return false
     }
 
-    if (foundExtensions.includes("py")) {
-      neededPlugins.push("@learnpack/python")
+    if (includesAll(stdout, jsPluginsDependencies)) 
+return true
+
+    Console.error("The jest dependencies are not installed")
+    const confirmInstall = await cli.confirm(
+      "Do you want to install the needed dependencies? (y/n)"
+    )
+    if (!confirmInstall) {
+      Console.error(
+        `The exercises can't be tested without the following dependencies: ${jsPluginsDependencies.join(
+          ", "
+        )}`
+      )
+      Console.info(
+        `Please install them and try again. Run the following command to install them: \nnpm install -g ${jsPluginsDependencies.join(
+          " "
+        )}`
+      )
+      return false
     }
 
-    if (foundExtensions.includes("js") && !foundExtensions.includes("html")) {
-      neededPlugins.push("@learnpack/node")
+    Console.log("Installing jest dependencies...")
+    await installDependencies(jsPluginsDependencies, "npm")
+  }
+
+  if (pytestNeeded) {
+    const { stdout, stderr } = await exec("pip list")
+    if (stderr) {
+      Console.error(`Error executing pip list. Use debug for more info`)
+      Console.debug(stderr)
+      return
+    }
+
+    if (includesAll(stdout, pyPluginsDependencies)) 
+return true
+
+    Console.error("The pytest dependencies are not installed")
+    const confirmInstall = await cli.confirm(
+      "Do you want to install the needed dependencies? (y/n)"
+    )
+    if (!confirmInstall) {
+      Console.error(
+        `The exercises can't be tested without the following dependencies: ${pyPluginsDependencies.join(
+          ", "
+        )}`
+      )
+      Console.info(
+        `Please install them and try again. Run the following command to install them: \npip install ${pyPluginsDependencies.join(
+          " "
+        )}`
+      )
+      return false
     }
+
+    Console.log("Installing pytest dependencies...")
+    await installDependencies(pyPluginsDependencies, "pip")
   }
 
-  return neededPlugins.filter(item => !installedPlugins.includes(item))
+  return true
 }

package/src/utils/console.ts

@@ -1,24 +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)}`),
-}
+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: any, ...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)}`),
+}