mumukit 2.17.0 → 2.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b678748b9bbd865a42951a22eb71244968362faf551452fdfe4d0a9f14889fda
-  data.tar.gz: 42ea663c41b564d65222f11d7baa5b7447a2e49b053eb8579b4ec2d8ad814268
+  metadata.gz: aa9b52569d8acc92b3996ab2797748cb26b04c8b424eabe47c8ea1fcd8f554a0
+  data.tar.gz: 18a004a9b5ccf64c278952ac02ac3fc1f5942c3acbd06ed583c5623c8c422f49
 SHA512:
-  metadata.gz: bbb8f3d2905dc3b02b600efb96609bbfb888410228822d40ad55977e59aee51683d1842afb8faa5816b3c76a846639bd4de364f707bc0600d4817c8184b6f785
-  data.tar.gz: 0cfadb4c1dc8c55e3ed8b903c0d3d05c2217f56d39845bca17fcc97ac6888b8d5bfa7ca2c48f87f714849ed52a86302eb2893d3168b64c553d915bb975331ba5
+  metadata.gz: 7c403421b59fde8fb7a27ca8448d43a1331b86d590199278b5bf26f7ae76c165220ab67d97bf6eff63c8a082aa1b3de59ab51e1b90968dbf7056c2db36182603
+  data.tar.gz: a03dba8b04f49b4dfa4a0127db26021f47d6d9ca550ef8bd0ac30c2578c660ac990701622e887120293369c7c2efdebd290c87a2cf8c4b6763ab9abe2a7b44fb

data/lib/locales/en.yml

@@ -1,6 +1,6 @@
 en:
   mumukit:
-    memory_exceeded: Memory limit exceeded. Is your program trying to allocate to much memory?
+    memory_exceeded: Memory limit exceeded. Is your program trying to allocate too much memory?
     time_exceeded:  Execution time limit of %{limit}s exceeded. Is your program performing an infinite loop or recursion?
     masked_tempfile_basename: solution
     interactive:
@@ -8,6 +8,8 @@ en:
       check_last_query_fails: "query should fail but it passed"
       check_last_query_matches: "query does not match regex %{regex}"
       check_last_query_outputs: "query output should be '%{expected}' but was '%{actual}'"
+      check_last_query_includes: "query output should include '%{expected}' but was '%{actual}'"
+      check_last_query_like: "query output should be like '%{expected}' but was '%{actual}'"
       check_last_query_passes: "query should pass but it failed"
       check_query_fails: "query '%{query}' should fail but it passed"
       check_query_outputs: "query '%{query}' output should be '%{expected}' but was '%{actual}'"

data/lib/locales/es.yml

@@ -8,6 +8,8 @@ es:
       check_last_query_fails: "La consulta debería fallar pero pasó"
       check_last_query_matches: "La consulta no cumple con la expresión regular %{regex}"
       check_last_query_outputs: "La consulta debería devolver '%{expected}' pero devolvió '%{actual}'"
+      check_last_query_includes: "La consulta debería incluir '%{expected}' pero devolvió '%{actual}'"
+      check_last_query_like: "La consulta debería ser como '%{expected}' pero devolvió '%{actual}'"
       check_last_query_passes: "La consulta debería pasar pero falló"
       check_query_fails: "La consulta '%{query}' debería fallar pero pasó"
       check_query_outputs: "La consulta '%{query}' debería devolver '%{expected}' pero devolvió '%{actual}'"

data/lib/locales/pt.yml

@@ -0,0 +1,17 @@
+pt:
+  mumukit:
+    memory_exceeded: Limite de memoria excedido. ¿Tu programa está alocando demasiada memoria?
+    time_exceeded:  Limite de tempo de execução de %{limit}s excedido. O seu programa está executando um loop ou recursão infinito?
+    masked_tempfile_basename: solução
+    interactive:
+      check_last_query_equals: "a consulta deve ser '%{expected}' mas foi '%{actual}'"
+      check_last_query_fails: "a consulta deve falhar, mas passou"
+      check_last_query_matches: "A consulta não corresponde a regex %{regex}"
+      check_last_query_outputs: "O resultado da consulta deve ser '%{expected}', mas foi '%{actual}'"
+      check_last_query_includes: "O resultado da consulta deve incluir '%{expected}', mas foi '%{actual}'"
+      check_last_query_like: "O resultado da consulta deve ser como '%{expected}', mas foi '%{actual}'"
+      check_last_query_passes: "A consulta deve passar, mas falhou"
+      check_query_fails: "a consulta '%{query}' deve falhar, mas passou"
+      check_query_outputs: "a consulta '%{query}' deve ser '%{expected}', mas foi '%{actual}'"
+      check_query_passes: "a consulta '%{query}' deve passar, mas falhou"
+      goal_passed: "O objetivo foi alcançado com sucesso"

data/lib/mumukit/defaults/default_precompile_hook.rb

@@ -0,0 +1,5 @@
+class Mumukit::Defaults::PrecompileHook < Mumukit::Hook
+  def compile(request)
+    request
+  end
+end

data/lib/mumukit/defaults.rb

@@ -9,5 +9,6 @@ require_relative './defaults/default_query_hook'
 require_relative './defaults/default_feedback_hook'
 require_relative './defaults/default_validation_hook'
 require_relative './defaults/default_test_hook'
+require_relative './defaults/default_precompile_hook'
 require_relative './defaults/default_try_hook'
-require_relative './defaults/default_metadata_hook'
+require_relative './defaults/default_metadata_hook'

data/lib/mumukit/metatest/checker.rb

@@ -1,10 +1,39 @@
 module Mumukit::Metatest
   class Checker
-    def check(result, example)
-      example[:postconditions].each { |key, arg| check_assertion key, result, arg, example }
-      [example[:name], :passed, render_success_output(result)]
+
+    ## Check an input against a metatest example.
+    ## The example has the following shape:
+    ##
+    ## ```
+    ## {
+    ##   name: 'an example name',
+    ##   postconditions: {
+    ##     an_assertion: assertion_config,
+    ##     another_assertion: assertion_config,
+    ##   }
+    ## }
+    ## ```
+    ##
+    ## Alternatively, the `postconditions` key may be omitted:
+    ##
+    ## ```
+    ## {
+    ##   name: 'an example name',
+    ##   an_assertion: assertion_config,
+    ##   another_assertion: assertion_config,
+    ## }
+    ##
+    def check(input, example)
+      check_assertions input, postconditions_for(example), example
+      [example[:name], :passed, render_success_output(input)]
     rescue => e
-      [example[:name], :failed, render_error_output(result, e.message)]
+      [example[:name], :failed, render_error_output(input, e.message)]
+    end
+
+    ## If no postconditions are included in the example,
+    ## all the example except by the name is considered as postconditions
+    def postconditions_for(example)
+      example[:postconditions] || example.except(:name)
     end
 
     def render_success_output(value)
@@ -15,8 +44,14 @@ module Mumukit::Metatest
       error
     end
 
-    def check_assertion(key, result, arg, example)
-      send "check_#{key}", result, arg
+    def check_assertions(input, assertions_hash, example)
+      assertions_hash.each do |assertion_name, assertion_config|
+        check_assertion assertion_name, input, assertion_config, example
+      end
+    end
+
+    def check_assertion(assertion_name, input, assertion_config, _example)
+      send "check_#{assertion_name}", input, assertion_config
     end
 
     def fail(message)
@@ -31,4 +66,4 @@ module Mumukit::Metatest
       raise Mumukit::Metatest::Errored, message
     end
   end
-end
+end

data/lib/mumukit/metatest/interactive_checker.rb

@@ -6,42 +6,54 @@ module Mumukit::Metatest
     end
 
     def check_last_query_equals(_result, goal)
-      expected = goal[:query]
-      actual = @request.query
+      expected = goal[:value]
+      actual = @request.query.strip
       fail_t :check_last_query_equals, expected: expected, actual: actual unless expected == actual
     end
 
     def check_last_query_matches(_result, goal)
-      regex = goal[:regex]
+      regex = goal[:regexp]
       fail_t :check_last_query_matches, regex: regex.inspect unless regex.matches? @request.query
     end
 
     def check_last_query_fails(result, _goal)
-      fail_t :check_last_query_fails unless result[:query][:status] == :failed
+      fail_t :check_last_query_fails unless result[:query][:status].failed?
     end
 
     def check_last_query_outputs(result, goal)
-      expected = goal.with_indifferent_access[:output]
+      compare_last_query_by(:check_last_query_outputs, result, goal) { |expected, actual| expected == actual }
+    end
+
+    def check_last_query_output_includes(result, goal)
+      compare_last_query_by(:check_last_query_output_includes, result, goal) { |expected, actual| actual.include? expected }
+    end
+
+    def check_last_query_output_like(result, goal)
+      compare_last_query_by(:check_last_query_output_like, result, goal) { |expected, actual| normalize(expected) == normalize(actual) }
+    end
+
+    def compare_last_query_by(sym, result, goal, &condition)
+      expected = goal[:output]
       actual = result[:query][:result]
-      fail_t :check_last_query_outputs, expected: expected, actual: actual unless expected == actual
+      fail_t sym, expected: expected, actual: actual unless condition.call expected, actual
     end
 
     def check_last_query_passes(result, _goal)
-      fail_t :check_last_query_passes unless result[:query][:status] == :passed
+      fail_t :check_last_query_passes unless result[:query][:status].passed?
     end
 
     def check_query_passes(result, goal)
-      fail_t :check_query_passes, query: goal.with_indifferent_access[:query] unless result[:status] == :passed
+      fail_t :check_query_passes, query: goal[:query] unless result[:status].passed?
     end
 
     def check_query_fails(result, goal)
-      fail_t :check_query_fails, query: goal.with_indifferent_access[:query] unless result[:status] == :failed
+      fail_t :check_query_fails, query: goal[:query] unless result[:status].failed?
     end
 
     def check_query_outputs(result, goal)
-      expected = goal.with_indifferent_access[:output]
+      expected = goal[:output]
       actual = result[:goal]
-      fail_t :check_query_outputs, query: goal.with_indifferent_access[:query], expected: expected, actual: actual unless expected == actual
+      fail_t :check_query_outputs, query: goal[:query], expected: expected, actual: actual unless expected == actual
     end
 
     def render_success_output(_value)
@@ -55,5 +67,10 @@ module Mumukit::Metatest
     def locale(sym)
       'mumukit.interactive.' + sym.to_s
     end
+
+    def normalize(a_string)
+      a_string.delete(" \t\r\n").downcase
+    end
+
   end
 end

data/lib/mumukit/runner.rb

@@ -11,6 +11,12 @@ class Mumukit::Runner
     yield @config
   end
 
+  def reconfigure(&block)
+    @config = nil
+    @pipeline = nil
+    configure &block
+  end
+
   def configure_runtime(config)
     @runtime = Mumukit::Runtime.new(config)
   end
@@ -30,16 +36,29 @@ class Mumukit::Runner
   def new_directives_pipeline
     if config.preprocessor_enabled
       Mumukit::Directives::Pipeline.new(
-          [Mumukit::Directives::Sections.new,
-           Mumukit::Directives::Interpolations.new('test'),
-           Mumukit::Directives::Interpolations.new('extra'),
-           Mumukit::Directives::Flags.new],
+          [new_sections_directive,
+           new_interpolations_directive('test'),
+           new_interpolations_directive('extra'),
+           new_interpolations_directive('content'),
+           new_flags_directive],
           config.comment_type)
     else
       Mumukit::Directives::NullPipeline
     end
   end
 
+  def new_interpolations_directive(key)
+    Mumukit::Directives::Interpolations.new(key)
+  end
+
+  def new_sections_directive
+    Mumukit::Directives::Sections.new nest_sections: Mumukit.config.multifile
+  end
+
+  def new_flags_directive
+    Mumukit::Directives::Flags.new
+  end
+
   def self.default_config
     @default_config
   end
@@ -48,4 +67,4 @@ class Mumukit::Runner
     @default_config ||= OpenStruct.new
     yield @default_config
   end
-end
+end

data/lib/mumukit/runtime/info.rb

@@ -6,19 +6,22 @@ module Mumukit::RuntimeInfo
         escualo_base_version: ENV['ESCUALO_BASE_VERSION'],
         escualo_service_version: ENV['ESCUALO_SERVICE_VERSION'],
         mumukit_version: Mumukit::VERSION,
+        worker_image: Mumukit.config.docker_image,
         output_content_type: Mumukit.config.content_type,
         comment_type: Mumukit.config.comment_type,
         features: {
-            query: query_hook?,
-            try: try_hook?,
-            expectations: expectations_hook?,
-            feedback: feedback_hook?,
-            secure: validation_hook?,
-            stateful: Mumukit.config.stateful,
-            preprocessor: Mumukit.config.preprocessor_enabled,
+          precompile: precompile_hook?,
+          query: query_hook?,
+          try: try_hook?,
+          expectations: expectations_hook?,
+          feedback: feedback_hook?,
+          secure: validation_hook?,
+          stateful: Mumukit.config.stateful,
+          multifile: Mumukit.config.multifile,
+          preprocessor: Mumukit.config.preprocessor_enabled,
 
-            sandboxed: any_hook_include?([:test, :query], Mumukit::Templates::WithIsolatedEnvironment),
-            structured: any_hook_include?([:test], Mumukit::Templates::WithStructuredResults) || Mumukit.config.structured
+          sandboxed: any_hook_include?([:test, :query], Mumukit::Templates::WithIsolatedEnvironment),
+          structured: any_hook_include?([:test], Mumukit::Templates::WithStructuredResults) || Mumukit.config.structured
         }
     }
   end
@@ -28,4 +31,4 @@ module Mumukit::RuntimeInfo
   def any_hook_include?(hooks, mixin)
     hooks.any? { |it| hook_includes?(it, mixin) }
   end
-end
+end

data/lib/mumukit/server/app.rb

@@ -6,7 +6,7 @@ require 'json'
 class Mumukit::Server::App < Sinatra::Base
   configure do
     set :mumuki_url, 'http://mumuki.io'
-    set :show_exceptions, :after_handler
+    set :show_exceptions, false
     enable :logging
   end
 
@@ -65,11 +65,8 @@ class Mumukit::Server::App < Sinatra::Base
 
   error StandardError do
     content_type :json
-    status 200
-
+    status 500
     message = Mumukit::ContentType::Plain.format_exception env['sinatra.error']
-    logger.error "Unhandled error #{message}"
-
-    {status: :errored, exit: message}.to_json
+    {exit: :errored, out: message}.to_json
   end
 end

data/lib/mumukit/server/test_server.rb

@@ -10,7 +10,10 @@ class Mumukit::Server::TestServer
   end
 
   def info(url)
-    runtime.info.merge(runtime.metadata_hook.metadata).merge(url: url)
+    runtime.info
+        .merge(repo_url: default_repo_url)
+        .merge(runtime.metadata_hook.metadata)
+        .merge(url: url)
   end
 
   def start_request!(_request)
@@ -58,13 +61,13 @@ class Mumukit::Server::TestServer
   end
 
   def run_tests!(request)
-    return ['', :passed] if request.test.blank?
+    return ['', :passed] if should_skip_tests?(request.test)
 
     compile_and_run runtime.test_hook, request
   end
 
   def run_expectations!(request)
-    return [] if request.expectations.nil? || request.content.nil?
+    return [] if should_skip_expectations?(request)
 
     compile_and_run runtime.expectations_hook, request
   end
@@ -91,19 +94,30 @@ class Mumukit::Server::TestServer
   end
 
   def preprocess(request)
-    Mumukit.directives_pipeline.transform(request)
+    runtime.precompile_hook.compile Mumukit.directives_pipeline.transform(request)
   end
 
   def validate_request!(request)
     runtime.validation_hook.validate! request
   end
 
+  def should_skip_expectations?(request)
+    request.expectations.nil? || (request.content.nil? && !Mumukit.config.process_expectations_on_empty_content)
+  end
+
+  def should_skip_tests?(tests)
+    tests.blank? && !Mumukit.config.run_test_hook_on_empty_test
+  end
+
   def respond_to(request)
     yield preprocess request.tap { |r| validate_request! r }
   rescue Mumukit::RequestValidationError => e
     {exit: :aborted, out: e.message}
-  rescue Exception => e
+  rescue => e
     {exit: :errored, out: content_type.format_exception(e)}
   end
 
+  def default_repo_url
+    "https://github.com/mumuki/mumuki-#{Mumukit.runner_name}-runner"
+  end
 end

data/lib/mumukit/templates/expectations_hook.rb

@@ -0,0 +1,81 @@
+require 'mumukit/inspection'
+
+module Mumukit
+  class Templates::ExpectationsHook < Mumukit::Hook
+    SOURCE_EXPECTATION_EVALUATORS = {
+      'SourceRepeats' => lambda { |source, target| source.scan(target).count > 1 },
+      'SourceContains' => lambda { |source, target| source.include? target },
+      'SourceEquals' => lambda { |source, target| source == target },
+      'SourceEqualsIgnoreSpaces' => lambda { |source, target| source.delete(' ') == target.delete(' ') }
+    }
+    SOURCE_EXPECTATIONS = SOURCE_EXPECTATION_EVALUATORS.keys.flat_map { |it| [it, "Not:#{it}"] }
+
+    def compile(request)
+      { request: request, expectations: compile_expectations(request) }
+    end
+
+    def run!(spec)
+      spec[:expectations][:source].map { |it| it.evaluate spec[:request][:content] }
+    end
+
+    private
+
+    def compile_expectations(request)
+      expectations = {ast: [], source: [], exceptions: []}
+      request[:expectations].each do |it|
+        fill_expectations it.deep_symbolize_keys, expectations
+      end
+      expectations
+    end
+
+    def fill_expectations(expectation, expectations)
+      inspection = expectation[:inspection]
+      if inspection&.start_with? 'Except:'
+        expectations[:exceptions] << inspection[7..-1]
+      elsif SOURCE_EXPECTATIONS.any? { |it| inspection.starts_with? it  }
+        expectations[:source] << compile_source_expectation(expectation)
+      else
+        expectations[:ast] << compile_expectation(expectation)
+      end
+    end
+
+    def compile_expectation(expectation)
+      Mumukit::Inspection::Expectation.parse(expectation).as_v2.to_h
+    end
+
+    def compile_source_expectation(expectation)
+      SourceExpectation.parse(expectation)
+    end
+
+    class SourceExpectation
+      def initialize(expectation, evaluator)
+        @expectation = expectation
+        @evaluator = evaluator
+      end
+
+      def evaluate(content)
+        { result: evaluate_inspection(content), expectation: @expectation.to_h }
+      end
+
+      def inspection
+        @expectation.inspection
+      end
+
+      def self.parse(expectation)
+        parsed = Mumukit::Inspection::Expectation.parse(expectation)
+        evaluator = parse_evaluator(parsed.inspection)
+        new parsed, evaluator
+      end
+
+      private
+
+      def evaluate_inspection(content)
+        inspection.negated? ^ @evaluator.call(content, inspection.target.value)
+      end
+
+      def self.parse_evaluator(inspection)
+        SOURCE_EXPECTATION_EVALUATORS[inspection.type]
+      end
+    end
+  end
+end

data/lib/mumukit/templates/file_hook.rb

@@ -4,7 +4,6 @@ module Mumukit
 
     attr_accessor :request
 
-
     def compile(request)
       self.request = request
       write_tempfile! compile_file_content(request)

data/lib/mumukit/templates/mulang_expectations_hook.rb

@@ -1,29 +1,31 @@
-require 'mumukit/inspection'
 require 'mulang'
 
 module Mumukit
-  class Templates::MulangExpectationsHook < Mumukit::Hook
+  class Templates::MulangExpectationsHook < Mumukit::Templates::ExpectationsHook
     LOGIC_SMELLS = %w(UsesCut UsesFail UsesUnificationOperator HasRedundantReduction)
     FUNCTIONAL_SMELLS = %w(HasRedundantParameter HasRedundantGuards)
     OBJECT_ORIENTED_SMELLS = %w(DoesNullTest ReturnsNull)
     IMPERATIVE_SMELLS = %w(HasRedundantLocalVariableReturn HasAssignmentReturn)
     EXPRESSIVENESS_SMELLS = %w(HasTooShortBindings HasWrongCaseBindings HasMisspelledBindings)
-    GENERIC_SMELLS = %w(IsLongCode HasCodeDuplication HasRedundantLambda HasRedundantIf DoesTypeTest HasRedundantBooleanComparison)
+    GENERIC_SMELLS = %w(IsLongCode HasCodeDuplication HasRedundantLambda HasRedundantIf DoesTypeTest HasRedundantBooleanComparison HasEmptyIfBranches)
 
     required :language, 'You have to provide a Mulang-compatible language in order to use this hook'
 
-    def compile(request)
-      expectations, exceptions = compile_expectations_and_exceptions request
+    def run!(spec)
+      super(spec) + run_mulang_analysis(compile_mulang_analysis(spec[:request], spec[:expectations]))
+    end
+
+    def compile_mulang_analysis(request, expectations)
       mulang_code(request).analysis(
-        expectations: expectations,
+        expectations: expectations[:ast],
         smellsSet: {
           tag: 'AllSmells',
-          exclude: (exceptions + default_smell_exceptions)
+          exclude: (expectations[:exceptions] + default_smell_exceptions)
         },
         domainLanguage: domain_language)
     end
 
-    def run!(analysis)
+    def run_mulang_analysis(analysis)
       parse_response Mulang.analyse(analysis)
     rescue JSON::ParserError
       raise Mumukit::CompilationError, "Can not handle mulang results for analysis #{analysis}"
@@ -50,32 +52,10 @@ module Mumukit
       language == 'Mulang' ? Mulang::Language::External.new :  Mulang::Language::Native.new(language)
     end
 
-    def compile_expectations_and_exceptions(request)
-      expectations = []
-      exceptions = []
-      request[:expectations].each do |it|
-        fill_expectations_and_excetions it.deep_symbolize_keys, expectations, exceptions
-      end
-      [expectations, exceptions]
-    end
-
-    def fill_expectations_and_excetions(expectation, expectations, exceptions)
-      inspection = expectation[:inspection]
-      if inspection&.start_with? 'Except:'
-        exceptions << inspection[7..-1]
-      else
-        expectations << compile_expectation(expectation)
-      end
-    end
-
     def compile_content(content)
       content
     end
 
-    def compile_expectation(expectation)
-      Mumukit::Inspection::Expectation.parse(expectation).as_v2.to_h
-    end
-
     def parse_response(response)
       if response['tag'] == 'AnalysisFailed'
         raise Mumukit::CompilationError, response['reason']

data/lib/mumukit/templates/multi_file_precompile_hook.rb

@@ -0,0 +1,49 @@
+module Mumukit
+  class Templates::MultiFilePrecompileHook < Mumukit::Hook
+    include Mumukit::Templates::WithMultipleFiles
+
+    def compile(request)
+      request
+        .to_h
+        .merge(content: files_content(request))
+        .to_struct
+    end
+
+    def main_file
+      raise NotImplementedError
+    end
+
+    def consolidate(main_content, files)
+      raise NotImplementedError
+    end
+
+    private
+
+    def files_content(request)
+      files = files_of request
+      if files.empty?
+        no_files_content request
+      elsif files.count == 1
+        single_file_content files
+      else
+        multi_file_content files
+      end
+    end
+
+    def no_files_content(request)
+      request.content
+    end
+
+    def single_file_content(files)
+      files.values.first
+    end
+
+    def multi_file_content(files)
+      consolidate main_file_content(files), files
+    end
+
+    def main_file_content(files)
+      files[main_file] || ''
+    end
+  end
+end

data/lib/mumukit/templates/try_hook.rb

@@ -1,7 +1,9 @@
 module Mumukit
   class Templates::TryHook < Templates::FileHook
     def compile(request)
-      @goal = {postconditions: [[request.goal.with_indifferent_access[:kind], request.goal]]}
+      request_goal = request.goal.with_indifferent_access
+
+      @goal = {postconditions: [[request_goal[:kind], request_goal]]}
       @checker = Metatest::InteractiveChecker.new request
       super request
     end

data/lib/mumukit/templates/with_multiple_files.rb

@@ -0,0 +1,6 @@
+module Mumukit::Templates::WithMultipleFiles
+  def files_of(request)
+    raise 'You need to enable Mumukit.config.multifile first!' unless Mumukit.config.multifile
+    request.content.is_a?(Hash) ? request.content : {}
+  end
+end

data/lib/mumukit/templates.rb

@@ -3,8 +3,6 @@ module Mumukit
   end
 end
 
-require_relative './templates/file_hook'
-require_relative './templates/try_hook'
 require_relative './templates/with_structured_results'
 require_relative './templates/with_metatest'
 require_relative './templates/with_metatest_results'
@@ -12,6 +10,12 @@ require_relative './templates/with_mashup_file_content'
 require_relative './templates/with_embedded_environment'
 require_relative './templates/with_isolated_environment'
 require_relative './templates/with_line_number_offset'
-require_relative './templates/mulang_expectations_hook'
+require_relative './templates/with_multiple_files'
 require_relative './templates/with_code_smells'
 require_relative './templates/with_cookie'
+
+require_relative './templates/file_hook'
+require_relative './templates/try_hook'
+require_relative './templates/expectations_hook'
+require_relative './templates/mulang_expectations_hook'
+require_relative './templates/multi_file_precompile_hook'

data/lib/mumukit/version.rb

@@ -1,3 +1,3 @@
 module Mumukit
-  VERSION = '2.17.0'
+  VERSION = '2.27.0'
 end

data/lib/mumukit.rb

@@ -22,12 +22,16 @@ module Mumukit
     current_runner.name
   end
 
+  def self.runner_url
+    Rack::Request.new(Mumukit::Env.env).base_url
+  end
+
   def self.configure_defaults(&block)
     Mumukit::Runner.configure_defaults(&block)
   end
 
   class << self
-    delegate :prefix, :config, :configure, :runtime, :configure_runtime, :directives_pipeline, to: :current_runner
+    delegate :prefix, :config, :configure, :reconfigure, :runtime, :configure_runtime, :directives_pipeline, to: :current_runner
   end
 end
 
@@ -42,6 +46,9 @@ Mumukit.configure_defaults do |config|
   config.stateful = false
   config.command_time_limit = 4
   config.command_size_limit = 1024
+  config.process_expectations_on_empty_content = false
+  config.run_test_hook_on_empty_test = false
+  config.multifile = false
 end
 
 require 'mumukit/content_type'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mumukit
 version: !ruby/object:Gem::Version
-  version: 2.17.0
+  version: 2.27.0
 platform: ruby
 authors:
 - Franco Leonardo Bulgarelli
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-16 00:00:00.000000000 Z
+date: 2018-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sinatra
   requirement: !ruby/object:Gem::Requirement
@@ -170,14 +184,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: mumukit-inspection
   requirement: !ruby/object:Gem::Requirement
@@ -196,36 +210,30 @@ dependencies:
   name: mumukit-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.2'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.2'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: mumukit-directives
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: mumukit-content-type
   requirement: !ruby/object:Gem::Requirement
@@ -256,6 +264,7 @@ files:
 - bin/limit
 - lib/locales/en.yml
 - lib/locales/es.yml
+- lib/locales/pt.yml
 - lib/mumukit.rb
 - lib/mumukit/compilation_error.rb
 - lib/mumukit/cookie.rb
@@ -263,6 +272,7 @@ files:
 - lib/mumukit/defaults/default_expectations_hook.rb
 - lib/mumukit/defaults/default_feedback_hook.rb
 - lib/mumukit/defaults/default_metadata_hook.rb
+- lib/mumukit/defaults/default_precompile_hook.rb
 - lib/mumukit/defaults/default_query_hook.rb
 - lib/mumukit/defaults/default_test_hook.rb
 - lib/mumukit/defaults/default_try_hook.rb
@@ -291,8 +301,10 @@ files:
 - lib/mumukit/server/test_pipeline.rb
 - lib/mumukit/server/test_server.rb
 - lib/mumukit/templates.rb
+- lib/mumukit/templates/expectations_hook.rb
 - lib/mumukit/templates/file_hook.rb
 - lib/mumukit/templates/mulang_expectations_hook.rb
+- lib/mumukit/templates/multi_file_precompile_hook.rb
 - lib/mumukit/templates/try_hook.rb
 - lib/mumukit/templates/with_code_smells.rb
 - lib/mumukit/templates/with_cookie.rb
@@ -302,6 +314,7 @@ files:
 - lib/mumukit/templates/with_mashup_file_content.rb
 - lib/mumukit/templates/with_metatest.rb
 - lib/mumukit/templates/with_metatest_results.rb
+- lib/mumukit/templates/with_multiple_files.rb
 - lib/mumukit/templates/with_structured_results.rb
 - lib/mumukit/version.rb
 - lib/mumukit/with_command_line.rb
@@ -328,7 +341,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.2
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Mumuki Test Server Development Kit