game-of-life 0.1.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NTdhOTY3OTFmZWFjZTdhM2IwNzc5MzliMTY4NTBkOWFiM2IxMGE1Nw==
+  data.tar.gz: !binary |-
+    ZTc2ZDBlNjM5OTBlOGJjYzczMjYyYTZjM2U3ZDJiY2RiMjNiY2NkMw==
+SHA512:
+  metadata.gz: !binary |-
+    ZmU2NDQ4YzU1OGEyYzY4YmEwNzI3MTU4YjliZjAyMjFlNWU4NGEwMzc1MzYz
+    YzRjNzhiZTY3YzEzYzI5OWE2OGY5OTUxNTU3MWY2M2JlZDM1YWQ0MDdmMzI3
+    MDBjYzAzMzE5OTdiMjc5OWI5MjZjNmZiZWY0ODk0MjQ3MjBkYzM=
+  data.tar.gz: !binary |-
+    NDc3YTQxNjE2ZWFmZDk1ZjdhNjA3YjhmNjMxMmIxNTc5MGVmNGY1YzkwZWUw
+    NzY0ZDBlMjE4MzRmN2UzZDY3YTUwY2RmZDU4MzU3NDcyYTdkNzQ3Y2EwNWI0
+    MjI4MjVlOGFmMjBhOTI3ZGEzMTY2NWRlYTQ0YWYzNjgzNzk3Zjg=

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3-p448

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,18 @@
+PATH
+  remote: .
+  specs:
+    game-of-life (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    gosu (0.7.50)
+    rake (0.9.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  game-of-life!
+  gosu
+  rake

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/bin/game-of-life

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/game_of_life'
+
+raise RubyVersionException unless RUBY_VERSION == "1.9.3"
+
+GameOfLife::GameOfLifeWindow.new(800,600).show
+

data/game-of-life.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'game-of-life/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "game-of-life"
+  gem.version       = GameOfLife::VERSION
+  gem.authors       = ["Thiago Rocha"]
+  gem.email         = ["kimo@kimo.io"]
+  gem.description   = %q{The Game of Life}
+  gem.summary       = %q{A gem that shows random matches of Conway's Game of Life }
+  gem.homepage      = "http://thiagokimo.github.io/game-of-life"
+
+  gem.license = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.add_development_dependency 'rake'
+
+  gem.add_dependency 'gosu'
+end

data/lib/game-of-life/cell.rb

@@ -0,0 +1,33 @@
+module GameOfLife
+  class Cell
+    attr_accessor :x, :y, :alive, :neighbours
+    def initialize(x=0,y=0,alive=true)
+      @x,@y = x,y
+      @alive = alive
+    end
+
+    def ==(otherCell)
+      (self.x == otherCell.x) and (self.y == otherCell.y)
+    end
+
+    def neighbours
+      []
+    end
+
+    def alive?
+      self.alive
+    end
+
+    def dead?
+      not alive?
+    end
+
+    def reborn!
+      @alive = true
+    end
+
+    def die!
+      @alive = false
+    end
+  end
+end

data/lib/game-of-life/exceptions.rb

@@ -0,0 +1,2 @@
+class GameOfLifeException < StandardError ; end
+class RubyVersionException < GameOfLifeException ; end

data/lib/game-of-life/version.rb

@@ -0,0 +1,6 @@
+module GameOfLife
+  MAJOR = 0
+  MINOR = 1
+  PATCH = 1
+  VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}"
+end

data/lib/game-of-life/world.rb

@@ -0,0 +1,316 @@
+require 'matrix'
+
+module GameOfLife
+  class World
+    attr_accessor :cells, :board
+
+    def initialize(width,height)
+      @width, @height = width, height
+      setup(false)
+    end
+
+    def seed!
+      clean_cells
+      setup(true)
+    end
+
+    def live_cells
+      @cells.select { |cell| cell.alive? }
+    end
+
+    def dead_cells
+      @cells.select { |cell| cell.dead? }
+    end
+
+    def kill(x,y)
+      @board.element(x,y).die!
+    end
+
+    def get(x,y)
+      @board.element(x,y)
+    end
+
+    def revive(x,y)
+      @board.element(x,y).reborn!
+    end
+
+    def live_neighbours_of(x,y)
+      live_neighbours = []
+
+      # up-left
+      if x-1 >= 0 and y+1 <= @height-1
+        neighbour = get(x-1,y+1)
+        live_neighbours << neighbour if neighbour.alive?
+      end
+
+      # up
+      if y+1 <= @height-1
+        neighbour = get(x,y+1)
+        live_neighbours << neighbour if neighbour.alive?
+      end
+
+      # up-right
+      if x+1 <= @width-1 and y+1 <= @height-1
+        neighbour = get(x+1,y+1)
+        live_neighbours << neighbour if neighbour.alive?
+      end
+
+      # left
+      if x-1 >= 0
+        neighbour = get(x-1,y)
+        live_neighbours << neighbour if neighbour.alive?
+      end
+
+      # right
+      if x+1 <= @width-1
+        neighbour = get(x+1,y)
+        live_neighbours << neighbour if neighbour.alive?
+      end
+
+      # down-left
+      if x-1 >= 0 and y-1 >= 0
+        neighbour = get(x-1,y-1)
+        live_neighbours << neighbour if neighbour.alive?
+      end
+
+      # down
+      if y-1 >= 0
+        neighbour = get(x,y-1)
+        live_neighbours << neighbour if neighbour.alive?
+      end
+
+      # down-right
+      if x+1 <= @width-1 and y-1 >= 0
+        neighbour = get(x+1,y-1)
+        live_neighbours << neighbour if neighbour.alive?
+      end
+
+      live_neighbours
+    end
+
+    def rotate!
+      future_alive_cells = []
+      future_dead_cells = []
+
+      @cells.each do |cell|
+        live_neighbours = live_neighbours_of(cell.x,cell.y)
+
+        future_dead_cells << cell if apply_rule_1(cell,live_neighbours)
+        future_alive_cells << cell if apply_rule_2(cell,live_neighbours)
+        future_dead_cells << cell if apply_rule_3(cell,live_neighbours)
+        future_alive_cells << cell if apply_rule_4(cell,live_neighbours)
+      end
+
+      update_board(future_alive_cells,future_dead_cells)
+      update_cells
+    end
+
+    private
+    def apply_rule_1(cell,live_neighbours)
+      cell.alive? and live_neighbours.count < 2
+    end
+
+    def apply_rule_2(cell,live_neighbours)
+      cell.alive? and (live_neighbours.count == 2 or live_neighbours.count == 3)
+    end
+
+    def apply_rule_3(cell,live_neighbours)
+      cell.alive? and live_neighbours.count > 3
+    end
+
+    def apply_rule_4(cell,live_neighbours)
+      cell.dead? and live_neighbours.count == 3
+    end
+
+    def rebuild_board(live_cells,dead_cells)
+      (live_cells+dead_cells).each do |cell|
+        @board.set(cell.x,cell.y,cell)
+      end
+    end
+
+    def setup(random)
+      @board = Matrix.build(@width, @height) { |row,column|
+        if random
+          cell = Cell.new(row,column,[true,false].sample)
+        else
+          cell = Cell.new(row,column)
+        end
+      }
+
+      update_cells
+    end
+
+    def update_board(to_live,to_die)
+      to_live.each do |cell|
+        revive(cell.x,cell.y)
+      end
+      to_die.each do |cell|
+        kill(cell.x,cell.y)
+      end
+    end
+
+    def update_cells
+      @cells = @board.to_a.flatten!
+    end
+
+    def clean_cells
+      @cells = nil
+      @board = nil
+    end
+  end
+  # class World
+  #   attr_accessor :cells, :board
+  #   attr_reader :width, :height
+
+  #   def initialize(width=10, height=10, allow_negative_cells=true)
+  #     @width, @height = width, height
+  #     @negative = allow_negative_cells
+  #     @cells = []
+
+  #     setup_board
+  #   end
+
+  #   def dead_cells
+  #     @cells.select { |cell| cell.dead? }
+  #   end
+
+  #   def live_cells
+  #     @cells.select { |cell| cell.alive? }
+  #   end
+
+  #   def seed!
+  #     for x in (0).upto(@width-1) do
+  #       for y in (0).upto(@height-1) do
+  #         cell = Cell.new(x,y,[true,false].sample)
+  #         @cells << cell
+  #         @board[x][y] = cell
+  #       end
+  #     end
+  #   end
+
+  #   # up_left   | up   | up_right
+  #   # ----------|------|-----------
+  #   # left      | cell | right
+  #   # ----------|------|-----------
+  #   # down_left | down | down_right
+  #   def live_neighbours_of(cell)
+  #     live_neighbours = []
+
+  #     up_left = Cell.new(cell.x-1,cell.y+1)
+  #     up = Cell.new(cell.x,cell.y+1)
+  #     up_right = Cell.new(cell.x+1,cell.y+1)
+  #     left = Cell.new(cell.x-1,cell.y)
+  #     right = Cell.new(cell.x+1,cell.y)
+  #     down_left = Cell.new(cell.x-1,cell.y-1)
+  #     down = Cell.new(cell.x,cell.y-1)
+  #     down_right = Cell.new(cell.x+1,cell.y-1)
+
+  #     neighbour_candidates = [up_left,up,up_right,left,right,down_left,down,down_right]
+
+  #     neighbour_candidates.each do |neighbour|
+  #       live_neighbours << @board[neighbour.x][neighbour.y] if not outside_of_the_world?(neighbour) and neighbour.alive?
+  #     end
+
+  #     live_neighbours
+  #   end
+
+  #   def exist?(cell)
+  #     @cells.include? cell
+  #   end
+
+  #   def rotate!
+  #     future_alive_cells = []
+  #     future_dead_cells = []
+
+  #     @cells.each do |cell|
+  #       num_live_neighbours = live_neighbours_of(cell).count
+
+  #       # Rule #1
+  #       if cell.alive? and num_live_neighbours < 2
+  #         future_dead_cells << cell
+  #       end
+
+  #       # Rule #2
+  #       if live_neighbours_of(cell).count == 2 or live_neighbours_of(cell).count == 3
+  #         future_alive_cells << cell
+  #       end
+
+  #       # Rule #3
+  #       if cell.alive? and num_live_neighbours > 3
+  #         future_dead_cells << cell
+  #       end
+
+  #       # Rule #4
+  #       if cell.dead? and num_live_neighbours == 3
+  #         future_alive_cells << cell
+  #       end
+
+  #       update_cells(future_alive_cells,future_dead_cells)
+  #     end
+  #   end
+
+  #   def create(cell)
+  #     # raise CellAlreadyExistsInTheWorldException if exist?(cell)
+  #     raise CellInvalidCoordinatesException if outside_of_the_world?(cell) or negative_coordinates?(cell)
+  #     @cells << cell
+  #   end
+
+  #   def revive(cell)
+  #     raise CellIsAlreadyAliveException if exist?(cell) and cell.alive?
+  #     cell.reborn!
+  #   end
+
+  #   def kill(cell)
+  #     raise CellIsAlreadyDeadException if exist?(cell) and cell.dead?
+  #     cell.die!
+  #   end
+
+  #   private
+    # def setup_board
+    #   @board = Array.new(@width) do |row|
+    #     Array.new(@height) do |column|
+    #       Cell.new(row,column)
+    #     end
+    #   end
+
+    #   @board.each do |row|
+    #     row.each do |column|
+    #       @cells << column
+    #     end
+    #   end
+    # end
+
+  #   def update_cells(alives,deads)
+  #     alives.each do |cell|
+  #       cell.reborn!
+  #     end
+  #     deads.each do |cell|
+  #       cell.die!
+  #     end
+  #   end
+
+  #   def apply_rule_1(cell,number_of_live_neighbours)
+  #     kill(cell) if cell.alive? and number_of_live_neighbours < 2
+  #   end
+
+  #   def apply_rule_2(cell)
+  #     # revive(cell) if live_neighbours_of(cell).count == 2 or live_neighbours_of(cell).count == 3
+  #   end
+
+  #   def apply_rule_3(cell,number_of_live_neighbours)
+  #     kill(cell) if cell.alive? and number_of_live_neighbours > 3
+  #   end
+
+  #   def apply_rule_4(cell,number_of_live_neighbours)
+  #     revive(cell) if cell.dead? and number_of_live_neighbours == 3
+  #   end
+
+  #   def outside_of_the_world?(cell)
+  #     (cell.x > @width) or (cell.y > @height)
+  #   end
+
+  #   def negative_coordinates?(cell)
+  #     (cell.x < 0) or (cell.y < 0) and not @negative
+  #   end
+  # end
+end

data/lib/game_of_life.rb

@@ -0,0 +1,60 @@
+require_relative 'game-of-life/exceptions'
+require_relative 'game-of-life/cell'
+require_relative 'game-of-life/world'
+require_relative 'game-of-life/version'
+require 'gosu'
+
+module GameOfLife
+  class GameOfLifeWindow < Gosu::Window
+    def initialize(width=640, height=480)
+      @width, @height = width, height
+      super(@width, @height, false)
+      self.caption = 'The Game of Life'
+
+      # Variables
+      @num_columns = @width/5
+      @num_rows = @height/5
+      @column_width = @width/@num_columns
+      @row_height = @height/@num_rows
+
+      @white_color = Gosu::Color.new(0xffffffff)
+      @black_color = Gosu::Color.new(0xff000000)
+      @dead_color = Gosu::Color.new(0xff808080)
+
+      @world = World.new(@num_columns,@num_rows)
+      @world.seed!
+    end
+
+    def update
+      @world.rotate!
+    end
+
+    def draw
+      draw_cells
+    end
+
+    def needs_cursor?
+      true
+    end
+
+    def draw_cells
+      @world.cells.each do |cell|
+        if cell.alive?
+          draw_quad(
+            cell.x * @column_width, cell.y * @row_height, @white_color,
+            cell.x * @column_width + @column_width, cell.y * @row_height, @white_color,
+            cell.x * @column_width + @column_width, cell.y * @row_height + @row_height, @white_color,
+            cell.x * @column_width, cell.y * @row_height + @row_height, @white_color
+          )
+        else
+          draw_quad(
+            cell.x * @column_width, cell.y * @row_height, @black_color,
+            cell.x * @column_width + @column_width, cell.y * @row_height, @black_color,
+            cell.x * @column_width + @column_width, cell.y * @row_height + @row_height, @black_color,
+            cell.x * @column_width, cell.y * @row_height + @row_height, @black_color
+          )
+        end
+      end
+    end
+  end
+end

data/test/lib/game-of-life/cell_test.rb

@@ -0,0 +1,62 @@
+require_relative '../../test_helper'
+
+module GameOfLife
+  describe Cell do
+    describe "coordinates" do
+      it "coordinates" do
+        cell = Cell.new
+        cell.x.wont_be_nil
+        cell.y.wont_be_nil
+      end
+      it "should store coordinates" do
+        random_x = rand(11)
+        random_y = rand(11)
+
+        cell = Cell.new(random_x,random_y)
+
+        cell.x.must_equal random_x
+        cell.y.must_equal random_y
+      end
+    end
+
+    describe "==" do
+      it "should be true if 2 cells has the same coordinates" do
+        cell_1 = Cell.new(1,2)
+        cell_2 = Cell.new(1,2)
+
+        cell_1.must_equal cell_2
+      end
+
+      it "should be false if 2 cells has different coordinates" do
+        cell_1 = Cell.new(1,2)
+        cell_2 = Cell.new(2,1)
+
+        cell_1.wont_equal cell_2
+      end
+    end
+
+    it "should be able to die" do
+      cell = Cell.new
+
+      cell.die!
+      cell.dead?.must_equal true
+    end
+
+    it "should be able to reborn" do
+      cell = Cell.new(0,0,false)
+
+      cell.reborn!
+      cell.alive?.must_equal true
+    end
+
+    it "should be dead or alive" do
+      cell = Cell.new
+      cell.alive.wont_be_nil
+    end
+
+    it "must have neighbours cells" do
+      cell = Cell.new
+      cell.neighbours.wont_be_nil
+    end
+  end
+end

data/test/lib/game-of-life/world_test.rb

@@ -0,0 +1,85 @@
+require_relative '../../test_helper'
+
+module GameOfLife
+  describe World do
+    describe "#initialize" do
+      it "should have a collection of cells" do
+        world = World.new(1,1)
+
+        world.cells.wont_be_nil
+      end
+
+      it "number of cells must be its width multiplied per its height" do
+        world = World.new(5,3)
+        world.cells.count.must_equal 5*3
+      end
+
+      it "must setup a matrix of cells, that represents the game board" do
+        world = World.new(3,3)
+
+        world.board.must_be_kind_of(Matrix)
+      end
+    end
+
+    it "should be able to randomize some cells" do
+      world = World.new(10,10)
+
+      world.seed!
+
+      world.live_cells.count.must_be(:>,0)
+      world.dead_cells.count.must_be(:>,0)
+    end
+
+    describe "#live_neighbours_of" do
+      it "should be able to count the live neighbours of a cell" do
+        world = World.new(3,3)
+
+        world.kill(0,0)
+        world.kill(1,0)
+
+        world.live_neighbours_of(1,1).count.must_equal 6
+      end
+
+      it "the cell (0,0) must have only 3 live neighbours" do
+        world = World.new(3,3)
+
+        world.live_neighbours_of(0,0).count.must_equal 3
+      end
+    end
+
+    describe "#make_it_live" do
+      it "should be able to make a dead cell live" do
+        world = World.new(2,2)
+
+        world.kill(1,1)
+        world.get(1,1).dead?.must_equal true
+
+        world.revive(1,1)
+        world.get(1,1).dead?.must_equal false
+      end
+    end
+
+    describe "#get" do
+      it "should return a given cell" do
+        world = World.new(2,2)
+
+        cell_to_be_found = Cell.new(1,1)
+
+        found_cell = world.get(1,1)
+
+        found_cell.must_equal cell_to_be_found
+      end
+    end
+
+    describe "#kill" do
+      it "should be able to kill a cell" do
+        world = World.new(2,2)
+
+        world.dead_cells.count.must_equal 0
+        world.kill(1,1)
+
+        world.dead_cells.count.must_equal 1
+      end
+    end
+  end
+end

data/test/rules/first_rule_test.rb

@@ -0,0 +1,35 @@
+require_relative '../test_helper'
+
+module GameOfLife
+  describe "Rule #1: Any live cell with fewer than two live neighbours dies, as if caused by under-population." do
+    it "cells with 1 neighbour dies in the next day" do
+      world = World.new(2,2)
+
+      world.kill(0,0)
+      world.kill(1,1)
+
+      world.rotate!
+
+      world.cells.each do |cell|
+        cell.dead?.must_equal true
+      end
+    end
+
+    it "a cell with no live neighbours should die in the next day" do
+      world = World.new(3,3)
+
+      world.kill(0,0)
+      world.kill(1,0)
+      world.kill(2,0)
+      world.kill(0,1)
+      world.kill(2,1)
+      world.kill(0,2)
+      world.kill(1,2)
+      world.kill(2,2)
+
+      world.rotate!
+
+      world.get(1,1).dead?.must_equal true
+    end
+  end
+end

data/test/rules/fourth_rule_test.rb

@@ -0,0 +1,24 @@
+require_relative '../test_helper'
+
+module GameOfLife
+  describe "Rule #4: Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction." do
+    it "a dead cell with 3 live neighbours will reborn in the next day" do
+      world = World.new(3,3)
+
+      # (0,2) (1,2) (2,2)
+      # (0,1) (1,1) (2,1)
+      # (0,0) (1,0) (2,0)
+
+      world.kill(1,2)
+      world.kill(2,2)
+      world.kill(2,1)
+      world.kill(2,0)
+      world.kill(1,0)
+      world.kill(1,1)
+
+      world.rotate!
+
+      world.get(1,1).alive?.must_equal true
+    end
+  end
+end

data/test/rules/second_rule_test.rb

@@ -0,0 +1,33 @@
+require_relative '../test_helper'
+
+module GameOfLife
+  describe "Rule #2: Any live cell with two or three live neighbours lives on to the next generation." do
+    it "a cell with 2 live neighbours will be alive in the next day" do
+      world = World.new(3,3)
+
+      world.kill(0,2)
+      world.kill(1,2)
+      world.kill(2,2)
+      world.kill(0,0)
+      world.kill(1,0)
+      world.kill(2,0)
+
+      world.rotate!
+
+      world.get(1,1).alive?.must_equal true
+    end
+
+    it "a cell with 3 live neighbours will be alive in the next day" do
+      world = World.new(3,3)
+
+      world.kill(1,1)
+      world.kill(2,1)
+      world.kill(1,0)
+      world.kill(2,0)
+
+      world.rotate!
+
+      world.get(0,2).alive?.must_equal true
+    end
+  end
+end

data/test/rules/third_rule_test.rb

@@ -0,0 +1,26 @@
+require_relative '../test_helper'
+
+module GameOfLife
+  describe "Rule #3: Any live cell with more than three live neighbours dies, as if by overcrowding." do
+    it "a cell with 4 live neighbours will die in the next day" do
+      world = World.new(3,3)
+
+      world.kill(0,2)
+      world.kill(1,2)
+      world.kill(2,2)
+      world.kill(2,0)
+
+      world.rotate!
+
+      world.get(1,1).dead?.must_equal true
+    end
+
+    it "a cell surrounded by live neighbours must die in the next day" do
+      world = World.new(3,3)
+
+      world.rotate!
+
+      world.get(1,1).dead?.must_equal true
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'minitest/autorun'
+require File.expand_path('../../lib/game_of_life.rb', __FILE__)

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: game-of-life
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Thiago Rocha
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: gosu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The Game of Life
+email:
+- kimo@kimo.io
+executables:
+- game-of-life
+extensions: []
+extra_rdoc_files: []
+files:
+- .ruby-version
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- bin/game-of-life
+- game-of-life.gemspec
+- lib/game-of-life/cell.rb
+- lib/game-of-life/exceptions.rb
+- lib/game-of-life/version.rb
+- lib/game-of-life/world.rb
+- lib/game_of_life.rb
+- test/lib/game-of-life/cell_test.rb
+- test/lib/game-of-life/world_test.rb
+- test/rules/first_rule_test.rb
+- test/rules/fourth_rule_test.rb
+- test/rules/second_rule_test.rb
+- test/rules/third_rule_test.rb
+- test/test_helper.rb
+homepage: http://thiagokimo.github.io/game-of-life
+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.1.10
+signing_key: 
+specification_version: 4
+summary: A gem that shows random matches of Conway's Game of Life
+test_files:
+- test/lib/game-of-life/cell_test.rb
+- test/lib/game-of-life/world_test.rb
+- test/rules/first_rule_test.rb
+- test/rules/fourth_rule_test.rb
+- test/rules/second_rule_test.rb
+- test/rules/third_rule_test.rb
+- test/test_helper.rb