conway 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Matt Yoho
+
+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,15 @@
+## Conway
+A simple Game of Live implementation with formost focus on object design.
+
+Currently very much leaky of object references.
+
+Conway comes with a very simple ASCII visualize. It can be invoked like so,
+where the size argument determines the dimensions of the square cell grid:
+
+    conway --size 25 --cells="2,3 3,3 2,2 5,4 5,8 9,8, 7,6"
+    conway -s 30 -c 2,3:3,3:3,2:2,2:3,4
+
+Please feel free to send feedback via the GitHub project or via email at
+mby _AT_ mattyoho _dot_ com.
+
+https://github.com/mattyoho/conway

data/bin/conway

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+# Useful for running the script from the project directory
+lib_dir = File.join(File.dirname(__FILE__), '..', 'lib')
+$LOAD_PATH.unshift lib_dir if File.directory?(lib_dir)
+
+require 'choice'
+require 'conway/visualizer/ascii'
+
+PROGRAM_VERSION = 1
+
+module ConwayAscii
+  def self.suppress_warnings
+    original_verbosity = $VERBOSE
+    begin
+      $VERBOSE = nil
+      yield
+    ensure
+      $VERBOSE = original_verbosity
+    end
+  end
+
+  def self.parse_points(point_str)
+    point_str.split(/\s|;|:/).map do |pt|
+      x,y = pt.split(',').map {|d| d.to_i }
+      Conway::Point.new x,y
+    end
+  end
+
+  def self.exit
+    puts "\nExiting...\n"
+    Kernel::exit
+  end
+end
+
+ConwayAscii.suppress_warnings do
+  Choice.options do
+    header 'Conway Game of Life ASCII visualizer'
+    header 'Available options:'
+
+    option :size do
+      short '-s'
+      long  '--size=SIZE'
+      desc  'The size of the game grid, specified as the length of one side'
+      cast  Integer
+      default 30
+    end
+
+    option :cells do
+      short '-c'
+      long  '--cells=CELLS'
+      desc  'Starting points for live cells, comma-seperated x,y pairs, seperated by spaces, colons, or semicolons'
+      default '1,2 2,1'
+    end
+
+    option :help do
+      long  '--help'
+      desc  'Print this help message'
+    end
+  end
+end
+
+Signal.trap("TERM") do
+  ConwayAscii.exit
+end
+
+Signal.trap("INT") do
+  ConwayAscii.exit
+end
+
+live_points = ConwayAscii.parse_points Choice[:cells]
+grid        = Conway::Visualizer::Ascii.new(Choice[:size], live_points)
+
+grid.loop do |step|
+  puts step
+end

data/lib/conway.rb

@@ -0,0 +1,8 @@
+require 'conway/generation'
+require 'conway/live_cell'
+require 'conway/dead_cell'
+require 'conway/point'
+require 'conway/cell_location'
+require 'conway/potential_cell_collection'
+require 'conway/rule_set'
+require 'conway/cell_space'

data/lib/conway/cell_location.rb

@@ -0,0 +1,14 @@
+module Conway
+  class CellLocation
+    attr_reader :cell, :point
+
+    def initialize(cell, point)
+      @cell  = cell
+      @point = point
+    end
+
+    def adjacent_points
+      point.adjacents
+    end
+  end
+end

data/lib/conway/cell_space.rb

@@ -0,0 +1,23 @@
+module Conway
+  class CellSpace
+    def initialize(points)
+      self.potential_cells = PotentialCellCollection.new(live_locations(points))
+    end
+
+    def apply(rule_set)
+      potential_cells.each_cell do |cell, neighbors|
+        rule_set.apply(cell, neighbors)
+      end
+      potential_cells.live_cell_locations.map {|cell_loc| cell_loc.point }
+    end
+
+    private
+    attr_accessor :potential_cells
+
+    def live_locations(points)
+      points.map do |point|
+        CellLocation.new(LiveCell.new, point)
+      end
+    end
+  end
+end

data/lib/conway/dead_cell.rb

@@ -0,0 +1,9 @@
+module Conway
+  class DeadCell
+
+    def alive?
+      false
+    end
+
+  end
+end

data/lib/conway/generation.rb

@@ -0,0 +1,16 @@
+module Conway
+  class Generation
+    attr_reader :cell_coordinates, :rule_set
+
+    def initialize(cell_coordinates=[], rule_set=RuleSet.new)
+      @cell_coordinates = cell_coordinates
+      @rule_set         = rule_set
+    end
+
+    def next
+      cell_space = CellSpace.new(cell_coordinates)
+      new_coords = cell_space.apply(rule_set)
+      Generation.new new_coords, rule_set
+    end
+  end
+end

data/lib/conway/live_cell.rb

@@ -0,0 +1,9 @@
+module Conway
+  class LiveCell
+
+    def alive?
+      true
+    end
+
+  end
+end

data/lib/conway/point.rb

@@ -0,0 +1,29 @@
+module Conway
+  class Point
+    attr_reader :x, :y
+
+    def initialize(x=0,y=0)
+      @x,@y = x,y
+    end
+
+    def eql?(other)
+      self.x == other.x && self.y == other.y
+    end
+
+    def ==(other)
+      eql? other
+    end
+
+    def hash
+      :"#{x}-#{y}".object_id
+    end
+
+    def adjacents
+      grid = (-1..1).map do |j|
+        (-1..1).map do |i|
+          Point.new(x+i, y+j) unless i == 0 && j == 0
+        end
+      end.flatten.compact
+    end
+  end
+end

data/lib/conway/potential_cell_collection.rb

@@ -0,0 +1,45 @@
+module Conway
+  class PotentialCellCollection
+    def initialize(live_locations)
+      identify_potential_locations(live_locations)
+    end
+
+    def each_cell(&block)
+      potential_cell_locations.each do |point, cell_loc|
+        neighbors      = neighbors_for(cell_loc)
+        neighbor_cells = neighbors.map {|n| n.cell }
+
+        new_cell = block.call(cell_loc.cell, neighbor_cells)
+
+        new_location = CellLocation.new(new_cell, cell_loc.point)
+        potential_cell_locations[cell_loc.point] = new_location
+      end
+    end
+
+    def live_cell_locations
+      potential_cell_locations.values.select{|loc| loc.cell.kind_of?(LiveCell) }
+    end
+
+    private
+    def potential_cell_locations
+      @potential_cell_locations ||= Hash.new do |hash, point|
+        CellLocation.new(DeadCell.new, point)
+      end
+    end
+
+    def identify_potential_locations(locations)
+      locations.each do |loc|
+        potential_cell_locations[loc.point] = loc
+        neighbors_for(loc).each do |neighbor|
+          potential_cell_locations[neighbor.point] = neighbor
+        end
+      end
+    end
+
+    def neighbors_for(location)
+      location.adjacent_points.map do |point|
+        potential_cell_locations[point]
+      end
+    end
+  end
+end

data/lib/conway/rule_set.rb

@@ -0,0 +1,33 @@
+module Conway
+  class RuleSet
+    def apply(cell, neighbors)
+      live_neighbors_count = neighbors.count {|n| n.alive? }
+      case cell
+      when LiveCell
+        evaluate_live_cell(cell, live_neighbors_count)
+      when DeadCell
+        evaluate_dead_cell(cell, live_neighbors_count)
+      end
+    end
+
+    private
+
+    def evaluate_dead_cell(cell, live_neighbors_count)
+      if live_neighbors_count == 3
+        LiveCell.new
+      else
+        DeadCell.new
+      end
+    end
+
+    def evaluate_live_cell(cell, live_neighbors_count)
+      if live_neighbors_count < 2
+        DeadCell.new
+      elsif live_neighbors_count > 3
+        DeadCell.new
+      else
+        LiveCell.new
+      end
+    end
+  end
+end

data/lib/conway/visualizer/ascii.rb

@@ -0,0 +1,57 @@
+require "conway"
+
+module Conway
+  module Visualizer
+    class Ascii
+      def initialize(size, starting_cells, loop_interval=0.25)
+        self.max_x = self.max_y = size
+        self.starting_cells = starting_cells
+        self.loop_interval  = loop_interval
+      end
+
+      def loop
+        generation = Generation.new(starting_cells)
+        start      = Time.now
+
+        puts "They live!!\n\n"
+
+        begin
+          new_points = generation.cell_coordinates
+
+          if new_points.count == 0
+            puts "\nThey have all perished! D-:"
+            break
+          end
+
+          grid = ""
+          (1..max_y).each do |y|
+            (1..max_x).each do |x|
+              cell_char = cell_content_for(new_points, x,y)
+              grid << "|#{cell_char}"
+            end
+            grid << "|\n"
+          end
+
+          grid << "\n"
+
+          grid <<  "Total objects: #{ObjectSpace.count_objects[:TOTAL]} "
+          grid <<  "Total LiveCells: #{new_points.count}\n"
+
+          elapsed_minutes, elapsed_seconds = ((Time.now - start).to_i).divmod 60
+          grid << "Elapsed time: #{elapsed_minutes} min, #{elapsed_seconds} secs\n"
+
+          yield grid if block_given?
+
+          sleep(loop_interval)
+        end while(generation = generation.next)
+      end
+
+      private
+      attr_accessor :max_x, :max_y, :starting_cells, :loop_interval
+
+      def cell_content_for(points, x,y)
+        points.detect {|p| p.x == x && p.y == y } ? "X" : " "
+      end
+    end
+  end
+end

data/spec/conway/cell_location_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+include Conway
+
+describe CellLocation do
+  let(:cell_location) { CellLocation.new(LiveCell.new, Point.new(1,1)) }
+
+  it "has a cell" do
+    cell_location.cell.should be_a_kind_of(LiveCell)
+  end
+
+  it "has a point" do
+    cell_location.point.should be_a_kind_of(Point)
+  end
+
+  describe "#adjacent_points" do
+    it "is returns its point's adjacents" do
+      cell_location.adjacent_points.should == Point.new(1,1).adjacents
+    end
+  end
+end

data/spec/conway/cell_space_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+include Conway
+
+describe CellSpace do
+  it "accepts a collection of points" do
+    CellSpace.new [Point.new(0,0)]
+  end
+
+  describe "#apply" do
+    let(:space)    { CellSpace.new [Point.new(0,0)] }
+    let(:rule_set) { RuleSet.new }
+
+    it "returns a set of Points" do
+      space.apply(rule_set).all?{|p| p.kind_of?(Point)}.should be_true
+    end
+  end
+end

data/spec/conway/dead_cell_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Conway::DeadCell do
+
+  it "lives not" do
+    Conway::DeadCell.new.should_not be_alive
+  end
+
+end

data/spec/conway/generation_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+include Conway
+
+describe Generation do
+  let(:coordinates) { [Point.new(0,0), Point.new(1,1)] }
+  let(:generation)  { Generation.new(coordinates) }
+
+  describe "#cell_coordinates" do
+    it "returns points of current live cells" do
+      generation.cell_coordinates.should have(2).points
+      generation.cell_coordinates.should == coordinates
+    end
+  end
+
+  describe '#next' do
+    it 'returns the next Generation' do
+      generation.next.should be_a_kind_of(Generation)
+    end
+
+    it "that generation doesn't blow up" do
+      next_generation = generation.next
+      expect { next_generation.next }.to_not raise_error
+    end
+  end
+end

data/spec/conway/live_cell_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Conway::LiveCell do
+
+  it "lives" do
+    Conway::LiveCell.new.should be_alive
+  end
+end

data/spec/conway/point_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+include Conway
+
+describe Point do
+  let(:point) { Point.new 1,2 }
+
+  it "has x,y coordinates" do
+    point.x.should eql(1)
+    point.y.should eql(2)
+  end
+
+  describe "equality" do
+    it "should equal another point with the same coordinates" do
+      Point.new(1,2).should eql(Point.new(1,2))
+      Point.new(1,2).should ==  Point.new(1,2)
+    end
+  end
+
+  describe "#adjacents" do
+    let(:point) { Point.new(2,2) }
+    let(:neighbors) do
+      [Point.new(1,1),
+       Point.new(2,1),
+       Point.new(3,1),
+       Point.new(1,2),
+       Point.new(3,2),
+       Point.new(1,3),
+       Point.new(2,3),
+       Point.new(3,3)]
+    end
+
+    it "returns the eight adjacent points" do
+      point.adjacents.should == neighbors
+    end
+  end
+end
+

data/spec/conway/potential_cell_collection_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+include Conway
+
+describe PotentialCellCollection do
+  let(:live_cell)     { LiveCell.new }
+  let(:point)         { Point.new(1,1) }
+  let(:initial_cells) { [CellLocation.new(live_cell, point)] }
+  let(:collection)    { PotentialCellCollection.new(initial_cells) }
+
+  describe "#each_cell" do
+    it "contains the initial set of LiveCells" do
+      yielded_cells = []
+      collection.each_cell do |cell, dont_care|
+        yielded_cells << cell
+        cell
+      end
+      yielded_cells.should include(live_cell)
+    end
+
+    it "removes LiveCells that become DeadCells" do
+      collection.each_cell do |cell, neighbors|
+        DeadCell.new
+      end
+      collection.live_cell_locations.should be_empty
+    end
+
+    context "neighbors" do
+      let(:neighbor_cell) { LiveCell.new }
+      let(:initial_cells) do
+        [CellLocation.new(live_cell, point),
+         CellLocation.new(neighbor_cell, Point.new(1,2))]
+      end
+
+      it "yields the neighboring LiveCells" do
+        yielded_neighbors = nil
+        collection.each_cell do |cell, neighbors|
+          yielded_neighbors = neighbors
+          break
+        end
+
+        yielded_neighbors.should include(neighbor_cell)
+      end
+
+      it "yields the neighboring DeadCells" do
+        yielded_neighbors = nil
+        collection.each_cell do |cell, neighbors|
+          yielded_neighbors = neighbors
+          break
+        end
+
+        (yielded_neighbors - [neighbor_cell]).should have(7).neighbors
+      end
+
+      it "includes all neighboring DeadCells" do
+
+      end
+    end
+  end
+end

data/spec/conway/rule_set_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+include Conway
+
+describe RuleSet do
+  let(:rule_set) { RuleSet.new }
+  describe "#apply" do
+    context "when a DeadCell" do
+      let(:cell) { DeadCell.new }
+
+      it "returns a LiveCell when there are three live neighbors" do
+        new_cell = rule_set.apply(cell, [LiveCell.new] * 3)
+        new_cell.should be_alive
+      end
+
+      it "returns a DeadCell with fewer than three live neighbors" do
+        new_cell = rule_set.apply(cell, [LiveCell.new] * 2)
+        new_cell.should_not be_alive
+      end
+    end
+
+    context "when a LiveCell" do
+      let(:cell) { LiveCell.new }
+      it "returns a DeadCell when underpopulated" do
+        rule_set.apply(cell, [DeadCell.new] * 8).should_not be_alive
+      end
+
+      it "returns a LiveCell when sufficiently populated" do
+        new_cell = rule_set.apply(cell, [LiveCell.new] * 2)
+        new_cell.should be_alive
+      end
+
+      it "returns a LiveCell when sufficiently populated" do
+        new_cell = rule_set.apply(cell, [LiveCell.new] * 3)
+        new_cell.should be_alive
+      end
+
+      it "returns a DeadCell when over-populated" do
+        new_cell = rule_set.apply(cell, [LiveCell.new] * 4)
+        new_cell.should_not be_alive
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'conway'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: conway
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Matt Yoho
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-19 00:00:00 -05:00
+default_executable: conway
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: choice
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 4
+        version: 0.1.4
+  type: :runtime
+  version_requirements: *id001
+description: "\n     A simple implementation of Conway's Game of Life with an ASCII visualizer\n    "
+email: mby@mattyoho.com
+executables: 
+- conway
+extensions: []
+
+extra_rdoc_files: 
+- MIT-LICENSE
+- README.md
+files: 
+- MIT-LICENSE
+- README.md
+- lib/conway/cell_location.rb
+- lib/conway/cell_space.rb
+- lib/conway/dead_cell.rb
+- lib/conway/generation.rb
+- lib/conway/live_cell.rb
+- lib/conway/point.rb
+- lib/conway/potential_cell_collection.rb
+- lib/conway/rule_set.rb
+- lib/conway/visualizer/ascii.rb
+- lib/conway.rb
+- spec/conway/cell_location_spec.rb
+- spec/conway/cell_space_spec.rb
+- spec/conway/dead_cell_spec.rb
+- spec/conway/generation_spec.rb
+- spec/conway/live_cell_spec.rb
+- spec/conway/point_spec.rb
+- spec/conway/potential_cell_collection_spec.rb
+- spec/conway/rule_set_spec.rb
+- spec/spec_helper.rb
+- bin/conway
+has_rdoc: true
+homepage: http://github.com/mattyoho/conway
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A simple implementation of Conway's Game of Life with an ASCII visualizer . This version has significant reference leaks.
+test_files: 
+- spec/conway/cell_location_spec.rb
+- spec/conway/cell_space_spec.rb
+- spec/conway/dead_cell_spec.rb
+- spec/conway/generation_spec.rb
+- spec/conway/live_cell_spec.rb
+- spec/conway/point_spec.rb
+- spec/conway/potential_cell_collection_spec.rb
+- spec/conway/rule_set_spec.rb
+- spec/spec_helper.rb