conway 0.1.1 → 0.2.0

data/README.md

@@ -1,13 +1,13 @@
 ## Conway
 A simple Game of Life implementation with foremost focus on object design.
 
-It's currently very much leaky of object references and has no mind for
-efficiency.
+It's currently a bit leaky of object references and has not had efficiency
+optimization.
 
 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:
 
-    conway --size 25 --cells="2,3 3,3 2,2 5,4 5,8 9,8, 7,6"
+    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
 
 Please feel free to send feedback via the

data/bin/conway

@@ -5,7 +5,7 @@ lib_dir = File.join(File.dirname(__FILE__), '..', 'lib')
 $LOAD_PATH.unshift lib_dir if File.directory?(lib_dir)
 
 require 'choice'
-require 'conway/visualizer/ascii'
+require 'conway/driver/ascii'
 
 PROGRAM_VERSION = 1
 
@@ -69,7 +69,7 @@ Signal.trap("INT") do
 end
 
 live_points = ConwayCli.parse_points Choice[:cells]
-grid        = Conway::Visualizer::Ascii.new(Choice[:size], live_points)
+grid        = Conway::Driver::Ascii.new(Choice[:size], live_points)
 
 grid.loop do |step|
   puts step

data/lib/conway.rb

@@ -3,6 +3,7 @@ require 'conway/live_cell'
 require 'conway/dead_cell'
 require 'conway/point'
 require 'conway/cell_location'
+require 'conway/cell_location_lookup'
 require 'conway/potential_cell_collection'
 require 'conway/rule_set'
 require 'conway/cell_space'

data/lib/conway/cell_location_lookup.rb

@@ -0,0 +1,35 @@
+module Conway
+  class CellLocationLookup
+    def initialize
+      @hash  ||= {}
+      @point ||= Point.new(0,0)
+    end
+
+    def insert(cell_location)
+      @hash[cell_location.point] = cell_location
+    end
+
+    def retrieve(point_or_x, y=nil)
+      if y
+        point_or_x = @point.update(point_or_x, y)
+      end
+      @hash[point_or_x]
+    end
+
+    def locations
+      @hash.values
+    end
+
+    def count
+      locations.count
+    end
+
+    def empty?
+      !(count > 0)
+    end
+
+    def each(&block)
+      locations.each(&block)
+    end
+  end
+end

data/lib/conway/cell_space.rb

@@ -8,7 +8,7 @@ module Conway
       potential_cells.each_cell do |cell, neighbors|
         rule_set.apply(cell, neighbors)
       end
-      potential_cells.live_cell_locations.map {|cell_loc| cell_loc.point }
+      potential_cells.live_cell_lookup
     end
 
     private

data/lib/conway/driver/ascii.rb

@@ -0,0 +1,78 @@
+require "conway"
+
+module Conway
+  module Driver
+    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
+          lookup = generation.location_lookup
+
+          grid =  generate_grid(lookup)
+
+          grid << current_stats(lookup)
+          grid << elapsed_time_since(start)
+
+
+          yield grid if block_given?
+
+          if lookup.empty?
+            puts "\nThey have all perished! D-:"
+            break
+          end
+
+          sleep(loop_interval)
+        end while(generation = generation.next)
+      end
+
+      private
+      attr_accessor :max_x, :max_y, :starting_cells, :loop_interval
+
+      def generate_grid(lookup)
+        grid = ""
+        (1..max_y).each do |y|
+          (1..max_x).each do |x|
+            cell_char = cell_content_for(lookup, x, y)
+            grid << "|#{cell_char}"
+          end
+          grid << "|\n"
+        end
+        grid
+      end
+
+      def cell_content_for(lookup, x,y)
+        lookup.retrieve(x,y) ? "X" : " "
+      end
+
+      def current_stats(lookup)
+        stats =  "Total objects: #{live_object_count} "
+        stats << "Total living cells: #{lookup.count}\n"
+      end
+
+      def elapsed_time_since(start)
+        elapsed_minutes, elapsed_seconds = ((Time.now - start).to_i).divmod 60
+        "Elapsed time: #{elapsed_minutes} min, #{elapsed_seconds} secs\n"
+      end
+
+      def live_object_count
+        if ObjectSpace.respond_to?(:count_objects)
+          # Ruby 1.9.2
+          ObjectSpace.count_objects[:TOTAL]
+        else
+          # Ruby 1.8.7
+          ObjectSpace.live_objects
+        end
+      end
+    end
+  end
+end

data/lib/conway/generation.rb

@@ -1,16 +1,41 @@
 module Conway
   class Generation
-    attr_reader :cell_coordinates, :rule_set
+    attr_reader :location_lookup
 
-    def initialize(cell_coordinates=[], rule_set=RuleSet.new)
-      @cell_coordinates = cell_coordinates
-      @rule_set         = rule_set
+    def initialize(cell_locations, rule_set=RuleSet.new)
+      self.location_lookup = normalize_to_lookup cell_locations
+      self.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
+      cell_space   = CellSpace.new(cell_coordinates)
+      cell_lookup  = cell_space.apply(rule_set)
+      Generation.new cell_lookup, rule_set
+    end
+
+    def cell_coordinates
+      location_lookup.locations.map {|loc| loc.point }
+    end
+
+    private
+    attr_accessor :rule_set
+    attr_writer   :location_lookup
+
+    def normalize_to_lookup(points)
+      return points unless points.kind_of?(Array)
+
+      lookup = CellLocationLookup.new
+      points.each do |point|
+        loc = point_to_location(point)
+        lookup.insert(loc)
+      end
+
+      lookup
+    end
+
+    def point_to_location(point)
+      @live_cell ||= LiveCell.new
+      CellLocation.new(@live_cell, point)
     end
   end
 end

data/lib/conway/point.rb

@@ -21,6 +21,7 @@ module Conway
     def update(x, y)
       self.x = x
       self.y = y
+      self
     end
 
     def adjacents

data/lib/conway/potential_cell_collection.rb

@@ -1,45 +1,52 @@
 module Conway
   class PotentialCellCollection
+    attr_reader :live_cell_lookup
+
     def initialize(live_locations)
+      self.live_cell_lookup      = CellLocationLookup.new
+      self.potential_cell_lookup = CellLocationLookup.new
+      self.default_dead_cell     = DeadCell.new
+
       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 }
+      potential_cell_lookup.each do |cell_location|
+        neighbor_cells = neighbor_cells_for(cell_location)
 
-        new_cell = block.call(cell_loc.cell, neighbor_cells)
+        next_cell = block.call(cell_location.cell, neighbor_cells)
 
-        new_location = CellLocation.new(new_cell, cell_loc.point)
-        potential_cell_locations[cell_loc.point] = new_location
+        if next_cell.alive?
+          live_cell_lookup.insert(cell_location)
+        end
       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
+    attr_accessor :potential_cell_lookup, :default_dead_cell
+    attr_writer   :live_cell_lookup
 
     def identify_potential_locations(locations)
       locations.each do |loc|
-        potential_cell_locations[loc.point] = loc
+        potential_cell_lookup.insert(loc)
         neighbors_for(loc).each do |neighbor|
-          potential_cell_locations[neighbor.point] = neighbor
+          potential_cell_lookup.insert(neighbor)
         end
       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_locations[point]
+        potential_cell_lookup.retrieve(point) || dead_cell_location(point)
       end
     end
+
+    def neighbor_cells_for(location)
+      neighbors_for(location).map {|n| n.cell }
+    end
   end
 end

data/spec/conway/cell_location_lookup_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+include Conway
+
+describe CellLocationLookup do
+  let(:point)    { Point.new 1,1 }
+  let(:cell)     { LiveCell.new }
+  let(:location) { CellLocation.new cell, point }
+  let(:lookup)   { CellLocationLookup.new }
+
+  describe "#insert" do
+    it "accepts a CellLocation" do
+      lookup.insert location
+    end
+  end
+
+  describe "#retrieve" do
+    before { lookup.insert location }
+
+    it "looks up based on a point" do
+      lookup.retrieve(point).should eql(location)
+    end
+
+    it "looks up based on x,y" do
+      lookup.retrieve(1,1).should eql(location)
+    end
+  end
+
+  describe "#each" do
+    let(:point2)    { Point.new 2,2 }
+    let(:location2) { CellLocation.new cell, point2 }
+
+    before do
+      lookup.insert location
+      lookup.insert location2
+    end
+
+    it "yields each location once" do
+      locations = []
+      lookup.each do |loc|
+        locations << loc
+      end
+
+      locations.should have(2).locations
+      locations.should include(location)
+      locations.should include(location2)
+    end
+  end
+
+  describe "#locations" do
+    let(:point2)    { Point.new 2,2 }
+    let(:location2) { CellLocation.new cell, point2 }
+
+    before do
+      lookup.insert location
+      lookup.insert location2
+    end
+
+    it "is all the contained locations" do
+      lookup.locations.should have(2).locations
+      lookup.locations.should include(location)
+      lookup.locations.should include(location2)
+    end
+  end
+
+  describe "#count" do
+    let(:point2)    { Point.new 2,2 }
+    let(:location2) { CellLocation.new cell, point2 }
+
+    before do
+      lookup.insert location
+      lookup.insert location2
+    end
+
+    it "is the number of contained locations" do
+      lookup.count.should == 2
+    end
+  end
+
+  describe "#empty?" do
+    context "when the count is 0" do
+      it { should be_empty }
+    end
+
+    context "when the count is 1" do
+      before { subject.insert location }
+      it { should_not be_empty }
+    end
+  end
+end

data/spec/conway/cell_space_spec.rb

@@ -11,8 +11,8 @@ describe CellSpace 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
+    it "returns a CellLocationLookup" do
+      space.apply(rule_set).should be_a_kind_of(CellLocationLookup)
     end
   end
 end

data/spec/conway/generation_spec.rb

@@ -6,6 +6,17 @@ describe Generation do
   let(:coordinates) { [Point.new(0,0), Point.new(1,1)] }
   let(:generation)  { Generation.new(coordinates) }
 
+  describe "#initialize" do
+    it "accepts an array of Points" do
+      expect { generation.next }.to_not raise_error
+    end
+
+    it "accepts a CellLocationLookup" do
+      generation = Generation.new(CellLocationLookup.new)
+      expect { generation.next }.to_not raise_error
+    end
+  end
+
   describe "#cell_coordinates" do
     it "returns points of current live cells" do
       generation.cell_coordinates.should have(2).points

data/spec/conway/point_spec.rb

@@ -42,6 +42,10 @@ describe Point do
       point.x.should eql(1)
       point.y.should eql(3)
     end
+
+    it "returns self" do
+      point.update(4,2).should equal(point)
+    end
   end
 end
 

data/spec/conway/potential_cell_collection_spec.rb

@@ -5,7 +5,8 @@ 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(:cell_location) { CellLocation.new(live_cell, point) }
+  let(:initial_cells) { [cell_location] }
   let(:collection)    { PotentialCellCollection.new(initial_cells) }
 
   describe "#each_cell" do
@@ -18,11 +19,38 @@ describe PotentialCellCollection do
       yielded_cells.should include(live_cell)
     end
 
-    it "removes LiveCells that become DeadCells" do
-      collection.each_cell do |cell, neighbors|
-        DeadCell.new
+    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
-      collection.live_cell_locations.should be_empty
     end
 
     context "neighbors" do
@@ -53,7 +81,13 @@ describe PotentialCellCollection do
       end
 
       it "includes all neighboring DeadCells" do
+        yielded_neighbors = nil
+        collection.each_cell do |cell, neighbors|
+          yielded_neighbors = neighbors
+          break
+        end
 
+        (yielded_neighbors - [neighbor_cell]).any?{|c| c.alive?}.should be_false
       end
     end
   end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: conway
 version: !ruby/object:Gem::Version 
-  hash: 25
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Matt Yoho
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-20 00:00:00 -05:00
+date: 2011-01-21 00:00:00 -05:00
 default_executable: conway
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,7 +25,6 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        hash: 19
         segments: 
         - 0
         - 1
@@ -47,15 +45,17 @@ files:
 - MIT-LICENSE
 - README.md
 - lib/conway/cell_location.rb
+- lib/conway/cell_location_lookup.rb
 - lib/conway/cell_space.rb
 - lib/conway/dead_cell.rb
+- lib/conway/driver/ascii.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_lookup_spec.rb
 - spec/conway/cell_location_spec.rb
 - spec/conway/cell_space_spec.rb
 - spec/conway/dead_cell_spec.rb
@@ -80,7 +80,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -89,7 +88,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -99,8 +97,9 @@ 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.
+summary: A simple implementation of Conway's Game of Life with an ASCII visualizer . This version has fewer significant reference leaks.
 test_files: 
+- spec/conway/cell_location_lookup_spec.rb
 - spec/conway/cell_location_spec.rb
 - spec/conway/cell_space_spec.rb
 - spec/conway/dead_cell_spec.rb

data/lib/conway/visualizer/ascii.rb

@@ -1,69 +0,0 @@
-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
-          live_cells = generation.cell_coordinates
-
-          if live_cells.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(live_cells, x,y)
-              grid << "|#{cell_char}"
-            end
-            grid << "|\n"
-          end
-
-          grid << "\n"
-
-          grid <<  "Total objects: #{live_object_count} "
-          grid <<  "Total living cells: #{live_cells.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)
-        @comparison_point ||= Point.new(x,y)
-        @comparison_point.update(x,y)
-        points.detect {|p| p == @comparison_point } ? "X" : " "
-      end
-
-      def live_object_count
-        if ObjectSpace.respond_to?(:count_objects)
-          # Ruby 1.9.2
-          ObjectSpace.count_objects[:TOTAL]
-        else
-          # Ruby 1.8.7
-          ObjectSpace.live_objects
-        end
-      end
-    end
-  end
-end