mumuki-gobstones-runner 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZjI0MTQwYWIzZTQ4OThjZjc5NGFhODY3Y2ZiZGVhYzg0YTFjZWEzNA==
+  data.tar.gz: !binary |-
+    NGIwMmMyMzc2NWQ0OGM3NWIzYmYzZDEwODAyYjI4MjA2YjMzMjA3Nw==
+SHA512:
+  metadata.gz: !binary |-
+    MDk4Njk0YjVkM2JjMDhjMDgxNGE2MTU5NDBlMjNmZGMxZDdiOTRiOTI2NmJm
+    NjYwYzU2MjY3NTFlZTQzNWM2ZjI1ZjVjZDNlMmM3MTYyZWJiYTc1OWNlNzMw
+    ZTUxMjYyNTgyZDJiN2I3NGY5MTQyOThkOTg5NjQxMmZlMDhlM2Y=
+  data.tar.gz: !binary |-
+    OTgwMzNhMWIwNTU4NDk1NWQ1OWM2ZjdkYWY2N2ZmMzkxY2E4MGRmNmQ2Mzlh
+    Y2QyNjcxYWQzNWMwMWU3MTIxNzFkMDBjNTk1M2NkM2VjNjA4YmMyYTZlZWIx
+    ZDc3MmRmNmMwZmYxNzM3YjY5N2IxNWE5NjYzYjE5Mzk5NTViYmE=

data/lib/expectations_hook.rb

@@ -0,0 +1,102 @@
+require 'mumukit'
+require 'mumukit/inspection'
+require 'yaml'
+
+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}$/)
+    }
+  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 gobstones_command
+    @config['gobstones_command']
+  end
+end

data/lib/gobstones_runner.rb

@@ -0,0 +1,13 @@
+require 'mumukit'
+
+Mumukit.runner_name = 'gobstones'
+Mumukit.configure do |config|
+  config.structured = true
+  config.content_type = 'html'
+end
+
+require 'active_support/all'
+require_relative './stones_spec'
+require_relative './test_hook'
+require_relative './metadata_hook'
+require_relative './expectations_hook'

data/lib/metadata_hook.rb

@@ -0,0 +1,16 @@
+class GobstonesMetadataHook < Mumukit::Hook
+  def metadata
+    {language: {
+        name: 'gobstones',
+        icon: {type: 'devicon', name: 'gobstones'},
+        version: '1.4.1',
+        extension: 'gbs',
+        ace_mode: 'gobstones',
+        graphic: true
+    },
+     test_framework: {
+         name: 'stones-spec',
+         test_extension: 'yml'
+     }}
+  end
+end

data/lib/stones_spec.rb

@@ -0,0 +1,21 @@
+module StonesSpec
+end
+
+require 'stones'
+
+require_relative 'stones_spec/string'
+require_relative 'stones_spec/hash'
+
+require_relative 'stones_spec/with_tempfile'
+require_relative 'stones_spec/with_command_line'
+require_relative 'stones_spec/with_gbb_html_rendering'
+require_relative 'stones_spec/version'
+
+require_relative 'stones_spec/precondition'
+require_relative 'stones_spec/postcondition/postcondition'
+require_relative 'stones_spec/error_message_parser'
+require_relative 'stones_spec/gobstones'
+require_relative 'stones_spec/example'
+require_relative 'stones_spec/subject'
+require_relative 'stones_spec/runner'
+require_relative 'stones_spec/html_board_renderer'

data/lib/stones_spec/error_message_parser.rb

@@ -0,0 +1,17 @@
+module StonesSpec
+  module ErrorMessageParser
+    def self.parse(result)
+      remove_boom_line_specification(remove_line_specification(result.lines)).join.strip
+    end
+
+    private
+
+    def self.remove_line_specification(x)
+      x.drop_while { |str| !str.include_any? ['cerca de', 'Error de Gobstones'] }
+    end
+
+    def self.remove_boom_line_specification(x)
+      x.take_while { |str| not str.strip.start_with? 'En:' }
+    end
+  end
+end

data/lib/stones_spec/example.rb

@@ -0,0 +1,47 @@
+require 'ostruct'
+
+module StonesSpec
+  class Example < OpenStruct
+    include Mumukit::WithCommandLine
+
+    def initialize(subject, attributes)
+      super attributes
+      @title = attributes[:title]
+      @subject = subject
+      @precondition = Precondition.from_example(self)
+    end
+
+    def execution_data(source)
+      { source: @subject.test_program(source, @precondition.arguments),
+        initial_board: @precondition.initial_board_gbb }
+    end
+
+    def execute!(files)
+      result, status = run_command "#{Gobstones.run(files[:source], files[:initial_board], files[:final_board])} 2>&1"
+      { result: result, status: status }
+    end
+
+    def result(files, execution, postcondition)
+      if execution[:status] == :aborted
+        raise Gobstones::AbortedError, execution[:result]
+      end
+
+      if execution[:status] == :failed
+        error_message = Gobstones.parse_error_message execution[:result]
+        Gobstones.ensure_no_syntax_error! error_message
+      end
+
+      postcondition.validate(files[:initial_board].open.read, files[:final_board].open.read, execution[:result], execution[:status])
+    end
+
+    def title
+      @title || default_title
+    end
+
+    private
+
+    def default_title
+      @subject.default_title @precondition.arguments
+    end
+  end
+end

data/lib/stones_spec/gobstones.rb

@@ -0,0 +1,55 @@
+module StonesSpec
+  module Gobstones
+    def self.configure
+      @config ||= OpenStruct.new
+      yield @config
+    end
+
+    def self.config
+      @config
+    end
+
+    def self.run(source_file, initial_board_file, final_board_file)
+      "#{config.gbs_command} #{source_file.path} --from #{initial_board_file.path} --to #{final_board_file.path} --no-print-board --silent"
+    end
+
+    def self.parse_error_message(result)
+      "<pre>#{ErrorMessageParser.parse result}</pre>"
+    end
+
+    def self.runtime_error?(result)
+      result.include_any? ['Error en tiempo de ejecución', 'Error en el programa']
+    end
+
+    def self.syntax_error?(result)
+      result.include? 'Error de sintaxis'
+    end
+
+    def self.source_code_extension
+      'gbs'
+    end
+
+    def self.board_extension
+      'gbb'
+    end
+
+    def self.ensure_no_syntax_error!(error_message)
+      raise SyntaxError, error_message if syntax_error? error_message
+    end
+
+    class Error < Exception
+    end
+
+    class SyntaxError < Error
+      def status
+        :errored
+      end
+    end
+
+    class AbortedError < Error
+      def status
+        :aborted
+      end
+    end
+  end
+end

data/lib/stones_spec/hash.rb

@@ -0,0 +1,5 @@
+class Hash
+  def map_values(&block)
+    Hash[self.map {|k, v| [k, block.call(k,v)] }]
+  end
+end

data/lib/stones_spec/html_board_renderer.rb

@@ -0,0 +1,77 @@
+require_relative './with_gobstones_css'
+
+module StonesSpec
+  class HtmlBoardRenderer
+    include StonesSpec::WithGobstonesCSS
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def render(board)
+"<style type=\"text/css\">
+#{render_css}</style>
+
+#{render_html board}"
+    end
+
+    def method_missing(name)
+      @options[name]
+    end
+
+    def render_html(board)
+      width, height = board.size
+
+"#{table_title}
+#{html_row_titles width, 'top'}
+#{(0...height).to_a.reverse.map {|y| html_row(board, y)}.join}#{html_row_titles width, 'bottom'}
+</table>
+"
+    end
+
+    def render_css
+      gobstones_css '9pt', 30
+    end
+
+    private
+
+    def table_title
+      base = "<table class=\"gbs_board\">"
+      caption ? base + "\n<caption>#{caption}</caption>" : base
+    end
+
+    def html_row(board, y)
+"  <tr>
+    <td class=\"lv\">#{y}</td>
+#{(0...board.size[0]).map {|x| html_cell board, [x, y] }.join "\n"}
+    <td class=\"lv\">#{y}</td>
+  </tr>
+"
+    end
+
+    def html_cell(board, position)
+      cell = board.cell_at position
+
+"    <td class=\"gc#{board.head_position == position ? ' gh' : ''}\">
+      <table>
+        <tr>#{html_stone cell, :black}#{html_stone cell, :blue}</tr>
+        <tr>#{html_stone cell, :red}#{html_stone cell, :green}</tr>
+      </table>
+    </td>"
+    end
+
+    def html_stone(cell, color)
+      quantity = cell[color]
+
+      if cell[color] == 0
+        '<td><div class="O"></div></td>'
+      else
+        "<td><div class=\"gbs_stone #{Stones::Color.all_with_names.invert[color][0]}\"><span>#{quantity}</span></div></td>"
+      end
+    end
+
+    def html_row_titles(width, caption)
+"<tr><td class=\"lx #{caption}_left\"></td>#{(0...width).map {|x| "<td class=\"lh\">#{x}</td>"}.join}<td class=\"lx #{caption}_right\"></td></tr>"
+    end
+  end
+end

data/lib/stones_spec/postcondition/expected_boom.rb

@@ -0,0 +1,55 @@
+module StonesSpec
+  module Postcondition
+    class ExpectedBoom
+      include StonesSpec::WithGbbHtmlRendering
+
+      attr_reader :example, :error_type
+
+      def initialize(example)
+        @example = example
+        @error_type = known_error_types[example.error.to_sym]
+      end
+
+      def validate(initial_board_gbb, actual_final_board_gbb, result, status)
+        if status == :failed
+          check_right_error_type initial_board_gbb, result
+        else
+          boards = [['Tablero inicial', initial_board_gbb], ['Tablero final', actual_final_board_gbb]]
+          make_boards_output example.title, boards, :failed, failure_message
+        end
+      end
+
+      private
+
+      def check_right_error_type(initial_board_gbb, result)
+        if error_type_matches? result
+          [example.title, :passed, make_error_output(result, initial_board_gbb)]
+        else
+          [example.title, :failed, "#{invalid_boom_type_message}\n#{make_error_output(result, initial_board_gbb)}"]
+        end
+      end
+
+      def error_type_matches?(result)
+         error_type[:matcher] =~ result
+      end
+
+      def known_error_types
+        {
+          out_of_board: { matcher: /La posición cae afuera del tablero/, friendly_message: 'caer fuera del tablero' },
+          no_stones: { matcher: /No hay bolitas de ese color/, friendly_message: 'no haber bolitas' },
+          unassigned_variable: { matcher: /podría no tener asignado ningún valor/, friendly_message: 'tener una variable sin asignar' },
+          wrong_argument_type: { matcher: /El argumento de .+ debería ser/, friendly_message: 'tipo erróneo de un argumento' },
+          wrong_arguments_quantity: { matcher: /Esperaba \d+ argumentos (.|\n)* Recibió \d+/, friendly_message: 'cantidad inválida de argumentos' }
+        }
+      end
+
+      def failure_message
+        'Se esperaba que el programa hiciera BOOM pero se obtuvo un tablero final.'
+      end
+
+      def invalid_boom_type_message
+        "<p>Se esperaba que el programa hiciera BOOM por #{error_type[:friendly_message]}.</p>"
+      end
+    end
+  end
+end

data/lib/stones_spec/postcondition/expected_final_board.rb

@@ -0,0 +1,56 @@
+module StonesSpec
+  module Postcondition
+    class ExpectedFinalBoard < ExpectedResult
+      attr_reader :check_head_position, :show_initial_board
+
+      def initialize(example, check_head_position, show_initial_board)
+        super example
+        @check_head_position = check_head_position
+        @show_initial_board = show_initial_board
+      end
+
+      def validate_expected_result(initial_board_gbb, actual_final_board_gbb, _result)
+        if matches_with_expected_board? Stones::Gbb.read actual_final_board_gbb
+          passed_result initial_board_gbb, actual_final_board_gbb
+        else
+          failed_result initial_board_gbb, example.final_board, actual_final_board_gbb
+        end
+      end
+
+      private
+
+      def failed_result(initial_board_gbb, expected_board_gbb, actual_board_gbb)
+        boards = [
+            ['Tablero final esperado', expected_board_gbb],
+            ['Tablero final obtenido', actual_board_gbb]
+        ]
+
+        boards.unshift ['Tablero inicial', initial_board_gbb] if show_initial_board
+
+        make_boards_output example.title, boards, :failed
+      end
+
+      def passed_result(initial_board_gbb, actual_board_gbb)
+        boards = [
+            ['Tablero final', actual_board_gbb]
+        ]
+
+        boards.unshift ['Tablero inicial', initial_board_gbb] if show_initial_board
+
+        make_boards_output example.title, boards, :passed
+      end
+
+      def matches_with_expected_board?(actual_board)
+        if check_head_position
+          actual_board == final_board
+        else
+          actual_board.cells_equal? final_board
+        end
+      end
+
+      def final_board
+        Stones::Gbb.read example.final_board
+      end
+    end
+  end
+end

data/lib/stones_spec/postcondition/expected_return_value.rb

@@ -0,0 +1,44 @@
+module StonesSpec
+  module Postcondition
+    class ExpectedReturnValue < ExpectedResult
+      def initialize(example, show_initial_board)
+        super example
+        @show_initial_board = show_initial_board
+      end
+
+      def validate_expected_result(initial_board_gbb, _actual_final_board_gbb, result)
+        normalized_actual_return = parse_success_output(result).strip
+
+        if normalized_actual_return == return_value
+          make_result(:passed, initial_board_gbb)
+        else
+          make_result(:failed, initial_board_gbb, "Se esperaba <b>#{return_value}</b> pero se obtuvo <b>#{normalized_actual_return}</b>")
+        end
+      end
+
+      private
+
+      def parse_success_output(result)
+        first_return_value result || ''
+      end
+
+      def first_return_value(result)
+        result[/#1 -> (.+)/, 1]
+      end
+
+      def make_result(status, initial_board_gbb, output='')
+        title = "#{example.title} -> #{return_value}"
+
+        if @show_initial_board
+          make_boards_output title, [['Tablero inicial', initial_board_gbb]], status, output
+        else
+          [title, status, output]
+        end
+      end
+
+      def return_value
+        example.return.to_s
+      end
+    end
+  end
+end

data/lib/stones_spec/postcondition/postcondition.rb

@@ -0,0 +1,35 @@
+module StonesSpec
+  module Postcondition
+    def self.from(example, check_head_position, show_initial_board)
+      if example.final_board
+        ExpectedFinalBoard.new(example, check_head_position, show_initial_board)
+      elsif example.return
+        ExpectedReturnValue.new(example, show_initial_board)
+      else
+        ExpectedBoom.new(example)
+      end
+    end
+
+    class ExpectedResult
+      include StonesSpec::WithGbbHtmlRendering
+
+      attr_reader :example
+
+      def initialize(example)
+        @example = example
+      end
+
+      def validate(initial_board_gbb, actual_final_board_gbb, result, status)
+        if status == :failed
+          [example.title, :failed, make_error_output(result, initial_board_gbb)]
+        else
+          validate_expected_result(initial_board_gbb, actual_final_board_gbb, result)
+        end
+      end
+    end
+  end
+end
+
+require_relative './expected_boom'
+require_relative './expected_final_board'
+require_relative './expected_return_value'

data/lib/stones_spec/precondition.rb

@@ -0,0 +1,26 @@
+module StonesSpec
+  class Precondition
+    attr_reader :initial_board_gbb
+
+    def self.from_example(example)
+      self.new example.initial_board, example.arguments
+    end
+
+    def initialize(initial_board, arguments)
+      @initial_board_gbb = initial_board || default_initial_board
+      @arguments = arguments
+    end
+
+    def arguments
+      @arguments || []
+    end
+
+    private
+
+    def default_initial_board
+'GBB/1.0
+size 4 4
+head 0 0'
+    end
+  end
+end

data/lib/stones_spec/runner.rb

@@ -0,0 +1,41 @@
+module StonesSpec
+  class Runner
+    include StonesSpec::WithTempfile
+
+    def run!(test_definition)
+      subject = Subject.from(test_definition[:subject])
+      source = test_definition[:source]
+      check_head_position = test_definition[:check_head_position]
+      show_initial_board = test_definition.fetch(:show_initial_board, true)
+
+      begin
+        [test_definition[:examples].map do |example_definition|
+          run_example!(example_definition, check_head_position, show_initial_board, source, subject)
+         end]
+      rescue Gobstones::AbortedError => e
+        test_definition[:expect_endless_while] ? [e.message, :passed] : [e.message, e.status]
+      rescue Gobstones::Error => e
+        [e.message, e.status]
+      end
+    end
+
+    private
+
+    def run_example!(example_definition, check_head_position, show_initial_board, source, subject)
+      example = Example.new(subject, example_definition)
+
+      data = example.execution_data source
+      files = {
+        source: Gobstones.source_code_extension,
+        initial_board: Gobstones.board_extension,
+        final_board: Gobstones.board_extension
+      }.map_values { |name, extension| write_tempfile(data[name], extension) }
+
+      execution = example.execute! files
+
+      example.result files, execution, Postcondition.from(example, check_head_position, show_initial_board)
+    ensure
+      files.each_value(&:unlink)
+    end
+  end
+end

data/lib/stones_spec/string.rb

@@ -0,0 +1,10 @@
+class String
+  def start_with_lowercase?
+    first_letter = self[0]
+    first_letter.downcase == first_letter
+  end
+
+  def include_any?(other_strs)
+    other_strs.any? { |other| include? other }
+  end
+end

data/lib/stones_spec/subject.rb

@@ -0,0 +1,80 @@
+module StonesSpec
+  module Subject
+    def self.from(name)
+      if name
+        infer_subject_type_for(name).new(name)
+      else
+        Program
+      end
+    end
+
+    def self.infer_subject_type_for(string)
+      string.start_with_lowercase? ? StonesSpec::Subject::Function : StonesSpec::Subject::Procedure
+    end
+
+    module Program
+      def self.test_program(source, _arguments)
+        source
+      end
+
+      def self.default_title(_arguments)
+        nil
+      end
+
+      def self.ast_regexp
+        /AST\(entrypoint\s*program/
+      end
+
+      def self.default_expectations
+        [{ 'binding' => 'program', 'inspection' => 'HasBinding' }]
+      end
+    end
+
+    class Callable
+      def initialize(name)
+        @name = name
+      end
+
+      def call_string(arguments)
+        "#{@name}(#{arguments.join(', ')})"
+      end
+
+      def default_title(arguments)
+        call_string arguments
+      end
+
+      def default_expectations
+        [ { 'binding' => 'program', 'inspection' => 'Not:HasBinding' },
+          { 'binding' => "#{@name}", 'inspection' => 'HasBinding' } ]
+      end
+    end
+
+    class Procedure < Callable
+      def test_program(source, arguments)
+        "program {
+          #{call_string arguments}
+        }
+
+        #{source}"
+      end
+
+      def ast_regexp
+        /AST\(procedure\s*#{@name}$/
+      end
+    end
+
+    class Function < Callable
+      def test_program(source, arguments)
+        "program {
+          return (#{call_string arguments})
+        }
+
+        #{source}"
+      end
+
+      def ast_regexp
+        /AST\(function\s*#{@name}/
+      end
+    end
+  end
+end

data/lib/stones_spec/version.rb

@@ -0,0 +1,3 @@
+module StonesSpec
+  VERSION = '0.3.0'
+end

data/lib/stones_spec/with_command_line.rb

@@ -0,0 +1,7 @@
+module StonesSpec
+  module WithCommandLine
+    def run_command(command)
+      [%x{#{command}}, $?.success? ? :passed : :failed]
+    end
+  end
+end

data/lib/stones_spec/with_gbb_html_rendering.rb

@@ -0,0 +1,60 @@
+module StonesSpec
+  module WithGbbHtmlRendering
+    def get_html_board(caption, gbb_representation)
+      HtmlBoardRenderer.new(caption: caption).render(Stones::GbbReader.new.from_string gbb_representation)
+    end
+
+    def make_error_output(result, initial_board_gbb)
+      error_message = Gobstones.parse_error_message result
+      if Gobstones.runtime_error? error_message
+        "#{get_html_board 'Tablero inicial', initial_board_gbb}\n#{get_boom_board initial_board_gbb}\n#{error_message}"
+      else
+        error_message
+      end
+    end
+
+    def make_boards_output(title, gbb_boards, status, extra = nil)
+      boards = gbb_boards.map { |gbb_with_caption| get_html_board *gbb_with_caption }.join("\n")
+      output = "<div>#{boards}</div>"
+
+      output = "<p>#{extra}</p>\n#{output}" if extra
+
+      [title, status, output]
+    end
+
+    private
+
+    def get_boom_board(initial_board_gbb)
+      gbb = empty_board_gbb_like initial_board_gbb
+
+      boom_css =
+        "<style type=\"text/css\">
+          table.boom {
+            background-image: url('#{boom_image_url}');
+            background-size: contain;
+            background-repeat: no-repeat;
+            background-position: center;
+          }
+        </style>"
+
+      without_header with_boom_css_class "#{boom_css}\n#{get_html_board '¡Se produjo BOOM!', gbb}"
+    end
+
+    def boom_image_url
+      'https://raw.githubusercontent.com/mumuki/mumuki-gobstones-server/master/lib/assets/boom.png'
+    end
+
+    def empty_board_gbb_like(initial_board_gbb)
+      x, y = Stones::Gbb.read(initial_board_gbb).size
+      Stones::Gbb.write Stones::Board.empty(x, y)
+    end
+
+    def with_boom_css_class(html)
+      html.sub('class="gbs_board"', 'class="gbs_board boom"')
+    end
+
+    def without_header(html)
+      html.sub('class="gc gh"', 'class="gc"')
+    end
+  end
+end

data/lib/stones_spec/with_gobstones_css.rb

@@ -0,0 +1,112 @@
+module StonesSpec
+  module WithGobstonesCSS
+    def gobstones_css(font_size, size)
+      unit = 'px'
+
+      full_size = "#{size}#{unit}"
+      half_size = "#{size / 2}#{unit}"
+
+    "table.gbs_board {
+  border-style: none;
+  border: solid black 0px;
+  border-spacing: 0;
+  border-collapse: collapse;
+  font-family: Arial, Helvetica, sans-serif;
+  font-size: #{font_size};
+  display: inline-block;
+  vertical-align: top;
+}
+.gbs_board td {
+  margin: 0;
+  padding: 2px;
+  border: solid #888 1px;
+  width: #{full_size};
+  height: #{full_size};
+}
+.gbs_board td.gh { /* position of the header in the board */
+  margin: 0;
+  padding: 2px;
+  border: dotted #440 3px;
+  background: #dd8;
+  width: #{full_size};
+  height: #{full_size};
+}
+.gbs_board td.lv { /* labels at the side */
+  text-align: center;
+  vertical-align: middle;
+  border-style: none;
+  border: solid black 0px;
+  background: #ddd;
+  width: #{half_size};
+}
+.gbs_board td.lh { /* labels at the top / bottom */
+  text-align: center;
+  vertical-align: middle;
+  border-style: none;
+  border: solid black 0px;
+  background: #ddd;
+  height: #{half_size};
+}
+.gbs_board td.lx { /* corner */
+  border-style: none;
+  border: solid black 0px;
+  background: #ddd;
+  width: #{half_size};
+  height: #{half_size};
+}
+.gbs_board td.top_left {
+  -webkit-border-top-left-radius: 10px;
+  -moz-border-top-left-radius: 10px;
+  border-top-left-radius: 10px;
+}
+.gbs_board td.top_right {
+  -webkit-border-top-right-radius: 10px;
+  -moz-border-top-right-radius: 10px;
+  border-top-right-radius: 10px;
+}
+.gbs_board td.bottom_left {
+  -webkit-border-bottom-left-radius: 10px;
+  -moz-border-bottom-left-radius: 10px;
+  border-bottom-left-radius: 10px;
+}
+.gbs_board td.bottom_right {
+  -webkit-border-bottom-right-radius: 10px;
+  -moz-border-bottom-right-radius: 10px;
+  border-bottom-right-radius: 10px;
+}
+.gbs_board table.gc { /* cell table */
+  border-style: none;
+  border: solid black 0px;
+}
+.gbs_board .gc tr {
+  border-style: none;
+  border: 0px;
+}
+.gbs_board .gc td {
+  border-style: none;
+  border: solid black 0px;
+  width: #{half_size};
+  height: #{half_size};
+  text-align: center;
+  color: black;
+}
+.gbs_board .gc td div {
+  line-height: 2;
+}
+.gbs_board div.A { background: #88f; border: solid 1px #008; }
+.gbs_board div.N { background: #aaa; border: solid 1px #222; }
+.gbs_board div.R { background: #f88; border: solid 1px #800; }
+.gbs_board div.V { background: #8f8; border: solid 1px #080; }
+.gbs_board div.O { width: 20px; height: 20px; background: none; } /* empty */
+.gbs_stone {
+  font-weight: bold;
+    font-size: 8pt;
+    width: 20px;
+    height: 20px;
+    -webkit-border-radius: 10px;
+    -moz-border-radius: 10px;
+    border-radius: 10px;
+}"
+    end
+  end
+end

data/lib/stones_spec/with_tempfile.rb

@@ -0,0 +1,13 @@
+require 'tempfile'
+
+module StonesSpec
+  module WithTempfile
+
+    def write_tempfile(content, extension)
+      file = Tempfile.new %W(gobstones. .#{extension})
+      file.write content
+      file.close
+      file
+    end
+  end
+end

data/lib/test_hook.rb

@@ -0,0 +1,24 @@
+require 'mumukit'
+require 'yaml'
+
+require_relative 'stones_spec'
+require_relative 'with_test_parser'
+
+class GobstonesTestHook < Mumukit::Hook
+  include WithTestParser
+
+  def compile(request)
+    test = parse_test request
+    test[:source] = "#{request[:content]}\n#{request[:extra]}".strip
+    test[:check_head_position] = !!test[:check_head_position]
+    test
+  end
+
+  def run!(test_definition)
+    StonesSpec::Gobstones.configure do |config|
+      config.gbs_command = gobstones_command
+    end
+
+    StonesSpec::Runner.new.run!(test_definition)
+  end
+end

data/lib/with_test_parser.rb

@@ -0,0 +1,8 @@
+require 'yaml'
+require 'active_support/core_ext/hash'
+
+module WithTestParser
+  def parse_test(request)
+    (YAML.load request[:test]).deep_symbolize_keys
+  end
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: mumuki-gobstones-runner
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Franco Leonardo Bulgarelli
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mumukit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  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: mumukit-bridge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: 
+email:
+- franco@mumuki.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/assets/boom.png
+- lib/expectations_hook.rb
+- lib/gobstones_runner.rb
+- lib/metadata_hook.rb
+- lib/stones_spec.rb
+- lib/stones_spec/error_message_parser.rb
+- lib/stones_spec/example.rb
+- lib/stones_spec/gobstones.rb
+- lib/stones_spec/hash.rb
+- lib/stones_spec/html_board_renderer.rb
+- lib/stones_spec/postcondition/expected_boom.rb
+- lib/stones_spec/postcondition/expected_final_board.rb
+- lib/stones_spec/postcondition/expected_return_value.rb
+- lib/stones_spec/postcondition/postcondition.rb
+- lib/stones_spec/precondition.rb
+- lib/stones_spec/runner.rb
+- lib/stones_spec/string.rb
+- lib/stones_spec/subject.rb
+- lib/stones_spec/version.rb
+- lib/stones_spec/with_command_line.rb
+- lib/stones_spec/with_gbb_html_rendering.rb
+- lib/stones_spec/with_gobstones_css.rb
+- lib/stones_spec/with_tempfile.rb
+- lib/test_hook.rb
+- lib/with_test_parser.rb
+homepage: http://github.com/mumuki/mumuki-gobstones-server
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Gobstones Runner for Mumuki
+test_files: []