conway 0.2.0 → 0.3.0

data/README.md

@@ -1,8 +1,9 @@
 ## Conway
-A simple Game of Life implementation with foremost focus on object design.
+A simple [Game of Life](http://en.wikipedia.org/wiki/Conway's_Game_of_Life)
+implementation with a priority focus on object design.
 
-It's currently a bit leaky of object references and has not had efficiency
-optimization.
+It's probably a bit leaky of object references and hasn't had any go at
+optimizing the efficiency of the algorithm.
 
 Conway comes with a very simple ASCII visualizer. It can be invoked as
 below, where the size argument determines the dimensions of the cell grid:
@@ -10,8 +11,10 @@ below, where the size argument determines the dimensions of the cell grid:
     conway --size 25 --cells="10,2 9,3 8,3 9,4 10,4"
     conway -s 30 -c 2,3:3,3:3,2:2,2:3,4
 
+When playing with the code itself, there's a sanity check Rake task:
+
+    rake glider
+
 Please feel free to send feedback via the
 [GitHub project](https://github.com/mattyoho/conway) or via email at
 mby _AT_ mattyoho _DOT_ com.
-
-

data/bin/conway

@@ -46,6 +46,13 @@ ConwayCli.suppress_warnings do
       default 30
     end
 
+    option :stats do
+      short '-S'
+      long  '--stats'
+      desc  'Display object count and elapsed time'
+      default false
+    end
+
     option :cells do
       short '-c'
       long  '--cells=CELLS'
@@ -69,7 +76,7 @@ Signal.trap("INT") do
 end
 
 live_points = ConwayCli.parse_points Choice[:cells]
-grid        = Conway::Driver::Ascii.new(Choice[:size], live_points)
+grid        = Conway::Driver::Ascii.new(Choice[:size], live_points, :display_stats => Choice[:stats])
 
 grid.loop do |step|
   puts step

data/lib/conway.rb

@@ -1,9 +1,10 @@
 require 'conway/generation'
 require 'conway/live_cell'
 require 'conway/dead_cell'
+require 'conway/memoized_cells'
 require 'conway/point'
 require 'conway/cell_location'
 require 'conway/cell_location_lookup'
 require 'conway/potential_cell_collection'
-require 'conway/rule_set'
+require 'conway/rules'
 require 'conway/cell_space'

data/lib/conway/cell_location_lookup.rb

@@ -1,7 +1,7 @@
 module Conway
   class CellLocationLookup
-    def initialize
-      @hash  ||= {}
+    def initialize(&block)
+      @hash  ||= block_given? ? Hash.new {|h,p| yield p } : {}
       @point ||= Point.new(0,0)
     end
 

data/lib/conway/cell_space.rb

@@ -1,23 +1,20 @@
 module Conway
   class CellSpace
-    def initialize(points)
-      self.potential_cells = PotentialCellCollection.new(live_locations(points))
+    def initialize(locations)
+      self.potential_cells = PotentialCellCollection.new(locations)
     end
 
-    def apply(rule_set)
-      potential_cells.each_cell do |cell, neighbors|
-        rule_set.apply(cell, neighbors)
+    def apply(rules, live_cell_lookup = CellLocationLookup.new)
+      potential_cells.each_location do |location, neighbors|
+        cell = rules.apply(location.cell, neighbors.map{|n| n.cell })
+        if cell.alive?
+          live_cell_lookup.insert(CellLocation.new(cell, location.point))
+        end
       end
-      potential_cells.live_cell_lookup
+      live_cell_lookup
     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/driver/ascii.rb

@@ -3,10 +3,10 @@ require "conway"
 module Conway
   module Driver
     class Ascii
-      def initialize(size, starting_cells, loop_interval=0.25)
+      def initialize(size, starting_cells, options={})
         self.max_x          = self.max_y = size
         self.starting_cells = starting_cells
-        self.loop_interval  = loop_interval
+        self.options        = {:loop_interval => 0.25}.merge(options)
       end
 
       def loop
@@ -20,9 +20,10 @@ module Conway
 
           grid =  generate_grid(lookup)
 
-          grid << current_stats(lookup)
-          grid << elapsed_time_since(start)
-
+          if options[:display_stats]
+            grid << current_stats(lookup)
+            grid << elapsed_time_since(start)
+          end
 
           yield grid if block_given?
 
@@ -31,12 +32,12 @@ module Conway
             break
           end
 
-          sleep(loop_interval)
+          sleep(options[:loop_interval])
         end while(generation = generation.next)
       end
 
       private
-      attr_accessor :max_x, :max_y, :starting_cells, :loop_interval
+      attr_accessor :max_x, :max_y, :starting_cells, :options
 
       def generate_grid(lookup)
         grid = ""

data/lib/conway/generation.rb

@@ -2,15 +2,15 @@ module Conway
   class Generation
     attr_reader :location_lookup
 
-    def initialize(cell_locations, rule_set=RuleSet.new)
-      self.location_lookup = normalize_to_lookup cell_locations
-      self.rule_set        = rule_set
+    def initialize(points_or_lookup, rules=Rules.new)
+      self.location_lookup = normalize_to_lookup points_or_lookup
+      self.rules           = rules
     end
 
     def next
-      cell_space   = CellSpace.new(cell_coordinates)
-      cell_lookup  = cell_space.apply(rule_set)
-      Generation.new cell_lookup, rule_set
+      cell_space   = CellSpace.new(location_lookup.locations)
+      cell_lookup  = cell_space.apply(rules)
+      Generation.new cell_lookup, rules
     end
 
     def cell_coordinates
@@ -18,7 +18,7 @@ module Conway
     end
 
     private
-    attr_accessor :rule_set
+    attr_accessor :rules
     attr_writer   :location_lookup
 
     def normalize_to_lookup(points)

data/lib/conway/memoized_cells.rb

@@ -0,0 +1,14 @@
+require 'conway/live_cell'
+require 'conway/dead_cell'
+
+module Conway
+  module MemoizedCells
+    def live_cell
+      @live_cell ||= LiveCell.new
+    end
+
+    def dead_cell
+      @dead_cell ||= DeadCell.new
+    end
+  end
+end

data/lib/conway/point.rb

@@ -19,12 +19,15 @@ module Conway
     end
 
     def update(x, y)
-      self.x = x
-      self.y = y
+      self.x     = x
+      self.y     = y
+      @adjacents = nil
+
       self
     end
 
     def adjacents
+      @adjacents ||=
       (-1..1).map do |j|
         (-1..1).map do |i|
           Point.new(x+i, y+j) unless i == 0 && j == 0

data/lib/conway/potential_cell_collection.rb

@@ -1,32 +1,27 @@
 module Conway
   class PotentialCellCollection
-    attr_reader :live_cell_lookup
+    include Conway::MemoizedCells
 
     def initialize(live_locations)
-      self.live_cell_lookup      = CellLocationLookup.new
-      self.potential_cell_lookup = CellLocationLookup.new
-      self.default_dead_cell     = DeadCell.new
+      self.potential_cell_lookup = CellLocationLookup.new do |point|
+        CellLocation.new(dead_cell, point)
+      end
 
-      identify_potential_locations(live_locations)
+      insert_potential_locations(live_locations)
     end
 
-    def each_cell(&block)
+    def each_location(&block)
       potential_cell_lookup.each do |cell_location|
-        neighbor_cells = neighbor_cells_for(cell_location)
-
-        next_cell = block.call(cell_location.cell, neighbor_cells)
+        neighbor_locations = neighbors_for(cell_location)
 
-        if next_cell.alive?
-          live_cell_lookup.insert(cell_location)
-        end
+        block.call(cell_location, neighbor_locations)
       end
     end
 
     private
-    attr_accessor :potential_cell_lookup, :default_dead_cell
-    attr_writer   :live_cell_lookup
+    attr_accessor :potential_cell_lookup
 
-    def identify_potential_locations(locations)
+    def insert_potential_locations(locations)
       locations.each do |loc|
         potential_cell_lookup.insert(loc)
         neighbors_for(loc).each do |neighbor|
@@ -35,18 +30,10 @@ module Conway
       end
     end
 
-    def dead_cell_location(point)
-      CellLocation.new(default_dead_cell, point)
-    end
-
     def neighbors_for(location)
       location.adjacent_points.map do |point|
-        potential_cell_lookup.retrieve(point) || dead_cell_location(point)
+        potential_cell_lookup.retrieve(point)
       end
     end
-
-    def neighbor_cells_for(location)
-      neighbors_for(location).map {|n| n.cell }
-    end
   end
 end

data/lib/conway/rules.rb

@@ -0,0 +1,27 @@
+require 'conway/rules/under_population'
+require 'conway/rules/stability'
+require 'conway/rules/over_population'
+require 'conway/rules/reproduction'
+require 'conway/rules/default'
+
+module Conway
+  class Rules
+    def initialize(rules=[UnderPopulation.new,
+                          Stability.new,
+                          OverPopulation.new,
+                          Reproduction.new,
+                          Default.new])
+      self.rules = rules
+    end
+
+    def apply(cell, neighbors)
+      rules.map do |rule|
+        next_cell = rule.apply(cell, neighbors)
+        break next_cell if next_cell
+      end
+    end
+
+    private
+    attr_accessor :rules
+  end
+end

data/lib/conway/rules/default.rb

@@ -0,0 +1,11 @@
+module Conway
+  class Rules
+    class Default
+      include Conway::MemoizedCells
+
+      def apply(cell, neighbors)
+        dead_cell
+      end
+    end
+  end
+end

data/lib/conway/rules/live_count.rb

@@ -0,0 +1,11 @@
+module Conway
+  class Rules
+    module LiveCount
+      private
+
+      def live_count(neighbors)
+        neighbors.count {|n| n.alive? }
+      end
+    end
+  end
+end

data/lib/conway/rules/over_population.rb

@@ -0,0 +1,22 @@
+require 'conway/rules/live_count'
+
+module Conway
+  class Rules
+    class OverPopulation
+      include Conway::Rules::LiveCount
+      include Conway::MemoizedCells
+
+      def apply(cell, neighbors)
+        count = live_count(neighbors)
+        dead_cell if cell.alive? && greater_than_three?(count)
+      end
+
+      private
+
+      def greater_than_three?(count)
+        count > 3
+      end
+    end
+  end
+end
+

data/lib/conway/rules/reproduction.rb

@@ -0,0 +1,21 @@
+require 'conway/rules/live_count'
+
+module Conway
+  class Rules
+    class Reproduction
+      include Conway::Rules::LiveCount
+      include Conway::MemoizedCells
+
+      def apply(cell, neighbors)
+        count = live_count(neighbors)
+        live_cell unless cell.alive? || fewer_or_greater_than_three?(count)
+      end
+
+      private
+
+      def fewer_or_greater_than_three?(count)
+        count != 3
+      end
+    end
+  end
+end

data/lib/conway/rules/stability.rb

@@ -0,0 +1,21 @@
+require 'conway/rules/live_count'
+
+module Conway
+  class Rules
+    class Stability
+      include Conway::Rules::LiveCount
+      include Conway::MemoizedCells
+
+      def apply(cell, neighbors)
+        count = live_count(neighbors)
+        live_cell if cell.alive? && two_or_three?(count)
+      end
+
+      private
+
+      def two_or_three?(count)
+        count == 2 || count == 3
+      end
+    end
+  end
+end

data/lib/conway/rules/under_population.rb

@@ -0,0 +1,21 @@
+require 'conway/rules/live_count'
+
+module Conway
+  class Rules
+    class UnderPopulation
+      include Conway::Rules::LiveCount
+      include Conway::MemoizedCells
+
+      def apply(cell, neighbors)
+        count = live_count(neighbors)
+        dead_cell if cell.alive? && less_than_two?(count)
+      end
+
+      private
+
+      def less_than_two?(count)
+        count < 2
+      end
+    end
+  end
+end

data/spec/conway/cell_location_lookup_spec.rb

@@ -8,6 +8,15 @@ describe CellLocationLookup do
   let(:location) { CellLocation.new cell, point }
   let(:lookup)   { CellLocationLookup.new }
 
+  describe "#initialize" do
+    context "given a block" do
+      it "uses the block for default returns from #retrieve" do
+        lookup = CellLocationLookup.new {|p| "Point: (#{p.x},#{p.y})" }
+        lookup.retrieve(point).should eql("Point: (1,1)")
+      end
+    end
+  end
+
   describe "#insert" do
     it "accepts a CellLocation" do
       lookup.insert location

data/spec/conway/cell_space_spec.rb

@@ -3,16 +3,42 @@ require 'spec_helper'
 include Conway
 
 describe CellSpace do
-  it "accepts a collection of points" do
-    CellSpace.new [Point.new(0,0)]
+  it "accepts a collection of CellLocations" do
+    CellSpace.new [CellLocation.new(LiveCell.new, Point.new(0,0))]
   end
 
   describe "#apply" do
-    let(:space)    { CellSpace.new [Point.new(0,0)] }
-    let(:rule_set) { RuleSet.new }
+    let(:cell)     { LiveCell.new }
+    let(:location) { CellLocation.new(cell, Point.new(0,0)) }
+    let(:space)    { CellSpace.new [location] }
+    let(:rules)    { Rules.new }
 
     it "returns a CellLocationLookup" do
-      space.apply(rule_set).should be_a_kind_of(CellLocationLookup)
+      space.apply(rules).should be_a_kind_of(CellLocationLookup)
+    end
+
+    context "when the Rules gives a LiveCell" do
+      let(:rules) { stub(:apply => LiveCell.new) }
+
+      it "retains the cell" do
+        live_cell_lookup = space.apply(rules)
+        locations        = live_cell_lookup.locations
+
+        locations.should have(9).locations
+
+        locations.all? {|loc| loc.cell.alive? }.should be_true
+      end
+    end
+
+    context "when the Rules gives a DeadCell" do
+      let(:cell_location) { CellLocation.new(DeadCell.new, point) }
+      let(:rules)         { stub(:apply => DeadCell.new) }
+
+      it "does not retain the cell" do
+        live_cell_lookup = space.apply(rules)
+        live_cell_lookup.should be_empty
+      end
     end
   end
+
 end

data/spec/conway/memoized_cells_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Conway::MemoizedCells do
+  let(:klass)    { Class.new.tap {|c| c.send(:include, Conway::MemoizedCells) } }
+  let(:instance) { klass.new }
+  describe "#live_cell" do
+    it "is alive" do
+      instance.live_cell.should be_alive
+    end
+
+    it "returns the same object across invocations" do
+      instance.live_cell.should equal(instance.live_cell)
+    end
+  end
+
+  describe "#dead_cell" do
+    it "is not alive" do
+      instance.dead_cell.should_not be_alive
+    end
+
+    it "returns the same object across invocations" do
+      instance.dead_cell.should equal(instance.dead_cell)
+    end
+  end
+end

data/spec/conway/point_spec.rb

@@ -33,6 +33,12 @@ describe Point do
     it "returns the eight adjacent points" do
       point.adjacents.should == neighbors
     end
+
+    it "memoizes the points" do
+      point.adjacents
+      Point.should_receive(:new).never
+      point.adjacents
+    end
   end
 
   describe "#update" do
@@ -46,6 +52,13 @@ describe Point do
     it "returns self" do
       point.update(4,2).should equal(point)
     end
+
+    it "clears the adjacents cache" do
+      point.adjacents
+      point.instance_variable_get("@adjacents").should_not be_nil
+      point.update(0, 0)
+      point.instance_variable_get("@adjacents").should be_nil
+    end
   end
 end
 

data/spec/conway/potential_cell_collection_spec.rb

@@ -10,84 +10,50 @@ describe PotentialCellCollection do
   let(:collection)    { PotentialCellCollection.new(initial_cells) }
 
   describe "#each_cell" do
-    it "contains the initial set of LiveCells" do
+    it "yields the initial set of LiveCells" do
       yielded_cells = []
-      collection.each_cell do |cell, dont_care|
+      collection.each_location do |cell, dont_care|
         yielded_cells << cell
         cell
       end
-      yielded_cells.should include(live_cell)
-    end
-
-    context "when the cell is a LiveCell" do
-      it "does not retain the cell if it becomes a DeadCell" do
-        collection.each_cell do |cell, neighbors|
-          DeadCell.new
-        end
-        collection.live_cell_lookup.should be_empty
-      end
-
-      it "retains the cell if it remains a LiveCell" do
-        collection.each_cell do |cell, neighbors|
-          LiveCell.new
-        end
-        collection.live_cell_lookup.locations.should include(cell_location)
-      end
-    end
-
-    context "when the cell is a DeadCell" do
-      let(:cell_location) { CellLocation.new(DeadCell.new, point) }
-
-      it "does not retain the cell if it remains a DeadCell" do
-        collection.each_cell do |cell, neighbors|
-          DeadCell.new
-        end
-        collection.live_cell_lookup.should be_empty
-      end
-
-      it "retains the cell if it remains a LiveCell" do
-        collection.each_cell do |cell, neighbors|
-          LiveCell.new
-        end
-        collection.live_cell_lookup.locations.should include(cell_location)
-      end
+      yielded_cells.should include(cell_location)
     end
 
     context "neighbors" do
-      let(:neighbor_cell) { LiveCell.new }
+      let(:neighbor_cell)     { LiveCell.new }
+      let(:neighbor_location) { CellLocation.new(neighbor_cell, Point.new(1,2)) }
       let(:initial_cells) do
-        [CellLocation.new(live_cell, point),
-         CellLocation.new(neighbor_cell, Point.new(1,2))]
+        [CellLocation.new(live_cell, point), neighbor_location]
       end
 
       it "yields the neighboring LiveCells" do
         yielded_neighbors = nil
-        collection.each_cell do |cell, neighbors|
+        collection.each_location do |cell, neighbors|
           yielded_neighbors = neighbors
           break
         end
 
-        yielded_neighbors.should include(neighbor_cell)
+        yielded_neighbors.should include(neighbor_location)
       end
 
-      it "yields the neighboring DeadCells" do
+      it "yields the neighboring locations with DeadCells" do
         yielded_neighbors = nil
-        collection.each_cell do |cell, neighbors|
+        collection.each_location do |loc, neighbors|
           yielded_neighbors = neighbors
           break
         end
 
-        (yielded_neighbors - [neighbor_cell]).should have(7).neighbors
+        (yielded_neighbors - [neighbor_location]).should have(7).neighbors
       end
 
       it "includes all neighboring DeadCells" do
         yielded_neighbors = nil
-        collection.each_cell do |cell, neighbors|
+        collection.each_location do |cell, neighbors|
           yielded_neighbors = neighbors
           break
         end
 
-        (yielded_neighbors - [neighbor_cell]).any?{|c| c.alive?}.should be_false
+        (yielded_neighbors - [neighbor_location]).any?{|c| c.kind_of?(LiveCell)}.should be_false
       end
     end
   end

data/spec/conway/rules/default_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+include Conway
+
+describe Rules::Default do
+  let(:rule)      { Rules::Default.new }
+  let(:cell)      { }
+  let(:neighbors) { }
+
+  it "returns nil" do
+    rule.apply(cell, neighbors).should_not be_alive
+  end
+end

data/spec/conway/rules/over_population_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+include Conway
+
+describe Rules::OverPopulation do
+  let(:rule) { Rules::OverPopulation.new }
+
+  context "when a DeadCell" do
+    let(:cell) { DeadCell.new }
+
+    context "with a bunch of live neighbors" do
+      let(:neighbors) { [LiveCell.new] * 8 }
+
+      it "returns nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+
+    context "with a bunch of dead neighbors" do
+      let(:neighbors) { [DeadCell.new] * 8 }
+
+      it "returns nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+  end
+
+  context "when a LiveCell" do
+    let(:cell) { LiveCell.new }
+
+    context "with less than two live neighbors" do
+      let(:neighbors) { [DeadCell.new] * 7 + [LiveCell.new] }
+
+      it "returns a nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+
+    context "with two live neighbors" do
+      let(:neighbors) { [DeadCell.new] * 6 + [LiveCell.new] * 2 }
+
+      it "returns nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+
+    context "with three live neighbors" do
+      let(:neighbors) { [DeadCell.new] * 5 + [LiveCell.new] * 3 }
+
+      it "returns nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+
+    context "with more than three live neighbors" do
+      let(:neighbors) { [DeadCell.new] * 4 + [LiveCell.new] * 4 }
+
+      it "returns a DeadCell" do
+        rule.apply(cell, neighbors).should_not be_alive
+      end
+    end
+  end
+end

data/spec/conway/rules/reproduction_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+include Conway
+
+describe Rules::Reproduction do
+  let(:rule) { Rules::Reproduction.new }
+
+  context "when a LiveCell" do
+    let(:cell) { LiveCell.new }
+
+    context "with a bunch of live neighbors" do
+      let(:neighbors) { [LiveCell.new] * 8 }
+
+      it "returns nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+
+    context "with a bunch of dead neighbors" do
+      let(:neighbors) { [DeadCell.new] * 8 }
+
+      it "returns nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+  end
+
+  context "when a DeadCell" do
+    let(:cell) { DeadCell.new }
+
+    context "with less than three live neighbors" do
+      let(:neighbors) { [DeadCell.new] * 6 + [LiveCell.new] * 2 }
+
+      it "returns nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+
+    context "with three live neighbors" do
+      let(:neighbors) { [DeadCell.new] * 5 + [LiveCell.new] * 3 }
+
+      it "returns a LiveCell" do
+        rule.apply(cell, neighbors).should be_alive
+      end
+    end
+
+    context "with more than three live neighbors" do
+      let(:neighbors) { [DeadCell.new] * 4 + [LiveCell.new] * 4 }
+
+      it "returns nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+  end
+end

data/spec/conway/rules/stability_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+include Conway
+
+describe Rules::Stability do
+  let(:rule) { Rules::Stability.new }
+
+  context "when a DeadCell" do
+    let(:cell) { DeadCell.new }
+
+    context "with a bunch of live neighbors" do
+      let(:neighbors) { [LiveCell.new] * 8 }
+
+      it "returns nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+
+    context "with a bunch of dead neighbors" do
+      let(:neighbors) { [DeadCell.new] * 8 }
+
+      it "returns nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+  end
+
+  context "when a LiveCell" do
+    let(:cell) { LiveCell.new }
+
+    context "with less than two live neighbors" do
+      let(:neighbors) { [DeadCell.new] * 7 + [LiveCell.new] }
+
+      it "returns nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+
+    context "with two live neighbors" do
+      let(:neighbors) { [DeadCell.new] * 6 + [LiveCell.new] * 2 }
+
+      it "returns a LiveCell" do
+        rule.apply(cell, neighbors).should be_alive
+      end
+    end
+
+    context "with three live neighbors" do
+      let(:neighbors) { [DeadCell.new] * 5 + [LiveCell.new] * 3 }
+
+      it "returns a LiveCell" do
+        rule.apply(cell, neighbors).should be_alive
+      end
+    end
+
+    context "with more than three live neighbors" do
+      let(:neighbors) { [DeadCell.new] * 4 + [LiveCell.new] * 4 }
+
+      it "returns nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+  end
+end

data/spec/conway/rules/under_population_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+include Conway
+
+describe Rules::UnderPopulation do
+  let(:rule) { Rules::UnderPopulation.new }
+
+  context "when a DeadCell" do
+    let(:cell) { DeadCell.new }
+
+    context "with a bunch of live neighbors" do
+      let(:neighbors) { [LiveCell.new] * 8 }
+
+      it "returns nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+
+    context "with a bunch of dead neighbors" do
+      let(:neighbors) { [DeadCell.new] * 8 }
+
+      it "returns nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+  end
+
+  context "when a LiveCell" do
+    let(:cell) { LiveCell.new }
+
+    context "with less than two live neighbors" do
+      let(:neighbors) { [DeadCell.new] * 7 + [LiveCell.new] }
+
+      it "returns a DeadCell" do
+        rule.apply(cell, neighbors).should_not be_alive
+      end
+    end
+
+    context "with two live neighbors" do
+      let(:neighbors) { [DeadCell.new] * 6 + [LiveCell.new] * 2 }
+
+      it "returns nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+
+    context "with more than two live neighbors" do
+      let(:neighbors) { [DeadCell.new] * 5 + [LiveCell.new] * 3 }
+
+      it "returns nil" do
+        rule.apply(cell, neighbors).should be_nil
+      end
+    end
+  end
+end

data/spec/conway/rules_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+include Conway
+
+describe Rules do
+  describe "#apply" do
+    let(:cell)      { LiveCell.new }
+    let(:neighbors) { [LiveCell.new] }
+    let(:a_rule)    { stub }
+    let(:b_rule)    { stub }
+    let(:c_rule)    { stub }
+    let(:rule_set)  { [a_rule, b_rule, c_rule] }
+    let(:rules)     { Rules.new(rule_set) }
+
+    it "calls apply for each sub rule" do
+      rule_set.each {|r| r.should_receive(:apply).with(cell, neighbors) }
+      rules.apply(cell, neighbors)
+    end
+
+    context "return value" do
+      let(:a_rule)    { stub(:apply => nil) }
+      let(:b_rule)    { stub(:apply => :b) }
+      let(:c_rule)    { stub(:apply => :c) }
+
+      it "returns the first non-nil result" do
+        rules.apply(cell, neighbors).should == :b
+      end
+    end
+  end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Matt Yoho
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-21 00:00:00 -05:00
+date: 2011-01-24 00:00:00 -05:00
 default_executable: conway
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -51,9 +51,16 @@ files:
 - lib/conway/driver/ascii.rb
 - lib/conway/generation.rb
 - lib/conway/live_cell.rb
+- lib/conway/memoized_cells.rb
 - lib/conway/point.rb
 - lib/conway/potential_cell_collection.rb
-- lib/conway/rule_set.rb
+- lib/conway/rules/default.rb
+- lib/conway/rules/live_count.rb
+- lib/conway/rules/over_population.rb
+- lib/conway/rules/reproduction.rb
+- lib/conway/rules/stability.rb
+- lib/conway/rules/under_population.rb
+- lib/conway/rules.rb
 - lib/conway.rb
 - spec/conway/cell_location_lookup_spec.rb
 - spec/conway/cell_location_spec.rb
@@ -61,9 +68,15 @@ files:
 - spec/conway/dead_cell_spec.rb
 - spec/conway/generation_spec.rb
 - spec/conway/live_cell_spec.rb
+- spec/conway/memoized_cells_spec.rb
 - spec/conway/point_spec.rb
 - spec/conway/potential_cell_collection_spec.rb
-- spec/conway/rule_set_spec.rb
+- spec/conway/rules/default_spec.rb
+- spec/conway/rules/over_population_spec.rb
+- spec/conway/rules/reproduction_spec.rb
+- spec/conway/rules/stability_spec.rb
+- spec/conway/rules/under_population_spec.rb
+- spec/conway/rules_spec.rb
 - spec/spec_helper.rb
 - bin/conway
 has_rdoc: true
@@ -105,7 +118,13 @@ test_files:
 - spec/conway/dead_cell_spec.rb
 - spec/conway/generation_spec.rb
 - spec/conway/live_cell_spec.rb
+- spec/conway/memoized_cells_spec.rb
 - spec/conway/point_spec.rb
 - spec/conway/potential_cell_collection_spec.rb
-- spec/conway/rule_set_spec.rb
+- spec/conway/rules/default_spec.rb
+- spec/conway/rules/over_population_spec.rb
+- spec/conway/rules/reproduction_spec.rb
+- spec/conway/rules/stability_spec.rb
+- spec/conway/rules/under_population_spec.rb
+- spec/conway/rules_spec.rb
 - spec/spec_helper.rb

data/lib/conway/rule_set.rb

@@ -1,33 +0,0 @@
-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/spec/conway/rule_set_spec.rb

@@ -1,44 +0,0 @@
-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