tic_tac_toes 0.0.7 → 0.0.8

data/lib/tic_tac_toes/core/rules.rb

@@ -0,0 +1,66 @@
+require 'tic_tac_toes/core/player_factory'
+
+module TicTacToes
+  module Core
+    module Rules
+      ROW_SIZE_RANGE = (2..10)
+
+      def self.row_size_valid?(row_size)
+        row_size.between?(ROW_SIZE_RANGE.min, ROW_SIZE_RANGE.max)
+      end
+
+      def self.token_valid?(token, taken_tokens)
+        correct_length = token.length == 1
+        untaken = !taken_tokens.include?(token)
+
+        correct_length && untaken
+      end
+
+      def self.difficulty_valid?(difficulty)
+        PlayerFactory::AIS.include? difficulty
+      end
+
+      def self.game_over?(board, players)
+        winner = !determine_winner(board, players).nil?
+        tie = board.full?
+
+        winner || tie
+      end
+
+      def self.determine_winner(board, players)
+        winner = nil
+
+        players.each do |player|
+          player_has_won = win?(board, player)
+          winner = player.token if player_has_won
+        end
+
+        winner
+      end
+
+      def self.win?(board, player)
+        diagonal_win?(board, player) ||
+        horizontal_win?(board, player) ||
+        vertical_win?(board, player)
+      end
+
+      private
+
+      def self.diagonal_win?(board, player)
+        set_win?(board.diagonals, player)
+      end
+
+      def self.horizontal_win?(board, player)
+        set_win?(board.rows, player)
+      end
+
+      def self.vertical_win?(board, player)
+        set_win?(board.columns, player)
+      end
+
+      def self.set_win?(sets, player)
+        sets.any? { |set| set.all? { |space| space.token == player.token unless space.nil?  } }
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/core/strings.rb

@@ -0,0 +1,106 @@
+require 'tic_tac_toes/command_line/prompt'
+require 'tic_tac_toes/core/rules'
+
+module TicTacToes
+  module Core
+    module Strings
+      smallest_row_size = Rules::ROW_SIZE_RANGE.min
+      largest_row_size = Rules::ROW_SIZE_RANGE.max
+
+      NOT_AN_INTEGER           =  "Input must be an integer"
+      INVALID_ROW_SIZE         =  "Input must be between #{smallest_row_size} and #{largest_row_size}"
+      INVALID_TOKEN            =  "Input must be a single, untaken character"
+      INVALID_DIFFICULTY       =  "Input must be a valid difficulty"
+      INVALID_MOVE             =  "Input must be a space that is on the board and untaken"
+      ROW_SIZE_SOLICITATION    =  "Pick row size of board:"
+      DIFFICULTY_SOLICITATION  =  "Pick difficulty (easy, medium, hard):"
+      MOVE_SOLICITATION        =  "Pick a space:"
+      THINKING                 =  "Thinking..."
+
+      def self.token_solicitation(player)
+        "Pick #{player} token:"
+      end
+
+      def self.game_over_notification(winner)
+        "#{winner} wins!"
+      end
+
+      def self.board(board)
+        board_string = ""
+        board.rows.each_with_index do |row, index|
+          row_start_index = (index * board.row_size).to_i
+          at_last_row = index == board.row_size - 1
+          board_string << "\n"
+          board_string << row(row, row_start_index, board.size)
+          board_string << "\n"
+          board_string << horizontal_divider(board.row_size, board.size) unless at_last_row
+        end
+        board_string << "\n"
+      end
+
+      private
+
+      def self.row(row, row_start_index, board_size)
+        row_array = []
+        row.each_with_index do |space, index|
+          if space.nil?
+            board_index = index + row_start_index
+            row_array << empty_space(board_index, board_size)
+          else
+            row_array << token(space, board_size)
+          end
+        end
+        row_array.join("|")
+      end
+
+      def self.empty_space(board_index, board_size)
+        if space_needs_buffer?(board_index, board_size)
+          "[ #{board_index}]"
+        else
+          "[#{board_index}]"
+        end
+      end
+
+      def self.token(space, board_size)
+        token = get_colored_token(space)
+
+        if double_digit_board?(board_size)
+          "  #{token} "
+        else
+          " #{token} "
+        end
+      end
+
+      def self.get_colored_token(player)
+        if player.needs_to_think
+          return CommandLine::Prompt.red(player.token)
+        else
+          return CommandLine::Prompt.blue(player.token)
+        end
+      end
+
+      def self.space_needs_buffer?(board_index, board_size)
+        is_double_digit_board = double_digit_board?(board_size)
+        is_single_digit_space = board_index < 10
+
+        is_double_digit_board && is_single_digit_space
+      end
+
+      def self.double_digit_board?(board_size)
+        board_size > 10
+      end
+
+      def self.horizontal_divider(row_size, board_size)
+        horizontal_divider = ""
+        divider_unit = "-"
+        divider_units_per_space = double_digit_board?(board_size) ? 5 : 4
+        extra_units_per_row = 1
+
+        raw_length = (row_size * divider_units_per_space).to_i
+        truncated_length = raw_length - extra_units_per_row
+        truncated_length.times { horizontal_divider << divider_unit }
+        horizontal_divider
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/database/pg_wrapper.rb

@@ -0,0 +1,74 @@
+require 'pg'
+require 'tic_tac_toes/core/history'
+
+module TicTacToes
+  module Database
+    class PGWrapper
+      def initialize(database)
+        @database = database
+      end
+
+      def record_game_history(history)
+        connection = establish_connection
+        record_board_size_and_winner(history, connection)
+        record_moves(history, connection)
+      end
+
+      def read_game_histories
+        connection = establish_connection
+        games_result = connection.exec("SELECT * FROM games")
+        games = []
+
+        games_result.each_row do |row|
+          game_id = row[0]
+          board_size = row[1].to_i
+          winner = row[2]
+          moves_result = connection.exec("SELECT * FROM moves WHERE game = #{game_id}")
+
+          history = Core::History.new(self)
+
+          moves_result.each_row do |row|
+            token, space = row[2], row[3].to_i
+            history.record_move([token, space])
+          end
+          history.record_board_size(board_size)
+          history.record_winner(winner)
+
+          games << history
+        end
+
+        games
+      end
+
+      private
+
+      def establish_connection
+        PG.connect(dbname: @database)
+      end
+
+      def record_board_size_and_winner(history, connection)
+        connection.exec("INSERT INTO games (board_size, winner) VALUES (
+          #{history.board_size},
+          '#{history.winner}')")
+      end
+
+      def record_moves(history, connection)
+        game_id = read_game_id(connection)
+
+        history.moves.each_with_index do |move, index|
+          move_number = index + 1
+          connection.exec("INSERT INTO moves (game, number, token, space) VALUES (
+            #{game_id},
+            #{move_number},
+            '#{move.first}',
+            #{move.last})")
+        end
+      end
+
+      def read_game_id(connection)
+        result = connection.exec("SELECT currval(pg_get_serial_sequence('games','id'))")
+        result.getvalue(0,0)
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/ui/adapter.rb

@@ -0,0 +1,96 @@
+require 'tic_tac_toes/core/board'
+require 'tic_tac_toes/core/game_state'
+require 'tic_tac_toes/core/player_factory'
+require 'tic_tac_toes/core/rules'
+
+module TicTacToes
+  module UI
+    module Adapter
+      def self.new_board_structure
+        board = Core::Board.new
+        board.spaces
+      end
+
+      def self.make_move(board_structure, move, listener)
+        move = move.to_i
+        game_state = game_state_from_board_structure(board_structure)
+
+        human_player = game_state.players.first
+        game_state.board.place(human_player, move)
+
+        if Core::Rules.game_over?(game_state.board, game_state.players)
+          return listener.game_is_over(game_state_to_board_structure(game_state), "Game over")
+        end
+
+        game_state.turn_over(move)
+
+        computer_player = game_state.players.first
+        computer_player.place_and_return_move(game_state.board, game_state.players)
+
+        if Core::Rules.game_over?(game_state.board, game_state.players)
+          return listener.game_is_over(game_state_to_board_structure(game_state), "Game over")
+        end
+
+        listener.move_was_valid(game_state_to_board_structure(game_state))
+      end
+
+      def self.game_state_from_board_structure(board_structure)
+        player_factory = Core::PlayerFactory.new('unused_io')
+        human_player = player_factory.generate_human_player('X')
+        computer_player = player_factory.generate_computer_player('O', :hard)
+        players = [human_player, computer_player]
+
+        board_structure_with_players = replace_tokens_with_players(board_structure, human_player, computer_player)
+        board = board_from_structure(board_structure_with_players)
+
+        Core::GameState.new(board, players, NullHistory.new)
+      end
+
+      def self.game_state_to_board_structure(game_state)
+        structure_with_players = game_state.board.spaces
+
+        replace_players_with_tokens(structure_with_players)
+      end
+
+      private
+
+      def self.replace_tokens_with_players(board_structure, human_player, computer_player)
+        board_structure.map do |space|
+          case space
+          when 'X'
+            human_player
+          when 'O'
+            computer_player
+          else
+            nil
+          end
+        end
+      end
+
+      def self.replace_players_with_tokens(board_structure)
+        board_structure.map { |space| space.token unless space.nil? }
+      end
+
+      def self.board_from_structure(board_structure)
+        row_size = Math.sqrt(board_structure.count).to_i
+        board = Core::Board.new(row_size: row_size)
+
+        board_structure.each_with_index do |player, index|
+          board.place(player, index)
+        end
+
+        board
+      end
+    end
+
+    class NullHistory
+      def record_board_size(size)
+        nil
+      end
+
+      def record_move(move)
+        nil
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/version.rb

@@ -1,3 +1,3 @@
 module TicTacToes
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/spec/{command_line → tic_tac_toes/command_line}/menu_spec.rb

@@ -1,15 +1,15 @@
-require 'command_line/menu'
-require 'tic_tac_toes/board_factory'
-require 'tic_tac_toes/player_factory'
-require 'tic_tac_toes/io'
-require 'tic_tac_toes/move_strategies/human'
-require 'tic_tac_toes/move_strategies/medium_ai'
-
-describe CommandLine::Menu do
+require 'tic_tac_toes/command_line/menu'
+require 'tic_tac_toes/core/board_factory'
+require 'tic_tac_toes/core/player_factory'
+require 'tic_tac_toes/core/io'
+require 'tic_tac_toes/core/move_strategies/human'
+require 'tic_tac_toes/core/move_strategies/medium_ai'
+
+describe TicTacToes::CommandLine::Menu do
   let(:io) { double }
-  let(:board_factory) { TicTacToes::BoardFactory.new }
-  let(:player_factory) { TicTacToes::PlayerFactory.new(io) }
-  let(:menu) { CommandLine::Menu.new(io, board_factory, player_factory) }
+  let(:board_factory) { TicTacToes::Core::BoardFactory.new }
+  let(:player_factory) { TicTacToes::Core::PlayerFactory.new(io) }
+  let(:menu) { TicTacToes::CommandLine::Menu.new(io, board_factory, player_factory) }
 
   describe '#get_board' do
     let(:invalid_row_size) { 11 }
@@ -40,8 +40,8 @@ describe CommandLine::Menu do
       allow(io).to receive(:get_difficulty).and_return(difficulty)
 
       human_player, computer_player = menu.get_players
-      expect(human_player.move_strategy).to be_a TicTacToes::MoveStrategies::Human
-      expect(computer_player.move_strategy).to eq(TicTacToes::MoveStrategies::MediumAI)
+      expect(human_player.move_strategy).to be_a TicTacToes::Core::MoveStrategies::Human
+      expect(computer_player.move_strategy).to eq(TicTacToes::Core::MoveStrategies::MediumAI)
     end
 
     context 'when given an invalid (non-single-character) token' do
@@ -92,7 +92,7 @@ describe CommandLine::Menu do
         allow(io).to receive(:get_difficulty).and_return(invalid_difficulty, valid_difficulty)
 
         computer_player = menu.get_players.last
-        expect(computer_player.move_strategy).to eq(TicTacToes::MoveStrategies::MediumAI)
+        expect(computer_player.move_strategy).to eq(TicTacToes::Core::MoveStrategies::MediumAI)
       end
     end
   end

data/spec/{command_line → tic_tac_toes/command_line}/runner_spec.rb

@@ -1,6 +1,6 @@
-require 'command_line/runner'
+require 'tic_tac_toes/command_line/runner'
 
-describe CommandLine::Runner do
+describe TicTacToes::CommandLine::Runner do
   describe '#run' do
     let(:game_state) { double(board: 'board', players: 'players', game_over: true) }
 
@@ -11,15 +11,12 @@ describe CommandLine::Runner do
                                        get_players: true) }
     let(:game_state)          { double(board: 'board',
                                        players: 'players',
-                                       game_over: true) }
-    let(:game_state_factory)  { double(generate_game_state: game_state) }
-    let(:rules)               { double(game_over?: true,
+                                       game_over: true,
+                                       game_over?: true,
                                        determine_winner: true) }
+    let(:game_state_factory)  { double(generate_game_state: game_state) }
 
-    let(:runner)              { CommandLine::Runner.new(io,
-                                                        menu,
-                                                        game_state_factory,
-                                                        rules) }
+    let(:runner) { TicTacToes::CommandLine::Runner.new(io, menu, game_state_factory) }
 
     it 'gets an initial game state' do
       expect(game_state_factory).to receive(:generate_game_state)
@@ -27,7 +24,7 @@ describe CommandLine::Runner do
     end
 
     it 'takes turns until the game is over' do
-      allow(rules).to receive(:game_over?).and_return(false, true)
+      allow(game_state).to receive(:game_over?).and_return(false, true)
 
       expect(runner).to receive(:take_turn).once
       runner.run

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

@@ -1,9 +1,9 @@
-require 'tic_tac_toes/board_factory'
+require 'tic_tac_toes/core/board_factory'
 
-describe TicTacToes::BoardFactory do
+describe TicTacToes::Core::BoardFactory do
   describe '#generate_board' do
     it 'returns a board object generated from a row size' do
-      board_factory = TicTacToes::BoardFactory.new
+      board_factory = TicTacToes::Core::BoardFactory.new
       row_size = 5
 
       board = board_factory.generate_board(row_size)

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

@@ -1,9 +1,9 @@
-require 'test_board_generator'
-require 'tic_tac_toes/board'
+require 'tic_tac_toes/test_board_generator'
+require 'tic_tac_toes/core/board'
 
-describe TicTacToes::Board do
+describe TicTacToes::Core::Board do
   describe '#place (and #space)' do
-    let(:board) { TicTacToes::Board.new(row_size: 3) }
+    let(:board) { TicTacToes::Core::Board.new(row_size: 3) }
 
     it "returns nil if the space is not nil" do
       first_token, second_token = :X, :O
@@ -28,9 +28,9 @@ describe TicTacToes::Board do
 
   describe '#open_spaces' do
     it "returns an array of the board's nil spaces" do
-      board = TestBoardGenerator.generate([:X, :O, nil,
-                                           :O, :O,  :X,
-                                           :X, :X, nil])
+      board = TicTacToes::TestBoardGenerator.generate([:X, :O, nil,
+                                                       :O, :O,  :X,
+                                                       :X, :X, nil])
       open_spaces = [2, 8]
 
       expect(board.open_spaces).to eql(open_spaces)
@@ -40,10 +40,10 @@ describe TicTacToes::Board do
 
   describe '#rows' do
     it "returns an array of row arrays based on the board's spaces" do
-      board = TestBoardGenerator.generate([ :X,  :X,  :X,  :X,
-                                           nil, nil, nil, nil,
-                                           nil, nil, nil, nil,
-                                           nil, nil, nil, nil])
+      board = TicTacToes::TestBoardGenerator.generate([ :X,  :X,  :X,  :X,
+                                                       nil, nil, nil, nil,
+                                                       nil, nil, nil, nil,
+                                                       nil, nil, nil, nil])
       first_row = [:X, :X, :X, :X]
 
       expect(board.rows.size).to eq(4)
@@ -54,10 +54,10 @@ describe TicTacToes::Board do
 
   describe '#columns' do
     it "returns an array of column arrays based on the board's spaces" do
-      board = TestBoardGenerator.generate([:X, nil, nil, nil,
-                                           :X, nil, nil, nil,
-                                           :X, nil, nil, nil,
-                                           :X, nil, nil, nil])
+      board = TicTacToes::TestBoardGenerator.generate([:X, nil, nil, nil,
+                                                       :X, nil, nil, nil,
+                                                       :X, nil, nil, nil,
+                                                       :X, nil, nil, nil])
       first_column = [:X, :X, :X, :X]
 
       expect(board.columns.size).to eq(4)
@@ -68,10 +68,10 @@ describe TicTacToes::Board do
 
   describe '#diagonals' do
     it "returns an array of diagonal arrays based on the board's spaces" do
-      board = TestBoardGenerator.generate([ :X, nil, nil,  :O,
-                                           nil,  :X,  :O, nil,
-                                           nil,  :O,  :X, nil,
-                                            :O, nil, nil,  :X])
+      board = TicTacToes::TestBoardGenerator.generate([ :X, nil, nil,  :O,
+                                                       nil,  :X,  :O, nil,
+                                                       nil,  :O,  :X, nil,
+                                                        :O, nil, nil,  :X])
       back_diagonal  = [:X, :X, :X, :X]
       front_diagonal = [:O, :O, :O, :O]
 
@@ -84,14 +84,14 @@ describe TicTacToes::Board do
 
   describe '#full?' do
     it "returns false if any spaces are still nil" do
-      board = TicTacToes::Board.new
+      board = TicTacToes::Core::Board.new
       expect(board.full?).to be false
     end
 
     it "returns true if all spaces are non-nil" do
-      board = TestBoardGenerator.generate([:X, :O, :X,
-                                           :O, :X, :O,
-                                           :X, :O, :X])
+      board = TicTacToes::TestBoardGenerator.generate([:X, :O, :X,
+                                                       :O, :X, :O,
+                                                       :X, :O, :X])
 
       expect(board.full?).to be true
     end

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

@@ -1,10 +1,10 @@
-require 'tic_tac_toes/game_state_factory'
+require 'tic_tac_toes/core/game_state_factory'
 
-describe TicTacToes::GameStateFactory do
+describe TicTacToes::Core::GameStateFactory do
   describe '#generate_game_state' do
     it 'returns a game state object generated from a board object and player array' do
       history = double(record_board_size: true)
-      game_state_factory = TicTacToes::GameStateFactory.new(history)
+      game_state_factory = TicTacToes::Core::GameStateFactory.new(history)
       board, players = double(size: 3), double
 
       game_state = game_state_factory.generate_game_state(board, players)

data/spec/tic_tac_toes/core/game_state_spec.rb

@@ -0,0 +1,129 @@
+require 'tic_tac_toes/core/game_state'
+require 'tic_tac_toes/test_board_generator'
+
+describe TicTacToes::Core::GameState do
+  describe '@initialize' do
+    it "records its board's size" do
+      size = 5
+      board = double(size: size)
+      history = double
+
+      expect(history).to receive(:record_board_size).with(size)
+      TicTacToes::Core::GameState.new(board, 'players', history)
+    end
+  end
+
+  describe '#current_player' do
+    it 'returns the first item of its players array' do
+      history = double(record_board_size: true)
+      players = ['first_player', 'second_player']
+      game_state = TicTacToes::Core::GameState.new('board', players, history)
+
+      current_player = game_state.current_player
+      expect(current_player).to eq('first_player')
+    end
+  end
+
+  describe '#turn_over' do
+    it 'records the last move' do
+      move = double
+      players = double(rotate!: true)
+      history = double(record_board_size: true)
+      game_state = TicTacToes::Core::GameState.new('board', players, history)
+
+      expect(history).to receive(:record_move).with(move)
+      game_state.turn_over(move)
+    end
+
+    it 'rotates its player array' do
+      players = ['first_player', 'second_player']
+      history = double(record_board_size: true, record_move: true)
+      game_state = TicTacToes::Core::GameState.new('board', players, history)
+
+      game_state.turn_over('move')
+      expect(game_state.current_player).to eq('second_player')
+    end
+  end
+
+  describe '#game_over' do
+    it 'records the winner' do
+      winner = double
+      history = double(record_board_size: true, persist: true)
+      game_state = TicTacToes::Core::GameState.new('board', 'players', history)
+
+      expect(history).to receive(:record_winner).with(winner)
+      game_state.game_over(winner)
+    end
+
+    it 'persists its history' do
+      winner = double
+      history = double(record_board_size: true, record_winner: true)
+      game_state = TicTacToes::Core::GameState.new('board', 'players', history)
+
+      expect(history).to receive(:persist)
+      game_state.game_over(winner)
+    end
+  end
+
+  describe '#game_over?' do
+    let(:x) { double("human player", token: "x") }
+    let(:o) { double("computer player", token: "o") }
+    let(:players) { [x, o] }
+
+    let(:history) { double(record_board_size: true) }
+
+    it "returns false if there is not yet a winner and the board is not full" do
+      board = TicTacToes::TestBoardGenerator.generate([x, x,   o,
+                                                       o, o, nil,
+                                                       x, o,   x])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
+      expect(game_state.game_over?).to be false
+    end
+
+    it "returns true if any player has won" do
+      board = TicTacToes::TestBoardGenerator.generate([  x, nil, nil,
+                                                       nil,   x, nil,
+                                                       nil, nil,   x])
+
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
+
+      expect(game_state.game_over?).to be true
+    end
+
+    it "returns true if the board is full" do
+      board = TicTacToes::TestBoardGenerator.generate([x, x, o,
+                                                       o, o, x,
+                                                       x, o, x])
+
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
+      expect(game_state.game_over?).to be true
+    end
+  end
+
+  describe '#determine_winner' do
+    let(:x) { double("human player", token: "x") }
+    let(:o) { double("computer player", token: "o") }
+    let(:players) { [x, o] }
+
+    let(:history) { double(record_board_size: true) }
+    it "returns the winning token when there is a winner" do
+      board = TicTacToes::TestBoardGenerator.generate([  o, nil, nil,
+                                                       nil,   o, nil,
+                                                       nil, nil,   o])
+      winning_token = "o"
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
+
+      expect(game_state.determine_winner).to eql(winning_token)
+    end
+
+    it "returns nil if there is not a winner" do
+      board = TicTacToes::TestBoardGenerator.generate([x, x,   o,
+                                                       o, o, nil,
+                                                       x, o,   x])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
+
+      expect(game_state.determine_winner).to be_nil
+    end
+  end
+
+end