mumuki-gobstones-runner 2.8.5 → 2.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a1f462df1de2aa09e7025bc39fb066ebae0cf95203e2863276e549c57b35550
-  data.tar.gz: b1e8fbb1a19f96b130b5a5a25b3d8e582932b5c1d4063ece0ddcfe5358394980
+  metadata.gz: 1636b8a5a322c4a74f84a725e8df8fa0118e38362b3732a70e76deba7b87e620
+  data.tar.gz: 41d818b4cb24ce921ed45f0c539437ac0395ddc4152e2f5a4ebf3e2a19168b07
 SHA512:
-  metadata.gz: dbb901882298f1c889730748bfb60ba8016535198e2953d6f5b72f986f617c65230cdf06b7a7a6326459d9a11b2d46945df9dc1c9faf10c5b46f05fcab65fa8e
-  data.tar.gz: 3ce96b0e01751e64a831a56565352eb378b612aee687d074e116911d305004f97e7c9feacb5522b2582b264a1ad90c1a67fdb4ded965504c2a56aa1a427bfe5e
+  metadata.gz: bb2ac8c37f98b4239de66fdc9f4b73982a013769add4d71172561e7d399774038647690468193a2dee19d2c8cf886582538f4bfc13479057a3837918affec4d0
+  data.tar.gz: aba3b7d54384b3c44587219236ccfb4d3720560d63f5d7ac8193bc95604e4ec1ddd3de32544c8fcbaf0d3f396d19c62b3c9b6576b036e27f17d7d207d155b827

data/lib/assets_server.rb

@@ -54,6 +54,8 @@ class Mumukit::Server::App < Sinatra::Base
 
   get '/assets/editor/editor.html' do
     cross_origin
+    content_type 'text/html'
+
     @game_framework_extra = Gobstones::CompilationMode::GameFramework.extra_code
     @game_framework_program = Gobstones::CompilationMode::GameFramework.program_code
     @game_framework_default = Gobstones::CompilationMode::GameFramework.default_code

data/lib/checker.rb

@@ -113,6 +113,7 @@ module Gobstones
       return "no_stones" if code == 'cannot-remove-stone'
       return "out_of_board" if code == 'cannot-move-to'
       return "unassigned_variable" if code == 'undefined-variable'
+      return "boom_called" if code == 'boom-called'
       return "wrong_argument_type" if has_wrong_argument_type? code
       return "wrong_arguments_quantity" if code.include? 'arity-mismatch'
 

data/lib/feedback_hook.rb

@@ -0,0 +1,210 @@
+class GobstonesFeedbackHook < Mumukit::Hook
+  def run!(request, results)
+    content = request.content
+    test_results = results.test_results[0]
+
+    GobstonesExplainer.new.explain(content, test_results) if test_results.is_a? String
+  end
+
+  class GobstonesExplainer < Mumukit::Explainer
+    def explain_program_has_a_name(submission, result)
+      if identifier_instead_of_brace? result
+        (submission.match malformed_program_header_with_name).try do |it|
+          { name: it[1] }
+        end
+      end
+    end
+
+    def explain_program_has_no_opening_curly_brace(submission, result)
+      if identifier_instead_of_brace? result
+        /#{malformed_program_header_with_no_curly_braces}/ =~ submission
+      end
+    end
+
+    def explain_program_before_closing_structure_when_program(submission, result)
+      if program_instead_of_command?(result) && missing_brace_end?(submission) && function_or_procedure?(submission)
+        (submission.match program).try do |it|
+          { keyword: last_function_or_procedure(submission) }
+        end
+      end
+    end
+
+    def explain_program_before_closing_structure_when_no_program(submission, result)
+      if program_instead_of_command?(result) && missing_brace_end?(submission) && function_or_procedure?(submission)
+        if /#{program}/ =~ submission
+          nil
+        else
+          { keyword: last_function_or_procedure(submission) }
+        end
+      end
+    end
+
+    def explain_surplus_closing_brace(_, result)
+      if unbalanced_closing_braces? result
+        (error_line(result)).try do |it|
+          { line: it[1] }
+        end
+      end
+    end
+
+    def explain_upper_function_typo(submission, result)
+      if upper_identifier_instead_of_definition? result
+        /#{uppercase_function}/ =~ submission
+      end
+    end
+
+    def explain_upper_procedure_typo(submission, result)
+      if upper_identifier_instead_of_definition? result
+        /#{uppercase_procedure}/ =~ submission
+      end
+    end
+
+    def explain_upper_program_typo(submission, result)
+      if upper_identifier_instead_of_definition? result
+        /#{uppercase_program}/ =~ submission
+      end
+    end
+
+    def explain_missing_closing_brace_after_procedure(submission, result)
+      if procedure_instead_of_command?(result) && missing_brace_end?(submission)
+        (error_line(result)).try do |it|
+          { line: it[1] }
+        end
+      end
+    end
+
+    def explain_lower_builtin_procedure_typo(submission, result)
+      if open_paren_instead_of_assign?(result)
+        (submission.match lower_builtin_procedure).try do |it|
+          { lower: it[1][0...5], upper: it[1][0...5].capitalize }
+        end
+      end
+    end
+
+    def explain_upper_builtin_function_typo(submission, result)
+      if procedure_invocation_instead_of_expression?(result)
+        (submission.match upper_builtin_function).try do |it|
+          { upper: it[1], lower: it[1].camelize(:lower) }
+        end
+      end
+    end
+
+    def explain_color_typo(_, result)
+      if roja_not_defined?(result) || negra_not_defined?(result)
+        (result.match color_not_defined).try do |it|
+          { color: it[1], rectified_color: rectified_color(it[1]) }
+        end
+      end
+    end
+
+    private
+
+    def malformed_program_header_with_name
+      '.*program +([A-Za-z]\w*)'
+    end
+
+    def upper_identifier_instead_of_brace?(result)
+      identifier_instead_of_brace?(result, 'may')
+    end
+
+    def lower_identifier_instead_of_brace?(result)
+      identifier_instead_of_brace?(result, 'min')
+    end
+
+    def identifier_instead_of_brace?(result, capital='...')
+      result.match? /<pre>\[\d+:\d+\]: Se esperaba una llave izquierda \("{"\).\nSe encontró: un identificador con #{capital}úsculas.<\/pre>/
+    end
+
+    def malformed_program_header_with_no_curly_braces
+      '.*program *[\r\n]\s*[^{]\w+'
+    end
+
+    def program_instead_of_command?(result)
+      result.match? /<pre>\[\d+:\d+\]: Se esperaba un comando.\nSe encontró: la palabra clave "program".<\/pre>/
+    end
+
+    def missing_brace_end?(submission)
+      submission.count('{') > submission.count('}')
+    end
+
+    def function_or_procedure?(submission)
+      submission.match? function_or_procedure
+    end
+
+    def function_or_procedure
+      '(function)\s*\w+\s*\([\w\d\s,]*\)\s*{|(procedure)\s*\w+\s*\([\w\d\s,]*\)\s*{'
+    end
+
+    def last_function_or_procedure(submission)
+      submission.scan(/#{function_or_procedure}/).last.compact.first
+    end
+
+    def program
+      'program\s*{'
+    end
+
+    def unbalanced_closing_braces?(result)
+      result.match? /<pre>\[\d+:\d+\]: Se encontró un "}" pero no había una llave abierta "{".<\/pre>/
+    end
+
+    def error_line(result)
+      result.match /<pre>\[(\d+):\d+\]:/
+    end
+
+    def upper_identifier_instead_of_definition?(result)
+      result.match? /<pre>\[\d+:\d+\]: Se esperaba una definición \(de programa, función, procedimiento, o tipo\).\nSe encontró: un identificador con mayúsculas.<\/pre>/
+    end
+
+    def uppercase_function
+      'Function\s'
+    end
+
+    def uppercase_procedure
+      'Procedure\s'
+    end
+
+    def uppercase_program
+      'Program[\s{]*'
+    end
+
+    def procedure_instead_of_command?(result)
+      result.match? /<pre>\[\d+:\d+\]: Se esperaba un comando.\nSe encontró: la palabra clave "procedure".<\/pre>/
+    end
+
+    def open_paren_instead_of_assign?(result)
+      result.match? /<pre>\[\d+:\d+\]: Se esperaba un operador de asignación \(":="\).\nSe encontró: un paréntesis izquierdo \("\("\).<\/pre>/
+    end
+
+    def lower_builtin_procedure
+      '(mover[\s(]|poner[\s(]|sacar[\s(])'
+    end
+
+    def procedure_invocation_instead_of_expression?(result)
+      result.match? /<pre>\[\d+:\d+\]: Se esperaba una expresión.\nSe encontró: una invocación a un procedimiento.<\/pre>/
+    end
+
+    def upper_builtin_function
+      '(PuedeMover|NroBolitas|HayBolitas)'
+    end
+
+    def roja_not_defined?(result)
+      color_not_defined? result, 'Roja'
+    end
+
+    def negra_not_defined?(result)
+      color_not_defined? result, 'Negra'
+    end
+
+    def color_not_defined?(result, color)
+      result.match?(color_not_defined(color))
+    end
+
+    def color_not_defined(color='\w+')
+      /<pre>\[\d+:\d+\]: El constructor "(#{color})" no está definido.<\/pre>/
+    end
+
+    def rectified_color(color)
+      color.chop + "o"
+    end
+  end
+end

data/lib/gobstones_runner.rb

@@ -21,9 +21,10 @@ require_relative './render/html_renderer'
 
 require_relative './multiple_executions_runner'
 
+require_relative './checker'
+require_relative './expectations_hook'
+require_relative './feedback_hook'
 require_relative './metadata_hook'
 require_relative './precompile_hook'
 require_relative './test_hook'
 require_relative './version_hook'
-require_relative './expectations_hook'
-require_relative './checker'

data/lib/locales/en.yml

@@ -12,7 +12,19 @@ en:
   code_wrong_argument_type: 'wrong arguments type'
   code_unassigned_variable: 'unassigned variable'
   code_wrong_arguments_quantity: 'wrong arguments quantity'
+  color_typo: 'It seems you wrote %{color}. Maybe you meant %{rectified_color}?'
   expected_board: 'Expected final board'
   final_board: 'Final board'
   initial_board: 'Initial board'
+  lower_builtin_procedure_typo: 'Looks lie you wrote <code>%{lower}</code> in lowercase. Remember procedures such as <code>%{upper}()</code> should start in uppercase!'
+  missing_closing_brace_after_procedure: "Looks like you're missing a <code>}</code> to close a <code>procedure</code>. Maybe it's on line <strong>%{line}</strong> or near it?"
   no_program_found: 'No program definition was found'
+  program_before_closing_structure_when_no_program: "Looks like you're missing a <code>}</code> to close the last <code>%{keyword}</code>."
+  program_before_closing_structure_when_program: "Looks like you're missing a <code>}</code> to close the last <code>%{keyword}</code> before <code>program</code>."
+  program_has_a_name: "Looks like you named your <code>program</code> <code>%{name}</code>, but <code>program</code>s shouldn't be named."
+  program_has_no_opening_curly_brace: "Looks like a <code>{</code> is missing on <code>program</code>. Remember the content in <code>program</code> should be between curly braces."
+  surplus_closing_brace: "The amount of <code>{</code> and <code>}</code> doesn't match. Maybe there's an extra <code>}</code> on line <strong>%{line}</strong> or near it?"
+  upper_builtin_function_typo: 'Looks like you wrote <code>%{upper}</code> starting in uppercase. Remember functions such as <code>%{lower}</code> should start in lowercase!'
+  upper_function_typo: 'Looks like you wrote <code>Function</code> instead of <code>function</code>. Remember it should start in lowercase!'
+  upper_procedure_typo: 'Looks like you wrote <code>Procedure</code> instead of <code>procedure</code>. Remember it should start in lowercase!'
+  upper_program_typo: 'Looks like you wrote <code>Program</code> instead of <code>program</code>. Remember it should start in lowercase!'

data/lib/locales/es.yml

@@ -12,7 +12,19 @@ es:
   code_wrong_argument_type: 'problema de tipos en los argumentos'
   code_unassigned_variable: 'variable no asignada'
   code_wrong_arguments_quantity: 'cantidad errónea de argumentos'
+  color_typo: 'Parece que escribiste %{color}. ¿Quisiste referirte al color %{rectified_color}?'
   expected_board: 'Tablero final esperado'
   final_board: 'Tablero final'
   initial_board: 'Tablero inicial'
+  lower_builtin_procedure_typo: 'Parece que escribiste <code>%{lower}</code> en minúsculas. ¡Recordá que los procedimientos como <code>%{upper}()</code> deben comenzar en mayúsculas!'
+  missing_closing_brace_after_procedure: 'Parece que te falta una <code>}</code> que cierre un <code>procedure</code>. ¿Puede que sea en la línea <strong>%{line}</strong> o cerca de ella?'
   no_program_found: 'No se encontró ninguna definición de programa'
+  program_before_closing_structure_when_no_program: 'Parece que te falta una <code>}</code> que cierre el último <code>%{keyword}</code>.'
+  program_before_closing_structure_when_program: 'Parece que te falta una <code>}</code> que cierre el <code>%{keyword}</code> antes de <code>program</code>.'
+  program_has_a_name: 'Parece que llamaste <code>%{name}</code> a <code>program</code>, pero los <code>program</code> no llevan nombre.'
+  program_has_no_opening_curly_brace: 'Parece que a <code>program</code> le falta <code>{</code>. Recordá que el contenido de <code>program</code> va entre llaves.'
+  surplus_closing_brace: 'La cantidad de <code>{</code> y <code>}</code> no coincide. ¿Puede que sobre una <code>}</code> en la línea <strong>%{line}</strong> o cerca de ella?'
+  upper_builtin_function_typo: 'Parece que escribiste <code>%{upper}</code> comenzando en mayúsculas. ¡Recordá que las funciones como <code>%{lower}</code> deben comenzar en minúsculas!'
+  upper_function_typo: 'Parece que escribiste <code>Function</code> en lugar de <code>function</code>. ¡Recordá que debe comenzar en minúsculas!'
+  upper_procedure_typo: 'Parece que escribiste <code>Procedure</code> en lugar de <code>procedure</code>. ¡Recordá que debe comenzar en minúsculas!'
+  upper_program_typo: 'Parece que escribiste <code>Program</code> en lugar de <code>program</code>. ¡Recordá que debe comenzar en minúsculas!'

data/lib/locales/pt.yml

@@ -12,7 +12,19 @@ pt:
   code_wrong_argument_type: 'problema de tipos nos argumentos'
   code_unassigned_variable: 'variável não atribuída'
   code_wrong_arguments_quantity: 'quantidade errada de argumentos'
+  color_typo: 'Parece que você escreveu %{color}. Você quis se referir à cor %{rectified_color}?'
   expected_board: 'Tabuleiro final esperado'
   final_board: 'Tabuleiro final'
   initial_board: 'Tabuleiro inicial'
+  lower_builtin_procedure_typo: 'Parece que você escreveu <code>%{lower}</code> em letras minúsculas. Lembre-se de que procedimentos como <code>%{upper}()</code> devem começar em maiúsculas!'
+  missing_closing_brace_after_procedure: 'Parece que está faltando um <code>}</code> que fecha um <code>procedure</code>. Pode ser na linha <strong>%{line}</strong> ou perto dela?'
   no_program_found: 'Nenhuma definição de programa foi encontrada'
+  program_before_closing_structure_when_no_program: 'Parece que está faltando um <code>}</code> que fecha a última <code>%{keyword}</code>.'
+  program_before_closing_structure_when_program: 'Parece que está faltando um <code>}</code> que fecha o <code>%{keyword}</code> antes do <code>program</code>.'
+  program_has_a_name: 'Parece que você chamou <code>%{name}</code> para <code>program</code>, mas <code>program</code>as não têm nomes.'
+  program_has_no_opening_curly_brace: 'Parece que a <code>program</code> está faltando <code>{</code>. Lembre-se de que o conteúdo do <code>program</code> está entre colchetes.'
+  surplus_closing_brace: 'A quantidade de <code>{</code> e <code>}</code> não corresponde. Pode ser sobre um <code>}</code> na linha <strong>%{line}</strong> ou próximo a ela?'
+  upper_builtin_function_typo: 'Parece que você digitou <code>%{upper}</code> começando com letras maiúsculas. Lembre-se de que funções como <code>%{lower}</code> devem começar em minúsculas!'
+  upper_function_typo: 'Parece que você escreveu <code>Function</code> em vez de <code>function</code>. Lembre-se de começar em letras minúsculas!'
+  upper_procedure_typo: 'Parece que você escreveu <code>Procedure</code> em vez de <code>procedure</code>. Lembre-se de começar em letras minúsculas!'
+  upper_program_typo: 'Parece que você escreveu <code>Program</code> em vez de <code>program</code>. Lembre-se de começar em letras minúsculas!'

data/lib/render/editor/editor.css

@@ -116,7 +116,6 @@
   }
 }
 
-
 .mu-kids-exercise.mu-kindergarten .gbs_boom {
   display: none;
 }
@@ -124,3 +123,13 @@
 .mu-kids-exercise.mu-kindergarten .mu-scenario.active table.gbs_board {
   display: block !important;
 }
+
+.mu-kids-exercise.mu-kindergarten .gbs_gh {
+  outline: 0 !important;
+}
+
+.mu-kids-exercise.mu-kindergarten .mu-kids-state .mu-kids-state-image gs-board>table {
+    background-color: #6D6E70!important;
+    border: 1px solid #6D6E70 !important;
+    border-radius: 4px;
+}

data/lib/render/editor/editor.html.erb

@@ -5,6 +5,29 @@
 <script src="./hammer.min.js"></script>
 
 <script>
+  Blockly.FieldImage.prototype.__setValue__ = Blockly.FieldImage.prototype.setValue;
+  Blockly.FieldImage.prototype.setValue = function(a) {
+    if (a && a.startsWith("undefined")) {
+      console.debug(`Ignoring unavailable image ${a}`);
+    } else if (a) {
+      const absoluteUrl = a
+        .replace("../media/", "../local-media/")
+        .replace("../local-media/", "<%= @assets_url %>/local-media/");
+      this.__setValue__(absoluteUrl);
+    } else {
+      this.__setValue__(a);
+    }
+  }
+
+  Blockly.FieldImage.prototype.__setTooltip__ = Blockly.FieldImage.prototype.setTooltip;
+  Blockly.FieldImage.prototype.setTooltip = function(a) {
+    try {
+      this.__setTooltip__(a);
+    } catch (_e) {
+      console.debug('Could not set tooltip');
+    }
+  }
+
   function postpone(action) {
     return setTimeout(action, 50);
   }
@@ -115,10 +138,28 @@
         this._scrollToMainBlock();
       },
 
-      setToolbox(toolboxXml) {
-        this._getBlockly().toolbox = { defaultToolbox: toolboxXml };
-        // Blockly's workspace is destroyed when toolbox changes, so we initialize it here.
-        this._initializeBlocklyWorkspace();
+      /**
+       * Configures a custom toolbox using a toolbox url
+       * This method does nothing if editor is read-only, but
+       * assumes a gs-toolbox element is present - otherwise it would
+       * have no sense to have a toolboxUrl.
+       */
+      configureCustomToolboxFromUrl(toolboxUrl) {
+        if (this.readOnly) return;
+
+        console.debug('Configuring custom toolbox');
+
+        $.get(toolboxUrl, (toolboxXml) => {
+          this._initializeCustomToolboxBlocklyWorkspace(toolboxXml);
+        });
+      },
+
+      /**
+       * Wether a custom toolbox is required. Read only editors and gs-toolbox-less context
+       * don't require it
+       */
+      hasCustomToolbox() {
+        return !this.readOnly && $('gs-toolbox').length;
       },
 
       compile(code) {
@@ -129,10 +170,6 @@
         return this._getBlockly().initialXml.indexOf("block type=\"InteractiveProgram\"") !== -1;
       },
 
-      hasCustomToolbox() {
-        return $('gs-toolbox').length;
-      },
-
       toggleInteractiveMode() {
         this.$exerciseContainer.toggleClass('play-mode');
         this._triggerResize();
@@ -191,12 +228,7 @@
       _configureBlocklyBehavior() {
         this._setTeacherActions();
         this._setGameActions();
-
-        // Blockly's workspace is destroyed when toolbox changes, so it doesn't make sense to initialize it here.
-        if (!this.hasCustomToolbox()) {
-          this._initializeBlocklyWorkspace();
-        }
-
+        this._initializeNonCustomToolboxBlocklyWorkspace();
         this._registerLayoutChangedEvent();
       },
 
@@ -208,7 +240,34 @@
         $(window).resize(() => this._relocateTrash());
       },
 
+
+      /**
+       * Initializes a workspace using a custom toolbox.
+       *
+       * Blockly's workspace is destroyed when toolbox changes, so initialization
+       * is performed here
+       */
+      _initializeCustomToolboxBlocklyWorkspace(toolboxXml) {
+        this._getBlockly().toolbox = { defaultToolbox: toolboxXml };
+        this._initializeBlocklyWorkspace();
+      },
+
+      /**
+       * Initializes a workspace using a non-custom toolbox.
+       *
+       * Blockly's workspace is destroyed when toolbox changes,
+       * so this method will initialize it only if a there is a custom toolbox
+       * that will be called later.
+       */
+      _initializeNonCustomToolboxBlocklyWorkspace() {
+        if (!this.hasCustomToolbox()) {
+          this._initializeBlocklyWorkspace();
+        }
+      },
+
       _initializeBlocklyWorkspace() {
+        console.debug('Initializing Blockly Workspace');
+
         this._setInitialXml();
         this._initializeWorkspace();
         this._subscribeToWorkspace(() => this._updateSolution());
@@ -228,12 +287,18 @@
       },
 
       _updateSolution() {
+        console.debug("Updating solution");
         const blockly = this._getBlockly();
-
+        let changed;
         if (this.teacherMode) {
-          this._setExtraCode(blockly.workspaceXml);
+          changed = this._setExtraCode(blockly.workspaceXml);
         } else {
-          this._setStudentSolution(blockly.workspaceXml);
+          changed = this._setStudentSolution(blockly.workspaceXml);
+        }
+
+        if (!changed) {
+          console.debug("No solution update required")
+          return;
         }
 
         // TODO: this hack enables Angular two-way binding for Bibliotheca. Should be replaced with Mumuki events system
@@ -326,22 +391,44 @@
           return;
         }
 
-        const blockly = this._getBlockly();
+        console.debug("Set teacher actions");
         const actions = new Parser().getActionsFromSource(teacherCode);
-        blockly.primitiveProcedures = this._withDefaultIcons(actions, 'procedureDeclarations');
-        blockly.primitiveFunctions = this._withDefaultIcons(actions, 'functionDeclarations');
+
+        this._setPrimitiveProcedures(this._withDefaultIcons(actions, 'procedureDeclarations'));
+        this._setPrimitiveFunctions(this._withDefaultIcons(actions, 'functionDeclarations'));
       },
 
       _setGameActions() {
+        if (!this._isGame()) {
+          return;
+        }
+
+        console.debug("Set game actions");
         const blockly = this._getBlockly();
-        if (this._isGame()) {
-          blockly.primitiveProcedures = blockly.primitiveProcedures || [];
-          blockly.primitiveProcedures = blockly.primitiveProcedures.concat([
-            this._gamePrimitive('ShiftUp'),
-            this._gamePrimitive('ShiftDown'),
-            this._gamePrimitive('ShiftLeft'),
-            this._gamePrimitive('ShiftRight')
-          ]);
+
+        this._setPrimitiveProcedures((blockly.primitiveProcedures || []).concat([
+          this._gamePrimitive('ShiftUp'),
+          this._gamePrimitive('ShiftDown'),
+          this._gamePrimitive('ShiftLeft'),
+          this._gamePrimitive('ShiftRight')
+        ]));
+      },
+
+      _setPrimitiveProcedures(procedures) {
+        this._setBlocklyActions("primitiveProcedures", procedures);
+      },
+
+      _setPrimitiveFunctions(functions) {
+        this._setBlocklyActions("primitiveFunctions", functions);
+      },
+
+      _setBlocklyActions(key, actions) {
+        try {
+          this._getBlockly()[key] = actions
+        } catch (e) {
+          if (this._getBlockly()[key] !== actions) {
+            throw e;
+          }
         }
       },
 
@@ -362,8 +449,12 @@
        * to user content in laboratory, and default content in bibliotheca
        */
       _setStudentSolution(code) {
-        console.debug(`Setting student ${code}`)
-        this._getStudentEditor().value = code;
+        if (this._getStudentEditor().value !== code) {
+          console.debug(`Setting student ${code}`)
+          this._getStudentEditor().value = code;
+          return true;
+        }
+        return false;
       },
 
       _getDefaultCode() {
@@ -375,8 +466,12 @@
       },
 
       _setExtraCode(code) {
-        console.debug(`Setting extra ${code}`)
-        this._getEditorExtra().value = code;
+        if (this._getEditorExtra().value !== code) {
+          console.debug(`Setting extra ${code}`)
+          this._getEditorExtra().value = code;
+          return true;
+        }
+        return false;
       },
 
       _getEditorExtra: function() {
@@ -945,10 +1040,12 @@
       },
 
       _setEditorToolbox: function () {
-        const editor = $("mu-gobstones-custom-editor")[0];
-        $.get(this.toolboxUrl, function (toolboxXml) {
-          editor.setToolbox(toolboxXml);
-        });
+        const $editor = $("mu-gobstones-custom-editor")[0];
+
+        // there is no editor to configure
+        if (!$editor) return;
+
+        $editor.configureCustomToolboxFromUrl(this.toolboxUrl);
       }
     });
   </script>

data/lib/version_hook.rb

@@ -1,3 +1,3 @@
 module GobstonesVersionHook
-  VERSION = '2.8.5'
+  VERSION = '2.11.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mumuki-gobstones-runner
 version: !ruby/object:Gem::Version
-  version: 2.8.5
+  version: 2.11.0
 platform: ruby
 authors:
 - Rodrigo Alfonso
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-16 00:00:00.000000000 Z
+date: 2020-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gobstones-board
@@ -59,14 +59,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.36'
+        version: '2.37'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.36'
+        version: '2.37'
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -183,6 +183,7 @@ files:
 - lib/checker.rb
 - lib/expectations_hook.rb
 - lib/extensions/string.rb
+- lib/feedback_hook.rb
 - lib/game_framework/default.gbs.erb
 - lib/game_framework/default.xml.erb
 - lib/game_framework/extra.gbs.erb