chess 0.3.0 → 0.3.3

data/lib/chess/game.rb

@@ -7,6 +7,7 @@ module Chess
     # @raise [IllegalMoveError]
     # @raise [BadNotationError]
     def initialize(moves = [])
+      super()
       moves.each { |m| move(m) }
     end
 
@@ -20,7 +21,7 @@ module Chess
       pgn = Chess::Pgn.new(file)
       game = Chess::Game.new
       pgn.moves.each { |m| game.move(m) }
-      if !game.over?
+      unless game.over?
         case pgn.result
         when '1-0'
           game.resign(:black)
@@ -39,13 +40,11 @@ module Chess
     # @raise [InvalidFenFormatError]
     # @note This game do not have history before the FEN placement.
     def self.load_fen(fen)
-      if /^((?:[PRNBQKprnbqk1-8]{1,8}\/){7}[RNBQKPrnbqkp1-8]{1,8})\s(w|b)\s(K?Q?k?q?|-)\s([a-h][1-8]|-)\s(\d+)\s(\d+)$/.match?(fen)
-        game = Chess::Game.new
-        game.set_fen!(fen)
-        return game
-      else
-        raise InvalidFenFormatError.new(fen)
-      end
+      raise InvalidFenFormatError.new(fen) unless /^((?:[PRNBQKprnbqk1-8]{1,8}\/){7}[RNBQKPrnbqkp1-8]{1,8})\s(w|b)\s(K?Q?k?q?|-)\s([a-h][1-8]|-)\s(\d+)\s(\d+)$/.match?(fen)
+
+      game = Chess::Game.new
+      game.set_fen!(fen)
+      return game
     end
 
     # Make a move.
@@ -67,11 +66,9 @@ module Chess
         super(expand[:name], expand[:dis], expand[:to], expand[:promotion])
       end
     rescue IllegalMoveError
-      if ENV['DEBUG']
-        raise IllegalMoveError.new("Illegal move '#{notation}'\nStatus: #{self.status}\nPlayer turn #{self.active_player}\n#{self}")
-      else
-        raise IllegalMoveError.new("Illegal move '#{notation}'")
-      end
+      raise IllegalMoveError.new("Illegal move '#{notation}'\nStatus: #{self.status}\nPlayer turn #{self.active_player}\n#{self}") if ENV['DEBUG']
+
+      raise IllegalMoveError.new("Illegal move '#{notation}'")
     end
     alias move= move
     alias << move
@@ -106,38 +103,28 @@ module Chess
     # * `black_won_resign`: black player has won for resign.
     # * `stalemate`: draw for stalemate.
     # * `insufficient_material`: draw for insufficient material to checkmate.
-    # * `fifty_rule_move`: draw for fifty rule move.
-    # * `threefold_repetition`: draw for threefold_repetition.
-    # * `unknown`: something went wrong.
-    # @return [String]
+    # * `fifty_move_rule`: draw for fifty-move rule.
+    # * `threefold_repetition`: draw for threefold repetition.
+    # @return [Symbol]
     def status
       case self.result
       when '*'
         return :in_progress
       when '1-0'
-        if self.board.checkmate?
-          return :white_won
-        else
-          return :white_won_resign
-        end
+        return :white_won if self.board.checkmate?
+
+        return :white_won_resign
       when '0-1'
-        if self.board.checkmate?
-          return :black_won
-        else
-          return :black_won_resign
-        end
+        return :black_won if self.board.checkmate?
+
+        return :black_won_resign
       when '1/2-1/2'
-        if self.board.stalemate?
-          return :stalemate
-        elsif self.board.insufficient_material?
-          return :insufficient_material
-        elsif self.board.fifty_rule_move?
-          return :fifty_rule_move
-        elsif self.threefold_repetition?
-          return :threefold_repetition
-        end
+        return :stalemate if self.board.stalemate?
+        return :insufficient_material if self.board.insufficient_material?
+        return :fifty_move_rule if self.board.fifty_move_rule?
+
+        return :threefold_repetition if self.threefold_repetition?
       end
-      return :unknown
     end
 
     # Returns `true` if the game is over.
@@ -146,7 +133,7 @@ module Chess
     end
 
     # Returns the PGN rappresenting the game.
-    # @return [String]
+    # @return [Chess::Pgn]
     def pgn
       pgn = Chess::Pgn.new
       pgn.moves = self.moves
@@ -156,37 +143,52 @@ module Chess
 
     private
 
-      # Expand the short algebraic chess notation string `notation` in a hash like this:
-      #
-      #     Ngxe2 ==> { name: 'N', dis: 'g', from: nil, to: 'e2', promotion: nil }
-      def expand_move(notation)
-        if (match = notation.match(Chess::MOVE_REGEXP))
-          expand = {
-            name: match[1] || 'P',    # Piece name [RNBQK]
-            dis: match[2],            # Disambiguating move
-            to: match[3],             # Move to
-            promotion: match[4]      # Promote with
-          }
-          expand[:from] = match[2] if match[2] && match[2].size == 2
-          return expand
-        elsif SHORT_CASTLING_REGEXP.match?(notation)
-          if self.board.active_color # black king short castling
-            return { name: 'K', dis: nil, from: 'e8', to: 'g8', promotion: nil }
-          else # white king short castling
-            return { name: 'K', dis: nil, from: 'e1', to: 'g1', promotion: nil }
-          end
-        elsif LONG_CASTLING_REGEXP.match?(notation)
-          if self.board.active_color # black king long castling
-            return { name: 'K', dis: nil, from: 'e8', to: 'c8', promotion: nil }
-          else # white king long castling
-            return { name: 'K', dis: nil, from: 'e1', to: 'c1', promotion: nil }
-          end
+    # Expand the short algebraic chess notation string `notation` in a hash like this:
+    #
+    #     Ngxe2 ==> { name: 'N', dis: 'g', from: nil, to: 'e2', promotion: nil }
+    def expand_move(notation)
+      if (match = notation.match(MOVE_REGEXP))
+        expand = {
+          name: match[1] || 'P',    # Piece name [RNBQK]
+          dis: match[2],            # Disambiguating move
+          to: match[3],             # Move to
+          promotion: match[4]       # Promote with
+        }
+        expand[:from] = match[2] if match[2] && match[2].size == 2
+
+        # Support UCI protocol (Lichess)
+        case expand[:from]
+        when 'e1'
+          expand[:to] = 'g1' if expand[:to] == 'h1' # UCI protocol (Lichess) white king short castling
+          expand[:to] = 'c1' if expand[:to] == 'a1' # UCI protocol (Lichess) white king long castling
+        when 'e8'
+          expand[:to] = 'g8' if expand[:to] == 'h8' # UCI protocol (Lichess) black king short castling
+          expand[:to] = 'c8' if expand[:to] == 'a8' # UCI protocol (Lichess) black king long castling
         end
-        raise BadNotationError.new(notation)
+
+        return expand
+      end
+
+      # Castling notation
+      if SHORT_CASTLING_REGEXP.match?(notation)
+        return { name: 'K', dis: nil, from: 'e8', to: 'g8', promotion: nil } if self.board.active_color # black king short castling
+
+        return { name: 'K', dis: nil, from: 'e1', to: 'g1', promotion: nil } # white king short castling
+      end
+      if LONG_CASTLING_REGEXP.match?(notation)
+        return { name: 'K', dis: nil, from: 'e8', to: 'c8', promotion: nil } if self.board.active_color # black king long castling
+
+        return { name: 'K', dis: nil, from: 'e1', to: 'c1', promotion: nil } # white king long castling
       end
+
+      raise BadNotationError.new(notation)
+    end
   end
 
   MOVE_REGEXP = /^([RNBQK])?([a-h]|[1-8]|[a-h][1-8])?(?:x)?([a-h][1-8])(?:=?([RrNnBbQq]))?(?:ep)?(?:\+|\#)?$/.freeze
-  SHORT_CASTLING_REGEXP = /^([0O])-([0O])([\+#])?$/.freeze
-  LONG_CASTLING_REGEXP = /^([0O])-([0O])-([0O])([\+#])?$/.freeze
+  SHORT_CASTLING_REGEXP = /^([0O])-([0O])([+#])?$/.freeze
+  LONG_CASTLING_REGEXP = /^([0O])-([0O])-([0O])([+#])?$/.freeze
+  private_constant :MOVE_REGEXP
+  private_constant :SHORT_CASTLING_REGEXP
+  private_constant :LONG_CASTLING_REGEXP
 end

data/lib/chess/gnuchess.rb

@@ -46,69 +46,65 @@ module Chess
     class << self
       private
 
-        def included(_mod)
-          raise_if_gnuchess_is_not_installed
-        end
+      def included(_mod)
+        raise_if_gnuchess_is_not_installed
+      end
 
-        def extended(_mod)
-          raise_if_gnuchess_is_not_installed
-        end
+      def extended(_mod)
+        raise_if_gnuchess_is_not_installed
+      end
 
-        # Raise an exception if Gnuchess is not installed
-        def raise_if_gnuchess_is_not_installed
-          unless find_executable0('gnuchess')
-            raise 'You must install Gnuchess to use the module Chess::Gnuchess!'
-          end
-        end
+      # Raise an exception if Gnuchess is not installed
+      def raise_if_gnuchess_is_not_installed
+        raise 'You must install Gnuchess to use the module Chess::Gnuchess!' unless find_executable0('gnuchess')
+      end
     end
 
     private
 
-      def gen_pgn(file_to_save, moves = [])
-        done = false
-        pipe = IO.popen('gnuchess', 'r+')
-        begin
-          pipe.write("depth 1\n")
-          pipe.write("force\n")
-          pipe.write("name chess.rb\n")
-          moves.each do |move|
-            pipe.write("#{move}\n")
-          end
-          until done
-            pipe.write("go\n")
-            while (line = pipe.gets)
-              if /My move is : /.match?(line)
-                break
-              elsif / : resign/.match?(line)
-                break
-              elsif / : 1-0 {White mates}/.match?(line)
-                done = :white_won
-                break
-              elsif / : 0-1 {Black mates}/.match?(line)
-                done = :black_won
-                break
-              elsif (m = line.match(/1\/2-1\/2 {(.*?)}/))
-                case m[1]
-                when 'Stalemate'
-                  done = :stalemate
-                when 'Draw by repetition'
-                  done = :repetition
-                when 'Draw by fifty-move rule'
-                  done = :fifty_move_rule
-                when 'Draw by insufficient material'
-                  done = :insufficient_material
-                end
-                break
+    def gen_pgn(file_to_save, moves = [])
+      done = false
+      pipe = IO.popen('gnuchess', 'r+')
+      begin
+        pipe.write("depth 1\n")
+        pipe.write("force\n")
+        pipe.write("name chess.rb\n")
+        moves.each do |move|
+          pipe.write("#{move}\n")
+        end
+        until done
+          pipe.write("go\n")
+          while (line = pipe.gets)
+            break if /My move is : /.match?(line) || / : resign/.match?(line)
+
+            if / : 1-0 {White mates}/.match?(line)
+              done = :white_won
+              break
+            elsif / : 0-1 {Black mates}/.match?(line)
+              done = :black_won
+              break
+            elsif (m = line.match(/1\/2-1\/2 {(.*?)}/))
+              case m[1]
+              when 'Stalemate'
+                done = :stalemate
+              when 'Draw by repetition'
+                done = :repetition
+              when 'Draw by fifty-move rule'
+                done = :fifty_move_rule
+              when 'Draw by insufficient material'
+                done = :insufficient_material
               end
+              break
             end
           end
-          dir = File.dirname(file_to_save)
-          name = File.basename(file_to_save)
-          pipe.write("pgnsave #{File.join(dir, done.to_s, name)}\n")
-        ensure
-          pipe.write("quit\n")
-          pipe.close
         end
+        dir = File.dirname(file_to_save)
+        name = File.basename(file_to_save)
+        pipe.write("pgnsave #{File.join(dir, done.to_s, name)}\n")
+      ensure
+        pipe.write("quit\n")
+        pipe.close
       end
+    end
   end
 end

data/lib/chess/pgn.rb

@@ -40,7 +40,6 @@ module Chess
     def initialize(filename = nil, check_moves: false)
       self.load(filename, check_moves: check_moves) if filename
       @date = '??'
-      @round = '1'
     end
 
     # Load a PGN from file.
@@ -50,7 +49,7 @@ module Chess
     # @raise [InvalidPgnFormatError]
     # @raise [IllegalMoveError]
     def load(filename, check_moves: false)
-      str = File.open(filename, 'r').read
+      str = File.read(filename)
       load_from_string(str, check_moves: check_moves)
     end
 
@@ -70,12 +69,10 @@ module Chess
       raise Chess::InvalidPgnFormatError.new if game_index.nil?
 
       game = str[game_index..-1].strip
-      @moves = game.tr("\n", ' ').split(/\d+\./).collect(&:strip)[1..-1].collect { |t| t.split(' ') }.flatten
-      @moves.delete_at(@moves.size - 1) if @moves.last =~ /(0-1)|(1-0)|(1\/2)|(1\/2-1\/2)|(\*)/
+      @moves = game.tr("\n", ' ').split(/\d+\./).collect(&:strip)[1..-1].map(&:split).flatten
+      @moves.delete_at(@moves.size - 1) if @moves.last.match?(/(0-1)|(1-0)|(1\/2)|(1\/2-1\/2)|(\*)/)
       @moves.each do |m|
-        if m !~ MOVE_REGEXP && m !~ SHORT_CASTLING_REGEXP && m !~ LONG_CASTLING_REGEXP
-          raise Chess::InvalidPgnFormatError.new
-        end
+        raise Chess::InvalidPgnFormatError.new if m !~ MOVE_REGEXP && m !~ SHORT_CASTLING_REGEXP && m !~ LONG_CASTLING_REGEXP
       end
       Chess::Game.new(@moves) if check_moves
       return self
@@ -85,13 +82,13 @@ module Chess
     def to_s
       s = ''
       TAGS.each do |t|
-        tag = instance_variable_get("@#{t}")
+        tag = instance_variable_defined?("@#{t}") ? instance_variable_get("@#{t}") : ''
         s << "[#{t.capitalize} \"#{tag}\"]\n"
       end
       s << "\n"
       m = ''
       @moves.each_with_index do |move, i|
-        m << "#{i / 2 + 1}. " if i.even?
+        m << "#{(i / 2) + 1}. " if i.even?
         m << "#{move} "
       end
       m << @result unless @result.nil?
@@ -101,7 +98,7 @@ module Chess
     # Write PGN to file.
     # @param [String] filename The path of the PGN file.
     def write(filename)
-      File.open(filename, 'w') { |f| f.write(self.to_s) }
+      File.write(filename, self.to_s)
     end
 
     # # @!visibility private
@@ -109,11 +106,12 @@ module Chess
 
     # Set the date tag.
     def date=(value)
-      if value.is_a?(Time)
-        @date = value.strftime('%Y.%m.%d')
-      else
-        @date = value
-      end
+      @date =
+        if value.is_a?(Time)
+          value.strftime('%Y.%m.%d')
+        else
+          value
+        end
     end
   end
 end

data/lib/chess/version.rb

@@ -1,5 +1,5 @@
 # The Chess library module.
 module Chess
   # The library version.
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.3.3'.freeze
 end

data/test/test_big_pgn_collection.rb

@@ -11,7 +11,7 @@ class ChessTest < Minitest::Test
       define_method "test_big_pgn_#{filename}" do
         pgn = Chess::Pgn.new(path)
         game = Chess::Game.new(pgn.moves)
-        assert(game.checkmate?) if pgn.moves.last =~ /\#$/
+        assert(game.checkmate?) if pgn.moves.last.match?(/\#$/)
       end
     end
   end

data/test/test_checkmate.rb

@@ -9,11 +9,11 @@ class ChessTest < Minitest::Test
       game = Chess::Game.new(pgn.moves)
       assert(game.board.checkmate?)
       if file.include?('white_won')
-        assert_equal(game.result, '1-0')
-        assert_equal(game.active_player, :black)
+        assert_equal('1-0', game.result)
+        assert_equal(:black, game.active_player)
       elsif file.include?('black_won')
-        assert_equal(game.result, '0-1')
-        assert_equal(game.active_player, :white)
+        assert_equal('0-1', game.result)
+        assert_equal(:white, game.active_player)
       end
     end
   end

data/test/test_errors.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+class ChessTest < Minitest::Test
+  def test_bad_notation_error
+    game = Chess::Game.new
+    assert_raises(Chess::BadNotationError) do
+      game << 'gg'
+    end
+  end
+
+  def test_invalid_pgn_format_error
+    assert_raises(Chess::InvalidPgnFormatError) do
+      Chess::Pgn.new('test/pgn_collection/invalid/0001.pgn')
+    end
+  end
+
+  def test_invalid_fen_format_error
+    assert_raises(Chess::InvalidFenFormatError) do
+      Chess::Game.load_fen('invalid')
+    end
+  end
+end

data/test/test_fifty_rule_move.rb

@@ -3,10 +3,10 @@ require 'test_helper'
 class ChessTest < Minitest::Test
   TestHelper.pgns('fifty_move_rule').each do |file|
     name = File.basename(file, '.pgn')
-    define_method "test_fifty_rule_move_#{name}" do
+    define_method "test_fifty_move_rule_#{name}" do
       pgn = Chess::Pgn.new(file)
       game = Chess::Game.new(pgn.moves)
-      assert(game.board.fifty_rule_move?)
+      assert game.board.fifty_move_rule?
     end
   end
 end

data/test/test_game.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+class ChessTest < Minitest::Test
+  def test_moves
+    game = Chess::Game.new
+    game.moves = %w[e4 e5]
+    assert_equal %w[e4 e5], game.moves
+  end
+
+  def test_active_player
+    game = Chess::Game.new
+    game << 'a3'
+    assert_equal :black, game.active_player
+  end
+
+  def test_inactive_player
+    game = Chess::Game.new
+    game.moves = %w[a3 f5]
+    assert_equal :black, game.inactive_player
+  end
+
+  def test_status_white_won_resign
+    game = Chess::Game.new
+    game.resign(:black)
+    assert_equal :white_won_resign, game.status
+    assert game.over?
+    assert_equal '1-0', game.result
+  end
+
+  def test_status_black_won_resign
+    game = Chess::Game.new
+    game << 'e4'
+    game.resign(:white)
+    assert_equal :black_won_resign, game.status
+    assert game.over?
+    assert_equal '0-1', game.result
+  end
+
+  def test_status_insufficient_material
+    pgn = TestHelper.pick_pgn('insufficient_material/0001.pgn')
+    game = Chess::Game.new(pgn.moves)
+    assert_equal :insufficient_material, game.status
+  end
+
+  def test_status_fifty_move_rule
+    pgn = TestHelper.pick_pgn('fifty_move_rule/0001.pgn')
+    game = Chess::Game.new(pgn.moves)
+    game.draw
+    assert_equal :fifty_move_rule, game.status
+  end
+
+  def test_status_threefold_repetition
+    pgn = TestHelper.pick_pgn('threefold_repetition/0001.pgn')
+    game = Chess::Game.new(pgn.moves)
+    game.draw
+    assert_equal :threefold_repetition, game.status
+  end
+
+  def test_pgn
+    pgn = TestHelper.pick_pgn('valid/0001.pgn')
+    game = Chess::Game.new(pgn.moves)
+    expected_pgn = <<~PGN
+      [Event ""]
+      [Site ""]
+      [Date "??"]
+      [Round ""]
+      [White ""]
+      [Black ""]
+      [Result "*"]
+
+      1. e4 c5 2. Nf3 d6 3. d4 cxd4 4. Qxd4 Nc6 5. Bb5 Bd7 6. Bxc6 Bxc6 7. Bg5 Nf6
+      8. Bxf6 gxf6 9. Nc3 e6 10. O-O-O Be7 11. Rhe1 Rg8 12. Qe3 Rxg2 13. Rg1 Rg6 14.
+      Nd4 Qb6 15. h4 O-O-O 16. h5 Rg5 17. Nd5 Bxd5 18. exd5 e5 19. Qh3+ Kb8 20. Nf5
+      Bf8 21. Rxg5 fxg5 22. Ne3 Qb4 23. c4 g4 24. Qxg4 Bh6 25. Kb1 Rc8 26. Rc1 Qd2
+      27. Qf5 Bf4 28. Qc2 Qxc2+ 29. Rxc2 Rg8 30. b4 Rg5 31. c5 e4 32. c6 Rxh5 33.
+      Rc4 f5 34. b5 Rg5 35. Rc3 Be5 36. Rc1 Bd4 37. Nc4 Bc5 38. Ne5 dxe5 39. Rxc5
+      Rg6 40. a4 Rd6 41. a5 b6 42. axb6 axb6 43. Rc2 Rxd5 44. Rb2 h5 45. Ka2 h4 46.
+      Ka3 h3 47. Ka4 Rd1 *
+    PGN
+    assert_equal expected_pgn, game.pgn.to_s
+  end
+end

data/test/test_helper.rb

@@ -1,5 +1,15 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'lib/chess/gnuchess.rb'
+end
+if ENV['CODECOV'] == 'true'
+  require 'codecov'
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end
+
 require 'chess'
 require 'minitest/autorun'
+require 'byebug'
 
 module TestHelper
   PGN_COLLECTION = 'test/pgn_collection'.freeze
@@ -8,4 +18,9 @@ module TestHelper
   def self.pgns(path, prefix = PGN_COLLECTION)
     Dir[File.join(prefix, path, '**/*.pgn')]
   end
+
+  def self.pick_pgn(path, prefix = PGN_COLLECTION)
+    file = File.join(prefix, path)
+    return Chess::Pgn.new(file)
+  end
 end

data/test/test_insufficient_material.rb

@@ -17,15 +17,15 @@ class ChessTest < Minitest::Test
   FENS.each_with_index do |fen, i|
     define_method("test_insufficient_material_by_fen_#{i}") do
       game = Chess::Game.load_fen(fen)
-      assert(game.board.insufficient_material?)
+      assert game.board.insufficient_material?
     end
   end
 
   ONLY_KINGS_FENS.each_with_index do |fen, i|
     define_method("test_only_kings_by_fen_#{i}") do
       game = Chess::Game.load_fen(fen)
-      assert(game.board.insufficient_material?)
-      assert(game.board.only_kings?)
+      assert game.board.insufficient_material?
+      assert game.board.only_kings?
     end
   end
 
@@ -34,7 +34,7 @@ class ChessTest < Minitest::Test
     define_method "test_insufficient_material_#{name}" do
       pgn = Chess::Pgn.new(file)
       game = Chess::Game.new(pgn.moves)
-      assert(game.board.insufficient_material?)
+      assert game.board.insufficient_material?
     end
   end
 end

data/test/test_move_generator.rb

@@ -2,7 +2,7 @@ require 'test_helper'
 
 class ChessTest < Minitest::Test
   GENS = {
-    'r2qk3/8/2n5/8/8/8/p2B4/4K2R w K - 0 1' => { 'e1' => ['Kd1', 'Ke2', 'Kf2', 'Kf1', 'O-O'] },
+    'r2qk3/8/2n5/8/8/8/p2B4/4K2R w K - 0 1' => { 'e1' => %w[Kd1 Ke2 Kf2 Kf1 O-O] },
     'r2qk3/8/2n5/8/8/8/p2B4/4K2R w - - 0 1' => { 'e1' => %w[Kd1 Ke2 Kf2 Kf1] },
     'r2qk3/8/2n5/2b5/8/8/p2B4/4K2R w K - 0 1' => { 'e1' => %w[Kd1 Ke2 Kf1] },
     'r2qk3/8/2n5/2b5/8/8/p2B4/4K2R b K - 0 1' => { 'a2' => ['a1=Q'] },
@@ -12,7 +12,8 @@ class ChessTest < Minitest::Test
     '1B1k4/r3q3/2n1n3/2b2pP1/8/8/2nB4/3K3R b - - 0 1' => { 'c6' => %w[Nxb8 Ne5 Nc6d4 N6b4 Na5] },
     '1B1k4/r3q3/2n1n2P/2b5/5p2/3p1RP1/3B4/3K4 w - - 0 1' => { 'f3' => %w[Rxd3 Re3 Rxf4 Rf2 Rf1] },
     'k7/1Q6/2P5/8/8/8/8/3K4 b - - 0 1' => { 'a8' => [] },
-    'k7/6P1/8/8/8/3r4/3Q4/3K4 w - - 0 1' => { 'd2' => ['Qxd3'] }
+    'k7/6P1/8/8/8/3r4/3Q4/3K4 w - - 0 1' => { 'd2' => ['Qxd3'] },
+    'rnbqkbnr/1ppppppp/8/8/pP2P3/P7/2PP1PPP/RNBQKBNR w KQkq - 0 3' => { 'c2' => %w[c3 c4] }
   }.freeze
 
   GENS.each do |fen, generators|

data/test/test_pgn.rb

@@ -67,4 +67,39 @@ class ChessTest < Minitest::Test
     assert_nil pgn.result
     assert_equal 'Re6', pgn.moves.last
   end
+
+  def test_write_pgn
+    tempfile = Tempfile.new('test_pgn')
+    game = Chess::Game.new
+    game.moves = %w[e4 e5 d3]
+    pgn = game.pgn
+    pgn.event = 'Ruby Chess Tournament'
+    pgn.site = 'Ruby Chess test suite'
+    pgn.date = '1984.10.21'
+    pgn.round = '2'
+    pgn.white = 'Pioz'
+    pgn.black = 'Elizabeth Harmon'
+    pgn.write(tempfile.path)
+
+    loaded_pgn = Chess::Pgn.new
+    loaded_pgn.load(tempfile.path)
+    tempfile.delete
+    assert_equal 'Ruby Chess Tournament', loaded_pgn.event
+    assert_equal 'Ruby Chess test suite', loaded_pgn.site
+    assert_equal '1984.10.21', loaded_pgn.date
+    assert_equal '2', loaded_pgn.round
+    assert_equal 'Pioz', loaded_pgn.white
+    assert_equal 'Elizabeth Harmon', loaded_pgn.black
+    assert_equal '*', loaded_pgn.result
+    assert_equal %w[e4 e5 d3], loaded_pgn.moves
+  end
+
+  def test_set_date
+    pgn = Chess::Pgn.new
+    pgn.date = Time.parse('21-10-1984')
+    assert_equal '1984.10.21', pgn.date
+
+    pgn.date = '1984.10.21'
+    assert_equal '1984.10.21', pgn.date
+  end
 end

data/test/test_pgn_collection.rb

@@ -8,8 +8,8 @@ class ChessTest < Minitest::Test
       game = Chess::Game.new
       pgn.moves.each do |m|
         game.move(m)
-        assert(game.board.check?) if m =~ /\+$/
-        assert(game.board.checkmate?) if m =~ /\#$/
+        assert(game.board.check?) if m.match?(/\+$/)
+        assert(game.board.checkmate?) if m.match?(/\#$/)
       end
     end
     define_method "test_pgn_result_#{name}" do