tic_tac_toes 0.0.1

data/spec/tic_tac_toes/io_interface_spec.rb

@@ -0,0 +1,175 @@
+require 'tic_tac_toes/board'
+require 'tic_tac_toes/io_interface'
+require 'tic_tac_toes/spec_helper'
+require 'tic_tac_toes/strings'
+
+describe TicTacToes::IOInterface do
+  let(:strings) { TicTacToes::Strings }
+  let(:io) { double("io", solicit_input: 0, display: true, display_red: true) }
+  let(:io_interface) { TicTacToes::IOInterface.new(io) }
+
+
+  describe '#make_move' do
+    it "displays a move solicitation" do
+      expect(io_interface).to receive(:move_solicitation)
+      io_interface.make_move("_board", "_players")
+    end
+
+    context 'when given not-integer-like input' do
+      let(:not_integer_like) { "string" }
+      let(:integer_like) { "100" }
+
+      it "displays a not an integer error" do
+        allow(io).to receive(:solicit_input).and_return(not_integer_like, integer_like)
+
+        expect(io_interface).to receive(:not_an_integer_error).once
+        io_interface.make_move("_board", "_players")
+      end
+
+      it "only returns a move (converted to integer) once it gets integer-like input" do
+        allow(io).to receive(:solicit_input).and_return(not_integer_like, integer_like)
+
+        expect(io_interface.make_move("_board", "_players")).to eq(100)
+      end
+    end
+  end
+
+
+  describe '#get_row_size' do
+    it "displays a row size solicitation" do
+      expect(io_interface).to receive(:row_size_solicitation)
+      io_interface.get_row_size
+    end
+
+    context 'when given not-integer-like input' do
+      let(:not_integer_like) { "string" }
+      let(:integer_like) { "100" }
+
+      it "displays a not an integer error" do
+        allow(io).to receive(:solicit_input).and_return(not_integer_like, integer_like)
+
+        expect(io_interface).to receive(:not_an_integer_error).once
+        io_interface.get_row_size
+      end
+
+      it "only returns a row size (converted to integer) once it gets integer-like input" do
+        allow(io).to receive(:solicit_input).and_return(not_integer_like, integer_like)
+
+        expect(io_interface.get_row_size).to eq(100)
+      end
+    end
+  end
+
+
+  describe '#get_token' do
+    let(:player) { double("player") }
+
+    it "displays a token solicitation with the name of the player whose token is to be set" do
+      expect(io_interface).to receive(:token_solicitation).with(player)
+      io_interface.get_token(player)
+    end
+
+    it "returns the user input" do
+      token = "X"
+      allow(io).to receive(:solicit_input) { token }
+
+      expect(io_interface.get_token(player)).to equal(token)
+    end
+  end
+
+
+  describe '#get_difficulty' do
+    let(:difficulty) { "HARD" }
+
+    it "displays a difficulty solicitation" do
+      allow(io).to receive(:solicit_input) { difficulty }
+
+      expect(io_interface).to receive(:difficulty_solicitation)
+      io_interface.get_difficulty
+    end
+
+    it "returns the user input (downcased and converted into a symbol)" do
+      allow(io).to receive(:solicit_input) { difficulty }
+
+      expect(io_interface.get_difficulty).to equal(:hard)
+    end
+  end
+
+
+  describe '#draw_board' do
+    it "displays a board string" do
+      board = TicTacToes::Board.new
+      board_string = strings.board(board)
+
+      expect(io).to receive(:display).with(board_string)
+      io_interface.draw_board(board)
+    end
+  end
+
+
+  describe '#invalid_row_size_error' do
+    it "displays a red invalid row size message" do
+      expect(io).to receive(:display_red).with(strings::INVALID_ROW_SIZE)
+      io_interface.invalid_row_size_error
+    end
+  end
+
+
+  describe '#invalid_token_error' do
+    it "displays a red invalid token message" do
+      expect(io).to receive(:display_red).with(strings::INVALID_TOKEN)
+      io_interface.invalid_token_error
+    end
+  end
+
+
+  describe '#invalid_difficulty_error' do
+    it "displays a red invalid difficulty message" do
+      expect(io).to receive(:display_red).with(strings::INVALID_DIFFICULTY)
+      io_interface.invalid_difficulty_error
+    end
+  end
+
+
+  describe '#invalid_move_error' do
+    it "displays a red invalid move message" do
+      expect(io).to receive(:display_red).with(strings::INVALID_MOVE)
+      io_interface.invalid_move_error
+    end
+  end
+
+
+  describe '#thinking_notification' do
+    it "displays a red thinking message" do
+      expect(io).to receive(:display_red).with(strings::THINKING)
+      io_interface.thinking_notification
+    end
+  end
+
+
+  describe '#game_over_notification' do
+    it "displays a game over message with the name of the winner" do
+      winner = :X
+      game_over_message = strings.game_over_notification(winner)
+
+      expect(io).to receive(:display).with(game_over_message)
+      io_interface.game_over_notification(winner)
+    end
+  end
+
+
+  describe '#red' do
+    it "calls its IO's red method with the passed message" do
+      expect(io).to receive(:red).with("message")
+      io_interface.red("message")
+    end
+  end
+
+
+  describe '#blue' do
+    it "calls its IO's blue method with the passed message" do
+      expect(io).to receive(:blue).with("message")
+      io_interface.blue("message")
+    end
+  end
+end

data/spec/tic_tac_toes/medium_ai_spec.rb

@@ -0,0 +1,22 @@
+require 'tic_tac_toes/medium_ai'
+require 'tic_tac_toes/spec_helper'
+
+describe TicTacToes::MediumAI do
+  let(:ai) { TicTacToes::MediumAI }
+  let(:x) { TicTacToes::Player.new("decider", "x", false, "interface") }
+  let(:o) { TicTacToes::Player.new(ai, "o", true, "interface") }
+  let(:players) { [x, o] }
+
+  describe '#make_move' do
+    it "makes a valid move (based on either EasyAI or HardAI)" do
+      structure = [  o, o,   x,
+                   nil, x, nil,
+                   nil, x, nil]
+      board = generate_board(structure)
+      valid_moves = [3, 5, 6, 8]
+
+      move = ai.make_move(board, players)
+      expect(valid_moves).to include(move)
+    end
+  end
+end

data/spec/tic_tac_toes/player_factory_spec.rb

@@ -0,0 +1,34 @@
+require 'command_line/io'
+require 'tic_tac_toes/io_interface'
+require 'tic_tac_toes/medium_ai'
+require 'tic_tac_toes/player_factory'
+require 'tic_tac_toes/spec_helper'
+
+describe TicTacToes::PlayerFactory do
+  let(:io) { CommandLine::IO }
+  let(:io_interface) { TicTacToes::IOInterface.new(io) }
+  let(:player_factory) { TicTacToes::PlayerFactory.new(io_interface) }
+
+
+  describe '#generate_human_player' do
+    it "returns a player with the correct token and decider" do
+      token = "X"
+
+      human_player = player_factory.generate_human_player(token)
+      expect(human_player.decider).to be_a TicTacToes::IOInterface
+      expect(human_player.token).to eq(token)
+    end
+  end
+
+
+  describe '#generate_computer_player' do
+    it "returns a player with the correct token and decider when given a valid difficulty" do
+      token = "O"
+      difficulty = :medium
+
+      computer_player = player_factory.generate_computer_player(token, difficulty)
+      expect(computer_player.decider).to eql(TicTacToes::MediumAI)
+      expect(computer_player.token).to eq(token)
+    end
+  end
+end

data/spec/tic_tac_toes/player_spec.rb

@@ -0,0 +1,34 @@
+require 'tic_tac_toes/board'
+require 'tic_tac_toes/io_interface'
+require 'tic_tac_toes/player'
+require 'tic_tac_toes/spec_helper'
+
+describe TicTacToes::Player do
+  let(:board) { TicTacToes::Board.new(row_size: 3) }
+  let(:io_interface) { double("io_interface", invalid_move_error: true) }
+  let(:players) { double("players") }
+
+  describe '#make_move' do
+    let(:decider) { double("decider") }
+    let(:token) { "X" }
+    let(:needs_to_think) { false }
+
+    let(:player) { TicTacToes::Player.new(decider, token, needs_to_think, io_interface) }
+ 
+    it "only returns a move once it receives a valid move" do
+      invalid_space, valid_space = 9, 0
+      allow(decider).to receive(:make_move).and_return(invalid_space, valid_space)
+
+      player.make_move(board, players)
+      expect(board.space(valid_space)).to eq(player)
+    end
+
+    it "displays an invalid move error when given an invalid move" do
+      invalid_space, valid_space = 9, 0
+      allow(decider).to receive(:make_move).and_return(invalid_space, valid_space)
+
+      expect(io_interface).to receive(:invalid_move_error)
+      player.make_move(board, players)
+    end
+  end
+end

data/spec/tic_tac_toes/rules_spec.rb

@@ -0,0 +1,159 @@
+require 'tic_tac_toes/spec_helper'
+require 'tic_tac_toes/rules'
+
+describe TicTacToes::Rules do
+  let(:rules) { TicTacToes::Rules }
+  let(:x) { double("human player", token: "x") }
+  let(:o) { double("computer player", token: "o") }
+  let(:players) { [x, o] }
+
+  describe '#row_size_valid?' do
+    it "returns false if the row size is outside the range 2 to 10" do
+      invalid_row_size = 11
+
+      expect(rules.row_size_valid?(invalid_row_size)).to be false
+    end
+
+    it "returns true if the row size is in the range 2 to 10" do
+      valid_row_size = 10
+
+      expect(rules.row_size_valid?(valid_row_size)).to be true
+    end
+  end
+
+
+  describe '#token_valid?' do
+    it "returns false if the token is not a single character" do
+      long_token, taken_tokens = :long, []
+
+      expect(rules.token_valid?(long_token, taken_tokens)).to be false
+    end
+
+    it "returns false if the token is already taken" do
+      taken_token, taken_tokens = :X, [:X]
+
+      expect(rules.token_valid?(taken_token, taken_tokens)).to be false
+    end
+
+    it "returns true if the token is a single character and untaken" do
+      valid_token, taken_tokens = :O, [:X]
+
+      expect(rules.token_valid?(valid_token, taken_tokens)).to be true
+    end
+  end
+
+
+  describe '#difficulty_valid?' do
+    it "returns false if the difficulty is not a key in AI_DIFFICULTIES" do
+      invalid_difficulty = :invalid
+
+      expect(rules.difficulty_valid?(invalid_difficulty)).to be false
+    end
+
+    it "returns true if the difficulty is a key in AI_DIFFICULTIES" do
+      valid_difficulty = :medium
+
+      expect(rules.difficulty_valid?(valid_difficulty)).to be true
+    end
+  end
+
+
+  describe '#game_over?' do
+    it "returns false if there is not yet a winner and the board is not full" do
+      structure = [x, x,   o,
+                   o, o, nil,
+                   x, o,   x]
+      board = generate_board(structure)
+
+      expect(rules.game_over?(board, players)).to be false
+    end
+
+    it "returns true if any player has won" do
+      structure = [  x, nil, nil,
+                   nil,   x, nil,
+                   nil, nil,   x]
+      board = generate_board(structure)
+
+      expect(rules.game_over?(board, players)).to be true
+    end
+
+    it "returns true if the board is full" do
+      structure = [x, x, o,
+                   o, o, x,
+                   x, o, x]
+      board = generate_board(structure)
+
+      expect(rules.game_over?(board, players)).to be true
+    end
+  end
+
+
+  describe '#determine_winner' do
+    it "returns the winning token when there is a winner" do
+      structure = [  o, nil, nil,
+                   nil,   o, nil,
+                   nil, nil,   o]
+      board = generate_board(structure)
+      winning_token = "o"
+
+      expect(rules.determine_winner(board, players)).to eql(winning_token)
+    end
+
+    it "returns nil if there is not a winner" do
+      structure = [x, x,   o,
+                   o, o, nil,
+                   x, o,   x]
+      board = generate_board(structure)
+
+      expect(rules.determine_winner(board, players)).to be_nil
+    end
+  end
+
+
+  describe '#win?' do
+    it "returns false if the given token has not won" do
+      structure = [x, x,  o,
+                   o, o, nil,
+                   x, o,  x]
+      board = generate_board(structure)
+
+      expect(rules.win?(board, x)).to be false
+    end
+
+    it "returns true if the given token has achieved a back diagonal win" do
+      structure = [  x, nil, nil,
+                   nil,   x, nil,
+                   nil, nil,   x]
+      board = generate_board(structure)
+
+      expect(rules.win?(board, x)).to be true
+    end
+
+    it "returns true if the given token has achieved a front diagonal win" do
+      structure = [nil, nil,   x,
+                   nil,   x, nil,
+                     x, nil, nil]
+      board = generate_board(structure)
+
+      expect(rules.win?(board, x)).to be true
+    end
+
+    it "returns true if the given token has achieved a horizonatal win" do
+      structure = [nil, nil, nil,
+                     x,   x,   x,
+                   nil, nil, nil]
+      board = generate_board(structure)
+
+      expect(rules.win?(board, x)).to be true
+    end
+
+    it "returns true if the given token has achieved a vertical win" do
+      structure = [nil, x, nil,
+                   nil, x, nil,
+                   nil, x, nil]
+      board = generate_board(structure)
+
+      expect(rules.win?(board, x)).to be true
+    end
+  end
+end

data/spec/tic_tac_toes/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'tic_tac_toes/board'
+
+def generate_board(structure)
+  board_size = structure.count
+  row_size = Math.sqrt(board_size)
+  board = TicTacToes::Board.new(row_size: row_size)
+
+  structure.each_with_index do |player, index|
+    board.place(player, index)
+  end
+
+  board
+end

data/spec/tic_tac_toes/strings_spec.rb

@@ -0,0 +1,50 @@
+require 'tic_tac_toes/board'
+require 'tic_tac_toes/rules'
+require 'tic_tac_toes/spec_helper'
+require 'tic_tac_toes/strings'
+
+describe TicTacToes::Strings do
+  let(:strings) { TicTacToes::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
+
+      expect(strings::INVALID_ROW_SIZE).to include(smallest_row_size, largest_row_size)
+    end
+  end
+
+  describe '#token_solicitation' do
+    it "returns a string containing the name of the player whose token is being picked" do
+      player = "human"
+      expect(strings.token_solicitation(player)).to include(player)
+    end
+  end
+
+  describe '#game_over_notification' do
+    it "returns a string containing the name of the winner" do
+      winner = "X"
+      expect(strings.game_over_notification(winner)).to include(winner)
+    end
+  end
+
+  describe '#board' do
+    it "returns a board string" do
+      board = TicTacToes::Board.new(row_size: 3)
+
+      leading_spaces_regexp = /^[[:blank:]]+/
+      board_string = <<-END.gsub(leading_spaces_regexp, '')
+
+        [0]|[1]|[2]
+        -----------
+        [3]|[4]|[5]
+        -----------
+        [6]|[7]|[8]
+
+      END
+
+      expect(strings.board(board)).to eql(board_string)
+    end
+  end
+end

data/tic_tac_toes.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tic_tac_toes/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tic_tac_toes"
+  spec.version       = TicTacToes::VERSION
+  spec.authors       = ["Ben Spatafora"]
+  spec.email         = ["benjamin.spatafora@gmail.com"]
+  spec.summary       = %q{The game Tic-tac-toe, featuring an unbeatable AI}
+  spec.homepage      = "http://github.com/bspatafora/tic_tac_toes"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = ["tic_tac_toes"]
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_dependency "pg"
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: tic_tac_toes
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ben Spatafora
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- benjamin.spatafora@gmail.com
+executables:
+- tic_tac_toes
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/tic_tac_toes
+- lib/command_line/io.rb
+- lib/command_line/menu.rb
+- lib/command_line/runner.rb
+- lib/database/pg_wrapper.rb
+- lib/tic_tac_toes/board.rb
+- lib/tic_tac_toes/easy_ai.rb
+- lib/tic_tac_toes/hard_ai.rb
+- lib/tic_tac_toes/history.rb
+- lib/tic_tac_toes/io_interface.rb
+- lib/tic_tac_toes/medium_ai.rb
+- lib/tic_tac_toes/player.rb
+- lib/tic_tac_toes/player_factory.rb
+- lib/tic_tac_toes/rules.rb
+- lib/tic_tac_toes/strings.rb
+- lib/tic_tac_toes/version.rb
+- spec/command_line/menu_spec.rb
+- spec/command_line/runner_spec.rb
+- spec/database/pg_wrapper_spec.rb
+- spec/tic_tac_toes/board_spec.rb
+- spec/tic_tac_toes/easy_ai_spec.rb
+- spec/tic_tac_toes/hard_ai_spec.rb
+- spec/tic_tac_toes/history_spec.rb
+- spec/tic_tac_toes/io_interface_spec.rb
+- spec/tic_tac_toes/medium_ai_spec.rb
+- spec/tic_tac_toes/player_factory_spec.rb
+- spec/tic_tac_toes/player_spec.rb
+- spec/tic_tac_toes/rules_spec.rb
+- spec/tic_tac_toes/spec_helper.rb
+- spec/tic_tac_toes/strings_spec.rb
+- tic_tac_toes.gemspec
+homepage: http://github.com/bspatafora/tic_tac_toes
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: The game Tic-tac-toe, featuring an unbeatable AI
+test_files:
+- spec/command_line/menu_spec.rb
+- spec/command_line/runner_spec.rb
+- spec/database/pg_wrapper_spec.rb
+- spec/tic_tac_toes/board_spec.rb
+- spec/tic_tac_toes/easy_ai_spec.rb
+- spec/tic_tac_toes/hard_ai_spec.rb
+- spec/tic_tac_toes/history_spec.rb
+- spec/tic_tac_toes/io_interface_spec.rb
+- spec/tic_tac_toes/medium_ai_spec.rb
+- spec/tic_tac_toes/player_factory_spec.rb
+- spec/tic_tac_toes/player_spec.rb
+- spec/tic_tac_toes/rules_spec.rb
+- spec/tic_tac_toes/spec_helper.rb
+- spec/tic_tac_toes/strings_spec.rb