ttt-core 1.0.0

data/spec/ai_player_spec.rb

@@ -0,0 +1,143 @@
+require 'ai_player'
+require 'board'
+
+RSpec.describe AiPlayer do
+  let(:ai_player) { AiPlayer.new(PlayerSymbols::X) }
+
+  it "has a player symbol" do
+    expect(ai_player.game_symbol).to eq(PlayerSymbols::X)
+  end
+
+  it "has ready state" do
+    expect(ai_player.ready?).to be true
+  end
+
+  it "scores zero when a draw is made" do
+    draw_board = Board.new([PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::X, PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::O, PlayerSymbols::O, PlayerSymbols::X, PlayerSymbols::X])
+    expect(ai_player.minimax(draw_board, true, draw_board.vacant_indices.size, -2, 2).first.first).to be (0 + draw_board.vacant_indices.size)
+  end
+
+  it "scores one if computer wins" do
+    winning_board = Board.new([PlayerSymbols::X, PlayerSymbols::X, PlayerSymbols::X, nil, nil, PlayerSymbols::O, PlayerSymbols::O, nil, nil])
+
+    expect(ai_player.minimax(winning_board, true, winning_board.vacant_indices.size, -2, 2).first.first).to be(1 + winning_board.vacant_indices.size)
+  end
+
+  it "scores negative one if opponent wins" do
+    winning_board = Board.new([PlayerSymbols::O, PlayerSymbols::O, PlayerSymbols::O, nil, nil, PlayerSymbols::X, PlayerSymbols::X, nil, nil])
+
+    expect(ai_player.minimax(winning_board, true, winning_board.vacant_indices.size, -2, 2).first.first).to be(-1 - winning_board.vacant_indices.size)
+  end
+
+  it "takes a winning move on top row" do
+    winning_move_on_top_row = Board.new([PlayerSymbols::X, nil, PlayerSymbols::X, nil, nil, PlayerSymbols::O, PlayerSymbols::O, nil, nil])
+
+    move = ai_player.choose_move(winning_move_on_top_row)
+    expect(move).to eq(1)
+  end
+
+  it "takes a winning move on middle row" do
+    winning_move_on_middle_row = Board.new([PlayerSymbols::O, nil, nil, PlayerSymbols::X, nil, PlayerSymbols::X, PlayerSymbols::O, nil, PlayerSymbols::O])
+
+    move = ai_player.choose_move(winning_move_on_middle_row)
+    expect(move).to eq(4)
+  end
+
+  it "takes a winning move on bottom row" do
+    winning_move_on_bottom_row = Board.new([PlayerSymbols::O, nil, PlayerSymbols::O, PlayerSymbols::O, nil, PlayerSymbols::X, nil, PlayerSymbols::X, PlayerSymbols::X])
+
+    move = ai_player.choose_move(winning_move_on_bottom_row)
+    expect(move).to eq(6)
+  end
+
+  it "takes a winning move on left column" do
+    winning_move_on_left_column = Board.new([PlayerSymbols::X, PlayerSymbols::O, nil, nil, nil, nil,  PlayerSymbols::X, nil, PlayerSymbols::O])
+
+    move = ai_player.choose_move(winning_move_on_left_column)
+    expect(move).to eq(3)
+  end
+
+  it "takes a winning move on middle column" do
+    winning_move_on_middle_column = Board.new([nil, PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::O, PlayerSymbols::X, nil, nil, nil, nil])
+
+    move = ai_player.choose_move(winning_move_on_middle_column)
+    expect(move).to eq(7)
+  end
+
+  it "takes a winning move on right column" do
+    winning_move_on_right_column = Board.new([nil, PlayerSymbols::O, PlayerSymbols::X, nil, PlayerSymbols::O, nil, nil, nil, PlayerSymbols::X])
+
+    move = ai_player.choose_move(winning_move_on_right_column)
+    expect(move).to eq(5)
+  end
+
+  it "takes a winning move on first diagonal" do
+    winning_move_on_first_diagonal = Board.new([PlayerSymbols::X, nil, PlayerSymbols::O, nil, nil, PlayerSymbols::O, nil, nil, PlayerSymbols::X])
+
+    move = ai_player.choose_move(winning_move_on_first_diagonal)
+    expect(move).to eq(4)
+  end
+
+  it "takes a winning move on second diagonal" do
+    winning_move_on_second_diagonal = Board.new([PlayerSymbols::O, nil, nil, nil, PlayerSymbols::X, nil, PlayerSymbols::X, PlayerSymbols::O, nil])
+
+    move = ai_player.choose_move(winning_move_on_second_diagonal)
+    expect(move).to eq(2)
+  end
+
+  it "takes a blocking move on top row" do
+    blocking_move_on_top_row = Board.new([PlayerSymbols::O, nil, PlayerSymbols::O, PlayerSymbols::X, nil, nil, nil, nil, PlayerSymbols::X])
+
+    move = ai_player.choose_move(blocking_move_on_top_row)
+    expect(move).to eq(1)
+  end
+
+  it "takes a blocking move on middle row" do
+    blocking_move_on_middle_row = Board.new([PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::O, nil, nil, PlayerSymbols::X, nil])
+
+    move = ai_player.choose_move(blocking_move_on_middle_row)
+    expect(move).to eq(5)
+  end
+
+  it "takes a blocking move on bottom row" do
+    blocking_move_on_bottom_row = Board.new([PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::X, nil, nil, PlayerSymbols::X, nil, PlayerSymbols::O, PlayerSymbols::O])
+
+    move = ai_player.choose_move(blocking_move_on_bottom_row)
+    expect(move).to eq(6)
+  end
+
+  it "takes a blocking move on left column" do
+    blocking_move_on_left_column = Board.new([PlayerSymbols::O, nil, nil, nil, nil, PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::X, nil])
+
+    move = ai_player.choose_move(blocking_move_on_left_column)
+    expect(move).to eq(3)
+  end
+
+  it "takes a blocking move on middle column" do
+    blocking_move_on_middle_column = Board.new([nil, PlayerSymbols::O, nil, PlayerSymbols::X,nil, nil, nil, PlayerSymbols::O, nil])
+
+    move = ai_player.choose_move(blocking_move_on_middle_column)
+    expect(move).to eq(4)
+  end
+
+  it "takes a blocking move on right column" do
+    blocking_move_on_right_column = Board.new([nil, nil, PlayerSymbols::O, nil, nil, PlayerSymbols::O, nil, PlayerSymbols::X, nil])
+
+    move = ai_player.choose_move(blocking_move_on_right_column)
+    expect(move).to eq(8)
+  end
+
+ it "takes a blocking move on first diagonal" do
+    blocking_move_on_first_diagonal = Board.new([PlayerSymbols::O, PlayerSymbols::X, nil, nil,nil, nil, nil, nil, PlayerSymbols::O])
+
+    move = ai_player.choose_move(blocking_move_on_first_diagonal)
+    expect(move).to eq(4)
+  end
+
+ it "takes a blocking move on second diagonal" do
+    blocking_move_on_second_diagonal = Board.new([nil, nil, PlayerSymbols::O, nil, nil, nil, PlayerSymbols::O, PlayerSymbols::X, nil])
+
+    move = ai_player.choose_move(blocking_move_on_second_diagonal)
+    expect(move).to eq(4)
+  end
+end

data/spec/board_factory_spec.rb

@@ -0,0 +1,10 @@
+require 'board_factory'
+
+RSpec.describe BoardFactory do
+  let(:board_factory) { BoardFactory.new }
+
+  it "creates 3x3 board " do
+    board = board_factory.create_board
+    expect(board.grid_for_display.size).to be 3
+  end
+end

data/spec/board_spec.rb

@@ -0,0 +1,125 @@
+require 'board'
+require 'player_symbols'
+
+RSpec.describe Board do
+  X = PlayerSymbols::X
+  O = PlayerSymbols::O
+
+  let (:board) {Board.new}
+
+  it "is empty on initialisation" do
+    expect(board.empty?).to be true
+  end
+
+  it "is not empty when all slots are occupied" do
+    full_board = Board.new([X, O, X, O, X, O, X, X, O])
+    expect(full_board.empty?).to be false
+  end
+
+  it "returns the current grid formation" do
+    board = Board.new([nil, nil, nil, nil, X, O, nil, nil, nil])
+    expect(board.grid_for_display).to eq([[nil, nil, nil], [nil, X, O], [nil, nil, nil]])
+  end
+
+  it "can get symbol at given position" do
+    board = Board.new([nil, nil, nil, nil, X, O, nil, nil, nil])
+    expect(board.get_symbol_at(4)).to be :X
+  end
+
+  it "can be updated at a given position" do
+    updated_board = board.make_move(1, X)
+    expect(updated_board.get_symbol_at(1)).to eq(X)
+  end
+
+  it "has free spaces" do
+    expect(board.free_spaces?).to be true
+  end
+
+  it "has no free spaces when all slots are occupied" do
+    full_board = Board.new([X, O, X, O, X, O, X, X, O])
+    expect(full_board.free_spaces?).to be false
+  end
+
+  it "has no winning combination" do
+    winning_board = Board.new([O, X, X, nil, nil, nil, nil, nil, nil])
+    expect(winning_board.winning_combination?).to be false
+  end
+
+  it "has winning combination of X in top row" do
+    winning_board = Board.new([X, X, X, nil, nil, nil, nil, nil, nil])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of X in middle row" do
+    winning_board = Board.new([nil, nil, nil, X, X, X, nil, nil, nil])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of X in bottom row" do
+    winning_board = Board.new([nil, nil, nil, nil, nil, nil, X, X, X])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of X in left column" do
+    winning_board = Board.new([X, nil, nil, X, nil, nil, X, nil, nil])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of X in middle column" do
+    winning_board = Board.new([nil, X, nil, nil, X, nil, nil, X, nil])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of X in right column" do
+    winning_board = Board.new([nil, nil, X, nil, nil, X, nil, nil, X])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of X in first diagonal" do
+    winning_board = Board.new([X, nil, nil, nil, X, nil, nil, nil, X])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of X in second diagonal" do
+    winning_board = Board.new([nil, nil, X, nil, X, nil, X, nil, nil])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of O in top row" do
+    winning_board = Board.new([O, O, O, nil, nil, nil, nil, nil, nil])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of O in left column" do
+    winning_board = Board.new([O, nil, nil, O, nil, nil, O, nil, nil])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning combination of O in first diagonal" do
+    winning_board = Board.new([O, nil, nil, nil, O, nil, nil, nil, O])
+    expect(winning_board.winning_combination?).to be true
+  end
+
+  it "has winning symbol X" do
+    winning_board = Board.new([X, X, X, nil, nil, nil, nil, nil, nil])
+    expect(winning_board.winning_symbol).to be X
+  end
+
+  it "has winning symbol O" do
+    winning_board = Board.new([O, O, O, nil, nil, nil, nil, nil, nil])
+    expect(winning_board.winning_symbol).to be O
+  end
+
+  it "has no winning symbol" do
+    expect(board.winning_symbol).to be nil
+  end
+
+  it "gives all vacant indices on an empty board" do
+    expect(board.vacant_indices).to include(0, 1, 2, 3, 4, 5, 6, 7, 8)
+  end
+
+  it "gives all vacant indices on a board with moves" do
+    board = Board.new([X, nil, O, nil, nil, nil, nil, nil, nil])
+    expect(board.vacant_indices).not_to include(0, 2)
+  end
+end

data/spec/game_spec.rb

@@ -0,0 +1,58 @@
+require 'board'
+require 'game'
+require 'player'
+require 'player_symbols'
+
+RSpec.describe Game do
+  let(:player_x_spy) { instance_double(FakePlayer).as_null_object }
+  let(:player_o_spy) { instance_double(FakePlayer).as_null_object }
+
+  it "continues until player is not ready" do
+    allow(player_x_spy).to receive(:ready?).and_return(true, false)
+    allow(player_o_spy).to receive(:ready?).and_return(true)
+
+    expect(player_x_spy).to receive(:choose_move).exactly(1).times.and_return(2)
+    expect(player_o_spy).to receive(:choose_move).exactly(1).times.and_return(8)
+
+    Game.new(Board.new, [player_x_spy, player_o_spy]).play
+  end
+
+  it "players take turn until there is no space on board" do
+    expect(player_x_spy).to receive(:choose_move).exactly(5).times.and_return(0, 1, 4, 5, 6)
+    expect(player_o_spy).to receive(:choose_move).exactly(4).times.and_return(2, 3, 7, 8)
+
+    Game.new(Board.new, [player_x_spy, player_o_spy]).play
+
+  end
+
+  it "game ends when a winning combination is formed" do
+    allow(player_x_spy).to receive(:choose_move).once.and_return(2)
+    allow(player_x_spy).to receive(:game_symbol).and_return(PlayerSymbols::X)
+
+    board = Board.new([PlayerSymbols::X, PlayerSymbols::X, nil, PlayerSymbols::O, nil, nil, nil, nil, nil])
+    updated_board = Game.new(board, [player_x_spy, player_o_spy]).play
+
+    expect(updated_board.get_symbol_at(2)).to be (PlayerSymbols::X)
+    expect(player_o_spy).to_not have_received(:choose_move)
+  end
+
+  it "game ends when there are no free spaces on the board" do
+    full_board = Board.new([PlayerSymbols::X, PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::O, PlayerSymbols::O, PlayerSymbols::X, PlayerSymbols::X, PlayerSymbols::O, PlayerSymbols::X])
+    game = Game.new(full_board, [player_x_spy, player_o_spy]).play
+
+    expect(player_o_spy).to_not have_received(:choose_move)
+    expect(player_x_spy).to_not have_received(:choose_move)
+  end
+end
+
+class FakePlayer
+
+  include Player
+
+  def choose_move(board)
+  end
+
+  def ready?
+  end
+end
+

data/spec/player_options_spec.rb

@@ -0,0 +1,33 @@
+require 'player_options'
+
+RSpec.describe PlayerOptions do
+
+  it "has player option Human vs Human" do
+    expect(PlayerOptions::HUMAN_VS_HUMAN).to eq ("Human vs Human")
+  end
+
+  it "has player option Human vs Ai" do
+    expect(PlayerOptions::HUMAN_VS_AI).to eq ("Human vs Ai")
+  end
+
+  it "has player option Ai vs Human" do
+    expect(PlayerOptions::AI_VS_HUMAN).to eq ("Ai vs Human")
+  end
+
+  it "has valid player option ids" do
+    expect(PlayerOptions::valid_ids).to eq ([1, 2, 3])
+  end
+
+  it "gets player type for id" do
+    expect(PlayerOptions::get_player_type_for_id(1)).to eq (PlayerOptions::HUMAN_VS_HUMAN)
+  end
+
+  it "gets player options for display" do
+ expect(PlayerOptions::display_player_options).to eq("(1) Human vs Human, (2) Human vs Ai, (3) Ai vs Human" )
+  end
+
+  it "gets all player options" do
+    all_expected_types = { 1 => "Human vs Human", 2=> "Human vs Ai", 3 => "Ai vs Human" }
+    expect(PlayerOptions::all).to eq(all_expected_types)
+  end
+end

data/spec/player_symbols_spec.rb

@@ -0,0 +1,32 @@
+require 'player_symbols'
+
+RSpec.describe PlayerSymbols do
+
+  it "has player symbol X" do
+    expect(PlayerSymbols::X).to be :X
+  end
+
+  it "has player symbol O" do
+    expect(PlayerSymbols::O).to be :O
+  end
+
+  it "finds opponent of X" do
+    expect(PlayerSymbols::opponent(PlayerSymbols::X)).to be :O
+  end
+
+  it "finds opponent of O" do
+    expect(PlayerSymbols::opponent(PlayerSymbols::O)).to be :X
+  end
+
+  it "all player symbols as strings" do
+    expect(PlayerSymbols::all).to eq ["X", "O"]
+  end
+
+  it "converts X to player symbol" do
+    expect(PlayerSymbols::to_symbol("X")).to eq :X
+  end
+
+  it "converts O to player symbol" do
+    expect(PlayerSymbols::to_symbol("O")).to eq :O
+  end
+end

data/spec/replay_option_spec.rb

@@ -0,0 +1,8 @@
+require 'replay_option'
+
+RSpec.describe ReplayOption do
+
+  it "has replay option of Y" do
+    expect(ReplayOption::Y.include?("Y")).to be true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,107 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'simplecov'
+require 'coveralls'
+
+Coveralls.wear!
+SimpleCov.minimum_coverage 100
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
+    SimpleCov::Formatter::HTMLFormatter,
+      Coveralls::SimpleCov::Formatter
+])
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+    mocks.verify_doubled_constant_names = true
+  end
+
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/ttt-core-0.0.1/.gitignore

@@ -0,0 +1,36 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+.coveralls.yml
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/ttt-core-0.0.1/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/ttt-core-0.0.1/.ruby-gemset

@@ -0,0 +1 @@
+ttt

data/ttt-core-0.0.1/.ruby-version

@@ -0,0 +1 @@
+2.2.1

data/ttt-core-0.0.1/.travis.yml

@@ -0,0 +1,2 @@
+language: ruby
+

data/ttt-core-0.0.1/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+gem 'pry'
+gem 'pry-byebug'
+
+group :test do
+    gem 'rake'
+    gem 'simplecov'
+    gem 'coveralls', :require => false
+    gem 'rspec', :require => 'spec'
+end

data/ttt-core-0.0.1/README.md

@@ -0,0 +1,21 @@
+# Apprenticeship-RubyTicTacToe
+
+Tic Tac Toe game implemented in Ruby  
+
+[![Master Build Status](https://travis-ci.org/gemcfadyen/Apprenticeship-RubyTicTacToe.svg?branch=master)](https://travis-ci.org/gemcfadyen/Apprenticeship-RubyTicTacToe)   [![Master Coverage Status](https://coveralls.io/repos/gemcfadyen/Apprenticeship-RubyTicTacToe/badge.svg?branch=master&service=github)](https://coveralls.io/github/gemcfadyen/Apprenticeship-RubyTicTacToe?branch=master)
+
+To run the application clone the project into a folder 
+
+>> git clone git@github.com:gemcfadyen/Apprenticeship-RubyTicTacToe.git
+
+
+From this folder run the command
+
+>> bin/run.sh
+
+The game will then start. To make a move, enter a number via the commandline when prompted. If the move is not valid, you will be reprompted until a valid move is given.
+
+Once the game is over, the winner will be announced, or the game will be a draw. 
+
+You can replay by entering Y or y when prompted.
+

data/ttt-core-0.0.1/Rakefile

@@ -0,0 +1,7 @@
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError
+end
+
+task :default => :spec

data/ttt-core-0.0.1/bin/run.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+##Setup Load Path
+$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+
+require 'command_line_app'
+require 'command_line_ui'
+require 'board_factory'
+require 'command_line_player_factory'
+require 'prompt_writer'
+require 'prompt_reader'
+
+writer = PromptWriter.new($stdout)
+reader = PromptReader.new($stdin)
+command_line_ui = CommandLineUI.new(writer, reader)
+
+board_factory = BoardFactory.new
+player_factory = CommandLinePlayerFactory.new
+
+command_line_app = CommandLineApp.new(command_line_ui, board_factory, player_factory)
+command_line_app.start