ruby-go 0.0.2 → 1.0.0

data/lib/ruby-go/printers/text.rb

@@ -0,0 +1,40 @@
+module RubyGo
+  class TextPrinter
+    COLORS = { black: 'x', white: 'o', empty: '_' }.freeze
+
+    attr_reader :io
+
+    def initialize(io)
+      @io = io
+    end
+
+    def print_game(game)
+      print_board(game.board)
+      io.puts  "   " + "_"*(game.board.size * 2)
+      io.print "   Prisoners || White: #{game.captures[:black]} |"
+      io.puts  " Black: #{game.captures[:white]}"
+      io.puts  "   " + "-"*(game.board.size * 2)
+    end
+
+    private
+
+    def print_board(board)
+      if board.size < 11
+        io.puts "   #{(0..board.size - 1).to_a.join(' ')}"
+      else
+        io.puts "   #{(0..10).to_a.join(' ')}#{(11..board.size - 1).to_a.join('')}"
+      end
+
+      board.rows.each_with_index do |row, i|
+        i = " #{i}" if i < 10
+        io.print "#{i} "
+        row.each { |stn| print_stone(stn) }
+        io.puts
+      end
+    end
+
+    def print_stone(stone)
+      io.print "#{COLORS[stone.color]} "
+    end
+  end
+end

data/lib/ruby-go/stone.rb

@@ -0,0 +1,50 @@
+module RubyGo
+  class Stone
+    LETTERS = ('a'..'z').to_a
+
+    attr_reader :color, :x_coord, :y_coord
+
+    def initialize(x_coord, y_coord, color)
+      @x_coord = x_coord
+      @y_coord = y_coord
+      @color = color
+    end
+
+    def to_sgf
+      x = LETTERS[x_coord]
+      y = LETTERS[y_coord]
+      ";#{color.to_s[0].upcase}[#{x}#{y}]"
+    end
+
+    def empty?
+      false
+    end
+
+    def to_coord
+      [x_coord, y_coord]
+    end
+
+    def ==(other)
+      other.is_a?(Stone) &&
+        (color == other.color) &&
+        (to_coord == other.to_coord)
+    end
+  end
+
+  # This can be changed to a Pass object
+  class NullStone < Stone
+    def initialize(color = :empty)
+      @x_coord = nil
+      @y_coord = nil
+      @color = color
+    end
+
+    def to_sgf
+      ";#{color.to_s[0].upcase}[]"
+    end
+
+    def empty?
+      true
+    end
+  end
+end

data/lib/ruby-go/version.rb

@@ -0,0 +1,3 @@
+module RubyGo
+  VERSION = "1.0.0"
+end

data/test/go_test.rb

@@ -1,161 +1,183 @@
 require_relative 'test_helper'
 require 'stringio'
 
-class GoTest < Minitest::Test 
-  def setup
-    b,w = Board::Colors[:black], Board::Colors[:white] 
-    e   = Board::Colors[:empty]
+module RubyGo
+  class GoTest < Minitest::Test
+    def setup
+      @row_9_str = " 8 _ _ _ _ _ _ _ _ _ \n"
 
-    @row_9_str = "_ _ _ _ _ _ _ _ _\n" 
+      @game = Game.new(board: 9)
+    end
 
-    @game = Game.new(board: 9)
-  end
+    def test_game_has_blank_board_when_initialized
+      assert @game.board.empty?
+    end
 
-  def test_game_has_blank_board_when_initialized
-    assert @game.board.empty?
-  end
+    def test_printer_can_print_the_game
+      out = StringIO.new
+      printer = RubyGo::TextPrinter.new(out)
+      printer.print_game(@game)
+      out.rewind
+      assert_includes out.read, @row_9_str
+    end
 
-  def test_empty_board_looks_like_empty_board
-    assert_includes @game.board.to_s, @row_9_str 
-  end
+    def test_game_can_place_a_stone
+      game = Game.new(board: 9)
+      game.place_black(2,2)
+      assert_equal :black, game.board.at(2,2).color
+    end
 
-  def test_game_can_print_the_board
-    out = StringIO.new
-    temp = $stdout
-    $stdout = out
-    @game.view
-    $stdout = temp
-    out.rewind
-    assert_includes out.read, @row_9_str
-  end
+    def test_cannot_place_a_stone_on_top_of_another_stone
+      game = Game.new(board: 9)
+      game.place_black(2,2)
+      assert_raises(Game::IllegalMove) do
+        game.place_white(2,2)
+      end
+    end
 
-  def test_game_can_place_a_stone
-    game = Game.new(board: 9)
-    game.black(2,2)
-    assert_equal BlackStone.new(2,2), game.board.at(2,2) 
-  end
+    def test_can_capture_one_stone
+      game = Game.new(board: 9)
+      game.place_black(2,2)
+      game.place_white(2,1)
+      game.place_white(2,3)
+      game.place_white(1,2)
+      game.place_white(3,2)
+      assert_equal 1, game.captures[:black]
+    end
 
-  def test_cannot_place_a_stone_on_top_of_another_stone
-    game = Game.new(board: 9)
-    game.black(2,2)
-    assert_raises(Game::IllegalMove) do
-      game.white(2,2)
+    def test_capture_removes_stone
+      game = Game.new(board: 9)
+      game.place_black(2,2)
+      game.place_white(2,1)
+      game.place_white(2,3)
+      game.place_white(1,2)
+      game.place_white(3,2)
+      assert game.board.at(2,2).empty?
     end
-  end
 
-  def test_can_capture_one_stone
-    game = Game.new(board: 9)
-    game.black(2,2)
-    game.white(2,1)
-    game.white(2,3)
-    game.white(1,2)
-    game.white(3,2)
-    assert_equal 1, game.captures[:black]
-  end
+    def test_capture_three_stones
+      game = Game.new(board: 9)
+      game.place_black(2,1)
+      game.place_black(2,2)
+      game.place_black(2,3)
+      game.place_white(2,0)
+      game.place_white(2,4)
+      game.place_white(1,1)
+      game.place_white(1,2)
+      game.place_white(1,3)
+      game.place_white(3,1)
+      game.place_white(3,2)
+      game.place_white(3,3)
+      assert_equal 3, game.captures[:black]
+    end
 
-  def test_capture_removes_stone
-    game = Game.new(board: 9)
-    game.black(2,2)
-    game.white(2,1)
-    game.white(2,3)
-    game.white(1,2)
-    game.white(3,2)
-    assert_equal Liberty.new(2,2), game.board.at(2,2) 
-  end
+    def test_snap_back
+      game = Game.new(board: 9)
+      game.place_black(3,2)
+      game.place_black(2,3)
+      game.place_black(4,3)
+      game.place_black(2,4)
+      game.place_black(5,4)
+      game.place_black(3,5)
+      game.place_black(4,5)
+      game.place_white(4,2)
+      game.place_white(5,3)
+      game.place_white(3,4)
+      game.place_white(4,4)
+      game.place_white(3,3)
+      assert_equal 1, game.captures[:black]
+      assert_equal 0, game.captures[:white]
+      game.place_black(4,3)
+      assert_equal 1, game.captures[:black]
+      assert_equal 3, game.captures[:white]
+    end
 
-  def test_capture_three_stones
-    game = Game.new(board: 9)
-    game.black(2,1)
-    game.black(2,2)
-    game.black(2,3)
-    game.white(2,0)
-    game.white(2,4)
-    game.white(1,1)
-    game.white(1,2)
-    game.white(1,3)
-    game.white(3,1)
-    game.white(3,2)
-    game.white(3,3)
-    assert_equal 3, game.captures[:black]
-  end
+    def test_can_undo
+      game = Game.new()
+      game.place_black(2,2)
+      game.place_white(2,3)
+      game.undo
+      assert game.board.at(2,3).empty?
+    end
 
-  def test_can_undo
-    game = Game.new()
-    game.black(2,2)
-    game.white(2,3)
-    game.undo
-    assert_equal Liberty.new(2,3), game.board.at(2,3)
-  end
+    def test_can_undo_pass
+      game = Game.new
+      game.place_black(2,2)
+      game.white_pass
+      game.undo
+      assert_equal 0, game.passes
+    end
 
-  def test_can_undo_until_beginning
-    game = Game.new()
-    game.black(2,2)
-    game.white(3,2)
-    game.black(3,3)
-    3.times {game.undo}
-    assert_equal Liberty.new(2,2), game.board.at(2,2)
-  end
+    def test_can_undo_until_beginning
+      game = Game.new()
+      game.place_black(2,2)
+      game.place_white(3,2)
+      game.place_black(3,3)
+      3.times {game.undo}
+      assert game.board.at(2,2).empty?
+    end
 
-  def test_can_pass
-    game = Game.new
-    game.pass 
-    game.pass
-    assert_equal 2, game.passes
-  end
+    def test_can_pass
+      game = Game.new
+      game.black_pass
+      game.white_pass
+      assert_equal 2, game.passes
+    end
 
-  def test_cannot_play_a_suicide
-    game = Game.new
-    game.black(3,3)
-    game.white(2,3)
-    game.white(4,3)
-    game.white(3,4)
-    game.white(3,2)
-    assert_raises(Game::IllegalMove) do
-      game.black(3,3)
+    def test_cannot_play_a_suicide
+      game = Game.new
+      game.place_black(3,3)
+      game.place_white(2,3)
+      game.place_white(4,3)
+      game.place_white(3,4)
+      game.place_white(3,2)
+      assert_raises(Game::IllegalMove) do
+        game.place_black(3,3)
+      end
     end
-  end
 
-  def test_cannot_play_a_ko
-    game = Game.new
-    game.black(3,3)
-    game.white(2,3)
-    game.white(4,3)
-    game.white(3,4)
-    game.white(3,2)
-    game.black(4,2)
-    game.black(4,4)
-    game.black(5,3)
-    game.black(3,3)
-    assert_raises(Game::IllegalMove) do
-      game.white(4,3)
+    def test_cannot_play_a_ko
+      game = Game.new
+      game.place_black(3,3)
+      game.place_white(2,3)
+      game.place_white(4,3)
+      game.place_white(3,4)
+      game.place_white(3,2)
+      game.place_black(4,2)
+      game.place_black(4,4)
+      game.place_black(5,3)
+      game.place_black(3,3)
+      assert_raises(Game::IllegalMove) do
+        game.place_white(4,3)
+      end
     end
-  end
 
-  def big_capture_area_game
-    game = Game.new
-    game.black(0,0)
-    game.white(1,1)
-    game.black(0,1)
-    game.white(0,2)
-    game.black(1,0)
-    game.white(2,0)
-    game
-  end
+    def big_capture_area_game
+      game = Game.new
+      game.place_black(0,0)
+      game.place_white(1,1)
+      game.place_black(0,1)
+      game.place_white(0,2)
+      game.place_black(1,0)
+      game.place_white(2,0)
+      game
+    end
 
-  def test_can_play_in_previous_capture_area_that_is_not_a_ko
-    game = big_capture_area_game
-    assert_equal Liberty.new(0,0), game.board.at(0,0) 
-    game.black(0,0)
-    assert_equal BlackStone.new(0,0), game.board.at(0,0) 
-
-    game = big_capture_area_game
-    assert_equal Liberty.new(0,1), game.board.at(0,1) 
-    game.black(0,1)
-    assert_equal BlackStone.new(0,1), game.board.at(0,1) 
-
-    game = big_capture_area_game
-    assert_equal Liberty.new(1,0), game.board.at(1,0) 
-    game.black(1,0)
-    assert_equal BlackStone.new(1,0), game.board.at(1,0) 
+    def test_can_play_in_previous_capture_area_that_is_not_a_ko
+      game = big_capture_area_game
+      assert game.board.at(0,0).empty?
+      game.place_black(0,0)
+      assert_equal :black, game.board.at(0,0).color
+
+      game = big_capture_area_game
+      assert game.board.at(0,1).empty?
+      game.place_black(0,1)
+      assert_equal :black, game.board.at(0,1).color
+
+      game = big_capture_area_game
+      assert game.board.at(1,0).empty?
+      game.place_black(1,0)
+      assert_equal :black, game.board.at(1,0).color
+    end
   end
 end

data/test/sgf_test.rb

@@ -1,51 +1,52 @@
 require_relative 'test_helper'
 
-class SGFTest < Minitest::Test
+module RubyGo
+  class SGFTest < Minitest::Test
 
-  def test_game_converts_to_sgf
-    game = Game.new
-    assert_equal "(;GM[1]FF[4]CA[UTF-8]AP[jphager2]SZ[19]PW[White]PB[Black])",
-      game.to_sgf
-  end
+    def test_game_converts_to_sgf
+      game = Game.new
+      assert_equal "(;GM[1]FF[4]CA[UTF-8]AP[jphager2]SZ[19]PW[White]PB[Black])",
+        game.to_sgf
+    end
 
-  def test_game_converts_to_sgf_with_moves
-    game = Game.new
-    game.black(15,3)
-    game.white(3,3)
-    game.black(3,15)
-    game.white(15,15)
-    assert_equal "(;GM[1]FF[4]CA[UTF-8]AP[jphager2]SZ[19]PW[White]PB[Black];B[pd];W[dd];B[dp];W[pp])",
-      game.to_sgf
-  end
+    def test_game_converts_to_sgf_with_moves
+      game = Game.new
+      game.place_black(15,3)
+      game.place_white(3,3)
+      game.place_black(3,15)
+      game.place_white(15,15)
+      assert_equal "(;GM[1]FF[4]CA[UTF-8]AP[jphager2]SZ[19]PW[White]PB[Black];B[pd];W[dd];B[dp];W[pp])",
+        game.to_sgf
+    end
 
-  def test_game_converts_correctly_with_capture
-    game = Game.new
-    game.black(15,3)
-    game.white(16,3)
-    game.black(16,2)
-    game.white(15,2)
-    game.black(14,2)
-    game.white(14,3)
-    game.black(17,3)
-    game.white(15,4)
-    game.black(16,4)
-    game.white(15,3)
+    def test_game_converts_correctly_with_capture
+      game = Game.new
+      game.place_black(15,3)
+      game.place_white(16,3)
+      game.place_black(16,2)
+      game.place_white(15,2)
+      game.place_black(14,2)
+      game.place_white(14,3)
+      game.place_black(17,3)
+      game.place_white(15,4)
+      game.place_black(16,4)
+      game.place_white(15,3)
 
-    assert_equal "(;GM[1]FF[4]CA[UTF-8]AP[jphager2]SZ[19]PW[White]PB[Black];B[pd];W[qd];B[qc];W[pc];B[oc];W[od];B[rd];W[pe];B[qe];W[pd])",
-      game.to_sgf
-  end
+      assert_equal "(;GM[1]FF[4]CA[UTF-8]AP[jphager2]SZ[19]PW[White]PB[Black];B[pd];W[qd];B[qc];W[pc];B[oc];W[od];B[rd];W[pe];B[qe];W[pd])",
+        game.to_sgf
+    end
 
-  def test_saves_sgf
-    file = File.expand_path('../../my_go_game.sgf', __FILE__)
-    path = File.expand_path('../../*.sgf', __FILE__)
-    File.delete(file) if File.exist?(file)
-    game = Game.new
-    game.black(15,3)
-    game.white(16,3)
-    game.black(16,2)
-    game.white(15,2)
-    game.save
-    assert_includes Dir.glob(path), file 
+    def test_saves_sgf
+      file = File.expand_path('../../my_go_game.sgf', __FILE__)
+      path = File.expand_path('../../*.sgf', __FILE__)
+      File.delete(file) if File.exist?(file)
+      game = Game.new
+      game.place_black(15,3)
+      game.place_white(16,3)
+      game.place_black(16,2)
+      game.place_white(15,2)
+      game.save
+      assert_includes Dir.glob(path), file
+    end
   end
-
 end