tactical_tic_tac_toe 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 91f9d2072259b9710988edde50d53c39cc3962e7
-  data.tar.gz: fb68237c3ad7abf7c4259fef3bffc81d45701629
+  metadata.gz: a48e3069e89982be0b1927358042ccdf5931e344
+  data.tar.gz: 199d9b74f5bc4c0eab7e68ab78a6ee8534832688
 SHA512:
-  metadata.gz: 0232937a96a30ad91f9d27fbb38cd67edfd6a7f5e327557edfb2859faa4dd60fe4fa396bc6732c10fee0fe1bcd2c8f9a823a1beacfe6bfa4758b9fd322cd8a10
-  data.tar.gz: 2303ffecb1799bfda197289f85d7e418b34edb71efa5f5a83a87d16853d86f2c77df5dfcd34dd5ebdb7fd4e0cb08c252ebdd0305d464e34fb3f3a86b845847f8
+  metadata.gz: 87fa250b8b7f466e6fb30c39f4db48a08aa6e7bc79494180d63b5698a67ce89d1418f4bcda55b1c45dd6b8b543b92c33d8b7999c6aa5f4ba16b5e5da6af3470c
+  data.tar.gz: 1928f444469351637902c7a8afaecd00fed4fa18b5ad883ba913b730a1957446000b91bed94194f44ae96659fbf08402c2c897af6e34786081305a5c0ea737cd

data/lib/board.rb

@@ -5,19 +5,25 @@ module TicTacToe
     attr_reader :size, :last_move_made
 
     def initialize(parameters)
-      @size = parameters[:size]
-      @cells = parameters[:config] || blank_board_configuration
+      @size = parameters[:size] || infer_size(parameters[:marked_spaces])
+      @spaces = parameters[:marked_spaces] || blank_spaces
       @last_move_made = parameters[:last_move_made]
     end
 
-    def read_cell(row, col)
-      @cells[row * @size + col]
+    def read_space(coordinates)
+      @spaces[coordinates_to_flat_index(coordinates)]
     end
 
-    def mark_cell(mark, row, col)
-      config = @cells.dup
-      config[row * @size + col] = mark
-      Board.new(size: @size, config: config, last_move_made: [row, col])
+    def mark_space(mark, coordinates)
+      marked_spaces = @spaces.dup
+      marked_spaces[coordinates_to_flat_index(coordinates)] = mark
+
+      Board.new(marked_spaces: marked_spaces, last_move_made: coordinates)
+    end
+
+    def last_mark_made
+      return if @last_move_made.nil?
+      self.read_space(last_move_made)
     end
 
     def lines
@@ -30,27 +36,22 @@ module TicTacToe
       (0...@size).to_a.repeated_permutation(2).to_a
     end
 
-    def blank_cell_coordinates
+    def blank_space_coordinates
       all_coordinates.reject { |coordinates| marked?(coordinates) }
     end
 
-    def last_mark_made
-      return if @last_move_made.nil?
-      self.read_cell(*last_move_made)
+    def out_of_bounds?(coordinates)
+      coordinates.any? { |i| !i.between?(0, @size - 1) }
     end
 
     def blank?(coordinates)
-      self.read_cell(*coordinates) == BLANK_MARK
+      self.read_space(coordinates) == BLANK_MARK
     end
 
     def marked?(coordinates)
       !blank?(coordinates)
     end
 
-    def out_of_bounds?(coordinates)
-      coordinates.any? { |i| !i.between?(0, @size - 1) }
-    end
-
     def all_blank?
       all_coordinates.all? { |coordinates| blank?(coordinates) }
     end
@@ -61,31 +62,41 @@ module TicTacToe
 
     def has_winning_line?
       lines.each do |line|
-        return true if line.first != BLANK_MARK && line.all? { |cell| cell == line.first }
+        return true if line.first != BLANK_MARK && line.all? { |mark| mark == line.first }
       end
       false
     end
 
     private
 
-    def blank_board_configuration
+    def infer_size(marked_spaces)
+      return if marked_spaces.nil?
+      Math.sqrt(marked_spaces.count).to_i
+    end
+
+    def coordinates_to_flat_index(coordinates)
+      row, col = coordinates
+      row * @size + col
+    end
+
+    def blank_spaces
       Array.new(@size**2) { BLANK_MARK }
     end
 
     def row_at(row)
-      (0...@size).map { |col| self.read_cell(row, col) }
+      (0...@size).map { |col| self.read_space([row, col]) }
     end
 
     def col_at(col)
-      (0...@size).map { |row| self.read_cell(row, col) }
+      (0...@size).map { |row| self.read_space([row, col]) }
     end
 
     def left_diag
-      (0...@size).map { |index| self.read_cell(index, index) }
+      (0...@size).map { |index| self.read_space([index, index]) }
     end
 
     def right_diag
-      (0...@size).map { |row| self.read_cell(row, @size - row - 1) }
+      (0...@size).map { |row| self.read_space([row, @size - row - 1]) }
     end
   end
 end

data/lib/command_line_interface.rb

@@ -1,6 +1,5 @@
 module TicTacToe
   class CommandLineInterface
-
     def initialize(parameters)
       @input = parameters[:input]
       @output = parameters[:output]
@@ -86,7 +85,7 @@ EOS
       (0...board.size).each do |row|
         output_string += col_separator
         (0...board.size).each do |col|
-          output_string += " #{board.read_cell(row, col) || " "} " + col_separator
+          output_string += " #{board.read_space([row, col]) || " "} " + col_separator
         end
         output_string += "\n" + row_separator
       end

data/lib/computer_player.rb

@@ -47,9 +47,9 @@ module TicTacToe
         board = node.fetch(:board)
         current_player_mark = node.fetch(:current_player_mark)
 
-        board.blank_cell_coordinates.map do |coordinates|
+        board.blank_space_coordinates.map do |coordinates|
           child_node = {
-            board: board.mark_cell(current_player_mark, *coordinates),
+            board: board.mark_space(current_player_mark, coordinates),
             current_player_mark: toggle_mark(current_player_mark),
             last_move_made: coordinates
           }
@@ -71,8 +71,8 @@ module TicTacToe
         board = node.fetch(:board)
 
         board.lines.each do |line|
-          return 1 if line.all? { |cell|  cell == @player_mark }
-          return -1 if line.all? { |cell|  cell == @opponent_mark }
+          return 1 if line.all? { |mark|  mark == @player_mark }
+          return -1 if line.all? { |mark|  mark == @opponent_mark }
         end
         0
       end

data/lib/game.rb

@@ -37,7 +37,7 @@ module TicTacToe
     def handle_one_turn(current_player)
       @interface.show_game_board(@board)
       coordinates = get_valid_move(current_player)
-      @board = @board.mark_cell(current_player.player_mark, *coordinates)
+      @board = @board.mark_space(current_player.player_mark, coordinates)
       @interface.report_move(current_player.player_mark, coordinates)
     end
 
@@ -77,12 +77,12 @@ module TicTacToe
     end
 
     def create_player(mark, type)
-      player_config = {
+      player_parameters = {
         type: type,
         game: self,
         player_mark: mark
       }
-      PlayerFactory.build(player_config)
+      PlayerFactory.build(player_parameters)
     end
   end
 end

data/lib/player_factory.rb

@@ -4,30 +4,30 @@ require "available_player_types"
 
 module TicTacToe
   module PlayerFactory
-    def self.build(config)
-      case config[:type]
+    def self.build(parameters)
+      case parameters[:type]
       when AvailablePlayerTypes::HUMAN
-        create_human_player(config)
+        create_human_player(parameters)
       when AvailablePlayerTypes::COMPUTER
-        create_computer_player(config)
+        create_computer_player(parameters)
       end
     end
 
     private
 
-    def self.create_human_player(config)
+    def self.create_human_player(parameters)
       human_parameters = {
-        player_mark: config[:player_mark],
-        interface: config[:game].interface
+        player_mark: parameters[:player_mark],
+        interface: parameters[:game].interface
       }
       HumanPlayer.new(human_parameters)
     end
 
-    def self.create_computer_player(config)
+    def self.create_computer_player(parameters)
       computer_parameters = {
-        player_mark: config[:player_mark],
-        opponent_mark: (config[:game].player_marks - [config[:player_mark]]).pop,
-        board: config[:game].board
+        player_mark: parameters[:player_mark],
+        opponent_mark: (parameters[:game].player_marks - [parameters[:player_mark]]).pop,
+        board: parameters[:game].board
       }
       ComputerPlayer.new(computer_parameters)
     end

data/spec/board_spec.rb

@@ -11,26 +11,26 @@ module TicTacToe
     let(:o) { @default_player_marks.last }
 
     describe "#initialize" do
-      context "given the configuration of a board with preexisting marks" do
-        let(:config) do
+      context "given a set of preexisting marks" do
+        let(:marked_spaces) do
           [ x, _, _,
             _, o, _,
             _, _, x ]
         end
 
-        it "generates a board with the specified marks in each cell" do
-          board = new_board(size: Math.sqrt(config.size).to_i, config: config)
+        it "generates a board with the specified marks in each space" do
+          board = build_board(marked_spaces)
 
-          board.all_coordinates.zip(config).each do |coordinates, mark|
-            expect(board.read_cell(*coordinates)).to eq mark
+          board.all_coordinates.zip(marked_spaces).each do |coordinates, mark|
+            expect(board.read_space(coordinates)).to eq mark
           end
         end
       end
 
-      context "when not given a configuration of a board with preexisting marks" do
+      context "when not given a a set of preexisting marks" do
         it "generates a NxN board of the given size" do
           (3..5).each do |size|
-            custom_board = new_board(size: size)
+            custom_board = blank_board(size)
 
             expect(custom_board.size).to eq size
             expect(custom_board.all_coordinates.count).to eq size**2
@@ -38,23 +38,21 @@ module TicTacToe
         end
 
         it "leaves the generated board blank" do
-          expect(new_board(size: @default_board_size).all_blank?).to be true
+          expect(blank_board(@default_board_size).all_blank?).to be true
         end
       end
     end
 
-    describe "#read_cell" do
-      it "gets the contents of cell at given row and column" do
-        mark = @default_player_marks.sample
-        config = blank_board_configuration(@default_board_size)
-        config[0] = mark
-        board = build_board(config)
+    describe "#read_space" do
+      it "gets the contents of space at given row and column" do
+        marked_spaces = [x, _, _, _, _, _, _, _, _]
+        board = build_board(marked_spaces)
 
-        expect(board.read_cell(0, 0)).to eq mark
+        expect(board.read_space([0, 0])).to eq x
       end
     end
 
-    describe "#mark_cell" do
+    describe "#mark_space" do
       let(:board) { blank_board(@default_board_size) }
       let(:coordinates) { random_coordinates(board.size) }
       let(:mark) { @default_player_marks.sample }
@@ -62,19 +60,19 @@ module TicTacToe
       it "returns a new board with the given coordinates played" do
         board = blank_board(@default_board_size)
 
-        expect(board.mark_cell(mark, *coordinates).read_cell(*coordinates)).to eq(mark)
+        expect(board.mark_space(mark, coordinates).read_space(coordinates)).to eq(mark)
       end
 
       it "does not mutate the board" do
         board = blank_board(@default_board_size)
 
-        board.mark_cell(mark, *coordinates)
+        board.mark_space(mark, coordinates)
 
         expect(board).to be_all_blank
       end
 
       it "records the coordinates of the last mark made" do
-        returned_board = board.mark_cell(mark, *coordinates)
+        returned_board = board.mark_space(mark, coordinates)
 
         expect(returned_board.last_move_made).to eq coordinates
       end
@@ -96,33 +94,33 @@ module TicTacToe
     describe "#all_coordinates" do
       let(:board) { blank_board(@default_board_size) }
 
-      it "returns the coordinates of every cell in board" do
+      it "returns the coordinates of every space in board" do
         all_coordinates = (0...board.size).to_a.repeated_permutation(2).to_a
 
         expect(board.all_coordinates).to match_array all_coordinates
       end
     end
 
-    describe "#blank_cell_coordinates" do
-      it "returns all cell coordinates when board is blank" do
+    describe "#blank_space_coordinates" do
+      it "returns all space coordinates when board is blank" do
         board = blank_board(@default_board_size)
 
-        expect(board.blank_cell_coordinates).to match_array board.all_coordinates
+        expect(board.blank_space_coordinates).to match_array board.all_coordinates
       end
 
-      it "returns the coordinates of all blank cells in board" do
-        config = [x, o, _, _, _, _, _, _, _].shuffle
-        board = build_board(config)
+      it "returns the coordinates of all blank spaces in board" do
+        marked_spaces = [x, o, _, _, _, _, _, _, _].shuffle
+        board = build_board(marked_spaces)
         unmarked_coordinates = board.all_coordinates.reject { |coords| board.marked?(coords) }
 
-        expect(board.blank_cell_coordinates).to match_array unmarked_coordinates
+        expect(board.blank_space_coordinates).to match_array unmarked_coordinates
       end
 
-      it "returns no coordinates when no cells are blank" do
-        config = [x, o, x, o, x, o, x, o, x].shuffle
-        board = build_board(config)
+      it "returns no coordinates when no spaces are blank" do
+        marked_spaces = [x, o, x, o, x, o, x, o, x].shuffle
+        board = build_board(marked_spaces)
 
-        expect(board.blank_cell_coordinates.count).to eq 0
+        expect(board.blank_space_coordinates.count).to eq 0
       end
     end
 
@@ -137,7 +135,7 @@ module TicTacToe
         it "returns the last mark made on the board" do
           board = blank_board(@default_board_size)
           mark = @default_player_marks.sample
-          returned_board = board.mark_cell(mark, *random_coordinates(board.size))
+          returned_board = board.mark_space(mark, random_coordinates(board.size))
 
           expect(returned_board.last_mark_made).to eq mark
         end
@@ -145,31 +143,31 @@ module TicTacToe
     end
 
     describe "#blank?" do
-      it "returns true if cell at given coordinates is blank" do
+      it "returns true if space at given coordinates is blank" do
         board = blank_board(@default_board_size)
 
         expect(board.blank?(random_coordinates(board.size))).to be true
       end
 
-      it "returns false if cell at given coordinates is not blank" do
+      it "returns false if space at given coordinates is not blank" do
         board = blank_board(@default_board_size)
         coordinates = random_coordinates(board.size)
-        returned_board = board.mark_cell(@default_player_marks.sample, *coordinates)
+        returned_board = board.mark_space(@default_player_marks.sample, coordinates)
 
         expect(returned_board.blank?(coordinates)).to be false
       end
     end
 
     describe "#marked?" do
-      it "returns true if cell at given coordinates has any player's mark" do
+      it "returns true if space at given coordinates has any player's mark" do
         board = blank_board(@default_board_size)
         coordinates = random_coordinates(board.size)
-        returned_board = board.mark_cell(@default_player_marks.sample, *coordinates)
+        returned_board = board.mark_space(@default_player_marks.sample, coordinates)
 
         expect(returned_board.marked?(coordinates)).to be true
       end
 
-      it "returns false if cell at given coordinates does not have a player's mark" do
+      it "returns false if space at given coordinates does not have a player's mark" do
         blank_board = blank_board(@default_board_size)
         coordinates = random_coordinates(blank_board.size)
 
@@ -195,31 +193,31 @@ module TicTacToe
     end
 
     describe "#all_blank?" do
-      it "returns true if no cell in board is marked" do
+      it "returns true if no space in board is marked" do
         board = blank_board(@default_board_size)
 
         expect(board.all_blank?).to be true
       end
 
-      it "returns false if any cell in board is marked" do
-        config = [x, _, _, _, _, _, _, _, _].shuffle
-        board = build_board(config)
+      it "returns false if any space in board is marked" do
+        marked_spaces = [x, _, _, _, _, _, _, _, _].shuffle
+        board = build_board(marked_spaces)
 
         expect(board.all_blank?).to be false
       end
     end
 
     describe "#all_marked?" do
-      it "returns true if all cells in board are marked" do
-        config = [x, x, x, x, x, o, o, o, o].shuffle
-        board = build_board(config)
+      it "returns true if all spaces in board are marked" do
+        marked_spaces = [x, x, x, x, x, o, o, o, o].shuffle
+        board = build_board(marked_spaces)
 
         expect(board.all_marked?).to be true
       end
 
-      it "returns false if any cell in board is blank" do
-        config = [x, x, x, x, _, o, o, o, o].shuffle
-        board = build_board(config)
+      it "returns false if any space in board is blank" do
+        marked_spaces = [x, x, x, x, _, o, o, o, o].shuffle
+        board = build_board(marked_spaces)
 
         expect(board.all_marked?).to be false
       end
@@ -227,7 +225,7 @@ module TicTacToe
 
     describe "#has_winning_line?" do
       it "returns true if board has a horizontal winning line" do
-        winning_configs = [
+        winning_configurations = [
           [ x, x, x,
             _, _, _,
             _, _, _ ],
@@ -239,13 +237,13 @@ module TicTacToe
             x, x, x ]
         ]
 
-        winning_configs.each do |config|
-          expect(build_board(config).has_winning_line?).to be true
+        winning_configurations.each do |marked_spaces|
+          expect(build_board(marked_spaces).has_winning_line?).to be true
         end
       end
 
       it "returns true if board has a vertical winning line" do
-        winning_configs = [
+        winning_configurations = [
           [ x, _, _,
             x, _, _,
             x, _, _ ],
@@ -257,13 +255,13 @@ module TicTacToe
             _, _, x ]
         ]
 
-        winning_configs.each do |config|
-          expect(build_board(config).has_winning_line?).to be true
+        winning_configurations.each do |marked_spaces|
+          expect(build_board(marked_spaces).has_winning_line?).to be true
         end
       end
 
       it "returns true if board has a diagonal winning line" do
-        winning_configs = [
+        winning_configurations = [
           [ x, _, _,
             _, x, _,
             _, _, x ],
@@ -272,13 +270,13 @@ module TicTacToe
             x, _, _ ]
         ]
 
-        winning_configs.each do |config|
-          expect(build_board(config).has_winning_line?).to be true
+        winning_configurations.each do |marked_spaces|
+          expect(build_board(marked_spaces).has_winning_line?).to be true
         end
       end
 
       it "returns false if board has no winning line" do
-        non_winning_configs = [
+        non_winning_configurations = [
           [ _, _, _,
             _, _, _,
             _, _, _ ],
@@ -296,8 +294,8 @@ module TicTacToe
             o, x, o ]
         ]
 
-        non_winning_configs.each do |config|
-          expect(build_board(config).has_winning_line?).to be false
+        non_winning_configurations.each do |marked_spaces|
+          expect(build_board(marked_spaces).has_winning_line?).to be false
         end
       end
     end

data/spec/command_line_interface_spec.rb

@@ -15,6 +15,11 @@ module TicTacToe
       CommandLineInterface.new(parameters)
     end
 
+    def at_least_one_repeated_line?(string)
+      lines = string.split("\n")
+      lines.uniq.length < lines.length
+    end
+
     describe "#game_setup_interaction" do
       before do
         input_stream.string = %w(human computer).join("\n")
@@ -41,7 +46,7 @@ module TicTacToe
 
       it "prints a prompt to the command line" do
         input_stream.string = valid_input
-        interface.solicit_player_type(@default_first_player)
+        interface.solicit_player_type(@default_player_marks.first)
 
         expect(output_stream.string).not_to eq ""
       end
@@ -50,7 +55,7 @@ module TicTacToe
         it "returns the player type input by user" do
           input_stream.string = valid_input
 
-          expect(interface.solicit_player_type(@default_first_player)).to eq valid_input.to_sym
+          expect(interface.solicit_player_type(@default_player_marks.first)).to eq valid_input.to_sym
         end
       end
 
@@ -59,7 +64,7 @@ module TicTacToe
 
         it "prompts the user until given valid input" do
           input_stream.string = invalid_input + "\n" + invalid_input + "\n" + valid_input
-          interface.solicit_player_type(@default_first_player)
+          interface.solicit_player_type(@default_player_marks.first)
 
           expect(at_least_one_repeated_line?(output_stream.string)).to be true
         end
@@ -67,17 +72,17 @@ module TicTacToe
     end
 
     describe "#show_game_board" do
+      let(:_) { Board::BLANK_MARK }
+      let(:x) { @default_player_marks.first }
+      let(:o) { @default_player_marks.last }
+
       it "prints a respresentation of the given board to the command line" do
-        board = board_with_draw(@default_board_size, @default_player_marks)
+        board = build_board([x, x, x, o, o, o, _, _, _])
         interface.show_game_board(board)
-
         board_characters = output_stream.string.split("")
-        cell_count = board.size**2
-        expected_first_mark_count = cell_count.odd? ? cell_count / 2 + 1 : cell_count / 2
-        expected_second_mark_count = cell_count / 2
 
-        expect(board_characters.count(@default_first_player.to_s)).to eq expected_first_mark_count
-        expect(board_characters.count(@default_second_player.to_s)).to eq expected_second_mark_count
+        expect(board_characters.count(x.to_s)).to eq 3
+        expect(board_characters.count(o.to_s)).to eq 3
       end
     end
 
@@ -86,7 +91,7 @@ module TicTacToe
 
       it "prints a prompt to the command line" do
         input_stream.string = valid_input
-        interface.solicit_move(@default_first_player)
+        interface.solicit_move(@default_player_marks.first)
 
         expect(output_stream.string).not_to eq ""
       end
@@ -96,7 +101,7 @@ module TicTacToe
           input_stream.string = valid_input
           valid_coordinate = valid_input.split(",").map(&:to_i)
 
-          expect(interface.solicit_move(@default_first_player)).to eq valid_coordinate
+          expect(interface.solicit_move(@default_player_marks.first)).to eq valid_coordinate
         end
       end
 
@@ -105,7 +110,7 @@ module TicTacToe
 
         it "prompts the user until given valid input" do
           input_stream.string = invalid_input + "\n" + invalid_input + "\n" + valid_input
-          interface.solicit_move(@default_first_player)
+          interface.solicit_move(@default_player_marks.first)
 
           expect(at_least_one_repeated_line?(output_stream.string)).to be true
         end
@@ -122,10 +127,10 @@ module TicTacToe
 
     describe "#report_move" do
       it "prints a notification of the move made by the given mark at the given coordinates" do
-        interface.report_move(@default_first_player, [0, 0])
+        interface.report_move(@default_player_marks.first, [0, 0])
         interface_output = output_stream.string
 
-        expect(interface_output).to include @default_first_player.to_s
+        expect(interface_output).to include @default_player_marks.first.to_s
         expect(interface_output.split("").count("0")).to eq 2
       end
     end
@@ -133,8 +138,8 @@ module TicTacToe
     describe "#report_game_over" do
       context "when given the mark of a winning player" do
         it "prints a notification that the player has won" do
-          expect(interface).to receive(:report_win).with(@default_first_player)
-          interface.report_game_over(@default_first_player)
+          expect(interface).to receive(:report_win).with(@default_player_marks.first)
+          interface.report_game_over(@default_player_marks.first)
         end
       end
 
@@ -148,10 +153,10 @@ module TicTacToe
 
     describe "#report_win" do
       it "prints a notification that the player using the given mark has won" do
-        interface.report_win(@default_first_player)
+        interface.report_win(@default_player_marks.first)
         interface_output = output_stream.string
 
-        expect(interface_output).to include @default_first_player.to_s
+        expect(interface_output).to include @default_player_marks.first.to_s
         expect(interface_output).to include "wins"
       end
     end

data/spec/computer_player_spec.rb

@@ -10,8 +10,8 @@ module TicTacToe
     include_context "helper_methods"
 
     let(:_) { Board::BLANK_MARK }
-    let(:x) { @default_first_player }
-    let(:o) { @default_second_player }
+    let(:x) { @default_player_marks.first }
+    let(:o) { @default_player_marks.last }
 
     def new_computer_player(parameters)
       ComputerPlayer.new(parameters)
@@ -37,12 +37,12 @@ module TicTacToe
 
     describe "#move" do
       it "returns the coordinates of a valid move" do
-        board_config = [
+        marked_spaces = [
           x, o, x,
           x, x, o,
           o, _, _
         ]
-        board = build_board(board_config).mark_cell(o, *[2, 1])
+        board = build_board(marked_spaces).mark_space(o, [2, 1])
         game = Game.new(board: board)
         computer_player = x_player(board)
         coordinates = computer_player.move(game)
@@ -64,7 +64,7 @@ module TicTacToe
 
       context "when computer player can make a horizontal winning move" do
         it "returns the coordinates of the winning move" do
-          board_configs = [
+          board_configurations = [
             [ x, _, x,
               _, o, _,
               o, x, o ],
@@ -76,8 +76,8 @@ module TicTacToe
               _, x, x ]
           ]
           winning_moves = [[0, 1], [1, 2], [2, 0]]
-          board_configs.zip(winning_moves).each do |board_config, winning_move|
-            board = build_board(board_config)
+          board_configurations.zip(winning_moves).each do |marked_spaces, winning_move|
+            board = build_board(marked_spaces)
             game = Game.new(board: board)
             computer_player = x_player(board)
 
@@ -88,7 +88,7 @@ module TicTacToe
 
       context "when computer player can make a vertical winning move" do
         it "returns the coordinates of the winning move" do
-          board_configs = [
+          board_configurations = [
             [ x, _, o,
               _, o, x,
               x, _, o ],
@@ -100,8 +100,8 @@ module TicTacToe
               o, x, x ]
           ]
           winning_moves = [[1, 0], [2, 1], [0, 2]]
-          board_configs.zip(winning_moves).each do |board_config, winning_move|
-            board = build_board(board_config)
+          board_configurations.zip(winning_moves).each do |marked_spaces, winning_move|
+            board = build_board(marked_spaces)
             game = Game.new(board: board)
             computer_player = x_player(board)
 
@@ -112,7 +112,7 @@ module TicTacToe
 
       context "when computer player can make a diagonal winning move" do
         it "returns the coordinates of the winning move" do
-          board_configs = [
+          board_configurations = [
             [ x, _, o,
               o, x, _,
               x, o, _ ],
@@ -121,8 +121,8 @@ module TicTacToe
               x, o, _ ]
           ]
           winning_moves = [[2, 2], [0, 2]]
-          board_configs.zip(winning_moves).each do |board_config, winning_move|
-            board = build_board(board_config)
+          board_configurations.zip(winning_moves).each do |marked_spaces, winning_move|
+            board = build_board(marked_spaces)
             computer_player = x_player(board)
             game = Game.new(board: board)
 
@@ -133,7 +133,7 @@ module TicTacToe
 
       context "when opponent can make a horizontal winning move next turn" do
         it "returns the coordinates of the move that blocks the opponent from winning" do
-          board_configs = [
+          board_configurations = [
             [ x, _, x,
               _, o, _,
               o, x, o ],
@@ -145,8 +145,8 @@ module TicTacToe
               _, x, x ]
           ]
           winning_moves = [[0, 1], [1, 2], [2, 0]]
-          board_configs.zip(winning_moves).each do |board_config, winning_move|
-            board = build_board(board_config)
+          board_configurations.zip(winning_moves).each do |marked_spaces, winning_move|
+            board = build_board(marked_spaces)
             computer_player = o_player(board)
             game = Game.new(board: board)
 
@@ -157,7 +157,7 @@ module TicTacToe
 
       context "when opponent can make a vertical winning move next turn" do
         it "returns the coordinates of the move that blocks the opponent from winning" do
-          board_configs = [
+          board_configurations = [
             [ x, _, o,
               _, o, x,
               x, _, o ],
@@ -169,8 +169,8 @@ module TicTacToe
               o, x, x ]
           ]
           winning_moves = [[1, 0], [2, 1], [0, 2]]
-          board_configs.zip(winning_moves).each do |board_config, winning_move|
-            board = build_board(board_config)
+          board_configurations.zip(winning_moves).each do |marked_spaces, winning_move|
+            board = build_board(marked_spaces)
             computer_player = o_player(board)
             game = Game.new(board: board)
 
@@ -181,7 +181,7 @@ module TicTacToe
 
       context "when opponent can make a diagonal winning move next turn" do
         it "returns the coordinates of the move that blocks the opponent from winning" do
-          board_configs = [
+          board_configurations = [
             [ x, _, o,
               o, x, _,
               x, o, _ ],
@@ -190,8 +190,8 @@ module TicTacToe
               x, o, _ ]
           ]
           winning_moves = [[2, 2], [0, 2]]
-          board_configs.zip(winning_moves).each do |board_config, winning_move|
-            board = build_board(board_config)
+          board_configurations.zip(winning_moves).each do |marked_spaces, winning_move|
+            board = build_board(marked_spaces)
             computer_player = o_player(board)
             game = Game.new(board: board)
 
@@ -202,7 +202,7 @@ module TicTacToe
 
       context "when opponent can make a fork next turn" do
         it "returns the coordinates of a move that prevents that fork" do
-          board_configs = [
+          board_configurations = [
             [ x, _, _,
               _, x, _,
               _, _, o ],
@@ -218,8 +218,8 @@ module TicTacToe
             [[0, 1], [1, 0], [1, 2], [2, 1]],
             [[0, 0], [0, 2], [2, 0], [2, 2]]
           ]
-          board_configs.zip(good_move_sets).each do |board_config, good_moves|
-            board = build_board(board_config)
+          board_configurations.zip(good_move_sets).each do |marked_spaces, good_moves|
+            board = build_board(marked_spaces)
             computer_player = o_player(board)
             game = Game.new(board: board)
 

data/spec/game_spec.rb

@@ -114,7 +114,7 @@ module TicTacToe
       let(:player_stub) { Object.new }
 
       before do
-        allow(player_stub).to receive(:player_mark).and_return(@default_first_player)
+        allow(player_stub).to receive(:player_mark).and_return(@default_player_marks.first)
         allow(player_stub).to receive(:move).and_return([0, 0])
       end
 
@@ -138,13 +138,13 @@ module TicTacToe
         allow(game.interface).to receive(:report_move)
         game.handle_one_turn(player_stub)
 
-        expect(game.board.read_cell(0, 0)).to eq @default_first_player
+        expect(game.board.read_space([0, 0])).to eq @default_player_marks.first
       end
 
       it "reports the move that was just made through the interface" do
         allow(game.interface).to receive(:show_game_board)
 
-        expect(game.interface).to receive(:report_move).with(@default_first_player, [0, 0])
+        expect(game.interface).to receive(:report_move).with(@default_player_marks.first, [0, 0])
         game.handle_one_turn(player_stub)
       end
     end
@@ -206,9 +206,9 @@ module TicTacToe
         it "reports that the given last player to move has won via the interface" do
           allow(game.interface).to receive(:show_game_board)
           allow(game.board).to receive(:has_winning_line?).and_return(true)
-          allow(game.board).to receive(:last_mark_made).and_return(@default_first_player)
+          allow(game.board).to receive(:last_mark_made).and_return(@default_player_marks.first)
 
-          expect(game.interface).to receive(:report_game_over).with(@default_first_player)
+          expect(game.interface).to receive(:report_game_over).with(@default_player_marks.first)
           game.handle_game_over
         end
       end
@@ -216,7 +216,7 @@ module TicTacToe
       context "when game has no winner" do
         it "reports that game ended in a draw via the interface" do
           allow(game.interface).to receive(:show_game_board)
-          allow(game.board).to receive(:last_mark_made).and_return(@default_first_player)
+          allow(game.board).to receive(:last_mark_made).and_return(@default_player_marks.first)
 
           expect(game.interface).to receive(:report_game_over).with(:none)
           game.handle_game_over
@@ -277,7 +277,7 @@ module TicTacToe
 
         it "should end in a win for the computer player against an unskilled human player" do
           allow(game.interface).to receive(:solicit_move) do
-            game.board.blank_cell_coordinates.first
+            game.board.blank_space_coordinates.first
           end
           computer_player_mark = :o
           game.run

data/spec/human_player_spec.rb

@@ -8,8 +8,7 @@ module TicTacToe
     let(:interface) { double("CommandLineInterface") }
     let(:human_player) do
       HumanPlayer.new(
-        # interface: interface,
-        player_mark: @default_first_player)
+        player_mark: @default_player_marks.first)
     end
 
     describe "#move" do

data/spec/player_factory_spec.rb

@@ -10,38 +10,38 @@ module TicTacToe
     describe ".build" do
       let(:player_types) { [AvailablePlayerTypes::HUMAN, AvailablePlayerTypes::COMPUTER] }
       let(:player_classes) { [HumanPlayer, ComputerPlayer] }
-      let(:player_config) do
+      let(:player_parameters) do
         {
           game: Game.new({}),
           player_mark: @default_player_marks.first
         }
       end
 
-      def build_player(config)
-        PlayerFactory.build(config)
+      def build_player(player_parameters)
+        PlayerFactory.build(player_parameters)
       end
 
       it "creates a player of the given type" do
         player_types.zip(player_classes).each do |type, player_class|
-          player_config[:type] = type
+          player_parameters[:type] = type
 
-          expect(build_player(player_config)).to be_a player_class
+          expect(build_player(player_parameters)).to be_a player_class
         end
       end
 
       it "creates players that respond to #move" do
         player_types.each do |type|
-          player_config[:type] = type
+          player_parameters[:type] = type
 
-          expect(build_player(player_config)).to respond_to :move
+          expect(build_player(player_parameters)).to respond_to :move
         end
       end
 
       it "creates players that use the given mark" do
         player_types.each do |type|
-          player_config[:type] = type
+          player_parameters[:type] = type
 
-          expect(build_player(player_config).player_mark).to eq player_config[:player_mark]
+          expect(build_player(player_parameters).player_mark).to eq player_parameters[:player_mark]
         end
       end
     end

data/spec/spec_helper.rb

@@ -4,8 +4,6 @@ require "rspec/collection_matchers"
 RSpec.shared_context "default_values" do
   before :all do
     @default_board_size = 3
-    @default_first_player = :x
-    @default_second_player = :o
     @default_player_marks = [:x, :o]
     @default_player_types = [
       TicTacToe::AvailablePlayerTypes::HUMAN,
@@ -15,42 +13,15 @@ RSpec.shared_context "default_values" do
 end
 
 RSpec.shared_context "helper_methods" do
-  def blank_board_configuration(board_size)
-    (0...board_size**2).map { TicTacToe::Board::BLANK_MARK }
-  end
-
-  def at_least_one_repeated_line?(string)
-    lines = string.split("\n")
-    lines.uniq.length < lines.length
-  end
-
   def random_coordinates(board_size)
     [rand(board_size), rand(board_size)]
   end
 
-  def new_board(parameters)
-    TicTacToe::Board.new(parameters)
-  end
-
-  def build_board(config)
-    size = Math.sqrt(config.size).to_i
-    new_board(size: size, config: config)
+  def build_board(marked_spaces)
+    TicTacToe::Board.new(marked_spaces: marked_spaces)
   end
 
   def blank_board(board_size)
-    new_board(size: board_size)
-  end
-
-  def board_with_draw(board_size, player_marks)
-    first_mark, second_mark = player_marks
-    blank_board(board_size).blank_cell_coordinates.reduce(blank_board(board_size)) do |board, (row, col)|
-        if row == 0
-          mark = col.odd? ? first_mark : second_mark
-          board.mark_cell(mark, row, col)
-        else
-          mark = col.even? ? first_mark : second_mark
-          board.mark_cell(mark, row, col)
-        end
-    end
+    TicTacToe::Board.new(size: board_size)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tactical_tic_tac_toe
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Batman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-26 00:00:00.000000000 Z
+date: 2015-11-01 00:00:00.000000000 Z
 dependencies: []
 description: Command line tic tac toe! Run with command 'ttt'
 email: no@no.no