tic_tac_toes 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 77b92da0b3d048f306b6ac300f94e94fcd656ef7
-  data.tar.gz: 10497e3ed936e362e8ae20e1e85282b8990e92f7
+  metadata.gz: 973d4205866381b247cee7397ef538d46d26dbd3
+  data.tar.gz: 8383fa3bd6d89f0e1dc082bf15d58e22315c4d16
 SHA512:
-  metadata.gz: d33321f395dae4c693c0610a51b998d7b606bc00408ffe65cfcc305f8f06278f5bf09085ea1de4d7a4556fe80ad0a302a4c006c2a887f8b31db59dacb3ee4983
-  data.tar.gz: 5e7f86e90489fdc057a6804b77e85ed2ba067c189585d9d813051abbc2e5d5bae2dc34a270a2b9c3d477e8a92ed20fab08d82b17c36114434eb3e5917ee10473
+  metadata.gz: 38e1a5192560eb071120b41079ae56a77e442b5fefe60659537868e45eb76277f05ffd74b4510c1d707009c3a5a9bb22582bd30cd66a9fdc67ec6524d471a92f
+  data.tar.gz: 81602fbe1f20241e27b4400815bc4ee3fdbbb1bdaa9622de099134e4b043db4dd640bb6880258b072f7d8e16b0827dc9717904749ff8ae94ca5d4518cbfa0177

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    tic_tac_toes (0.1.4)
+    tic_tac_toes (0.1.6)
       pg
 
 GEM

data/bin/game_histories

@@ -4,10 +4,11 @@ $LOAD_PATH << File.expand_path(File.dirname(__FILE__) + '/../lib')
 
 require 'tic_tac_toes/database/pg_wrapper'
 require 'tic_tac_toes/command_line/history_reader'
+require 'tic_tac_toes/command_line/prompt'
 
 database = 'tic_tac_toes'
 
 wrapper = TicTacToes::Database::PGWrapper.new(database)
 reader = TicTacToes::CommandLine::HistoryReader.new(wrapper)
 
-reader.display_game_histories
+reader.game_history_strings.each { |history| TicTacToes::CommandLine::Prompt.display(history) }

data/lib/tic_tac_toes/core/game_state.rb

@@ -29,11 +29,19 @@ module TicTacToes
         @players[1]
       end
 
+      def computer_player
+        @players.detect { |player| player.move_strategy.type == MoveStrategies::COMPUTER }
+      end
+
       def turn_over(move)
         @history.record_move(move)
         @players.rotate!
       end
 
+      def moves
+        @history.moves
+      end
+
       def end_game(winner)
         @history.record_winner(winner)
         @history.persist
@@ -54,7 +62,6 @@ module TicTacToes
       end
 
       def record_difficulty
-        computer_player = @players.detect { |player| player.move_strategy.type == MoveStrategies::COMPUTER }
         @history.record_difficulty(computer_player.move_strategy)
       end
     end

data/lib/tic_tac_toes/core/history.rb

@@ -17,7 +17,7 @@ module TicTacToes
 
       def record_move(move)
         @moves ||= []
-        @moves << move
+        @moves << move unless move.nil?
       end
 
       def record_winner(winner)

data/lib/tic_tac_toes/core/io.rb

@@ -1,4 +1,4 @@
-require 'tic_tac_toes/core/strings'
+require 'tic_tac_toes/core/presenter'
 
 module TicTacToes
   module Core
@@ -27,41 +27,41 @@ module TicTacToes
       end
 
       def draw_board(board)
-        @io_strategy.display(Strings.board(board))
+        @io_strategy.display(Presenter.board(board))
       end
 
       def invalid_row_size_error
-        @io_strategy.display_red(Strings::INVALID_ROW_SIZE)
+        @io_strategy.display_red(Presenter::INVALID_ROW_SIZE)
       end
 
       def invalid_token_error
-        @io_strategy.display_red(Strings::INVALID_TOKEN)
+        @io_strategy.display_red(Presenter::INVALID_TOKEN)
       end
 
       def invalid_difficulty_error
-        @io_strategy.display_red(Strings::INVALID_DIFFICULTY)
+        @io_strategy.display_red(Presenter::INVALID_DIFFICULTY)
       end
 
       def invalid_move_error
-        @io_strategy.display_red(Strings::INVALID_MOVE)
+        @io_strategy.display_red(Presenter::INVALID_MOVE)
       end
 
       def thinking_notification
-        @io_strategy.display_red(Strings::THINKING)
+        @io_strategy.display_red(Presenter::THINKING)
       end
 
       def game_over_notification(winner)
         winner = "Nobody" if winner.nil?
         winner = winner.token unless winner.is_a? String
-        @io_strategy.display(Strings.game_over_notification(winner))
+        @io_strategy.display(Presenter.game_over_notification(winner))
       end
 
       def move_solicitation
-        @io_strategy.display(Strings::MOVE_SOLICITATION)
+        @io_strategy.display(Presenter::MOVE_SOLICITATION)
       end
 
       def not_an_integer_error
-        @io_strategy.display_red(Strings::NOT_AN_INTEGER)
+        @io_strategy.display_red(Presenter::NOT_AN_INTEGER)
       end
 
       def solicit_input
@@ -79,15 +79,15 @@ module TicTacToes
       private
 
       def row_size_solicitation
-        @io_strategy.display(Strings::ROW_SIZE_SOLICITATION)
+        @io_strategy.display(Presenter::ROW_SIZE_SOLICITATION)
       end
 
       def token_solicitation(player)
-        @io_strategy.display(Strings.token_solicitation(player))
+        @io_strategy.display(Presenter.token_solicitation(player))
       end
 
       def difficulty_solicitation
-        @io_strategy.display(Strings::DIFFICULTY_SOLICITATION)
+        @io_strategy.display(Presenter::DIFFICULTY_SOLICITATION)
       end
     end
   end

data/lib/tic_tac_toes/core/{strings.rb → presenter.rb}

@@ -3,7 +3,7 @@ require 'tic_tac_toes/core/rules'
 
 module TicTacToes
   module Core
-    module Strings
+    module Presenter
       smallest_row_size = Rules::ROW_SIZE_RANGE.min
       largest_row_size = Rules::ROW_SIZE_RANGE.max
 
@@ -101,6 +101,22 @@ module TicTacToes
         truncated_length.times { horizontal_divider << divider_unit }
         horizontal_divider
       end
+
+      def self.game_history_strings(wrapper)
+        game_histories = wrapper.read_game_histories
+        game_histories.map { |history| game_history_string(history) }
+      end
+
+      def self.game_history_string(history)
+        history_string = ''
+        history_string << "Board size: #{history.board_size.to_s}\n"
+        history_string << "Difficulty: #{history.difficulty}\n"
+        history_string << "Winner: #{history.winner}\n"
+        history_string << "Move history:\n"
+        history.moves.each { |move| history_string << "  #{move.join(' -> ')}\n" }
+        history_string << "\n"
+        history_string
+      end
     end
   end
 end

data/lib/tic_tac_toes/ui/adapter.rb

@@ -1,37 +1,29 @@
 require 'tic_tac_toes/core/player_factory'
 require 'tic_tac_toes/core/move_strategies/hard_ai'
+require 'tic_tac_toes/core/move_strategies/types'
 
 module TicTacToes
   module UI
     module Adapter
       def self.start_game(order, game_state, listener)
-        case order
-        when 'first'
-          listener.moves_were_made(game_state)
-        when 'second'
-          make_move(game_state, nil, listener)
-        end
+        user_is_first = order == 'first'
+
+        user_is_first ? listener.moves_were_made(game_state) : make_move(game_state, nil, listener)
       end
 
       def self.make_move(game_state, move, listener)
-        unless move.nil?
-          move = move.to_i
-          game_state.place_move(move)
-        end
-
-        if game_state.game_over?
-          tell_listener_game_is_over(game_state, listener)
-          return
-        end
+        computer_first = move.nil?
 
-        game_state.turn_over(move)
-        game_state.current_player.place_and_return_move(game_state)
-
-        if game_state.game_over?
-          tell_listener_game_is_over(game_state, listener)
-          return
+        if computer_first
+          game_state.turn_over(nil)
+          computer_move(game_state, listener)
+          return game_over(game_state, listener) if game_state.game_over?
+        else
+          human_move(game_state, move, listener)
+          return game_over(game_state, listener) if game_state.game_over?
+          computer_move(game_state, listener)
+          return game_over(game_state, listener) if game_state.game_over?
         end
-
         listener.moves_were_made(game_state)
       end
 
@@ -43,7 +35,7 @@ module TicTacToes
           potential_game_state = generate_game_state(game_state, space)
           next predictions << predicted_result(potential_game_state) if potential_game_state.game_over?
 
-          potential_game_state.turn_over([])
+          potential_game_state.turn_over(nil)
           potential_game_state.place_move(Core::MoveStrategies::HardAI.move(potential_game_state))
           next predictions << predicted_result(potential_game_state) if potential_game_state.game_over?
 
@@ -54,20 +46,36 @@ module TicTacToes
 
       private
 
-      def self.tell_listener_game_is_over(game_state, listener)
+      def self.computer_move(game_state, listener)
+        computer_player = game_state.computer_player
+        computer_move = computer_player.place_and_return_move(game_state)
+        game_state.turn_over(computer_move)
+      end
+
+      def self.human_move(game_state, move, listener)
+        human_player = game_state.current_player
+        game_state.place_move(move.to_i)
+        game_state.turn_over([human_player.token, move.to_i])
+      end
+
+      def self.game_over(game_state, listener)
         winning_player = game_state.determine_winner
 
-        case winning_player
-        when nil
-          listener.game_ended_in_draw(game_state)
-        else 
+        record_game_history(game_state, winning_player)
+        if winning_player
           listener.game_ended_in_winner(game_state, winning_player.token)
+        else
+          listener.game_ended_in_draw(game_state)
         end
       end
 
+      def self.record_game_history(game_state, winning_player)
+        game_state.start_game
+        game_state.end_game(winning_player)
+      end
+
       def self.generate_game_state(game_state, space)
         new_game_state = Marshal.load(Marshal.dump(game_state))
-        new_game_state.turn_over([])
         new_game_state.place_move(space)
         new_game_state
       end
@@ -77,7 +85,7 @@ module TicTacToes
 
         if winner.nil?
           "tie"
-        elsif winner.move_strategy.is_a? Core::MoveStrategies::Human
+        elsif winner.move_strategy.type == Core::MoveStrategies::HUMAN
           "win"
         else
           "loss"

data/lib/tic_tac_toes/ui/serializer.rb

@@ -1,6 +1,7 @@
 require 'tic_tac_toes/core/board'
 require 'tic_tac_toes/core/game_state'
 require 'tic_tac_toes/core/player_factory'
+require 'tic_tac_toes/database/pg_wrapper'
 
 module TicTacToes
   module UI
@@ -13,30 +14,35 @@ module TicTacToes
         board.spaces
       end
 
-      def self.game_state_from_board_structure(board_structure, computer_type)
+      def self.game_state(board_structure, computer_type, move_history)
         player_factory = Core::PlayerFactory.new('unused_io')
         human_player = player_factory.generate_player(X, Core::PlayerFactory::HUMAN)
         computer_player = player_factory.generate_player(O, Core::PlayerFactory.const_get(computer_type))
         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)
+        board = board(board_structure_with_players)
 
-        Core::GameState.new(board, players, NullHistory.new)
+        history = history(move_history)
+
+        Core::GameState.new(board, players, history)
       end
 
-      def self.board_structure_from_game_state(game_state)
+      def self.board_structure(game_state)
         structure_with_players = game_state.board.spaces
-
         replace_players_with_tokens(structure_with_players)
       end
 
-      def self.ai_type_from_game_state(game_state)
+      def self.ai_type(game_state)
         computer = Core::MoveStrategies::COMPUTER
         computer_player = game_state.players.detect { |player| player.move_strategy.type == computer }
         computer_player.move_strategy.ai_type
       end
 
+      def self.move_history(game_state)
+        game_state.moves.flatten.join if game_state.moves
+      end
+
       private
 
       def self.replace_tokens_with_players(board_structure, human_player, computer_player)
@@ -56,7 +62,7 @@ module TicTacToes
         board_structure.map { |space| space.token unless space.nil? }
       end
 
-      def self.board_from_structure(board_structure)
+      def self.board(board_structure)
         row_size = Math.sqrt(board_structure.count).to_i
         board = Core::Board.new(row_size: row_size)
 
@@ -66,6 +72,19 @@ module TicTacToes
 
         board
       end
+
+      def self.history(move_history)
+        storage_wrapper = Database::PGWrapper.new('tic_tac_toes')
+        history = Core::History.new(storage_wrapper)
+        if move_history
+          moves = move_history.split(//).each_slice(2).to_a
+          moves.each do |move|
+            move = [move.first, move.last.to_i]
+            history.record_move(move)
+          end
+        end
+        history
+      end
     end
 
     class NullHistory
@@ -80,6 +99,14 @@ module TicTacToes
       def record_move(move)
         nil
       end
+
+      def record_winner(winner)
+        nil
+      end
+
+      def persist
+        nil
+      end
     end
   end
 end

data/lib/tic_tac_toes/version.rb

@@ -1,3 +1,3 @@
 module TicTacToes
-  VERSION = "0.1.4"
+  VERSION = "0.1.6"
 end

data/spec/tic_tac_toes/core/game_state_spec.rb

@@ -88,6 +88,16 @@ describe TicTacToes::Core::GameState do
     end
   end
 
+  describe '#computer_player' do
+    it 'returns the game’s computer player' do
+      human_player = TicTacToes::Core::PlayerFactory.new('unused_io').generate_player('X', :human)
+      computer_player = TicTacToes::Core::PlayerFactory.new('unused_io').generate_player('O', :hard)
+      players = [human_player, computer_player]
+      game_state = TicTacToes::Core::GameState.new('board', players, 'history')
+      expect(game_state.computer_player).to eq(computer_player)
+    end
+  end
+
   describe '#turn_over' do
     it 'records the last move' do
       move = double
@@ -109,6 +119,15 @@ describe TicTacToes::Core::GameState do
     end
   end
 
+  describe '#moves' do
+    it 'returns it’s move history' do
+      moves = [['X', 0], ['O', 4]]
+      history = double(moves: moves)
+      game_state = TicTacToes::Core::GameState.new('board', 'players', history)
+      expect(game_state.moves).to eq(moves)
+    end
+  end
+
   describe '#end_game' do
     it 'records the winner' do
       winning_player = double

data/spec/tic_tac_toes/core/history_spec.rb

@@ -28,7 +28,14 @@ describe TicTacToes::Core::History do
       move = ["X", 0]
 
       history.record_move(move)
-      expect(history.moves.first).to eql(move)
+      expect(history.moves.first).to eq(move)
+    end
+
+    it "doesn’t record anything if move is nil" do
+      move = nil
+
+      history.record_move(move)
+      expect(history.moves).to eq([])
     end
   end
 

data/spec/tic_tac_toes/core/io_spec.rb

@@ -1,9 +1,9 @@
 require 'tic_tac_toes/core/board'
 require 'tic_tac_toes/core/io'
-require 'tic_tac_toes/core/strings'
+require 'tic_tac_toes/core/presenter'
 
 describe TicTacToes::Core::IO do
-  let(:strings)  { TicTacToes::Core::Strings }
+  let(:strings)  { TicTacToes::Core::Presenter }
   let(:prompt)   { double("prompt", solicit_input: 0, display: true, display_red: true) }
   let(:io)       { TicTacToes::Core::IO.new(prompt) }
 

data/spec/tic_tac_toes/core/presenter_spec.rb

@@ -0,0 +1,95 @@
+require 'tic_tac_toes/core/board'
+require 'tic_tac_toes/core/rules'
+require 'tic_tac_toes/core/presenter'
+
+describe TicTacToes::Core::Presenter do
+  before do
+    @presenter = TicTacToes::Core::Presenter
+  end
+
+  describe '#invalid_row_size' do
+    it "returns a string containing the minimum and maximum allowed row sizes" do
+      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(@presenter::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(@presenter.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(@presenter.game_over_notification(winner)).to include(winner)
+    end
+  end
+
+  describe '#board' do
+    it "returns a board string" do
+      board = TicTacToes::Core::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(@presenter.board(board)).to eql(board_string)
+    end
+  end
+
+  describe '#game_history_strings' do
+    it 'Returns an array with a string for each game history' do
+      history_double = double('history',
+                             board_size: 9,
+                             difficulty: 'Medium AI',
+                             winner: 'X',
+                             moves: [['A', 0], ['B', 4]])
+      histories_array = [history_double, history_double]
+      wrapper = double('wrapper', read_game_histories: histories_array)
+      
+      expect(@presenter.game_history_strings(wrapper).count).to eq(2)
+    end
+  end
+
+  describe '#game_history_string' do
+    before do
+      @history_double = double('history',
+                             board_size: 9,
+                             difficulty: 'Medium AI',
+                             winner: 'X',
+                             moves: [['A', 0], ['B', 4]])
+    end
+
+    it 'Returns a string that includes the game history’s board size' do
+      history_string = @presenter.game_history_string(@history_double)
+      expect(history_string).to include('9')
+    end
+
+    it 'Returns a string that includes the game history’s difficulty' do
+      history_string = @presenter.game_history_string(@history_double)
+      expect(history_string).to include('Medium AI')
+    end
+
+    it 'Returns a string that includes the game history’s winner' do
+      history_string = @presenter.game_history_string(@history_double)
+      expect(history_string).to include('X')
+    end
+
+    it 'Returns a string that includes the game history’s move history' do
+      history_string = @presenter.game_history_string(@history_double)
+      expect(history_string).to include('A', '0', 'B', '4')
+    end
+  end
+end

data/spec/tic_tac_toes/ui/adapter_spec.rb

@@ -19,8 +19,8 @@ describe TicTacToes::UI::Adapter do
     context 'when passed an order of “second”' do
       it 'sends its listener #moves_were_made with the game state' do
         order = 'second'
-        computer_player = double(place_and_return_move: 0)
-        game_state = double(game_over?: false, turn_over: true, current_player: computer_player)
+        computer_player = double(place_and_return_move: 0, token: 'O')
+        game_state = double(game_over?: false, turn_over: true, computer_player: computer_player)
         listener = double
 
         expect(listener).to receive(:moves_were_made).with(game_state)
@@ -56,6 +56,21 @@ describe TicTacToes::UI::Adapter do
       end
     end
 
+    context 'when the game is over' do
+      it 'records the game history' do
+        board = TicTacToes::TestBoardGenerator.generate([  x,   x, nil,
+                                                         nil, nil, nil,
+                                                         nil, nil, nil])
+        game_state = TicTacToes::Core::GameState.new(board, players, history)
+        move = '2'
+        listener = double(game_ended_in_winner: true)
+
+        expect(history).to receive(:persist)
+        TicTacToes::UI::Adapter.make_move(game_state, move, listener)
+        board.place(x, 2)
+      end
+    end
+
     context 'when the game has ended with a winner' do
       it 'sends its listener #game_ended_in_winner with the updated game state and the winning token' do
         board = TicTacToes::TestBoardGenerator.generate([  x,   x, nil,
@@ -98,7 +113,7 @@ describe TicTacToes::UI::Adapter do
     player_factory = TicTacToes::Core::PlayerFactory.new('unused_io')
     let(:x)          { player_factory.generate_player('x', TicTacToes::Core::PlayerFactory::HUMAN) }
     let(:o)          { player_factory.generate_player('o', TicTacToes::Core::PlayerFactory::HARD_AI) }
-    let(:players)    { [o, x] }   
+    let(:players)    { [x, o] }   
 
     it 'returns an array indicating which moves will result in a win' do
       board = TicTacToes::TestBoardGenerator.generate([   x,   x, nil,
@@ -139,9 +154,9 @@ describe TicTacToes::UI::Adapter do
                                                        nil, nil,    x])
       game_state = TicTacToes::Core::GameState.new(board, players, history)
 
-      expect(TicTacToes::UI::Adapter.predictions(game_state)).to eq([   nil,    nil,    nil,
-                                                                        nil,    nil, "loss",
-                                                                        nil, "loss",    nil])
+      expect(TicTacToes::UI::Adapter.predictions(game_state)).to eq([nil,    nil,    nil,
+                                                                     nil,    nil, "loss",
+                                                                     nil, "loss",    nil])
     end
   end
 end

data/spec/tic_tac_toes/ui/serializer_spec.rb

@@ -11,13 +11,14 @@ describe TicTacToes::UI::Serializer do
     end
   end
 
-  describe '#game_state_from_board_structure' do
-    it 'returns a game state object based on a board structure and computer type' do
+  describe '#game_state' do
+    it 'returns a game state object based on a board structure and AI type' do
       board_structure = [nil, nil, nil, nil, 'X', nil, nil, nil, nil]
-      computer_type = 'EASY_AI'
+      ai_type = 'EASY_AI'
+      move_history = 'X0O4'
       ai = TicTacToes::Core::PlayerFactory::AIS.fetch(TicTacToes::Core::PlayerFactory::EASY_AI)
 
-      game_state = TicTacToes::UI::Serializer.game_state_from_board_structure(board_structure, computer_type)
+      game_state = TicTacToes::UI::Serializer.game_state(board_structure, ai_type, move_history)
       middle_space = game_state.board.space(4)
       first_player = game_state.players.first
       second_player = game_state.players.last
@@ -26,10 +27,11 @@ describe TicTacToes::UI::Serializer do
       expect(first_player.token).to eq(TicTacToes::UI::Serializer::X)
       expect(second_player.token).to eq(TicTacToes::UI::Serializer::O)
       expect(second_player.move_strategy).to eq(ai)
+      expect(game_state.moves).to eq([['X', 0], ['O', 4]])
     end
   end
 
-  describe '#board_structure_from_game_state' do
+  describe '#board_structure' do
     it 'returns a board structure based on a game state object' do
       player_factory = TicTacToes::Core::PlayerFactory.new('unused_io')
       first_player = player_factory.generate_player(TicTacToes::UI::Serializer::X, TicTacToes::Core::PlayerFactory::HUMAN)
@@ -40,17 +42,25 @@ describe TicTacToes::UI::Serializer do
 
       game_state = TicTacToes::Core::GameState.new(board, players, TicTacToes::UI::NullHistory.new)
       board_structure = [nil, nil, nil, nil, 'X', nil, nil, nil, nil]
-      expect(TicTacToes::UI::Serializer.board_structure_from_game_state(game_state)).to eq(board_structure)
+      expect(TicTacToes::UI::Serializer.board_structure(game_state)).to eq(board_structure)
     end
   end
 
-  describe '#ai_type_from_game_state' do
+  describe '#ai_type' do
     it 'returns the type of a game state’s computer player' do
       move_strategy = TicTacToes::Core::PlayerFactory::AIS.fetch(TicTacToes::Core::PlayerFactory::EASY_AI)
       computer_player = double(move_strategy: move_strategy)
       players = [computer_player]
       game_state = double(players: players)
-      expect(TicTacToes::UI::Serializer.ai_type_from_game_state(game_state)).to eq('EASY_AI')
+      expect(TicTacToes::UI::Serializer.ai_type(game_state)).to eq('EASY_AI')
+    end
+  end
+
+  describe '#move_history' do
+    it 'returns a move history structure based on a game state object' do
+      moves = [['X', 0], ['O', 4]]
+      game_state = double('game_state', moves: moves)
+      expect(TicTacToes::UI::Serializer.move_history(game_state)).to eq('X0O4')
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tic_tac_toes
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Ben Spatafora
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-26 00:00:00.000000000 Z
+date: 2014-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -87,7 +87,6 @@ files:
 - bin/game_histories
 - bin/set_up_ttt_databases
 - bin/tic_tac_toes
-- lib/tic_tac_toes/command_line/history_reader.rb
 - lib/tic_tac_toes/command_line/menu.rb
 - lib/tic_tac_toes/command_line/prompt.rb
 - lib/tic_tac_toes/command_line/runner.rb
@@ -102,15 +101,14 @@ files:
 - lib/tic_tac_toes/core/move_strategies/types.rb
 - lib/tic_tac_toes/core/player.rb
 - lib/tic_tac_toes/core/player_factory.rb
+- lib/tic_tac_toes/core/presenter.rb
 - lib/tic_tac_toes/core/rules.rb
-- lib/tic_tac_toes/core/strings.rb
 - lib/tic_tac_toes/database/pg_wrapper.rb
 - lib/tic_tac_toes/tasks/destroy_databases.rake
 - lib/tic_tac_toes/tasks/set_up_databases.rake
 - lib/tic_tac_toes/ui/adapter.rb
 - lib/tic_tac_toes/ui/serializer.rb
 - lib/tic_tac_toes/version.rb
-- spec/tic_tac_toes/command_line/history_reader_spec.rb
 - spec/tic_tac_toes/command_line/menu_spec.rb
 - spec/tic_tac_toes/core/board_spec.rb
 - spec/tic_tac_toes/core/game_state_spec.rb
@@ -122,8 +120,8 @@ files:
 - spec/tic_tac_toes/core/move_strategies/medium_ai_spec.rb
 - spec/tic_tac_toes/core/player_factory_spec.rb
 - spec/tic_tac_toes/core/player_spec.rb
+- spec/tic_tac_toes/core/presenter_spec.rb
 - spec/tic_tac_toes/core/rules_spec.rb
-- spec/tic_tac_toes/core/strings_spec.rb
 - spec/tic_tac_toes/database/pg_wrapper_spec.rb
 - spec/tic_tac_toes/test_board_generator.rb
 - spec/tic_tac_toes/ui/adapter_spec.rb
@@ -154,7 +152,6 @@ signing_key:
 specification_version: 4
 summary: The game Tic-tac-toe, featuring an unbeatable AI
 test_files:
-- spec/tic_tac_toes/command_line/history_reader_spec.rb
 - spec/tic_tac_toes/command_line/menu_spec.rb
 - spec/tic_tac_toes/core/board_spec.rb
 - spec/tic_tac_toes/core/game_state_spec.rb
@@ -166,8 +163,8 @@ test_files:
 - spec/tic_tac_toes/core/move_strategies/medium_ai_spec.rb
 - spec/tic_tac_toes/core/player_factory_spec.rb
 - spec/tic_tac_toes/core/player_spec.rb
+- spec/tic_tac_toes/core/presenter_spec.rb
 - spec/tic_tac_toes/core/rules_spec.rb
-- spec/tic_tac_toes/core/strings_spec.rb
 - spec/tic_tac_toes/database/pg_wrapper_spec.rb
 - spec/tic_tac_toes/test_board_generator.rb
 - spec/tic_tac_toes/ui/adapter_spec.rb

data/lib/tic_tac_toes/command_line/history_reader.rb

@@ -1,28 +0,0 @@
-require 'tic_tac_toes/command_line/prompt'
-
-module TicTacToes
-  module CommandLine
-    class HistoryReader
-      def initialize(wrapper)
-        @wrapper = wrapper
-      end
-
-      def display_game_histories
-        game_histories = @wrapper.read_game_histories
-        game_histories.each { |history| Prompt.display(game_history_string(history)) }
-        nil
-      end
-
-      def game_history_string(history)
-        history_string = ''
-        history_string << "Board size: #{history.board_size.to_s}\n"
-        history_string << "Difficulty: #{history.difficulty}\n"
-        history_string << "Winner: #{history.winner}\n"
-        history_string << "Move history:\n"
-        history.moves.each { |move| history_string << "  #{move.join(' -> ')}\n" }
-        history_string << "\n"
-        history_string
-      end
-    end
-  end
-end

data/spec/tic_tac_toes/command_line/history_reader_spec.rb

@@ -1,48 +0,0 @@
-require 'tic_tac_toes/command_line/history_reader'
-
-describe TicTacToes::CommandLine::HistoryReader do
-  before do
-    @history_double = double('history',
-                             board_size: 9,
-                             difficulty: 'Medium AI',
-                             winner: 'X',
-                             moves: [['A', 0], ['B', 4]])
-  end
-
-  describe '#display_game_histories' do
-    it 'Displays something for each game history' do
-      histories_array = [@history_double, @history_double]
-      wrapper = double('wrapper', read_game_histories: histories_array)
-      
-      expect(TicTacToes::CommandLine::Prompt).to receive(:display).twice
-      TicTacToes::CommandLine::HistoryReader.new(wrapper).display_game_histories
-    end
-  end
-
-  describe '#game_history_string' do
-    before do
-      wrapper_double = double('wrapper')
-      @history_reader = TicTacToes::CommandLine::HistoryReader.new(wrapper_double)
-    end
-
-    it 'Returns a string that includes the game history’s board size' do
-      history_string = @history_reader.game_history_string(@history_double)
-      expect(history_string).to include('9')
-    end
-
-    it 'Returns a string that includes the game history’s difficulty' do
-      history_string = @history_reader.game_history_string(@history_double)
-      expect(history_string).to include('Medium AI')
-    end
-
-    it 'Returns a string that includes the game history’s winner' do
-      history_string = @history_reader.game_history_string(@history_double)
-      expect(history_string).to include('X')
-    end
-
-    it 'Returns a string that includes the game history’s move history' do
-      history_string = @history_reader.game_history_string(@history_double)
-      expect(history_string).to include('A', '0', 'B', '4')
-    end
-  end
-end

data/spec/tic_tac_toes/core/strings_spec.rb

@@ -1,49 +0,0 @@
-require 'tic_tac_toes/core/board'
-require 'tic_tac_toes/core/rules'
-require 'tic_tac_toes/core/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::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
-  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::Core::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