gobstones 0.0.1.1

data/lib/gobstones/parser/parse_error.rb

@@ -0,0 +1,17 @@
+module Gobstones
+
+  module Parser
+
+    class ParseError < StandardError
+
+      attr_reader :parser, :code
+
+      def initialize(parser, code)
+        @parser, @code = parser, code
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/parser/treetop_parser.rb

@@ -0,0 +1,73 @@
+require 'treetop'
+require 'gobstones/parser/ast/ast'
+require 'gobstones/parser/parse_error'
+
+module Gobstones
+
+  module Parser
+
+    class TreetopParser
+
+      def initialize
+        Treetop.load grammar_file
+        @parser = GobstonesParser.new
+      end
+
+      def parse(code)
+        code_without_comments = remove_comments_from(code)
+        result = @parser.parse code_without_comments
+        raise ParseError.new(self, code_without_comments) if result.nil?
+        result.value
+      end
+
+      def failure_reason
+        @parser.failure_reason
+      end
+
+      def failure_line
+        @parser.failure_line
+      end
+
+      def failure_column
+        @parser.failure_column
+      end
+
+      def remove_comments_from(code)
+        code
+          .gsub(single_line_c_style_comments_regex, '')
+          .gsub(single_line_haskell_style_comments_regex, '')
+          .gsub(multi_line_c_style_comments_regex, '')
+          .gsub(multi_line_haskell_style_comments_regex, '')
+      end
+
+      private
+
+      def grammar_file
+        File.join base_path, 'grammar/gobstones'
+      end
+
+      def base_path
+        File.expand_path File.dirname(__FILE__)
+      end
+
+      def single_line_c_style_comments_regex
+        /\/\/.*$/
+      end
+
+      def single_line_haskell_style_comments_regex
+        /--.*$/
+      end
+
+      def multi_line_c_style_comments_regex
+        /\/\*.*?\*\//m
+      end
+
+      def multi_line_haskell_style_comments_regex
+        /{-.*?\-}/m
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/runner/all.rb

@@ -0,0 +1,6 @@
+require 'gobstones/runner/board'
+require 'gobstones/runner/cell'
+require 'gobstones/runner/execution_context'
+require 'gobstones/runner/head'
+
+require 'gobstones/runner/errors/all'

data/lib/gobstones/runner/board.rb

@@ -0,0 +1,57 @@
+require 'gobstones/runner/cell'
+
+module Gobstones
+
+  module Runner
+
+    class Board
+
+      attr_reader :rows, :columns
+
+      def initialize(r, c)
+        @rows, @columns = r, c
+        @matrix = []
+        r.times { @matrix << []; c.times { @matrix.last << Cell.new } }
+      end
+
+      def cell_at(x, y)
+        raise OutOfBoardError unless \
+          x.between?(0, rows - 1) && y.between?(0, columns - 1)
+
+        @matrix[x][y]
+      end
+
+      def each_cell
+        @matrix.each { |row| row.each { |cell| yield cell } }
+      end
+
+      def put(x, y, color)
+        cell_at(x, y).put(color)
+      end
+
+      def take_out(x, y, color)
+        cell_at(x, y).take_out(color)
+      end
+
+      def are_there_balls?(x, y, color)
+        cell_at(x, y).are_there_balls?(color)
+      end
+
+      def number_of_balls(x, y, color)
+        cell_at(x, y).number_of_balls(color)
+      end
+
+      def empty!
+        each_cell { |cell| cell.empty! }
+      end
+
+      def empty?
+        each_cell { |cell| return false unless cell.empty? }
+        true
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/runner/cell.rb

@@ -0,0 +1,60 @@
+module Gobstones
+
+  module Runner
+
+    class Cell
+
+      def initialize
+        @values = { Azul => 0, Negro => 0, Rojo => 0, Verde => 0 }
+      end
+
+      def put(color)
+        check color
+        lookup(color) { |value| value + 1 }
+      end
+
+      def take_out(color)
+        check color
+        raise EmptyCellError unless are_there_balls?(color)
+        lookup(color) { |value| value - 1 }
+      end
+
+      def are_there_balls?(color)
+        check color
+        number_of_balls(color) > 0
+      end
+
+      def number_of_balls(color)
+        check color
+        lookup color
+      end
+
+      def empty!
+        initialize
+      end
+
+      def empty?
+        @values.values.all? { |value| value.zero? }
+      end
+
+      private
+
+      def check(color)
+        raise "'#{color}' is not a color" \
+        unless [Azul, Negro, Rojo, Verde].include? color.class
+      end
+
+      def lookup(color)
+        value = @values.keys.detect { |col| col == color.class }
+        if block_given?
+          @values[value] = yield @values[value]
+        else
+          @values[value]
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/runner/errors/all.rb

@@ -0,0 +1,8 @@
+require 'gobstones/runner/errors/boom_error'
+require 'gobstones/runner/errors/definition_not_found_error'
+require 'gobstones/runner/errors/empty_cell_error'
+require 'gobstones/runner/errors/gobstones_runtime_error'
+require 'gobstones/runner/errors/gobstones_type_error'
+require 'gobstones/runner/errors/undefined_variable_error'
+require 'gobstones/runner/errors/out_of_board_error'
+require 'gobstones/runner/errors/wrong_arguments_error'

data/lib/gobstones/runner/errors/boom_error.rb

@@ -0,0 +1,11 @@
+module Gobstones
+
+  module Runner
+
+    class BoomError < StandardError
+
+    end
+
+  end
+
+end

data/lib/gobstones/runner/errors/definition_not_found_error.rb

@@ -0,0 +1,19 @@
+module Gobstones
+
+  module Runner
+
+    class DefinitionNotFound < StandardError
+
+      def self.new(definition_name)
+        super(message_for(definition_name))
+      end
+
+      def self.message_for(definition_name)
+        "definition named '#{definition_name}' not found in program"
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/runner/errors/empty_cell_error.rb

@@ -0,0 +1,11 @@
+module Gobstones
+
+  module Runner
+
+    class EmptyCellError < StandardError
+
+    end
+
+  end
+
+end

data/lib/gobstones/runner/errors/gobstones_runtime_error.rb

@@ -0,0 +1,11 @@
+module Gobstones
+
+  module Runner
+
+    class GobstonesRuntimeError < StandardError
+
+    end
+
+  end
+
+end

data/lib/gobstones/runner/errors/gobstones_type_error.rb

@@ -0,0 +1,11 @@
+module Gobstones
+
+  module Runner
+
+    class GobstonesTypeError < StandardError
+
+    end
+
+  end
+
+end

data/lib/gobstones/runner/errors/out_of_board_error.rb

@@ -0,0 +1,11 @@
+module Gobstones
+
+  module Runner
+
+    class OutOfBoardError < StandardError
+
+    end
+
+  end
+
+end

data/lib/gobstones/runner/errors/undefined_variable_error.rb

@@ -0,0 +1,11 @@
+module Gobstones
+
+  module Runner
+
+    class UndefinedVariableError < StandardError
+
+    end
+
+  end
+
+end

data/lib/gobstones/runner/errors/wrong_arguments_error.rb

@@ -0,0 +1,11 @@
+module Gobstones
+
+  module Runner
+
+    class WrongArgumentsError < StandardError
+
+    end
+
+  end
+
+end

data/lib/gobstones/runner/execution_context.rb

@@ -0,0 +1,89 @@
+require 'gobstones/runner/head'
+
+module Gobstones
+
+  module Runner
+
+    class ExecutionContext
+
+      def initialize
+        @values = {}
+      end
+
+      def set(var_name, value)
+        @values[var_name] = value
+      end
+
+      def get(var_name)
+        @values[var_name] || (raise UndefinedVariableError)
+      end
+
+      def clear(var_name)
+        @values.delete(var_name)
+      end
+
+      def has_variable_named?(name)
+        @values.keys.any? { |var| var.name == name }
+      end
+
+    end
+
+    class ProgramExecutionContext < ExecutionContext
+
+      attr_reader :head
+
+      def self.for(program)
+        self.new program
+      end
+
+      def initialize(program)
+        super()
+        @head = Head.new
+        @program = program
+      end
+
+      def definition_named(name, found_block, not_found_block)
+        found_definition = @program.definitions.find { |definition|
+          definition.named? name
+        }
+        if found_definition
+          found_block.call found_definition
+        else
+          not_found_block.call
+        end
+      end
+
+      def program_context
+        self
+      end
+
+      def board
+        head.board
+      end
+
+    end
+
+    class ProcedureExecutionContext < ExecutionContext
+
+      def self.based_on(outer_context)
+        self.new outer_context
+      end
+
+      def initialize(outer_context)
+        super()
+        @outer_context = outer_context
+      end
+
+      def head
+        @outer_context.head
+      end
+
+      def program_context
+        @outer_context.program_context
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/runner/head.rb

@@ -0,0 +1,101 @@
+require 'gobstones/runner/board'
+
+module Gobstones
+
+  module Runner
+
+    class Head
+
+      MAX_ROWS = 9
+      MAX_COLS = 9
+
+      attr_reader :board, :x_pos, :y_pos
+
+      def self.at_random
+        new.at_random
+      end
+
+      def initialize
+        go_to_origin
+        @board = Board.new MAX_ROWS, MAX_COLS
+      end
+
+      def at_random
+        @x_pos, @y_pos = rand(MAX_ROWS), rand(MAX_COLS)
+        self
+      end
+
+      def can_move?(dir)
+        check dir
+        dir.can_move? self
+      end
+
+      def can_move_north?
+        @y_pos < MAX_COLS-1
+      end
+
+      def can_move_south?
+        @y_pos > 0
+      end
+
+      def can_move_east?
+        @x_pos < MAX_ROWS-1
+      end
+
+      def can_move_west?
+        @x_pos > 0
+      end
+
+      def move(dir)
+        raise OutOfBoardError unless can_move?(dir)
+        dir.move self
+      end
+
+      def move_north
+        @y_pos += 1
+      end
+
+      def move_south
+        @y_pos -= 1
+      end
+
+      def move_east
+        @x_pos += 1
+      end
+
+      def move_west
+        @x_pos -= 1
+      end
+
+      def go_to_origin
+        @x_pos, @y_pos = 0, 0
+      end
+
+      def put(color)
+        @board.put x_pos, y_pos, color
+      end
+
+      def take_out(color)
+        @board.take_out x_pos, y_pos, color
+      end
+
+      def number_of_balls(color)
+        @board.number_of_balls x_pos, y_pos, color
+      end
+
+      def are_there_balls?(color)
+        @board.are_there_balls? x_pos, y_pos, color
+      end
+
+      private
+
+      def check(dir)
+        raise GobstonesTypeError, "#{dir} is not a direction" \
+          unless [Norte, Sur, Este, Oeste].include? dir.class
+      end
+
+    end
+
+  end
+
+end