uci 0.0.2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.rvmrc

@@ -0,0 +1,2 @@
+rvm use 1.9.3@uci
+

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Matthew Nielsen
+
+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,238 @@
+# Ruby UCI - A Universal Chess Interface for Ruby
+
+The UCI gem allows for a much more ruby-like way of communicating with chess
+engines that support the UCI protocol.
+
+## Installation
+
+NOTE: No Chess engines are included. You must install an appropriate UCI-compatible engine first.
+
+Standard installation applies.  Either:
+
+    gem install uci
+
+..or, in a bundled project, add this line to your application's Gemfile:
+
+    gem 'uci'
+
+And then execute:
+
+    $ bundle
+
+## Example
+
+```ruby
+ require 'uci'
+
+  uci = Uci.new( :engine_path => '/usr/local/bin/stockfish' )
+
+  while !uci.ready? do
+    puts "Engine isn't ready yet, sleeping..."
+    sleep(1)
+  end
+
+  # this loop will make the engine play against itself.
+  loop do
+    puts "Move ##{uci.moves.size+1}."
+    puts uci.board # print ascii layout of current board.
+    uci.go!
+  end
+ ```
+
+## Docs
+
+### ::new(options = {})
+
+make a new connection to a UCI engine
+
+<pre>
+  Uci.new(
+    :engine_path => '/path/to/executable',
+    :debug => false, # true or false, default false
+    :name => "Name of engine", # optional
+    :movetime => 100, # max amount of time engine can "think" in ms - default 100
+    :options => { "Navalov Cache" => true } # optional configuration for engine
+  )
+</pre>
+
+### #bestmove()
+
+Ask the chess engine what the “best move” is given the current state of the
+internal chess board. This does not actiually execute a move, it simply queries
+for and returns what the engine would consider to be the best option available.
+
+### #board(empty_square_char = '.')
+
+ASCII-art representation of the current internal board.
+
+<pre>
+  > puts board
+    ABCDEFGH
+  8 r.bqkbnr
+  7 pppppppp
+  6 n.......
+  5 ........
+  4 .P......
+  3 ........
+  2 P.PPPPPP
+  1 RNBQKBNR
+</pre>
+
+### clear_position(position)
+
+Clear a position on the board, regardless of occupied state
+
+### engine_name()
+
+Return the current engine name
+
+### fenstring()
+
+Return the state of the interal board in a FEN (Forsyth–Edwards Notation)
+string, SHORT format (no castling info, move, etc).
+
+### get_piece(position)
+
+Get the details of a piece at the current position raises
+NoPieceAtPositionError if position is unoccupied.
+Returns array of [:piece, :player].
+
+<pre>
+  > get_piece(“a2”)
+  > [:pawn, :white]
+</pre>
+
+### go!()
+
+Tell the engine what the current board layout it, get its best move AND
+execute that move on the current board.
+
+### move_piece(move_string)
+
+Move a piece on the current interal board. Will raise NoPieceAtPositionError
+if source position is unoccupied. If destination is occipied, the occupying
+piece will be removed from the game.
+
+move_string is algebraic standard notation of the chess move. Shorthand is
+not allowed.
+
+<pre>
+  move_piece("a2a3") # Simple movement
+  move_piece("e1g1") # Castling (king’s rook white)
+  move_piece("a7a8q" # Pawn promomition (to Queen)
+</pre>
+
+Note that there is minimal rule checking here, illegal moves will be executed.
+
+### new_game!()
+
+Send “ucinewgame” to engine, reset interal board to standard starting layout.
+
+### new_game?()
+True if no moves have been recorded yet.
+
+### piece_at?(position)
+
+returns a boolean if a position is occupied
+
+<pre>
+  > piece_at?(“a2”)
+  > true
+  > piece_at?(“a3”)
+  > false
+</pre>
+
+### piece_name(p)
+
+Returns the piece name OR the piece icon, depending on that was passes.
+
+<pre>
+  > piece_name(:n)
+  > :knight
+  > piece_name(:queen)
+  > “q”
+</pre>
+
+### place_piece(player, piece, position)
+
+Place a piece on the board, regardless of occupied state.
+
+* player - symbol: :black or :white
+* piece - symbol: :pawn, :rook, etc
+* position - a2, etc
+
+<pre>
+  place_piece(:black, :rook, "h1")
+</pre>
+
+### ready?()
+
+True if engine is ready, false if not yet ready.
+
+### send_position_to_engine()
+
+Write board position information to the UCI engine, either the starting
+position and move log or the current FEN string, depending on how the
+board was set up.
+
+This does not tell the engine to execute a move.
+
+### set_board(fen)
+
+Set the board using Forsyth–Edwards Notation (FEN), LONG format including
+current player, castling, etc.
+
+
+* fen - rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1 (Please
+see en.wikipedia.org/wiki/Forsyth%E2%80%93Edwards_Notation)
+
+## Supported Engines
+
+In theory it can support any UCI-compatible engine (except for conditions outlined in the 'caveats' section).  It has been tested with:
+
+* Stockfish (Jan 11 2013 Github source)
+* Fruit 2.3.1 (Mac)
+
+## Caveats
+
+#### No move checking
+
+This gem assumes the engine knows what it's doing. If the gem wishes to place a illegal move it will be accepted.
+
+#### Unix-style Line endings are assumed.
+
+Current version assumes unix-style ("\n") line endings. That means running this under MS-DOS or Windows may barf.
+
+#### Very limited command set.
+
+Very few commands of the total UCI command set are currently supported. they are:
+
+* Starting a new game
+* Setting positions
+* Getting best move
+* Setting options
+
+It DOES NOT _yet_ support:
+
+* 'uci' command
+* ponder mode / infinite mode
+* ponderhit
+* registrations
+
+## Known Issues
+
+When connecting to more than one engine from the same code, there is a problem where their input streams get crosses. This is an issue with Open3, but for some reason turning "debug" on seems to mitigate it.
+
+Open3 is supposed to work under in Ruby 1.9.x in Windows, but this is currently untested.
+
+## Contributing
+
+Ruby UCI needs support for more features and to be tested with more chess
+engines.  To contribute to this project please fork the project and add/change
+any new code inside of a new branch:
+
+    git checkout -b my-new-feature
+
+Before committing and pushing code, please make sure all existing tests pass
+and that all new code has tests. Once that is verified, please push the changes
+and create a new pull request.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/uci.rb

@@ -0,0 +1,482 @@
+# The UCI gem allows for a much more ruby-like way of communicating with chess
+# engines that support the UCI protocol.
+
+require 'open3'
+require 'io/wait'
+
+class Uci
+  attr_reader :moves, :debug
+  attr_accessor :movetime
+  VERSION = "0.0.2"
+
+  RANKS = {
+    'a' => 0, 'b' => 1, 'c' => 2, 'd' => 3,
+    'e' => 4, 'f' => 5, 'g' => 6, 'h' => 7
+  }
+  PIECES = {
+    'p' => :pawn,
+    'r' => :rook,
+    'n' => :knight,
+    'b' => :bishop,
+    'k' => :king,
+    'q' => :queen
+  }
+
+  # make a new connection to a UCI engine
+  #
+  # ==== Options
+  #
+  # Required options:
+  # * :engine_path - path to the engine executable
+  #
+  # Optional options:
+  # * :debug - enable debugging messages - true /false
+  # * :name - name of the engine - string
+  # * :movetime - max amount of time the engine can "think" in ms - default 100
+  # * :options - hash to pass to the engine for configuration
+  def initialize(options = {})
+    options = default_options.merge(options)
+    require_keys!(options, [:engine_path, :movetime])
+    @movetime = options[:movetime]
+
+    set_debug(options)
+    reset_board!
+    set_startpos!
+
+    check_engine(options)
+    set_engine_name(options)
+    open_engine_connection(options[:engine_path])
+    set_engine_options(options[:options]) if !options[:options].nil?
+    new_game!
+  end
+
+  # true if engine is ready, false if not yet ready
+  def ready?
+    write_to_engine('isready')
+    read_from_engine == "readyok"
+  end
+
+  # send "ucinewgame" to engine, reset interal board to standard starting
+  # layout
+  def new_game!
+    write_to_engine('ucinewgame')
+    reset_board!
+    set_startpos!
+    @fen = nil
+  end
+
+  # true if no moves have been recorded yet
+  def new_game?
+    moves.empty?
+  end
+
+  # ask the chess engine what the "best move" is given the current state of
+  # the internal chess board. This does *not* actiually execute a move, it
+  # simply queries for and returns what the engine would consider to be the
+  # best option available.
+  def bestmove
+    write_to_engine("go movetime #{@movetime}")
+    until (move_string = read_from_engine).to_s.size > 1
+      sleep(0.25)
+    end
+    if move_string =~ /^bestmove/
+      if move_string =~ /^bestmove\sa1a1/ # fruit and rybka
+        raise EngineResignError, "Engine Resigns. Check Mate? #{move_string}"
+      elsif move_string =~ /^bestmove\sNULL/ # robbolita
+        raise NoMoveError, "No more moves: #{move_string}"
+      elsif move_string =~ /^bestmove\s\(none\)\s/ #stockfish
+        raise NoMoveError, "No more moves: #{move_string}"
+      elsif bestmove = move_string.match(/^bestmove\s([a-h][1-8][a-h][1-8])([a-z]{1}?)/)
+        return bestmove[1..-1].join
+      else
+        raise UnknownBestmoveSyntax, "Engine returned a 'bestmove' that I don't understand: #{move_string}"
+      end
+    else
+      raise ReturnStringError, "Expected return to begin with 'bestmove', but got '#{move_string}'"
+    end
+  end
+
+  # write board position information to the UCI engine, either the starting
+  # position + move log or the current FEN string, depending on how the board
+  # was set up.
+  def send_position_to_engine
+    if @fen
+      write_to_engine("position fen #{@fen}")
+    else
+      position_str = "position startpos"
+      position_str << " moves #{@moves.join(' ')}" unless @moves.empty?
+      write_to_engine(position_str)
+    end
+  end
+
+  # tell the engine what the current board layout it, get its best move AND
+  # execute that move on the current board.
+  def go!
+    send_position_to_engine
+    move_piece(bestmove)
+  end
+
+  # move a piece on the current interal board.
+  #
+  # ==== Attributes
+  # * move_string = algebraic standard notation of the chess move. Shorthand not allowed.
+  #
+  # Simple movement:              a2a3
+  # Castling (king's rook white): e1g1
+  # Pawn promomition (to Queen):  a7a8q
+  #
+  # Note that there is minimal rule checking here, illegal moves will be executed.
+  def move_piece(move_string)
+    raise BoardLockedError, "Board was set from FEN string" if @fen
+    (move, extended) = *move_string.match(/^([a-h][1-8][a-h][1-8])([a-z]{1}?)$/)[1..2]
+
+    start_pos = move.downcase.split('')[0..1].join
+    end_pos = move.downcase.split('')[2..3].join
+    (piece, player) = get_piece(start_pos)
+
+    place_piece(player, piece, end_pos)
+    clear_position(start_pos)
+
+    if extended.to_s.size > 0
+      if %w[q r b n].include?(extended)
+        place = move.split('')[2..3].join
+        p, player = get_piece(place)
+        log("pawn promotion: #{p} #{player}")
+        place_piece(player, piece_name(extended), place)
+      else
+        raise UnknownNotationExtensionError, "Unknown notation extension: #{move_string}"
+      end
+    end
+
+    # detect castling
+    if piece == :king
+      start_rank = start_pos.split('')[1]
+      start_file = start_pos.split('')[0].ord
+      end_file = end_pos.split('')[0].ord
+      if(start_file - end_file).abs > 1
+        # assume the engine knows the rook is present
+        if start_file < end_file # king's rook
+          place_piece(player, :rook, "f#{start_rank}")
+          clear_position("h#{start_rank}")
+        elsif end_file < start_file # queen's rook
+          place_piece(player, :rook, "d#{start_rank}")
+          clear_position("a#{start_rank}")
+        else
+          raise "Unknown castling behviour!"
+        end
+      end
+    end
+
+    @moves << move_string
+  end
+
+  # return the current movement log
+  def moves
+    @moves
+  end
+
+  # get the details of a piece at the current position
+  # raises NoPieceAtPositionError if position is unoccupied
+  #
+  # returns array of [:piece, :player]
+  #
+  # ==== Example
+  #
+  # > get_piece("a2")
+  # => [:pawn, :white]
+  def get_piece(position)
+    rank = RANKS[position.to_s.downcase.split('').first]
+    file = position.downcase.split('').last.to_i-1
+    piece = @board[file][rank]
+    if piece.nil?
+      raise NoPieceAtPositionError, "No piece at #{position}!"
+    end
+    player = if piece =~ /^[A-Z]$/
+      :white
+    else
+      :black
+    end
+    [piece_name(piece), player]
+  end
+
+  # returns a boolean if a position is occupied
+  #
+  # ==== Example
+  #
+  # > piece_at?("a2")
+  # => true
+  # > piece_at?("a3")
+  # => false
+  def piece_at?(position)
+    rank = RANKS[position.to_s.downcase.split('').first]
+    file = position.downcase.split('').last.to_i-1
+    !!@board[file][rank]
+  end
+
+  # Returns the piece name OR the piece icon, depending on that was passes.
+  #
+  # ==== Example
+  #
+  # > piece_name(:n)
+  # => :knight
+  # > piece_name(:queen)
+  # => "q"
+  def piece_name(p)
+    if p.class.to_s == "Symbol"
+      (p == :knight ? :night : p).to_s.downcase.split('').first
+    else
+      PIECES[p.downcase]
+    end
+  end
+
+  # clear a position on the board, regardless of occupied state
+  def clear_position(position)
+    raise BoardLockedError, "Board was set from FEN string" if @fen
+    rank = RANKS[position.to_s.downcase.split('').first]
+    file = position.downcase.split('').last.to_i-1
+    @board[file][rank] = nil
+  end
+
+  # place a piece on the board, regardless of occupied state
+  #
+  # ==== Attributes
+  # * player - symbol: :black or :white
+  # * piece - symbol: :pawn, :rook, etc
+  # * position - a2, etc
+  def place_piece(player, piece, position)
+    raise BoardLockedError, "Board was set from FEN string" if @fen
+    rank_index = RANKS[position.downcase.split('').first]
+
+    file_index = position.split('').last.to_i-1
+    icon = (piece == :knight ? :night : piece).to_s.split('').first
+    (player == :black ? icon.downcase! : icon.upcase!)
+    @board[file_index][rank_index] = icon
+  end
+
+  # set the board using Forsyth–Edwards Notation (FEN), *LONG* format including
+  # move, castling, etc.
+  #
+  # ==== Attributes
+  # * fen - rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1 (Please
+  # see http://en.wikipedia.org/wiki/Forsyth%E2%80%93Edwards_Notation)
+  def set_board(fen)
+    # rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1
+    fen_pattern = /^[a-zA-Z0-9\/]+\s[bw]\s[kqKQ-]+\s[a-h0-8-]+\s\d+\s\d+$/
+    unless fen =~ fen_pattern
+      raise FenFormatError, "Fenstring not correct: #{fen}. Expected to match #{fen_pattern}"
+    end
+    reset_board!
+    fen.split(' ').first.split('/').reverse.each_with_index do |rank, rank_index|
+      file_index = 0
+      rank.split('').each do |file|
+        if file.to_i > 0
+          file_index += file.to_i
+        else
+          @board[rank_index][file_index] = file
+          file_index += 1
+        end
+      end
+    end
+    new_game!
+    @fen = fen
+    send_position_to_engine
+  end
+
+  # return the state of the interal board in a FEN (Forsyth–Edwards Notation)
+  # string, *SHORT* format (no castling info, move, etc)
+  def fenstring
+    fen = []
+    (@board.size-1).downto(0).each do |rank_index|
+      rank = @board[rank_index]
+      if rank.include?(nil)
+        if rank.select{|r|r.nil?}.size == 8
+          fen << 8
+        else
+          rank_str = ""
+          empties = 0
+          rank.each do |r|
+            if r.nil?
+              empties += 1
+            else
+              if empties > 0
+                rank_str << empties.to_s
+                empties = 0
+              end
+              rank_str << r
+            end
+          end
+          rank_str << empties.to_s if empties > 0
+          fen << rank_str
+        end
+      else
+        fen << rank.join('')
+      end
+    end
+    fen.join('/')
+  end
+
+  # ASCII-art representation of the current internal board.
+  #
+  # ==== Example
+  #
+  # > puts board
+  #   ABCDEFGH
+  # 8 r.bqkbnr
+  # 7 pppppppp
+  # 6 n.......
+  # 5 ........
+  # 4 .P......
+  # 3 ........
+  # 2 P.PPPPPP
+  # 1 RNBQKBNR
+  #
+  def board(empty_square_char = '.')
+    board_str = "  ABCDEFGH\n"
+    (@board.size-1).downto(0).each do |rank_index|
+      line = "#{rank_index+1} "
+      @board[rank_index].each do |cell|
+        line << (cell.nil? ? empty_square_char : cell)
+      end
+      board_str << line+"\n"
+    end
+    board_str
+  end
+
+
+  # return the current engine name
+  def engine_name
+    @engine_name
+  end
+
+protected
+
+  def set_engine_options(options)
+    options.each do |k,v|
+      write_to_engine("setoption name #{k} value #{v}")
+    end
+  end
+
+  def write_to_engine(message, send_cr=true)
+    log("\twrite_to_engine")
+    log("\t\tME:    \t'#{message}'")
+    if send_cr && message.split('').last != "\n"
+      @engine_stdin.puts message
+    else
+      @engine_stdin.print message
+    end
+  end
+
+  def read_from_engine(strip_cr=true)
+    log("\tread_from_engine") #XXX
+    response = ""
+    while @engine_stdout.ready?
+      unless (response = @engine_stdout.readline) =~ /^info/
+        log("\t\tENGINE:\t'#{response}'")
+      end
+    end
+    if strip_cr && response.split('').last == "\n"
+      response.chop
+    else
+      response
+    end
+  end
+
+private
+
+  def reset_move_record!
+    @moves = []
+  end
+
+  def reset_board!
+    @board = []
+    8.times do |x|
+      @board[x] ||= []
+      8.times do |y|
+        @board[x] << nil
+      end
+    end
+    reset_move_record!
+  end
+
+  def set_startpos!
+    %w[a b c d e f g h].each do |f|
+      place_piece(:white, :pawn, "#{f}2")
+      place_piece(:black, :pawn, "#{f}7")
+    end
+
+    place_piece(:white, :rook, "a1")
+    place_piece(:white, :rook, "h1")
+    place_piece(:white, :night, "b1")
+    place_piece(:white, :night, "g1")
+    place_piece(:white, :bishop, "c1")
+    place_piece(:white, :bishop, "f1")
+    place_piece(:white, :king, "e1")
+    place_piece(:white, :queen, "d1")
+
+    place_piece(:black, :rook, "a8")
+    place_piece(:black, :rook, "h8")
+    place_piece(:black, :night, "b8")
+    place_piece(:black, :night, "g8")
+    place_piece(:black, :bishop, "c8")
+    place_piece(:black, :bishop, "f8")
+    place_piece(:black, :king, "e8")
+    place_piece(:black, :queen, "d8")
+  end
+
+  def check_engine(options)
+    unless File.exist?(options[:engine_path])
+      raise EngineNotFoundError, "Engine not found at #{options[:engine_path]}"
+    end
+    unless File.executable?(options[:engine_path])
+      raise EngineNotExecutableError, "Engine at #{options[:engine_path]} is not executable"
+    end
+  end
+
+  def set_debug(options)
+    @debug = !!options[:debug]
+  end
+
+  def log(message)
+    puts "DEBUG (#{engine_name}): #{message}" if @debug
+  end
+
+  def open_engine_connection(engine_path)
+    @engine_stdin, @engine_stdout = Open3.popen2e(engine_path)
+  end
+
+  def require_keys!(hash, *required_keys)
+    required_keys.flatten.each do |required_key|
+      if !hash.keys.include?(required_key)
+        key_string = (required_key.is_a?(Symbol) ? ":#{required_key}" : required_key )
+        raise MissingRequiredHashKeyError, "Hash key '#{key_string}' missing"
+      end
+    end
+    true
+  end
+
+  def set_engine_name(options)
+    if options[:name].to_s.size > 1
+      @engine_name = options[:name]
+    else
+      @engine_name = options[:engine_path].split('/').last
+    end
+  end
+
+  def default_options
+    { :movetime => 100 }
+  end
+end
+
+class UciError < StandardError; end
+class MissingRequiredHashKeyError < StandardError; end
+class EngineNotFoundError < UciError; end
+class EngineNotExecutableError < UciError; end
+class EngineNameMismatch < UciError; end
+class ReturnStringError < UciError; end
+class UnknownNotationExtensionError < UciError; end
+class NoMoveError < UciError; end
+class EngineResignError < NoMoveError; end
+class NoPieceAtPositionError < UciError; end
+class UnknownBestmoveSyntax < UciError; end
+class FenFormatError < UciError; end
+class BoardLockedError < UciError; end

data/spec/lib/uci_spec.rb

@@ -0,0 +1,334 @@
+require 'spec_helper'
+require 'uci'
+
+describe Uci do
+  before(:each) do
+    Uci.any_instance.stub(:check_engine)
+    Uci.any_instance.stub(:open_engine_connection)
+    Uci.any_instance.stub(:get_engine_name)
+    Uci.any_instance.stub(:new_game!)
+  end
+
+  subject do
+    Uci.new(
+      :engine_path => '/usr/bin/stockfish',
+      :debug => true
+    )
+  end
+
+  describe "#initialize" do
+    let(:valid_options) do
+      { :engine_path => 'xxx' }
+    end
+    it "should be an instance of Uci" do
+      subject.should be_a_kind_of Uci
+    end
+    it "should require :engine_path' in the options hash" do
+      lambda { Uci.new({}) }.should raise_exception
+      lambda { Uci.new(valid_options) }.should_not raise_exception
+    end
+    it "should set debug mode" do
+      uci = Uci.new(valid_options)
+      uci.debug.should be_false
+
+      uci = Uci.new(valid_options.merge( :debug => true ))
+      uci.debug.should be_true
+    end
+  end
+
+  describe "#ready?" do
+    before(:each) do
+      subject.stub!(:write_to_engine).with('isready')
+    end
+
+    context "engine is ready" do
+      it "should be true" do
+        subject.stub!(:read_from_engine).and_return('readyok')
+
+        subject.ready?.should be_true
+      end
+    end
+
+    context "engine is not ready" do
+      it "should be false" do
+        subject.stub!(:read_from_engine).and_return('no')
+
+        subject.ready?.should be_false
+      end
+    end
+  end
+
+  describe "new_game?" do
+    context "game is new" do
+      it "should be true" do
+        subject.stub(:moves).and_return([])
+        subject.new_game?.should be_true
+      end
+    end
+    context "game is not new" do
+      it "should be false" do
+        subject.stub(:moves).and_return(%w[ a2a3 ])
+        subject.new_game?.should be_false
+      end
+    end
+  end
+
+  describe "#board" do
+    it "should return an ascii-art version of the current board" do
+      # starting position
+      subject.board.should == "  ABCDEFGH
+8 rnbqkbnr
+7 pppppppp
+6 ........
+5 ........
+4 ........
+3 ........
+2 PPPPPPPP
+1 RNBQKBNR
+"
+
+      # moves
+      subject.move_piece('b2b4')
+      subject.move_piece('b8a6')
+      subject.board.should == "  ABCDEFGH
+8 r.bqkbnr
+7 pppppppp
+6 n.......
+5 ........
+4 .P......
+3 ........
+2 P.PPPPPP
+1 RNBQKBNR
+"
+    end
+  end
+
+  describe "#fenstring" do
+    it "should return a short fenstring of the current board" do
+      # starting position
+      subject.fenstring.should == "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
+
+      # moves
+      subject.move_piece('b2b4')
+      subject.move_piece('b8a6')
+      subject.fenstring.should == "r1bqkbnr/pppppppp/n7/8/1P6/8/P1PPPPPP/RNBQKBNR"
+    end
+  end
+
+  describe "#set_board" do
+    it "should set the board layout from a passed LONG fenstring" do
+      # given
+      subject.stub!( :send_position_to_engine )
+      subject.set_board("r1bqkbnr/pppppppp/n7/8/1P6/8/P1PPPPPP/RNBQKBNR b KQkq - 0 1")
+      # expect
+      subject.fenstring.should == "r1bqkbnr/pppppppp/n7/8/1P6/8/P1PPPPPP/RNBQKBNR"
+    end
+    it "should raise an error is the passed fen format is incorret" do
+      # try to use a short fen where we neeed a long fen
+      lambda { subject.set_board("r1bqkbnr/pppppppp/n7/8/1P6/8/P1PPPPPP/RNBQKBNR") }.should raise_exception FenFormatError
+    end
+  end
+
+  describe "#place_piece" do
+    it "should place a piece on the board" do
+      subject.place_piece(:white, :queen, "a3")
+      subject.get_piece("a3").should == [:queen, :white]
+
+      subject.place_piece(:black, :knight, "a3")
+      subject.get_piece("a3").should == [:knight, :black]
+    end
+    it "should raise an error if the board was set from a fen string" do
+      subject.stub!(:send_position_to_engine)
+      subject.set_board("r1bqkbnr/pppppppp/n7/8/1P6/8/P1PPPPPP/RNBQKBNR b KQkq - 0 1")
+      lambda { subject.place_piece(:black, :knight, "a3") }.should raise_exception BoardLockedError
+    end
+  end
+
+  describe "#clear_position" do
+    it "should clear a position on the board" do
+      # sanity
+      subject.get_piece("a1").should == [:rook, :white]
+      # given
+      subject.clear_position("a1")
+      # expect
+      subject.piece_at?("a1").should be_false
+    end
+    it "should raise an error if the board was set from a fen string" do
+      subject.stub!(:send_position_to_engine)
+      subject.set_board("r1bqkbnr/pppppppp/n7/8/1P6/8/P1PPPPPP/RNBQKBNR b KQkq - 0 1")
+      lambda { subject.clear_position("a1") }.should raise_exception BoardLockedError
+    end
+  end
+
+  describe "#piece_name" do
+    context "symbol name passed" do
+      it "should return the single letter symbol" do
+        subject.piece_name(:queen).should == "q"
+        subject.piece_name(:knight).should == "n"
+      end
+    end
+    context "single letter symbol passes" do
+      it "should return the symbiol name" do
+        subject.piece_name('n').should == :knight
+        subject.piece_name('k').should == :king
+        subject.piece_name('q').should == :queen
+      end
+    end
+  end
+
+  describe "#piece_at?" do
+    it "should be true if there is a piece at the position indicated" do
+      # assume startpos
+      subject.piece_at?("a1").should be_true
+    end
+    it "should be false if there is not a piece at the position indicated" do
+      # assume startpos
+      subject.piece_at?("a3").should be_false
+    end
+  end
+
+  describe "#get_piece" do
+    it "should return the information for a piece at a given position" do
+      # assume startpos
+      subject.get_piece('a1').should == [:rook, :white]
+      subject.get_piece('h8').should == [:rook, :black]
+    end
+    it "should raise an exception if there is no piece at the given position" do
+      lambda { subject.get_piece('a3') }.should raise_exception NoPieceAtPositionError
+    end
+  end
+
+  describe "#moves" do
+    it "should return the interal move list" do
+      # startpos
+      subject.moves.should == []
+
+      # add some moves
+      subject.move_piece('a2a3'); subject.move_piece('a7a5')
+      subject.moves.should == ['a2a3', 'a7a5']
+    end
+  end
+
+  describe "#move_piece" do
+    before(:each) do
+      # sanity
+      subject.piece_at?("a2").should be_true
+      subject.piece_at?("a3").should be_false
+    end
+    it "should raise an error if the board was set from a fen string" do
+      subject.stub!(:send_position_to_engine)
+      subject.set_board("r1bqkbnr/pppppppp/n7/8/1P6/8/P1PPPPPP/RNBQKBNR b KQkq - 0 1")
+      lambda { subject.move_piece("a2a3") }.should raise_exception BoardLockedError
+    end
+    it "should move pieces from one position to another" do
+      piece = subject.get_piece("a2")
+      subject.move_piece("a2a3")
+      piece.should == subject.get_piece("a3")
+      subject.piece_at?("a2").should be_false
+    end
+    it 'it should overwrite pieces if one is moved atop another' do
+      # note this is an illegal move
+      piece = subject.get_piece("a1")
+      subject.move_piece("a1a2")
+      piece.should == subject.get_piece("a2")
+      subject.piece_at?("a1").should be_false
+    end
+    it "should raise an exception if the source position has no piece" do
+      lambda { subject.move_piece("a3a4") }.should raise_exception NoPieceAtPositionError
+    end
+    it "should promote a pawn to a queen at the correct rank with the correct notation" do
+      subject.move_piece("a2a8q")
+      subject.get_piece("a8").should == [:queen, :white]
+    end
+    it "should promote a pawn to a rook at the correct rank with the correct notation" do
+      subject.move_piece("a2a8r")
+      subject.get_piece("a8").should == [:rook, :white]
+    end
+    it "should promote a pawn to a knight at the correct rank with the correct notation" do
+      subject.move_piece("a2a8n")
+      subject.get_piece("a8").should == [:knight, :white]
+    end
+    it "should promote a pawn to a bishop at the correct rank with the correct notation" do
+      subject.move_piece("a2a8b")
+      subject.get_piece("a8").should == [:bishop, :white]
+    end
+    it "should raise an exception if promotion to unallowed piece" do
+      lambda { subject.move_piece("a2a8k") }.should raise_exception UnknownNotationExtensionError
+    end
+    it "should properly understand castling, white king's rook" do
+      subject.move_piece("e1g1")
+      subject.get_piece("f1").should == [:rook, :white]
+      subject.get_piece("g1").should == [:king, :white]
+    end
+    it "should properly understand castling, white queens's rook" do
+      subject.move_piece("e1c1")
+      subject.get_piece("d1").should == [:rook, :white]
+      subject.get_piece("c1").should == [:king, :white]
+    end
+    it "should properly understand castling, black king's rook" do
+      subject.move_piece("e8g8")
+      subject.get_piece("f8").should == [:rook, :black]
+      subject.get_piece("g8").should == [:king, :black]
+    end
+    it "should properly understand castling, black queens's rook" do
+      subject.move_piece("e8c8")
+      subject.get_piece("d8").should == [:rook, :black]
+      subject.get_piece("c8").should == [:king, :black]
+    end
+
+    it "should append the move to the move log" do
+      subject.moves.should be_empty
+      subject.move_piece("a2a3")
+      subject.moves.should == ["a2a3"]
+    end
+  end
+
+  describe "#new_game!" do
+    it "should tell the engine a new game is set" do
+      pending
+    end
+    it "should reset the internal board" do
+      pending
+    end
+    it "should set the pieces in a startpos" do
+      pending
+    end
+  end
+
+  describe "#bestmove" do
+    it "should write the bestmove command to the engine" do
+      pending
+    end
+    it "should detect various forfeit notations" do
+      pending
+    end
+    it "should raise and exception if the bestmove notation is not understood" do
+      pending
+    end
+    it "shpould raise and exception if the returned command was not prefixed with 'bestmove'" do
+      pending
+    end
+  end
+
+  describe "#send_position_to_engine" do
+    context "board was set from fen" do
+      it "should send a 'position fen' command" do
+        pending
+      end
+    end
+    context "the board is set from startpos" do
+      it "should set a 'position startpo' command followed by the move log" do
+        pending
+      end
+    end
+  end
+
+  describe "#go!" do
+    it "should send the currentn position to the engine" do
+      pending
+    end
+    it "should update the current board with the result of 'bestmove'" do
+      pending
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'simplecov'
+if ENV["COVERAGE"]
+  SimpleCov.start
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  # config.filter_run :focus
+
+  # 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'
+end

data/uci.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'uci'
+
+Gem::Specification.new do |gem|
+  gem.name          = "uci"
+  gem.version       = Uci::VERSION
+  gem.authors       = ["Matthew Nielsen"]
+  gem.email         = ["xunker@pyxidis.org"]
+  gem.description   = %q{Ruby library for the Universal Chess Interface (UCI)}
+  gem.summary       = %q{Ruby library for the Universal Chess Interface (UCI)}
+  gem.homepage      = "https://github.com/xunker/uci"
+
+  gem.required_ruby_version = '>= 1.9.1'
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.has_rdoc = true
+  gem.add_development_dependency('simplecov', '0.7.1')
+  gem.add_development_dependency('rspec', '2.12.0')
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: uci
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Matthew Nielsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+description: Ruby library for the Universal Chess Interface (UCI)
+email:
+- xunker@pyxidis.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/uci.rb
+- spec/lib/uci_spec.rb
+- spec/spec_helper.rb
+- uci.gemspec
+homepage: https://github.com/xunker/uci
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby library for the Universal Chess Interface (UCI)
+test_files:
+- spec/lib/uci_spec.rb
+- spec/spec_helper.rb