@learnpack/learnpack 2.1.27 → 2.1.29

package/lib/managers/socket.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const socket_io_1 = require("socket.io");
+const console_1 = require("../utils/console");
+const fileQueue_1 = require("../utils/fileQueue");
+const SocketManager = {
+    socket: null,
+    config: null,
+    allowedActions: [],
+    possibleActions: ["build", "reset", "test", "tutorial"],
+    isTestingEnvironment: false,
+    actionCallBacks: {
+        clean: (_, s) => {
+            s.logs = [];
+        },
+    },
+    addAllowed: function (actions) {
+        var _a, _b;
+        if (!Array.isArray(actions))
+            actions = [actions];
+        // avoid adding the "test" action if grading is disabled
+        if (actions.includes("test") && ((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.disabledActions) === null || _b === void 0 ? void 0 : _b.includes("test"))) {
+            actions = actions.filter((a) => a !== "test");
+        }
+        this.allowedActions = [
+            ...(this.allowedActions || []).filter((a) => !actions.includes(a)),
+            ...actions,
+        ];
+    },
+    removeAllowed: function (actions) {
+        if (!Array.isArray(actions)) {
+            actions = [actions];
+        }
+        this.allowedActions = (this.allowedActions || []).filter((a) => !actions.includes(a));
+    },
+    start: function (config, server, isTestingEnvironment = false) {
+        var _a, _b, _c, _d;
+        this.config = config;
+        this.isTestingEnvironment = isTestingEnvironment;
+        this.socket = new socket_io_1.Server(server, {
+            allowEIO3: true,
+            cors: {
+                origin: "http://localhost:5173",
+                methods: ["GET", "POST"],
+            },
+        });
+        this.allowedActions =
+            ((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.disabledActions) === null || _b === void 0 ? void 0 : _b.includes("test")) || ((_c = this.config) === null || _c === void 0 ? void 0 : _c.disableGrading) ?
+                this.possibleActions.filter(a => { var _a, _b; return !((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.disabledActions) === null || _b === void 0 ? void 0 : _b.includes(a)) && a !== "test"; }) :
+                this.possibleActions.filter(a => { var _a; return !((_a = this.allowedActions) === null || _a === void 0 ? void 0 : _a.includes(a)); });
+        if (((_d = this.config) === null || _d === void 0 ? void 0 : _d.grading) === "incremental") {
+            this.removeAllowed("reset");
+        }
+        if (this.socket) {
+            this.socket.on("connection", (socket) => {
+                console_1.default.debug("Connection with client successfully established", this.allowedActions);
+                if (!this.isTestingEnvironment) {
+                    this.log("ready", ["Ready to compile or test..."]);
+                }
+                socket.on("compiler", ({ action, data }) => {
+                    this.emit("clean", "pending", ["Working..."]);
+                    if (typeof data.exerciseSlug === "undefined") {
+                        this.log("internal-error", ["No exercise slug specified"]);
+                        console_1.default.error("No exercise slug especified");
+                        return;
+                    }
+                    if (this.actionCallBacks &&
+                        typeof this.actionCallBacks[action] === "function") {
+                        this.actionCallBacks[action](data);
+                    }
+                    else {
+                        this.log("internal-error", ["Uknown action " + action]);
+                    }
+                });
+            });
+        }
+    },
+    on: function (action, callBack) {
+        if (this.actionCallBacks) {
+            this.actionCallBacks[action] = callBack;
+        }
+    },
+    clean: function (_ = "pending", logs = []) {
+        this.emit("clean", "pending", logs);
+    },
+    ask: function (questions = []) {
+        return new Promise((resolve, _) => {
+            this.emit("ask", "pending", ["Waiting for input..."], questions);
+            console.log("Setting up listeners");
+            this.on("input", ({ inputs }) => {
+                // Workaround to fix issue because null inputs
+                console.log("inputs", inputs);
+                let isNull = false;
+                // eslint-disable-next-line
+                inputs.forEach((input) => {
+                    if (input === null) {
+                        isNull = true;
+                    }
+                });
+                if (!isNull) {
+                    resolve(inputs);
+                }
+            });
+        });
+    },
+    reload: function (files = null, exercises = null) {
+        this.emit("reload", (files === null || files === void 0 ? void 0 : files.join("")) || "" /* TODO: Check it out this */, exercises);
+    },
+    openWindow: function (url = "") {
+        fileQueue_1.default.dispatcher().enqueue(fileQueue_1.default.events.OPEN_WINDOW, url);
+        this.emit(fileQueue_1.default.events.OPEN_WINDOW, "ready", [`Opening ${url}`], [], [], url);
+    },
+    log: function (status, messages = [], report = [], data = null) {
+        this.emit("log", status, messages, [], report, data);
+        console_1.default.log(messages);
+    },
+    emit: function (action, status = "ready", logs = [], inputs = [], report = [], data = null) {
+        var _a, _b, _c, _d, _e, _f;
+        if (((_a = this.config) === null || _a === void 0 ? void 0 : _a.compiler) &&
+            ["webpack", "vanillajs", "vue", "react", "css", "html"].includes((_b = this.config) === null || _b === void 0 ? void 0 : _b.compiler)) {
+            if (["compiler-success", "compiler-warning"].includes(status))
+                this.addAllowed("preview");
+            if (["compiler-error"].includes(status) || action === "ready")
+                this.removeAllowed("preview");
+        }
+        if (((_c = this.config) === null || _c === void 0 ? void 0 : _c.grading) === "incremental") {
+            this.removeAllowed("reset");
+        }
+        // eslint-disable-next-line
+        (_e = (_d = this.config) === null || _d === void 0 ? void 0 : _d.disabledActions) === null || _e === void 0 ? void 0 : _e.forEach((a) => this.removeAllowed(a));
+        (_f = this.socket) === null || _f === void 0 ? void 0 : _f.emit("compiler", {
+            action,
+            status,
+            logs,
+            allowed: this.allowedActions,
+            inputs,
+            report,
+            data,
+        });
+    },
+    ready: function (message) {
+        this.log("ready", [message]);
+    },
+    success: function (type, stdout) {
+        const types = ["compiler", "testing"];
+        if (!types.includes(type))
+            this.fatal(`Invalid socket success type "${type}" on socket`);
+        else if (stdout === "")
+            this.log((type + "-success"), [
+                "No stdout to display on the console",
+            ]);
+        else
+            this.log((type + "-success"), [stdout]);
+    },
+    error: function (type, stdout) {
+        console.error("Socket error: " + type, stdout);
+        this.log(type, [stdout]);
+        if (this.isTestingEnvironment) {
+            this.onTestingFinished({
+                result: "failed",
+            });
+        }
+    },
+    complete: function () {
+        console.log("complete");
+    },
+    fatal: function (msg) {
+        this.log("internal-error", [msg]);
+        throw msg;
+    },
+    onTestingFinished: function (result) {
+        var _a;
+        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.testingFinishedCallback) {
+            this.config.testingFinishedCallback(result);
+        }
+    },
+};
+exports.default = SocketManager;

package/lib/managers/test.js

@@ -0,0 +1,84 @@
+"use strict";
+/*
+
+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/lib/models/action.d.ts

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

package/lib/models/action.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/audit.d.ts

@@ -0,0 +1,15 @@
+export interface IAuditErrors {
+    exercise?: string;
+    msg: string;
+}
+declare type TType = "string" | "array" | "number" | "url" | "boolean";
+export interface ISchemaItem {
+    key: string;
+    mandatory: boolean;
+    type: TType;
+    max_size?: number;
+    allowed_extensions?: string[];
+    enum?: string[];
+    max_item_size?: number;
+}
+export {};

package/lib/models/audit.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/config-manager.d.ts

@@ -0,0 +1,21 @@
+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/lib/models/config-manager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/config.d.ts

@@ -0,0 +1,62 @@
+import { IExercise } from "./exercise-obj";
+export declare type TGrading = "isolated" | "incremental" | "no-grading";
+export declare type TMode = "preview" | "standalone";
+export declare type TConfigAction = "test" | "build" | "tutorial" | "reset" | "generate";
+export declare type TConfigObjAttributes = "config" | "exercises" | "grading";
+export declare 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;
+    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;
+    actions: Array<string>;
+    autoPlay: boolean;
+    projectType?: string;
+    contact?: string;
+    disabledActions?: Array<TConfigAction>;
+    compiler: TCompiler;
+    publicPath: string;
+    publicUrl?: string;
+    bugsLink?: string;
+    videoSolutions?: boolean;
+    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;
+}

package/lib/models/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/counter.d.ts

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

package/lib/models/counter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/errors.d.ts

@@ -0,0 +1,15 @@
+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/lib/models/errors.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/exercise-obj.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+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 {
+    lastMessages?: any;
+    userMessage?: string;
+    exerciseSlug: string;
+    entryPoint?: string;
+    files: string[];
+}

package/lib/models/exercise-obj.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/file.d.ts

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

package/lib/models/file.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/findings.d.ts

@@ -0,0 +1,17 @@
+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;
+}
+export {};

package/lib/models/findings.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/flags.d.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/lib/models/flags.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/front-matter.d.ts

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

package/lib/models/front-matter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/gitpod-data.d.ts

@@ -0,0 +1,16 @@
+import { Server } from 'socket.io';
+import { IConfigObj } from './config';
+export declare 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/lib/models/gitpod-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/language.d.ts

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

package/lib/models/language.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/package.d.ts

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

package/lib/models/package.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/plugin-config.d.ts

@@ -0,0 +1,16 @@
+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;
+}
+export {};

package/lib/models/plugin-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/session.d.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>;
+    getOpenAIToken: () => Promise<string | null>;
+    setOpenAIToken: (token: string) => Promise<boolean>;
+    setPayload: (value: IPayload) => Promise<boolean>;
+    getPayload: () => Promise<any>;
+    isActive: () => boolean;
+    get: (config?: IConfigObj) => Promise<any>;
+    login: () => Promise<void>;
+    loginWeb: (email: string, password: string) => Promise<void>;
+    sync: () => Promise<void>;
+    start: ({ token, payload }: IStartProps) => Promise<void>;
+    destroy: () => Promise<void>;
+}

package/lib/models/session.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/socket.d.ts

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

package/lib/models/socket.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/status.d.ts

@@ -0,0 +1 @@
+export declare 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" | "completed";