@learnpack/learnpack 2.1.25 → 2.1.26

package/src/managers/socket.ts

@@ -1,239 +1,239 @@
-import {Socket, Server} from 'socket.io'
-import Console from '../utils/console'
-import queue from '../utils/fileQueue'
-
-import {ISocket, TPossibleActions} from '../models/socket'
-import {IConfig} from '../models/config'
-import {ICallback, TAction} from '../models/action'
-import {IExercise, IExerciseData} from '../models/exercise-obj'
-import {TStatus} from '../models/status'
-import {TSuccessType} from '../models/success-types'
-import * as http from 'http'
-
-const SocketManager: ISocket = {
-  socket: null,
-  config: null,
-  allowedActions: [],
-  possibleActions: ['build', 'reset', 'test', 'tutorial'],
-  isTestingEnvironment: false,
-  actionCallBacks: {
-    clean: (_, s: { logs: Array<string> }) => {
-      s.logs = []
-    },
-  },
-  addAllowed: function (actions: Array<TPossibleActions> | TPossibleActions) {
-    if (!Array.isArray(actions))
-      actions = [actions]
-
-    // avoid adding the "test" action if grading is disabled
-    if (
-      actions.includes('test') &&
-      this.config?.disabledActions?.includes('test')
-    ) {
-      actions = actions.filter((a: TPossibleActions) => a !== 'test')
-    }
-
-    this.allowedActions = [
-      ...(this.allowedActions || []).filter(
-        (a: TPossibleActions) => !actions.includes(a),
-      ),
-      ...actions,
-    ]
-  },
-  removeAllowed: function (
-    actions: Array<TPossibleActions> | TPossibleActions,
-  ) {
-    if (!Array.isArray(actions)) {
-      actions = [actions]
-    }
-
-    this.allowedActions = (this.allowedActions || []).filter(
-      (a: TPossibleActions) => !actions.includes(a),
-    )
-  },
-  start: function (
-    config: IConfig,
-    server: http.Server,
-    isTestingEnvironment = false,
-  ) {
-    this.config = config
-    this.isTestingEnvironment = isTestingEnvironment
-
-    this.socket = new Server(server, {allowEIO3: true})
-
-    this.allowedActions = this.config?.disabledActions?.includes('test') ||
-      this.config?.disableGrading ? this.possibleActions.filter(
-        a => !this.config?.disabledActions?.includes(a) && a !== 'test',
-      ) : this.possibleActions.filter(
-        a => !this.allowedActions?.includes(a),
-      )
-
-    if (this.config?.grading === 'incremental') {
-      this.removeAllowed('reset')
-    }
-
-    if (this.socket) {
-      this.socket.on('connection', (socket: Socket) => {
-        Console.debug(
-          'Connection with client successfully established',
-          this.allowedActions,
-        )
-        if (!this.isTestingEnvironment) {
-          this.log('ready', ['Ready to compile or test...'])
-        }
-
-        socket.on(
-          'compiler',
-          ({action, data}: { action: string; data: IExerciseData }) => {
-            this.emit('clean', 'pending', ['Working...'])
-
-            if (typeof data.exerciseSlug === 'undefined') {
-              this.log('internal-error', ['No exercise slug specified'])
-              Console.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: TAction, callBack: ICallback) {
-    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}: any) => {
-        // Workaround to fix issue because null inputs
-        let isNull = false
-        // eslint-disable-next-line
-        inputs.forEach((input: any) => {
-          if (input === null) {
-            isNull = true
-          }
-        })
-
-        if (!isNull) {
-          resolve(inputs)
-        }
-      })
-    })
-  },
-  reload: function (
-    files: Array<string> | null = null,
-    exercises: Array<string> | null = null,
-  ) {
-    this.emit(
-      'reload',
-      files?.join('') || '' /* TODO: Check it out this */,
-      exercises!,
-    )
-  },
-  openWindow: function (url = '') {
-    queue.dispatcher().enqueue(queue.events.OPEN_WINDOW, url)
-    this.emit(
-      queue.events.OPEN_WINDOW as TAction,
-      'ready',
-      [`Opening ${url}`],
-      [],
-      [],
-      url,
-    )
-  },
-  log: function (
-    status: TStatus,
-    messages: string | Array<string> = [],
-    report: Array<string> = [],
-    data: any = null,
-  ) {
-    this.emit('log', status, messages, [], report, data)
-    Console.log(messages)
-  },
-  emit: function (
-    action: TAction,
-    status: TStatus | string = 'ready',
-    logs: string | Array<string> = [],
-    inputs: Array<string> = [],
-    report: Array<string> = [],
-    data: any = null,
-  ) {
-    if (
-      this.config?.compiler &&
-      ['webpack', 'vanillajs', 'vue', 'react', 'css', 'html'].includes(
-        this.config?.compiler,
-      )
-    ) {
-      if (['compiler-success', 'compiler-warning'].includes(status))
-        this.addAllowed('preview')
-      if (['compiler-error'].includes(status) || action === 'ready')
-        this.removeAllowed('preview')
-    }
-
-    if (this.config?.grading === 'incremental') {
-      this.removeAllowed('reset')
-    }
-
-    // eslint-disable-next-line
-    this.config?.disabledActions?.forEach((a) => this.removeAllowed(a));
-
-    this.socket?.emit('compiler', {
-      action,
-      status,
-      logs,
-      allowed: this.allowedActions,
-      inputs,
-      report,
-      data,
-    })
-  },
-
-  ready: function (message: string) {
-    this.log('ready', [message])
-  },
-  success: function (type: TSuccessType, stdout: string) {
-    const types = ['compiler', 'testing']
-    if (!types.includes(type))
-      this.fatal(`Invalid socket success type "${type}" on socket`)
-    else if (stdout === '')
-      this.log((type + '-success') as TSuccessType, [
-        'No stdout to display on the console',
-      ])
-    else
-      this.log((type + '-success') as TSuccessType, [stdout])
-  },
-  error: function (type: TStatus, stdout: string) {
-    console.error('Socket error: ' + type, stdout)
-    this.log(type, [stdout])
-
-    if (this.isTestingEnvironment) {
-      this.onTestingFinished({
-        result: 'failed',
-      })
-    }
-  },
-  fatal: function (msg: string) {
-    this.log('internal-error', [msg])
-    throw msg
-  },
-  onTestingFinished: function (result: any) {
-    if (this.config?.testingFinishedCallback) {
-      this.config.testingFinishedCallback(result)
-    }
-  },
-}
-
-export default SocketManager
+import {Socket, Server} from 'socket.io'
+import Console from '../utils/console'
+import queue from '../utils/fileQueue'
+
+import {ISocket, TPossibleActions} from '../models/socket'
+import {IConfig} from '../models/config'
+import {ICallback, TAction} from '../models/action'
+import {IExercise, IExerciseData} from '../models/exercise-obj'
+import {TStatus} from '../models/status'
+import {TSuccessType} from '../models/success-types'
+import * as http from 'http'
+
+const SocketManager: ISocket = {
+  socket: null,
+  config: null,
+  allowedActions: [],
+  possibleActions: ['build', 'reset', 'test', 'tutorial'],
+  isTestingEnvironment: false,
+  actionCallBacks: {
+    clean: (_, s: { logs: Array<string> }) => {
+      s.logs = []
+    },
+  },
+  addAllowed: function (actions: Array<TPossibleActions> | TPossibleActions) {
+    if (!Array.isArray(actions))
+      actions = [actions]
+
+    // avoid adding the "test" action if grading is disabled
+    if (
+      actions.includes('test') &&
+      this.config?.disabledActions?.includes('test')
+    ) {
+      actions = actions.filter((a: TPossibleActions) => a !== 'test')
+    }
+
+    this.allowedActions = [
+      ...(this.allowedActions || []).filter(
+        (a: TPossibleActions) => !actions.includes(a),
+      ),
+      ...actions,
+    ]
+  },
+  removeAllowed: function (
+    actions: Array<TPossibleActions> | TPossibleActions,
+  ) {
+    if (!Array.isArray(actions)) {
+      actions = [actions]
+    }
+
+    this.allowedActions = (this.allowedActions || []).filter(
+      (a: TPossibleActions) => !actions.includes(a),
+    )
+  },
+  start: function (
+    config: IConfig,
+    server: http.Server,
+    isTestingEnvironment = false,
+  ) {
+    this.config = config
+    this.isTestingEnvironment = isTestingEnvironment
+
+    this.socket = new Server(server, {allowEIO3: true})
+
+    this.allowedActions = this.config?.disabledActions?.includes('test') ||
+      this.config?.disableGrading ? this.possibleActions.filter(
+        a => !this.config?.disabledActions?.includes(a) && a !== 'test',
+      ) : this.possibleActions.filter(
+        a => !this.allowedActions?.includes(a),
+      )
+
+    if (this.config?.grading === 'incremental') {
+      this.removeAllowed('reset')
+    }
+
+    if (this.socket) {
+      this.socket.on('connection', (socket: Socket) => {
+        Console.debug(
+          'Connection with client successfully established',
+          this.allowedActions,
+        )
+        if (!this.isTestingEnvironment) {
+          this.log('ready', ['Ready to compile or test...'])
+        }
+
+        socket.on(
+          'compiler',
+          ({action, data}: { action: string; data: IExerciseData }) => {
+            this.emit('clean', 'pending', ['Working...'])
+
+            if (typeof data.exerciseSlug === 'undefined') {
+              this.log('internal-error', ['No exercise slug specified'])
+              Console.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: TAction, callBack: ICallback) {
+    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}: any) => {
+        // Workaround to fix issue because null inputs
+        let isNull = false
+        // eslint-disable-next-line
+        inputs.forEach((input: any) => {
+          if (input === null) {
+            isNull = true
+          }
+        })
+
+        if (!isNull) {
+          resolve(inputs)
+        }
+      })
+    })
+  },
+  reload: function (
+    files: Array<string> | null = null,
+    exercises: Array<string> | null = null,
+  ) {
+    this.emit(
+      'reload',
+      files?.join('') || '' /* TODO: Check it out this */,
+      exercises!,
+    )
+  },
+  openWindow: function (url = '') {
+    queue.dispatcher().enqueue(queue.events.OPEN_WINDOW, url)
+    this.emit(
+      queue.events.OPEN_WINDOW as TAction,
+      'ready',
+      [`Opening ${url}`],
+      [],
+      [],
+      url,
+    )
+  },
+  log: function (
+    status: TStatus,
+    messages: string | Array<string> = [],
+    report: Array<string> = [],
+    data: any = null,
+  ) {
+    this.emit('log', status, messages, [], report, data)
+    Console.log(messages)
+  },
+  emit: function (
+    action: TAction,
+    status: TStatus | string = 'ready',
+    logs: string | Array<string> = [],
+    inputs: Array<string> = [],
+    report: Array<string> = [],
+    data: any = null,
+  ) {
+    if (
+      this.config?.compiler &&
+      ['webpack', 'vanillajs', 'vue', 'react', 'css', 'html'].includes(
+        this.config?.compiler,
+      )
+    ) {
+      if (['compiler-success', 'compiler-warning'].includes(status))
+        this.addAllowed('preview')
+      if (['compiler-error'].includes(status) || action === 'ready')
+        this.removeAllowed('preview')
+    }
+
+    if (this.config?.grading === 'incremental') {
+      this.removeAllowed('reset')
+    }
+
+    // eslint-disable-next-line
+    this.config?.disabledActions?.forEach((a) => this.removeAllowed(a));
+
+    this.socket?.emit('compiler', {
+      action,
+      status,
+      logs,
+      allowed: this.allowedActions,
+      inputs,
+      report,
+      data,
+    })
+  },
+
+  ready: function (message: string) {
+    this.log('ready', [message])
+  },
+  success: function (type: TSuccessType, stdout: string) {
+    const types = ['compiler', 'testing']
+    if (!types.includes(type))
+      this.fatal(`Invalid socket success type "${type}" on socket`)
+    else if (stdout === '')
+      this.log((type + '-success') as TSuccessType, [
+        'No stdout to display on the console',
+      ])
+    else
+      this.log((type + '-success') as TSuccessType, [stdout])
+  },
+  error: function (type: TStatus, stdout: string) {
+    console.error('Socket error: ' + type, stdout)
+    this.log(type, [stdout])
+
+    if (this.isTestingEnvironment) {
+      this.onTestingFinished({
+        result: 'failed',
+      })
+    }
+  },
+  fatal: function (msg: string) {
+    this.log('internal-error', [msg])
+    throw msg
+  },
+  onTestingFinished: function (result: any) {
+    if (this.config?.testingFinishedCallback) {
+      this.config.testingFinishedCallback(result)
+    }
+  },
+}
+
+export default SocketManager

package/src/managers/test.ts

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

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