tic_tac_toes 0.0.1

data/lib/tic_tac_toes/strings.rb

@@ -0,0 +1,103 @@
+require 'tic_tac_toes/rules'
+
+module TicTacToes
+  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::IO.red(player.token)
+      else
+        return CommandLine::IO.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

data/lib/tic_tac_toes/version.rb

@@ -0,0 +1,3 @@
+module TicTacToes
+  VERSION = "0.0.1"
+end

data/spec/command_line/menu_spec.rb

@@ -0,0 +1,103 @@
+require 'tic_tac_toes/io_interface'
+require 'command_line/menu'
+require 'tic_tac_toes/medium_ai'
+require 'tic_tac_toes/spec_helper'
+
+describe CommandLine::Menu do
+  let(:io) { double("io") }
+  let(:io_interface) { TicTacToes::IOInterface.new(io) }
+  let(:menu) { CommandLine::Menu.new(io_interface) }
+
+
+  describe '#get_board' do
+    let(:invalid_row_size) { 11 }
+    let(:valid_row_size) { 7 }
+
+    it "displays an invalid row size error when given an invalid (outside 2-10) row size" do
+      allow(io_interface).to receive(:get_row_size).and_return(invalid_row_size, valid_row_size)
+
+      expect(io_interface).to receive(:invalid_row_size_error)
+      menu.get_board
+    end
+
+    it "only returns a row size once it receives a valid (2-10) row size" do
+      allow(io_interface).to receive(:invalid_row_size_error)
+      allow(io_interface).to receive(:get_row_size).and_return(invalid_row_size, valid_row_size)
+
+      board = menu.get_board
+      expect(board.row_size).to eq(valid_row_size)
+    end
+  end
+
+
+  describe '#get_players' do
+    before(:each) do
+      allow(io).to receive(:blue) { |argument| argument }
+      allow(io).to receive(:red) { |argument| argument }
+    end
+
+    it "returns an array with a human (IO decider) player and a computer (AI decider) player" do
+      first_token, second_token = "X", "O"
+      difficulty = :medium
+
+      allow(io_interface).to receive(:get_token).and_return(first_token, second_token)
+      allow(io_interface).to receive(:get_difficulty).and_return(difficulty)
+
+      human_player, computer_player = menu.get_players
+      expect(human_player.decider).to be_a TicTacToes::IOInterface
+      expect(computer_player.decider).to eq(TicTacToes::MediumAI)
+    end
+
+    context 'when given an invalid (non-single-character) token' do
+      let(:invalid_token) { "invalid" }
+      let(:first_token) { "X" }
+      let(:second_token) { "O" }
+
+      before(:each) do
+        valid_difficulty = :medium
+        allow(io_interface).to receive(:get_difficulty) { valid_difficulty }
+      end
+
+      it "displays an invalid token error" do
+        allow(io_interface).to receive(:get_token).and_return(invalid_token, first_token, second_token)
+
+        expect(io_interface).to receive(:invalid_token_error)
+        menu.get_players
+      end
+
+      it "only returns an array of players (with correct tokens) once it receives a valid token" do
+        allow(io_interface).to receive(:invalid_token_error)
+        allow(io_interface).to receive(:get_token).and_return(invalid_token, first_token, second_token)
+
+        first_player, second_player = menu.get_players
+        expect(first_player.token).to eq(first_token)
+        expect(second_player.token).to eq(second_token)
+      end
+    end
+
+    context 'when given an invalid (not in the list) difficulty' do
+      let(:invalid_difficulty) { :invalid }
+      let(:valid_difficulty) { :medium }
+
+      before(:each) do
+        first_token, second_token = "X", "O"
+        allow(io_interface).to receive(:get_token).and_return(first_token, second_token)
+      end
+
+      it "displays an invalid difficulty error" do
+        allow(io_interface).to receive(:get_difficulty).and_return(invalid_difficulty, valid_difficulty)
+
+        expect(io_interface).to receive(:invalid_difficulty_error)
+        menu.get_players
+      end
+
+      it "only returns an array of players (with correct difficulty) once it receives a valid difficulty" do
+        allow(io_interface).to receive(:invalid_difficulty_error)
+        allow(io_interface).to receive(:get_difficulty).and_return(invalid_difficulty, valid_difficulty)
+
+        computer_player = menu.get_players.last
+        expect(computer_player.decider).to eq(TicTacToes::MediumAI)
+      end
+    end
+  end
+end

data/spec/command_line/runner_spec.rb

@@ -0,0 +1,119 @@
+require 'command_line/runner'
+require 'tic_tac_toes/board'
+require 'tic_tac_toes/history'
+require 'tic_tac_toes/spec_helper'
+
+describe CommandLine::Runner do
+  let(:io_interface)        { double("io interface",
+                              :draw_board => true,
+                              :thinking_notification => true,
+                              :game_over_notification => true) }
+  let(:board)               { TicTacToes::Board.new(row_size: 3) }
+  let(:menu)                { double("menu",
+                              :get_board => board,
+                              :get_players => true) }
+  let(:rules)               { double("rules",
+                              :game_over? => true,
+                              :determine_winner => "X") }
+  let(:database_interface)  { double("database interface", :record_game_history => true) }
+  let(:history)             { TicTacToes::History.new(database_interface) }
+
+  let(:runner)              { CommandLine::Runner.new(io_interface, menu, rules, history) }
+
+
+  describe '#run' do
+    it "gets a board and players" do
+      expect(menu).to receive(:get_board)
+      expect(menu).to receive(:get_players)
+      runner.run
+    end
+
+    it "has its history object record the board size" do
+      runner.run
+      expect(history.board_size).to eq(board.size)
+    end
+
+    it "takes turns until the game is over" do
+      allow(rules).to receive(:game_over?).and_return(false, true)
+
+      expect(runner).to receive(:take_turn).once
+      runner.run
+    end
+
+    it "ends the game when the game is over" do
+      expect(runner).to receive(:end_game)
+      runner.run
+    end
+  end
+
+
+  describe '#take_turn' do
+    move = ["X", 0]
+    let(:board) { double("board") }
+    let(:first_player) { double("first player", make_move: move, needs_to_think: true) }
+    let(:second_player) { double("second player", make_move: move, needs_to_think: false) }
+    let(:players) { [first_player, second_player] }
+
+    it "draws the board" do
+      expect(io_interface).to receive(:draw_board)
+      runner.take_turn(board, players)
+    end
+
+    it "displays a thinking notification if the current player needs to think" do
+      expect(io_interface).to receive(:thinking_notification)
+      runner.take_turn(board, players)
+
+      expect(io_interface).not_to receive(:thinking_notification)
+      runner.take_turn(board, players)
+    end
+
+    it "asks the first player to make a move" do
+      expect(first_player).to receive(:make_move)
+      runner.take_turn(board, players)
+    end
+
+    it "has its history object record the move" do
+      runner.take_turn(board, players)
+      expect(history.moves.first).to eql(move)
+    end
+
+    it "keeps track of the current player by rotating the players" do
+      runner.take_turn(board, players)
+      expect(second_player).to receive(:make_move)
+      runner.take_turn(board, players)
+    end
+  end
+
+
+  describe '#end_game' do
+    let(:board) { double("board") }
+    let(:players) { double("players") }
+
+    it "draws the board" do
+      expect(io_interface).to receive(:draw_board)
+      runner.end_game(board, players)
+    end
+
+    it "determines the winner" do
+      expect(rules).to receive(:determine_winner)
+      runner.end_game(board, players)
+    end
+
+    it "displays the winner" do
+      allow(rules).to receive(:determine_winner) { :winner }
+
+      expect(io_interface).to receive(:game_over_notification).with(:winner)
+      runner.end_game(board, players)
+    end
+
+    it "has its history object record the winner" do
+      runner.end_game(board, players)
+      expect(history.winner).to eq("X")
+    end
+
+    it "has its history object persist the game history" do
+      expect(history).to receive(:persist)
+      runner.end_game(board, players)
+    end
+  end
+end

data/spec/database/pg_wrapper_spec.rb

@@ -0,0 +1,56 @@
+require 'database/pg_wrapper'
+require 'pg'
+require 'tic_tac_toes/history'
+require 'tic_tac_toes/spec_helper'
+
+describe Database::PGWrapper do
+  database = "test"
+  let(:pg_wrapper) { Database::PGWrapper.new(database) }
+  let(:history1)   { double("history 1",
+                     :board_size => 9,
+                     :moves => [["X", 1], ["O", 4]],
+                     :winner => "X") }
+  let(:history2)   { double("history 2",
+                     :board_size => 16,
+                     :moves => [["&", 14]],
+                     :winner => "*") }
+
+  before do
+    connection = PG.connect(dbname: database)
+    connection.exec("CREATE TABLE games (
+      id serial primary key,
+      board_size integer,
+      winner varchar)")
+    connection.exec("CREATE TABLE moves (
+      game integer REFERENCES games (id),
+      number integer,
+      token varchar,
+      space integer)")
+  end
+
+  describe '#record_game_history and #read_games' do
+    it "records and reads a history object to and from the database" do
+      pg_wrapper.record_game_history(history1)
+
+      history_from_database = pg_wrapper.read_game_histories.first
+
+      expect(history_from_database.board_size).to eq(9)
+      expect(history_from_database.moves[0]).to eq(["X", 1])
+      expect(history_from_database.moves[1]).to eq(["O", 4])
+      expect(history_from_database.winner).to eq("X")
+    end
+
+    it "records and reads multiple history objects to and from the database" do
+      pg_wrapper.record_game_history(history1)
+      pg_wrapper.record_game_history(history2)
+      histories_from_database = pg_wrapper.read_game_histories
+      expect(histories_from_database).to have(2).histories
+    end
+  end
+
+  after do
+    connection = PG.connect(dbname: database)
+    connection.exec("DROP TABLE moves")
+    connection.exec("DROP TABLE games")
+  end
+end

data/spec/tic_tac_toes/board_spec.rb

@@ -0,0 +1,104 @@
+require 'tic_tac_toes/spec_helper'
+require 'tic_tac_toes/board'
+
+describe TicTacToes::Board do
+  describe '#place (and #space)' do
+    let(:board) { TicTacToes::Board.new(row_size: 3) }
+
+    it "returns nil if the space is not nil" do
+      first_token, second_token = :X, :O
+      space = 0
+
+      board.place(first_token, space)
+      expect(board.place(second_token, space)).to be_nil
+    end
+
+    it "returns nil if it isn't in the board's spaces range" do
+      expect(board.place(:X, 9)).to be_nil
+    end
+
+    it "places a token at a space if the space is nil and in the board's spaces range" do
+      token, valid_space = :X, 0
+
+      board.place(token, valid_space)
+      expect(board.space(valid_space)).to eql(token)
+    end
+  end
+
+
+  describe '#open_spaces' do
+    it "returns an array of the board's nil spaces" do
+      structure = [:X, :O, nil,
+                   :O, :O,  :X,
+                   :X, :X, nil]
+      board = generate_board(structure)
+      open_spaces = [2, 8]
+
+      expect(board.open_spaces).to eql(open_spaces)
+    end
+  end
+
+
+  describe '#rows' do
+    it "returns an array of row arrays based on the board's spaces" do
+      structure = [ :X,  :X,  :X,  :X,
+                   nil, nil, nil, nil,
+                   nil, nil, nil, nil,
+                   nil, nil, nil, nil]
+      board = generate_board(structure)
+      first_row = [:X, :X, :X, :X]
+
+      expect(board.rows).to have(4).rows
+      expect(board.rows.first).to eql(first_row)
+    end
+  end
+
+
+  describe '#columns' do
+    it "returns an array of column arrays based on the board's spaces" do
+      structure = [:X, nil, nil, nil,
+                   :X, nil, nil, nil,
+                   :X, nil, nil, nil,
+                   :X, nil, nil, nil]
+      board = generate_board(structure)
+      first_column = [:X, :X, :X, :X]
+
+      expect(board.columns).to have(4).columns
+      expect(board.columns.first).to eql(first_column)
+    end
+  end
+
+
+  describe '#diagonals' do
+    it "returns an array of diagonal arrays based on the board's spaces" do
+      structure = [ :X, nil, nil,  :O,
+                   nil,  :X,  :O, nil,
+                   nil,  :O,  :X, nil,
+                    :O, nil, nil,  :X]
+      board = generate_board(structure)
+      back_diagonal = [:X, :X, :X, :X]
+      front_diagonal = [:O, :O, :O, :O]
+
+      expect(board.diagonals).to have(2).diagonals
+      expect(board.diagonals.first).to eql(back_diagonal)
+      expect(board.diagonals.last).to eql(front_diagonal)
+    end
+  end
+
+
+  describe '#full?' do
+    it "returns false if any spaces are still nil" do
+      board = TicTacToes::Board.new
+      expect(board.full?).to be false
+    end
+
+    it "returns true if all spaces are non-nil" do
+      structure = [:X, :O, :X,
+                   :O, :X, :O,
+                   :X, :O, :X]
+      board = generate_board(structure)
+
+      expect(board.full?).to be true
+    end
+  end
+end

data/spec/tic_tac_toes/easy_ai_spec.rb

@@ -0,0 +1,20 @@
+require 'tic_tac_toes/spec_helper'
+require 'tic_tac_toes/easy_ai'
+
+describe TicTacToes::EasyAI do
+  describe '#make_move' do
+    let(:players) { double("players") }
+    let(:ai) { TicTacToes::EasyAI }
+
+    it "returns a randomly-selected valid move" do
+      structure = [ :O, nil, nil,
+                   nil,  :X, nil,
+                   nil,  :X, nil]
+      board = generate_board(structure)
+      valid_moves = [1, 2, 3, 5, 6, 8]
+
+      move = ai.make_move(board, players)
+      expect(valid_moves).to include(move)
+    end
+  end
+end

data/spec/tic_tac_toes/hard_ai_spec.rb

@@ -0,0 +1,103 @@
+require 'tic_tac_toes/hard_ai'
+require 'tic_tac_toes/player'
+require 'tic_tac_toes/spec_helper'
+
+describe TicTacToes::HardAI do
+  let(:ai) { TicTacToes::HardAI }
+  let(:x) { TicTacToes::Player.new("decider", "x", false, "interface") }
+  let(:o) { TicTacToes::Player.new(ai, "o", true, "interface") }
+  let(:players) { [o, x] }
+
+
+  describe '#make_move' do
+    it "returns the best move" do
+      structure = [x, nil, nil,
+                   o,   o, nil,
+                   x, nil,   x]
+      board = generate_board(structure)
+      best_move = 5
+
+      expect(ai.make_move(board, players)).to eql(best_move)
+    end
+  end
+
+
+  describe '#minimax' do
+    it "returns the correct score for a pre-win board" do
+      structure = [x, nil, nil,
+                   o,   o, nil,
+                   x, nil,   x]
+      board = generate_board(structure)
+      win_score = 1
+
+      expect(ai.minimax(board, :max, players)).to eql(win_score)
+    end
+
+    it "returns the correct score for a pre-loss board" do
+      structure = [  o,   o,   x,
+                   nil, nil, nil,
+                     x, nil,   x]
+      board = generate_board(structure)
+      loss_score = -1
+
+      expect(ai.minimax(board, :max, players)).to eql(loss_score)
+    end
+
+    it "returns the correct score for a pre-draw board" do
+      structure = [x,   x, o,
+                   o, nil, x,
+                   x,   o, x]
+      board = generate_board(structure)
+      draw_score = 0
+
+      expect(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
+      structure = [  x, nil, nil,
+                   nil,   o, nil,
+                     x, nil, nil]
+      board = generate_board(structure)
+
+      new_board = 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
+      structure = [  o, nil, nil,
+                   nil,   o, nil,
+                   nil, nil,   o]
+      board = generate_board(structure)
+      win_score = 1
+
+      expect(ai.score(board, players)).to eql(win_score)
+    end
+
+    it "returns the correct score when no one has won" do
+      structure = [o, o, x,
+                   x, x, o,
+                   o, x, o]
+      board = generate_board(structure)
+      draw_score = 0
+
+      expect(ai.score(board, players)).to eql(draw_score)
+    end
+
+    it "returns the correct score when the opponent has won" do
+      structure = [  x, nil, nil,
+                   nil,   x, nil,
+                   nil, nil,   x]
+      board = generate_board(structure)
+      loss_score = -1
+
+      expect(ai.score(board, players)).to eql(loss_score)
+    end
+  end
+end

data/spec/tic_tac_toes/history_spec.rb

@@ -0,0 +1,41 @@
+require 'tic_tac_toes/spec_helper'
+require 'tic_tac_toes/history'
+
+describe TicTacToes::History do
+  let(:database_interface) { double("database interface", :record_game_history => true) }
+  let(:history) { TicTacToes::History.new(database_interface) }
+
+  describe '#record_board_size' do
+    it "records the passed board size" do
+      board_size = 9
+
+      history.record_board_size(board_size)
+      expect(history.board_size).to eq(board_size)
+    end
+  end
+
+  describe '#record_move' do
+    it "records the passed token and space" do
+      move = ["X", 0]
+
+      history.record_move(move)
+      expect(history.moves.first).to eql(move)
+    end
+  end
+
+  describe '#record_winner' do
+    it "records the passed winner" do
+      token = "O"
+
+      history.record_winner(token)
+      expect(history.winner).to eq(token)
+    end
+  end
+
+  describe '#persist' do
+    it "sends the history instance to its database interface for storage" do
+      expect(database_interface).to receive(:record_game_history).with history
+      history.persist
+    end
+  end
+end