mumuki-gobstones-runner 2.10.0 → 2.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abbf0ec6c1d486eadb06f71d4d479a520700c79376ab9d1e785a8fc658485624
-  data.tar.gz: 60dc12c4d5e60614a94987ae2c725892cb6e06065aefd673952cf0f73880ce06
+  metadata.gz: 7ba04506c9ef79dfcf3e5c4a080e1f147c87134f939afe70aa5f54e515640c51
+  data.tar.gz: 4fa2cae67f9e144499c8acc8eff28b3af3a4176a47df91b49085b2f3a9901d34
 SHA512:
-  metadata.gz: f253ffce6bfffc3aa0af02995cd3739df9a1ccb2122c6c7fbdb70883b3cb7da9ef6078372a1aa141fe62561491c929450fe2e9ba30fe7d8dad5561abc57f6c55
-  data.tar.gz: d7227916c7b0e94173319e8753364ceec1818a07aa10f70e155735549872c6541cf7065235be16f0d43aece40df847c3a5ee1842e20c33fa205161fafa0b23d0
+  metadata.gz: fd96ca8f78913c83581b165f73cf2f31b84b307c0dd7db599c2852aa9c794c7593b851595dd91aeadb0cbe9f515d4f93ca76c18c80db1f6444ae89aa8e40b396
+  data.tar.gz: dd57c527fe5915e0f2218dd3b152e850cb6a6c9a256877d16ccd252da48d8603b665bbfe1b5a459d66c9ed9b45a49751264f22f20f76bbcbc39aa14db8bb4cb7

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/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_before_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 <code>%{color}</code>. Did you mean <code>%{rectified_color}</code>?'
   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_before_procedure: "Looks like you're missing a <code>}</code> before 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 <code>%{color}</code>. ¿Quisiste referirte al color <code>%{rectified_color}</code>?'
   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_before_procedure: 'Parece que te falta una <code>}</code> antes de 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 <code>%{color}</code>. Você quis se referir à cor <code>%{rectified_color}</code>?'
   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_before_procedure: 'Parece que está faltando um <code>}</code> antes de 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

@@ -133,3 +133,7 @@
     border: 1px solid #6D6E70 !important;
     border-radius: 4px;
 }
+
+.mu-kids-exercise.mu-kindergarten .blocklyBubbleCanvas {
+  display: none;
+}

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

@@ -9,6 +9,11 @@
   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);
     }
@@ -211,10 +216,7 @@
         this._setBlocklyDisplayMode();
         this._setBlocklySounds();
         this._setBlocklyColors();
-
-        if (!this.readOnly) {
-          this._relocateTrashOnResize();
-        }
+        this._relocateTrashOnResize();
 
         // Removing "/" from the block id character set to avoid syntax errors
         Blockly.utils.genUid.soup_ = Blockly.utils.genUid.soup_.replace("/", "");
@@ -228,11 +230,16 @@
       },
 
       _relocateTrashOnResize() {
+        if (this.readOnly) {
+          console.debug("No trash relocate on resize required");
+          return;
+        }
+
         $('.mu-kids-context, .mu-kids-results').on('hidden.bs.modal shown.bs.modal', () => {
           this._relocateTrash();
         });
 
-        $(window).resize(() => this._relocateTrash());
+        $(window).resize(() => setTimeout(this._relocateTrash));
       },
 
 
@@ -241,6 +248,8 @@
        *
        * Blockly's workspace is destroyed when toolbox changes, so initialization
        * is performed here
+
+       * @see _initializeBlocklyWorkspace
        */
       _initializeCustomToolboxBlocklyWorkspace(toolboxXml) {
         this._getBlockly().toolbox = { defaultToolbox: toolboxXml };
@@ -253,6 +262,8 @@
        * 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.
+       *
+       * @see _initializeBlocklyWorkspace
        */
       _initializeNonCustomToolboxBlocklyWorkspace() {
         if (!this.hasCustomToolbox()) {
@@ -260,11 +271,20 @@
         }
       },
 
+      /**
+       * Performs actual workspace (re)creation,
+       * which sets initial xml, user solution, trash position
+       * and appropriate callbacks.
+       *
+       * This method is the actual culmination of the blockly initialization
+       * process
+       */
       _initializeBlocklyWorkspace() {
         console.debug('Initializing Blockly Workspace');
 
         this._setInitialXml();
         this._initializeWorkspace();
+        this._relocateTrash();
         this._subscribeToWorkspace(() => this._updateSolution());
 
         if (this.hasInteractiveProgram()) {
@@ -275,19 +295,32 @@
       },
 
       _relocateTrash() {
-        const width = $('#blocklyDiv').width() - 68;
-        const height = $('#blocklyDiv').height() - 210;
-        $('.blocklyTrash').css("transform", `translate(${width}px, ${height}px)`);
-        $('.blocklyTrash').css("display", "unset");
+        if (this.readOnly) {
+          console.debug("No trash relocate required");
+          return;
+        }
+
+        const $blocklyTrash = $('.blocklyTrash');
+        const $blocklyDiv = $('#blocklyDiv');
+        const width = $blocklyDiv.width() - 68;
+        const height = $blocklyDiv.height() - 210;
+        $blocklyTrash.css("transform", `translate(${width}px, ${height}px)`);
+        $blocklyTrash.css("display", "unset");
       },
 
       _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
@@ -380,22 +413,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;
+          }
         }
       },
 
@@ -416,8 +471,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() {
@@ -429,8 +488,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() {

data/lib/render/layout/layout.html

@@ -16,6 +16,7 @@
       _setAttire: function () {
         $.getJSON(this.attireUrl, function (attire) {
           GobstonesBoard && GobstonesBoard.setDefaultAttire(attire);
+          attire.rules.forEach((rule) => $.get(rule.image));
         });
       }
     });

data/lib/version_hook.rb

@@ -1,3 +1,3 @@
 module GobstonesVersionHook
-  VERSION = '2.10.0'
+  VERSION = '2.13.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mumuki-gobstones-runner
 version: !ruby/object:Gem::Version
-  version: 2.10.0
+  version: 2.13.0
 platform: ruby
 authors:
 - Rodrigo Alfonso
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-06 00:00:00.000000000 Z
+date: 2020-12-02 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
@@ -275,7 +276,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Gobstones Runner for Mumuki