mumuki-laboratory 7.5.0

data/app/assets/javascripts/mumuki_laboratory/application/load-analytics.js

@@ -0,0 +1,4 @@
+mumuki.load(function(){
+  ga('create', 'UA-58353823-1', 'auto');
+  ga('send', 'pageview');
+});

data/app/assets/javascripts/mumuki_laboratory/application/load-error-svg.js

@@ -0,0 +1,11 @@
+mumuki.load(function () {
+  var error_svgs = ['403', '404', '500', 'timeout_1', 'timeout_2', 'timeout_3'];
+
+  mumuki.errors = mumuki.errors || {};
+
+  error_svgs.forEach(function (svgErrorName) {
+    muvment.animation.addImage(mumuki.errors, svgErrorName, '/error/');
+  });
+
+  mumuki.errorState = (error_name) => mumuki.errors[error_name].asState(error_name);
+});

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

@@ -0,0 +1,93 @@
+mumuki.load(function () {
+  var Chat = {
+    $body: function () {
+      return $('body')
+    },
+    $newMessageModal: function () {
+      return $('.new-message-modal');
+    },
+    $newMessageModalComponents: function () {
+      return Chat.$newMessageModal().find('.modal-body, .modal-footer');
+    },
+    collapseNewMessageModal: function () {
+      Chat.$newMessageModalComponents().toggleClass('hidden');
+    },
+    token: new mumuki.CsrfToken(),
+    setMessages: function (data) {
+      $('.badge-notifications').html(data.messages_count);
+      $('.notifications-box').toggleClass('notifications-box-empty', !data.has_messages);
+      $('.pending-messages-filter').removeClass('pending-messages-filter');
+      $('button.btn-submit').removeClass('disabled');
+      $('.pending-messages-text').remove()
+    },
+    readMessages: function (url) {
+      Chat.tokenRequest({
+        url: url,
+        method: 'POST',
+        success: Chat.setMessages,
+        xhrFields: {withCredentials: true}
+      })
+    },
+    tokenRequest: function (data) {
+      $.ajax(Chat.token.newRequest(data))
+    },
+    getMessages: function () {
+      if ($('.badge-messages').length == 0) {
+        return;
+      }
+      Chat.tokenRequest({
+        url: '/messages',
+        type: 'GET'
+      }).done(function (res) {
+        Chat.setMessages(res);
+      }).fail(function (_error) {
+        //ignoring error, not important
+      });
+    },
+    setMessagesInterval: function () {
+      mumuki.setInterval(Chat.getMessages, 60000);
+    },
+    submitMessagesForm: function (url, readUrl, errorUrl) {
+      var $container = $('.mu-view-messages');
+
+      function renderHTML(data) {
+        $container.empty();
+        $container.html(data);
+        $("a[data-target='#messages']").click();
+      }
+
+      function success(data) {
+        renderHTML(data);
+        Chat.readMessages(readUrl);
+      }
+
+      function error(xhr) {
+        Chat.tokenRequest({
+          url: errorUrl,
+          success: renderHTML,
+          xhrFields: {withCredentials: true}
+        });
+      }
+
+      $.ajax({
+        url: url,
+        success: success,
+        error: error,
+        xhrFields: {withCredentials: true}
+      })
+    },
+    openNewMessageModal: function () {
+      Chat.$newMessageModal().modal({backdrop: false, keyboard: false});
+      Chat.$body().addClass("new-message-modal-open");
+      Chat.$body().removeClass("modal-open");
+    },
+    closeNewMessageModal: function () {
+      Chat.$body().removeClass("new-message-modal-open");
+    }
+  };
+
+  Chat.setMessagesInterval();
+  mumuki.Chat = Chat;
+
+})
+

data/app/assets/javascripts/mumuki_laboratory/application/multiple-choice.js

@@ -0,0 +1,11 @@
+mumuki.load(() => {
+	function dumpChoices(evt) {
+		var indexes = $('.solution-choice:checked').map(function () {
+			return $(this).data('index')
+		}).get().join(':');
+		$('#solution_content').attr('value', indexes);
+	}
+
+	mumuki.onInputsReady('.solution-choice', dumpChoices);
+  $('.solution-choice').change(dumpChoices);
+});

data/app/assets/javascripts/mumuki_laboratory/application/multiple-files.js

@@ -0,0 +1,241 @@
+mumuki.load(() => {
+  class File {
+    static get NAME_CLASS() { return '.file-name'; }
+    static get DELETE_BUTTON_CLASS() { return '.delete-file-button'; }
+
+    constructor(tab, editor) {
+      this.tab = tab;
+      this.editor = editor;
+    }
+
+    initialize(name) {
+      this.name = name;
+      this.unselect();
+
+      return this;
+    }
+
+    get name() {
+      return this.tab.find(File.NAME_CLASS).text();
+    }
+
+    set name(name) {
+      return this.tab.find(File.NAME_CLASS).text(name);
+    }
+
+    get deleteButton() {
+      return this.tab.find(File.DELETE_BUTTON_CLASS);
+    }
+
+    get isSelected() {
+      return this.tab.hasClass("active");
+    }
+
+    setUpOnRemove(handler) {
+      this.tab.find(File.DELETE_BUTTON_CLASS).click(() => {
+        handler(this);
+      });
+    }
+
+    remove() {
+      const wasSelected = this.isSelected;
+
+      this.tab.remove();
+      this.editor.remove();
+
+      return wasSelected;
+    }
+
+    select() {
+      this._selectElement(this.tab);
+      this._selectElement(this.editor);
+    }
+
+    unselect() {
+      this._unselectElement(this.tab);
+      this._unselectElement(this.editor);
+    }
+
+    _selectElement(element) {
+      element.addClass('active');
+      element.addClass('in');
+    }
+
+    _unselectElement(element) {
+      element.removeClass('active');
+      element.removeClass('in');
+    }
+  }
+
+  class MultipleFileEditor {
+    constructor(tabsContainer, editorsContainer) {
+      this.tabsContainer = tabsContainer;
+      this.editorsContainer = editorsContainer;
+
+      this.MAX_TABS = 5;
+
+      this._addFileButton = this.tabsContainer.siblings('.add-file-button');
+      this.updateButtonsVisibility();
+    }
+
+    get mainFile() {
+      return this._mainFile || '';
+    }
+
+    set mainFile(mainFile) {
+      this._mainFile = mainFile;
+    }
+
+    get files() {
+      const editors = this.editors;
+
+      return this.tabs.map((i, tab) => {
+        return new File($(tab), $(editors[i]));
+      });
+    }
+
+    get tabs() {
+      return this.tabsContainer.children();
+    }
+
+    get editors() {
+      return this.editorsContainer.find('.file-editor');
+    }
+
+    get highlightModes() {
+      return this._getDataFromHiddenInput('#highlight-modes')
+    }
+
+    get locales() {
+      return this._getDataFromHiddenInput('#multifile-locales')
+    }
+
+    setUpAddFile() {
+      this._addFileButton.click(() => {
+        this._addFile();
+      });
+    }
+
+    setUpDeleteFiles() {
+      this.files.each((i, file) => {
+        this.setUpDeleteFile(file);
+      });
+    }
+
+    setUpDeleteFile(file) {
+      file.setUpOnRemove(() => this._deleteFile(file));
+    }
+
+    updateButtonsVisibility() {
+      const filesCount = this._getFilesCount();
+
+      this._setVisibility(this._addFileButton, filesCount < this.MAX_TABS);
+      this.files.toArray().forEach(file => {
+        this._setVisibility(file.deleteButton, file.name !== this.mainFile && filesCount > 1)
+      });
+    }
+
+    _addFile() {
+      let name = prompt(this.locales.insert_file_name);
+      const alreadyExists = this.files.toArray().some(it => it.name === name);
+      if (!name || !name.includes('.') || alreadyExists) return;
+      name = this._sanitize(name);
+
+      const id = `editor-file-${this._getFilesCount()}`;
+      this.tabsContainer.append(this._createTab(name, id));
+      this.editors.parent().last().append(this._createEditor(name, id));
+      const file = this.files.last().get(0).initialize(name);
+      this.setUpDeleteFile(file);
+
+      this.updateButtonsVisibility();
+    }
+
+    _deleteFile(file) {
+      const index = this.files.toArray()
+        .map(file => file.name)
+        .indexOf(file.name);
+      const previousIndex = Math.max(index - 1, 0);
+
+      const wasSelected = file.remove();
+      if (wasSelected) this.files[previousIndex].select();
+
+      this.updateButtonsVisibility();
+    }
+
+    _createTab(name, id) {
+      const tab = this.tabs.last().clone();
+      tab.attr('data-target', `#${id}`);
+
+      return tab;
+    }
+
+    _createEditor(name, id) {
+      const editor = this.editors.last().clone();
+      editor.attr('id', id);
+      editor.find('.CodeMirror').remove();
+
+      const textarea = editor.children().first();
+      this._setUpTextArea(textarea, `solution_content[${name}]`, `solution[content[${name}]]`);
+
+      const highlightMode = this._getHighlightModeFor(name);
+      const codeMirrorEditor = new mumuki.editor.CodeMirrorBuilder(textarea.get(0))
+        .setupEditor()
+        .setupMinLines(textarea.data('lines'))
+        .setupLanguage(highlightMode)
+        .build();
+
+      codeMirrorEditor.on("change", (event) => {
+        textarea.val(event.getValue());
+      });
+
+      const solutionTextArea = $('.new_solution').find('textarea').last();
+      this._setUpTextArea(solutionTextArea, '', '');
+
+      return editor;
+    }
+
+    _getFilesCount() {
+      return this.files.length;
+    }
+
+    _setUpTextArea(textarea, id, name) {
+      textarea.attr('id', id);
+      textarea.attr('name', name);
+      textarea.text('');
+      textarea.val('');
+    }
+
+    _getHighlightModeFor(name) {
+      const extension = name.split('.').pop();
+      const language = this.highlightModes.find((it) => it.extension === extension);
+
+      return language && language.highlight_mode || extension;
+    }
+
+    _sanitize(name) {
+      return name.replace(/[^0-9A-Z\.-]/ig, "_");
+    }
+
+    _setVisibility(element, isVisible) {
+      if (isVisible) element.show(); else element.hide();
+    }
+
+    _getDataFromHiddenInput(name) {
+      return JSON.parse($(name).val());
+    }
+  }
+
+  const setUpTabsBehavior = () => {
+    const tabsContainer = $('.nav-tabs').last();
+    if (!tabsContainer.length) return;
+    const editorsContainer = $('.tab-content');
+
+    const multipleFileEditor = new MultipleFileEditor(tabsContainer, editorsContainer);
+    mumuki.multipleFileEditor = multipleFileEditor;
+    multipleFileEditor.setUpAddFile();
+    multipleFileEditor.setUpDeleteFiles();
+  };
+
+  $(document).ready(setUpTabsBehavior);
+
+});

data/app/assets/javascripts/mumuki_laboratory/application/multiple-scenarios.js

@@ -0,0 +1,152 @@
+var mumuki = mumuki || {};
+
+(function (mumuki) {
+
+  const setControlVisibility = function ($control, visible) {
+    visible ? $control.show() : $control.hide();
+  };
+
+  const addClickListener = function($element, listener) {
+    $element.on('click', listener);
+  };
+
+  const getControlElement = function(controlSelector) {
+    return $(`.mu-scenario-control.${controlSelector} i`);
+  };
+
+  const statusIconMap = new Map([
+    ['pending', 'fa-circle'],
+    ['passed', 'fa-check-circle'],
+    ['failed', 'fa-times-circle']
+  ]);
+
+  const highlightAnimationClass = 'jump';
+
+  const statusesClasses = Array.from(statusIconMap.keys());
+  const iconsClasses = Array.from(statusIconMap.values());
+  const indicatorsClasses = iconsClasses.concat(statusesClasses);
+
+  const getClassesFor = (status) => [status, statusIconMap.get(status)];
+
+  const wrapScenario = ($scenario) => $scenario.wrap("<div class='mu-scenario'></div>").parent();
+
+  const setIndicatorStatus = function (indicator, status) {
+    const indicatorClassList = indicator.classList;
+    const statusClasses = getClassesFor(status);
+    indicatorClassList.remove(...indicatorsClasses);
+    indicatorClassList.add(...statusClasses);
+  };
+
+  const unhighlightIndicator = function ($indicator) {
+    $indicator.classList.remove(highlightAnimationClass);
+  };
+
+  const highlightIndicator = function ($indicator) {
+    $indicator.classList.add(highlightAnimationClass);
+  };
+
+  const triggerResize = function () {
+    let event = document.createEvent('HTMLEvents');
+    event.initEvent('resize', true, false);
+    document.dispatchEvent(event);
+  };
+
+  class MultipleScenarios {
+    constructor(selectors) {
+      this.indicators = $('.mu-multiple-scenarios .indicators');
+      this.initialize(selectors);
+    }
+
+    initialize (selectors) {
+      this.createScenarios(selectors);
+      this.createControls();
+      this.createIndicators();
+      this.setActiveIndex(0);
+      $('.mu-scenario-control').removeClass('hidden');
+    }
+
+    validScenarioIndex (index) {
+      return index >= 0 && index < this.scenariosCount;
+    }
+
+    createControlListener ($control, changeStep) {
+      addClickListener($control, () => {
+        const newScenarioIndex = this.currentScenarioIndex + changeStep;
+        if (this.validScenarioIndex(newScenarioIndex)) {
+          this.setActiveIndex(newScenarioIndex);
+        }
+      })
+    }
+
+    createControls () {
+      this.previousControl = getControlElement('previous');
+      this.nextControl = getControlElement('next');
+      this.createControlListener(this.previousControl, -1);
+      this.createControlListener(this.nextControl, 1);
+    }
+
+    createScenarios (selectors) {
+      let $scenarios = selectors.map(selector => $(`.mu-multiple-scenarios ${selector}`));
+      this.scenarios = $scenarios.map($scenario => wrapScenario($scenario));
+      this.scenariosCount = this.scenarios[0].length;
+    }
+
+    createIndicators () {
+      for (let index = 0; index < this.scenariosCount; index++) {
+        let $indicator = $('<li class="fa"></li>');
+        this.indicators.append($indicator);
+        let indicatorIndex = index;
+        addClickListener($indicator, () => {
+          this.setActiveIndex(indicatorIndex);
+        });
+      }
+      this.indicatorItems = this.indicators.children('li');
+      this.resetIndicators();
+    }
+
+    setActiveIndex (index) {
+      this.currentScenarioIndex = index;
+      this.setActiveScenario(index);
+      unhighlightIndicator(this.indicatorItems[index]);
+      this.updateControls(index);
+      triggerResize();
+    }
+
+    updateControls (index) {
+      setControlVisibility(this.previousControl, index !== 0);
+      setControlVisibility(this.nextControl, index !== this.scenariosCount - 1);
+    }
+
+    setActiveScenario (index) {
+      [...this.scenarios, this.indicatorItems].forEach(($scenario) => {
+        $scenario.removeClass('active');
+        $scenario[index].classList.add('active');
+      });
+    }
+
+    updateIndicators (testResultsStatuses) {
+      testResultsStatuses.forEach((status, index) => {
+        const $indicator = this.indicatorItems[index];
+        setIndicatorStatus($indicator, status);
+      });
+      this.highlightFailedScenario(testResultsStatuses);
+    }
+
+    highlightFailedScenario (testResultsStatuses) {
+      const currentStatus = testResultsStatuses[this.currentScenarioIndex];
+      const isCurrentFailed = currentStatus === 'failed';
+      const $failedIndicator = this.indicatorItems.filter('.failed')[0];
+      if($failedIndicator && !isCurrentFailed) highlightIndicator($failedIndicator);
+    }
+
+    resetIndicators () {
+      this.indicatorItems.each((_, $indicator) => {
+        setIndicatorStatus($indicator, 'pending');
+        unhighlightIndicator($indicator);
+      });
+    }
+  }
+
+  mumuki.MultipleScenarios = MultipleScenarios;
+
+}(mumuki));