ruby-stones 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5e91e5b19b7e1af7d13c7d8188306f6d61ccfa11
+  data.tar.gz: af406f7c45f5acd829b2693d8e9413d8b08cf3aa
+SHA512:
+  metadata.gz: 846d8f203ad7d55bf298883aabe507462f9c7002dd00d0b7f6ff90e884724ee655f79cfe4f65242bb2e00e7e78149b3360421bbdcf80f7c34f58d0b02efe01e9
+  data.tar.gz: 22edef2eac5e62bc4d6fd7ec3fd8224488b32e5322ed4561e8e6599ef982271e137de161127a925ebb195c88595e9aaadf664441fea72a12a5d66bb4b28edfaf

data/bin/stones

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+if ARGV.size != 3
+  puts 'Not enough arguments. Must pass program file, input board file and output board file'
+  exit 1
+end
+
+program = File.read ARGV[0]
+input_gbb = File.read ARGV[1]
+output_gbb_file = ARGV[2]
+
+require 'stones'
+
+Main = Class.new
+Main.class_eval do
+  include Stones::Program
+  eval program
+end
+
+context = Stones::ExecutionContext.new
+context.board = Stones::Gbb.read input_gbb
+context.run Main
+File.write output_gbb_file, Stones::Gbb.write(context.board)

data/lib/extensions/array.rb

@@ -0,0 +1,5 @@
+class Array
+  def init(n=1)
+    take size - n
+  end
+end

data/lib/stones.rb

@@ -0,0 +1,10 @@
+module Stones
+end
+
+require_relative 'stones/direction'
+require_relative 'stones/color'
+require_relative 'stones/board'
+require_relative 'stones/execution_context'
+require_relative 'stones/program'
+require_relative 'stones/gbb'
+require_relative 'stones/version'

data/lib/stones/board.rb

@@ -0,0 +1,78 @@
+require_relative './board/with_head'
+require_relative './board/with_stones'
+
+module Stones
+  class OutOfBoardError < RuntimeError
+  end
+
+  class Board
+    include WithHead
+    include WithStones
+
+    attr_reader :cells, :head_position
+
+    def initialize(cells, position)
+      @cells = cells
+      @head_position = position
+    end
+
+    def size
+      [cells[0].size, cells.size]
+    end
+
+    def ==(other)
+      self.class == other.class &&
+          self.cells == other.cells &&
+          self.head_position == other.head_position
+    end
+
+    def hash
+      self.cells.hash ^ self.head_position.hash
+    end
+
+    def self.empty(x, y, position=[0, 0])
+      self.new(empty_cells(x, y), position)
+    end
+
+    def self.from(cells, position=[0, 0])
+      self.new(cells.map { |row| row.map { |cell| empty_cell.merge(cell) } }, position)
+    end
+
+    private
+
+    def each_cell
+      (0..(size[0]-1)).each do |x|
+        (0..(size[1]-1)).each do |y|
+          yield cell_at([x, y]), x, y
+        end
+      end
+    end
+
+    def cell_at(position)
+      raise OutOfBoardError unless within_bounds? position
+      cells[-(position[1]+1)][position[0]]
+    end
+
+    def set_cell(position, cell)
+      cell_at(position).merge! cell
+    end
+
+    def within_bounds?(position)
+      (x, y) = size
+      position[0] >= 0 && position[1] >= 0 &&
+          position[0] < x && position[1] < y
+    end
+
+    def head_cell
+      cell_at(head_position)
+    end
+
+    def self.empty_cell
+      {red: 0, black: 0, green: 0, blue: 0}
+    end
+
+    def self.empty_cells(x, y)
+      (1..y).map { (1..x).map { empty_cell } }
+    end
+  end
+end

data/lib/stones/board/with_head.rb

@@ -0,0 +1,27 @@
+module Stones
+  module WithHead
+    def can_move?(direction)
+      within_bounds? next_position(direction)
+    end
+
+    def move!(direction)
+      move_to! next_position(direction)
+    end
+
+    def move_to_edge!(direction)
+      move!(direction) while can_move?(direction)
+    end
+
+    private
+
+    def move_to!(position)
+      raise OutOfBoardError unless within_bounds? position
+      @head_position = position
+    end
+
+    def next_position(direction)
+      direction.call(*@head_position)
+    end
+
+  end
+end

data/lib/stones/board/with_stones.rb

@@ -0,0 +1,24 @@
+module Stones
+  module WithStones
+    def push!(color, amount=1)
+      head_cell[color] += amount
+    end
+
+    def pop!(color)
+      raise "#{color} Underflow" if head_cell[color] == 0
+      head_cell[color] -= 1
+    end
+
+    def clear!
+      @cells = self.class.empty_cells(*size)
+    end
+
+    def count(color)
+      head_cell[color]
+    end
+
+    def exist?(color)
+      count(color) > 0
+    end
+  end
+end

data/lib/stones/color.rb

@@ -0,0 +1,25 @@
+module Stones
+  module Color
+    def red
+      :red
+    end
+
+    def blue
+      :blue
+    end
+
+    def green
+      :green
+    end
+
+    def black
+      :black
+    end
+
+    def self.all
+      [red, green, black, blue]
+    end
+
+    module_function :red, :blue, :green, :black
+  end
+end

data/lib/stones/direction.rb

@@ -0,0 +1,25 @@
+module Stones
+  module Direction
+    def east
+      @east ||= -> (x, y) { [x+1, y] }
+    end
+
+    def west
+      @west ||= -> (x, y) { [x-1, y] }
+    end
+
+    def north
+      @north ||= -> (x, y) { [x, y+1] }
+    end
+
+    def south
+      @south ||= -> (x, y) { [x, y-1] }
+    end
+
+    def self.all
+      [east, west, south, north]
+    end
+
+    module_function :north, :south, :east, :west
+  end
+end

data/lib/stones/execution_context.rb

@@ -0,0 +1,11 @@
+module Stones
+  class ExecutionContext
+    attr_accessor :board
+
+    def run(program_class)
+      program = program_class.new
+      program.board = board
+      program.main
+    end
+  end
+end

data/lib/stones/gbb.rb

@@ -0,0 +1,14 @@
+require_relative './gbb/gbb_reader'
+require_relative './gbb/gbb_writer'
+
+module Stones
+  module Gbb
+    def self.read(gbb)
+      GbbReader.new.from_string(gbb)
+    end
+
+    def self.write(board)
+      GbbWriter.write(board)
+    end
+  end
+end

data/lib/stones/gbb/gbb_reader.rb

@@ -0,0 +1,52 @@
+require_relative '../../extensions/array.rb'
+
+
+class MatchData
+  def to_position
+    [self[1].to_i, self[2].to_i]
+  end
+end
+
+module Stones
+  class GbbReader
+    COLORS = {'Azul' => :blue, 'Negro' => :black, 'Rojo' => :red, 'Verde' => :green}
+
+    def from_string(gbb_string)
+      board = nil
+
+      lines = gbb_string.lines.reject { |it| it.start_with? 'GBB', '%%' }
+
+      /size (\d+) (\d+)/.match(lines[0]) { |match| board = Board.empty(match[1].to_i, match[2].to_i) }
+      /head (\d+) (\d+)/.match(lines.last) { |match| board.send :move_to!, match.to_position }
+
+      lines.drop(1).init.each do |cell_line|
+        position = get_position_from cell_line
+        cell = create_cell_from cell_line
+
+        board.send :set_cell, position, cell
+      end
+
+      board
+    end
+
+    private
+
+    def get_position_from(cell_line)
+      /cell (\d+) (\d+)/.match(cell_line).to_position
+    end
+
+    def create_cell_from(cell_line)
+      cell = {}
+
+      cell_line.scan(/(Azul|Negro|Rojo|Verde) (\d+)/) do |match|
+        cell[to_color(match[0])] = match[1].to_i
+      end
+
+      cell
+    end
+
+    def to_color(gbb_color_string)
+      COLORS[gbb_color_string]
+    end
+  end
+end

data/lib/stones/gbb/gbb_writer.rb

@@ -0,0 +1,37 @@
+module Stones
+  module GbbWriter
+    def self.write(board)
+      "GBB/1.0\n" +
+      "size #{board.size[0]} #{board.size[1]}\n" +
+      "#{write_cells board}" +
+      "head #{board.head_position[0]} #{board.head_position[1]}"
+    end
+
+    private
+
+    def self.write_cells(board)
+      cells_gbb = ''
+
+      board.send :each_cell do |cell, x, y|
+        cell = cell.select { |color, count| count > 0 }
+        next if cell.empty?
+        cells_gbb << "cell #{x} #{y} #{write_colors cell}\n"
+      end
+
+      cells_gbb
+    end
+
+    def self.write_colors(cell)
+      cell.map { |color, count| "#{to_gbb_color color} #{count}" }.join(' ')
+    end
+
+    def self.to_gbb_color(color)
+      case color
+        when :red then 'Rojo'
+        when :green then 'Verde'
+        when :black then 'Negro'
+        when :blue then 'Azul'
+      end
+    end
+  end
+end

data/lib/stones/program.rb

@@ -0,0 +1,48 @@
+module Stones
+  module Program
+    attr_accessor :board
+
+    include Stones::Color
+    include Stones::Direction
+
+    def move!(direction)
+      board.move!(direction)
+    end
+
+    def move_to_edge!(direction)
+      board.move_to_edge!
+    end
+
+    def can_move?(direction)
+      board.can_move?(direction)
+    end
+
+    def push!(color)
+      board.push!(color)
+    end
+
+    def pop!(color)
+      board.pop!(color)
+    end
+
+    def clear!
+      board.clear!
+    end
+
+    def count(color)
+      board.count(color)
+    end
+
+    def exist?(color)
+      board.exists?(color)
+    end
+
+    def colors
+      Color.all
+    end
+
+    def directions
+      Direction.all
+    end
+  end
+end

data/lib/stones/version.rb

@@ -0,0 +1,3 @@
+module Stones
+  VERSION = '0.0.5'
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: ruby-stones
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Federico Aloi
+- Franco Bulgarelli
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-01 00:00:00.000000000 Z
+dependencies:
+- !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: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !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'
+description: Write Gobstones program within Ruby
+email:
+- federico.aloi@gmail.com
+- flbulgarelli@yahoo.com.ar
+executables:
+- stones
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/stones
+- lib/extensions/array.rb
+- lib/stones.rb
+- lib/stones/board.rb
+- lib/stones/board/with_head.rb
+- lib/stones/board/with_stones.rb
+- lib/stones/color.rb
+- lib/stones/direction.rb
+- lib/stones/execution_context.rb
+- lib/stones/gbb.rb
+- lib/stones/gbb/gbb_reader.rb
+- lib/stones/gbb/gbb_writer.rb
+- lib/stones/program.rb
+- lib/stones/version.rb
+homepage: https://github.com/uqbar-project/ruby-stones
+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.2.0
+signing_key: 
+specification_version: 4
+summary: Pure ruby library that implements a Gobstones-like board and dsl
+test_files: []