@learnpack/learnpack 1.0.0 → 2.0.0

package/src/managers/test.ts

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

package/src/models/action.ts

@@ -0,0 +1,3 @@
+export type TAction = 'test' | 'log' | 'reload' | 'ready' | 'clean' | 'ask';
+
+export type ICallback = (...agrs: any[]) => any;

package/src/models/audit-errors.ts

@@ -0,0 +1,4 @@
+export interface IAuditErrors {
+  exercise?: string;
+  msg: string;
+}

package/src/models/config-manager.ts

@@ -0,0 +1,23 @@
+import { IConfigObj, TGrading } from "./config";
+import { IExercise } from "./exercise-obj";
+
+export interface IConfigManagerAttributes {
+  grading: TGrading;
+  disableGrading: boolean;
+  version: string;
+  mode?: string;
+}
+
+export interface IConfigManager {
+  validLanguages?: any;
+  get: () => IConfigObj;
+  clean: () => void;
+  getExercise: (slug: string | undefined) => IExercise;
+  startExercise: (slug: string) => IExercise;
+  reset: (slug: string) => void;
+  buildIndex: () => boolean | void;
+  watchIndex: (onChange: (...args: Array<any>) => void) => void;
+  save: () => void;
+  noCurrentExercise: () => void;
+  getAllExercises: () => IExercise[];
+}

package/src/models/config.ts

@@ -0,0 +1,74 @@
+import { IExercise } from "./exercise-obj";
+
+export type TGrading = "isolated" | "incremental" | "no-grading";
+
+export type TMode = "preview" | "standalone";
+
+export type TConfigAction = "test" | "build" | "tutorial" | "reset";
+
+export type TConfigObjAttributes = "config" | "exercises" | "grading";
+
+export type TCompiler =
+  | "webpack"
+  | "vanillajs"
+  | "vue"
+  | "react"
+  | "css"
+  | "html";
+
+export interface IConfigPath {
+  base: string;
+}
+
+export interface IEditor {
+  mode?: TMode;
+  version: string;
+  agent?: string;
+}
+
+export interface TEntries {
+  python3?: string;
+  html?: string;
+  node?: string;
+  react?: string;
+  java?: string;
+}
+
+export interface IConfig {
+  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
+  // TODO: nameExerciseValidation
+  disabledActions?: Array<TConfigAction>;
+  compiler: TCompiler;
+  publicPath: string;
+  publicUrl?: string;
+  skills: Array<string>;
+  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/counter.ts

@@ -0,0 +1,11 @@
+interface ILinks {
+  error: number;
+  total: number;
+}
+
+export interface ICounter {
+  images: ILinks;
+  links: ILinks;
+  exercises: number;
+  readmeFiles: number;
+}

package/src/models/errors.ts

@@ -0,0 +1,22 @@
+export interface ISolution {
+  video?: string;
+  message: string;
+  slug?: string;
+  gif: string;
+}
+
+export interface IError extends TypeError {
+  status?: number;
+  type?:
+    | "validation-error"
+    | "not-found-error"
+    | "compiler-error"
+    | "testing-error"
+    | "auth-error"
+    | "internal-error";
+  slug?: string;
+  video?: string;
+  message: string;
+  gif?: string;
+  stdout?: string;
+}

package/src/models/exercise-obj.ts

@@ -0,0 +1,26 @@
+import { IFile } from "./file";
+import { IConfig } from "./config";
+import { ISocket } from "./socket";
+
+export interface IExercise {
+  position?: number;
+  files: Array<IFile>;
+  slug: string;
+  path: string;
+  done: boolean;
+  language?: string | null;
+  entry?: string | null;
+  graded?: boolean;
+  translations?: { [key: string]: string };
+  title: string;
+  getReadme: (lang: string | null) => any;
+  getFile: (name: string) => string | Buffer;
+  saveFile: (name: string, content: string) => void;
+  getTestReport: () => any;
+  test?: (sessionConfig: any, config: IConfig, socket: ISocket) => void;
+}
+
+export interface IExerciseData {
+  exerciseSlug: string;
+  files: string[];
+}

package/src/models/file.ts

@@ -0,0 +1,5 @@
+export interface IFile {
+  path: string;
+  name: string;
+  hidden: boolean;
+}

package/src/models/findings.ts

@@ -0,0 +1,18 @@
+interface IFindingOption {
+  content: string;
+  absUrl: string;
+  mdUrl: string;
+  relUrl: string;
+}
+
+interface ILinks {
+  [key: string]: IFindingOption;
+}
+
+export interface IFindings {
+  relativeImages?: ILinks;
+  externalImages?: ILinks;
+  markdownLinks?: ILinks;
+  url?: ILinks;
+  uploadcare?: ILinks;
+}

package/src/models/flags.ts

@@ -0,0 +1,10 @@
+export interface IStartFlags {
+  port?: string | unknown;
+  host?: string | unknown;
+  disableGrading?: boolean | unknown;
+  watch?: boolean | unknown;
+  editor?: string | unknown;
+  version?: string | unknown;
+  grading?: string | unknown;
+  debug?: boolean | unknown;
+}

package/src/models/front-matter.ts

@@ -0,0 +1,11 @@
+interface IAttributes {
+  intro: string;
+  tutorial: string;
+}
+
+export interface IFrontmatter {
+  attributes?: IAttributes;
+  body?: string;
+  bodyBegin?: number;
+  frontmatter?: string;
+}

package/src/models/gitpod-data.ts

@@ -0,0 +1,19 @@
+import {Server} from 'socket.io'
+import {IConfigObj} from './config'
+
+export type TFile = string;
+
+export interface IGitpodData {
+  files: Array<TFile>;
+}
+
+export interface IGitpod {
+  socket: Server | null;
+  config: IConfigObj | null;
+  initialized: boolean;
+  hasGPCommand: boolean;
+  init: (config?: IConfigObj) => void;
+  openFiles: (files: Array<TFile>) => Promise<boolean | undefined>;
+  setup: (config?: IConfigObj) => void;
+  autosave: (value: string) => void;
+}

package/src/models/language.ts

@@ -0,0 +1,4 @@
+export interface ILanguage {
+  title: string;
+  slug: string;
+}

package/src/models/package.ts

@@ -0,0 +1,7 @@
+export interface IPackage {
+  title: string;
+  slug: string;
+  difficulty: string;
+  downloads: string;
+  skills: Array<any>;
+}

package/src/models/plugin-config.ts

@@ -0,0 +1,17 @@
+import { IConfig } from "./config";
+import { IExercise } from "./exercise-obj";
+
+export interface IPluginConfig {
+  language: string;
+  compile?: {
+    run: () => void;
+    validate: (args: IValidate) => boolean;
+    dependencies: string[];
+  };
+  test?: () => void;
+}
+
+interface IValidate {
+  exercise: IExercise;
+  configuration: IConfig;
+}

package/src/models/session.ts

@@ -0,0 +1,26 @@
+import {IConfig, IConfigObj} from './config'
+
+export interface IPayload {
+  email: string;
+}
+
+export interface IStartProps {
+  token: string;
+  payload: IPayload | null;
+}
+
+export interface ISession {
+  sessionStarted: boolean;
+  token: string | null;
+  config: IConfig | null;
+  currentCohort: null;
+  initialize: () => Promise<boolean>;
+  setPayload: (value: IPayload) => Promise<boolean>;
+  getPayload: () => Promise<any>;
+  isActive: () => boolean;
+  get: (config?: IConfigObj) => Promise<any>;
+  login: () => Promise<void>;
+  sync: () => Promise<void>;
+  start: ({token, payload}: IStartProps) => Promise<void>;
+  destroy: () => Promise<void>;
+}

package/src/models/socket.ts

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

package/src/models/status.ts

@@ -0,0 +1,15 @@
+export type TStatus =
+  | 'ready'
+  | 'internal-error'
+  | 'compiler-success'
+  | 'testing-success'
+  | 'compiling'
+  | 'testing'
+  | 'start_exercise'
+  | 'initializing'
+  | 'configuration_loaded'
+  | 'connection_ended'
+  | 'reset_exercise'
+  | 'open_files'
+  | 'open_window'
+  | 'instructions_closed';

package/src/models/success-types.ts

@@ -0,0 +1 @@
+export type TSuccessType = 'compiler-success' | 'testing-success';

package/src/plugin/command/compile.ts

@@ -0,0 +1,17 @@
+import { IError } from "../../models/errors";
+
+const CompilationError = (messages: string) => {
+  const _err: IError = new Error(messages);
+  _err.status = 400;
+  _err.stdout = messages;
+  _err.type = "compiler-error";
+  return _err;
+};
+
+export default {
+  CompilationError,
+  default: async ({ action, ...rest }: any) => {
+    const stdout = await action.run(rest);
+    return stdout;
+  },
+};

package/src/plugin/command/test.ts

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

package/src/plugin/index.ts

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

package/src/plugin/plugin.ts

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