mumuki-gobstones-runner 1.0.1 → 1.1.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NWJiYTc4NTUwOTRkNjgyZGE0OTQ5NTg0MTcyYjczMTJjMDVmZGM2OQ==
-  data.tar.gz: !binary |-
-    NjcyYTc4MWQ5MmFjM2UwOWVkOGJkNDk2YWE2ZjcxZjhhNzVkOTJhNQ==
+SHA1:
+  metadata.gz: 27939843f1079b96e0fe0dcd5ac9b7b8d2a8a63f
+  data.tar.gz: 2716a7461ea02e23df6d9186c009e1415ea85c25
 SHA512:
-  metadata.gz: !binary |-
-    NWJmYjRkZjg3YWVlNGEzOWQ1YTNiOTNjMGZjODQ5NWI1OThiMTg4YjhlZDdm
-    YzIyOTZhNGRjODE5NjY3YTk4MjRlYzU3Y2JhOTRiZTFhZTMzMTU3YTFmODI0
-    OWU0ZjQwNWMwMWIyZTAzZmRkNmMyZGJlMDEzMTE3ZjdlOTg2Mjg=
-  data.tar.gz: !binary |-
-    MmUxZmJiY2ZlYTg2MmM3YmFhZTA3NDA5MDc1YmRhYTIxOGIyYjI2Zjg5YWMy
-    ODlkNzk5MWQzNzYwNTY2MGI1NTkxNzE1ZDg2MTdiYzQyZjMwNzY4ZmFlZTZm
-    NWI0ZWQ1M2JlNDJmODVmOTEyMzEyMTE0ZWJjZDI4YTczNmNkZTI=
+  metadata.gz: 875d7f8a03261bad7ee99e45e672644ea4498fd43467ee6f182060526cf218fb242ef830dae5d77bdb1054f2eceab801fc672fb657dbcefdd4d28dd3d954c939
+  data.tar.gz: 833e0840163ed6dfe96a12446833457aacac8d5d9bfc4e294da45293b15bd65b5e8506c77a4af81591c958d4ab051449dc9b96424c3c923730ff014bb2999ebf

data/lib/assets_server.rb

@@ -0,0 +1,37 @@
+require 'sinatra/base'
+require 'sinatra/cross_origin'
+
+class Mumukit::Server::App < Sinatra::Base
+  register Sinatra::CrossOrigin
+
+  configure do
+    enable :cross_origin
+  end
+
+  def self.get_asset(route, absolute_path, type)
+    get "/assets/#{route}" do
+      send_file absolute_path, { type: type }
+    end
+  end
+
+  def self.get_board_asset(route, path, type)
+    get_asset route, Gobstones::Board.assets_path_for(path), type
+  end
+
+  def self.get_editor_asset(route, path, type)
+    get_asset route, Gobstones::Blockly.assets_path_for(path), type
+  end
+
+  def self.get_local_asset(route, path, type)
+    get_asset route, File.expand_path(path), type
+  end
+
+  get_board_asset  'webcomponents.js',     'javascripts/vendor/webcomponents.min.js',   'application/javascript'
+  get_local_asset  'editor/editor.js',     'lib/render/editor/editor.js',               'application/javascript'
+  get_board_asset  'polymer.html',         'htmls/vendor/polymer.html',                 'text/html'
+  get_board_asset  'polymer-mini.html',    'htmls/vendor/polymer-mini.html',            'text/html'
+  get_board_asset  'polymer-micro.html',   'htmls/vendor/polymer-micro.html',           'text/html'
+  get_board_asset  'gs-board.html',        'htmls/gs-board.html',                       'text/html'
+  get_editor_asset 'editor/editor.html',   'htmls/gs-element-blockly.html',             'text/html'
+  get_local_asset  'editor/editor.css',    'lib/render/editor/editor.css',              'text/css'
+end

data/lib/checker.rb

@@ -0,0 +1,101 @@
+module Gobstones
+  class Checker < Mumukit::Metatest::Checker
+    include Gobstones::WithRenderer
+
+    def initialize(options)
+      @options = options
+    end
+
+    def check_final_board(output, expected)
+      status = output[:status]
+      result = output[:result]
+
+      is_expected_timeout = result[:finalBoardError] &&
+                                    result[:finalBoardError][:reason][:code] == 'timeout' &&
+                                    @options[:expect_endless_while]
+
+      return if is_expected_timeout
+      assert_not_boom status, result
+
+      expected_board = result[:extraBoard]
+      actual_board = result[:finalBoard]
+      boards_match = board_json(expected_board).eql? board_json(actual_board)
+      headers_match = expected_board[:head].eql?(actual_board[:head]) || !@options[:check_head_position]
+
+      fail_with status: :check_final_board_failed_different_boards,
+                result: {
+                  initial: result[:initialBoard],
+                  expected: expected_board,
+                  actual: actual_board
+                } unless boards_match && headers_match
+    end
+
+    def check_error(output, expected)
+      status = output[:status]
+      result = output[:result]
+
+      fail_with status: :check_error_failed_expected_boom,
+                result: {
+                  initial: result[:initialBoard],
+                  expected: :boom,
+                  final: result[:finalBoard]
+                } if status == :passed
+
+      reason_code = convert_known_reason_code result[:finalBoardError][:reason][:code]
+      fail_with status: :check_error_failed_another_reason,
+                result: {
+                  reason: result[:finalBoardError],
+                  expected_code: expected
+                } if reason_code != expected
+    end
+
+    def check_return(output, expected)
+      status = output[:status]
+      result = output[:result]
+
+      assert_not_boom status, result
+      return_value = result[:finalBoard][:returnValue]
+
+      fail_with status: :check_return_failed_no_return,
+                result: {
+                  initial: result[:initialBoard],
+                  expected_value: expected
+                } if return_value.nil?
+
+      final_value = return_value[:value]
+      fail_with status: :check_return_failed_different_values,
+                result: {
+                  initial: result[:initialBoard],
+                  expected_value: expected,
+                  actual_value: final_value
+                } if final_value != expected
+    end
+
+    private
+
+    def assert_not_boom(status, result)
+      fail_with status: :check_failed_unexpected_boom,
+                result: {
+                  initial: result[:initialBoard],
+                  expected: result[:extraBoard],
+                  actual: :boom,
+                  reason: result[:finalBoardError]
+                } if status == :runtime_error
+    end
+
+    def fail_with(error)
+      fail error.to_json
+    end
+
+    def board_json(board)
+      board[:table][:json]
+    end
+
+    def convert_known_reason_code(code)
+      return "no_stones" if code == "cannot-remove-stone"
+      return "out_of_board" if code == "cannot-move-to"
+
+      code
+    end
+  end
+end

data/lib/expectations_hook.rb

@@ -1,102 +1,14 @@
-require 'mumukit'
-require 'mumukit/inspection'
-require 'yaml'
+class GobstonesExpectationsHook < Mumukit::Templates::MulangExpectationsHook
+  include_smells true
 
-require_relative 'with_test_parser'
-
-module EvalExpectationsOnAST
-  def eval_in_gobstones(binding, ast)
-    pattern_generator = expectations[type]
-
-    if pattern_generator
-      !!(ast =~ pattern_generator[binding])
-    else
-      true
-    end
-  end
-
-  def use(regexp)
-    lambda { |_| regexp }
-  end
-
-  def subject_for(binding)
-    if binding == 'program'
-      StonesSpec::Subject::Program
-    else
-      StonesSpec::Subject.from(binding)
-    end
-  end
-
-  def check_repeat_of(target)
-    use(/AST\(repeat\s*#{target}/)
-  end
-end
-
-class Mumukit::Inspection::PlainInspection
-  include EvalExpectationsOnAST
-
-  def expectations
-    {
-      'HasBinding' => lambda { |binding| subject_for(binding).ast_regexp },
-      'HasForeach' => use(/AST\(foreach/),
-      'HasRepeat' => check_repeat_of('.+'),
-      'HasVariable' => use(/AST\(assignVarName/),
-      'HasWhile' => use(/AST\(while/)
-    }
-  end
-end
-
-class Mumukit::Inspection::TargetedInspection
-  include EvalExpectationsOnAST
-
-  def expectations
-    {
-      'HasArity' => lambda { |binding| /#{subject_for(binding).ast_regexp}\s*AST\((\s*\w+){#{target}}\)/ },
-      'HasRepeatOf' => check_repeat_of("AST\\(literal\\s*#{target}\\)"),
-      'HasUsage' => use(/AST\((proc|func)Call\s*#{target}$/)
-    }
+  def language
+    'Mulang'
   end
-end
-
-class Mumukit::Inspection::NegatedInspection
-  def eval_in_gobstones(binding, ast)
-    !@inspection.eval_in_gobstones(binding, ast)
-  end
-end
-
-class GobstonesExpectationsHook < Mumukit::Defaults::ExpectationsHook
-  include StonesSpec::WithTempfile
-  include WithTestParser
-
-  def run!(request)
-    content = request[:content]
-    expectations = request[:expectations]
-
-    if content.strip.empty?
-      return expectations.map { |exp| {'expectation' => exp, 'result' => false } }
-    end
-
-    ast = generate_ast! content
-    all_expectations = expectations + (default_expectations_for parse_test request)
 
-    all_expectations.map { |exp| {'expectation' => exp, 'result' => run_expectation!(exp, ast)} }
-  end
-
-  private
-
-  def default_expectations_for(test)
-    StonesSpec::Subject.from(test[:subject]).default_expectations
-  end
-
-  def run_expectation!(expectation, ast)
-    Mumukit::Inspection.parse(expectation['inspection']).eval_in_gobstones(expectation['binding'], ast)
-  end
-
-  def generate_ast!(source_code)
-    %x"#{gobstones_command} #{write_tempfile(source_code, 'gbs').path} --print-ast --target parse --no-print-retvals --silent"
-  end
+  def mulang_code(request)
+    output, status = request.result
 
-  def gobstones_command
-    @config['gobstones_command']
+    ast = output.first[:result][:mulangAst]
+    Mulang::Code.new(mulang_language, ast)
   end
 end

data/lib/extensions/string.rb

@@ -0,0 +1,17 @@
+class String
+  def parse_as_json
+    JSON.parse(self, symbolize_names: true)
+  end
+
+  def initial_is_lower?
+    initial.lower?
+  end
+
+  def initial
+    slice 0, 1
+  end
+
+  def lower?
+    self == downcase
+  end
+end

data/lib/gobstones.rb

@@ -0,0 +1,11 @@
+require 'gobstones/board'
+require 'gobstones/blockly'
+
+module Gobstones
+
+end
+
+require_relative './gobstones/batch'
+require_relative './gobstones/batch_parser'
+require_relative './gobstones/error_builder'
+require_relative './gobstones/example_code_builder'

data/lib/gobstones/batch.rb

@@ -0,0 +1,38 @@
+class Gobstones::Batch
+  attr_accessor :options, :examples, :content, :extra
+
+  def initialize(content, examples, extra, options)
+    @content = content
+    @examples = examples
+    @extra = extra
+    @options = options
+  end
+
+  def run_tests!(output)
+    Mumukit::Metatest::Framework.new(
+      checker: Gobstones::Checker.new(options),
+      runner: Gobstones::MultipleExecutionsRunner.new).test output, examples
+  end
+
+  def to_json
+    examples.map { |example| example_json(example) }.to_json
+  end
+
+  private
+
+  def example_json(example)
+    expected_board = example[:postconditions][:final_board]
+    base = example_base_json(example)
+    expected_board ? base.merge(extraBoard: expected_board) : base
+  end
+
+  def example_base_json(example)
+    {initialBoard: example[:preconditions][:initial_board],
+     originalCode: content,
+     code: "#{example_code(example)}\n#{extra}"}
+  end
+
+  def example_code(example)
+    Gobstones::ExampleCodeBuilder.new(content, example, options).build
+  end
+end

data/lib/gobstones/batch_parser.rb

@@ -0,0 +1,68 @@
+module Gobstones::BatchParser
+  class << self
+    def parse(request)
+      test = parse_test(request)
+
+      options = parse_options test
+      examples = parse_examples test, options
+
+      Gobstones::Batch.new request.content, examples, request.extra, options
+    end
+
+    private
+
+    def parse_test(request)
+      YAML.load(request.test).deep_symbolize_keys
+    end
+
+    def parse_examples(test, options)
+      examples = test[:examples]
+      examples.each_with_index.map do |example, index|
+        parse_example options, {
+          id: index,
+          name: example[:title],
+          preconditions: example.slice(*preconditions),
+          postconditions: example.slice(*postconditions)
+        }
+      end
+    end
+
+    def parse_example(options, example)
+      return example unless options[:subject]
+
+      return_value = example[:postconditions][:return]
+      if return_value
+        example[:name] = "#{options[:subject]}() -> #{return_value}" unless example[:name]
+        options[:show_final_board] = false
+      end
+
+      example
+    end
+
+    def parse_options(test)
+      [
+        struct(key: :show_initial_board, default: true),
+        struct(key: :show_final_board, default: true),
+        struct(key: :check_head_position, default: false),
+        struct(key: :expect_endless_while, default: false),
+        struct(key: :subject, default: nil)
+      ].map { |it| [
+          it.key,
+          if test[it.key].nil?
+            it.default
+          else
+            test[it.key]
+          end
+        ]
+      }.to_h
+    end
+
+    def preconditions
+      [:initial_board, :arguments]
+    end
+
+    def postconditions
+      [:final_board, :error, :return]
+    end
+  end
+end

data/lib/gobstones/error_builder.rb

@@ -0,0 +1,6 @@
+module Gobstones
+  def self.build_error(error)
+    position = error[:on][:range][:start]
+    "[#{position[:row]}:#{position[:column]}]: #{error[:message]}"
+  end
+end

data/lib/gobstones/example_code_builder.rb

@@ -0,0 +1,35 @@
+class Gobstones::ExampleCodeBuilder
+  def initialize(code, example, options)
+    @code = code
+    @example = example
+    @options = options
+  end
+
+  def build
+    return @code unless subject
+<<GBS
+#{@code}
+program {
+   #{code_call}
+}
+GBS
+  end
+
+  private
+
+  def code_call
+    subject.initial_is_lower? ? "return (#{invocation})" : invocation
+  end
+
+  def subject
+    @options[:subject]
+  end
+
+  def invocation
+    "#{subject}(#{arguments})"
+  end
+
+  def arguments
+    (@example[:preconditions][:arguments] || []).join ','
+  end
+end