golr 0.5.1

data/bin/golr

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+require 'golr'
+require 'optparse'
+
+options = { :generations => 100 }
+
+optparse = OptionParser.new do |opts|
+  opts.banner =
+  "\nUsage: golr game-file [options]\n\nValid options are\n"
+
+  opts.on("-h", "--help", "Print this help") do |h|
+    puts opts.banner
+    puts opts.summarize
+    puts "\n"
+    exit 0
+  end
+
+  opts.on("-g", "--generations [NUMBER]", "Evolve game through this many generations [defaults to 100]") do |g|
+    options[:generations] = g.to_i
+  end
+end
+
+optparse.parse!
+
+# load game from file
+game_file = ARGV[0]
+begin
+  game_string = File.read(game_file)
+  game = Golr::GameReader.from_string(game_string)
+rescue Errno::ENOENT, Errno::EACCES => e
+  puts "Cannot read #{game_file} - Does it exist and is it readable?"
+  exit 1
+end
+
+# evolve through generations
+generations = options[:generations]
+puts 'Generation #0'
+Golr::GamePrinter.print(game)
+generation = 1
+generations.times.each do
+  game.evolve
+  puts "Generation \##{generation}"
+  Golr::GamePrinter.print(game)
+  generation += 1
+end

data/lib/golr.rb

@@ -0,0 +1,4 @@
+require 'golr/game'
+require 'golr/game_reader'
+require 'golr/game_printer'
+

data/lib/golr/game.rb

@@ -0,0 +1,76 @@
+require 'golr/key'
+require 'golr/rules'
+
+module Golr
+
+  class Game
+
+    attr_reader :grid, :columns, :rows
+
+    def initialize(columns, rows, living_cells = [])
+      @columns = columns
+      @rows = rows
+      @grid = init_grid(living_cells)
+      @rules = Rules.new
+    end
+
+    def init_grid(living_cells = [])
+      new_grid = {}
+      Range.new(1, @columns).to_a.each do |x|
+        Range.new(1, @rows).to_a.each do |y|
+          key = Key.key(x, y)
+          new_grid[key] = living_cells.include?(key) ? true : false
+        end
+      end
+      new_grid
+    end
+    private :init_grid
+
+    def evolve
+      next_grid = init_grid
+      @grid.each_key do |key|
+        next_grid[key] = @rules.evaluate(living_neighbors(key), alive?(key))
+      end
+      @grid = next_grid
+      self
+    end
+
+    def alive?(key)
+      @grid[key] == true
+    end
+
+    def living_neighbors(key)
+      living_neighbors = neighboring_keys(key).inject(0) do |result, _key|
+        folded_key = fold_key_if_required(_key)
+        result += 1 if alive?(folded_key)
+        result
+      end
+    end
+    private :living_neighbors
+
+    def neighboring_keys(key)
+      neighbor_keys = []
+      x,y = Key.coordinates(key)
+      ((x-1)..(x+1)).to_a.each do |_x|
+        ((y-1)..(y+1)).to_a.each do |_y|
+          neighbor_keys << Key.key(_x,_y) unless x == _x && y == _y
+        end
+      end
+      neighbor_keys
+    end
+    private :neighboring_keys
+
+    # FIXME: smelly
+    def fold_key_if_required(key)
+      x,y = Key.coordinates(key)
+      _x = x < 1 ? @columns : x
+      _x = _x > @columns ? 1 : _x
+      _y = y < 1 ? @rows : y
+      _y = _y > @rows ? 1 : _y
+      Key.key(_x,_y)
+    end
+    private :fold_key_if_required
+
+  end
+
+end

data/lib/golr/game_printer.rb

@@ -0,0 +1,31 @@
+module Golr
+
+  class GamePrinter
+
+    def self.print(game, io = STDOUT)
+      line_feed(io)
+      print_game_state(game, io)
+      line_feed(io)
+    end
+
+
+    private
+
+    def self.line_feed(io)
+      printf(io, "\n")
+    end
+
+    def self.print_game_state(game, io)
+      Range.new(1, game.rows).to_a.each do |y|
+        printf(io, '|')
+        Range.new(1, game.columns).to_a.each do |x|
+          printf(io, game.grid[Key.key(x,y)] == true ? 'o' : ' ')
+        end
+        printf(io, '|')
+        line_feed(io)
+      end
+    end
+
+  end
+
+end

data/lib/golr/game_reader.rb

@@ -0,0 +1,39 @@
+module Golr
+
+  class GameReader
+
+    def self.from_string(multi_line_string)
+      keys = []
+      row = 1
+      columns = count_columns(multi_line_string)
+      multi_line_string.split(/\r?\n/).each do |line|
+        keys |= keys_from_line(line, row)
+        row += 1
+      end
+      rows = row - 1
+      Game.new(columns, rows, keys)
+    end
+
+    private
+
+    def self.count_columns(multi_line_string)
+      first_line = multi_line_string.split(/\r\n?|\n/).first
+      first_line.strip.bytesize - 2
+      # TODO: not entirely clear why this works even on Travis, while string.size did not
+    end
+
+    def self.keys_from_line(line, row)
+      char_in_line = 1
+      keys_in_line = []
+      line.strip!
+      line.gsub!('|','')
+      line.each_char do |c|
+        keys_in_line << Key.key(char_in_line, row) if c == 'o'
+        char_in_line += 1
+      end
+      keys_in_line
+    end
+
+  end
+
+end

data/lib/golr/key.rb

@@ -0,0 +1,16 @@
+module Golr
+
+  class Key
+
+    def self.key(x, y)
+      "#{x}_#{y}"
+    end
+
+    def self.coordinates(key)
+      split = key.split('_')
+      [split[0].to_i, split[1].to_i]
+    end
+
+  end
+
+end

data/lib/golr/rules.rb

@@ -0,0 +1,9 @@
+module Golr
+  class Rules
+    def evaluate(living_neighbors, cell_alive = false)
+      return true if living_neighbors == 3
+      return true if cell_alive && living_neighbors == 2
+      false
+    end
+  end
+end

data/lib/golr/version.rb

@@ -0,0 +1,3 @@
+module Golr
+  VERSION = "0.5.1"
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: golr
+version: !ruby/object:Gem::Version
+  version: 0.5.1
+  prerelease: 
+platform: ruby
+authors:
+- Markus Krogemann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.3
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+description: Offers methods to initialize and evolve a grid of cells, implementing
+  the rules of Conway's Game of Life
+email:
+- markus@krogemann.de
+executables:
+- golr
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/golr/game.rb
+- lib/golr/game_printer.rb
+- lib/golr/game_reader.rb
+- lib/golr/key.rb
+- lib/golr/rules.rb
+- lib/golr/version.rb
+- lib/golr.rb
+- bin/golr
+homepage: https://github.com/mkrogemann/golr
+licenses:
+- MIT
+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.25
+signing_key: 
+specification_version: 3
+summary: Conway's Game of Life
+test_files: []