ruby_life 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 716e87982dcd1319e6da966a7c471b9522c26003
+  data.tar.gz: b0bcbff0820634af5cbc22a3f809715ce65d13fc
+SHA512:
+  metadata.gz: b4214dbeb9d7170b5f793fbe1ff26d22335976a0652ae63e052933f46f787d31a09fcb6d792e99ff9011e83a3713f94710724a42664b6b41b3ee3ad2daecc1d0
+  data.tar.gz: 13df4d2f782c0ef107b7933de3645cab0df4a4b59270fef9fbff580e5363f313382307428b67cbf61afdb434fba9a3490a61ba7f3dd2bc739442ee7c10f87c67

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-gemset

@@ -0,0 +1 @@
+game-of-life

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,27 @@
+PATH
+  remote: .
+  specs:
+    ruby_life (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.4)
+    rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.3)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  rake
+  rspec
+  ruby_life!

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Eno Compton 4
+
+MIT License
+
+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,20 @@
+Ruby Life
+=========
+
+A test-driven implementation of Conway's Game of Life in Ruby.
+
+The Rules
+=========
+
+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.
+

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/bin/ruby_life

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'ruby_life'
+RubyLife::Game.new.run
+

data/lib/ruby_life/cell.rb

@@ -0,0 +1,30 @@
+module RubyLife
+  class Cell
+    attr_reader :status
+
+    def initialize(status = nil)
+      @status = status || [:alive, :dead].sample
+    end
+
+    def alive?
+      @status == :alive
+    end
+
+    def dead?
+      @status == :dead
+    end
+
+    def die!
+      @status = :dead
+    end
+
+    def live!
+      @status = :alive
+    end
+
+    def to_s
+      alive? ? "o" : "."
+    end
+  end
+end
+

data/lib/ruby_life/exceptions.rb

@@ -0,0 +1,4 @@
+module RubyLife
+  class BadInitialState < StandardError; end
+end
+

data/lib/ruby_life/game.rb

@@ -0,0 +1,31 @@
+module RubyLife
+  class Game
+    def initialize
+      @grid = Grid.new(40)
+    end
+
+    def run
+      clear_screen
+
+      i = 0
+      loop do
+        puts "generation #{i}"
+        puts @grid
+        @grid.generate!
+        animate_transition
+        i += 1
+      end
+    end
+
+    private
+    def clear_screen
+      print "\e[H\e[2J"
+    end
+
+    def animate_transition
+      sleep 1
+      clear_screen
+    end
+  end
+end
+

data/lib/ruby_life/grid.rb

@@ -0,0 +1,112 @@
+module RubyLife
+  class Grid
+    attr_reader :size
+
+    def initialize(size, state: nil)
+      @size = size
+      if state
+        raise BadInitialState unless size_matches_state?(@size, state)
+
+        @storage = state.map { |status| Cell.new(status) }
+      else
+        @storage = number_of_cells(@size).times.map { Cell.new }
+      end
+    end
+
+    def get_neighbors_from_index(index)
+      indices_to_retrieve = []
+      indices_to_retrieve << (index - 1) unless beginning_of_row?(index)
+      indices_to_retrieve << (index + 1) unless end_of_row?(index)
+
+      unless first_row?(index)
+        indices_to_retrieve << (above(index - 1)) unless beginning_of_row?(index)
+        indices_to_retrieve << (above(index + 1)) unless end_of_row?(index)
+        indices_to_retrieve << (above(index))
+      end
+
+      unless last_row?(index)
+        indices_to_retrieve << (below(index) - 1) unless beginning_of_row?(index)
+        indices_to_retrieve << (below(index) + 1) unless end_of_row?(index)
+        indices_to_retrieve << (below(index))
+      end
+
+      indices_to_retrieve.map { |i| @storage[i] }
+    end
+
+    def [](x, y)
+      @storage[x + (y * size)]
+    end
+
+    def generate!
+      next_generation = {}
+
+      @storage.each_with_index do |cell, index|
+        neighbors = get_neighbors_from_index(index)
+        living_neighbor_count = neighbors.select(&:alive?).count
+
+        if cell.alive? && [2, 3].include?(living_neighbor_count)
+          next_generation[index] = :alive
+        elsif cell.alive? && living_neighbor_count == 4
+          next_generation[index] = :dead
+        elsif cell.dead? && living_neighbor_count == 3
+          next_generation[index] = :alive
+        else
+          next_generation[index] = :dead
+        end
+      end
+
+      next_generation.each do |index, status|
+        status == :alive ? @storage[index].live! : @storage[index].die!
+      end
+    end
+
+    def state
+      @storage.map(&:status)
+    end
+
+    def to_s
+      grid_string = ""
+
+      @storage.each_with_index do |cell, index|
+        grid_string += " #{cell}"
+        grid_string += "\n" if end_of_row?(index)
+      end
+
+      grid_string
+    end
+
+    private
+    def beginning_of_row?(index)
+      index % size == 0
+    end
+
+    def end_of_row?(index)
+      (index + 1) % size == 0
+    end
+
+    def first_row?(index)
+      index < size
+    end
+
+    def last_row?(index)
+      index >= (number_of_cells(size) - size)
+    end
+
+    def size_matches_state?(size, state)
+      number_of_cells(size) == state.length
+    end
+
+    def above(index)
+      index - size
+    end
+
+    def below(index)
+      index + size
+    end
+
+    def number_of_cells(size)
+      size * size
+    end
+  end
+end
+

data/lib/ruby_life/version.rb

@@ -0,0 +1,3 @@
+module RubyLife
+  VERSION = "0.0.1"
+end

data/lib/ruby_life.rb

@@ -0,0 +1,9 @@
+require 'ruby_life/cell'
+require 'ruby_life/exceptions'
+require 'ruby_life/game'
+require 'ruby_life/grid'
+require 'ruby_life/version'
+
+module RubyLife
+end
+

data/ruby_life.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby_life/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "ruby_life"
+  gem.version       = RubyLife::VERSION
+  gem.authors       = ["Eno Compton 4"]
+  gem.email         = ["eno4@ecom.com"]
+  gem.description   = %q{A command line version of Conway's Game of Life}
+  gem.summary       = %q{Observe cells as they live and die on the CLI.}
+  gem.homepage      = "http://github.com/enocom/ruby_life"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "bundler", "~> 1.3"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+end

data/spec/ruby_life/cell_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe RubyLife::Cell do
+  let(:cell) { RubyLife::Cell.new }
+
+  it 'can live and die' do
+    cell.live!
+    expect(cell.alive?).to be_true
+    cell.die!
+    expect(cell.alive?).to be_false
+  end
+
+  it 'takes an optional status' do
+    dead_cell = RubyLife::Cell.new(:dead)
+    expect(dead_cell.alive?).to be_false
+  end
+end
+

data/spec/ruby_life/game_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe RubyLife::Game do
+end
+

data/spec/ruby_life/grid_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+describe RubyLife::Grid do
+  let(:grid) { RubyLife::Grid.new(3) }
+
+  it 'accepts a dimension as an argument' do
+    expect(grid.state.length).to eq 9
+  end
+
+  it 'initializes separate instances of cells' do
+    expect(grid[0, 0].object_id).not_to eq(grid[0, 1].object_id)
+  end
+
+  it 'can retrieve cells from the grid' do
+    grid = RubyLife::Grid.new(3, state: [:dead, :dead, :dead,
+                                         :dead, :alive, :dead,
+                                         :dead, :dead, :dead])
+    expect(grid[1,1].alive?).to be_true
+
+    grid = RubyLife::Grid.new(3, state: [:dead, :alive, :dead,
+                                         :dead, :dead, :dead,
+                                         :dead, :dead, :dead])
+    expect(grid[1,0].alive?).to be_true
+
+    grid = RubyLife::Grid.new(3, state: [:dead, :dead, :dead,
+                                         :dead, :dead, :dead,
+                                         :dead, :alive, :dead])
+    expect(grid[1,2].alive?).to be_true
+  end
+
+  context 'specifying an initial state' do
+    it 'accepts an initial state' do
+      grid = RubyLife::Grid.new(2, state: [:dead, :alive, :dead, :alive])
+      expect(grid[0, 0].alive?).to be_false
+      expect(grid[1, 1].alive?).to be_true
+    end
+
+    it 'raises an error when passed mismatching dimensions and state' do
+      expect {
+        RubyLife::Grid.new(2, state: [:dead])
+      }.to raise_error(RubyLife::BadInitialState)
+
+      expect {
+        RubyLife::Grid.new(2, state: [:dead, :alive, :dead])
+      }.to raise_error(RubyLife::BadInitialState)
+    end
+  end
+
+  context 'retrieving neighboring cells' do
+    it 'finds neighbors of cells away from edges' do
+      expect(grid.get_neighbors_from_index(4).size).to eq 8
+    end
+
+    it 'finds neighbors of the corner cells' do
+      expect(grid.get_neighbors_from_index(0).size).to eq 3
+      expect(grid.get_neighbors_from_index(2).size).to eq 3
+      expect(grid.get_neighbors_from_index(6).size).to eq 3
+      expect(grid.get_neighbors_from_index(8).size).to eq 3
+    end
+
+    it 'finds neighbors of the edge cells' do
+      expect(grid.get_neighbors_from_index(1).size).to eq 5
+      expect(grid.get_neighbors_from_index(3).size).to eq 5
+      expect(grid.get_neighbors_from_index(5).size).to eq 5
+      expect(grid.get_neighbors_from_index(7).size).to eq 5
+    end
+  end
+
+  context 'printing the grid' do
+    it 'renders the live and dead cells' do
+      grid = RubyLife::Grid.new(2, state: [:dead, :alive, :alive, :dead])
+      expected_grid =" . o\n o .\n"
+      expect(grid.to_s).to eq expected_grid
+    end
+  end
+
+  context 'rule 1: any live cell with fewer than two live neighbors dies' do
+    specify 'a sole survivor dies' do
+      grid = RubyLife::Grid.new(2, state: [:dead, :dead,
+                                           :dead, :alive])
+      grid.generate!
+
+      expect(grid.state).to eq [:dead, :dead,
+                                :dead, :dead]
+    end
+
+    specify 'two sole survivors die' do
+      grid = RubyLife::Grid.new(2, state: [:dead,  :dead,
+                                           :alive, :alive])
+      grid.generate!
+
+      expect(grid.state).to eq [:dead, :dead,
+                                :dead, :dead]
+    end
+  end
+
+  context 'rule 2: any live cell with two or three live neighbors lives' do
+    specify 'any live cell with two live neighbors lives' do
+      grid = RubyLife::Grid.new(2, state: [:dead,  :alive,
+                                           :alive, :alive])
+      grid.generate!
+
+      expect(grid.state).to eq [:alive, :alive,
+                                :alive, :alive]
+    end
+
+    specify 'any live cell with three live neighbors lives' do
+      grid = RubyLife::Grid.new(2, state: [:alive, :alive,
+                                           :alive, :alive])
+      grid.generate!
+
+      expect(grid.state).to eq [:alive,  :alive,
+                                :alive,  :alive]
+    end
+  end
+
+  context 'rule 3: a live cell dies with more than three live neighbors' do
+    specify 'a cell dies with four live neighbors' do
+      grid = RubyLife::Grid.new(3, state: [:alive, :alive, :dead,
+                                           :alive, :alive, :alive,
+                                           :dead,  :dead,  :dead])
+      grid.generate!
+
+      expect(grid.state).to eq [:alive, :dead,  :alive,
+                                :alive, :dead,  :alive,
+                                :dead,  :alive, :dead]
+    end
+  end
+
+  context 'rule 4: a dead cell with extactly three live neighbors lives' do
+    specify 'a dead cell lives with three live neighbors' do
+      grid = RubyLife::Grid.new(2, state: [:dead,  :alive,
+                                           :alive, :alive])
+
+      grid.generate!
+
+      expect(grid.state).to eq [:alive, :alive,
+                                :alive, :alive]
+    end
+  end
+
+  context 'big grids' do
+    specify 'big grids respect all four rules' do
+      big_grid = RubyLife::Grid.new(5, state: [
+        :alive, :alive, :alive, :alive, :alive,
+        :alive, :alive, :alive, :alive, :alive,
+        :alive, :alive, :alive, :alive, :alive,
+        :alive, :alive, :alive, :alive, :alive,
+        :alive, :alive, :alive, :alive, :alive
+      ])
+
+      big_grid.generate!
+
+      expect(big_grid.state).to eq [
+        :alive, :dead, :dead, :dead, :alive,
+        :dead,  :dead, :dead, :dead, :dead,
+        :dead,  :dead, :dead, :dead, :dead,
+        :dead,  :dead, :dead, :dead, :dead,
+        :alive, :dead, :dead, :dead, :alive
+      ]
+
+      big_grid.generate!
+
+      expect(big_grid.state).to eq [
+        :dead,  :dead, :dead, :dead, :dead,
+        :dead,  :dead, :dead, :dead, :dead,
+        :dead,  :dead, :dead, :dead, :dead,
+        :dead,  :dead, :dead, :dead, :dead,
+        :dead,  :dead, :dead, :dead, :dead
+      ]
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rspec'
+require 'ruby_life'
+
+Dir[File.join(File.dirname(__FILE__), "../lib/ruby_life.rb")]
+  .each { |f| require f }
+

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: ruby_life
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Eno Compton 4
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: rspec
+  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: A command line version of Conway's Game of Life
+email:
+- eno4@ecom.com
+executables:
+- ruby_life
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-gemset
+- .ruby-version
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/ruby_life
+- lib/ruby_life.rb
+- lib/ruby_life/cell.rb
+- lib/ruby_life/exceptions.rb
+- lib/ruby_life/game.rb
+- lib/ruby_life/grid.rb
+- lib/ruby_life/version.rb
+- ruby_life.gemspec
+- spec/ruby_life/cell_spec.rb
+- spec/ruby_life/game_spec.rb
+- spec/ruby_life/grid_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/enocom/ruby_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.0.6
+signing_key: 
+specification_version: 4
+summary: Observe cells as they live and die on the CLI.
+test_files:
+- spec/ruby_life/cell_spec.rb
+- spec/ruby_life/game_spec.rb
+- spec/ruby_life/grid_spec.rb
+- spec/spec_helper.rb