Add method #clone to create a complete duplicate

Method #clone should take no arguments and return an instance of class
Board. The returned board should have exactly the same values in
attributes 'spaces' 'size' and 'symbols_added'. Each of these attributes
must share no references with the original instance.
Add 'require' statement for Board class

When tested in isolation, the CommandLineConsole class does not know
about the Board class.
Make CommandLineConsole encapsulate other classes

Class CommandLineConsole is, by design, the only class that uses both
CommandLineRenderer and CommandLinePrompter. They should be instantiated
within the method #initialize.

For testing and injection, method #initialize should now take two IO
arguments for an input stream and output stream. Inside the #initialize
method, those arguments should be set on the prompter and renderer.
Make #initialize use default arguments

Method #initialize should default the values of input and output
arguments to $stdin and $stdout, respectively.
Make #run send a clone of the board to players

To insulate the game board from changes by players, a clone of the board
should be passed into the player method #choose_move.
Test method #display_board_results console calls

Method #display_board_results should call console methods listed:
 - #display_game_winner
 - #display_game_draw
Add method #valid_move? to validate a move choice

Method #valid_move? should take an integer (representing a board space)
as an argument and return true/false according to these conditions:
 - true if board space is marked with Board::BLANK
 - false if board space is marked by anything else
Make #run loop request for player move until valid

Method #run should request a move from each player, but also verify that
each response received is a valid move. If the response cannot be used,
the player method #choose_move should be called again on the same player
until a valid move is returned.
Test to ensure players cannot modify the board

Write a test to confirm that the cloning of the board insulates the game
board from modification by players.
Make #generate_solutions work for board size 4

Method #generate_solutions should take no arguments and return no value.
The method should fill the 'solutions' attribute with a two-dimensional
array holding integers. Each integer array should represent a list of
board spaces which are a winning solution for the board.

This method should create a full list of horizontal, vertical, and
diagonal solutions for board sizes of 3 and 4. The length of each
solution array should be equal to the size of the board.
Test #initialize for board space initialization

Method #initialize should store an array of blank marks of length equal
to the square of the board size.
 - (e.g. board size 3 = 9 blank spaces)
 - (e.g. board size 4 = 16 blank spaces)
Change spacing to use more padding
Adjust #available_spaces_to_ascii for size 4 board

Boards of size 4 have space indices up to two digits in length, to
maintain consistent display of these values, they should be displayed
with a constant padding.

Change #available_spaces_to_ascii to apply a simple string formatting
with padding before storing the index in the result array.
Make #display_board always pad using five spaces

Output from #display_board currently squeezes output into ten spaces,
aligned to the right. Using the same alignment, output should use a
constant of five spaces to pad.
Make #display_board_choices pad using five spaces

Output from #display_board_choices currently squeezes output into ten
spaces, aligned to the right. Using the same alignment, output should use a
constant of five spaces to pad.
Add method #prompt_board_size to get board size

Method #prompt_board_size should take no arguments and return an integer
representing the desired size of the board. The console prompter should
be set with valid_inputs of '3x3' and '4x4' for the accepted board
sizes. A request should be issued with a clear message requesting board
size from the user. The input should then be converted to an integer
appropriate to construct a board of the requested dimensions.
Make Configuration hold an array of board sizes

Configuration should have the responsibility of knowing which board
sizes may be used in a game. These values should be stored in a class
attribute array.
Add method #choose_board to create a board

Method #choose_board should take no arguments and return no value. It
should call console method #prompt_board_size, instantiate a board of
the requested size, and store that board in the 'board' reader
attribute.

This method should be placed in the #setup sequence after #choose_player
and #choose_opponent methods.
Make #initialize store the Configuration board

The Configuration object should have the responsibility of initializing
the board used by the game. Method #initialize in the Game class should
store a reference to the Configuration's board.
Make #prompt_player_mark use an array argument

Method #prompt_player_mark should receive an array as an argument, and
return an integer result. The array passed to the method should be a
list of the BLANK spaces on the game board. The resulting integer should
be one of these indices as designated by the player/user.

Each value in the array argument should be incremented for the sake of
presentation and converted to a String form. These values should be
stored in the 'valid_input' attribute of the console's Prompter object.
This part is necessary to ensure that input to the prompter is matched
to a String.

When input is supplied to and returned from the prompter, it is
converted back to an integer and decremented to account for the
original increment for presentation.

Use of the method #prompt_player_mark by the Human class should account
for the change in arguments.