mumukit 2.4.0 → 2.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3f8afb7358f144c2e25c356c70f0061144ff2f04
-  data.tar.gz: d41e834b6c92fea4897c87d46f5d3303983a8209
+SHA256:
+  metadata.gz: b678748b9bbd865a42951a22eb71244968362faf551452fdfe4d0a9f14889fda
+  data.tar.gz: 42ea663c41b564d65222f11d7baa5b7447a2e49b053eb8579b4ec2d8ad814268
 SHA512:
-  metadata.gz: b4830f051f2f4ede2c1a76f05306974ea4c8d05947b2a0b8e4d2f7c3b3ad5dbb32207045accb30c10815bd90dd2e6ccc8a9e982a947e48c0fd17df2582b67e63
-  data.tar.gz: d1c908995f05aeab6cd7bc6a47c4614a20ec242cb3e49fee4497060c03ebc87a3636578652a3fb3716016543861405db1c7a4cd94335772303ed5cc30a06d30a
+  metadata.gz: bbb8f3d2905dc3b02b600efb96609bbfb888410228822d40ad55977e59aee51683d1842afb8faa5816b3c76a846639bd4de364f707bc0600d4817c8184b6f785
+  data.tar.gz: 0cfadb4c1dc8c55e3ed8b903c0d3d05c2217f56d39845bca17fcc97ac6888b8d5bfa7ca2c48f87f714849ed52a86302eb2893d3168b64c553d915bb975331ba5

data/lib/locales/en.yml

@@ -2,3 +2,14 @@ en:
   mumukit:
     memory_exceeded: Memory limit exceeded. Is your program trying to allocate to 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:
+      check_last_query_equals: "query should be '%{expected}' but was '%{actual}'"
+      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_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}'"
+      check_query_passes: "query '%{query}' should pass but it failed"
+      goal_passed: "goal was met successfully"

data/lib/locales/es.yml

@@ -2,3 +2,14 @@ es:
   mumukit:
     memory_exceeded: Limite de memoria excedido. ¿Tu programa está alocando demasiada memoria?
     time_exceeded:  Limite de tiempo de ejecución de %{limit}s excedido. ¿Tu programa tiene recursión o bucle infinito?
+    masked_tempfile_basename: solucion
+    interactive:
+      check_last_query_equals: "La consulta debería ser '%{expected}' pero fue '%{actual}'"
+      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_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}'"
+      check_query_passes: "La consulta '%{query}' debería pasar pero falló"
+      goal_passed: "El objetivo se cumplió exitosamente"

data/lib/mumukit/compilation_error.rb

@@ -0,0 +1,4 @@
+module Mumukit
+  class CompilationError < StandardError
+  end
+end

data/lib/mumukit/cookie.rb

@@ -0,0 +1,19 @@
+class Mumukit::Cookie
+  attr_accessor :statements
+
+  def initialize(statements)
+    @statements = statements || []
+  end
+
+  def code
+    "#{statements_code}\n#{stdout_separator_code}\n"
+  end
+
+  def trim(output)
+    output.split("#{stdout_separator}\n")[1]
+  end
+
+  def stdout_separator
+    '!!!!MUMUKI-COOKIE-STDOUT-SEPARATOR-END!!!!'
+  end
+end

data/lib/mumukit/defaults/default_try_hook.rb

@@ -0,0 +1,9 @@
+class Mumukit::Defaults::TryHook < Mumukit::Hook
+  def compile(request)
+    request
+  end
+
+  def run!(compilation)
+    ['unimplemented', :aborted, {result: 'unimplemented', status: :aborted}]
+  end
+end

data/lib/mumukit/defaults/default_version_hook.rb

@@ -0,0 +1,3 @@
+class Mumukit::Defaults::VersionHook
+  VERSION = File.read('version') rescue 'master'
+end

data/lib/mumukit/defaults.rb

@@ -3,9 +3,11 @@ module Mumukit
   end
 end
 
+require_relative './defaults/default_version_hook'
 require_relative './defaults/default_expectations_hook'
 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_try_hook'
 require_relative './defaults/default_metadata_hook'

data/lib/mumukit/explainer.rb

@@ -0,0 +1,23 @@
+class Mumukit::Explainer
+  def explain(content, test_results)
+    explain_methods
+        .map { |selector, key| eval_explain(selector, key, content, test_results) }
+        .compact
+        .map { |explain| I18n.t(explain[:key], explain[:binding]) }
+        .map { |it| "* #{it}" }
+        .join("\n")
+  end
+
+  def eval_explain(selector, key, content, test_results)
+    send(selector, content, test_results).try do |it|
+      {key: key, binding: it}
+    end
+  end
+
+  def explain_methods
+    self.class
+        .instance_methods(false)
+        .flat_map { |it| it.to_s.captures(/explain_(.*)/).map { [it, $1] } }
+        .compact
+  end
+end

data/lib/mumukit/hook.rb

@@ -27,4 +27,11 @@ class Mumukit::Hook
   def should_forward_to_config?(args, name)
     args.length == 0 && !block_given? && @config[name]
   end
+
+  def self.stateful_through(cookie_clazz)
+    include Mumukit::Templates::WithCookie
+    define_method :cookie_class do
+      cookie_clazz
+    end
+  end
 end

data/lib/mumukit/isolated_environment.rb

@@ -16,21 +16,22 @@ module Mumukit
 
       command = yield(*filenames).split
 
+      configure_container! command, binds, volumes
+    end
+
+    def configure_container!(command, binds, volumes)
       self.container = Docker::Container.create(
-          'Image' => Mumukit.config.docker_image,
-          'Cmd' => command,
-          'NetworkDisabled' => true,
-          'HostConfig' => {
-              'Binds' => binds},
-          'Volumes' => volumes)
+        'Image' => Mumukit.config.docker_image,
+        'Cmd' => command,
+        'NetworkDisabled' => true,
+        'HostConfig' => {
+            'Binds' => binds},
+        'Volumes' => volumes)
     end
 
     def run!
-      container.start
-      container.wait(Mumukit.config.command_time_limit)
-
-      exit = container.json['State']['ExitCode']
-      out = container.streaming_logs(stdout: true, stderr: true)
+      run_container!
+      exit, out = fetch_container_state!
 
       if exit == 0
         [out, :passed]
@@ -41,6 +42,17 @@ module Mumukit
       [I18n.t('mumukit.time_exceeded', limit: Mumukit.config.command_time_limit), :aborted]
     end
 
+    def run_container!
+      container.start
+      container.wait(Mumukit.config.command_time_limit)
+    end
+
+    def fetch_container_state!
+      exit = container.json['State']['ExitCode']
+      out = container.streaming_logs(stdout: true, stderr: true)
+      [exit, out]
+    end
+
     def destroy!
       if container
         container.stop
@@ -48,4 +60,4 @@ module Mumukit
       end
     end
   end
-end
+end

data/lib/mumukit/metatest/checker.rb

@@ -1,10 +1,10 @@
 module Mumukit::Metatest
   class Checker
-    def check(value, example)
-      example[:postconditions].each { |key, arg| check_assertion key, value, arg, example }
-      [example[:name], :passed, render_success_output(value)]
+    def check(result, example)
+      example[:postconditions].each { |key, arg| check_assertion key, result, arg, example }
+      [example[:name], :passed, render_success_output(result)]
     rescue => e
-      [example[:name], :failed, render_error_output(value, e.message)]
+      [example[:name], :failed, render_error_output(result, e.message)]
     end
 
     def render_success_output(value)
@@ -15,8 +15,8 @@ module Mumukit::Metatest
       error
     end
 
-    def check_assertion(key, value, arg, example)
-      send "check_#{key}", value, arg
+    def check_assertion(key, result, arg, example)
+      send "check_#{key}", result, arg
     end
 
     def fail(message)

data/lib/mumukit/metatest/interactive_checker.rb

@@ -0,0 +1,59 @@
+module Mumukit::Metatest
+  class InteractiveChecker < Checker
+
+    def initialize(request)
+      @request = request
+    end
+
+    def check_last_query_equals(_result, goal)
+      expected = goal[:query]
+      actual = @request.query
+      fail_t :check_last_query_equals, expected: expected, actual: actual unless expected == actual
+    end
+
+    def check_last_query_matches(_result, goal)
+      regex = goal[:regex]
+      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
+    end
+
+    def check_last_query_outputs(result, goal)
+      expected = goal.with_indifferent_access[:output]
+      actual = result[:query][:result]
+      fail_t :check_last_query_outputs, expected: expected, actual: actual unless expected == actual
+    end
+
+    def check_last_query_passes(result, _goal)
+      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
+    end
+
+    def check_query_fails(result, goal)
+      fail_t :check_query_fails, query: goal.with_indifferent_access[:query] unless result[:status] == :failed
+    end
+
+    def check_query_outputs(result, goal)
+      expected = goal.with_indifferent_access[:output]
+      actual = result[:goal]
+      fail_t :check_query_outputs, query: goal.with_indifferent_access[:query], expected: expected, actual: actual unless expected == actual
+    end
+
+    def render_success_output(_value)
+      I18n.t locale(:goal_passed)
+    end
+
+    def fail_t(sym, *args)
+      fail I18n.t locale(sym), *args
+    end
+
+    def locale(sym)
+      'mumukit.interactive.' + sym.to_s
+    end
+  end
+end

data/lib/mumukit/metatest.rb

@@ -3,5 +3,6 @@ end
 
 require_relative './metatest/errors'
 require_relative './metatest/checker'
+require_relative './metatest/interactive_checker'
 require_relative './metatest/framework'
 require_relative './metatest/identity_runner'

data/lib/mumukit/runner.rb

@@ -1,3 +1,4 @@
+
 class Mumukit::Runner
   attr_reader :name, :runtime
 
@@ -22,6 +23,23 @@ class Mumukit::Runner
     name.camelize
   end
 
+  def directives_pipeline
+    @pipeline ||= new_directives_pipeline
+  end
+
+  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],
+          config.comment_type)
+    else
+      Mumukit::Directives::NullPipeline
+    end
+  end
+
   def self.default_config
     @default_config
   end

data/lib/mumukit/runtime/info.rb

@@ -2,7 +2,7 @@ module Mumukit::RuntimeInfo
   def info
     {
         name: Mumukit.runner_name,
-        version: (File.read('version') rescue 'master'),
+        version: hook_class(:version)::VERSION,
         escualo_base_version: ENV['ESCUALO_BASE_VERSION'],
         escualo_service_version: ENV['ESCUALO_SERVICE_VERSION'],
         mumukit_version: Mumukit::VERSION,
@@ -10,6 +10,7 @@ module Mumukit::RuntimeInfo
         comment_type: Mumukit.config.comment_type,
         features: {
             query: query_hook?,
+            try: try_hook?,
             expectations: expectations_hook?,
             feedback: feedback_hook?,
             secure: validation_hook?,

data/lib/mumukit/runtime/runtime.rb

@@ -7,6 +7,10 @@ class Mumukit::Runtime
     @hook_classes = {}
   end
 
+  def reset!
+    @hook_classes = {}
+  end
+
   def hook_defined?(hook_name)
     hook_name.to_default_mumukit_hook_class rescue raise "Wrong hook #{hook_name}"
 
@@ -21,8 +25,6 @@ class Mumukit::Runtime
     hook_class(hook_name).new(@config)
   end
 
-  private
-
   def hook_class(hook_name)
     @hook_classes[hook_name] ||=
         if hook_defined? hook_name

data/lib/mumukit/runtime/symbol.rb

@@ -8,10 +8,10 @@ class Symbol
   end
 
   def to_mumukit_hook_class
-    Kernel.const_get to_mumukit_hook_class_name
+    to_mumukit_hook_class_name.constantize
   end
 
   def to_default_mumukit_hook_class
-    Kernel.const_get "Mumukit::Defaults::#{to_simple_mumukit_hook_class_name}"
+    "Mumukit::Defaults::#{to_simple_mumukit_hook_class_name}".constantize
   end
 end

data/lib/mumukit/server/app.rb

@@ -55,6 +55,10 @@ class Mumukit::Server::App < Sinatra::Base
     JSON.generate(server.query!(parse_request))
   end
 
+  post '/try' do
+    JSON.generate(server.try!(parse_request))
+  end
+
   get '/*' do
     redirect settings.mumuki_url
   end

data/lib/mumukit/server/response_builder.rb

@@ -12,6 +12,10 @@ class Mumukit::Server::ResponseBuilder
     @response.merge!(expectationResults: r) if r.present?
   end
 
+  def add_try_results(r)
+    @response = unstructured_base_response(r)
+    @response.merge!(queryResult: r[2])
+  end
 
   def add_feedback(f)
     @response.merge!(feedback: f) if f.present?

data/lib/mumukit/server/test_pipeline.rb

@@ -0,0 +1,30 @@
+class Mumukit::Server::TestPipeline
+  def initialize(server, request)
+    @server = server
+    @request = request
+  end
+
+  def evaluate!
+    @test_results = @server.run_tests! @request
+    @expectation_results = @server.run_expectations!(@request).try do |raw|
+      static_errors?(raw) ? [] : raw
+    end
+  end
+
+  def generate_feedback!
+    @feedback = @server.run_feedback! @request,
+                                     struct(test_results: @test_results, expectation_results: @expectation_results)
+  end
+
+  def response
+    builder = Mumukit::Server::ResponseBuilder.new
+    builder.add_test_results @test_results
+    builder.add_expectation_results @expectation_results
+    builder.add_feedback @feedback
+    builder.build
+  end
+
+  def static_errors?(raw)
+    raw.size == 2 && raw[1] == :errored
+  end
+end

data/lib/mumukit/server/test_server.rb

@@ -32,19 +32,10 @@ class Mumukit::Server::TestServer
 
   def test!(request)
     respond_to(request) do |r|
-      test_results = run_tests! r
-      expectation_results = run_expectations! r
-
-      results = OpenStruct.new(test_results: test_results,
-                               expectation_results: expectation_results)
-
-      feedback = run_feedback! r, results
-
-      Mumukit::Server::ResponseBuilder.build do
-        add_test_results(test_results)
-        add_expectation_results(expectation_results)
-        add_feedback(feedback)
-      end
+      pipeline = Mumukit::Server::TestPipeline.new self, r
+      pipeline.evaluate!
+      pipeline.generate_feedback!
+      pipeline.response
     end
   end
 
@@ -57,8 +48,13 @@ class Mumukit::Server::TestServer
     end
   end
 
-  def run_query!(request)
-    compile_and_run runtime.query_hook, request
+  def try!(request)
+    respond_to(request) do |r|
+      results = run_try!(r)
+      Mumukit::Server::ResponseBuilder.build do
+        add_try_results(results)
+      end
+    end
   end
 
   def run_tests!(request)
@@ -68,11 +64,9 @@ class Mumukit::Server::TestServer
   end
 
   def run_expectations!(request)
-    if request.expectations
-      compile_and_run runtime.expectations_hook, request
-    else
-      []
-    end
+    return [] if request.expectations.nil? || request.content.nil?
+
+    compile_and_run runtime.expectations_hook, request
   end
 
   def run_feedback!(request, results)
@@ -81,26 +75,23 @@ class Mumukit::Server::TestServer
 
   private
 
+  def run_query!(request)
+    compile_and_run runtime.query_hook, request
+  end
+
+  def run_try!(request)
+    compile_and_run runtime.try_hook, request
+  end
+
   def compile_and_run(hook, request)
-    compilation = hook.compile(preprocess request)
+    compilation = hook.compile(request)
     hook.run!(compilation)
+  rescue Mumukit::CompilationError => e
+    [e.message, :errored]
   end
 
   def preprocess(request)
-    if Mumukit.config.preprocessor_enabled
-      directives_pipeline.transform(request)
-    else
-      request
-    end
-  end
-
-  def directives_pipeline
-    @pipeline ||= Mumukit::Directives::Pipeline.new(
-        [Mumukit::Directives::Sections.new,
-         Mumukit::Directives::Interpolations.new('test'),
-         Mumukit::Directives::Interpolations.new('extra'),
-         Mumukit::Directives::Flags.new],
-        Mumukit.config.comment_type)
+    Mumukit.directives_pipeline.transform(request)
   end
 
   def validate_request!(request)
@@ -108,7 +99,7 @@ class Mumukit::Server::TestServer
   end
 
   def respond_to(request)
-    yield request.tap { |r| validate_request! r }
+    yield preprocess request.tap { |r| validate_request! r }
   rescue Mumukit::RequestValidationError => e
     {exit: :aborted, out: e.message}
   rescue Exception => e

data/lib/mumukit/server.rb

@@ -4,4 +4,5 @@ module Mumukit
 end
 
 require_relative './server/response_builder'
+require_relative './server/test_pipeline'
 require_relative './server/test_server'

data/lib/mumukit/templates/file_hook.rb

@@ -2,17 +2,25 @@ module Mumukit
   class Templates::FileHook < Mumukit::Hook
     include Mumukit::WithTempfile
 
+    attr_accessor :request
+
+
     def compile(request)
+      self.request = request
       write_tempfile! compile_file_content(request)
     end
 
     def run!(file)
       result, status = run_file!(file)
-      post_process_file(file, result.force_encoding('UTF-8'), status)
+      post_process_file(file, cleanup_raw_result(result), status)
     ensure
       file.unlink
     end
 
+    def cleanup_raw_result(result)
+      mask_tempfile_references(result.force_encoding('UTF-8'), masked_tempfile_path)
+    end
+
     def post_process_file(file, result, status)
       [result, status]
     end
@@ -22,8 +30,29 @@ module Mumukit
 
     required :run_file!, 'Wrong configuration. You must include an environment mixin'
 
-    def self.structured(value=true)
+    def masked_tempfile_path
+      @masked_tempfile_path ||= "#{t 'mumukit.masked_tempfile_basename'}#{tempfile_extension}"
+    end
+
+    def self.line_number_offset(offset, options={})
+      include Mumukit::Templates::WithLineNumberOffset
+
+      define_method(:line_number_offset) do
+        extra_offset = options[:include_extra] && request.extra ? request.extra.lines.length : 0
+        offset + extra_offset
+      end
+    end
+
+    def self.metatested(value=true)
+      if value
+        include Mumukit::Templates::WithMetatest
+        include Mumukit::Templates::WithMetatestResults
+      end
+    end
+
+    def self.structured(value=true, separator: nil)
       if value
+        @separator = separator
         include Mumukit::Templates::WithStructuredResults
       end
     end
@@ -36,8 +65,9 @@ module Mumukit
       end
     end
 
-    def self.mashup(*args)
+    def self.mashup(*args, &map_block)
       include Mumukit::Templates::WithMashupFileContent
+      define_method(:map_mashup_fields, &map_block) if block_given?
 
       args = args.present? ? args : [:extra, :content, :test]
 

data/lib/mumukit/templates/mulang_expectations_hook.rb

@@ -1,32 +1,71 @@
+require 'mumukit/inspection'
+require 'mulang'
+
 module Mumukit
-  class Templates::MulangExpectationsHook < Mumukit::Templates::FileHook
-    isolated false
+  class Templates::MulangExpectationsHook < Mumukit::Hook
+    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)
 
     required :language, 'You have to provide a Mulang-compatible language in order to use this hook'
 
-    def tempfile_extension
-      '.json'
+    def compile(request)
+      expectations, exceptions = compile_expectations_and_exceptions request
+      mulang_code(request).analysis(
+        expectations: expectations,
+        smellsSet: {
+          tag: 'AllSmells',
+          exclude: (exceptions + default_smell_exceptions)
+        },
+        domainLanguage: domain_language)
+    end
+
+    def run!(analysis)
+      parse_response Mulang.analyse(analysis)
+    rescue JSON::ParserError
+      raise Mumukit::CompilationError, "Can not handle mulang results for analysis #{analysis}"
     end
 
-    def command_line(filename)
-      "cat #{filename} | #{mulang_path} -s"
+
+    def domain_language
+      {
+        caseStyle: "CamelCase",
+        minimumIdentifierSize: 3,
+        jargon: []
+      }
     end
 
-    def post_process_file(file, result, status)
-      parse_response JSON.pretty_parse(result)
+    def default_smell_exceptions
+      []
     end
 
-    def compile_file_content(request)
-      compile_json_file_content(request).to_json
+    def mulang_code(request)
+      Mulang::Code.new(mulang_language, compile_content(request[:content]))
     end
 
-    def compile_json_file_content(request)
-      {
-          expectations: request[:expectations].map { |it| compile_expectation(it.deep_symbolize_keys) },
-          code: {
-              content: compile_content(request[:content]),
-              language: language}
-      }
+    def mulang_language
+      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)
@@ -34,11 +73,14 @@ module Mumukit
     end
 
     def compile_expectation(expectation)
-      (expectation[:verb].present? ? {tag: :Advanced} : {tag: :Basic}).merge(expectation)
+      Mumukit::Inspection::Expectation.parse(expectation).as_v2.to_h
     end
 
     def parse_response(response)
-      response['results'].map do |it|
+      if response['tag'] == 'AnalysisFailed'
+        raise Mumukit::CompilationError, response['reason']
+      end
+      response['expectationResults'].map do |it|
         {result: it['result'],
          expectation: parse_expectation(it['expectation'])}
       end
@@ -54,4 +96,4 @@ module Mumukit
       end
     end
   end
-end
+end

data/lib/mumukit/templates/try_hook.rb

@@ -0,0 +1,17 @@
+module Mumukit
+  class Templates::TryHook < Templates::FileHook
+    def compile(request)
+      @goal = {postconditions: [[request.goal.with_indifferent_access[:kind], request.goal]]}
+      @checker = Metatest::InteractiveChecker.new request
+      super request
+    end
+
+    def post_process_file(file, result, status)
+      structured_results = to_structured_results(file, result, status)
+      check_results = @checker.check structured_results, @goal
+      [check_results[2], check_results[1], structured_results[:query]]
+    end
+
+    required :to_structured_results
+  end
+end

data/lib/mumukit/templates/with_cookie.rb

@@ -0,0 +1,10 @@
+module Mumukit::Templates::WithCookie
+  def build_cookie_code(request)
+    @cookie = cookie_class.new(request.cookie)
+    @cookie.code
+  end
+
+  def trim_cookie_output(output)
+    @cookie.trim(output)
+  end
+end

data/lib/mumukit/templates/with_line_number_offset.rb

@@ -0,0 +1,19 @@
+module Mumukit::Templates::WithLineNumberOffset
+  def cleanup_raw_result(result)
+    super(result).gsub(line_number_reference_regexp) do
+      rebuild_line_number_reference correct_line_number($1.to_i)
+    end
+  end
+
+  def line_number_reference_regexp
+    /#{masked_tempfile_path}\:(\d+)/m
+  end
+
+  def rebuild_line_number_reference(new_line_number)
+    "#{masked_tempfile_path}:#{new_line_number}"
+  end
+
+  def correct_line_number(number)
+    number - line_number_offset
+  end
+end

data/lib/mumukit/templates/with_mashup_file_content.rb

@@ -1,11 +1,15 @@
 module Mumukit
   module Templates::WithMashupFileContent
     def compile_file_content(request)
-      mashup_fields.map { |field| request.send field }.join("\n")
+      map_mashup_fields(*mashup_fields.map { |field| request.public_send field }).join("\n")
     end
 
     def mashup_fields
       raise 'must define mashup fields'
     end
+
+    def map_mashup_fields(*fields)
+    	fields
+    end
   end
 end

data/lib/mumukit/templates/with_metatest.rb

@@ -0,0 +1,14 @@
+module Mumukit::Templates::WithMetatest
+  def metatest
+    Mumukit::Metatest::Framework.new checker: metatest_checker,
+                                     runner: metatest_runner
+  end
+
+  def metatest_runner
+    Mumukit::Metatest::IdentityRunner.new
+  end
+
+  def run_metatest!(target, examples)
+    metatest.test target, examples
+  end
+end

data/lib/mumukit/templates/with_metatest_results.rb

@@ -0,0 +1,31 @@
+module Mumukit::Templates::WithMetatestResults
+  def compile_file_content(request)
+    @examples = compile_metatest_examples(request)
+    compile_metatest_file_content(request)
+  end
+
+  def compile_metatest_examples(request)
+    YAML.load(request.test).deep_symbolize_keys[:examples]
+  end
+
+  def post_process_file(file, result, status)
+    if status == :passed
+      run_metatest! to_metatest_compilation(result), @examples
+    else
+      post_process_unsuccessful_result(file, result, status)
+    end
+  rescue JSON::ParserError
+    [result, :errored]
+  end
+
+  def post_process_unsuccessful_result(_file, result, status)
+    [result, status]
+  end
+
+  def to_metatest_compilation(result)
+    JSON.pretty_parse(result).deep_symbolize_keys
+  end
+end
+
+
+

data/lib/mumukit/templates/with_structured_results.rb

@@ -1,15 +1,26 @@
 module Mumukit::Templates::WithStructuredResults
   def post_process_file(file, result, status)
+    result = extract_result(result)
     if [:passed, :failed].include? status
       [to_structured_result(result)]
     else
-      [result, status]
+      post_process_unstructured_result(file, result, status)
     end
   rescue JSON::ParserError
     [result, :errored]
   end
 
+  def post_process_unstructured_result(_file, result, status)
+    [result, status]
+  end
+
+  def extract_result(result)
+    separator = self.class.instance_variable_get :@separator
+    result = result.split(separator).last if separator.present?
+    result
+  end
+
   def to_structured_result(result)
     JSON.pretty_parse(result)
   end
-end
+end

data/lib/mumukit/templates.rb

@@ -4,9 +4,14 @@ module Mumukit
 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'
 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_code_smells'
+require_relative './templates/with_cookie'

data/lib/mumukit/version.rb

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

data/lib/mumukit/with_tempfile.rb

@@ -23,5 +23,8 @@ module Mumukit
       file
     end
 
+    def mask_tempfile_references(string, masked_tempfile_path)
+      string.gsub(/\/tmp\/mumuki\.compile(.+?)#{tempfile_extension}/, masked_tempfile_path)
+    end
   end
 end

data/lib/mumukit.rb

@@ -1,15 +1,8 @@
-require 'i18n'
-require 'i18n/backend/fallbacks'
 require 'mumukit/core'
 require 'mumukit/directives'
 require 'ostruct'
 
-pwd = File.expand_path(File.dirname(__FILE__))
-
-I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
-I18n.load_path += Dir[File.join(pwd, 'locales', '*.yml')]
-
-I18n.backend.load_translations
+I18n.load_translations_path File.join(__dir__, 'locales', '*.yml')
 
 module Mumukit
   def self.current_runner=(runner)
@@ -34,14 +27,14 @@ module Mumukit
   end
 
   class << self
-    delegate :prefix, :config, :configure, :runtime, :configure_runtime, to: :current_runner
+    delegate :prefix, :config, :configure, :runtime, :configure_runtime, :directives_pipeline, to: :current_runner
   end
 end
 
 require_relative 'mumukit/runner'
 
 Mumukit.configure_defaults do |config|
-  config.limit_script = File.join(pwd, '..', 'bin', 'limit')
+  config.limit_script = File.join(__dir__, '..', 'bin', 'limit')
   config.content_type = :plain
   config.comment_type = Mumukit::Directives::CommentType::Cpp
   config.preprocessor_enabled = true
@@ -55,6 +48,7 @@ require 'mumukit/content_type'
 
 require_relative 'mumukit/version'
 require_relative 'mumukit/env'
+require_relative 'mumukit/cookie'
 require_relative 'mumukit/with_tempfile'
 require_relative 'mumukit/with_content_type'
 require_relative 'mumukit/with_command_line'
@@ -63,6 +57,8 @@ require_relative 'mumukit/runtime'
 require_relative 'mumukit/isolated_environment'
 require_relative 'mumukit/templates'
 require_relative 'mumukit/request_validation_error'
+require_relative 'mumukit/compilation_error'
 require_relative 'mumukit/defaults'
 require_relative 'mumukit/metatest'
+require_relative 'mumukit/explainer'
 require_relative 'mumukit/server'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mumukit
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.17.0
 platform: ruby
 authors:
 - Franco Leonardo Bulgarelli
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-11 00:00:00.000000000 Z
+date: 2017-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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
@@ -151,47 +165,87 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.46'
 - !ruby/object:Gem::Dependency
-  name: mumukit-core
+  name: mulang
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '3.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: mumukit-inspection
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: mumukit-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: mumukit-directives
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: mumukit-content-type
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
 description: Helpers for building a Mumuki Test Server
 email:
 - flbulgarelli@yahoo.com.ar
@@ -200,18 +254,22 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/limit
-- bin/mulang
 - lib/locales/en.yml
 - lib/locales/es.yml
 - lib/mumukit.rb
+- lib/mumukit/compilation_error.rb
+- lib/mumukit/cookie.rb
 - lib/mumukit/defaults.rb
 - 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_query_hook.rb
 - lib/mumukit/defaults/default_test_hook.rb
+- lib/mumukit/defaults/default_try_hook.rb
 - lib/mumukit/defaults/default_validation_hook.rb
+- lib/mumukit/defaults/default_version_hook.rb
 - lib/mumukit/env.rb
+- lib/mumukit/explainer.rb
 - lib/mumukit/hook.rb
 - lib/mumukit/isolated_environment.rb
 - lib/mumukit/metatest.rb
@@ -219,6 +277,7 @@ files:
 - lib/mumukit/metatest/errors.rb
 - lib/mumukit/metatest/framework.rb
 - lib/mumukit/metatest/identity_runner.rb
+- lib/mumukit/metatest/interactive_checker.rb
 - lib/mumukit/request_validation_error.rb
 - lib/mumukit/runner.rb
 - lib/mumukit/runtime.rb
@@ -229,14 +288,20 @@ files:
 - lib/mumukit/server.rb
 - lib/mumukit/server/app.rb
 - lib/mumukit/server/response_builder.rb
+- lib/mumukit/server/test_pipeline.rb
 - lib/mumukit/server/test_server.rb
 - lib/mumukit/templates.rb
 - lib/mumukit/templates/file_hook.rb
 - lib/mumukit/templates/mulang_expectations_hook.rb
+- lib/mumukit/templates/try_hook.rb
 - lib/mumukit/templates/with_code_smells.rb
+- lib/mumukit/templates/with_cookie.rb
 - lib/mumukit/templates/with_embedded_environment.rb
 - lib/mumukit/templates/with_isolated_environment.rb
+- lib/mumukit/templates/with_line_number_offset.rb
 - 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_structured_results.rb
 - lib/mumukit/version.rb
 - lib/mumukit/with_command_line.rb
@@ -263,7 +328,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.7.2
 signing_key: 
 specification_version: 4
 summary: Mumuki Test Server Development Kit