ttt 1.0.0

data/features/computer_player.feature

@@ -0,0 +1,62 @@
+Feature: Computer player
+
+  In order to hone my tic-tac-toe skills
+  As a player
+  I want an unbeatable computer opponent
+  
+  The following scenarios should cover a sampling of possible boards. As there are
+  765 possible game possible congruence classes of boards, I won't attempt to cover
+  them all, but will verify that the computer plays optimally in a number of common
+  situations (two game boards are in a congruence class, such as the two below, 
+  if one can be turned into the other by rotating or mirroring).
+  
+  For a list of all congruent states, there are some rake tasks which compute them
+  and explore some of their properties.
+  
+  Example of congruent boards (rotate the left board 90 degrees to get the right board):
+  
+   1 |   |        |   | 1 
+  ---|---|---  ---|---|---
+     |   |        |   |   
+  ---|---|---  ---|---|---
+     |   |        |   |   
+  
+
+  Scenario Outline: Computer's moves
+    When I create a game with "<configuration>"
+    And a computer player as player <player>
+    Then it is player<player>s turn
+    And the computer moves to one of the following: <possible boards>
+    
+    Scenarios: Computer always takes a win when it is available
+      | configuration | player | possible boards     | description                                            |
+      | 110200200     | 1      | 111200200           | can win across top                                     |
+      | 220000110     | 1      | 220000111           | can win across bottom and opponent can win across top  |
+      | 201201000     | 1      | 201201001           | can win vertically on RHS opponent can win too         |
+      | 120120000     | 1      | 120120100           | can win vertically on RHS opponent can win too         |
+      | 102210000     | 1      | 102210001           | can win diagonally                                     |
+      | 120112020     | 1      | 120112120 120112021 | can win in two positions                               |
+      | 120021001     | 2      | 120021021           | takes win when 2nd player and 1st can also win         |
+    
+    Scenarios: Computer blocks opponent's win
+      | configuration | player | possible boards     | description                                            |
+      | 120100000     | 2      | 120100200           | blocks lhs                                             |
+      | 122110000     | 2      | 122110200 122110002 | blocks either of opponent's possible wins              |
+      | 211200000     | 1      | 211200100           | blocks when first player                               |
+
+    Scenarios: Finds best moves for likely game states
+      | configuration | player | possible boards                          | description                                            |
+      | 000000000     | 1      | 100000000 001000000 000000100 000000001  | makes best 1st move                                    |
+      | 120000000     | 1      | 120000100 120010000 120100000            | makes move that will guarantee win in future           |
+      | 100000002     | 1      | 101000002 100000102                      | makes move that will guarantee win in future           |
+      | 100000020     | 1      | 100000120 101000020 100010020            | makes move that will guarantee win in future           |
+      | 102000000     | 1      | 102100000 102000100 102000001            | makes move that will guarantee win in future           |
+      | 102100200     | 1      | 102110200                                | makes move that will guarantee win next turn           |
+      | 100020000     | 1      | 110020000 100120000                      | makes move with highest probability of win in future   |
+      | 100000000     | 2      | 100020000                                | makes move with lowest probability of losing in future |
+  
+  Scenario: Plays correctly for current player
+    Given I create a game with "000000000"
+    And I have a computer player
+    Then the computer will play for 1
+    Then the computer will play for 2

data/features/create_game.feature

@@ -0,0 +1,63 @@
+Feature: Create game
+
+  TTT is the core lib that underlies an interface, where the interface allows users to play the game.
+  
+  In order to allow users to play the game
+  An interface must be able to create a game in various states.
+
+  A board can be represented as a string of 9 digits, where a 0 indicates that neither player has moved
+  into that position, a 1 indicates that player1 has moved there, and a 2 indicates that player2 has moved there.
+  The digits correspond to the board in the following manner:
+  
+  abcdefghi
+  
+   a | b | c 
+  ---|---|---
+   d | e | f 
+  ---|---|---
+   g | h | i 
+  
+  So the game board "001002100" would look like this (let "x" represent player 1 and "o" represent player2):
+
+     |   | x 
+  ---|---|---
+     |   | o 
+  ---|---|---
+   x |   |   
+
+
+  Scenario: Create a new game
+    When I create a new game
+    Then the game board is "000000000"
+    And it is player1s turn
+  
+  Scenario Outline: Create an existing game
+    When I create a game with "<configuration>"
+    Then the game board is "<configuration>"
+    And it is player<player>s turn
+    
+    Scenarios: Player1s turn
+      | configuration | player |
+      | 000000000     | 1      |
+      | 120000000     | 1      |
+      | 120120000     | 1      |
+      | 120120210     | 1      |
+      | 000010002     | 1      |
+      | 120221112     | 1      |
+    
+    Scenarios: Player2s turn
+      | configuration | player |
+      | 100000000     | 2      |
+      | 012100000     | 2      |
+      | 001112200     | 2      |
+      | 100200100     | 2      |
+      | 120221110     | 2      |
+  
+  Scenario: Know who is where
+    Given I create a game with "000120000"
+    When I ask who is at position 4, it returns 1
+    When I ask who is at position 5, it returns 2
+    When I ask who is at position 6, it returns nil
+
+  
+  

data/features/finish_game.feature

@@ -0,0 +1,53 @@
+Feature: Finish game
+
+  In order to allow for actual gameplay
+  As a player
+  I can win, lose, and tie
+
+  Scenario: Player1 wins  
+    Given I create a game with "120120000"
+    Then the game is not over
+    When I mark position 7
+    Then the game board is "120120100"
+    And the game is over
+    And player1 wins
+    And player2 loses
+    And it is no one's turn
+  
+  Scenario: Player2 wins  
+    Given I create a game with "121120000"
+    Then the game is not over
+    When I mark position 8
+    Then the game board is "121120020"
+    And the game is over
+    And player2 wins
+    And player1 loses
+    And it is no one's turn
+
+  Scenario: The players tie
+    Given I create a game with "121221012"
+    Then the game is not over
+    When I mark position 7
+    Then the game board is "121221112"
+    And the game is over
+    And player1 ties
+    And player2 ties
+    And it is no one's turn
+
+  Scenario Outline: I can ask which positions won
+    Given I create a game with "<configuration>"
+    When I ask what positions won
+    Then it tells me [<p1>, <p2>, <p3>]
+    
+    Scenarios:
+      | configuration | p1 | p2 | p3 |
+      | 111220000     | 1  | 2  | 3  |
+      | 220111000     | 4  | 5  | 6  |
+      | 220000111     | 7  | 8  | 9  |
+      | 120120100     | 1  | 4  | 7  |
+      | 210210010     | 2  | 5  | 8  |
+      | 201201001     | 3  | 6  | 9  |
+      | 120210001     | 1  | 5  | 9  |
+      | 021210100     | 3  | 5  | 7  |
+      | 021210100     | 3  | 5  | 7  |
+      | 211210200     | 1  | 4  | 7  |

data/features/finished_states.feature

@@ -0,0 +1,56 @@
+Feature: Finished states
+
+  In order to finish the game, the library must know what a finished state is.
+  A finished state is a state that either has no available moves left, or where
+  a player has won the game. A player has won the game if they have marked
+  three consecutive spaces in a horizontal, vertical, or diagonal direction.
+
+  Scenario: No winner, no available moves left
+    Given a tie game
+    Then the game is over
+
+  Scenario Outline: Three marks in a row
+    When I create a game with "<configuration>"
+    Then the game is over
+    And player<winner> wins
+
+    Scenarios: Horizontal win
+      | configuration | winner |
+      | 111000000     | 1      |
+      | 000111000     | 1      |
+      | 000000111     | 1      |
+      | 222000000     | 2      |
+      | 000222000     | 2      |
+      | 000000222     | 2      |
+
+    Scenarios: Vertical win
+      | configuration | winner |
+      | 100100100     | 1      |
+      | 010010010     | 1      |
+      | 001001001     | 1      |
+      | 200200200     | 2      |
+      | 020020020     | 2      |
+      | 002002002     | 2      |
+
+    Scenarios: Diagonal win
+      | configuration | winner |
+      | 100010001     | 1      |
+      | 001010100     | 1      |
+      | 200020002     | 2      |
+      | 002020200     | 2      |
+
+  Scenario Outline: Unfinished states
+    When I create a game with "<configuration>"
+    Then the game is not over
+
+    Scenarios: Playing to a tie game
+      | configuration |
+      | 000000000     |
+      | 100000000     |
+      | 100020000     |
+      | 101020000     |
+      | 121020000     |
+      | 121020010     |
+      | 121220010     |
+      | 121221010     |
+      | 121221012     |

data/features/mark_board.feature

@@ -0,0 +1,24 @@
+Feature: Mark board
+
+  In order to play the game
+  As a player (or, more probably, an interface translating a player's desire)
+  I want to mark the board
+
+  Scenario: Marking an empty board
+    Given I create a new game
+    When I mark position 1
+    Then the game board is "100000000"
+
+  Scenario: Marking a board when it is player1s turn
+    Given I create a game with "120000000"
+    Then it is player1s turn
+    When I mark position 4
+    Then the game board is "120100000"
+    And it is player2s turn
+  
+  Scenario: Marking a board when it is player2s turn
+    Given I create a game with "120100000"
+    Then it is player2s turn
+    When I mark position 7
+    Then the game board is "120100200"
+    And it is player1s turn

data/features/step_definitions/binary_steps.rb

@@ -0,0 +1,42 @@
+Given /^I look at (.*)$/ do |location|
+  @location = location
+end
+
+When /^I see it is executable$/ do
+  File.executable?(@location).should be
+end
+
+Given /^I pass the it "([^"]*)" on the command line$/ do |args|
+  pending "Yet again don't know how to test, it hangs b/c it expects input."\
+          "I can put it in a thread and kill it later, but inconsistent results."
+  require 'open3' # from stdlib
+  binary = Class.new Struct.new(:exitstatus, :stdout, :stderr) do
+    def initialize(args)
+      Open3.popen3 "bin/ttt #{args}" do |stdin, stdout, stderr, wait_thr|
+        super(wait_thr.value.exitstatus, stdout.read.strip, stderr.read.strip)
+      end
+    end
+  end
+  @binary = binary.new args
+end
+
+Then %r{^it should display /([^/]*)/$} do |message|
+  Then "it should print /#{message}/ to stdout"
+end
+
+Then %r{^it should print /([^/]*)/ to (\w+)$} do |message, output_name|
+  output = @binary.send output_name
+  output.should match Regexp.new(message)
+end
+
+Then /^it should exit with code of (\d+)$/ do |code|
+  @binary.exitstatus.should be code.to_i
+end
+
+
+# a simple greeting we'll have the CLI write
+# just to make sure everything is hooked up correctly
+Then /^it should welcome me to Tic Tac Toe$/ do
+  Then "it should display /Welcome to Tic Tac Toe/"
+end
+

data/features/step_definitions/ttt_steps.rb

@@ -0,0 +1,82 @@
+When /^I create a new game$/ do
+  @game = TTT::Game.new
+end
+
+Then /^the game board is "([^"]*)"$/ do |board|
+  @game.board.should == board
+end
+
+Then /^it is (player(\d+)s|no one's) turn$/ do |turn, player_number|
+  if player_number
+    @game.turn.should == player_number.to_i
+  else
+    @game.turn.should be_nil
+  end
+end
+
+When /^I ask what positions won$/ do
+  @winning_positions = @game.winning_positions
+end
+
+Then /^it tells me \[(\d+), (\d+), (\d+)\]$/ do |p1, p2, p3|
+  @winning_positions.sort.should == [p1, p2, p3].map(&:to_i).sort
+end
+
+
+When /^I create a game with "([^"]*)"$/ do |configuration|
+  @game = TTT::Game.new configuration
+end
+
+When /^I mark position (\d+)$/ do |position|
+  @game.mark position.to_i
+end
+
+Then /^board\(:ttt\) will be "([^"]*)"$/ do |board|
+  @game.board(:ttt).should == board.gsub('\\n', "\n")
+end
+
+Then /^the game is (not )?over$/ do |not_over|
+  if not_over
+    @game.should_not be_over
+  else
+    @game.should be_over
+  end
+end
+
+When /^I ask who is at position (\d+), it returns (\w+)$/ do |position, player|
+  player = player.to_i
+  player = nil if player.zero?
+  @game[position.to_i].should == player
+end
+
+Then /^player(\d+) (wins|loses|ties)$/ do |player, status|
+  @game.status(player.to_i).should == status.to_sym
+end
+
+Given /^a tie game$/ do
+  @game = TTT::Game.new '121221112'
+end
+
+When /^a computer player as player (\d+)$/ do |current_turn|
+  @game.turn.should == current_turn.to_i
+end
+
+Then /^the computer moves to one of the following: ((?:\d+ ?)+)$/ do |possible_boards|
+  @computer = TTT::ComputerPlayer.new @game
+  @computer.take_turn
+  possible_boards.split.should include @game.board
+end
+
+Given /^I have a computer player$/ do
+  @computer = TTT::ComputerPlayer.new @game
+end
+
+Then /^the computer will play for (\d+)$/ do |player_number|
+  player_number = player_number.to_i
+  @game.turn.should == player_number
+  @computer.player_number.should == player_number
+  @computer.take_turn
+  @game.turn.should_not == player_number
+  @computer.player_number.should_not == player_number.to_i
+end
+

data/features/support/env.rb

@@ -0,0 +1,8 @@
+require 'bundler/bouncer'
+
+$LOAD_PATH << File.expand_path('../../../lib', __FILE__)
+
+# lib files
+require 'ttt'
+require 'ttt/computer_player'
+require 'ttt/binary'

data/features/view_board_as_developer.feature

@@ -0,0 +1,13 @@
+Feature: View board as developer
+
+  In order to be able to do exploratory testing
+  As a developer
+  I want to be able to view the board in standard tic-tac-toe format
+  
+  Scenario: View board in tic-tac-toe format
+    Given I create a game with "abcdefghi"
+    Then board(:ttt) will be "  a | b | c  \n----|---|----\n  d | e | f  \n----|---|----\n  g | h | i  "
+  
+  Scenario: Viewing a board with spaces no one has moved into
+  Given I create a game with "120000000"
+  Then board(:ttt) will be "  1 | 2 |    \n----|---|----\n    |   |    \n----|---|----\n    |   |    "

data/features/view_board_as_tester.feature

@@ -0,0 +1,9 @@
+Feature: View board as tester
+
+  In order to verify game state
+  As a tester
+  I want to view the board as a simple string
+  
+  Scenario: View board in string format
+    Given I create a game with "abcdefghi"
+    Then the game board is "abcdefghi"

data/lib/ttt.rb

@@ -0,0 +1 @@
+require 'ttt/game'

data/lib/ttt/binary.rb

@@ -0,0 +1,96 @@
+require 'optparse'
+
+require 'ttt/interface'
+
+module TTT
+  
+  # The code for ttt/bin
+  class Binary
+    
+    attr_accessor :filein, :fileout, :fileerr
+    
+    def initialize(argv, io={})
+      self.fileout = io.fetch :fileout, $stdout
+      self.fileerr = io.fetch :fileerr, $stderr
+      self.filein  = io.fetch :filein,  $stdin
+      parse argv
+    end
+    
+    def parse(argv)
+      argv = ['-h'] if argv.empty?
+      Parser.new(self).parse argv
+    rescue OptionParser::MissingArgument => e
+      fileerr.puts e.message
+      Kernel.exit 1
+    end
+    
+    def has_interface?(interface_name)
+      TTT::Interface.registered? interface_name
+    end
+    
+    def list_of_registered
+      TTT::Interface.registered_names.map(&:inspect).join(', ')
+    end
+    
+    def interface(interface_name)
+      TTT::Interface.registered[interface_name]
+    end
+    
+    
+    
+    class Parser
+      
+      attr_accessor :binary
+      
+      def initialize(binary)
+        self.binary = binary
+      end
+      
+      def method_missing(meth, *args, &block)
+        super unless binary.respond_to? meth
+        binary.send meth, *args, &block
+      end
+            
+      def parse(argv)
+        options.parse argv
+      end
+      
+      def options
+        OptionParser.new do |options|
+          define_banner     options
+          define_interface  options
+          define_help       options
+        end
+      end
+    
+      def options_for_interface
+        return :filein => filein, :fileout => fileout, :fileerr => fileerr
+      end
+    
+      def define_banner(options)
+          options.banner = "Usage: ttt --interface interface_name\n" \
+                           "ttt is an implementation of Tic Tac Toe by Josh Cheek\n\n"
+      end
+    
+      def define_interface(options)
+        options.on '-i', '--interface TYPE', "Specify which interface to play on. Select from: #{list_of_registered}" do |interface_name|
+          if interface_name.equal? true
+            fileerr.puts "Please supply interface type"
+            Kernel.exit 1
+          elsif has_interface? interface_name
+            interface(interface_name).new(options_for_interface).play
+          else
+            fileerr.puts "#{interface_name.inspect} is not a valid interface, select from: #{list_of_registered}"
+          end
+        end
+      end
+    
+      def define_help(options)
+        options.on '-h', '--help', 'Display this screen' do
+          fileout.puts options
+        end
+      end
+    end
+    
+  end
+end