mumuki-laboratory 7.7.6 → 7.8.0

data/app/assets/javascripts/mumuki_laboratory/application/speech-bubble-renderer.js

@@ -1,4 +1,5 @@
-((mumuki)=> {
+mumuki.renderers = mumuki.renderers || {};
+mumuki.renderers.speechBubble = (()=> {
 
   function renderSpeechBubbleResultItem(item) {
     return `
@@ -93,7 +94,13 @@
     }
   }
 
-  mumuki.renderers = mumuki.renderers || {};
-  mumuki.renderers.SpeechBubbleRenderer = SpeechBubbleRenderer;
-  mumuki.renderers.renderSpeechBubbleResultItem = renderSpeechBubbleResultItem;
-})(mumuki)
+  return {
+    SpeechBubbleRenderer,
+    renderSpeechBubbleResultItem
+  }
+})();
+
+/** @deprecated use {@code mumuki.renderers.speechBubble.SpeechBubbleRenderer} instead */
+mumuki.renderers.SpeechBubbleRenderer = mumuki.renderers.speechBubble.SpeechBubbleRenderer;
+/** @deprecated use {@code mumuki.renderers.speechBubble.renderSpeechBubbleResultItem} instead */
+mumuki.renderers.renderSpeechBubbleResultItem = mumuki.renderers.speechBubble.renderSpeechBubbleResultItem;

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

@@ -1,6 +1,4 @@
-var mumuki = mumuki || {};
-
-(function (mumuki) {
+mumuki.submission = (() => {
 
   // =============
   // UI Components
@@ -14,32 +12,31 @@ var mumuki = mumuki || {};
       .play();
   }
 
-  function ResultsBox(submissionsResults) {
-    this.submissionsResultsArea = submissionsResults;
-    this.processingTemplate = $('#processing-template');
-    this.submissionsErrorTemplate = $(".submission-result-error");
-  }
-
-  ResultsBox.prototype = {
-    waiting: function () {
+  class ResultsBox {
+    constructor(submissionsResults) {
+      this.submissionsResultsArea = submissionsResults;
+      this.processingTemplate = $('#processing-template');
+      this.submissionsErrorTemplate = $(".submission-result-error");
+    }
+    waiting() {
       this.submissionsResultsArea.html(this.processingTemplate.html());
       this.submissionsErrorTemplate.hide();
-    },
-    success: function (data, submitButton) {
+    }
+    success(data, submitButton) {
       this.submissionsResultsArea.html(data.html);
       data.status === 'aborted' ? this.error(submitButton) : submitButton.enable();
       mumuki.updateProgressBarAndShowModal(data);
-    },
-    error: function (submitButton) {
+    }
+    error(submitButton) {
       this.submissionsResultsArea.html('');
       this.submissionsErrorTemplate.show();
       animateTimeoutError(submitButton);
-    },
-    done: function (data, submitButton) {
+    }
+    done(data, submitButton) {
       submitButton.updateAttemptsLeft(data);
       mumuki.pin.scroll();
     }
-  };
+  }
 
   class SubmitButton extends mumuki.Button {
 
@@ -59,78 +56,6 @@ var mumuki = mumuki || {};
     }
   }
 
-  // ============
-  // Content Sync
-  // ============
-
-  /**
-   * 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[]}
-   */
-  function getStandardEditorContents() {
-    mumuki.submission._syncContent();
-    return $('.new_solution').serializeArray();
-  }
-
-  /**
-   * Answers a content 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
-   */
-  function getContent() {
-    let content = {};
-    let contents;
-
-    if (mumuki.CustomEditor.hasSources) {
-      contents = mumuki.CustomEditor.getContents();
-    } else {
-      contents = mumuki.submission.getStandardEditorContents();
-    }
-
-    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
-   */
-  function _syncContent() {
-    if (mumuki.submission._contentSyncer) {
-      mumuki.submission._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
-   */
-  function registerContentSyncer(syncer = null) {
-    mumuki.submission._contentSyncer = syncer;
-  }
 
   // ==========
   // Processing
@@ -212,7 +137,7 @@ var mumuki = mumuki || {};
   // Entry Point
   // ===========
 
-  mumuki.load(function () {
+  mumuki.load(() => {
     var $submissionsResults = $('.submission-results');
     if (!$submissionsResults) return;
 
@@ -222,8 +147,7 @@ var mumuki = mumuki || {};
     mumuki.submission._selectSolutionProcessor(submitButton, $submissionsResults);
 
     submitButton.start(() => {
-      var solution = mumuki.submission.getContent();
-      mumuki.submission.processSolution(solution);
+      mumuki.submission.processSolution(mumuki.editors.getSubmission());
     });
 
     submitButton.checkAttemptsLeft();
@@ -244,18 +168,12 @@ var mumuki = mumuki || {};
    *
    * @module mumuki.submission
    */
-  mumuki.submission = {
+  return {
     processSolution,
     _registerSolutionProcessor,
     _selectSolutionProcessor,
 
-    _syncContent,
-    registerContentSyncer,
-    getStandardEditorContents,
-    getContent,
-
     animateTimeoutError,
     SubmitButton,
   };
-
-})(mumuki);
+})();

data/app/assets/javascripts/mumuki_laboratory/application/submissions-store.js

@@ -0,0 +1,93 @@
+mumuki.SubmissionsStore = (() => {
+  const SubmissionsStore = new class {
+    /**
+     * Returns the submission's result status for the last submission to
+     * the given exercise, or pending, if not present
+     *
+     * @param {number} exerciseId
+     * @returns {SubmissionStatus}
+     */
+    getLastSubmissionStatus(exerciseId) {
+      const submission = this.getLastSubmissionAndResult(exerciseId);
+      return submission ? submission.result.status : 'pending';
+    }
+
+    /**
+     * Returns the submission and result for the last submission to
+     * the given exercise
+     *
+     * @param {number} exerciseId
+     * @returns {SubmissionAndResult}
+     */
+    getLastSubmissionAndResult(exerciseId) {
+      const submissionAndResult = window.localStorage.getItem(this._keyFor(exerciseId));
+      if (!submissionAndResult) return null;
+      return JSON.parse(submissionAndResult);
+    }
+
+    /**
+     * Saves the result for the given exercise
+     *
+     * @param {number} exerciseId
+     * @param {SubmissionAndResult} submissionAndResult
+     */
+    setSubmissionResultFor(exerciseId, submissionAndResult) {
+      window.localStorage.setItem(this._keyFor(exerciseId), this._asString(submissionAndResult));
+    }
+
+    /**
+     * Retrieves the last cached, non-aborted result for the given submission of the given exercise
+     *
+     * @param {number} exerciseId
+     * @param {Submission} submission
+     * @returns {SubmissionResult} the cached result for this submission
+     */
+    getSubmissionResultFor(exerciseId, submission) {
+      const last = this.getLastSubmissionAndResult(exerciseId);
+      if (!last
+          || last.result.status === 'aborted'
+          || !this.submissionSolutionEquals(last.submission, submission)) {
+        return null;
+      }
+      return last.result;
+    }
+
+     /**
+     * Extract the submission's solution content
+     *
+     * @param {Submission} submission
+     * @returns {string}
+     */
+    submissionSolutionContent(submission) {
+      if (submission.solution) {
+        return submission.solution.content;
+      } else {
+        return submission['solution[content]'];
+      }
+    }
+
+    /**
+     * Compares two solutions to determine if they are equivalent
+     * from the point of view of the code evaluation
+     *
+     * @param {Submission} one
+     * @param {Submission} other
+     * @returns {boolean}
+     */
+    submissionSolutionEquals(one, other) {
+      return this.submissionSolutionContent(one) === this.submissionSolutionContent(other);
+    }
+
+    // private API
+
+    _asString(object) {
+      return JSON.stringify(object);
+    }
+
+    _keyFor(exerciseId) {
+      return `/exercise/${exerciseId}/submission`;
+    }
+  };
+
+  return SubmissionsStore;
+})();

data/app/assets/javascripts/mumuki_laboratory/application/sync-mode.js

@@ -0,0 +1,75 @@
+/** @type {boolean} */
+mumuki.incognitoUser;
+mumuki.syncMode = (() => {
+
+  /**
+   * Syncs progress and solutions
+   * from local storage
+   */
+  class ClientSyncMode {
+    syncProgress() {
+      mumuki.progress.updateWholeProgressBar($anchor => this._getProgressListItemClass($anchor));
+    }
+
+    syncEditorContent() {
+      const lastSubmission = mumuki.SubmissionsStore.getLastSubmissionAndResult(mumuki.exercise.id);
+      if (lastSubmission) {
+        /** @todo extract core module  */
+        const content = mumuki.SubmissionsStore.submissionSolutionContent(lastSubmission.submission);
+        mumuki.editors.setContent(content);
+      }
+    }
+
+    /**
+     * @param {JQuery} $anchor
+     */
+    _getProgressListItemClass($anchor) {
+      const exerciseId = $anchor.data('mu-exercise-id');
+      const status = mumuki.SubmissionsStore.getLastSubmissionStatus(exerciseId);
+      return mumuki.renderers.progressListItemClassForStatus(status, exerciseId == mumuki.exercise.id);
+    }
+
+  }
+
+  /**
+   * Syncs progress and solutions from server.
+   *
+   * This class does nothing actually, since a server-side behaviour is the default one
+   * and no additional actions are needed.
+   */
+  class ServerSyncMode {
+    syncProgress() {
+      // nothing
+    }
+
+    syncEditorContent() {
+      // nothing
+    }
+  }
+
+
+  /** Selects the most appropriate sync mode */
+  function _selectSyncMode() {
+    if (mumuki.incognitoUser) {
+      mumuki.syncMode._current = new ClientSyncMode();
+    } else {
+      mumuki.syncMode._current = new ServerSyncMode();
+    }
+  }
+
+  return {
+    ServerSyncMode,
+    ClientSyncMode,
+
+    _selectSyncMode,
+
+    /** @type {ClientSyncMode|ServerSyncMode}*/
+    _current: null
+  }
+})();
+
+mumuki.load(() => {
+  mumuki.syncMode._selectSyncMode();
+  mumuki.syncMode._current.syncProgress();
+  mumuki.syncMode._current.syncEditorContent();
+})

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

@@ -1,7 +1,5 @@
-var mumuki = mumuki || {};
-
-(function (mumuki) {
-  mumuki.startTimer = function (endDate) {
+mumuki.startTimer = (() => {
+  function startTimer(endDate) {
     var endTime = new Date(endDate).getTime();
     var currentTime = Date.now();
     var diffTime = endTime - currentTime;
@@ -17,5 +15,6 @@ var mumuki = mumuki || {};
         $('#timer').text(duration.format("HH:mm:ss"));
       }
     }, intervalDuration);
-  };
-})(mumuki);
+  }
+  return startTimer
+})();

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

@@ -1,3 +1,3 @@
-mumuki.load(function () {
+mumuki.load(() => {
     $('[title]').tooltip();
 });

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

@@ -1,4 +1,4 @@
-mumuki.load(function() {
+mumuki.load(() => {
   $('#upload-input').change(function (evt) {
     var file = evt.target.files[0];
     if (!file) return;

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

@@ -1,4 +1,4 @@
-mumuki.load(function () {
+mumuki.load(() => {
   var hash = document.location.hash;
   if (hash) {
     $(".nav-tabs a[data-target='" + hash + "']").tab('show');

data/app/assets/stylesheets/mumuki_laboratory/application/modules/_gs-board.scss

@@ -4,5 +4,8 @@ gs-board {
     span {
       vertical-align: middle;
     }
+    &.gs-board {
+      background-color: #FFFFFF;
+    }
   }
 }

data/app/assets/stylesheets/mumuki_laboratory/application/modules/_kids.scss

@@ -338,7 +338,6 @@ $kids-speech-tabs-width: 40px;
         td, th {
           &.gs-board {
             border: $kids-speech-border !important;
-            background-color: #FFFFFF;
           }
           &.gbs_lx,
           &.gbs_lh,

data/app/controllers/application_controller.rb

@@ -11,6 +11,7 @@ class ApplicationController < ActionController::Base
   include Mumuki::Laboratory::Controllers::Notifications
   include Mumuki::Laboratory::Controllers::DynamicErrors
   include Mumuki::Laboratory::Controllers::EmbeddedMode
+  include Mumuki::Laboratory::Controllers::IncognitoMode
 
   before_action :set_current_organization!
   before_action :set_locale!

data/app/helpers/{locale_helper.rb → globals_helper.rb}

@@ -1,10 +1,14 @@
-module LocaleHelper
-  def locale_tags
+module GlobalsHelper
+  def globals_tags
     %Q{
       <script type="text/javascript">
         window.mumukiLocale = #{raw Organization.current.locale_json};
         mumuki.locale = '#{Organization.current.locale}';
         moment.locale('#{Organization.current.locale}');
+
+        mumuki.incognitoUser = #{current_incognito_user?};
+
+        mumuki.version = '#{Mumuki::Laboratory::VERSION}';
       </script>
     }.html_safe
   end