@learnpack/learnpack 2.0.19 → 2.0.21

package/lib/managers/socket.js

@@ -0,0 +1,164 @@
+"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 });
+        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);
+            this.on('input', ({ inputs }) => {
+                // Workaround to fix issue because null 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',
+            });
+        }
+    },
+    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';
+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-errors.d.ts

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

package/lib/models/audit-errors.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,57 @@
+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";
+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>;
+    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;
+}

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,27 @@
+/// <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 {
+    exerciseSlug: 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,23 @@
+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/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,31 @@
+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';
+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/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';

package/lib/models/status.js

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

package/lib/models/success-types.d.ts

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

package/lib/models/success-types.js

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

package/lib/plugin/command/compile.d.ts

@@ -0,0 +1,6 @@
+import { IError } from "../../models/errors";
+declare const _default: {
+    CompilationError: (messages: string) => IError;
+    default: ({ action, ...rest }: any) => Promise<any>;
+};
+export default _default;