mumuki-laboratory 7.7.3 → 7.9.0

data/app/assets/javascripts/mumuki_laboratory/application/console.js

@@ -1,5 +1,4 @@
-var mumuki = mumuki || {};
-(function (mumuki) {
+(() => {
   function historicalQueries() {
     var queries = $('#historical_queries').val();
     if (queries) {
@@ -36,65 +35,64 @@ var mumuki = mumuki || {};
     $('.jquery-console-prompt-box:not(:last)').remove()
   }
 
-  function QueryConsole() {
-    this.endpoint = $('#console_endpoint').val();
-    this.token = new mumuki.CsrfToken();
-    this.statefulConsole = $('#stateful_console').val() === "true";
-    this.lines = [];
-  }
-
-  QueryConsole.prototype = {
-    newQuery: function (line) {
+  class QueryConsole {
+    constructor() {
+      this.endpoint = $('#console_endpoint').val();
+      this.token = new mumuki.CsrfToken();
+      this.statefulConsole = $('#stateful_console').val() === "true";
+      this.lines = [];
+      this.controller = null;
+    }
+    newQuery(line) {
       var cookies = this.statefulConsole ? this.lines : [];
       return new Query(line, cookies, this);
-    },
-    clearState: function () {
+    }
+    clearState() {
       this.lines = [];
       clearConsole();
-    },
-    sendQuery: function (queryContent) {
+    }
+    sendQuery(queryContent) {
       this.controller.promptText(queryContent);
       this.controller.typer.commandTrigger();
-    },
-    preloadQuery: function (queryWithResults) {
+    }
+    preloadQuery(queryWithResults) {
       this.lines.push(queryWithResults.query);
       this.enqueuePreloadedQuery(queryWithResults);
       this.sendQuery(queryWithResults.query);
-    },
-    enqueuePreloadedQuery: function (queryWithResults) {
+    }
+    enqueuePreloadedQuery(queryWithResults) {
       this.preloadedQuery = queryWithResults;
-    },
-    dequeuePreloadedQuery: function () {
+    }
+    dequeuePreloadedQuery() {
       var result = this.preloadedQuery;
       this.preloadedQuery = undefined;
       return result;
-    },
-    preloadHistoricalQueries: function () {
+    }
+    preloadHistoricalQueries() {
       var self = this;
       historicalQueries().forEach(function (queryWithResults) {
         self.preloadQuery(queryWithResults);
       });
     }
-  };
-
-  function Query(line, cookie, console) {
-    this.console = console;
-    this.line = line;
-    this.cookie = cookie;
   }
 
-  Query.prototype = {
+  class Query {
+    constructor(line, cookie, console) {
+      this.console = console;
+      this.line = line;
+      this.cookie = cookie;
+    }
     get token() {
       return this.console.token;
-    },
+    }
     get content() {
       var firstEditor = mumuki.page.editors[0];
       if (firstEditor && $("#include_solution").prop("checked"))
         return firstEditor.getValue();
       else
         return '';
-    },
-    submit: function (report, queryConsole, line) {
+    }
+    submit(report, queryConsole, line) {
       var self = this;
       var preloadedQuery = queryConsole.dequeuePreloadedQuery();
       if (preloadedQuery) {
@@ -110,8 +108,8 @@ var mumuki = mumuki || {};
       }).fail(function (response) {
         reportStatus(response.responseText, 'failed', report);
       });
-    },
-    displayGoalResult: function (response) {
+    }
+    displayGoalResult(response) {
       if (response.status == 'passed') {
         $('.submission-results').show();
         $('.submission-results').html(response.html);
@@ -121,15 +119,15 @@ var mumuki = mumuki || {};
         $('.submission-results').hide();
         $('.progress-list-item.active').attr('class', "progress-list-item text-center danger active");
       }
-    },
-    displayQueryResult: function (report, queryConsole, line, response) {
+    }
+    displayQueryResult(report, queryConsole, line, response) {
       if (response.status !== 'errored') {
         queryConsole.lines.push(line);
         reportStatus(response.result, response.status, report);
       } else {
         reportStatus(response.result, 'failed', report);
       }
-    },
+    }
     get _request() {
       var self = this;
       return self.token.newRequest({
@@ -137,17 +135,17 @@ var mumuki = mumuki || {};
         type: 'POST',
         data: self._requestData
       })
-    },
+    }
     get _requestUrl() {
       return this.console.endpoint;
-    },
+    }
     get _requestData() {
       return {content: this.content, query: this.line, cookie: this.cookie};
     }
-  };
+  }
 
 
-  mumuki.load(function () {
+  mumuki.load(() => {
     var prompt = $('#prompt').attr('value');
     var queryConsole = new QueryConsole();
 
@@ -172,4 +170,4 @@ var mumuki = mumuki || {};
     queryConsole.preloadHistoricalQueries();
   });
 
-}(mumuki));
+})();

data/app/assets/javascripts/mumuki_laboratory/application/csrf-token.js

@@ -1,18 +1,15 @@
-var mumuki = mumuki || {};
-(function (mumuki) {
-  function CsrfToken() {
-    this.value = $('meta[name="csrf-token"]').attr('content');
-  }
-
-  CsrfToken.prototype = {
-    newRequest: function (data) {
+mumuki.CsrfToken =  (() => {
+  class CsrfToken {
+    constructor() {
+      this.value = $('meta[name="csrf-token"]').attr('content');
+    }
+    newRequest(data) {
       var self = this;
       data.beforeSend = function (xhr) {
         xhr.setRequestHeader('X-CSRF-Token', self.value);
       };
       return data;
     }
-  };
-
-  mumuki.CsrfToken = CsrfToken;
-}(mumuki));
+  }
+  return CsrfToken;
+})();

data/app/assets/javascripts/mumuki_laboratory/application/custom-editor.js

@@ -6,11 +6,16 @@
  * @typedef {{getContent: () => EditorProperty}} CustomEditorSource
  */
 
-var mumuki = mumuki || {};
-
-(function (mumuki) {
+/**
+ * This module allows custom editors to register
+ * content sources that can not me mapped to standard selectors {@code mu-custom-editor-value},
+ * {@code mu-custom-editor-extra} and {@code mu-custom-editor-test}
+ *
+ * CustomEditor sources are cleared after page reload even when using turbolinks
+ */
+mumuki.CustomEditor = (() => {
 
-  var CustomEditor = {
+  const CustomEditor = {
     /**
      * @type {CustomEditorSource[]}
      */
@@ -50,14 +55,5 @@ var mumuki = mumuki || {};
     mumuki.CustomEditor.clearSources();
   });
 
-  /**
-   * This module allows custom editors to register
-   * content sources that can not me mapped to standard selectors {@code mu-custom-editor-value},
-   * {@code mu-custom-editor-extra} and {@code mu-custom-editor-test}
-   *
-   * CustomEditor sources are cleared after page reload even when using turbolinks
-   *
-   * @module mumuki.CustomEditor
-   */
-  mumuki.CustomEditor = CustomEditor;
-}(mumuki));
+  return CustomEditor;
+})();

data/app/assets/javascripts/mumuki_laboratory/application/discussions.js

@@ -1,6 +1,4 @@
-var mumuki = mumuki || {};
-
-mumuki.load(function () {
+mumuki.load(() => {
   var $subscriptionSpans = $('.discussion-subscription > span');
   var $upvoteSpans = $('.discussion-upvote > span');
 

data/app/assets/javascripts/mumuki_laboratory/application/editors.js

@@ -0,0 +1,104 @@
+/**
+ * This module allows to read and write the current editor's contents
+ * regardless if it is an standard editor or a custom editor
+ */
+mumuki.editors = {
+  /**
+   * @type {() => void}
+   */
+  _contentSyncer: null,
+
+  /**
+   * Updates the current editor's content
+   *
+   * @param {string} content
+   */
+  setContent(content) {
+    const $customEditor = $('#mu-custom-editor-value');
+    if ($customEditor.length) {
+      $customEditor.val(content);
+    } else {
+      mumuki.editor.setContent(content);
+    }
+  },
+
+
+  /**
+   * @returns {EditorProperty[]}
+   */
+  getContents() {
+    return mumuki.CustomEditor.hasSources ?
+      mumuki.CustomEditor.getContents() :
+      this.getStandardEditorContents();
+  },
+
+  /**
+   * Syncs and returns the content objects of the standard editor form
+   *
+   * This content object may include keys like {@code content},
+   * {@code content_extra} and {@code content_test}
+   *
+   * @returns {EditorProperty[]}
+   */
+  getStandardEditorContents() {
+    this._syncContent();
+    return $('.new_solution').serializeArray();
+  },
+
+  /**
+   * Answers a submission object with a key for each of the current
+   * editor sources.
+   *
+   * This method will use CustomEditor's sources if availble, or
+   * standard editor's content sources otherwise
+   *
+   * @returns {Submission}
+   */
+  getSubmission() {
+    let content = {};
+    let contents = this.getContents();
+    contents.forEach((it) => {
+      content[it.name] = it.value;
+    });
+    return content;
+  },
+
+  /**
+   * Copies current solution from it native rendering components
+   * to the appropriate submission form elements.
+   *
+   * Both editors and runners with a custom editor that don't register a source should
+   * register its own syncer function in order to {@link syncContent} work properly.
+   *
+   * @see registerContentSyncer
+   * @see CustomEditor#addSource
+   */
+  _syncContent() {
+    if (this._contentSyncer) {
+      this._contentSyncer();
+    }
+  },
+
+  /**
+   * Sets a content syncer, that will be used by {@link _syncContent}
+   * in ordet to dump solution into the submission form fields.
+   *
+   * Each editor should have its own syncer registered - otherwise previous or none may be used
+   * causing unpredicatble behaviours - or cleared by passing {@code null}.
+   *
+   * As a particular case, runners with custom editors that don't add sources using {@link CustomEditor#addSource}
+   * should set the {@code #mu-custom-editor-value} value within its syncer.
+   *
+   * @param {() => void} [syncer] the syncer, or null, if no sync'ing is needed
+   */
+  registerContentSyncer(syncer = null) {
+    this._contentSyncer = syncer;
+  },
+
+  /**
+   * @param {CustomEditorSource} source
+   */
+  addCustomSource(source) {
+    mumuki.CustomEditor.addSource(source)
+  }
+};

data/app/assets/javascripts/mumuki_laboratory/application/elipsis.js

@@ -7,7 +7,7 @@
 //
 //
 // This module assumes the strings are already markdown-like escaped code strings, not plain code
-(function (mumuki) {
+mumuki.elipsis = (() => {
 
   function elipsis(code) {
     return code
@@ -16,8 +16,7 @@
       .replace(/<description-for-student\[([^\]]*)\]@[\s\S]*?@description-for-student>/g, ' ... $1 ... ');
   }
 
-  mumuki.elipsis = elipsis;
-  mumuki.elipsis.replaceHtml = () => {
+  elipsis.replaceHtml = () => {
     let $elipsis = $('.mu-elipsis');
     $elipsis.each((it, e) =>  {
       let $e = $(e);
@@ -28,4 +27,6 @@
   mumuki.load(() => {
     mumuki.elipsis.replaceHtml();
   });
-})(mumuki);
+
+  return elipsis;
+})();

data/app/assets/javascripts/mumuki_laboratory/application/events.js

@@ -0,0 +1,51 @@
+/**
+ * A general-purpuose event system
+ */
+mumuki.events = {
+  _handlers: {},
+
+  /**
+   * Enables registration of event handlers for the given event name
+   *
+   * @param {string} eventName
+   */
+  enable(eventName) {
+    this._handlers[eventName] = this._handlers[eventName] || [];
+  },
+
+  /**
+   * Registers a listener that will be called whenever the given event is produced.
+   * If the event is not enabled, the given handler is simply ignored.
+   *
+   * @param {string} eventName the event to listen to
+   * @param {(event: any) => void} handler
+   */
+  on(eventName, handler) {
+    if (this._handlers[eventName]) {
+      this._handlers[eventName].push(handler);
+    }
+  },
+
+  /**
+   * Fires a given event
+   *
+   * @param {string} eventName
+   * @param {any} [value]
+   */
+  fire(eventName, value = null) {
+    if (this._handlers[eventName]) {
+      this._handlers[eventName].forEach(it => it(value))
+    }
+  },
+
+  /**
+   * Clears handlers of the given event
+   *
+   * @param {string} eventName
+   */
+  clear(eventName) {
+    if (this._handlers[eventName]) {
+      this._handlers[eventName] = [];
+    }
+  }
+}

data/app/assets/javascripts/mumuki_laboratory/application/exercise.js

@@ -0,0 +1,57 @@
+/**
+ * @typedef {"input_right" | "input_bottom" | "input_primary" | "input_kindergarten"} Layout
+ * @typedef {{id: number, layout: Layout}} Exercise
+ */
+
+mumuki.exercise = {
+
+  /**
+   * The current exercise's id
+   *
+   * @type {Exercise?}
+   * */
+  _current: null,
+
+  /**
+   * The current exercise's id
+   *
+   * @type {number?}
+   * */
+  get id() {
+    return this._current ? this._current.id : null;
+  },
+
+  /**
+   * The current exercise's layout
+   *
+   * @type {Layout?}
+   * */
+  get layout() {
+    return this._current ? this._current.layout : null;
+  },
+
+  /**
+   * @type {Exercise?}
+   */
+  get current() {
+    return this._current;
+  },
+
+  /**
+   * Set global current exercise information
+   */
+  load() {
+    const $muExerciseId = $('#mu-exercise-id');
+    if ($muExerciseId.length) {
+      this._current = {
+        id: Number($muExerciseId.val()),
+        // @ts-ignore
+        layout: $('#mu-exercise-layout').val()
+      };
+    } else {
+      this._current = null;
+    }
+  }
+}
+
+mumuki.load(() => mumuki.exercise.load())