go_gtp 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+example/game.sgf
+pkg
+

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2-p0

data/README.markdown

@@ -0,0 +1,61 @@
+The Go Text Protocol
+====================
+
+This library wraps [GNU Go](http://www.gnu.org/software/gnugo/)'s version of the Go Text Protocol or GTP.  It runs GNU Go in a separate process and communicates with the program over a pipe using the GTP protocol.  This makes it easy to:
+
+* Manage full games of Go
+* Work with SGF files
+* Analyze Go positions
+
+Installing
+----------
+
+This library is available as a gem, so you can install it with a command like:
+
+    gem install go_gtp
+
+The above command may need super user privileges.
+
+This library requires an install of GNU Go to communicate with.  You will need to install that separately.
+
+Examples
+--------
+
+This code would load an SGF file and show the current state of the game in that file:
+
+    require "go/gtp"
+    
+    go = Go::GTP.run_gnugo
+    go.loadsgf("game.sgf") or abort "Failed to load file"
+    puts go.showboard
+    go.quit
+
+This shows the two main types of GTP methods.  Methods like `showboard()` return the indicated content.  In this case, you actually get back a `Go::GTP::Board` object which can indexed into, or just converted into a `String` for display as it is used here.
+
+Other methods, like `loadsgf()`, are just called for their side effects and they don't return anything.  For these, you get a boolean result telling you if the call succeeded (`true`) or triggered an error (`false`).  You can always check the `success?()` of either type of call after the fact and retrieve the `last_error()` when there is one, so these return values are just a convenience.  As another convenience, these boolean methods can be called with Ruby's query syntax as well:  `loadsgf?()`.
+
+When working with a GNU Go process, it's a good idea to remember to call `quit()` so the pipe can be closed.  One way to ensure that happens is to use the block form of `run_gnugo()` to have it done for you.  Given that, the following example is another way to handle loading and displaying a game:
+
+    require "go/gtp"
+    
+    Go::GTP.run_gnugo do |go|
+      go.loadsgf?("game.sgf") or abort "Failed to load file"
+      puts go.showboard
+    end  # quit called automatically after this block
+
+You can customize how GNU Go is invoked, by passing parameters to `run_gnugo()`.  Probably the two most useful are the `:directory` where the executable lives and any `:arguments` you would like to pass it.  For example:
+
+    require "go/gtp"
+    
+    go = Go::GTP.run_gnugo( directory: "/usr/local/bin",
+                            arguments: "--boardsize 9" )
+    # ...
+
+Of course, you could also set the board size after the connection is open with `go.boardsize(9)`.
+
+See the [example directory](http://github.com/JEG2/go_gtp/tree/master/example/) for more ideas about how to use this library.
+
+GTP Commands
+------------
+
+The method names are literally the command names right out of [the GTP documentation](http://www.gnu.org/software/gnugo/gnugo_19.html#SEC200).  That's intended to make it easy to figure out what you can do with this library.  Return values are Rubified into nice objects, when it makes sense to do so.

data/Rakefile

@@ -0,0 +1,14 @@
+require "rake"
+require "spec/rake/spectask"
+require "rake/gempackagetask"
+
+task :default => :spec
+
+Spec::Rake::SpecTask.new do |rspec|
+  rspec.warning = true
+end
+
+load(File.join(File.dirname(__FILE__), "go_gtp.gemspec"))
+Rake::GemPackageTask.new(SPEC) do |package|
+  # do nothing:  I just need a gem but this block is required
+end

data/TODO

@@ -0,0 +1,4 @@
+To Do
+
+* Support the rest of the GTP commands GNU Go provides
+* Add documentation

data/example/create_game.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), *%w[.. lib])
+require "go/gtp"
+
+abort "USAGE:  #{$PROGRAM_NAME} BOARD_SIZE_INT" unless ARGV.first =~ /\A\d+\z/
+
+Go::GTP.run_gnugo do |go|
+  go.boardsize(ARGV.first) or abort "Invalid board size"
+  go.clear_board
+  go.printsgf(File.join(File.dirname(__FILE__), "game.sgf"))
+end

data/example/generate_move.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), *%w[.. lib])
+require "go/gtp"
+
+GAME_FILE = File.join(File.dirname(__FILE__), "game.sgf")
+
+Go::GTP.run_gnugo do |go|
+  color = go.loadsgf(GAME_FILE)
+  puts go.genmove(color)
+  go.printsgf(GAME_FILE)
+end

data/example/play_all.rb

@@ -0,0 +1,23 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), *%w[.. lib])
+require "go/gtp"
+
+abort "USAGE:  #{$PROGRAM_NAME} BOARD_SIZE_INT" unless ARGV.first =~ /\A\d+\z/
+
+# this script is handy for measuring performance
+
+start  = Time.now
+colors = %w[black white].cycle
+Go::GTP.run_gnugo do |go|
+  go.boardsize(ARGV.first) or abort "Invalid board size"
+  go.clear_board
+  1.upto(19) do |row|
+    ("A".."T").each do |column|
+      next if column == "I"
+      move = "#{column}#{row}"
+      next if move == "T19" # illegal move
+      go.play(colors.next, move) or abort "Invalid move #{move}"
+    end
+  end
+  puts go.showboard
+end
+puts "Total time:  #{Time.now - start} seconds"

data/example/play_go.rb

@@ -0,0 +1,40 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), *%w[.. lib])
+require "go/gtp"
+
+class IllegalMoveError < RuntimeError; end
+
+COLORS  = %w[black white]
+PLAYERS = Hash[COLORS.zip(%w[computer player].sample(2))]
+
+begin
+  Go::GTP.run_gnugo(arguments: ARGV.empty? ? nil : ARGV) do |go|
+    COLORS.cycle do |color|
+      puts go.showboard
+      abort "Error:  failed to show board" unless go.success?
+      move = nil
+      case PLAYERS[color]
+      when "player"
+        begin
+          print "Move for #{color}?  "
+          move = $stdin.gets.to_s.strip
+          unless move =~ /\S/ and go.is_legal?(color, move)
+            raise IllegalMoveError, "Illegal move"
+          end
+          go.play?(color, move) or abort "Error:  move failed"
+        rescue IllegalMoveError => error
+          puts error.message
+          retry
+        end
+      when "computer"
+        move = go.genmove(color)
+        abort "Error:  failed to generate move" unless go.success?
+        puts "Move for #{color}:  #{move}"
+      end
+      puts
+      break if go.over?
+    end
+    puts "Final score:  #{go.final_score}"
+  end
+rescue Errno::EPIPE
+  abort "Error:  bad arguments"
+end

data/example/play_move.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), *%w[.. lib])
+require "go/gtp"
+
+abort "USAGE:  #{$PROGRAM_NAME} MOVE" unless ARGV.first =~ /\A[A-Z]\d+\z/i
+
+GAME_FILE = File.join(File.dirname(__FILE__), "game.sgf")
+
+Go::GTP.run_gnugo do |go|
+  color = go.loadsgf(GAME_FILE)
+  go.play(color, ARGV.first) or abort "Invalid move for #{color}"
+  go.printsgf(GAME_FILE)
+end

data/example/show_board.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), *%w[.. lib])
+require "go/gtp"
+
+Go::GTP.run_gnugo do |go|
+  go.loadsgf(File.join(File.dirname(__FILE__), "game.sgf"))
+  puts go.showboard
+end

data/go_gtp.gemspec

@@ -0,0 +1,31 @@
+DIR     = File.dirname(__FILE__)
+LIB     = File.join(DIR, *%w[lib go gtp.rb])
+VERSION = open(LIB) { |lib|
+  lib.each { |line|
+    if v = line[/^\s*VERSION\s*=\s*(['"])(\d\.\d\.\d)\1/, 2]; break v end
+  }
+}
+
+SPEC = Gem::Specification.new do |s|
+  s.name        = "go_gtp"
+  s.version     = VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["James Edward Gray II", "Ryan Bates"]
+  s.email       = ["james@graysoftinc.com"]
+  s.homepage    = "http://github.com/JEG2/go_gtp"
+  s.summary     = "A wrapper for GNU Go's Go Text Protocol (GTP)."
+  s.description = <<-END_DESCRIPTION.gsub(/\s+/, " ").strip
+  This library runs GNU Go in a separate process and allows you to communicate
+  with it using the Go Text Protocol (GTP).  This makes it easy to manage full
+  games of Go, work with SGF files, analyze Go positions, and more.
+  END_DESCRIPTION
+
+  s.required_rubygems_version = "~> 1.9.2"
+  s.required_rubygems_version = "~> 1.3.6"
+
+  s.add_development_dependency "rspec"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*_spec.rb`.split("\n")
+  s.require_paths = %w[lib]
+end

data/lib/go/gtp.rb

@@ -0,0 +1,485 @@
+require "go/gtp/board"
+
+module Go
+  class GTP
+    VERSION = "0.0.1"
+    
+    def self.run_gnugo(options = { }, &commands)
+      directory    = options.fetch(:directory,    nil)
+      command      = options.fetch(:command,      "gnugo --mode gtp")
+      arguments    = options.fetch(:arguments,    nil)
+      redirections = options.fetch(:redirections, "2>&1")
+      path         = [ File.join(*[directory, command].compact),
+                       arguments,
+                       redirections ].compact.join(" ")
+
+      new(IO.popen(path, "r+"), &commands)
+    end
+    
+    def initialize(io)
+      @io         = io
+      @id         = 0
+      @last_error = nil
+      
+      if block_given?
+        begin
+          yield self
+        ensure
+          quit
+        end
+      end
+    end
+    
+    attr_reader :last_error
+    
+    def success?
+      @last_error.nil?
+    end
+    
+    def quit
+      send_command(:quit)
+      @io.close
+      success?
+    end
+    alias_method :quit?, :quit
+    
+    def protocol_version
+      send_command(:protocol_version)
+    end
+    
+    def name
+      send_command(:name)
+    end
+    
+    def version
+      send_command(:version)
+    end
+    
+    def boardsize(boardsize)
+      send_command(:boardsize, boardsize)
+      success?
+    end
+    alias_method :boardsize?, :boardsize
+    
+    def query_boardsize
+      send_command(:query_boardsize)
+    end
+    
+    def clear_board
+      send_command(:clear_board)
+      success?
+    end
+    alias_method :clear_board?, :clear_board
+    
+    def orientation(orientation)
+      send_command(:orientation, orientation)
+      success?
+    end
+    alias_method :orientation?, :orientation
+    
+    def query_orientation
+      send_command(:query_orientation)
+    end
+    
+    def komi(komi)
+      send_command(:komi, komi)
+      success?
+    end
+    alias_method :komi?, :komi
+    
+    def get_komi
+      send_command(:get_komi)
+    end
+    
+    def play(color, vertex)
+      send_command(:play, color, vertex)
+      success?
+    end
+    alias_method :play?, :play
+    
+    def replay(vertices)
+      colors = %w[black white].cycle
+      vertices.each do |vertex|
+        play(colors.next, vertex)
+        return success? unless success?
+      end
+      success?
+    end
+    alias_method :replay?, :replay
+    
+    def fixed_handicap(number_of_stones)
+      extract_vertices(send_command(:fixed_handicap, number_of_stones))
+    end
+    
+    def place_free_handicap(number_of_stones)
+      extract_vertices(send_command(:place_free_handicap, number_of_stones))
+    end
+    
+    def set_free_handicap(*vertices)
+      send_command(:set_free_handicap, *vertices)
+      success?
+    end
+    alias_method :set_free_handicap?, :set_free_handicap
+    
+    def get_handicap
+      send_command(:get_handicap)
+    end
+    
+    def loadsgf(path, move_number_or_vertex = nil)
+      send_command(:loadsgf, *[path, move_number_or_vertex].compact)
+    end
+    
+    def color(vertex)
+      extract_color(send_command(:color, vertex))
+    end
+    
+    def list_stones(color)
+      extract_vertices(send_command(:list_stones, color))
+    end
+    
+    def countlib(vertex)
+      extract_integer(send_command(:countlib, vertex))
+    end
+    
+    def findlib(vertex)
+      extract_vertices(send_command(:findlib, vertex))
+    end
+    
+    def accuratelib(color, vertex)
+      extract_vertices(send_command(:accuratelib, color, vertex))
+    end
+    
+    def is_legal(color, vertex)
+      extract_boolean(send_command(:is_legal, color, vertex))
+    end
+    alias_method :is_legal?, :is_legal
+    
+    def all_legal(color)
+      extract_vertices(send_command(:all_legal, color))
+    end
+    
+    def captures(color)
+      extract_integer(send_command(:captures, color))
+    end
+    
+    def last_move
+      extract_move(send_command(:last_move))
+    end
+    
+    def move_history
+      extract_moves(send_command(:move_history))
+    end
+    
+    def over?
+      last_two_moves = move_history.first(2)
+      Array(last_two_moves.first).last.to_s.upcase         == "RESIGN" or
+      last_two_moves.map { |m| Array(m).last.to_s.upcase } == %w[PASS PASS]
+    end
+    
+    def invariant_hash
+      send_command(:invariant_hash)
+    end
+    
+    def invariant_hash_for_moves(color)
+      extract_moves(send_command(:invariant_hash_for_moves, color))
+    end
+    
+    def trymove(color, vertex)
+      send_command(:trymove, color, vertex)
+      success?
+    end
+    alias_method :trymove?, :trymove
+    
+    def tryko(color, vertex)
+      send_command(:tryko, color, vertex)
+      success?
+    end
+    alias_method :tryko?, :tryko
+    
+    def popgo
+      send_command(:popgo)
+      success?
+    end
+    alias_method :popgo?, :popgo
+    
+    def clear_cache
+      send_command(:clear_cache)
+      success?
+    end
+    alias_method :clear_cache?, :clear_cache
+    
+    # ...
+    
+    def increase_depths
+      send_command(:increase_depths)
+      success?
+    end
+    alias_method :increase_depths?, :increase_depths
+
+    def decrease_depths
+      send_command(:decrease_depths)
+      success?
+    end
+    alias_method :decrease_depths?, :decrease_depths
+    
+    # ...
+    
+    def unconditional_status(vertex)
+      send_command(:unconditional_status, vertex)
+    end
+    
+    # ...
+    
+    def genmove(color)
+      send_command(:genmove, color)
+    end
+    
+    def reg_genmove(color)
+      send_command(:reg_genmove, color)
+    end
+    
+    def gg_genmove(color, random_seed = nil)
+      send_command(:gg_genmove, *[color, random_seed].compact)
+    end
+    
+    def restricted_genmove(color, *vertices)
+      send_command(:restricted_genmove, color, *vertices)
+    end
+    
+    def kgs_genmove_cleanup(color)
+      send_command(:kgs_genmove_cleanup, color)
+    end
+    
+    def level(level)
+      send_command(:level, level)
+      success?
+    end
+    alias_method :level?, :level
+    
+    def undo
+      send_command(:undo)
+      success?
+    end
+    alias_method :undo?, :undo
+    
+    def gg_undo(moves = nil)
+      send_command(:gg_undo, *[moves].compact)
+      success?
+    end
+    alias_method :gg_undo?, :gg_undo
+    
+    def time_settings(main_time, byo_yomi_time, byo_yomi_stones)
+      send_command(:time_settings, main_time, byo_yomi_time, byo_yomi_stones)
+      success?
+    end
+    alias_method :time_settings?, :time_settings
+    
+    def time_left(color, time, stones)
+      send_command(:time_left, color, time, stones)
+      success?
+    end
+    alias_method :time_left?, :time_left
+    
+    def final_score(random_seed = nil)
+      send_command(:final_score, *[random_seed].compact)
+    end
+    
+    def final_status(vertex, random_seed = nil)
+      send_command(:final_status, *[vertex, random_seed].compact)
+    end
+    
+    def final_status_list(status, random_seed = nil)
+      extract_vertices( send_command( :final_status_list,
+                                      *[status, random_seed].compact ) )
+    end
+    
+    def estimate_score
+      send_command(:estimate_score)
+    end
+    
+    def experimental_score(color)
+      send_command(:experimental_score, color)
+    end
+    
+    def reset_owl_node_counter
+      send_command(:reset_owl_node_counter)
+      success?
+    end
+    alias_method :reset_owl_node_counter?, :reset_owl_node_counter
+    
+    def get_owl_node_counter
+      send_command(:reset_owl_node_counter)
+    end
+    
+    def reset_reading_node_counter
+      send_command(:reset_reading_node_counter)
+      success?
+    end
+    alias_method :reset_reading_node_counter?, :reset_reading_node_counter
+    
+    def get_reading_node_counter
+      send_command(:reset_reading_node_counter)
+    end
+    
+    def reset_trymove_node_counter
+      send_command(:reset_trymove_node_counter)
+      success?
+    end
+    alias_method :reset_trymove_node_counter?, :reset_trymove_node_counter
+    
+    def get_trymove_node_counter
+      send_command(:reset_trymove_node_counter)
+    end
+    
+    def reset_connection_node_counter
+      send_command(:reset_connection_node_counter)
+      success?
+    end
+    alias_method :reset_connection_node_counter?, :reset_connection_node_counter
+    
+    def get_connection_node_counter
+      send_command(:reset_connection_node_counter)
+    end
+    
+    # ...
+    
+    def cputime
+      send_command(:cputime)
+    end
+    
+    def showboard
+      Board.new(send_command(:showboard))
+    end
+    
+    # ...
+    
+    def printsgf(path = nil)
+      if path
+        send_command(:printsgf, path)
+        success?
+      else
+        send_command(:printsgf)
+      end
+    end
+    alias_method :printsgf?, :printsgf
+    
+    def tune_move_ordering(*move_ordering_parameters)
+      send_command(:tune_move_ordering, *move_ordering_parameters)
+    end
+    
+    def echo(string)
+      send_command(:echo, string)
+    end
+    
+    def echo_err(string)
+      send_command(:echo_err, string)
+    end
+    
+    def help
+      extract_lines(send_command(:help))
+    end
+    
+    def known_command(command)
+      extract_boolean(send_command(:known_command, command))
+    end
+    alias_method :known_command?, :known_command
+    
+    def report_uncertainty(on_or_off)
+      send_command(:report_uncertainty, on_or_off)
+    end
+    alias_method :report_uncertainty?, :report_uncertainty
+    
+    def get_random_seed
+      send_command(:get_random_seed)
+    end
+    
+    def set_random_seed(random_seed)
+      send_command(:set_random_seed, random_seed)
+      success?
+    end
+    alias_method :set_random_seed?, :set_random_seed
+    
+    def advance_random_seed(games)
+      send_command(:advance_random_seed, games)
+      success?
+    end
+    alias_method :advance_random_seed?, :advance_random_seed
+    
+    # ...
+    
+    def set_search_diamond(position)
+      send_command(:set_search_diamond, position)
+      success?
+    end
+    alias_method :set_search_diamond?, :set_search_diamond
+    
+    def reset_search_mask
+      send_command(:reset_search_mask)
+      success?
+    end
+    alias_method :reset_search_mask?, :reset_search_mask
+    
+    def limit_search(value)
+      send_command(:limit_search, value)
+      success?
+    end
+    alias_method :limit_search?, :limit_search
+    
+    def set_search_limit(position)
+      send_command(:set_search_limit, position)
+      success?
+    end
+    alias_method :set_search_limit?, :set_search_limit
+    
+    def draw_search_area
+      send_command(:draw_search_area)
+    end
+    
+    private
+    
+    def next_id
+      @id += 1
+    end
+    
+    def send_command(command, *arguments)
+      @io.puts [next_id, command, *arguments].join(" ")
+      result = @io.take_while { |line| line != "\n" }.join
+      if result.sub!(/^=#{@id} */, "")
+        @last_error = nil
+      elsif result.sub!(/^\?#{@id} *(\S.*\S?).*/, "")
+        @last_error = $1
+      else
+        raise "Unexpected response format"
+      end
+      result.sub(/\A(?: *\n)+/, "").sub(/(?:\n *)+\z/, "")
+    end
+    
+    def extract_vertices(response)
+      success? ? response.scan(/[A-Z]\d+/) : [ ]
+    end
+    
+    def extract_color(response)
+      !success? || response == "empty" ? nil : response
+    end
+    
+    def extract_move(response)
+      success? ? response.split : nil
+    end
+    
+    def extract_moves(response)
+      success? ? response.lines.map { |line| line.strip.split } : nil
+    end
+    
+    def extract_boolean(response)
+      success? ? response == "1" || response == "true" : nil
+    end
+    
+    def extract_integer(response)
+      success? ? response.to_i : nil
+    end
+    
+    def extract_lines(response)
+      success? ? response.lines.map { |line| line.strip } : nil
+    end
+  end
+end

data/lib/go/gtp/board.rb

@@ -0,0 +1,44 @@
+module Go
+  class GTP
+    class Board
+      STONES = {"X" => "black", "O" => "white"}
+      
+      def initialize(board_string)
+        @string = board_string
+        @array  = nil
+      end
+      
+      def [](*args)
+        point = if args.size == 1 and args.first.is_a? Point
+                  args.first
+                elsif args.size == 1 and
+                      args.first =~ /\A([A-HJ-T])(\d{1,2})\z/i
+                  Point.new(*args, board_size: size)
+                else
+                  Point.new(*args)
+                end
+        to_a[point.y][point.x]
+      end
+      
+      def captures(color)
+        @string[/#{Regexp.escape(color)}(?: \([XO])?\) has captured (\d+)/i, 1]
+        .to_i
+      end
+      
+      def to_s
+        @string
+      end
+      
+      def to_a
+        @array ||= @string.scan(/^\s*(\d+)((?:.[.+XO])+).\1\b/)
+                          .map { |_, row| row.chars
+                                             .each_slice(2)
+                                             .map { |_, stone| STONES[stone] } }
+      end
+      
+      def size
+        to_a.size
+      end
+    end
+  end
+end

data/lib/go/gtp/point.rb

@@ -0,0 +1,58 @@
+module Go
+  class GTP
+    # 
+    # This utility class manages points on a Go board using any one of three
+    # formats:
+    # 
+    # * X and Y Array indices counting from the upper left hand corner
+    # * SGF letter pairs ("ac") counting from the upper left hand corner
+    # * GNU Go letter and number pairs ("A13") counting from the lower left hand
+    #   corner
+    # 
+    # There are two gotchas to stay aware of with these systems.  First, the GNU
+    # Go format skips over I in columns, but the SGF format does not.  Second,
+    # the GNU Go format relies on knowing the board size.  A 19x19 size is
+    # assumed, but you can override this when creating from or converting to
+    # this format.
+    # 
+    # Point instances can be initialized from any format and converted to any
+    # format.
+    # 
+    class Point
+      BIG_A    = "A".getbyte(0)
+      LITTLE_A = "a".getbyte(0)
+      
+      def initialize(*args)
+        if args.size == 2 and args.all? { |n| n.is_a? Integer }
+          @x, @y = args
+        elsif (args.size == 1 or (args.size == 2 and args.last.is_a?(Hash))) and
+              args.first =~ /\A([A-HJ-T])(\d{1,2})\z/i
+          options = args.last.is_a?(Hash) ? args.pop : { }
+          letter  = $1.upcase
+          @x      = letter.getbyte(0) - BIG_A - (letter > "I" ? 1 : 0)
+          @y      = options.fetch(:board_size, 19) - $2.to_i
+        elsif args.size == 1 and args.first =~ /\A([a-s])([a-s])\z/i
+          @x, @y = $~.captures.map { |l| l.downcase.getbyte(0) - LITTLE_A }
+        else
+          fail ArgumentError, "unrecognized point format"
+        end
+      end
+      
+      attr_reader :x, :y
+      
+      def to_indexes
+        [@x, @y]
+      end
+      alias_method :to_indices, :to_indexes
+      
+      def to_sgf
+        [@x, @y].map { |n| (LITTLE_A + n).chr }.join
+      end
+      
+      def to_gnugo(board_size = 19)
+        "#{(BIG_A + @x).chr}#{board_size - @y}"
+      end
+      alias_method :to_s, :to_gnugo
+    end
+  end
+end

data/spec/board_spec.rb

@@ -0,0 +1,68 @@
+require "go/gtp/board"
+
+describe Go::GTP::Board do
+  before :all do
+    @string = <<-END_BOARD.gsub(/^ {4}/, "")
+       A B C D E F G H J
+     9 . . . . . . . . . 9
+     8 . . . . . . . . . 8
+     7 . . X . . . + . . 7
+     6 . . . . . . . . . 6
+     5 . . . . + . . . . 5
+     4 . . . . . . . . . 4
+     3 . . + . . O + . . 3
+     2 . . . . . . . . . 2     WHITE (O) has captured 10 stones
+     1 . . . . . . . . . 1     BLACK (X) has captured 11 stones
+       A B C D E F G H J
+    END_BOARD
+    @board = Go::GTP::Board.new(@string)
+  end
+  
+  it "should stringify to what it was created from" do
+    @board.to_s.should == @string
+  end
+  
+  it "should be possible to get the board as an array of arrays" do
+    @board.to_a.should == [
+      [nil, nil, nil,     nil, nil, nil,     nil, nil, nil],
+      [nil, nil, nil,     nil, nil, nil,     nil, nil, nil],
+      [nil, nil, "black", nil, nil, nil,     nil, nil, nil],
+      [nil, nil, nil,     nil, nil, nil,     nil, nil, nil],
+      [nil, nil, nil,     nil, nil, nil,     nil, nil, nil],
+      [nil, nil, nil,     nil, nil, nil,     nil, nil, nil],
+      [nil, nil, nil,     nil, nil, "white", nil, nil, nil],
+      [nil, nil, nil,     nil, nil, nil,     nil, nil, nil],
+      [nil, nil, nil,     nil, nil, nil,     nil, nil, nil]
+    ]
+  end
+  
+  it "should support indexing by coordinates" do
+    @board[0, 0].should be_nil
+    @board[2, 2].should satisfy { |color| color == "black" }
+    @board[5, 6].should satisfy { |color| color == "white" }
+  end
+  
+  it "should support indexing by vertices" do
+    @board["A1"].should be_nil
+    @board["C7"].should satisfy { |color| color == "black" }
+    @board["F3"].should satisfy { |color| color == "white" }
+  end
+  
+  it "should fail to index for any other combination" do
+    lambda { @board["A", "1"] }.should raise_error(ArgumentError)
+  end
+  
+  it "should be able to count captures by color name" do
+    @board.captures("white").should satisfy { |stones| stones == 10 }
+    @board.captures("WHITE").should satisfy { |stones| stones == 10 }
+    @board.captures("black").should satisfy { |stones| stones == 11 }
+    @board.captures("BLACK").should satisfy { |stones| stones == 11 }
+  end
+  
+  it "should be able to count captures by stone type" do
+    @board.captures("o").should satisfy { |stones| stones == 10 }
+    @board.captures("O").should satisfy { |stones| stones == 10 }
+    @board.captures("x").should satisfy { |stones| stones == 11 }
+    @board.captures("X").should satisfy { |stones| stones == 11 }
+  end
+end

data/spec/gtp_spec.rb

@@ -0,0 +1,166 @@
+require "stringio"
+
+require "go/gtp"
+
+class MockPipe
+  def initialize(input)
+    @input  = StringIO.new(input)
+    @output = StringIO.new
+    @closed = false
+  end
+  
+  attr_reader :input, :output
+  
+  def puts(*args)
+    @output.puts(*args)
+  end
+  
+  def close
+    @closed = true
+  end
+  
+  def closed?
+    @closed
+  end
+  
+  def method_missing(meth, *args, &blk)
+    @input.send(meth, *args, &blk)
+  end
+end
+
+describe Go::GTP do
+  def gtp(input = "=1", &commands)
+    @pipe = MockPipe.new(input)
+    return [Go::GTP.new(@pipe, &commands), @pipe.input, @pipe.output]
+  end
+  
+  it "should send quit after running a provided block" do
+    ran          = false
+    _, _, output = gtp do
+      ran        = true
+    end
+    ran.should be(true)
+    output.string.should match(/\A\d+\s+quit\Z/)
+  end
+  
+  context "when connected" do
+    before :each do
+      @go, @input, @output = gtp
+    end
+    
+    def add_input(input)
+      @input << input
+      @input.rewind
+    end
+    
+    it "should return an instance without sending commands without a block" do
+      @output.string.should be_empty
+    end
+
+    it "should report the success of the last command" do
+      @go.clear_board
+      @go.should be_success
+    end
+
+    it "should not report success if the last command failed" do
+      add_input("?1 error message")
+      @go.clear_board
+      @go.should_not be_success
+    end
+
+    it "should not have an error after a successful command" do
+      @go.clear_board.should be(true)
+      @go.last_error.should be_nil
+    end
+
+    it "should have an error after an unsuccessful command" do
+      add_input("?1 error message")
+      @go.clear_board.should be(false)
+      @go.last_error.should == "error message"
+    end
+    
+    it "should close the IO on quit" do
+      @pipe.should_not be_closed
+      @go.quit
+      @pipe.should be_closed
+    end
+    
+    it "should return output from commands that return data" do
+      add_input("=1 2.0")
+      @go.protocol_version.should == "2.0"
+    end
+    
+    it "should return the success or failure of boolean operations" do
+      @go.boardsize(9).should == @go.success?
+    end
+    
+    it "should support the query interface for boolean operations" do
+      @go.boardsize?(9).should == @go.success?
+    end
+    
+    it "should return lists of vertices in an array" do
+      add_input("=1 A1 B2")
+      @go.fixed_handicap(2) == %w[A1 B1]
+    end
+    
+    it "should return colors as black, white, or nil" do
+      add_input("=1 black\n\n=2 white\n\n=3 empty")
+      @go.color("A1").should satisfy { |stone| stone == "black" }
+      @go.color("B1").should satisfy { |stone| stone == "white" }
+      @go.color("C1").should be_nil
+    end
+    
+    it "should return boolean results as true and false" do
+      add_input("=1 1\n\n=2 0")
+      @go.is_legal?("black", "A1").should be(true)
+      @go.is_legal?("black", "B1").should be(false)
+    end
+    
+    it "should return a move in an array" do
+      add_input("=1 white A1")
+      @go.last_move.should == %w[white A1]
+    end
+    
+    it "should return moves in an array of arrays" do
+      add_input("=1\nwhite A1\nblack B1")
+      @go.move_history.should == [%w[white A1], %w[black B1]]
+    end
+    
+    it "should return board diagrams wrapped in an appropriate object" do
+      add_input("=1 board")
+      @go.showboard.should be_an_instance_of(Go::GTP::Board)
+    end
+    
+    it "should support a dual interface for methods that can return data" do
+      add_input("=1 board\n\n=2")
+      @go.printsgf.should satisfy { |sgf| sgf == "board" }
+      @go.printsgf?("/path/to/file").should be(true)
+    end
+    
+    it "should return line results in an array" do
+      add_input("=1 help\nknown_command")
+      @go.help.should == %w[help known_command]
+    end
+    
+    it "should detect a resignation as a game over condition" do
+      add_input("=1 black RESIGN")
+      @go.should be_over
+    end
+    
+    it "should detect two passes as a game over condition" do
+      add_input("=1 black PASS\nwhite PASS")
+      @go.should be_over
+    end
+    
+    it "should not any other game over conditions" do
+      add_input("=1 black E4\nwhite PASS")
+      @go.should_not be_over
+    end
+    
+    it "should allow you to replay a series of moves" do
+      add_input("=1\n\n=2\n\n=3\n\n=4 black E6")
+      @go.replay(%w[E4 E5 E6]).should be(true)
+      @go.last_move.should == %w[black E6]
+    end
+  end
+end

data/spec/point_spec.rb

@@ -0,0 +1,75 @@
+require "go/gtp/point"
+
+describe Go::GTP::Point do
+  it "should initialize from an x, y integer index pair" do
+    lambda { Go::GTP::Point.new(0, 2) }.should_not raise_error(ArgumentError)
+  end
+
+  it "should initialize from a GNU Go letter and integer pair" do
+    lambda { Go::GTP::Point.new("A12") }.should_not raise_error(ArgumentError)
+  end
+
+  it "should initialize from an SGF letter pair" do
+    lambda { Go::GTP::Point.new("ad") }.should_not raise_error(ArgumentError)
+  end
+  
+  it "should fail with an argmument error with any other arguments" do
+    lambda { Go::GTP::Point.new("junk") }.should raise_error(ArgumentError)
+  end
+  
+  context "initialized from any format" do
+    before :all do
+      @points = [[0, 2], "A17", "ac"].map { |args| Go::GTP::Point.new(*args) }
+    end
+    
+    it "should track its indices" do
+      @points.each do |point|
+        point.x.should satisfy { |x| x == 0 }
+        point.y.should satisfy { |y| y == 2 }
+      end
+    end
+    
+    it "should convert to indices" do
+      @points.each do |point|
+        point.to_indexes.should satisfy { |xy| xy == [0, 2] }
+        point.to_indices.should satisfy { |xy| xy == [0, 2] }
+      end
+    end
+    
+    it "should convert to SGF letters" do
+      @points.each do |point|
+        point.to_sgf.should == "ac"
+      end
+    end
+    
+    it "should convert to GNU Go letters and numbers" do
+      @points.each do |point|
+        point.to_gnugo.should satisfy { |ln| ln == "A17" }
+        point.to_s.should     satisfy { |ln| ln == "A17" }
+      end
+    end
+  end
+  
+  context "in the GNU Go format" do
+    it "should default to assuming a 19x19 board on creation" do
+      Go::GTP::Point.new("A13").to_indices.should == [0, 6]
+    end
+
+    it "should allow you to override board size on creation" do
+      Go::GTP::Point.new("A13", board_size: 13).to_indices.should == [0, 0]
+    end
+
+    it "should default to assuming a 19x19 board on conversion" do
+      Go::GTP::Point.new(0, 6).to_gnugo.should == "A13"
+    end
+
+    it "should allow you to override board size on conversion" do
+      Go::GTP::Point.new(0, 0).to_gnugo(13).should == "A13"
+    end
+    
+    it "should skip over the unused I column" do
+      Go::GTP::Point.new("H19").to_indices.should satisfy { |ln| ln == [7, 0] }
+      Go::GTP::Point.new("J19").to_indices.should satisfy { |ln| ln == [8, 0] }
+    end
+  end
+end

data/spec/run_gnugo_spec.rb

@@ -0,0 +1,75 @@
+require "go/gtp"
+
+describe Go::GTP, "when connecting to GNU Go" do
+  before :all do
+    Go::GTP::IO = mock
+  end
+  
+  it "should return a connected instance" do
+    Go::GTP::IO.should_receive(:popen)
+    Go::GTP.run_gnugo.should be_an_instance_of(Go::GTP)
+  end
+  
+  it "should open the connection in reading and writing mode" do
+    Go::GTP::IO.should_receive(:popen) do |_, mode|
+      mode.should match(/\A[rw]\+\z/)
+    end
+    Go::GTP.run_gnugo
+  end
+  
+  it "should default to using no directory" do
+    Go::GTP::IO.should_receive(:popen) do |path, _|
+      path.should match(/\Agnugo\b/)
+    end
+    Go::GTP.run_gnugo
+  end
+  
+  it "should allow the directory to be overriden" do
+    Go::GTP::IO.should_receive(:popen) do |path, _|
+      path.should match(%r{\A/usr/local/bin/gnugo\b})
+    end
+    Go::GTP.run_gnugo(directory: "/usr/local/bin")
+  end
+  
+  it "should default to using gnugo in GTP mode" do
+    Go::GTP::IO.should_receive(:popen) do |path, _|
+      path.should match(/\Agnugo\b.*--mode\s+gtp\b/)
+    end
+    Go::GTP.run_gnugo
+  end
+  
+  it "should allow the command to be overriden" do
+    Go::GTP::IO.should_receive(:popen) do |path, _|
+      path.should match(/\Amy_go\b/)
+    end
+    Go::GTP.run_gnugo(command: "my_go")
+  end
+  
+  it "should default to using no arguments" do
+    Go::GTP::IO.should_receive(:popen) do |path, _|
+      path.should_not match(/--(?!mode\b)\w+/)
+    end
+    Go::GTP.run_gnugo
+  end
+  
+  it "should allow the arguments to be overriden" do
+    Go::GTP::IO.should_receive(:popen) do |path, _|
+      path.should match(/--boardsize\s+9\b/)
+    end
+    Go::GTP.run_gnugo(arguments: "--boardsize 9")
+  end
+  
+  it "should default to redirecting STDERR to STDOUT" do
+    Go::GTP::IO.should_receive(:popen) do |path, _|
+      path.should match(/2>&1\z/)
+    end
+    Go::GTP.run_gnugo
+  end
+  
+  it "should allow the redirections to be overriden" do
+    Go::GTP::IO.should_receive(:popen) do |path, _|
+      path.should match(%r{2>/dev/null\z})
+    end
+    Go::GTP.run_gnugo(redirections: "2>/dev/null")
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: go_gtp
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- James Edward Gray II
+- Ryan Bates
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-02 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: This library runs GNU Go in a separate process and allows you to communicate with it using the Go Text Protocol (GTP). This makes it easy to manage full games of Go, work with SGF files, analyze Go positions, and more.
+email: 
+- james@graysoftinc.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- README.markdown
+- Rakefile
+- TODO
+- example/create_game.rb
+- example/generate_move.rb
+- example/play_all.rb
+- example/play_go.rb
+- example/play_move.rb
+- example/show_board.rb
+- go_gtp.gemspec
+- lib/go/gtp.rb
+- lib/go/gtp/board.rb
+- lib/go/gtp/point.rb
+- spec/board_spec.rb
+- spec/gtp_spec.rb
+- spec/point_spec.rb
+- spec/run_gnugo_spec.rb
+has_rdoc: true
+homepage: http://github.com/JEG2/go_gtp
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ~>
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A wrapper for GNU Go's Go Text Protocol (GTP).
+test_files: 
+- spec/board_spec.rb
+- spec/gtp_spec.rb
+- spec/point_spec.rb
+- spec/run_gnugo_spec.rb