lifelike 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b0f8ff229a6f20aac5756a3122d51847238cb654
+  data.tar.gz: d47628a5cdfe439f30cbe59c964aea9f01ffe8b9
+SHA512:
+  metadata.gz: c423f41ddcb779269309a091582f9e573c3ffd4aa514dde9de51cd97aa902fc018f282a8095f7e855b1a3427ef9094f8a033f4abca578b0bbfefcf4d5994b3f3
+  data.tar.gz: 591891b01d827562c74dc27e7d6e9a9adcf8baf254d41522ba3c3c2a1333a5d18f3e5018b36fb5f898953e55e762670f7379230414dc14d99b727912fa127f92

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,26 @@
+Metrics/LineLength:
+  Exclude:
+    - spec/*
+
+Metrics/MethodLength:
+  Max: 9
+
+Lint/HandleExceptions:
+  Exclude:
+    - Rakefile
+
+Style/TrivialAccessors:
+  AllowPredicates: true
+
+Style/TrailingComma:
+  Enabled: false
+
+Style/RaiseArgs:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/RegexpLiteral:
+  MaxSlashes: 0
+

data/.ruby-version

@@ -0,0 +1 @@
+2.2.0

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.0
+  - 2.1.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lifelike.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Max Holder
+
+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,132 @@
+# Lifelike
+
+[![Build
+Status](https://travis-ci.org/mxhold/lifelike.svg?branch=master)](https://travis-ci.org/mxhold/lifelike)
+[![Code
+Climate](https://codeclimate.com/github/mxhold/lifelike/badges/gpa.svg)](https://codeclimate.com/github/mxhold/lifelike)
+[![Test
+Coverage](https://codeclimate.com/github/mxhold/lifelike/badges/coverage.svg)](https://codeclimate.com/github/mxhold/lifelike)
+
+Lifelike plays [Conway's Game of
+Life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life) by default but it
+can be used to simulate any [Life-like cellular
+automata](https://en.wikipedia.org/wiki/Life-like_cellular_automaton).
+
+## Rationale
+
+This gem is inspired by the [Global Day of
+Coderetreat](http://globalday.coderetreat.org/) where participants attempt to
+implement Conway's Game of Life under various constraints.
+
+The goal of this implementation is to make the code as well-factored as possible
+rather than as efficient as possible.
+
+## Installation
+
+    $ gem install lifelike
+
+## Usage
+
+By default, Lifelike plays [Conway's Game of
+Life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life).
+
+It gets it initial state from standard input or a file and then prints the next
+generation:
+
+```bash
+$ echo "...\nooo\n..." > blinker
+$ cat blinker
+...
+ooo
+...
+$ cat blinker | lifelike
+.o.
+.o.
+.o.
+$ lifelike blinker
+.o.
+.o.
+.o.
+```
+
+### Multiple generations
+
+You can also provide a number of generations to simulate before printing:
+
+```bash
+$ echo "..o..\no.o..\n.oo..\n....." > glider
+$ cat glider
+..o..
+o.o..
+.oo..
+.....
+$ cat glider | lifelike -c 4
+.....
+...o.
+.o.o.
+..oo.
+```
+
+### Alternate dead/alive characters
+
+You don't have to use `o` and `.` to represent life and death.
+Lifelike will be smart and try to guess based on the input provided:
+
+```bash
+$ echo "000\n111\n000" | lifelike
+010
+010
+010
+$ echo "   \nXXX\n   " | lifelike
+ X
+ X
+ X
+```
+
+You can use any combination of two of the following characters (which are in
+order here from what lifelike will consider more dead to more alive):
+
+    <space> _ . , o O 0 1 x * X # @
+
+### Game of Life variants
+
+You can define the rules Lifelike will use with the `-r` flag.
+
+By default, it uses the rules for Conway's Game of Life, which are `B3/S23`.
+
+This format of specifying the rules means:
+
+- It takes 3 live neighbors for a cell to be **b**orn
+- It takes 2 or 3 live neighbors for a cell to **s**tay alive
+
+One interesting variant is called
+[Seeds](https://en.wikipedia.org/wiki/Seeds_(cellular_automaton)) which has the
+rule `B2/S`, meaning:
+
+- It takes 2 live neighbors for a cell to be born
+- No cells ever survive
+
+This is how you would make Lifelike play this variant:
+
+```bash
+$ echo ".......\n.......\n..oo..\n.......\n......." | lifelike -r "B2/S"
+.......
+..oo...
+......
+..oo...
+.......
+$ echo ".......\n.......\n..oo..\n.......\n......." | lifelike -r "B2/S" -c 2
+..oo...
+.......
+.o..o.
+.......
+..oo...
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/mxhold/lifelike/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler/gem_tasks'
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new(:rubocop)
+
+  task default: [:spec, :rubocop]
+rescue LoadError
+end

data/bin/lifelike

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'lifelike'
+require 'lifelike/cli'
+
+Lifelike::CLI.invoke

data/lib/lifelike/cli/options.rb

@@ -0,0 +1,65 @@
+require 'optparse'
+module Lifelike
+  module CLI
+    class Options
+      def self.parse!(argv)
+        new.parse!(argv)
+      end
+
+      def initialize
+        @options = default_options
+      end
+
+      def parse!(argv)
+        option_parser.parse!(argv)
+        @options
+      end
+
+      private
+
+      def default_options
+        {
+          generations: 1,
+          rule_string: 'B3/S23'
+        }
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def option_parser
+        OptionParser.new do |opts|
+          opts.banner = 'Usage: lifelike [options] [file]'
+          opts.separator 'Options:'
+
+          opts.on(
+            '-c [iterations]',
+            '--count [iterations]',
+            'Number of iterations to perform' \
+            "(default #{default_options[:generations]})"
+          ) do |c|
+            @options[:generations] = c.to_i
+          end
+
+          opts.on(
+            '-r [rule_string]',
+            '--rules [rule_string]',
+            'Rules for the life-like cellular automaton ' \
+            "(default #{default_options[:rules]})"
+          ) do |rule_string|
+            @options[:rule_string] = rule_string
+          end
+
+          opts.on('-h', '--help', 'Prints this message') do
+            puts opts
+            exit
+          end
+
+          opts.on('-v', '--version', 'Prints the version') do
+            puts Lifelike::VERSION
+            exit
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+    end
+  end
+end

data/lib/lifelike/cli.rb

@@ -0,0 +1,25 @@
+require 'lifelike/cli/options'
+module Lifelike
+  module CLI
+    # Conventional exit codes from BSD's sysexits.h
+    # See: https://www.freebsd.org/cgi/man.cgi?query=sysexits
+    EX_USAGE = 64 # Command was used incorrectly
+    EX_DATAERR = 65 # Input data was incorrect
+
+    def self.invoke
+      options = Options.parse!(ARGV)
+      puts Runner.new(ARGF.read, options).run
+      exit
+    rescue OptionParser::ParseError, UnparsableRuleStringError => e
+      report_error e
+      exit EX_USAGE
+    rescue UnexpectedCharacterError, InsufficientValidCharacterError => e
+      report_error e
+      exit EX_DATAERR
+    end
+
+    def self.report_error(error)
+      $stderr.puts "lifelike: #{error}"
+    end
+  end
+end

data/lib/lifelike/error.rb

@@ -0,0 +1,26 @@
+module Lifelike
+  class LifelikeError < StandardError
+  end
+
+  class InsufficientValidCharacterError < LifelikeError
+    def initialize(valid_characters)
+      super 'Insufficient characters for determining life/death. ' \
+        'Expected two of the following characters: ' \
+        "#{valid_characters.map { |c| "\"#{c}\"" }.join(', ') }"
+    end
+  end
+
+  class UnexpectedCharacterError < LifelikeError
+    def initialize(character, expected:)
+      super "Unexpected character: \"#{character}\" " \
+        "Expected: #{expected.map { |c| "\"#{c}\"" }.join(' or ')}"
+    end
+  end
+
+  class UnparsableRuleStringError < LifelikeError
+    def initialize(rule_string)
+      super "Unparsable rule string: \"#{rule_string}\" " \
+        'Expected something like: "B3/S23"'
+    end
+  end
+end

data/lib/lifelike/grid.rb

@@ -0,0 +1,60 @@
+module Lifelike
+  class Grid
+    ROW_DELIMITER = "\n"
+    CELL_DELIMITER = ''
+
+    def initialize(rows)
+      @rows = rows
+    end
+
+    def self.from_s(string)
+      new(
+        string.split(ROW_DELIMITER).map do |row_string|
+          row_string.split(CELL_DELIMITER).map do |char|
+            yield(char)
+          end
+        end
+      )
+    end
+
+    def map_with_neighbors
+      self.class.new(
+        @rows.map.with_index do |row, row_index|
+          row.map.with_index do |cell, col_index|
+            yield(cell, neighbors(row_index, col_index))
+          end
+        end
+      )
+    end
+
+    def to_s
+      @rows.map do |row|
+        row.map do |cell|
+          yield(cell)
+        end.join(CELL_DELIMITER)
+      end.join(ROW_DELIMITER)
+    end
+
+    private
+
+    def neighbors(row_index, col_index)
+      neighbor_shifts.flat_map do |row_shift, col_shift|
+        nonwrapping_fetch(row_index + row_shift, col_index + col_shift)
+      end.compact
+    end
+
+    # rubocop:disable all
+    def neighbor_shifts
+      [
+        [-1, -1], [-1,  0], [-1,  1],
+        [ 0, -1],           [ 0,  1],
+        [ 1, -1], [ 1,  0], [ 1,  1],
+      ]
+    end
+    # rubocop:enable all
+
+    def nonwrapping_fetch(row_index, col_index)
+      @rows.fetch(row_index, [])[col_index] if row_index >= 0 && col_index >= 0
+    end
+  end
+end

data/lib/lifelike/lifelike_cellular_automaton/cell.rb

@@ -0,0 +1,33 @@
+module Lifelike
+  class LifelikeCellularAutomaton
+    class Cell
+      def initialize(alive, rules)
+        @alive = alive
+        @rules = rules
+      end
+
+      def alive?
+        @alive
+      end
+
+      def tick(neighbors)
+        @neighbors = neighbors
+        self.class.new(alive_next?, @rules)
+      end
+
+      private
+
+      def alive_next?
+        if alive?
+          @rules.survives?(alive_neighbor_count)
+        else
+          @rules.born?(alive_neighbor_count)
+        end
+      end
+
+      def alive_neighbor_count
+        @neighbors.select(&:alive?).size
+      end
+    end
+  end
+end

data/lib/lifelike/lifelike_cellular_automaton/cell_serializer.rb

@@ -0,0 +1,43 @@
+module Lifelike
+  class LifelikeCellularAutomaton
+    class CellSerializer
+      def initialize(alive_char:, dead_char:, rules:)
+        @alive_char = alive_char
+        @dead_char = dead_char
+        @rules = rules
+      end
+
+      def dump(cell)
+        if cell.alive?
+          @alive_char
+        else
+          @dead_char
+        end
+      end
+
+      def load(char)
+        Cell.new(alive?(char), @rules)
+      end
+
+      private
+
+      def alive?(char)
+        case char
+        when @alive_char
+          true
+        when @dead_char
+          false
+        else
+          handle_unexpected_character(char)
+        end
+      end
+
+      def handle_unexpected_character(char)
+        fail UnexpectedCharacterError.new(
+          char,
+          expected: [@alive_char, @dead_char]
+        )
+      end
+    end
+  end
+end

data/lib/lifelike/lifelike_cellular_automaton/rules.rb

@@ -0,0 +1,47 @@
+module Lifelike
+  class LifelikeCellularAutomaton
+    class Rules
+      def initialize(string)
+        @rule_string = RuleString.new(string)
+      end
+
+      def survives?(alive_neighbor_count)
+        @rule_string.alive_neighbors_to_survive.include?(alive_neighbor_count)
+      end
+
+      def born?(alive_neighbor_count)
+        @rule_string.alive_neighbors_to_be_born.include?(alive_neighbor_count)
+      end
+    end
+
+    class RuleString
+      # See: http://www.conwaylife.com/wiki/Rule#Rules
+      # Example: B3/S23
+      def initialize(string)
+        @string = string
+      end
+
+      def alive_neighbors_to_be_born
+        numbers_after('B')
+      end
+
+      def alive_neighbors_to_survive
+        numbers_after('S')
+      end
+
+      private
+
+      def numbers_after(letter)
+        if (characters = numeric_characters_after(letter))
+          characters.split('').map(&:to_i)
+        else
+          fail UnparsableRuleStringError.new(@string)
+        end
+      end
+
+      def numeric_characters_after(letter)
+        @string[/#{letter}(\d*)/, 1]
+      end
+    end
+  end
+end

data/lib/lifelike/lifelike_cellular_automaton/world.rb

@@ -0,0 +1,24 @@
+module Lifelike
+  class LifelikeCellularAutomaton
+    class World
+      attr_reader :cell_grid
+      def initialize(cell_grid)
+        @cell_grid = cell_grid
+      end
+
+      def tick(generations)
+        (1..generations).reduce(self) do |world, _|
+          world.tick_once
+        end
+      end
+
+      def tick_once
+        self.class.new(
+          @cell_grid.map_with_neighbors do |cell, neighbors|
+            cell.tick(neighbors)
+          end
+        )
+      end
+    end
+  end
+end

data/lib/lifelike/lifelike_cellular_automaton/world_serializer.rb

@@ -0,0 +1,31 @@
+module Lifelike
+  class LifelikeCellularAutomaton
+    class WorldSerializer
+      def initialize(cell_serializer)
+        @cell_serializer = cell_serializer
+      end
+
+      def load(string)
+        World.new(string_to_cell_grid(string))
+      end
+
+      def dump(world)
+        cell_grid_to_string(world.cell_grid)
+      end
+
+      private
+
+      def string_to_cell_grid(string)
+        Grid.from_s(string) do |char|
+          @cell_serializer.load(char)
+        end
+      end
+
+      def cell_grid_to_string(cell_grid)
+        cell_grid.to_s do |cell|
+          @cell_serializer.dump(cell)
+        end
+      end
+    end
+  end
+end

data/lib/lifelike/lifelike_cellular_automaton/world_string_analyzer.rb

@@ -0,0 +1,82 @@
+module Lifelike
+  class LifelikeCellularAutomaton
+    class WorldStringAnalyzer
+      def initialize(string, default_dead_char: ' ', default_alive_char: 'X')
+        @world_string = string
+        @default_dead_char = default_dead_char
+        @default_alive_char = default_alive_char
+      end
+
+      def dead_char
+        case valid_chars.size
+        when 0
+          fail InsufficientValidCharacterError.new(allowed_chars_by_aliveness)
+        when 1
+          deadlike_char || @default_dead_char
+        else
+          least_alive_valid_char
+        end
+      end
+
+      def alive_char
+        case valid_chars.size
+        when 0
+          fail InsufficientValidCharacterError.new(allowed_chars_by_aliveness)
+        when 1
+          lifelike_char || @default_alive_char
+        else
+          most_alive_valid_char
+        end
+      end
+
+      private
+
+      def deadlike_char
+        valid_char if deadlike.include?(valid_char)
+      end
+
+      def lifelike_char
+        valid_char if lifelike.include?(valid_char)
+      end
+
+      def valid_char
+        valid_chars.first
+      end
+
+      def least_alive_valid_char
+        valid_chars_by_aliveness.first
+      end
+
+      def most_alive_valid_char
+        valid_chars_by_aliveness.last
+      end
+
+      def valid_chars_by_aliveness
+        valid_chars.take(2).sort_by { |char| aliveness(char) }
+      end
+
+      def valid_chars
+        @world_string.chars.uniq.select do |char|
+          allowed_chars_by_aliveness.include?(char)
+        end
+      end
+
+      # Roughly in order from most dead-like to most alive-like
+      def allowed_chars_by_aliveness
+        deadlike + lifelike
+      end
+
+      def deadlike
+        [' ', '_', '.', ',', 'o', 'O', '0']
+      end
+
+      def lifelike
+        ['1', 'x', '*', 'X', '#', '@']
+      end
+
+      def aliveness(char)
+        allowed_chars_by_aliveness.index(char)
+      end
+    end
+  end
+end

data/lib/lifelike/lifelike_cellular_automaton.rb

@@ -0,0 +1,48 @@
+require 'lifelike/lifelike_cellular_automaton/rules'
+require 'lifelike/lifelike_cellular_automaton/world'
+require 'lifelike/lifelike_cellular_automaton/cell'
+require 'lifelike/lifelike_cellular_automaton/cell_serializer'
+require 'lifelike/lifelike_cellular_automaton/world_serializer'
+require 'lifelike/lifelike_cellular_automaton/world_string_analyzer'
+module Lifelike
+  class LifelikeCellularAutomaton
+    def initialize(initial_world_string, rule_string)
+      @initial_world_string = initial_world_string
+      @rules = Rules.new(rule_string)
+    end
+
+    def tick(generations)
+      world_serializer.dump(initial_world.tick(generations))
+    end
+
+    private
+
+    def initial_world
+      world_serializer.load(@initial_world_string)
+    end
+
+    def world_serializer
+      @world_serializer ||= WorldSerializer.new(cell_serializer)
+    end
+
+    def cell_serializer
+      CellSerializer.new(
+        alive_char: alive_char,
+        dead_char: dead_char,
+        rules: @rules
+      )
+    end
+
+    def alive_char
+      world_string_analyzer.alive_char
+    end
+
+    def dead_char
+      world_string_analyzer.dead_char
+    end
+
+    def world_string_analyzer
+      @analyzer ||= WorldStringAnalyzer.new(@initial_world_string)
+    end
+  end
+end

data/lib/lifelike/runner.rb

@@ -0,0 +1,23 @@
+module Lifelike
+  class Runner
+    def initialize(initial_world_string, rule_string:, generations:)
+      @initial_world_string = initial_world_string
+      @rule_string = rule_string
+      @generations = generations
+    end
+
+    def run
+      final_world_string
+    end
+
+    private
+
+    def final_world_string
+      lifelike_cellular_automaton.tick(@generations)
+    end
+
+    def lifelike_cellular_automaton
+      LifelikeCellularAutomaton.new(@initial_world_string, @rule_string)
+    end
+  end
+end

data/lib/lifelike/version.rb

@@ -0,0 +1,3 @@
+module Lifelike
+  VERSION = '1.0.0'
+end

data/lib/lifelike.rb

@@ -0,0 +1,8 @@
+require 'lifelike/version'
+require 'lifelike/error'
+require 'lifelike/grid'
+require 'lifelike/lifelike_cellular_automaton'
+require 'lifelike/runner'
+
+module Lifelike
+end

data/lifelike.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lifelike/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lifelike'
+  spec.version       = Lifelike::VERSION
+  spec.authors       = ['Max Holder']
+  spec.email         = ['mxhold@gmail.com']
+  spec.summary       = 'Simulates Life-like cellular automata'
+  spec.description   = 'A gem for playing Conway\'s Game of Life and other ' \
+                       'Life-like cellular automata'
+  spec.homepage      = 'https://github.com/mxhold/lifelike'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.2'
+  spec.add_development_dependency 'codeclimate-test-reporter'
+  spec.add_development_dependency 'rubocop'
+
+  spec.required_ruby_version = '~> 2.1'
+end

data/spec/cli_spec.rb

@@ -0,0 +1,90 @@
+require 'lifelike'
+require 'lifelike/cli'
+RSpec.describe Lifelike::CLI, :integration do
+  context 'no arguments' do
+    it 'prints the input after a generation' do
+      stub_const('ARGV', [])
+      allow(ARGF).to receive(:read) { "010\n010\n010" }
+      allow(Lifelike::CLI).to receive(:exit)
+      expect do
+        Lifelike::CLI.invoke
+      end.to output("000\n111\n000\n").to_stdout
+    end
+  end
+
+  context 'given 2 as an argument' do
+    it 'prints the input after 2 generations' do
+      stub_const('ARGV', ['-c', '2'])
+      allow(ARGF).to receive(:read) { "010\n010\n010" }
+      allow(Lifelike::CLI).to receive(:exit)
+      expect do
+        Lifelike::CLI.invoke
+      end.to output("010\n010\n010\n").to_stdout
+    end
+  end
+
+  context 'alternate rules specified' do
+    it 'prints the input after a generation using the alternate rules' do
+      stub_const('ARGV', ['-r', 'B2/S'])
+      allow(ARGF).to receive(:read) { "0000000\n0000000\n0011000\n0000000\n0000000" }
+      allow(Lifelike::CLI).to receive(:exit)
+      expect do
+        Lifelike::CLI.invoke
+      end.to output("0000000\n0011000\n0000000\n0011000\n0000000\n").to_stdout
+    end
+  end
+
+  context 'alternate live/dead characters' do
+    it 'prints the output with the same characters' do
+      stub_const('ARGV', [])
+      allow(ARGF).to receive(:read) { ".o.\n.o.\n.o." }
+      allow(Lifelike::CLI).to receive(:exit)
+      expect do
+        Lifelike::CLI.invoke
+      end.to output("...\nooo\n...\n").to_stdout
+    end
+  end
+
+  context 'invalid arguments' do
+    it 'prints an error and exits with the appropriate exit code' do
+      stub_const('ARGV', ['-dsaf'])
+      expect(Lifelike::CLI).to receive(:exit).with(64)
+      expect do
+        Lifelike::CLI.invoke
+      end.to output(/invalid option/).to_stderr
+    end
+  end
+
+  context 'unparsable rule string' do
+    it 'prints an error and exits with the appropriate exit code' do
+      stub_const('ARGV', ['-r', 'QWSD'])
+      allow(ARGF).to receive(:read) { 'o.o' }
+      expect(Lifelike::CLI).to receive(:exit).with(64)
+      expect do
+        Lifelike::CLI.invoke
+      end.to output(/unparsable rule string/i).to_stderr
+    end
+  end
+
+  context 'insufficient valid characters' do
+    it 'raises an error and exits with the appropriate exit code' do
+      stub_const('ARGV', [])
+      allow(ARGF).to receive(:read) { 'wyr' }
+      allow(Lifelike::CLI).to receive(:exit).with(65)
+      expect do
+        Lifelike::CLI.invoke
+      end.to output(/insufficient characters/i).to_stderr
+    end
+  end
+
+  context 'unexpected character' do
+    it 'raises an error and exits with the appropriate exit code' do
+      stub_const('ARGV', [])
+      allow(ARGF).to receive(:read) { 'o.o.W' }
+      allow(Lifelike::CLI).to receive(:exit).with(65)
+      expect do
+        Lifelike::CLI.invoke
+      end.to output(/unexpected character/i).to_stderr
+    end
+  end
+end

data/spec/options_spec.rb

@@ -0,0 +1,45 @@
+require 'lifelike/cli/options'
+RSpec.describe Lifelike::CLI::Options do
+  describe '.parse' do
+    it 'has defaults' do
+      expect(described_class.parse!([])).to eql(generations: 1, rule_string: 'B3/S23')
+    end
+
+    it 'sets the generations' do
+      expect(described_class.parse!(['-c', '1'])).to include(generations: 1)
+      expect(described_class.parse!(['--count', '1'])).to include(generations: 1)
+    end
+
+    it 'sets the rule_string' do
+      expect(described_class.parse!(['-r', 'B2/S3'])).to include(rule_string: 'B2/S3')
+      expect(described_class.parse!(['--rule', 'B2/S3'])).to include(rule_string: 'B2/S3')
+    end
+
+    it 'displays the help with -h' do
+      allow_any_instance_of(described_class).to receive(:exit)
+      expect do
+        described_class.parse!(['-h'])
+      end.to output(/Usage/).to_stdout
+      expect do
+        described_class.parse!(['--help'])
+      end.to output(/Usage/).to_stdout
+    end
+
+    it 'displays the version with -v' do
+      allow_any_instance_of(described_class).to receive(:exit)
+      stub_const('Lifelike::VERSION', '1.2.3')
+      expect do
+        described_class.parse!(['-v'])
+      end.to output("1.2.3\n").to_stdout
+      expect do
+        described_class.parse!(['--version'])
+      end.to output("1.2.3\n").to_stdout
+    end
+
+    it 'raises an exception on unknown options' do
+      expect do
+        described_class.parse!(['-z'])
+      end.to raise_exception(OptionParser::InvalidOption)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,89 @@
+require 'codeclimate-test-reporter'
+CodeClimate::TestReporter.start
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end

data/spec/world_string_analyzer_spec.rb

@@ -0,0 +1,99 @@
+require_relative '../lib/lifelike/error'
+require_relative '../lib/lifelike/lifelike_cellular_automaton/world_string_analyzer'
+
+RSpec.describe Lifelike::LifelikeCellularAutomaton::WorldStringAnalyzer do
+  context 'given at least two valid characters' do
+    describe 'detecting alive/dead character' do
+      matcher :consider do |deadlike|
+        match do |subject|
+          analyzer = subject.new("#{deadlike}#{@lifelike}")
+          analyzer.dead_char == deadlike && analyzer.alive_char == @lifelike
+        end
+
+        chain :deader_looking_than, :lifelike
+      end
+
+      subject { described_class }
+
+      it { is_expected.to consider(' ').deader_looking_than('_') }
+      it { is_expected.to consider('_').deader_looking_than('.') }
+      it { is_expected.to consider('.').deader_looking_than(',') }
+      it { is_expected.to consider(',').deader_looking_than('o') }
+      it { is_expected.to consider('o').deader_looking_than('O') }
+      it { is_expected.to consider('O').deader_looking_than('0') }
+      it { is_expected.to consider('0').deader_looking_than('1') }
+      it { is_expected.to consider('1').deader_looking_than('x') }
+      it { is_expected.to consider('x').deader_looking_than('*') }
+      it { is_expected.to consider('*').deader_looking_than('X') }
+      it { is_expected.to consider('X').deader_looking_than('#') }
+      it { is_expected.to consider('#').deader_looking_than('@') }
+    end
+  end
+
+  context 'given a single valid character' do
+    describe 'detecting whether it should be considered alive or dead' do
+      matcher :consider do |character|
+        match do |subject|
+          analyzer = subject.new(character, default_dead_char: 'd', default_alive_char: 'a')
+          fail if %w(d a).include?(character)
+          if @consider_dead
+            analyzer.dead_char == character
+          else
+            analyzer.alive_char == character
+          end
+        end
+
+        chain(:to_be_dead) { @consider_dead = true }
+        chain(:to_be_alive) { @consider_dead = false }
+      end
+
+      subject { described_class }
+
+      it { is_expected.to consider(' ').to_be_dead }
+      it { is_expected.to consider('_').to_be_dead }
+      it { is_expected.to consider('.').to_be_dead }
+      it { is_expected.to consider(',').to_be_dead }
+      it { is_expected.to consider('o').to_be_dead }
+      it { is_expected.to consider('O').to_be_dead }
+      it { is_expected.to consider('0').to_be_dead }
+
+      it { is_expected.to consider('1').to_be_alive }
+      it { is_expected.to consider('x').to_be_alive }
+      it { is_expected.to consider('*').to_be_alive }
+      it { is_expected.to consider('X').to_be_alive }
+      it { is_expected.to consider('#').to_be_alive }
+      it { is_expected.to consider('@').to_be_alive }
+    end
+    describe 'default characters' do
+      context 'provided char was considered dead' do
+        subject { described_class.new(' ') }
+        it 'uses "X" as the default alive char' do
+          expect(subject.alive_char).to eql 'X'
+        end
+      end
+      context 'provided char was considered alive' do
+        subject { described_class.new('X') }
+        it 'uses " " as the default dead char' do
+          expect(subject.dead_char).to eql ' '
+        end
+      end
+    end
+  end
+
+  context 'given no valid characters' do
+    describe '#alive_char' do
+      it 'raises a InsufficientValidCharacterError' do
+        expect do
+          described_class.new('').alive_char
+        end.to raise_error(Lifelike::InsufficientValidCharacterError)
+      end
+    end
+    describe '#dead_char' do
+      it 'raises a InsufficientValidCharacterError' do
+        expect do
+          described_class.new('').dead_char
+        end.to raise_error(Lifelike::InsufficientValidCharacterError)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: lifelike
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Max Holder
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: 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: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  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: rubocop
+  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 gem for playing Conway's Game of Life and other Life-like cellular
+  automata
+email:
+- mxhold@gmail.com
+executables:
+- lifelike
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/lifelike
+- lib/lifelike.rb
+- lib/lifelike/cli.rb
+- lib/lifelike/cli/options.rb
+- lib/lifelike/error.rb
+- lib/lifelike/grid.rb
+- lib/lifelike/lifelike_cellular_automaton.rb
+- lib/lifelike/lifelike_cellular_automaton/cell.rb
+- lib/lifelike/lifelike_cellular_automaton/cell_serializer.rb
+- lib/lifelike/lifelike_cellular_automaton/rules.rb
+- lib/lifelike/lifelike_cellular_automaton/world.rb
+- lib/lifelike/lifelike_cellular_automaton/world_serializer.rb
+- lib/lifelike/lifelike_cellular_automaton/world_string_analyzer.rb
+- lib/lifelike/runner.rb
+- lib/lifelike/version.rb
+- lifelike.gemspec
+- spec/cli_spec.rb
+- spec/options_spec.rb
+- spec/spec_helper.rb
+- spec/world_string_analyzer_spec.rb
+homepage: https://github.com/mxhold/lifelike
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Simulates Life-like cellular automata
+test_files:
+- spec/cli_spec.rb
+- spec/options_spec.rb
+- spec/spec_helper.rb
+- spec/world_string_analyzer_spec.rb