xo 1.0.0 → 1.1.0

data/spec/{xo/evaluator_spec.rb → evaluator_spec.rb}

@@ -4,10 +4,10 @@ module XO
 
   describe Evaluator do
 
-    describe ".analyze" do
+    let (:evaluator) { Evaluator.instance }
+    let (:grid) { Grid.new }
 
-      let (:evaluator) { Evaluator.instance }
-      let (:grid) { Grid.new }
+    describe "#analyze" do
 
       describe "standard play" do
 
@@ -210,6 +210,11 @@ module XO
                 positions: [[1, 3], [2, 2], [3, 1]]
               }]
             }
+
+            evaluator.analyze(grid, Grid::X).must_equal result
+
+            result[:type] = :loser
+            evaluator.analyze(grid, Grid::O).must_equal result
           end
         end
 
@@ -227,13 +232,6 @@ module XO
         end
       end
 
-      describe "invalid token input" do
-
-        it "raises ArgumentError" do
-          proc { evaluator.analyze(Grid.new, :not_a_token) }.must_raise ArgumentError
-        end
-      end
-
       describe "invalid grid input" do
 
         it "returns too many moves ahead" do
@@ -256,6 +254,23 @@ module XO
           evaluator.analyze(grid, Grid::O).must_equal result
         end
       end
+
+      describe "invalid token input" do
+
+        it "raises ArgumentError" do
+          proc { evaluator.analyze(Grid.new, :not_a_token) }.must_raise ArgumentError
+        end
+      end
+    end
+
+    describe ".xos" do
+
+      it "returns the number of x's and o's" do
+        xs, os = Evaluator.xos(Grid.new('xoxxo'))
+
+        xs.must_equal 3
+        os.must_equal 2
+      end
     end
   end
 end

data/spec/{xo/ai/geometric_grid_spec.rb → geometric_grid_spec.rb}

@@ -4,8 +4,6 @@ module XO::AI
 
   describe GeometricGrid do
 
-    let(:grid) { GeometricGrid.new }
-
     describe "#rotate" do
 
       let (:grid) { GeometricGrid.new("xoooxxoxo") }
@@ -81,7 +79,7 @@ module XO::AI
       end
     end
 
-    describe "equality" do
+    describe "#==" do
 
       it "is reflexive, symmetric and transitive" do
         a = GeometricGrid.new('x')

data/spec/{xo/grid_spec.rb → grid_spec.rb}

@@ -4,6 +4,8 @@ module XO
 
   describe Grid do
 
+    let(:grid) { Grid.new }
+
     it "defines X" do
       Grid::X.must_equal :x
     end
@@ -12,6 +14,10 @@ module XO
       Grid::O.must_equal :o
     end
 
+    it "defines EMPTY" do
+      Grid::EMPTY.must_equal :e
+    end
+
     it "has 3 rows" do
       Grid::ROWS.must_equal 3
     end
@@ -56,8 +62,8 @@ module XO
       end
 
       it "returns false otherwise" do
-        [nil, :e, '', ' '].each do
-          Grid.is_token?(:e).must_equal false
+        [nil, :e, '', ' '].each do |val|
+          Grid.is_token?(val).must_equal false
         end
       end
     end
@@ -77,16 +83,11 @@ module XO
       end
     end
 
-    let(:grid) { Grid.new }
-
-    describe "an initial grid" do
+    describe ".new" do
 
-      it "is empty" do
+      it "is returns an empty grid when given no arguments" do
         grid.empty?.must_equal true
       end
-    end
-
-    describe "#new" do
 
       it "can create a grid from a string" do
         grid = Grid.new('xox o')
@@ -154,14 +155,14 @@ module XO
       end
 
       it "returns false when at least one position doesn't have a token" do
-        grid[1, 3] = :e
+        grid[1, 3] = Grid::EMPTY
         grid.full?.must_equal false
       end
     end
 
     describe "#[]=" do
 
-      it "sets a position to X, O or :e" do
+      it "sets a position to X, O or EMPTY" do
         grid[2, 1] = Grid::X
         grid[2, 1].must_equal Grid::X
 
@@ -169,7 +170,7 @@ module XO
         grid[2, 2].must_equal Grid::O
 
         grid[2, 3] = :anything_else
-        grid[2, 3].must_equal :e
+        grid[2, 3].must_equal Grid::EMPTY
       end
 
       it "raises IndexError when the position is off the grid" do
@@ -211,10 +212,6 @@ module XO
 
         grid.empty?.must_equal true
       end
-
-      it "returns self" do
-        grid.clear.must_be_same_as grid
-      end
     end
 
     describe "#each" do

data/xo.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.author        = 'Dwayne R. Crooks'
   spec.email         = ['me@dwaynecrooks.com']
   spec.summary       = %q{A Ruby library for Tic-tac-toe.}
-  spec.description   = %q{A Ruby library that can be used to develop Tic-tac-toe game clients.}
+  spec.description   = %q{A Ruby library for Tic-tac-toe that can be used to develop Tic-tac-toe game clients and servers.}
   spec.homepage      = 'https://github.com/dwayne/xo'
   spec.license       = 'MIT'
 
@@ -20,6 +20,8 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 1.9.3'
 
+  spec.add_runtime_dependency 'state_design_pattern', '~> 0.0.2'
+
   spec.add_development_dependency 'rake', '~> 10.3'
   spec.add_development_dependency 'minitest', '~> 5.3'
   spec.add_development_dependency 'coveralls', '~> 0.7'

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: xo
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Dwayne R. Crooks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-08 00:00:00.000000000 Z
+date: 2014-05-23 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: state_design_pattern
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.2
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -80,7 +94,8 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.8'
-description: A Ruby library that can be used to develop Tic-tac-toe game clients.
+description: A Ruby library for Tic-tac-toe that can be used to develop Tic-tac-toe
+  game clients and servers.
 email:
 - me@dwaynecrooks.com
 executables:
@@ -97,19 +112,26 @@ files:
 - Rakefile
 - bin/xo
 - lib/xo.rb
-- lib/xo/ai.rb
 - lib/xo/ai/geometric_grid.rb
+- lib/xo/ai/max_player.rb
+- lib/xo/ai/min_player.rb
 - lib/xo/ai/minimax.rb
+- lib/xo/ai/player.rb
 - lib/xo/engine.rb
+- lib/xo/engine/game_context.rb
+- lib/xo/engine/game_over.rb
+- lib/xo/engine/game_state.rb
+- lib/xo/engine/init.rb
+- lib/xo/engine/playing.rb
 - lib/xo/evaluator.rb
 - lib/xo/grid.rb
 - lib/xo/version.rb
+- spec/engine_spec.rb
+- spec/evaluator_spec.rb
+- spec/geometric_grid_spec.rb
+- spec/grid_spec.rb
+- spec/minimax_spec.rb
 - spec/spec_helper.rb
-- spec/xo/ai/geometric_grid_spec.rb
-- spec/xo/ai/minimax_spec.rb
-- spec/xo/engine_spec.rb
-- spec/xo/evaluator_spec.rb
-- spec/xo/grid_spec.rb
 - xo.gemspec
 homepage: https://github.com/dwayne/xo
 licenses:
@@ -136,10 +158,10 @@ signing_key:
 specification_version: 4
 summary: A Ruby library for Tic-tac-toe.
 test_files:
+- spec/engine_spec.rb
+- spec/evaluator_spec.rb
+- spec/geometric_grid_spec.rb
+- spec/grid_spec.rb
+- spec/minimax_spec.rb
 - spec/spec_helper.rb
-- spec/xo/ai/geometric_grid_spec.rb
-- spec/xo/ai/minimax_spec.rb
-- spec/xo/engine_spec.rb
-- spec/xo/evaluator_spec.rb
-- spec/xo/grid_spec.rb
 has_rdoc: 

data/lib/xo/ai.rb

@@ -1,2 +0,0 @@
-require 'xo/ai/geometric_grid'
-require 'xo/ai/minimax'

data/spec/xo/engine_spec.rb

@@ -1,331 +0,0 @@
-require 'spec_helper'
-
-module XO
-
-  describe Engine do
-
-    let (:engine) { Engine.new }
-
-    describe "its initial state" do
-
-      it "is in the :init state" do
-        engine.state.must_equal :init
-      end
-
-      it "is nobody's turn" do
-        engine.turn.must_equal :nobody
-      end
-
-      it "has an empty grid" do
-        engine.grid.empty?.must_equal true
-      end
-
-      it "has last event set to :new" do
-        event = engine.last_event
-
-        event[:name].must_equal :new
-      end
-
-      describe "#next_turn" do
-
-        it "returns :nobody" do
-          engine.next_turn.must_equal :nobody
-        end
-      end
-    end
-
-    describe "#grid" do
-
-      it "returns a copy of the underlying grid" do
-        grid = engine.grid
-
-        grid[1, 1] = Grid::X
-
-        engine.grid.open?(1, 1).must_equal true
-      end
-    end
-
-    describe "how the state machine works" do
-
-      describe "state :init" do
-
-        it "is in state :init" do
-          engine.state.must_equal :init
-        end
-
-        describe "#start" do
-
-          before { engine.start(Grid::X) }
-
-          it "changes state to :playing" do
-            engine.state.must_equal :playing
-          end
-
-          it "sets turn to the value passed in" do
-            engine.turn.must_equal Grid::X
-          end
-
-          it "starts with an empty grid" do
-            engine.grid.empty?.must_equal true
-          end
-
-          it "sets last event" do
-            event = engine.last_event
-
-            event[:name].must_equal :game_started
-          end
-
-          describe "#next_turn" do
-
-            it "returns O" do
-              engine.next_turn.must_equal Grid::O
-            end
-          end
-        end
-
-        it "only allows #start to be called" do
-          proc { engine.stop }.must_raise Engine::IllegalStateError
-          proc { engine.play(1, 1) }.must_raise Engine::IllegalStateError
-          proc { engine.continue_playing(Grid::X) }.must_raise Engine::IllegalStateError
-        end
-      end
-
-      describe "state :playing" do
-
-        before do
-          engine.start(Grid::X)
-        end
-
-        it "is in state :playing" do
-          engine.state.must_equal :playing
-        end
-
-        describe "#play" do
-
-          describe "valid moves" do
-
-            describe "when given (1, 1)" do
-
-              before { engine.play(1, 1) }
-
-              it "remains in state :playing" do
-                engine.state.must_equal :playing
-              end
-
-              it "sets turn to O" do
-                engine.turn.must_equal Grid::O
-              end
-
-              it "updates the grid at that position" do
-                engine.grid[1, 1].must_equal Grid::X
-              end
-
-              it "sets last event" do
-                event = engine.last_event
-
-                event[:name].must_equal :next_turn
-                event[:last_move][:turn].must_equal Grid::X
-                event[:last_move][:r].must_equal 1
-                event[:last_move][:c].must_equal 1
-              end
-            end
-
-            describe "when the next move results in the game being over" do
-
-              describe "winning" do
-
-                before do
-                  engine.play(1, 1).play(2, 1).play(1, 2).play(2, 2).play(1, 3)
-                end
-
-                it "changes state to :game_over" do
-                  engine.state.must_equal :game_over
-                end
-
-                it "sets turn to the winner" do
-                  engine.turn.must_equal Grid::X
-                end
-
-                it "leaves the grid unchanged" do
-                  engine.grid.inspect.must_equal 'xxxoo    '
-                end
-
-                it "sets last event" do
-                  event = engine.last_event
-
-                  event[:name].must_equal :game_over
-                  event[:type].must_equal :winner
-                  event[:last_move][:turn].must_equal Grid::X
-                  event[:last_move][:r].must_equal 1
-                  event[:last_move][:c].must_equal 3
-                  event[:details].must_equal [
-                    { where: :row, index: 1, positions: [[1, 1], [1, 2], [1, 3]] }
-                  ]
-                end
-              end
-
-              describe "squashed" do
-
-                before do
-                  engine.play(1, 1).play(1, 2).play(1, 3).play(2, 2).play(3, 2).play(2, 1).play(2, 3).play(3, 3).play(3, 1)
-                end
-
-                it "changes state to :game_over" do
-                  engine.state.must_equal :game_over
-                end
-
-                it "leaves turn set to the last one played" do
-                  engine.turn.must_equal Grid::X
-                end
-
-                it "leaves the grid unchanged" do
-                  engine.grid.inspect.must_equal 'xoxooxxxo'
-                end
-
-                it "sets last event" do
-                  event = engine.last_event
-
-                  event[:name].must_equal :game_over
-                  event[:type].must_equal :squashed
-                  event[:last_move][:turn].must_equal Grid::X
-                  event[:last_move][:r].must_equal 3
-                  event[:last_move][:c].must_equal 1
-                end
-              end
-            end
-          end
-
-          describe "invalid moves" do
-
-            describe "when given (0, 0)" do
-
-              it "sets last event to out of bounds" do
-                event = engine.play(0, 0).last_event
-
-                event[:name].must_equal :invalid_move
-                event[:type].must_equal :out_of_bounds
-              end
-            end
-
-            describe "when given (1, 1) and it already has a token there" do
-
-              it "sets last event to occupied" do
-                event = engine.play(1, 1).play(1, 1).last_event
-
-                event[:name].must_equal :invalid_move
-                event[:type].must_equal :occupied
-              end
-            end
-          end
-        end
-
-        describe "#stop" do
-
-          before { engine.stop }
-
-          it "changes state to :init" do
-            engine.state.must_equal :init
-          end
-
-          it "sets turn to :nobody" do
-            engine.turn.must_equal :nobody
-          end
-
-          it "clears the grid" do
-            engine.grid.empty?.must_equal true
-          end
-
-          it "sets last event" do
-            event = engine.last_event
-
-            event[:name].must_equal :game_stopped
-          end
-        end
-
-        it "only allows #play and #stop to be called" do
-          proc { engine.start(Grid::O) }.must_raise Engine::IllegalStateError
-          proc { engine.continue_playing(Grid::O) }.must_raise Engine::IllegalStateError
-        end
-      end
-
-      describe "state :game_over" do
-
-        before do
-          engine
-            .start(Grid::O)
-            .play(1, 1).play(2, 1).play(1, 2).play(2, 2).play(1, 3)
-        end
-
-        it "is in state :game_over" do
-          engine.state.must_equal :game_over
-        end
-
-        describe "#continue_playing" do
-
-          before { engine.continue_playing(Grid::O) }
-
-          it "changes state to :playing" do
-            engine.state.must_equal :playing
-          end
-
-          it "sets turn to O" do
-            engine.turn.must_equal Grid::O
-          end
-
-          it "clears the grid" do
-            engine.grid.empty?.must_equal true
-          end
-
-          it "sets last event" do
-            event = engine.last_event
-
-            event[:name].must_equal :game_started
-            event[:type].must_equal :continue_playing
-          end
-        end
-
-        describe "#stop" do
-
-          before { engine.stop }
-
-          it "changes state to :init" do
-            engine.state.must_equal :init
-          end
-
-          it "sets turn to :nobody" do
-            engine.turn.must_equal :nobody
-          end
-
-          it "clears the grid" do
-            engine.grid.empty?.must_equal true
-          end
-
-          it "sets last event" do
-            event = engine.last_event
-
-            event[:name].must_equal :game_stopped
-          end
-        end
-
-        it "only allows #continue_playing and #stop to be called" do
-          proc { engine.start(Grid::X) }.must_raise Engine::IllegalStateError
-          proc { engine.play(1, 1) }.must_raise Engine::IllegalStateError
-        end
-      end
-    end
-
-    describe "#start with invalid input" do
-
-      it "raises an ArgumentError" do
-        proc { engine.start(:invalid_input) }.must_raise ArgumentError
-      end
-    end
-
-    describe "#continue_playing with invalid input" do
-
-      it "raises an ArgumentError" do
-        proc { engine.continue_playing(:invalid_input) }.must_raise ArgumentError
-      end
-    end
-  end
-end