pgn2 1.4.0 → 2.0.0

data/lib/pgn/notation.rb

@@ -133,7 +133,7 @@ module PGN
     # Other squares holding `piece` whose move to `to_idx` is legal.
     def same_type_legals(piece, from_idx, to_idx)
       (0...128).each_with_object([]) do |idx, acc|
-        next if (idx & 0x88) != 0
+        next if idx.anybits?(0x88)
         next if idx == from_idx
         next unless @board.at_index(idx) == piece
 
@@ -230,9 +230,9 @@ module PGN
 
       case piece.upcase
       when 'N'
-        KNIGHT_OFFS.any? { |o| (from_idx + o) == to_idx }
+        Board::KNIGHT_ATTACKS[from_idx].include?(to_idx)
       when 'K'
-        KING_OFFS.any? { |o| (from_idx + o) == to_idx }
+        Board::KING_ATTACKS[from_idx].include?(to_idx)
       when 'B', 'R', 'Q'
         slider_reaches?(piece.upcase, from_idx, to_idx)
       else
@@ -243,7 +243,7 @@ module PGN
     def slider_reaches?(piece_up, from_idx, to_idx)
       slider_dirs(piece_up).any? do |off|
         i = from_idx + off
-        while (i & 0x88).zero?
+        while i.nobits?(0x88)
           return true if i == to_idx
           break if @board.at_index(i)
 
@@ -264,7 +264,7 @@ module PGN
     end
 
     def own?(piece, color)
-      color == 'w' ? piece == piece.upcase : piece == piece.downcase
+      piece == (color == 'w' ? piece.upcase : piece.downcase)
     end
 
     # Slider ray directions for a piece letter ('B'/'R'/'Q').
@@ -281,7 +281,7 @@ module PGN
     def king_idx(board, color)
       king = color == 'w' ? 'K' : 'k'
       (0...128).each do |idx|
-        next if (idx & 0x88) != 0
+        next if idx.anybits?(0x88)
 
         return idx if board.at_index(idx) == king
       end
@@ -301,24 +301,18 @@ module PGN
       pawn = color == 'w' ? 'P' : 'p'
       offs.any? do |off|
         i = target + off
-        (i & 0x88).zero? && board.at_index(i) == pawn
+        i.nobits?(0x88) && board.at_index(i) == pawn
       end
     end
 
     def knight_attacked?(board, target, color)
       knight = color == 'w' ? 'N' : 'n'
-      KNIGHT_OFFS.any? do |off|
-        i = target + off
-        (i & 0x88).zero? && board.at_index(i) == knight
-      end
+      Board::KNIGHT_ATTACKS[target].any? { |i| board.at_index(i) == knight }
     end
 
     def king_attacked?(board, target, color)
       king = color == 'w' ? 'K' : 'k'
-      KING_OFFS.any? do |off|
-        i = target + off
-        (i & 0x88).zero? && board.at_index(i) == king
-      end
+      Board::KING_ATTACKS[target].any? { |i| board.at_index(i) == king }
     end
 
     def slider_attacked?(board, target, color)
@@ -332,10 +326,11 @@ module PGN
     def ray_hit?(board, target, dirs)
       dirs.each do |off|
         i = target + off
-        while (i & 0x88).zero?
+        while i.nobits?(0x88)
           piece = board.at_index(i)
           if piece
             return true if yield(piece)
+
             break
           end
           i += off
@@ -352,7 +347,7 @@ module PGN
       ep_idx = ep_target_idx(position, board)
 
       (0...128).any? do |idx|
-        next if (idx & 0x88) != 0
+        next if idx.anybits?(0x88)
 
         piece = board.at_index(idx)
         piece && own?(piece, color) && move_from?(board, idx, piece, color, ep_idx)
@@ -370,8 +365,8 @@ module PGN
     def move_from?(board, idx, piece, color, ep_idx)
       up = piece.upcase
       case up
-      when 'N' then leaper_moves?(board, idx, piece, color, KNIGHT_OFFS)
-      when 'K' then leaper_moves?(board, idx, piece, color, KING_OFFS)
+      when 'N' then leaper_moves?(board, idx, piece, color, Board::KNIGHT_ATTACKS[idx])
+      when 'K' then leaper_moves?(board, idx, piece, color, Board::KING_ATTACKS[idx])
       when 'B', 'R', 'Q'
         slider_moves?(board, idx, piece, color, slider_dirs(up))
       when 'P'
@@ -381,22 +376,22 @@ module PGN
       end
     end
 
-    def leaper_moves?(board, idx, piece, color, offs)
-      offs.any? do |off|
-        t = idx + off
-        (t & 0x88).zero? && landable?(board, t, color) && safe?(board, idx, t, piece, nil)
+    def leaper_moves?(board, idx, piece, color, targets)
+      targets.any? do |t|
+        landable?(board, t, color) && safe?(board, idx, t, piece, nil)
       end
     end
 
     def slider_moves?(board, idx, piece, color, dirs)
       dirs.any? do |off|
         t = idx + off
-        while (t & 0x88).zero?
+        while t.nobits?(0x88)
           tp = board.at_index(t)
           if tp.nil?
             return true if safe?(board, idx, t, piece, nil)
           else
             return true if !own?(tp, color) && safe?(board, idx, t, piece, nil)
+
             break
           end
           t += off
@@ -416,24 +411,24 @@ module PGN
       promo_rank = color == 'w' ? 7 : 0
 
       t = idx + dir
-      return false unless (t & 0x88).zero? && board.at_index(t).nil?
+      return false unless t.nobits?(0x88) && board.at_index(t).nil?
 
-      promo = (t >> 4 == promo_rank) ? 'Q' : nil
+      promo = t >> 4 == promo_rank ? 'Q' : nil
       return true if safe?(board, idx, t, piece, promo)
 
       t2 = idx + (dir * 2)
       (idx >> 4) == start_rank && board.at_index(t2).nil? && safe?(board, idx, t2, piece, nil)
     end
 
-    def pawn_captures?(board, idx, piece, color, ep_idx) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def pawn_captures?(board, idx, piece, color, ep_idx)
       promo_rank = color == 'w' ? 7 : 0
       caps = color == 'w' ? [15, 17] : [-15, -17]
       caps.any? do |off|
         t = idx + off
-        next false unless (t & 0x88).zero?
+        next false unless t.nobits?(0x88)
 
         tp = board.at_index(t)
-        promo = (t >> 4 == promo_rank) ? 'Q' : nil
+        promo = t >> 4 == promo_rank ? 'Q' : nil
         if tp && !own?(tp, color)
           safe?(board, idx, t, piece, promo)
         elsif tp.nil? && t == ep_idx

data/lib/pgn/position.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PGN
   # {PGN::Position} encapsulates all of the information necessary to
   # completely understand a chess position. It can be turned into a FEN string
@@ -31,12 +33,7 @@ module PGN
     PLAYERS  = %i[white black].freeze
     CASTLING = %w[K Q k q].freeze
 
-    attr_accessor :board
-    attr_accessor :player
-    attr_accessor :castling
-    attr_accessor :en_passant
-    attr_accessor :halfmove
-    attr_accessor :fullmove
+    attr_accessor :board, :player, :castling, :en_passant, :halfmove, :fullmove
 
     # @return [PGN::Position] the starting position of a chess game
     #
@@ -83,17 +80,10 @@ module PGN
 
       restrictions = calculator.castling_restrictions
       new_castling = restrictions.empty? ? castling : castling - restrictions
-      new_halfmove = if calculator.increment_halfmove?
-                       halfmove + 1
-                     else
-                       0
-                     end
-      new_fullmove = if calculator.increment_fullmove?
-                       fullmove + 1
-                     else
-                       fullmove
-                     end
-      no_move = str == '--'
+      new_halfmove = calculator.increment_halfmove? ? halfmove + 1 : 0
+      new_fullmove = calculator.increment_fullmove? ? fullmove + 1 : fullmove
+      no_move      = str == '--'
+
       PGN::Position.new(
         no_move ? board : calculator.result_board,
         next_player,
@@ -110,8 +100,32 @@ module PGN
       player == :white ? :black : :white
     end
 
+    # The perft node count at +depth+ from this position, computed by the
+    # native bitboard engine via a FEN round-trip. Requires the compiled
+    # native extension (the shipped gem); raises NameError if it is absent.
+    #
+    # @param depth [Integer] search depth, >= 0
+    # @return [Integer]
+    #
+    def perft(depth)
+      raise ArgumentError, 'depth must be a non-negative Integer' unless depth.is_a?(Integer) && depth >= 0
+
+      PGN::Bitboard::Engine.new(to_fen.to_s).perft(depth)
+    end
+
+    # All legal moves from this position as sorted UCI strings
+    # (e.g. "e2e4", "e1g1" for castling, "e7e8q" for promotion), computed
+    # by the native bitboard engine via a FEN round-trip. Requires the
+    # compiled native extension; raises NameError if it is absent.
+    #
+    # @return [Array<String>] sorted lexicographically
+    #
+    def legal_moves
+      PGN::Bitboard::Engine.new(to_fen.to_s).legal_moves
+    end
+
     def inspect
-      "\n" + board.inspect
+      "\n#{board.inspect}"
     end
 
     # @return [PGN::FEN] a {PGN::FEN} object representing the current position
@@ -120,11 +134,38 @@ module PGN
       PGN::FEN.from_attributes(
         board: board,
         active: player == :white ? 'w' : 'b',
-        castling: castling.join(''),
+        castling: castling.join,
         en_passant: en_passant,
         halfmove: halfmove.to_s,
         fullmove: fullmove.to_s
       )
     end
+
+    # Positions are equal when their board, side to move, castling rights,
+    # and en-passant square match. Halfmove/fullmove counters are ignored
+    # (matching threefold-repetition semantics).
+    def eql?(other)
+      other.is_a?(PGN::Position) &&
+        player == other.player &&
+        castling == other.castling &&
+        en_passant == other.en_passant &&
+        zobrist == other.zobrist &&
+        board == other.board
+    end
+
+    alias == eql?
+
+    def hash
+      zobrist
+    end
+
+    # The Zobrist hash of the position. Computed lazily on first access and
+    # cached, so the replay hot path (which never asks for the hash) pays
+    # nothing; consumers like threefold-repetition checks pay one full seed.
+    #
+    # @return [Integer]
+    def zobrist
+      @zobrist ||= Zobrist.seed(board, player, castling, en_passant)
+    end
   end
 end

data/lib/pgn/serializer.rb

@@ -17,7 +17,7 @@ module PGN
 
     # @return [String] a canonical PGN string ending with a trailing newline
     def to_s
-      tag_section + "\n\n" + movetext_section + "\n"
+      "#{tag_section}\n\n#{movetext_section}\n"
     end
 
     private
@@ -39,18 +39,16 @@ module PGN
     # result, all joined by spaces.
     def movetext_section
       tokens = []
-      if @game.comment && !@game.comment.empty?
-        tokens << "{ #{escape_comment(@game.comment)} }"
-      end
+      tokens << "{ #{escape_comment(@game.comment)} }" if @game.comment && !@game.comment.empty?
       line = emit_line(@game.moves, starting_fullmove, starting_player)
       tokens << line unless line.empty?
       tokens << result_token
-      tokens.join(" ")
+      tokens.join(' ')
     end
 
     # The result token: the game's result if present and non-empty, else "*".
     def result_token
-      (@game.result.nil? || @game.result.empty?) ? "*" : @game.result
+      @game.result.nil? || @game.result.empty? ? '*' : @game.result
     end
 
     # Emit a single line (mainline or variation) of movetext, tracking the
@@ -63,12 +61,11 @@ module PGN
       moves.each do |move|
         if player == :white
           tokens << "#{fullmove}."
-          tokens << move_token(move, fullmove, player)
         else # black
           need_number = prev_player.nil? || prev_had_extras || prev_player != :white
           tokens << "#{fullmove}..." if need_number
-          tokens << move_token(move, fullmove, player)
         end
+        tokens << move_token(move, fullmove, player)
 
         prev_player = player
         prev_had_extras = has_extras?(move)
@@ -76,7 +73,7 @@ module PGN
         player = opposite(player)
       end
 
-      tokens.join(" ")
+      tokens.join(' ')
     end
 
     # A move token: notation plus trailing extras (annotation, comment,
@@ -85,13 +82,11 @@ module PGN
     def move_token(move, fullmove, player)
       parts = [move.notation]
       (move.annotation || []).each { |a| parts << a }
-      if move.comment && !move.comment.empty?
-        parts << "{ #{escape_comment(move.comment)} }"
-      end
+      parts << "{ #{escape_comment(move.comment)} }" if move.comment && !move.comment.empty?
       (move.variations || []).each do |variation|
         parts << "(#{emit_line(variation, fullmove, player)})"
       end
-      parts.join(" ")
+      parts.join(' ')
     end
 
     # Whether a move carries any annotation, comment, or variation.
@@ -118,8 +113,8 @@ module PGN
     # string replacement would otherwise re-interpret backslashes).
     def escape_tag(value)
       value.to_s
-           .gsub("\\") { "\\\\" }
-           .gsub('"') { "\\\"" }
+           .gsub('\\') { '\\\\' }
+           .gsub('"') { '\"' }
     end
 
     # Escape backslashes and braces for a comment body (block form, so the
@@ -133,9 +128,9 @@ module PGN
     # acknowledged v1 limitation.
     def escape_comment(text)
       text.to_s
-          .gsub("\\") { "\\\\" }
-          .gsub("{") { "\\{" }
-          .gsub("}") { "\\}" }
+          .gsub('\\') { '\\\\' }
+          .gsub('{') { '\\{' }
+          .gsub('}') { '\\}' }
     end
   end
 end

data/lib/pgn/version.rb

@@ -1,3 +1,3 @@
 module PGN
-  VERSION = '1.4.0'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/lib/pgn/zobrist.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module PGN
+  # Zobrist hashing keys for incremental position hashing. All keys are
+  # fixed 64-bit pseudo-random Integers generated once at load time from a
+  # frozen seed so hashes are stable for the life of the process.
+  #
+  # Indexing is by 0x88 square index (0..127); off-board indices are
+  # allocated but never read.
+  module Zobrist
+    SEED = 0x1234_5678_9abc_def1
+
+    # Deterministic pseudo-random generator so hashes are stable per
+    # process and across machines (no Kernel#rand).
+    def self.gen
+      @gen ||= Random.new(SEED)
+    end
+    private_class_method :gen
+
+    def self.rand64
+      gen.rand(1 << 64)
+    end
+    private_class_method :rand64
+
+    PIECES = %w[P N B R Q K p n b r q k].freeze
+
+    TABLE = PIECES.to_h { |piece| [piece, Array.new(128) { rand64 }] }.freeze
+
+    SIDE = rand64
+    CASTLING = { 'K' => rand64, 'Q' => rand64, 'k' => rand64, 'q' => rand64 }.freeze
+    EP_FILE = Array.new(8) { rand64 }.freeze
+
+    # @param board [PGN::Board]
+    # @param player [Symbol] :white or :black
+    # @param castling [Array<String>] e.g. %w[K Q k q]
+    # @param en_passant [String, nil] e.g. "e3" or nil
+    # @return [Integer] the Zobrist hash of the position
+    def self.seed(board, player, castling, en_passant)
+      h = 0
+      0.upto(7) do |rank|
+        0.upto(7) do |file|
+          idx = board.index_for(file, rank)
+          piece = board.at_index(idx)
+          h ^= TABLE[piece][idx] if piece
+        end
+      end
+      h ^= SIDE if player == :black
+      castling.to_a.each { |right| h ^= CASTLING[right] if CASTLING.key?(right) }
+      h ^= EP_FILE[Board::FILE_TO_INDEX[en_passant[0]]] if en_passant && !en_passant.empty?
+      h
+    end
+  end
+end

data/lib/pgn.rb

@@ -5,11 +5,13 @@ require 'pgn/move'
 require 'pgn/move_calculator'
 require 'pgn/lexer'
 require 'pgn/notation'
+require 'pgn/zobrist'
 require 'pgn/pgn_parser'
 require 'pgn/parser'
 require 'pgn/position'
 require 'pgn/serializer'
 require 'pgn/version'
+require 'pgn/bitboard'
 
 module PGN
   # @param pgn [String] a pgn representation of one or more chess games

data/pgn2.gemspec

@@ -1,3 +1,4 @@
+require 'English'
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'pgn/version'
@@ -10,27 +11,33 @@ Gem::Specification.new do |spec|
   spec.description   = 'A PGN parser and FEN generator for Ruby'
   spec.summary       = 'A PGN parser for Ruby'
   spec.homepage      = 'https://github.com/muriloime/pgn'
-  spec.license       = 'MIT'
+  spec.licenses      = ['MIT', 'MPL-2.0']
   spec.required_ruby_version = '>= 3.0'
 
   spec.metadata = {
-    'homepage_uri'      => 'https://github.com/muriloime/pgn',
-    'source_code_uri'   => 'https://github.com/muriloime/pgn',
-    'bug_tracker_uri'   => 'https://github.com/muriloime/pgn/issues',
-    'changelog_uri'     => 'https://github.com/muriloime/pgn/blob/main/CHANGELOG.md'
+    'homepage_uri' => 'https://github.com/muriloime/pgn',
+    'source_code_uri' => 'https://github.com/muriloime/pgn',
+    'bug_tracker_uri' => 'https://github.com/muriloime/pgn/issues',
+    'changelog_uri' => 'https://github.com/muriloime/pgn/blob/main/CHANGELOG.md',
+    'rubygems_mfa_required' => 'true'
   }
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
+  spec.extensions = ['ext/pgn2_native/extconf.rb']
+  spec.add_dependency 'rb_sys', '~> 0.9.39'
+  spec.add_development_dependency 'rake-compiler', '~> 1.2'
+  spec.add_development_dependency 'rake-compiler-dock', '~> 1.6'
+
+  spec.add_development_dependency 'benchmark-ips'
   spec.add_development_dependency 'bundler', '~> 2.3'
+  spec.add_development_dependency 'bundler-audit'
+  spec.add_development_dependency 'memory_profiler'
   spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'racc'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'racc'
-  spec.add_development_dependency 'benchmark-ips'
-  spec.add_development_dependency 'memory_profiler'
   spec.add_development_dependency 'rubocop', '~> 1.60'
 end

data/spec/bitboard_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+RSpec.describe PGN::Bitboard::Engine do
+  let(:startpos) { 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1' }
+
+  # The native extension is optional from the gem's perspective; skip the
+  # whole suite if it isn't compiled in this environment.
+  skip 'native extension PGN::Bitboard::Engine not compiled' unless PGN::Bitboard.const_defined?(:Engine)
+
+  it 'perfts the start position' do
+    e = described_class.new(startpos)
+    expect(e.perft(1)).to eq(20)
+    expect(e.perft(2)).to eq(400)
+    expect(e.perft(3)).to eq(8902)
+    expect(e.perft(4)).to eq(197_281)
+  end
+
+  it 'perfts Kiwipete' do
+    e = described_class.new('r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1')
+    expect(e.perft(1)).to eq(48)
+    expect(e.perft(3)).to eq(97_862)
+  end
+
+  it 'raises on a bad FEN' do
+    expect { described_class.new('not a fen') }.to raise_error(ArgumentError)
+  end
+
+  it 'lists legal moves in sorted UCI' do
+    e = described_class.new(startpos)
+    moves = e.legal_moves
+    expect(moves.length).to eq(20)
+    expect(moves).to eq(moves.sort)
+    expect(moves).to include('e2e4', 'g1f3', 'd2d4')
+  end
+
+  it 'answers legal? with UCI' do
+    e = described_class.new(startpos)
+    expect(e.legal?('e2e4')).to be(true)
+    expect(e.legal?('e2e5')).to be(false)
+    expect(e.legal?('g1f3')).to be(true)
+  end
+
+  it 'encodes promotions in legal_moves' do
+    e = described_class.new('8/P7/8/8/8/8/8/4k2K w - - 0 1')
+    moves = e.legal_moves
+    expect(moves).to include('a7a8q', 'a7a8r', 'a7a8b', 'a7a8n')
+  end
+
+  it 'recognizes castling as legal' do
+    e = described_class.new('r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1')
+    expect(e.legal?('e1g1')).to be(true)
+    expect(e.legal?('e1c1')).to be(true)
+  end
+end

data/spec/board_spec.rb

@@ -7,6 +7,36 @@ describe PGN::Board do
     end
   end
 
+  describe 'attack masks' do
+    it 'KNIGHT_ATTACKS lists the on-board knight targets for each 0x88 index' do
+      expect(PGN::Board::KNIGHT_ATTACKS[0]).to contain_exactly(18, 33) # a1: c3(0x12), b3(0x21)
+      expect(PGN::Board::KNIGHT_ATTACKS[0x54].length).to eq(8) # e4 = 0x54, centre
+      expect(PGN::Board::KNIGHT_ATTACKS[0x77]).to contain_exactly(86, 101) # h8: f7(0x56), g6(0x65)
+    end
+
+    it 'KING_ATTACKS lists the on-board king targets for each 0x88 index' do
+      expect(PGN::Board::KING_ATTACKS[0]).to contain_exactly(1, 16, 17) # a1: b1, a2, b2
+      expect(PGN::Board::KING_ATTACKS[0x54].length).to eq(8)
+      expect(PGN::Board::KING_ATTACKS[0x77]).to contain_exactly(102, 103, 118) # h8: g7, h7, g8
+    end
+
+    it 'only contains on-board squares and is nil for off-board source indices' do
+      on_board = (0...128).select { |i| i.nobits?(0x88) }
+      expect(PGN::Board::KNIGHT_ATTACKS.length).to eq(128)
+      expect(PGN::Board::KING_ATTACKS.length).to eq(128)
+      on_board.each do |i|
+        expect(PGN::Board::KNIGHT_ATTACKS[i]).to be_an(Array)
+        expect(PGN::Board::KING_ATTACKS[i]).to be_an(Array)
+        expect(PGN::Board::KNIGHT_ATTACKS[i]).to all(satisfy { |sq| sq.nobits?(0x88) })
+        expect(PGN::Board::KING_ATTACKS[i]).to all(satisfy { |sq| sq.nobits?(0x88) })
+      end
+      (0...128).reject { |i| i.nobits?(0x88) }.each do |i|
+        expect(PGN::Board::KNIGHT_ATTACKS[i]).to be_nil
+        expect(PGN::Board::KING_ATTACKS[i]).to be_nil
+      end
+    end
+  end
+
   describe '#at' do
     # Use .dup because PGN::Board.start returns the same shared board
     # backed by the frozen START constant.
@@ -100,6 +130,29 @@ describe PGN::Board do
     end
   end
 
+  describe '#fen_board_string' do
+    it 'serializes the start position to the FEN board string' do
+      expect(PGN::Board.start.fen_board_string)
+        .to eq('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR')
+    end
+
+    it 'collapses runs of empty squares into digits' do
+      board = PGN::FEN.new('8/8/8/8/8/8/8/8 w - - 0 1').board
+      expect(board.fen_board_string).to eq('8/8/8/8/8/8/8/8')
+    end
+
+    it 'serializes a mid-game board byte-for-byte like FEN#board_string' do
+      fen = 'r1bqkb1r/pp1p1ppp/2n1pn2/8/3NP3/2N5/PPP2PPP/R1BQKB1R w KQkq - 3 6'
+      board = PGN::FEN.new(fen).board
+      expect(board.fen_board_string).to eq(fen.split.first)
+    end
+
+    it 'serializes rank 8 first and rank 1 last (FEN order)' do
+      board = PGN::FEN.new('4k3/8/8/8/8/8/8/4K3 w - - 0 1').board
+      expect(board.fen_board_string).to eq('4k3/8/8/8/8/8/8/4K3')
+    end
+  end
+
   describe '#inspect' do
     it 'returns a string with unicode pieces and newlines' do
       inspected = PGN::Board.start.inspect