tictactoe_j8th 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 66d20ba2e1cacc30029cc615d91958fc24a1ced6
+  data.tar.gz: c123145b5bc58bf774032b247aa37bd7d03f7ac4
+SHA512:
+  metadata.gz: c6ebd647c5a33b7190c95476a08b2d3a0b8a4cc295a595c44db7c0d85cfe72aa5b88c63dc1571e46461bc14f58003970bbeaab03a4dee74ae7aba0bec022447b
+  data.tar.gz: b4ef4f7a71cc547795842f883d8ce665ea73ac38f312e4b2d5a2a775ff948d952788eed9e0569a37d77617c87d9a8074832085d0a8fd8bf30ab989d9cdbdd800

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.swp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tictactoe_j8th.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 TODO: Write your name
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# TictactoeJ8th
+
+A gem encapsulating the logic of a tic tac toe game with an unbeatable AI.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tictactoe_j8th'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tictactoe_j8th
+
+## Usage
+
+Everything is in a TictactoeJ8th module.
+You get Game, Board, Human, and AI.
+
+```ruby
+require 'tictactoe_j8th'
+
+include TictactoeJ8th
+Game.new(Board.new, Human.new(:X), AI.new(:O))
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/tictactoe_j8th/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,15 @@
+require "bundler/gem_tasks"
+
+desc 'Run the normal test suite (same as \'rake spec\').'
+task default: %w[spec]
+
+desc 'Run the normal test suite, excluding some slower tests.'
+task :spec do
+	  system 'rspec --tag ~slow'
+end
+
+desc 'Run the full test suite.'
+task :fullspec do
+	  system 'rspec'
+end
+

data/lib/tictactoe_j8th/ai.rb

@@ -0,0 +1,96 @@
+module TictactoeJ8th
+  class AI
+
+    attr_reader :token
+
+    def initialize(token)
+      @token = token
+    end
+
+    def move(board)
+      return nil if board.full?
+
+      # ####### Speed Hacks #######
+      # Hacks to speed up minimax by bypassing most of the possible games.
+      # The return statements here are important.  We make a move, then
+      # bail out so that we don't end up analyzing all the possible games further down.
+      # TODO:  See if there is a craftier, less hackish way to speed things up.
+
+      # If the board is empty, always take the middle.
+      if board.empty?
+        board.place(token, 0)
+        return 0
+      end
+
+      open_spots = get_open_spots(board)
+      # If there is one spot taken, then always take the middle.
+      # Unless the middle is taken already, then take the corner.
+      if open_spots.count == Board::BOARD_SIZE-1
+        spot = board[4].nil? ? 4 : 0
+        board.place(token, spot)
+        return spot
+      end
+      # ###### End Hacks ########
+
+
+      enemy_token = discover_enemy_token(board)
+      # Better here, but we do it above for our speed hacks.
+      #open_spots = get_open_spots(board)
+      games = Hash.new
+
+      open_spots.each do |i|
+        board_copy = board.create_copy
+        board_copy.place(token, i)
+        game = Game.new(board_copy, AI.new(enemy_token), AI.new(token))
+        if game.winner == token
+          board.place(token, i)
+          return i
+        end
+        games[i] = game
+      end
+
+      scores = Hash.new
+
+      games.each do |i, game|
+        game.play
+        scores[i] = 1 if game.winner == token
+        scores[i] = -1 if game.winner == enemy_token
+        scores[i] = 0 if game.winner.nil? and game.game_over?
+      end
+
+      max = scores.max_by { |k, v| v }
+      spot = max[0]
+      board.place(token, spot)
+      spot
+    end
+
+
+
+    private
+    # TODO:  Messy, reconsider this later.
+    # Determine the enemy token.
+    # Anything we find on the board that is not our token is considered the 'enemy_token'
+    # We assume there is only one enemy token.
+    # If we do not find any enemy tokens on the board, we assume the enemy token to be 'O',
+    #   or we assume it to be 'X' if our own token is 'O'.
+    def discover_enemy_token(board)
+      enemy_token = nil
+      (0..Board::BOARD_SIZE-1).each do |i|
+        enemy_token = board[i] if board[i] != token and board[i] != nil
+      end
+      if enemy_token.nil?
+        enemy_token = token == :X ? :O : :X
+      end
+      enemy_token
+    end
+
+    def get_open_spots(board)
+      open_spots = Array.new
+      (0..Board::BOARD_SIZE-1).each do |i|
+        open_spots.push(i) if board[i].nil?
+      end
+      open_spots
+    end
+
+  end
+end

data/lib/tictactoe_j8th/board.rb

@@ -0,0 +1,63 @@
+module TictactoeJ8th
+  class Board
+    BOARD_SIZE = 9
+    BOARD_LINES = [
+      [0, 1, 2],
+      [3, 4, 5],
+      [6, 7, 8],
+
+      [0, 3, 6],
+      [1, 4, 7],
+      [2, 5, 8],
+
+      [0, 4, 8],
+      [2, 4, 6]
+    ]
+
+    def initialize
+      @board = Array.new(BOARD_SIZE)
+    end
+
+    def empty?
+      board.all? { |value| value.nil? }
+    end
+
+    def place(item, position)
+      board[position] = item if board[position].nil?
+    end
+
+    def full?
+      return false if board.include? nil
+      true
+    end
+
+    def [](spot)
+      board[spot]
+    end
+
+    def lines
+      array = []
+      BOARD_LINES.each do |line|
+        hash = {}
+        line.each do |i|
+          hash[i] = board[i]
+        end
+        array.push(hash)
+      end
+      array
+    end
+
+    def set_board(array)
+      @board = array
+    end
+
+    def create_copy
+      copy = Board.new
+      copy.set_board(@board.dup)
+      copy
+    end
+
+    private
+    attr_accessor :board
+  end
+end

data/lib/tictactoe_j8th/game.rb

@@ -0,0 +1,47 @@
+module TictactoeJ8th
+  class Game
+
+    attr_reader :board
+
+    def initialize(board, player1, player2)
+      @board = board
+      @player1 = player1
+      @player2 = player2
+
+      @playerup = @player1
+    end
+
+    def game_over?
+      return true if @board.full? or not winner.nil?
+      false
+    end
+
+    def winner
+      @board.lines.each do |line|
+        return @player1.token if line.values.all? { |v| v == @player1.token }
+        return @player2.token if line.values.all? { |v| v == @player2.token }
+      end
+      nil
+    end
+
+    def turn(spot = nil)
+      if spot.nil?
+        spot = @playerup.move(@board)
+      else
+        @board.place(@playerup.token, spot)
+      end
+      @playerup = @playerup == @player1 ? @player2 : @player1
+      spot
+    end
+
+    def play
+      turn
+      play unless game_over?
+    end
+
+    def player_up
+      
+    end
+
+  end
+end

data/lib/tictactoe_j8th/human.rb

@@ -0,0 +1,11 @@
+module TictactoeJ8th
+  class Human
+
+    attr_reader :token
+
+    def initialize(token)
+      @token = token
+    end
+
+  end
+end

data/lib/tictactoe_j8th/version.rb

@@ -0,0 +1,3 @@
+module TictactoeJ8th
+  VERSION = "0.2.0"
+end

data/lib/tictactoe_j8th.rb

@@ -0,0 +1,10 @@
+require "tictactoe_j8th/version"
+
+require "tictactoe_j8th/ai"
+require "tictactoe_j8th/board"
+require "tictactoe_j8th/game"
+require "tictactoe_j8th/human"
+
+module TictactoeJ8th
+  # Any extra module methods here, of which there are none now.
+end

data/spec/ai_spec.rb

@@ -0,0 +1,136 @@
+require 'tictactoe_j8th/board'
+require 'tictactoe_j8th/game'
+require 'tictactoe_j8th/ai'
+
+include TictactoeJ8th
+
+describe 'AI' do
+
+  let(:board) { Board.new }
+  let(:ai1) { AI.new(:X) }
+  let(:ai2) { AI.new(:O) }
+
+  context '#initialize' do
+    it 'Sets a token for the AI.' do
+      ai = AI.new(:O)
+      expect(ai.token).to eq(:O)
+    end
+  end
+
+  context '#move' do
+    it 'makes a move on a board.' do
+      ai1.move(board)
+      expect(board.empty?).to eq(false)
+    end
+
+    it 'makes a move on a non-empty board' do
+      board.place(ai1.token, 0)
+      board.place(ai2.token, 4)
+      board.place(ai1.token, 2)
+
+      ai1.move(board)
+
+      tokens = []
+      (0..8).each do |i|
+        tokens.push(board[i]) unless board[i].nil?
+      end
+
+      expect(tokens.count).to eq(4)
+    end
+
+    it 'blocks a win for the opposing player.' do
+      # No, this is a state where ai2 has already won, so it is not
+      # reasonable to expect the AI to move in space 8.
+      #board = Board.new
+      #board.place(ai2.token, 0)
+      #board.place(ai1.token, 1)
+      #board.place(ai2.token, 4)
+      #ai1.move(board)
+      #expect(board[8]).to eq(ai1.token)
+
+      # Nope, this one too!
+      #board.place(ai1.token, 0)
+      #board.place(ai2.token, 3)
+      #board.place(ai1.token, 1)
+      #ai2.move(board)
+      #expect(board[2]).to eq(ai2.token)
+
+      # Finally, a reasonable test.
+      board.place(ai1.token, 4)
+      board.place(ai2.token, 0)
+      board.place(ai1.token, 5)
+      ai2.move(board)
+      expect(board[3]).to eq(ai2.token)
+      # And another this test keeps going.
+      # Each move is a block, so we should reasonable expect 2 AI's
+      # to play the game out this way.
+      ai1.move(board)
+      expect(board[6]).to eq(ai1.token)
+      ai2.move(board)
+      expect(board[2]).to eq(ai2.token)
+      ai1.move(board)
+      expect(board[1]).to eq(ai1.token)
+      ai2.move(board)
+      expect(board[7]).to eq(ai2.token)
+
+    end
+
+    it 'takes a win for itself' do
+      board.place(ai1.token, 0)
+      board.place(ai1.token, 1)
+      board.place(ai2.token, 3)
+      ai1.move(board)
+      expect(board[2]).to eq(ai1.token)
+
+      board = Board.new
+      board.place(ai1.token, 4)
+      board.place(ai1.token, 3)
+      board.place(ai2.token, 6)
+      ai1.move(board)
+      expect(board[5]).to eq(ai1.token)
+    end
+
+    it 'takes a win before it takes a block' do
+      board.place(ai1.token, 2)
+      board.place(ai1.token, 5)
+      board.place(ai2.token, 1)
+      board.place(ai2.token, 4)
+      ai1.move(board)
+      expect(board[8]).to eq(ai1.token)
+    end
+
+    it 'returns the spot where the ai chose to move' do
+      spot = ai1.move(board)
+      found = nil
+      (0..Board::BOARD_SIZE-1).each do |i|
+        found = i if board[i] == ai1.token
+      end
+      expect(spot).to eq(found)
+    end
+
+    # This test written to fix a bug where the spot moved was not returned if it was the last move of the game.
+    it 'returns the spot where the ai chose to move on the last move of the game' do
+      board.place(ai1.token, 4)
+      board.place(ai2.token, 1)
+      board.place(ai1.token, 0)
+      board.place(ai2.token, 2)
+      spot = ai1.move(board)
+      expect(spot).to eq(8)
+    end
+  end
+
+
+  context 'Comprehensive AI Testing.  (AI vs AI)', :slow => true do
+    it 'never loses.  This means that the result of every game between two AI\'s is a draw.' do
+      100.times do
+        board = Board.new
+        ai1 = AI.new(:X)
+        ai2 = AI.new(:O)
+        game = Game.new(board, ai1, ai2)
+        game.play
+        expect(game.winner).to be_nil
+        expect(game.game_over?).to eq(true)
+      end
+    end
+  end
+end

data/spec/board_spec.rb

@@ -0,0 +1,85 @@
+require 'tictactoe_j8th/board'
+
+include TictactoeJ8th
+
+def fill_board
+  9.times { |i| board.place(:X, i) }
+end
+
+describe Board do
+  let(:board) { Board.new }
+
+  context '#place' do
+    it 'places the mark at position 0' do
+      board.place(:something, 0)
+      expect(board[0]).to eq(:something)
+    end
+
+    it 'places the mark at position 1 and returns true' do
+      expect(board.place(:something, 1)).to eq(:something)
+      expect(board[1]).to eq(:something)
+    end
+
+    it 'does not place the mark if taken and returns false' do
+      board.place(:something, 1)
+      expect(board.place(:something_else, 1)).to be_nil
+      expect(board[1]).to eq(:something)
+    end
+  end
+
+  context '#empty?' do
+    it 'returns true when the board is empty' do
+      expect(board.empty?).to eq(true)
+    end
+
+    it 'returns false when the board is not empty' do
+      board.place(:something, 0)
+      expect(board.empty?).to eq(false)
+    end
+  end
+
+  context '#full?' do
+    it 'returns false with a new board' do
+      expect(board.full?).to eq(false)
+    end
+
+    it 'returns true when the board is full.' do
+      fill_board
+      expect(board.full?).to eq(true)
+    end
+
+    it 'does NOT return true just because we fill the last spot on the board.  (it returns false)' do
+      board.place(:X, 8)
+      expect(board.full?).to eq(false)
+    end
+  end
+
+  context '#[]' do
+    it 'Gets the value of the given spot' do
+      board.place('X', 0)
+      expect(board[0]).to eq('X')
+    end
+  end
+
+  context '#lines' do
+    it 'returns all the lines for a given board' do
+      board.place('X', 0)
+      board.place('X', 3)
+      board.place('O', 4)
+      expect(board.lines).to eq(
+        [
+          {0 => 'X', 1 => nil, 2 => nil},
+          {3 => 'X', 4 => 'O', 5 => nil},
+          {6 => nil, 7 => nil, 8 => nil},
+
+          {0 => 'X', 3 => 'X', 6 => nil},
+          {1 => nil, 4 => 'O', 7 => nil},
+          {2 => nil, 5 => nil, 8 => nil},
+
+          {0 => 'X', 4 => 'O', 8 => nil},
+          {2 => nil, 4 => 'O', 6 => nil}
+        ]
+      )
+    end
+  end
+end

data/spec/game_spec.rb

@@ -0,0 +1,141 @@
+require 'tictactoe_j8th/game'
+require 'tictactoe_j8th/board'
+require 'tictactoe_j8th/ai'
+
+include TictactoeJ8th
+
+def count_tokens(player, board)
+  tokens = []
+  (0..Board::BOARD_SIZE).each do |i|
+    tokens.push(board[i]) if board[i] == player.token
+  end
+  tokens.count
+end
+
+describe Game do
+  let(:board) { Board.new }
+  let(:player1) { AI.new(:X) }
+  let(:player2) { AI.new(:O) }
+  let(:game)  { Game.new(board, player1, player2) }
+
+  context '#game_over?' do
+    it 'returns false for a game with a new board' do
+      expect(game.game_over?).to eq(false)
+    end
+
+    it 'returns true for a game with a winner' do
+      board.place(player1.token, 0)
+      board.place(player1.token, 1)
+      board.place(player1.token, 2)
+
+      expect(game.game_over?).to eq(true)
+    end
+
+    it 'returns true for a draw game' do
+      # X O X
+      # X O O
+      # O X X
+      board.place(player1.token, 0)
+      board.place(player2.token, 1)
+      board.place(player1.token, 2)
+
+      board.place(player1.token, 3)
+      board.place(player2.token, 4)
+      board.place(player2.token, 5)
+
+      board.place(player2.token, 6)
+      board.place(player1.token, 7)
+      board.place(player1.token, 8)
+
+      expect(game.game_over?).to eq(true)
+    end
+  end
+
+  context '#winner' do
+    it 'returns nil when there is no winner' do
+      expect(game.winner).to be_nil
+    end
+
+    [
+      [0, 1, 2],
+      [3, 4, 5],
+      [6, 7, 8],
+
+      [0, 3, 6],
+      [1, 4, 7],
+      [2, 5, 8],
+
+      [0, 4, 8],
+      [2, 4, 6]
+    ].each do |(a, b, c)|
+      it ":X is the winner when its marks are at (#{a}, #{b}, #{c})" do
+        board.place(:X, a)
+        board.place(:X, b)
+        board.place(:X, c)
+        expect(game.winner).to eq(:X)
+      end
+    end
+  end
+
+  context '#turn' do
+    it 'makes a player move on the board' do
+      game.turn
+      expect(board.empty?).to eq(false)
+    end
+
+    it 'makes the player move in the given spot, if a spot is given' do
+      game.turn(3)
+      expect(board[3]).to eq(player1.token)
+
+      game.turn(1)
+      expect(board[1]).to eq(player2.token)
+
+      game.turn(5)
+      expect(board[5]).to eq(player1.token)
+    end
+
+    it 'alternates players across invocations' do
+      game.turn
+      expect(count_tokens(player1, board)).to eq(1)
+
+      game.turn
+      expect(count_tokens(player2, board)).to eq(1)
+
+      game.turn
+      expect(count_tokens(player1, board)).to eq(2)
+      expect(count_tokens(player2, board)).to eq(1)
+
+      game.turn
+      expect(count_tokens(player1, board)).to eq(2)
+      expect(count_tokens(player2, board)).to eq(2)
+    end
+
+    # May be unnecessary, but very explicit?
+    it 'starts with player1' do
+      game.turn
+      expect(count_tokens(player1, board)).to eq(1)
+      expect(count_tokens(player2, board)).to eq(0)
+    end
+
+    it 'returns the spot where the player moved' do
+      spot = game.turn()
+      found = nil
+      (0..Board::BOARD_SIZE-1).each do |i|
+        found = i if not game.board[i].nil?
+      end
+      expect(spot).to eq(found)
+
+      game = Game.new(Board.new, AI.new(:X), AI.new(:O))
+      spot = game.turn(7)
+      expect(spot).to eq(7)
+    end
+  end
+
+  context '#play' do
+    it 'takes turns until the game is over' do
+      game.play
+      expect(game.game_over?).to eq(true)
+    end
+  end
+
+end

data/spec/human_spec.rb

@@ -0,0 +1,11 @@
+require 'tictactoe_j8th/human'
+require 'tictactoe_j8th/board'
+
+include TictactoeJ8th
+
+describe 'Human' do
+
+  let(:board)   { Board.new }
+  let(:human)   { Human.new(:X) }
+
+end

data/spec/spec_helper.rb

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

data/tictactoe_j8th.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tictactoe_j8th/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tictactoe_j8th"
+  spec.version       = TictactoeJ8th::VERSION
+  spec.authors       = ["j8th"]
+  spec.email         = ["jgoodman@8thlight.com"]
+  spec.summary       = %q{TicTacToe game logic with an unbeatable AI.}
+  spec.description   = %q{A gem encapsulating the logic of a tic tac toe game with an unbeatable AI.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.1"
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: tictactoe_j8th
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- j8th
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: A gem encapsulating the logic of a tic tac toe game with an unbeatable
+  AI.
+email:
+- jgoodman@8thlight.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/tictactoe_j8th.rb
+- lib/tictactoe_j8th/ai.rb
+- lib/tictactoe_j8th/board.rb
+- lib/tictactoe_j8th/game.rb
+- lib/tictactoe_j8th/human.rb
+- lib/tictactoe_j8th/version.rb
+- spec/ai_spec.rb
+- spec/board_spec.rb
+- spec/game_spec.rb
+- spec/human_spec.rb
+- spec/spec_helper.rb
+- tictactoe_j8th.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: TicTacToe game logic with an unbeatable AI.
+test_files:
+- spec/ai_spec.rb
+- spec/board_spec.rb
+- spec/game_spec.rb
+- spec/human_spec.rb
+- spec/spec_helper.rb