mumuki-gobstones-runner 1.0.1 → 1.1.0

data/lib/stones_spec.rb

@@ -1,21 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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