pgn2 1.5.0 → 2.0.1

data/spec/position_attack_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe PGN::Position, 'attack helpers' do
+  describe '#in_check?' do
+    it 'is false for the start position' do
+      expect(PGN::Position.start.in_check?).to be(false)
+    end
+
+    it 'is true when the side to move is checked' do
+      # White king on e1, black rook on e2 giving check.
+      pos = PGN::FEN.new('4k3/8/8/8/8/8/4r3/4K3 w - - 0 1').to_position
+      expect(pos.in_check?).to be(true)
+    end
+
+    it 'is false when a piece blocks the check' do
+      pos = PGN::FEN.new('4k3/8/8/8/8/8/4p3/4R1K1 w - - 0 1').to_position
+      expect(pos.in_check?).to be(false)
+    end
+
+    it 'is false for black to move when black is not in check' do
+      pos = PGN::FEN.new('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR b KQkq - 0 1').to_position
+      expect(pos.in_check?).to be(false)
+    end
+  end
+
+  describe '#attackers' do
+    it 'lists the attacking squares for the opponent color' do
+      pos = PGN::FEN.new('4k3/8/8/8/8/8/4r3/4K3 w - - 0 1').to_position
+      # White king on e1 is attacked by the black rook on e2.
+      expect(pos.attackers('e1')).to include('e2')
+    end
+
+    it 'lists pawn attackers' do
+      # White pawn d5 attacks e6 and c6; ask for attackers of e6 by white.
+      pos = PGN::FEN.new('4k3/8/8/3P4/8/8/8/4K3 w - - 0 1').to_position
+      expect(pos.attackers('e6', 'w')).to include('d5')
+    end
+
+    it 'lists knight attackers' do
+      pos = PGN::FEN.new('4k3/8/8/8/8/2N5/8/4K3 w - - 0 1').to_position
+      expect(pos.attackers('e4', 'w')).to include('c3')
+    end
+
+    it 'lists bishop/rook/queen attackers' do
+      pos = PGN::FEN.new('4k3/8/8/8/8/8/8/Q3K3 w - - 0 1').to_position
+      expect(pos.attackers('a8', 'w')).to include('a1')
+    end
+
+    it 'returns an empty array when nothing attacks the square' do
+      pos = PGN::Position.start
+      expect(pos.attackers('e4')).to eq([])
+    end
+  end
+end

data/spec/position_legal_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe PGN::Position, '#legal?' do
+  skip 'native extension PGN::Bitboard::Engine not compiled' unless PGN::Bitboard.const_defined?(:Engine)
+
+  let(:start) { PGN::Position.start }
+
+  it 'accepts SAN pawn moves' do
+    expect(start.legal?('e4')).to be(true)
+    expect(start.legal?('d4')).to be(true)
+    expect(start.legal?('e5')).to be(false) # no pawn on e5 can move
+  end
+
+  it 'accepts SAN piece moves' do
+    expect(start.legal?('Nf3')).to be(true)
+    expect(start.legal?('Nc3')).to be(true)
+    expect(start.legal?('Nb1')).to be(false) # no piece can move to b1 from start
+  end
+
+  it 'accepts UCI strings' do
+    expect(start.legal?('e2e4')).to be(true)
+    expect(start.legal?('e2e5')).to be(false)
+    expect(start.legal?('g1f3')).to be(true)
+    expect(start.legal?('b1a3')).to be(true) # knight on b1 can reach a3
+    expect(start.legal?('b1b3')).to be(false) # knights do not move two squares
+  end
+
+  it 'accepts SAN with check/mate suffixes' do
+    # Scholar's mate position before the queen move: 1. e4 e5 2. Bc4 Nc6 3. Qh5 Nf6?? 4. Qxf7#
+    pos = PGN::FEN.new('r1bqkb1r/pppp1ppp/2n2n2/4p2Q/2B1P3/8/PPPP1PPP/RNB1K1NR w KQkq - 4 4').to_position
+    expect(pos.legal?('Qxf7#')).to be(true)
+    expect(pos.legal?('Qxf7+')).to be(true)
+    expect(pos.legal?('Qxf7')).to be(true)
+  end
+
+  it 'accepts redundant disambiguation in SAN' do
+    # Two knights (b1 and f1) can reach d2; "Nbd2" and "Nfd2" are both legal,
+    # and the unambiguous "Nd2" is rejected as ambiguous.
+    pos = PGN::FEN.new('4k3/8/8/8/8/8/8/1N3NK1 w - - 0 1').to_position
+    expect(pos.legal?('Nbd2')).to be(true)
+    expect(pos.legal?('Nfd2')).to be(true)
+    expect(pos.legal?('Nd2')).to be(false) # ambiguous, no disambiguation
+  end
+
+  it 'handles castling SAN and UCI' do
+    pos = PGN::FEN.new('r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1').to_position
+    expect(pos.legal?('O-O')).to be(true)
+    expect(pos.legal?('O-O-O')).to be(true)
+    expect(pos.legal?('e1g1')).to be(true)
+    expect(pos.legal?('e1c1')).to be(true)
+  end
+
+  it 'handles promotion SAN and UCI' do
+    pos = PGN::FEN.new('8/P7/8/8/8/8/8/4k2K w - - 0 1').to_position
+    expect(pos.legal?('a8=Q')).to be(true)
+    expect(pos.legal?('a8=N')).to be(true)
+    expect(pos.legal?('a7a8q')).to be(true)
+    expect(pos.legal?('a7a8n')).to be(true)
+  end
+
+  it 'handles en passant SAN' do
+    pos = PGN::FEN.new('rnbqkbnr/ppp1pppp/8/3pP3/8/8/PPPP1PPP/RNBQKBNR w KQkq d6 0 3').to_position
+    expect(pos.legal?('exd6')).to be(true)
+    expect(pos.legal?('e5d6')).to be(true)
+  end
+
+  it 'rejects moves that leave the king in check' do
+    # White king on e1, rook pinning the knight on e2 to the king along the e-file.
+    pos = PGN::FEN.new('4r3/8/8/8/8/8/4N3/4K3 w - - 0 1').to_position
+    expect(pos.legal?('Nf4')).to be(false) # knight moves away, king is in check from rook
+  end
+
+  it 'returns false for malformed input' do
+    expect(start.legal?('z9z9')).to be(false)
+    expect(start.legal?('Qxh8')).to be(false) # no legal queen move from start
+    expect(start.legal?('')).to be(false)
+  end
+
+  it 'respects the side to move' do
+    # Black to move; a white move should be illegal.
+    pos = PGN::FEN.new('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR b KQkq - 0 1').to_position
+    expect(pos.legal?('e4')).to be(false)
+    expect(pos.legal?('e5')).to be(true)
+  end
+end
+
+RSpec.describe PGN::Position, '#legal_moves_san' do
+  skip 'native extension PGN::Bitboard::Engine not compiled' unless PGN::Bitboard.const_defined?(:Engine)
+
+  it 'returns 20 sorted SAN moves for the start position' do
+    sans = PGN::Position.start.legal_moves_san
+    expect(sans.length).to eq(20)
+    expect(sans).to eq(sans.sort)
+    expect(sans).to include('e4', 'Nf3', 'd4', 'a3')
+  end
+
+  it 'includes castling and promotion SAN' do
+    pos = PGN::FEN.new('r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1').to_position
+    sans = pos.legal_moves_san
+    expect(sans).to include('O-O', 'O-O-O')
+  end
+
+  it 'produces SAN whose moves are all legal? and vice versa' do
+    pos = PGN::FEN.new('r1bqkb1r/pppp1ppp/2n2n2/4p2Q/2B1P3/8/PPPP1PPP/RNB1K1NR w KQkq - 4 4').to_position
+    sans = pos.legal_moves_san
+    uci = pos.legal_moves
+    expect(sans.length).to eq(uci.length)
+    expect(sans.all? { |s| pos.legal?(s) }).to be(true)
+  end
+
+  it 'round-trips: every legal UCI maps to a SAN that legal? accepts' do
+    pos = PGN::FEN.new('rnbqkbnr/ppp1pppp/8/3pP3/8/8/PPPP1PPP/RNBQKBNR w KQkq d6 0 3').to_position
+    pos.legal_moves.each do |uci|
+      from = uci[0, 2]
+      to = uci[2, 2]
+      promo = uci[5]
+      san = PGN::Notation.san(pos, from, to, promo)
+      expect(pos.legal?(san)).to be(true), "#{san} (from #{uci}) should be legal"
+    end
+  end
+end

data/spec/position_spec.rb

@@ -1,53 +1,50 @@
 require 'spec_helper'
 
 describe PGN::Position do
-
-  describe "start" do
-
-    it "should have fullmove 1" do
+  describe 'start' do
+    it 'should have fullmove 1' do
       pos = PGN::Position.start
       pos.fullmove.should == 1
     end
-    
   end
-  
-  context "disambiguating moves" do
-    describe "using SAN square disambiguation" do
-      pos = PGN::FEN.new("r1bqkb1r/pp1p1ppp/2n1pn2/8/3NP3/2N5/PPP2PPP/R1BQKB1R w KQkq - 3 6").to_position
-      next_pos = pos.move("Ndb5")
-
-      it "should move the specified piece" do
-        next_pos.board.at("d4").should be_nil
+
+  context 'disambiguating moves' do
+    describe 'using SAN square disambiguation' do
+      pos = PGN::FEN.new('r1bqkb1r/pp1p1ppp/2n1pn2/8/3NP3/2N5/PPP2PPP/R1BQKB1R w KQkq - 3 6').to_position
+      next_pos = pos.move('Ndb5')
+
+      it 'should move the specified piece' do
+        next_pos.board.at('d4').should be_nil
       end
 
-      it "should not move the other piece" do
-        next_pos.board.at("c3").should == "N"
+      it 'should not move the other piece' do
+        next_pos.board.at('c3').should == 'N'
       end
     end
 
-    describe "using discovered check" do
-      pos = PGN::FEN.new("rnbqk2r/p1pp1ppp/1p2pn2/8/1bPP4/2N1P3/PP3PPP/R1BQKBNR w KQkq - 0 5").to_position
-      next_pos = pos.move("Ne2")
+    describe 'using discovered check' do
+      pos = PGN::FEN.new('rnbqk2r/p1pp1ppp/1p2pn2/8/1bPP4/2N1P3/PP3PPP/R1BQKBNR w KQkq - 0 5').to_position
+      next_pos = pos.move('Ne2')
 
       it "should move the piece that doesn't give discovered check" do
-        next_pos.board.at("g1").should be_nil
+        next_pos.board.at('g1').should be_nil
       end
 
       it "shouldn't move the other piece" do
-        next_pos.board.at("c3").should == "N"
+        next_pos.board.at('c3').should == 'N'
       end
     end
 
-    describe "with two pawns on the same file" do
-      pos = PGN::FEN.new("r2q1rk1/4bppp/p3n3/1p2n3/4N3/1B2BP2/PP3P1P/R2Q1RK1 w - - 4 19").to_position
-      next_pos = pos.move("f4")
+    describe 'with two pawns on the same file' do
+      pos = PGN::FEN.new('r2q1rk1/4bppp/p3n3/1p2n3/4N3/1B2BP2/PP3P1P/R2Q1RK1 w - - 4 19').to_position
+      next_pos = pos.move('f4')
 
-      it "should move the pawn in front" do
-        next_pos.board.at("f3").should be_nil
+      it 'should move the pawn in front' do
+        next_pos.board.at('f3').should be_nil
       end
 
-      it "should not move the other pawn" do
-        next_pos.board.at("f2").should == "P"
+      it 'should not move the other pawn' do
+        next_pos.board.at('f2').should == 'P'
       end
     end
   end
@@ -124,4 +121,108 @@ describe PGN::Position do
       expect(parsed.to_fen.to_s).to eq(fen)
     end
   end
+
+  describe '#zobrist and equality' do
+    it 'seeds the start position with a stable hash' do
+      expect(PGN::Position.start.zobrist).to be_an(Integer)
+      expect(PGN::Position.start.zobrist).to eq(PGN::Position.start.zobrist)
+    end
+
+    it 'updates the hash after a move (and matches a fresh seed)' do
+      start = PGN::Position.start
+      after = start.move('e4')
+      expect(after.zobrist).to eq(
+        PGN::Zobrist.seed(after.board, after.player, after.castling, after.en_passant)
+      )
+    end
+
+    it 'is equal to an independently built equivalent position' do
+      a = PGN::Position.start.move('e4').move('e5')
+      b = PGN::Position.start.move('e4').move('e5')
+      expect(a).to eq(b)
+      expect(a.hash).to eq(b.hash)
+    end
+
+    it 'is not equal when only the side to move differs' do
+      a = PGN::Position.start
+      b = PGN::Position.start.move('e4')
+      expect(a).not_to eq(b)
+    end
+
+    it 'is not equal when castling rights differ' do
+      fen = 'r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1'
+      a = PGN::FEN.new(fen).to_position
+      b = a.move('O-O')
+      expect(a).not_to eq(b)
+    end
+
+    it 'ignores halfmove and fullmove counters for equality' do
+      a = PGN::Position.new(PGN::Board.start, :white, %w[K Q k q], nil, 0, 1)
+      b = PGN::Position.new(PGN::Board.start, :white, %w[K Q k q], nil, 7, 9)
+      expect(a).to eq(b)
+      expect(a.hash).to eq(b.hash)
+    end
+
+    it 'keeps the replay hash in sync with a fresh seed for a whole game' do
+      moves = %w[e4 c5 Nf3 d6 d4 cxd4 Nxd4 Nf6 Nc3 a6 Be2 e6]
+      pos = PGN::Position.start
+      moves.each do |m|
+        pos = pos.move(m)
+        expect(pos.zobrist).to eq(
+          PGN::Zobrist.seed(pos.board, pos.player, pos.castling, pos.en_passant)
+        ), "drift after #{m}"
+      end
+    end
+  end
+end
+
+RSpec.describe PGN::Position, '#perft' do
+  it 'returns 1 at depth 0 for the start position' do
+    expect(PGN::Position.start.perft(0)).to eq(1)
+  end
+
+  it 'matches published startpos perft values' do
+    p = PGN::Position.start
+    expect(p.perft(1)).to eq(20)
+    expect(p.perft(2)).to eq(400)
+    expect(p.perft(3)).to eq(8_902)
+    expect(p.perft(4)).to eq(197_281)
+  end
+
+  it 'matches published Kiwipete perft values' do
+    fen = 'r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1'
+    p = PGN::FEN.new(fen).to_position
+    expect(p.perft(1)).to eq(48)
+    expect(p.perft(2)).to eq(2_039)
+    expect(p.perft(3)).to eq(97_862)
+  end
+
+  it 'raises ArgumentError on negative depth' do
+    expect { PGN::Position.start.perft(-1) }.to raise_error(ArgumentError)
+  end
+end
+
+RSpec.describe PGN::Position, '#legal_moves' do
+  it 'lists 20 legal moves from the start position' do
+    expect(PGN::Position.start.legal_moves.length).to eq(20)
+  end
+
+  it 'returns sorted UCI strings matching the UCI format' do
+    moves = PGN::Position.start.legal_moves
+    expect(moves).to eq(moves.sort)
+    expect(moves).to all(match(/\A[a-h][1-8][a-h][1-8][qrbn]?\z/))
+  end
+
+  it 'matches the engine direct output for the same FEN (delegation equivalence)' do
+    fen = 'r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1'
+    pos = PGN::FEN.new(fen).to_position
+    expect(pos.legal_moves).to eq(PGN::Bitboard::Engine.new(fen).legal_moves)
+  end
+
+  it 'includes a promotion UCI when one is legal' do
+    # White king e1, black king h1, white pawn e7 — e7e8q must be legal.
+    fen = '8/4P3/8/8/8/8/8/4K2k w - - 0 1'
+    pos = PGN::FEN.new(fen).to_position
+    expect(pos.legal_moves).to include('e7e8q')
+  end
 end

data/spec/serializer_spec.rb

@@ -62,10 +62,10 @@ describe PGN::Serializer do
     it 'reproduces the variations.pgn movetext shape, including 2... after variations' do
       game = PGN.parse(File.read('./spec/pgn_files/variations.pgn')).first
       expected = "[Black \"Petrov\"]\n[White \"Somebody\"]\n\n" \
-                "1. e4 e5 2. Nf3 { comment } " \
-                "(2. f4 exf4 { final variation }) " \
-                "(2. Nc3 { other } 2... d5 (2... f5) 3. exd5) " \
-                "2... Nf6 *\n"
+                 '1. e4 e5 2. Nf3 { comment } ' \
+                 '(2. f4 exf4 { final variation }) ' \
+                 '(2. Nc3 { other } 2... d5 (2... f5) 3. exd5) ' \
+                 "2... Nf6 *\n"
       expect(PGN::Serializer.new(game).to_s).to eq(expected)
     end
 

data/spec/zobrist_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PGN::Zobrist do
+  it 'exposes table, side, castling, and ep_file constants' do
+    expect(PGN::Zobrist::TABLE).to be_a(Hash)
+    expect(PGN::Zobrist::TABLE.keys.sort).to eq(%w[B K N P Q R b k n p q r].sort)
+    expect(PGN::Zobrist::TABLE['P'].length).to eq(128)
+    expect(PGN::Zobrist::SIDE).to be_an(Integer)
+    expect(PGN::Zobrist::CASTLING).to be_a(Hash)
+    expect(PGN::Zobrist::CASTLING.keys.sort).to eq(%w[K Q k q].sort)
+    expect(PGN::Zobrist::EP_FILE.length).to eq(8)
+  end
+
+  it 'seeds the starting position to a stable integer' do
+    first  = PGN::Zobrist.seed(PGN::Board.start, :white, %w[K Q k q], nil)
+    second = PGN::Zobrist.seed(PGN::Board.start, :white, %w[K Q k q], nil)
+    expect(first).to eq(second)
+    expect(first).to be_an(Integer)
+  end
+
+  it 'differs when the side to move changes' do
+    white_to_move = PGN::Zobrist.seed(PGN::Board.start, :white, %w[K Q k q], nil)
+    black_to_move = PGN::Zobrist.seed(PGN::Board.start, :black, %w[K Q k q], nil)
+    expect(white_to_move).not_to eq(black_to_move)
+  end
+
+  it 'differs when castling rights change' do
+    full = PGN::Zobrist.seed(PGN::Board.start, :white, %w[K Q k q], nil)
+    no_k = PGN::Zobrist.seed(PGN::Board.start, :white, %w[Q k q], nil)
+    expect(full).not_to eq(no_k)
+  end
+
+  it 'differs when an en-passant file is present vs absent' do
+    with_ep = PGN::Zobrist.seed(PGN::Board.start, :white, %w[K Q k q], 'e3')
+    no_ep   = PGN::Zobrist.seed(PGN::Board.start, :white, %w[K Q k q], nil)
+    expect(with_ep).not_to eq(no_ep)
+  end
+
+  it 'is deterministic across processes (frozen constants)' do
+    expect(PGN::Zobrist::TABLE).to be_frozen
+    expect(PGN::Zobrist::CASTLING).to be_frozen
+    expect(PGN::Zobrist::EP_FILE).to be_frozen
+  end
+end