Ruby (not Rails) attribute validation, saving records and output - ruby

Question

I am implementing Game of Life in Ruby and here is what I have so far:
class Cell
attr_accessor :world, :x, :y
def initialize(world=World.new, x=0, y=0)
#world = world
#world.cells << self
#x = x
#y = y
end
def neighbours
#neighbours = []
world.cells.each do |cell|
# Detects neighbour to the north
if self.x == cell.x && self.y == cell.y - 1
#neighbours << cell
end
# Detects neighbour to the north-east
if self.x == cell.x - 1 && self.y == cell.y - 1
#neighbours << cell
end
# Detects neighbour to the east
if self.x == cell.x - 1 && self.y == cell.y
#neighbours << cell
end
# Detects neighbour to the south-east
if self.x == cell.x - 1 && self.y == cell.y + 1
#neighbours << cell
end
# Detects neighbour to the south
if self.x == cell.x && self.y == cell.y + 1
#neighbours << cell
end
# Detects neighbour to the south-west
if self.x == cell.x + 1 && self.y == cell.y + 1
#neighbours << cell
end
# Detects neighbour to the west
if self.x == cell.x + 1 && self.y == cell.y
#neighbours << cell
end
# Detects neighbour to the north-west
if self.x == cell.x + 1 && self.y == cell.y - 1
#neighbours << cell
end
end
#neighbours
end
def alive?
self.world.cells.include?(self)
end
def dead?
!self.world.cells.include?(self)
end
def die!
self.world.cells.delete(self)
end
def revive!
self.world.cells << self
end
end
class World
attr_accessor :cells
def initialize
#cells = []
end
def tick!
self.cells.each do |cell|
# Rule 1
if cell.neighbours.count < 2
cell.die!
end
end
end
end
I have been coding in Rails for a while but I am confused as to how to do the following things:
validate and make sure only one Cell object can exist on one field in the World?
How to save things to DB (postgresql for example) ? And do I have to in this case or can I just leave it as it and run it in memory?
How to make the graphical output of my Game of life so it looks something like this?
Reason for my confusion is because Rails does this right out of the box and now I just need the help of understanding how Ruby alone does this.
EDIT:
I've updated the Cell class with validation method, but I can only run it after the object is being initialized. Is there a way to run it while initializing? Here's the code:
5 def initialize(world=World.new, x=0, y=0) | 53 neighbour_cell = Cell.new(subject.world, -1, 0)
6 #world = world | 54 subject.neighbours.count.should == 1
7 #world.cells << self # if self.valid? < this after if doesn't work | 55 end
8 #x = x | 56
9 #y = y | 57 it 'Detects cell to the north-west' do
10 end | 58 neighbour_cell = Cell.new(subject.world, -1, 1)
11 | 59 subject.neighbours.count.should == 1
12 def valid? | 60 end
13 #valid = true | 61
14 self.world.cells.each do |cell| | 62 it 'Creates a live cell' do
15 if self.x == cell.x && self.y == cell.y | 63 cell.should be_alive
16 #valid = false | 64 end
17 self.world.cells.delete(self) | 65
18 end | 66 it 'Kills a cell' do
19 end | 67 cell.die!
20 #valid | 68 cell.should be_dead
21 end

Answer 1

It's good that you're breaking out of Rails and trying something different, especially a classic challenge like the Game of Life.
As for your questions, they all depend on the system design that you choose. But for a simple implementation here's a few pointers.
How about using the Set class? This is an array of objects that allows no duplicates.
You only need a DB if you want to maintain the state between separate runs of the application. If you don't need that, just keep it all in memory.
This is too big a question to answer here, but you have many options. The extremes are:
managing screen updates pixel rendering yourself, printing characters to the terminal as the cells change
using something like rubygame, which has a concept of sprites, GUIs and drawing

Answer 2

You are asking some big, general questions here, and each of them have many answers. I'll give my initial take on each:
1: Validation - It seems like (coming from rails) you want to have some kind of method like valid? that you can call on your objects. In pure ruby, though, you have to define explicitly what a "valid" object really is. You also have to decide where your validation should take place, i.e. which object is doing the validation and which object is being validated.
From the code presented above, I'd suggest that you need at least one more class, call it Game for example, which controls the world and all of the cells in it. Currently, you've loaded a lot of logic into the Cell class, and you might want to review the single responsibility principle to see if this is a valid (ha ha) design choice.
2. Persistence - There's nothing stopping you from using ActiveRecord in pure ruby as your ORM. You could check out this SO question for an example implementation: how-to-use-active-record-without-rails.
3. Graphics - There are a number of game libraries for ruby which have built-in graphics APIs for whichever platform you are on. I've not worked with them much personally, but gosu seems like a good option.

Answer 3

I have done it! But not with the approach taken here. Here is my code below, the only thing left to do is implement some graphic output. Also, here is the whole code on Github, check it out and comment and help me improve it and stuff. Thank you both for helping me :)
I could refactor this 'live_neighbours_around_cell(cell)' method, but don't know how. Can you help with that? Also, it would be useful to add 'Cell.new' immediately to 'cells' array and not like I do now where I have separate function for that.
class Game
attr_accessor :world
def initialize(world=World.new, seeds=[[1, 1]])
#world = world
seeds.each do |seed|
world.cell_board[seed[0]][seed[1]].alive = true
end
end
def tick!
next_round_live_cells = []
next_round_dead_cells = []
world.cells.each do |cell|
# Rule 1:
# Any live cell with fewer than two live neighbours dies
if world.live_neighbours_around_cell(cell).count < 2
next_round_dead_cells << cell
end
# Rule 2:
# Any live cell with two or three live neighbours lives on to the next generation
if cell.alive? && world.live_neighbours_around_cell(cell).count == (2 || 3)
next_round_live_cells << cell
end
# Rule 3:
# Any live cell with more than three live neighbours dies
if cell.alive? && world.live_neighbours_around_cell(cell).count > 3
next_round_dead_cells << cell
end
# Rule 4:
# Any dead cell with exactly three live neighbours becomes a live cell
if cell.dead? && world.live_neighbours_around_cell(cell).count == 3
next_round_live_cells << cell
end
end
next_round_live_cells.each do |cell|
cell.revive!
end
next_round_dead_cells.each do |cell|
cell.die!
end
end
end
class World
attr_accessor :rows, :cols, :cell_board, :cells
# Scheme of default initialized world matrix
#------------------------
# 0 1 2
# 0 [ dead, dead, dead ]
# 1 [ dead, alive, dead ]
# 2 [ dead, dead, dead ]
#-----------------------
def initialize(rows=3, cols=3)
#rows = rows
#cols = cols
#cells = []
#cell_board = Array.new(rows) do |row|
Array.new(cols) do |col|
Cell.new(row, col)
end
end
cell_board.each do |row|
row.each do |element|
if element.is_a?(Cell)
cells << element
end
end
end
end
def live_cells
cells.select { |cell| cell.alive }
end
def live_neighbours_around_cell(cell)
live_neighbours = []
live_cells.each do |live_cell|
# Neighbour to the North
if live_cell.x == cell.x - 1 && live_cell.y == cell.y
live_neighbours << live_cell
end
# Neighbour to the North-East
if live_cell.x == cell.x - 1 && live_cell.y == cell.y + 1
live_neighbours << live_cell
end
# Neighbour to the East
if live_cell.x == cell.x && live_cell.y == cell.y + 1
live_neighbours << live_cell
end
# Neighbour to the South-East
if live_cell.x == cell.x + 1 && live_cell.y == cell.y + 1
live_neighbours << live_cell
end
# Neighbour to the South
if live_cell.x == cell.x + 1 && live_cell.y == cell.y
live_neighbours << live_cell
end
# Neighbour to the South-West
if live_cell.x == cell.x + 1 && live_cell.y == cell.y - 1
live_neighbours << live_cell
end
# Neighbour to the West
if live_cell.x == cell.x && live_cell.y == cell.y - 1
live_neighbours << live_cell
end
# Neighbour to the North-West
if live_cell.x == cell.x - 1 && live_cell.y == cell.y - 1
live_neighbours << live_cell
end
end
live_neighbours
end
end
class Cell
attr_accessor :x, :y, :alive
def initialize(x=0, y=0)
#x = x
#y = y
#alive = false
end
def alive?
alive
end
def dead?
!alive
end
def die!
#alive = false
end
def revive!
#alive = true # same as > self.alive = true
end
end