tic_tac_toes 0.0.7 → 0.0.8

data/spec/tic_tac_toes/{history_spec.rb → core/history_spec.rb}

@@ -1,8 +1,8 @@
-require 'tic_tac_toes/history'
+require 'tic_tac_toes/core/history'
 
-describe TicTacToes::History do
+describe TicTacToes::Core::History do
   let(:database_wrapper)  { double("database wrapper", :record_game_history => true) }
-  let(:history)           { TicTacToes::History.new(database_wrapper) }
+  let(:history)           { TicTacToes::Core::History.new(database_wrapper) }
 
   describe '#record_board_size' do
     it "records the passed board size" do

data/spec/tic_tac_toes/{io_spec.rb → core/io_spec.rb}

@@ -1,11 +1,11 @@
-require 'tic_tac_toes/board'
-require 'tic_tac_toes/io'
-require 'tic_tac_toes/strings'
+require 'tic_tac_toes/core/board'
+require 'tic_tac_toes/core/io'
+require 'tic_tac_toes/core/strings'
 
-describe TicTacToes::IO do
-  let(:strings)  { TicTacToes::Strings }
+describe TicTacToes::Core::IO do
+  let(:strings)  { TicTacToes::Core::Strings }
   let(:prompt)   { double("prompt", solicit_input: 0, display: true, display_red: true) }
-  let(:io)       { TicTacToes::IO.new(prompt) }
+  let(:io)       { TicTacToes::Core::IO.new(prompt) }
 
   describe '#get_row_size' do
     it "displays a row size solicitation" do
@@ -70,7 +70,7 @@ describe TicTacToes::IO do
 
   describe '#draw_board' do
     it "displays a board string" do
-      board = TicTacToes::Board.new
+      board = TicTacToes::Core::Board.new
       board_string = strings.board(board)
 
       expect(prompt).to receive(:display).with(board_string)

data/spec/tic_tac_toes/core/move_strategies/easy_ai_spec.rb

@@ -0,0 +1,19 @@
+require 'tic_tac_toes/test_board_generator'
+require 'tic_tac_toes/core/move_strategies/easy_ai'
+
+describe TicTacToes::Core::MoveStrategies::EasyAI do
+  describe '#move' do
+    let(:players) { double("players") }
+    let(:easy_ai) { TicTacToes::Core::MoveStrategies::EasyAI }
+
+    it "returns a randomly-selected valid move" do
+      board = TicTacToes::TestBoardGenerator.generate([ :O, nil, nil,
+                                                       nil,  :X, nil,
+                                                       nil,  :X, nil])
+      valid_moves = [1, 2, 3, 5, 6, 8]
+
+      move = easy_ai.move(board, players)
+      expect(valid_moves).to include(move)
+    end
+  end
+end

data/spec/tic_tac_toes/core/move_strategies/hard_ai_spec.rb

@@ -0,0 +1,121 @@
+require 'tic_tac_toes/test_board_generator'
+require 'tic_tac_toes/core/move_strategies/hard_ai'
+require 'tic_tac_toes/core/player'
+
+describe TicTacToes::Core::MoveStrategies::HardAI do
+  let(:hard_ai) { TicTacToes::Core::MoveStrategies::HardAI }
+  let(:x) { TicTacToes::Core::Player.new("human", "x", false, "io") }
+  let(:o) { TicTacToes::Core::Player.new(hard_ai, "o", true, "io") }
+  let(:players) { [o, x] }
+
+
+  describe '#move' do
+    it "returns the best move" do
+      board = TicTacToes::TestBoardGenerator.generate([x, nil, nil,
+                                                       o,   o, nil,
+                                                       x, nil,   x])
+      best_move = 5
+
+      expect(hard_ai.move(board, players)).to eql(best_move)
+    end
+
+    context "when playing on a 3x3 board" do
+      it "returns 4 when the opponent’s first move was a corner" do
+        board = TicTacToes::TestBoardGenerator.generate([nil, nil, nil,
+                                                         nil, nil, nil,
+                                                         nil, nil,   x])
+
+        expect(hard_ai.move(board, players)).to eq(4)
+      end
+      
+      it "returns 4 when the opponent’s first move was an edge" do
+        board = TicTacToes::TestBoardGenerator.generate([nil, nil, nil,
+                                                         nil, nil,   x,
+                                                         nil, nil, nil])
+
+        expect(hard_ai.move(board, players)).to eq(4)
+      end
+
+      it "returns 0 when the opponent’s first move was the center" do
+        board = TicTacToes::TestBoardGenerator.generate([nil, nil, nil,
+                                                         nil,   x, nil,
+                                                         nil, nil, nil])
+
+        expect(hard_ai.move(board, players)).to eq(0)
+      end
+    end
+  end
+
+
+  describe '#minimax' do
+    it "returns the correct score for a pre-win board" do
+      board = TicTacToes::TestBoardGenerator.generate([x, nil, nil,
+                                                       o,   o, nil,
+                                                       x, nil,   x])
+      win_score = 1
+
+      expect(hard_ai.minimax(board, :max, players)).to eql(win_score)
+    end
+
+    it "returns the correct score for a pre-loss board" do
+      board = TicTacToes::TestBoardGenerator.generate([  o,   o,   x,
+                                                       nil, nil, nil,
+                                                         x, nil,   x])
+      loss_score = -1
+
+      expect(hard_ai.minimax(board, :max, players)).to eql(loss_score)
+    end
+
+    it "returns the correct score for a pre-draw board" do
+      board = TicTacToes::TestBoardGenerator.generate([x,   x, o,
+                                                       o, nil, x,
+                                                       x,   o, x])
+      draw_score = 0
+
+      expect(hard_ai.minimax(board, :max, players)).to eql(draw_score)
+    end
+  end
+
+
+  describe '#generate_board' do
+    it "returns a board based on a token, a space, and an existing board" do
+      token, space = o, 3
+      board = TicTacToes::TestBoardGenerator.generate([  x, nil, nil,
+                                                       nil,   o, nil,
+                                                         x, nil, nil])
+
+      new_board = hard_ai.generate_board(token, space, board)
+      expect(new_board.space(space)).to eql(token)
+    end
+  end
+
+
+  describe '#score' do
+    it "returns the correct score when HardAI has won" do
+      board = TicTacToes::TestBoardGenerator.generate([  o, nil, nil,
+                                                       nil,   o, nil,
+                                                       nil, nil,   o])
+      win_score = 1
+
+      expect(hard_ai.score(board, players)).to eql(win_score)
+    end
+
+    it "returns the correct score when no one has won" do
+      board = TicTacToes::TestBoardGenerator.generate([o, o, x,
+                                                       x, x, o,
+                                                       o, x, o])
+      draw_score = 0
+
+      expect(hard_ai.score(board, players)).to eql(draw_score)
+    end
+
+    it "returns the correct score when the opponent has won" do
+      board = TicTacToes::TestBoardGenerator.generate([  x, nil, nil,
+                                                       nil,   x, nil,
+                                                       nil, nil,   x])
+      loss_score = -1
+
+      expect(hard_ai.score(board, players)).to eql(loss_score)
+    end
+  end
+end

data/spec/tic_tac_toes/{move_strategies → core/move_strategies}/human_spec.rb

@@ -1,9 +1,9 @@
-require 'tic_tac_toes/move_strategies/human'
+require 'tic_tac_toes/core/move_strategies/human'
 
-describe TicTacToes::MoveStrategies::Human do
+describe TicTacToes::Core::MoveStrategies::Human do
   describe '#move' do
     let(:io)     { double("io", solicit_input: 0, move_solicitation: true, not_an_integer_error: true) }
-    let(:human)  { TicTacToes::MoveStrategies::Human.new(io) }
+    let(:human)  { TicTacToes::Core::MoveStrategies::Human.new(io) }
 
     it "displays a move solicitation" do
       expect(io).to receive(:move_solicitation)

data/spec/tic_tac_toes/core/move_strategies/medium_ai_spec.rb

@@ -0,0 +1,21 @@
+require 'tic_tac_toes/test_board_generator'
+require 'tic_tac_toes/core/move_strategies/medium_ai'
+
+describe TicTacToes::Core::MoveStrategies::MediumAI do
+  let(:medium_ai) { TicTacToes::Core::MoveStrategies::MediumAI }
+  let(:x) { TicTacToes::Core::Player.new("human", "x", false, "io") }
+  let(:o) { TicTacToes::Core::Player.new(medium_ai, "o", true, "io") }
+  let(:players) { [x, o] }
+
+  describe '#move' do
+    it "returns a valid move (based on either EasyAI or HardAI)" do
+      board = TicTacToes::TestBoardGenerator.generate([  o, o,   x,
+                                                       nil, x, nil,
+                                                       nil, x, nil])
+      valid_moves = [3, 5, 6, 8]
+
+      move = medium_ai.move(board, players)
+      expect(valid_moves).to include(move)
+    end
+  end
+end

data/spec/tic_tac_toes/{player_factory_spec.rb → core/player_factory_spec.rb}

@@ -1,13 +1,13 @@
-require 'tic_tac_toes/move_strategies/human'
-require 'tic_tac_toes/move_strategies/medium_ai'
-require 'tic_tac_toes/player_factory'
+require 'tic_tac_toes/core/move_strategies/human'
+require 'tic_tac_toes/core/move_strategies/medium_ai'
+require 'tic_tac_toes/core/player_factory'
 
-describe TicTacToes::PlayerFactory do
-  let(:player_factory) { TicTacToes::PlayerFactory.new("io") }
+describe TicTacToes::Core::PlayerFactory do
+  let(:player_factory) { TicTacToes::Core::PlayerFactory.new("io") }
 
   describe '#generate_human_player' do
     it "returns a player with the correct token and move strategy" do
-      strategy = TicTacToes::MoveStrategies::Human
+      strategy = TicTacToes::Core::MoveStrategies::Human
       token = 'X'
 
       human_player = player_factory.generate_human_player(token)
@@ -20,7 +20,7 @@ describe TicTacToes::PlayerFactory do
     it 'returns a player with the correct token and move strategy' do
       token = 'O'
       difficulty = :medium
-      strategy = TicTacToes::MoveStrategies::MediumAI
+      strategy = TicTacToes::Core::MoveStrategies::MediumAI
 
       computer_player = player_factory.generate_computer_player(token,
                                                                 difficulty)

data/spec/tic_tac_toes/{player_spec.rb → core/player_spec.rb}

@@ -1,8 +1,8 @@
-require 'tic_tac_toes/board'
-require 'tic_tac_toes/player'
+require 'tic_tac_toes/core/board'
+require 'tic_tac_toes/core/player'
 
-describe TicTacToes::Player do
-  let(:board)         { TicTacToes::Board.new(row_size: 3) }
+describe TicTacToes::Core::Player do
+  let(:board)         { TicTacToes::Core::Board.new(row_size: 3) }
   let(:io)            { double("io", invalid_move_error: true) }
   let(:players)       { double("players") }
 
@@ -11,7 +11,7 @@ describe TicTacToes::Player do
     let(:token)           { "X" }
     let(:needs_to_think)  { false }
 
-    let(:player) { TicTacToes::Player.new(move_strategy, token, needs_to_think, io) }
+    let(:player) { TicTacToes::Core::Player.new(move_strategy, token, needs_to_think, io) }
  
     it "only places/returns a move once it receives a valid move" do
       invalid_space, valid_space = 9, 0

data/spec/tic_tac_toes/{rules_spec.rb → core/rules_spec.rb}

@@ -1,8 +1,8 @@
-require 'test_board_generator'
-require 'tic_tac_toes/rules'
+require 'tic_tac_toes/test_board_generator'
+require 'tic_tac_toes/core/rules'
 
-describe TicTacToes::Rules do
-  let(:rules) { TicTacToes::Rules }
+describe TicTacToes::Core::Rules do
+  let(:rules) { TicTacToes::Core::Rules }
   let(:x) { double("human player", token: "x") }
   let(:o) { double("computer player", token: "o") }
   let(:players) { [x, o] }
@@ -60,25 +60,25 @@ describe TicTacToes::Rules do
 
   describe '#game_over?' do
     it "returns false if there is not yet a winner and the board is not full" do
-      board = TestBoardGenerator.generate([x, x,   o,
-                                           o, o, nil,
-                                           x, o,   x])
+      board = TicTacToes::TestBoardGenerator.generate([x, x,   o,
+                                                       o, o, nil,
+                                                       x, o,   x])
 
       expect(rules.game_over?(board, players)).to be false
     end
 
     it "returns true if any player has won" do
-      board = TestBoardGenerator.generate([  x, nil, nil,
-                                           nil,   x, nil,
-                                           nil, nil,   x])
+      board = TicTacToes::TestBoardGenerator.generate([  x, nil, nil,
+                                                       nil,   x, nil,
+                                                       nil, nil,   x])
 
       expect(rules.game_over?(board, players)).to be true
     end
 
     it "returns true if the board is full" do
-      board = TestBoardGenerator.generate([x, x, o,
-                                           o, o, x,
-                                           x, o, x])
+      board = TicTacToes::TestBoardGenerator.generate([x, x, o,
+                                                       o, o, x,
+                                                       x, o, x])
 
       expect(rules.game_over?(board, players)).to be true
     end
@@ -87,18 +87,18 @@ describe TicTacToes::Rules do
 
   describe '#determine_winner' do
     it "returns the winning token when there is a winner" do
-      board = TestBoardGenerator.generate([  o, nil, nil,
-                                           nil,   o, nil,
-                                           nil, nil,   o])
+      board = TicTacToes::TestBoardGenerator.generate([  o, nil, nil,
+                                                       nil,   o, nil,
+                                                       nil, nil,   o])
       winning_token = "o"
 
       expect(rules.determine_winner(board, players)).to eql(winning_token)
     end
 
     it "returns nil if there is not a winner" do
-      board = TestBoardGenerator.generate([x, x,   o,
-                                           o, o, nil,
-                                           x, o,   x])
+      board = TicTacToes::TestBoardGenerator.generate([x, x,   o,
+                                                       o, o, nil,
+                                                       x, o,   x])
 
       expect(rules.determine_winner(board, players)).to be_nil
     end
@@ -107,41 +107,41 @@ describe TicTacToes::Rules do
 
   describe '#win?' do
     it "returns false if the given token has not won" do
-      board = TestBoardGenerator.generate([x, x,  o,
-                                           o, o, nil,
-                                           x, o,  x])
+      board = TicTacToes::TestBoardGenerator.generate([x, x,  o,
+                                                       o, o, nil,
+                                                       x, o,  x])
 
       expect(rules.win?(board, x)).to be false
     end
 
     it "returns true if the given token has achieved a back diagonal win" do
-      board = TestBoardGenerator.generate([  x, nil, nil,
-                                           nil,   x, nil,
-                                           nil, nil,   x])
+      board = TicTacToes::TestBoardGenerator.generate([  x, nil, nil,
+                                                       nil,   x, nil,
+                                                       nil, nil,   x])
 
       expect(rules.win?(board, x)).to be true
     end
 
     it "returns true if the given token has achieved a front diagonal win" do
-      board = TestBoardGenerator.generate([nil, nil,   x,
-                                           nil,   x, nil,
-                                             x, nil, nil])
+      board = TicTacToes::TestBoardGenerator.generate([nil, nil,   x,
+                                                       nil,   x, nil,
+                                                         x, nil, nil])
 
       expect(rules.win?(board, x)).to be true
     end
 
     it "returns true if the given token has achieved a horizonatal win" do
-      board = TestBoardGenerator.generate([nil, nil, nil,
-                                             x,   x,   x,
-                                           nil, nil, nil])
+      board = TicTacToes::TestBoardGenerator.generate([nil, nil, nil,
+                                                         x,   x,   x,
+                                                       nil, nil, nil])
 
       expect(rules.win?(board, x)).to be true
     end
 
     it "returns true if the given token has achieved a vertical win" do
-      board = TestBoardGenerator.generate([nil, x, nil,
-                                           nil, x, nil,
-                                           nil, x, nil])
+      board = TicTacToes::TestBoardGenerator.generate([nil, x, nil,
+                                                       nil, x, nil,
+                                                       nil, x, nil])
 
       expect(rules.win?(board, x)).to be true
     end

data/spec/tic_tac_toes/{strings_spec.rb → core/strings_spec.rb}

@@ -1,14 +1,14 @@
-require 'tic_tac_toes/board'
-require 'tic_tac_toes/rules'
-require 'tic_tac_toes/strings'
+require 'tic_tac_toes/core/board'
+require 'tic_tac_toes/core/rules'
+require 'tic_tac_toes/core/strings'
 
-describe TicTacToes::Strings do
-  let(:strings) { TicTacToes::Strings }
+describe TicTacToes::Core::Strings do
+  let(:strings) { TicTacToes::Core::Strings }
 
   describe '#invalid_row_size' do
     it "returns a string containing the minimum and maximum allowed row sizes" do
-      smallest_row_size = TicTacToes::Rules::ROW_SIZE_RANGE.min.to_s
-      largest_row_size = TicTacToes::Rules::ROW_SIZE_RANGE.max.to_s
+      smallest_row_size = TicTacToes::Core::Rules::ROW_SIZE_RANGE.min.to_s
+      largest_row_size = TicTacToes::Core::Rules::ROW_SIZE_RANGE.max.to_s
 
       expect(strings::INVALID_ROW_SIZE).to include(smallest_row_size, largest_row_size)
     end
@@ -30,7 +30,7 @@ describe TicTacToes::Strings do
 
   describe '#board' do
     it "returns a board string" do
-      board = TicTacToes::Board.new(row_size: 3)
+      board = TicTacToes::Core::Board.new(row_size: 3)
 
       leading_spaces_regexp = /^[[:blank:]]+/
       board_string = <<-END.gsub(leading_spaces_regexp, '')

data/spec/{database → tic_tac_toes/database}/pg_wrapper_spec.rb

@@ -1,10 +1,10 @@
-require 'database/pg_wrapper'
+require 'tic_tac_toes/database/pg_wrapper'
 require 'pg'
 
-describe Database::PGWrapper do
+describe TicTacToes::Database::PGWrapper do
   database = "tic_tac_toes_test"
 
-  let(:pg_wrapper) { Database::PGWrapper.new(database) }
+  let(:pg_wrapper) { TicTacToes::Database::PGWrapper.new(database) }
   let(:history1)   { double("history 1",
                      :board_size => 9,
                      :moves => [["X", 1], ["O", 4]],

data/spec/tic_tac_toes/test_board_generator.rb

@@ -0,0 +1,17 @@
+require 'tic_tac_toes/core/board'
+
+module TicTacToes
+  module TestBoardGenerator
+    def self.generate(structure)
+      board_size = structure.count
+      row_size = Math.sqrt(board_size)
+      board = TicTacToes::Core::Board.new(row_size: row_size)
+
+      structure.each_with_index do |player, index|
+        board.place(player, index)
+      end
+
+      board
+    end
+  end
+end

data/spec/{ui → tic_tac_toes/ui}/adapter_spec.rb

@@ -1,13 +1,13 @@
-require 'tic_tac_toes/board'
-require 'tic_tac_toes/game_state'
-require 'tic_tac_toes/player_factory'
-require 'ui/adapter'
+require 'tic_tac_toes/core/board'
+require 'tic_tac_toes/core/game_state'
+require 'tic_tac_toes/core/player_factory'
+require 'tic_tac_toes/ui/adapter'
 
-describe UI::Adapter do
+describe TicTacToes::UI::Adapter do
   describe '#new_board_structure' do
     it 'returns a new board structure' do
       new_board_structure = [nil, nil, nil, nil, nil, nil, nil, nil, nil]
-      expect(UI::Adapter.new_board_structure).to eq(new_board_structure)
+      expect(TicTacToes::UI::Adapter.new_board_structure).to eq(new_board_structure)
     end
   end
 
@@ -21,7 +21,7 @@ describe UI::Adapter do
         updated_board_structure = ["X", "O", "X", nil, "O", nil, nil, nil, nil]
 
         expect(listener).to receive(:move_was_valid).with(updated_board_structure)
-        UI::Adapter.make_move(board_structure, move, listener)
+        TicTacToes::UI::Adapter.make_move(board_structure, move, listener)
       end
     end
 
@@ -35,7 +35,7 @@ describe UI::Adapter do
         game_over_message = "Game over"
 
         expect(listener).to receive(:game_is_over).with(updated_board_structure, game_over_message)
-        UI::Adapter.make_move(board_structure, move, listener)
+        TicTacToes::UI::Adapter.make_move(board_structure, move, listener)
       end
     end
   end
@@ -44,7 +44,7 @@ describe UI::Adapter do
     it 'returns a game state object based on a board structure' do
       board_structure = [nil, nil, nil, nil, "X", nil, nil, nil, nil]
 
-      game_state = UI::Adapter.game_state_from_board_structure(board_structure)
+      game_state = TicTacToes::UI::Adapter.game_state_from_board_structure(board_structure)
       middle_space = game_state.board.space(4)
       first_player = game_state.players.first
       second_player = game_state.players.last
@@ -57,16 +57,16 @@ describe UI::Adapter do
 
   describe '#game_state_to_board_structure' do
     it 'returns a board structure based on a game state object' do
-      player_factory = TicTacToes::PlayerFactory.new('unused_io')
+      player_factory = TicTacToes::Core::PlayerFactory.new('unused_io')
       first_player = player_factory.generate_human_player('X')
       second_player = player_factory.generate_computer_player('O', :hard)
       players = [first_player, second_player]
-      board = TicTacToes::Board.new
+      board = TicTacToes::Core::Board.new
       board.place(first_player, 4)
 
-      game_state = TicTacToes::GameState.new(board, players, UI::NullHistory.new)
+      game_state = TicTacToes::Core::GameState.new(board, players, TicTacToes::UI::NullHistory.new)
       board_structure = [nil, nil, nil, nil, "X", nil, nil, nil, nil]
-      expect(UI::Adapter.game_state_to_board_structure(game_state)).to eq(board_structure)
+      expect(TicTacToes::UI::Adapter.game_state_to_board_structure(game_state)).to eq(board_structure)
     end
   end
 end