stones-spec 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 61404af586ca76a2bbe93f918c43e9e5f96d6e27
+  data.tar.gz: 6a5c5604f68519886817fd96e6c8d1ebe811d2ec
+SHA512:
+  metadata.gz: 30bfcb15abdf1f02ae85ba42def8c1d74bf91d0c5924fbc3be60a383a458e1cae152743a7c7ed0d560115746eb52f5f3160bf58a441371169f06aefd1c064ee2
+  data.tar.gz: c2c67ed0a00ff8c5ebe54f227448efc184f3e2fb40d55c19d0eed7f3bb2ec7f449519a1d9e1a8a8bfe975631abb7dbc526beec8b228fe3827670bc79dfa83435

data/lib/example.rb

@@ -0,0 +1,43 @@
+require 'ostruct'
+
+module StonesSpec
+  class Example < OpenStruct
+    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, parser)
+      parser.run(files[:source], files[:initial_board], files[:final_board])
+    end
+
+    def result(files, execution, postcondition)
+      if execution[:status] == :syntax_error
+        raise Gobstones::SyntaxError, execution[:result]
+      end
+
+      if execution[:status] == :runtime_error
+        raise Gobstones::AbortedError, execution[:result]
+      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/gobstones.rb

@@ -0,0 +1,26 @@
+module StonesSpec
+  module Gobstones
+    def self.source_code_extension
+      'gbs'
+    end
+
+    def self.board_extension
+      'gbb'
+    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/helpers/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/helpers/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/helpers/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/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/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/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/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/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/renderers/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/renderers/with_gbb_html_rendering.rb

@@ -0,0 +1,55 @@
+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)
+      "#{get_html_board 'Tablero inicial', initial_board_gbb}\n#{get_boom_board initial_board_gbb}\n#{result}"
+    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/renderers/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/runner.rb

@@ -0,0 +1,45 @@
+module StonesSpec
+  class Runner
+    include StonesSpec::WithTempfile
+    
+    def initialize(parser)
+      @parser = parser
+    end
+
+    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, @parser
+
+      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.rb

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

data/lib/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/version.rb

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

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: stones-spec
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Mumuki
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-stones
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !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: 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'
+description: 
+email:
+- mumuki@mumuki.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/example.rb
+- lib/gobstones.rb
+- lib/helpers/hash.rb
+- lib/helpers/string.rb
+- lib/helpers/with_tempfile.rb
+- lib/postcondition/expected_boom.rb
+- lib/postcondition/expected_final_board.rb
+- lib/postcondition/expected_return_value.rb
+- lib/postcondition/postcondition.rb
+- lib/precondition.rb
+- lib/renderers/html_board_renderer.rb
+- lib/renderers/with_gbb_html_rendering.rb
+- lib/renderers/with_gobstones_css.rb
+- lib/runner.rb
+- lib/stones-spec.rb
+- lib/subject.rb
+- lib/version.rb
+homepage: http://github.com/mumuki/stones-spec
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Minimal test framework for Gobstones
+test_files: []