game_of_life 1.0.0

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+.yardoc/
+doc/

data/.rdebugrc

@@ -0,0 +1,4 @@
+set autoeval on
+set history save on
+set listsize 12
+set autolist on

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.2@game_of_life --create

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - rbx
+  - rbx
+  - ree

data/.yardopts

@@ -0,0 +1,5 @@
+--readme README.md - notes.md
+--title 'Game Of Life Documentation'
+--output-dir doc
+--protected
+--private

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+
+gem "rake"
+# gem "ruby-debug19"
+
+group :test do
+  gem "rspec"
+  gem "cucumber"
+end
+
+gem "yard", :group => [:development, :test]
+# Need redcarpet for markdown formatting (using yard)
+gem "redcarpet", :group => [:development, :test]

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Arnab Deka
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# Conway's Game of Life, in Ruby
+[![Build Status](https://secure.travis-ci.org/arnab/game_of_life.png?branch=master)][travis]
+[travis]: http://travis-ci.org/arnab/game_of_life
+
+## About
+See the [notes file](https://github.com/arnab/game_of_life/blob/master/notes.md) for details about my thoughts.
+
+## Setup
+* If you are using rvm, as soon as you cd into this directory a gemset will be created, wherein all the gems will be installed by bundler
+* So the only steps you need to take are:
+	1. `gem install bundler`
+	2. `bundle install`
+
+## How to play
+* Run the cucumber steps to see examples.
+* You can play with the code with the simple script provided:
+`
+./scripts/play_game.rb examples/pulsar.txt
+`
+
+## Documentation
+### Hosted
+* Available at [http://rubydoc.info/github/arnab/game_of_life/](http://rubydoc.info/github/arnab/game_of_life/)
+
+### Build your own
+* Follow setup steps above if you have not already
+* Generate the yard dpcumentation by running: `yard server --reload`
+* Then you can see it at http://localhost:8808/
+
+## Supported Rubies
+[Tested against][travis] the following Ruby implementations:
+
+* Ruby 1.8.7
+* Ruby 1.9.2
+* Ruby 1.9.3
+* [Rubinius][]
+* [Ruby Enterprise Edition][ree]
+
+[rubinius]: http://rubini.us/
+[ree]: http://www.rubyenterpriseedition.com/
+
+##Copyright
+Copyright (c) 2012 Arnab Deka.
+See [LICENSE][] for details.
+
+[license]: https://github.com/arnab/game_of_life/blob/master/LICENSE.md
+

data/Rakefile

@@ -0,0 +1,11 @@
+require 'yard'
+require 'yard/rake/yardoc_task'
+require 'rspec/core/rake_task'
+require 'cucumber/rake/task'
+
+YARD::Rake::YardocTask.new
+RSpec::Core::RakeTask.new
+Cucumber::Rake::Task.new
+
+task :test => [:spec, :cucumber]
+task :default => :test

data/cucumber.yml

@@ -0,0 +1,4 @@
+---
+default: --profile sane
+sane: --format pretty --tags ~@wip
+wip: --tags @wip

data/examples/glider.txt

@@ -0,0 +1,3 @@
+- X -
+- X X
+X - X

data/examples/lwss.txt

@@ -0,0 +1,4 @@
+- X - - X
+X - - - -
+X - - - X
+X X X X -

data/examples/pulsar.txt

@@ -0,0 +1,15 @@
+- - - - - - - - - - - - - - -
+- - - X X X - - - X X X - - -
+- - - - - - - - - - - - - - -
+- X - - - - X - X - - - - X -
+- X - - - - X - X - - - - X -
+- X - - - - X - X - - - - X -
+- - - X X X - - - X X X - - -
+- - - - - - - - - - - - - - -
+- - - X X X - - - X X X - - -
+- X - - - - X - X - - - - X -
+- X - - - - X - X - - - - X -
+- X - - - - X - X - - - - X -
+- - - - - - - - - - - - - - -
+- - - X X X - - - X X X - - -
+- - - - - - - - - - - - - - -

data/features/gameplay.feature

@@ -0,0 +1,62 @@
+Feature: Gameplay of the Game of Life
+  In order to observe the Game of Life being played out
+  As an observer
+  I want various scenarios of the game to change the state of the board correctly
+
+  Scenario: A: Block pattern
+    Given that the game is seeded with:
+    """
+    X X
+    X X
+    """
+    When the next tick occurs
+    Then the board's state should change to:
+    """
+    X X
+    X X
+    """
+
+  Scenario: B: Boat pattern
+    Given that the game is seeded with:
+    """
+    X X -
+    X - X
+    - X -
+    """
+    When the next tick occurs
+    Then the board's state should change to:
+    """
+    X X -
+    X - X
+    - X -
+    """
+
+  Scenario: C: Blinker pattern
+    Given that the game is seeded with:
+    """
+    - X -
+    - X -
+    - X -
+    """
+    When the next tick occurs
+    Then the board's state should change to:
+    """
+    - - -
+    X X X
+    - - -
+    """
+
+  Scenario: D: Toad pattern
+    Given that the game is seeded with:
+    """
+    - X X X
+    X X X -
+    """
+    When the next tick occurs
+    Then the board's state should change to:
+    """
+    - - X -
+    X - - X
+    X - - X
+    - X - -
+    """

data/features/multi_generation_gameplay.feature

@@ -0,0 +1,41 @@
+Feature: Multi-generation Gameplay of the Game of Life
+  In order to observe the Game of Life being played out for multiple generations
+  As an observer
+  I want various scenarios of the game to change the state of the board continuously
+
+  Scenario: A: Glider pattern
+    Given that the game is seeded with:
+    """
+    - X -
+    - X X
+	X - X
+    """
+    When the next tick occurs
+    Then the board's state should change to:
+    """
+	- X X
+	X - X
+	- - X
+    """
+    When the next tick occurs
+    Then the board's state should change to:
+    """
+	- X X -
+	- - X X
+	- X - -
+    """
+    When the next tick occurs
+    Then the board's state should change to:
+    """
+	- X X X
+	- - - X
+	- - X -
+    """
+    When the next tick occurs
+    Then the board's state should change to:
+    """
+	- - X -
+	- - X X
+	- X - X
+	- - - -
+    """

data/features/step_definitions/gameplay_steps.rb

@@ -0,0 +1,16 @@
+def game
+  @game ||= GameOfLife::Game.new
+end
+
+Given /^that the game is seeded with:$/ do |raw_input|
+  formatted_seed_data = GameOfLife::Inputters::SimpleStringInputter.new.parse raw_input
+  game.seed(formatted_seed_data)
+end
+
+When /^the next tick occurs$/ do
+  game.tick
+end
+
+Then /^the board's state should change to:$/ do |expected_formatted_output|
+  game.board.view.should == expected_formatted_output
+end

data/features/support/env.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH << File.expand_path('../../../lib', __FILE__)
+require 'game_of_life'

data/lib/game_of_life.rb

@@ -0,0 +1,6 @@
+require 'game_of_life/game'
+require 'game_of_life/board'
+require 'game_of_life/cell'
+require 'game_of_life/rules'
+require 'game_of_life/outputters/simple_string_outputter'
+require 'game_of_life/inputters/simple_string_inputter'

data/lib/game_of_life/board.rb

@@ -0,0 +1,191 @@
+module GameOfLife
+  # Raised when a {Board} gets into an invalid shape
+  class InvalidBoardError < RuntimeError; end;
+
+  # The board used in the game. Holds the {Cell}s.
+  class Board
+
+    # The {Cell}s in this board,internally maintained as a 2D Array of {Cell}s.
+    # The x-coordinate increases horizontally and is always positive.
+    # The y-coordinate increases vertically and is always positive.
+    # Internally, the cells are arranged as a 2D array. The first-level Array indexed
+    # with the y-coordinates. It contains an Array of {Cell}s, whose position is
+    # the x-coordinate.
+    # @note Use {#each_cell}, {#each_row} etc. methods to access the cells individually.
+    attr_reader :cells
+
+    # Creates the board
+    # @param [2D Array<Symbol>] seed_data the data for the {Cell}s in the board, as an 2D array.
+    # @example seed_data looks like
+    #   the output of SimpleStringInputter#parse
+    # @raise [InvalidBoardError] if the seed_data is not in the shape of a square,
+    #   or if all elements are not present
+    def initialize(seed_data)
+      @cells = Array.new(Array.new)
+      seed_with!(seed_data)
+      begin
+        validate
+      rescue InvalidBoardError => ex
+        # Add the seed_data into the error message, so the caller gets a clue
+        raise InvalidBoardError, ex.message + " [seed data was: #{seed_data.inspect}]"
+      end
+    end
+
+    # @param [OutPutter] the outputter that you want to use. Defaults to {Outputters::SimpleStringOutputter}
+    def view(outputter = Outputters::SimpleStringOutputter.new)
+      outputter.render(self)
+    end
+
+    def each_row(&block)
+      @cells.each { |row| yield row }
+    end
+
+    def each_row_with_index(&block)
+      @cells.each_with_index { |row, i| yield row, i }
+    end
+
+    def each_cell(&block)
+      @cells.flatten.each { |cell| yield cell }
+    end
+
+    # Find the cell at a given pair of co-ordinates. Following Array symantics,
+    # this method returns nil if nothing exists at that location or if the
+    # location is out of the board. To avoid Array's negative index symantics it
+    # returns nill if a negative index is passed.
+    # @param [Integer] x the x-coordinate
+    # @param [Integer] y the y-coordinate
+    # @return [Cell] or nil
+    def cell_at(x, y)
+      return nil if (x < 0 || y < 0)
+      @cells[y][x] if @cells[y]
+    end
+
+    # Finds the neighbors of a given {Cell}'s co-ordinates. The neighbors are the eight cells
+    # that surround the given one.
+    # @param [Integer] x the x-coordinate of the cell you find the neighbors of
+    # @param [Integer] y the y-coordinate of the cell you find the neighbors of
+    # @return [Array<Cell>]
+    def neighbors_of_cell_at(x, y)
+      neighbors = coords_of_neighbors(x, y).map { |x, y| self.cell_at(x, y) }
+      neighbors.reject {|n| n.nil?}
+    end
+
+    # This is the first stage in a Game's #tick.
+    # @see Game#tick
+    def reformat_for_next_generation!
+      # create an array of dead cells and insert it as the first and last row of cells
+      dead_cells = (1..@cells.first.size).map { Cell.new }
+      # don't forget to deep copy the dead_cells
+      @cells.unshift Marshal.load(Marshal.dump(dead_cells))
+      @cells.push Marshal.load(Marshal.dump(dead_cells))
+
+      # also insert a dead cell at the left and right of each row
+      @cells.each do |row|
+        row.unshift Cell.new
+        row.push Cell.new
+      end
+
+      # validate to see if we broke the board
+      validate
+    end
+
+    # Goes through each {Cell} and marks it (using {Rules}) to signal it's state for the next
+    # generation. This prevents modifying any {Cell} in-place as each generation is a pure
+    # function of the previous. Once all {Cell}s are marked, it sweeps across them gets them
+    # to change their state if they were marked to.
+    # @see #mark_changes_for_next_generation
+    # @see #sweep_changes_for_next_generation!
+    def mark_and_sweep_for_next_generation!
+      mark_changes_for_next_generation
+      sweep_changes_for_next_generation!
+    end
+
+    # This is the third and last stage in a Game's #tick.
+    # @see Game#tick
+    def shed_dead_weight!
+      # Remove the first and last rows if all cells are dead
+      @cells.shift if @cells.first.all? { |cell| cell.dead? }
+      @cells.pop if @cells.last.all? { |cell| cell.dead? }
+
+      # Remove the first cell of every row, if they are all dead
+      first_columns = @cells.map { |row| row.first }
+      if first_columns.all? { |cell| cell.dead? }
+        @cells.each { |row| row.shift }
+      end
+
+      # Remove the last cell of every row, if they are all dead
+      last_columns = @cells.map { |row| row.last }
+      if last_columns.all? { |cell| cell.dead? }
+        @cells.each { |row| row.pop }
+      end
+
+      validate
+    end
+
+    private
+      def validate
+        num_o_rows = @cells.size
+        columns_in_each_row = @cells.map(&:size)
+        unless columns_in_each_row.uniq.size == 1
+          msg = "Unequal number of columns, #{columns_in_each_row.inspect} in different rows found"
+          raise InvalidBoardError, msg
+        end
+
+        num_o_columns = columns_in_each_row.uniq.first
+        num_o_elements = @cells.flatten.reject {|d| d.nil? }.size
+        unless (num_o_rows * num_o_columns) == num_o_elements
+          msg = "Not a rectangular shape: " +
+            "rows(#{num_o_rows}) x columns(#{num_o_columns}) != total elements(#{num_o_elements})]. "
+          raise InvalidBoardError, msg
+        end
+      end
+
+      def seed_with!(data)
+        data.each_with_index do |row, y|
+          @cells << []
+          row.each_with_index do |state, x|
+            @cells[y] << Cell.new(state)
+          end
+        end
+      end
+
+      def mark_changes_for_next_generation
+        self.each_row_with_index do |cells, y|
+          cells.each_with_index do |cell, x|
+            cell.should_live_in_next_generation =
+              Rules.should_cell_live?(self, cell, x, y)
+          end
+        end
+      end
+
+      def sweep_changes_for_next_generation!
+        self.each_cell { |cell| cell.change_state_if_needed! }
+      end
+
+      # Calculates the co-ordinates of neighbors of a given pair of co-ordinates.
+      # @param [Integer] x the x-coordinate
+      # @param [Integer] y the y-coordinate
+      # @return [Array<Integer, Integer>] the list of neighboring co-ordinates
+      # @example
+      #   coords_of_neighbors(1,1) =>
+      #     [
+      #       [0, 0], [0, 1], [0, 2],
+      #       [1, 0],         [1, 2],
+      #       [2, 0], [2, 1], [2, 2],
+      #     ]
+      # @note This method returns all possible co-ordinate pairs of neighbors,
+      #   so it can contain coordinates of cells not in the board, or negative ones.
+      # @see #neighbors_of_cell_at
+      def coords_of_neighbors(x, y)
+        coords_of_neighbors = []
+        (x - 1).upto(x + 1).each do |neighbors_x|
+          (y - 1).upto(y + 1).each do |neighbors_y|
+            next if (x == neighbors_x) && (y == neighbors_y)
+            coords_of_neighbors << [neighbors_x, neighbors_y]
+          end
+        end
+        coords_of_neighbors
+      end
+
+  end
+end

data/lib/game_of_life/cell.rb

@@ -0,0 +1,37 @@
+module GameOfLife
+  class Board
+    # An indivisual cell in the Game {Board}
+    class Cell
+      STATES = [:live, :dead]
+      attr_accessor :state, :should_live_in_next_generation
+
+      # Creates a {Cell}. A cell starts out as dead unless explicitly set alive.
+      def initialize(initial_state=:dead)
+        raise ArgumentError, "Unknown state #{initial_state}" unless STATES.include? initial_state
+        @state = initial_state
+      end
+
+      def change_state_if_needed!
+        if self.should_live_in_next_generation
+          self.state = :live
+        else
+          self.state = :dead
+        end
+      end
+
+      def alive?
+        state == :live
+      end
+
+      def dead?
+        ! alive?
+      end
+
+      def to_s
+        fields = %w{state should_live_in_next_generation}
+        important_details = fields.map {|attr| "#{attr}:#{self.send(attr)}"}
+        "#{super} <#{important_details.join(' ')}>"
+      end
+    end
+  end
+end

data/lib/game_of_life/game.rb

@@ -0,0 +1,34 @@
+module GameOfLife
+  class Game
+    # the Game Board
+    attr_reader :board
+
+    # Takes the formatted input data and seeds the {Board} with it
+    # @param [string] formatted_input
+    # @example
+    #   [
+    #     [:dead, :live, :live, :live],
+    #     [:live, :live, nil,   :dead]
+    #   ]
+    def seed(formatted_input)
+      @board = Board.new(formatted_input)
+    end
+
+    # The event by which the board transitions from the current to the next generation/state.
+    # There are three stages in the process:
+    # * reformat the board: Each tick can make the neighboring dead cells
+    #   (which are not technically in the board now) cells alive. So reformat the board to
+    #   add a new row at the top and bottom an a column at the left and right (all dead cells)
+    # * mark and sweep for the next generation
+    # * shed the dead weight: In stage 1, we added a layer of dead cells around the current board.
+    #   If the whole layer is still dead, just remove it as we don't want to keep adding layers of
+    #   dead weight on every tick.
+    # @see Board#mark_and_sweep_for_next_generation!
+    def tick
+      @board.reformat_for_next_generation!
+      @board.mark_and_sweep_for_next_generation!
+      @board.shed_dead_weight!
+    end
+
+  end
+end

data/lib/game_of_life/inputters/simple_string_inputter.rb

@@ -0,0 +1,46 @@
+module GameOfLife
+  # Inputters can parse various kinds of data into a format that is easily converted to {Board}'s {Board::Cell Cell}s. Some forms of possible inputters:
+  #   JSONInputter would accept JSON objects (which can be posted by a website for example)
+  #   SimpleStringInputter can be used by tests to verify results
+  #   FileInputter can read files in a given format
+  module Inputters
+    # parses an input string for the board data
+    class SimpleStringInputter
+      # Parses board's data from a string.
+      # @example Will parse this input string
+      #   X - X
+      #   - - -
+      #   - X -
+      # @example into this output structure:
+      #   [
+      #     [:live, :dead, :live],
+      #     [:dead, :dead, :dead],
+      #     [:dead, :live, :dead]
+      #   ]
+      # @param [String] raw_input the given string
+      # @return [2D Array<Symbol>] formatted board data
+      # @raise [ArgumentError] if anything other then an 'X' or '-' as the state
+      def parse(raw_input)
+        rows = raw_input.split("\n")
+        rows.map! { |row| row.split(' ') }
+        rows.map! do |row|
+          row.map! { |symbol| convert_cryptic_symbol_to_state(symbol) }
+        end
+        rows
+      end
+
+      private
+        def convert_cryptic_symbol_to_state(symbol)
+          case symbol
+          when 'X'
+            :live
+          when '-'
+            :dead
+          else
+            raise ArgumentError, "Don't know how to convert #{symbol} into a Cell's state"
+          end
+        end
+
+    end
+  end
+end

data/lib/game_of_life/outputters/simple_string_outputter.rb

@@ -0,0 +1,37 @@
+module GameOfLife
+  # Outputters can display/render a board in a specific way. Some forms of possible outputters:
+  #   JSONOutputter would return the board as a JSON object (which can be used by a website for example)
+  #   SimpleStringOutputter can be used by tests to verify results
+  #   ConsoleOutputter can render it appropriately for a console-application
+  module Outputters
+    # Renders a board as a simple string, that can be used to inspect it from, say a test
+    class SimpleStringOutputter
+      # Renders the given board as a simple string. Cells are delimited by spaces and rows by newlnes
+      # A live cell is marked 'X' and a dead cell with a '-'
+      # @param [GameOfLife::Board] board the given board
+      # @return [String] the board rendered as a string
+      def render(board)
+        output = ""
+        board.each_row do |row|
+          row.each do |cell|
+            output << simplified_state(cell.state)
+            output << " "
+          end
+          output.strip!
+          output << "\n"
+        end
+        output.chomp
+      end
+
+      private
+      def simplified_state(state)
+        case state
+        when :live
+          'X'
+        when :dead
+          '-'
+        end
+      end
+    end
+  end
+end

data/lib/game_of_life/rules.rb

@@ -0,0 +1,21 @@
+module GameOfLife
+  module Rules
+
+    # The rules followed are:
+    # 1. Any live cell with fewer than two live neighbours dies, as if caused by under-population.
+    # 2. Any live cell with two or three live neighbours lives on to the next generation.
+    # 3. Any live cell with more than three live neighbours dies, as if by overcrowding.
+    # 4. Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.
+    def should_cell_live?(board, cell, x, y)
+      live_neighbors_count = board.neighbors_of_cell_at(x, y).select { |n| n.alive? }.size
+      case cell.state
+      when :live
+        (2..3).include? live_neighbors_count
+      when :dead
+        live_neighbors_count == 3
+      end
+    end
+
+    module_function :should_cell_live?
+  end
+end

data/notes.md

@@ -0,0 +1,52 @@
+These are basically just my raw thoughts about the game. See my updates from 1/7 Saturday.
+
+# Objects
+
+## GameOfLife
+Top level namespace (module). Has the following things:
+
+### Game
+* incorporates rules
+* gets the input (*seed*)
+* and waits for *tick*s
+* @see the Game class' #tick documentation for more details
+
+### Board
+* has a grid (2d array) of Cells
+* checks integrity after every tick, like:
+  - is it a filled shape (rectangular)?
+  - we don't do any bounds check as we try not to have our API dictate the client to pass in a bound and then data
+  - as long as the board's shape is good and every cell is filled, we are fine
+
+#### Cell
+* state: :live or :dead
+
+### Rules
+* Any live cell with fewer than two live neighbours dies, as if by loneliness.
+* Any live cell with more than three live neighbours dies, as if by overcrowding.
+* Any live cell with two or three live neighbours lives, unchanged, to the next generation.
+* Any dead cell with exactly three live neighbours comes to life.
+
+### Player
+* do we need one? there isn't really a real player, but we can assume one which seeds and then observes the Game#ticks *
+
+# Analysis
+Space-complexity wise an infinite grid might be tricky because each tick results in a board which is a pure function of the previous state of the board. In other words, if it's really infinite, or very large, it will be impossible to copy the board before every manipulation. Three options that I can see (following discussions assume there are (n x n) *Cell*s in the *Board*):
+
+* Mark-And-Sweep: Keep some sort of a has\_changed signifier in each *Cell*. Instead of trying to change the state in-place, flip this boolean field. After all the *Cell*s have been touched, use this field to go through once more and flip the state if required.
+  - This increases by the space required by O(n-squared * some-constant-amount-for-a-boolean), which is O(n-squared)
+* Another simple optimization can be to go row-by-row. Every time we reach row n, where n > 2, the (n-2)th row can be flushed (i.e. their state can be changed) since no *Cell* in (n-2) row can be n row's neighbor. This way only 2 rows need to copied in memory at a time.
+  - This increases the space required by O(n). But if n is again very large (and not n-squared) this will still not be efficient.
+* A third approach could be to walk the *Board* in a radially outward manner, flushing the earliest-seen-*Cell*s as soon as we are in a neighborhood which is one row/column away from the first generation.
+  - This would be very optimal but will be complicated to write. Is it worth it is the question.
+
+## Assumptions and Conslusions
+Given all these considerations and reassurance from my recruiter that we are looking for a *simple* OO Design (and not space-complexity) I am going with alternative 1: mark and sweep (instead of duplicating the data on every tick).
+
+# Updates
+## 1/7 Saturday
+So it turns out some of my assumptions were wrong. Given the `X` and `-` markings in the example for live and dead cells I thought that once seeded the size of the board was constant. It dawns on me now that that the "infiniteness" of the board plays on every tick/generation change. Basically, `X` are live cells but everything else (in all directions) is dead (the ones inside the playing area are marked explicitly with a `-`). So we'll need some changes, but that's why software is designed with principles of design in mind. Let's see how our code adopts.
+
+I am going to continue and complete the mark-and-sweep part. That will get scenario C passing. To tackle Scenario D (Toad, which changes the size of the board) as the first pas, we can implement the  [self-constructing pattern][1], basically create a new generation of cells and kill the old one. I suspect it won't perform optimally (given we are using a 2D array) but we can leave the optimization for later (perhaps a 2D LinkedList will fare better).
+
+[1]: http://en.wikipedia.org/wiki/Conway's_Game_of_Life#Self-replication

data/scripts/play_game.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby -KU
+
+$LOAD_PATH << './lib'
+require "game_of_life"
+
+game = GameOfLife::Game.new
+
+file_name = ARGV[0]
+raise "Please provide a seed file as an argument. See inside the examples directory for examples." unless file_name
+raw_input = File.readlines file_name
+raw_input = raw_input.map { |line| line.chomp }.join("\n")
+
+formatted_seed_data = GameOfLife::Inputters::SimpleStringInputter.new.parse raw_input
+game.seed(formatted_seed_data)
+
+puts "Starting with:"
+puts game.board.view
+
+i = 1
+while(true)
+  print "\e[2J\e[f"
+  puts "Generation: #{i}"
+  game.tick
+  puts game.board.view
+  i += 1
+  sleep(1)
+end

data/spec/game_of_life/board_spec.rb

@@ -0,0 +1,69 @@
+require "spec_helper"
+
+module GameOfLife
+  describe Board do
+    describe "#initialize" do
+      it "should raise Error when seed data contains unequal number of fields across rows" do
+        seed_data = [
+          [:live, :dead], [:live, :dead, :live]
+        ]
+        expect {
+          Board.new(seed_data)
+          }.to raise_error InvalidBoardError, /unequal number of columns/i
+      end
+
+      it "should NOT raise Error when rows != columns, but is a rectangular shape" do
+        seed_data = [
+          [:live, :dead, :live],
+          [:live, :dead, :live]
+        ]
+        expect {
+          Board.new(seed_data)
+        }.to_not raise_error InvalidBoardError
+      end
+
+    end
+
+    describe "#cell_at" do
+      let(:board) {
+        Board.new([
+          [ :live, :live ],
+          [ :live, :live ],
+        ])
+      }
+      it "should return nil if the coordinates are negative" do
+        board.cell_at(-1, -1).should be_nil
+      end
+
+      it "should return nil if the coordinates are outside the board" do
+        board.cell_at(26, 11).should be_nil
+      end
+    end
+
+    describe "#neighbors_of" do
+      let(:board) {
+        Board.new([
+          [ :live, :live, :live ],
+          [ :live, :live, :live ],
+          [ :live, :live, :live ],
+        ])
+      }
+
+      it "should return 3 neighbors for the cell at (0,0)" do
+        board.neighbors_of_cell_at(0, 0).should have(3).items
+      end
+
+      it "should return 3 neighbors for the cell at (2,2)" do
+        board.neighbors_of_cell_at(2, 2).should have(3).items
+      end
+
+      it "should return 5 neighbors for the cell at (1,0)" do
+        board.neighbors_of_cell_at(1, 0).should have(5).items
+      end
+
+      it "should return 8 neighbors for the cell at (1,1)" do
+        board.neighbors_of_cell_at(1, 1).should have(8).items
+      end
+    end
+  end
+end

data/spec/game_of_life/cell_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+module GameOfLife
+  describe Board::Cell do
+    describe "#initialize" do
+      it "should raise Error when an unknown state is given" do
+        expect {
+          Board::Cell.new(:in_limbo)
+          }.to raise_error ArgumentError, /in_limbo/
+      end
+    end
+  end
+end

data/spec/game_of_life/inputters/simple_string_inputter_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+module GameOfLife
+  describe Inputters::SimpleStringInputter do
+    describe "#parse" do
+      let(:inputter) { GameOfLife::Inputters::SimpleStringInputter.new }
+      it "should raise Error when an unknown symbol (other than X or -) is given" do
+        str = ["X Y -", "Y Y -"].join("\n")
+        expect {
+          inputter.parse(str)
+          }.to raise_error ArgumentError, /Y/
+      end
+
+      it "should not raise Error when X and - are the only symbols used" do
+        str = ["X - -", "- X -"].join("\n")
+        expect {
+          inputter.parse(str)
+          }.to_not raise_error ArgumentError
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'game_of_life'

data/tasks.txt

@@ -0,0 +1,33 @@
+size  status    name
+--    ------    ---------------------------------------------
+1     done      set up a bare git repo
+1     done      set up rvmrc
+1     done      set up gemfile
+1     done      set up rake
+1     done      setup cucumber
+1     done      setup rspec
+1     done      set up yard
+1     done      add notes.txt with thoughts
+2     done      think and create actual stories *
+1     done      add a README.markdown to show to run
+
+* Stories that came out of the thinking story above
+2     done      cucumber features for first scenarios
+2     done      implementation of game using the strategy/template pattern to take an outputter
+2     done      seeding the board
+3     done      calculate the next state of the board after a tick
+1     done      set the next state as calculated above
+1     done      an outputter to produce console like output
+2     done      cucumber features for various scenarios
+1     done      inputter also as a template, like outputter
+1     done      integrity check of board
+1     done      clarify Toad Pattern (D) with recruiter
+1     done      grid can be rectangular, not necessarily square
+2     done      implement self-replication (add the neighboring row/columns and clean up if needed)
+1     done      board should use outputter only in view
+1     done      board should use inputter only in parse
+1     done      board should not hold on to a game
+2     done      add a CLI so we can do file input and test that way
+1     done      some cucumber steps with multiple ticks
+1     done      complete README
+1     done      complete documentation

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: game_of_life
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- arnab (Arnab Deka)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-12 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2152022520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2152022520
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: &2152022100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2152022100
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2152021600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *2152021600
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &2152021180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2152021180
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: &2152020720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2152020720
+description: A Ruby library that encaptulates the logic of the game
+email:
+- arnab.deka+game_of_life@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rdebugrc
+- .rspec
+- .rvmrc
+- .travis.yml
+- .yardopts
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- cucumber.yml
+- examples/glider.txt
+- examples/lwss.txt
+- examples/pulsar.txt
+- features/gameplay.feature
+- features/multi_generation_gameplay.feature
+- features/step_definitions/gameplay_steps.rb
+- features/support/env.rb
+- lib/game_of_life.rb
+- lib/game_of_life/board.rb
+- lib/game_of_life/cell.rb
+- lib/game_of_life/game.rb
+- lib/game_of_life/inputters/simple_string_inputter.rb
+- lib/game_of_life/outputters/simple_string_outputter.rb
+- lib/game_of_life/rules.rb
+- notes.md
+- scripts/play_game.rb
+- spec/game_of_life/board_spec.rb
+- spec/game_of_life/cell_spec.rb
+- spec/game_of_life/inputters/simple_string_inputter_spec.rb
+- spec/spec_helper.rb
+- tasks.txt
+homepage: https://github.com/arnab/game_of_life
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Conway's Game of Life, in Ruby
+test_files:
+- features/gameplay.feature
+- features/multi_generation_gameplay.feature
+- features/step_definitions/gameplay_steps.rb
+- features/support/env.rb
+- spec/game_of_life/board_spec.rb
+- spec/game_of_life/cell_spec.rb
+- spec/game_of_life/inputters/simple_string_inputter_spec.rb
+- spec/spec_helper.rb
+has_rdoc: