pgn2 0.4.0 → 1.0.0

data/pgn2.gemspec

@@ -11,16 +11,26 @@ Gem::Specification.new do |spec|
   spec.summary       = 'A PGN parser for Ruby'
   spec.homepage      = 'https://github.com/muriloime/pgn'
   spec.license       = 'MIT'
+  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'
+  }
 
   spec.files         = `git ls-files`.split($/)
   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.add_dependency 'whittle'
-
   spec.add_development_dependency 'bundler', '~> 2.3'
   spec.add_development_dependency 'pry'
   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/board_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe PGN::Board do
+  describe '.start' do
+    it 'uses the START constant for its squares' do
+      expect(PGN::Board.start.squares).to eq(PGN::Board::START)
+    end
+  end
+
+  describe '#at' do
+    # Use .dup because PGN::Board.start returns the same shared board
+    # backed by the frozen START constant.
+    let(:board) { PGN::Board.start.dup }
+
+    it 'returns the starting pieces on their home squares' do
+      expect(board.at('a1')).to eq('R')
+      expect(board.at('b1')).to eq('N')
+      expect(board.at('c1')).to eq('B')
+      expect(board.at('d1')).to eq('Q')
+      expect(board.at('e1')).to eq('K')
+      expect(board.at('h1')).to eq('R')
+      expect(board.at('a2')).to eq('P')
+      expect(board.at('e2')).to eq('P')
+      expect(board.at('a7')).to eq('p')
+      expect(board.at('e8')).to eq('k')
+      expect(board.at('d8')).to eq('q')
+    end
+
+    it 'returns nil for empty squares' do
+      expect(board.at('e3')).to be_nil
+      expect(board.at('d4')).to be_nil
+      expect(board.at('a3')).to be_nil
+    end
+
+    it 'agrees between the string and coordinate overloads' do
+      expect(board.at('e4')).to eq(board.at(4, 3))
+      expect(board.at('a1')).to eq(board.at(0, 0))
+      expect(board.at('h8')).to eq(board.at(7, 7))
+    end
+  end
+
+  describe '#coordinates_for / #position_for' do
+    it 'round-trips every square on the board' do
+      ('a'..'h').each_with_index do |file, fi|
+        ('1'..'8').each_with_index do |rank, ri|
+          square = "#{file}#{rank}"
+          expect(PGN::Board.start.coordinates_for(square)).to eq([fi, ri])
+          expect(PGN::Board.start.position_for([fi, ri])).to eq(square)
+        end
+      end
+    end
+  end
+
+  describe '#update' do
+    it 'places a piece and mutates self, returning self' do
+      board = PGN::Board.start.dup
+      result = board.update('e4', 'P')
+      expect(result).to be(board)
+      expect(board.at('e4')).to eq('P')
+    end
+
+    it 'can clear a square with nil' do
+      board = PGN::Board.start.dup
+      board.update('e2', nil)
+      expect(board.at('e2')).to be_nil
+    end
+  end
+
+  describe '#change!' do
+    it 'applies several squares at once and returns self' do
+      board = PGN::Board.start.dup
+      result = board.change!('e2' => nil, 'e4' => 'P')
+      expect(result).to be(board)
+      expect(board.at('e2')).to be_nil
+      expect(board.at('e4')).to eq('P')
+    end
+  end
+
+  describe '#dup' do
+    it 'returns a PGN::Board with equal squares' do
+      original = PGN::Board.start.dup
+      copy = original.dup
+      expect(copy).to be_a(PGN::Board)
+      expect(copy.squares).to eq(original.squares)
+    end
+
+    it 'is independent: mutating the copy leaves the original untouched' do
+      original = PGN::Board.start.dup
+      copy = original.dup
+      copy.update('e4', 'Q')
+      expect(original.at('e4')).to be_nil
+      expect(copy.at('e4')).to eq('Q')
+    end
+
+    it 'is independent: mutating the original leaves the copy untouched' do
+      original = PGN::Board.start.dup
+      copy = original.dup
+      original.update('e4', 'Q')
+      expect(copy.at('e4')).to be_nil
+    end
+  end
+
+  describe '#inspect' do
+    it 'returns a string with unicode pieces and newlines' do
+      inspected = PGN::Board.start.inspect
+      expect(inspected).to be_a(String)
+      expect(inspected).to include("\u{2659}") # white pawn
+      expect(inspected).to include("\n")
+    end
+  end
+end

data/spec/fen_spec.rb

@@ -97,4 +97,29 @@ describe PGN::FEN do
       fen.inspect.should be_a(String)
     end
   end
+
+  describe "board_string round-trip" do
+    fens = [
+      PGN::FEN::INITIAL,
+      "r1bqkb1r/pp1p1ppp/2n1pn2/8/3NP3/2N5/PPP2PPP/R1BQKB1R w KQkq - 3 6",
+      "8/8/8/8/8/8/8/8 w - - 0 1",
+      "r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1",
+      "4k3/4P3/8/8/8/8/8/4K3 w - - 0 1",
+      "rnbqkbnr/ppp1pppp/8/3pP3/8/8/PPPP1PPP/RNBQKBNR w KQkq d6 0 3",
+    ]
+
+    it "round-trips every fixture through FEN#to_s" do
+      fens.each do |fen|
+        expect(PGN::FEN.new(fen).to_s).to eq(fen), fen
+      end
+    end
+
+    it "round-trips the board portion through FEN#to_position.to_fen" do
+      fens.each do |fen|
+        original  = PGN::FEN.new(fen)
+        roundtrip = original.to_position.to_fen
+        expect(roundtrip.board_string).to eq(original.board_string), fen
+      end
+    end
+  end
 end

data/spec/game_spec.rb

@@ -18,4 +18,78 @@ describe PGN::Game do
       expect(last_pos.fullmove).to eq 2
     end
   end
+
+  describe '#to_pgn' do
+    it 'returns a canonical PGN string ending with a newline' do
+      game = PGN::Game.new(%w[e4 e5], { 'White' => 'A' }, '1-0')
+      expect(game.to_pgn).to eq("[White \"A\"]\n\n1. e4 e5 1-0\n")
+      expect(game.to_pgn).to end_with("\n")
+    end
+
+    # Recursively compare two move lists: notation, annotation, comment,
+    # and the structure of their variations.
+    #
+    # The current parser reverses the order of a move's variations on each
+    # parse (its `variation_list` rule is right-recursive), so variation
+    # *order* does not round-trip; only the set of variations does. We
+    # therefore compare variations order-independently via a canonical
+    # signature.
+    def move_signature(m)
+      c = m.comment.to_s
+      # The current parser does not unescape \\, {, or }, so comments
+      # containing those do not round-trip byte-for-byte (design spec v1
+      # limitation). Treat them as a single sentinel so the set comparison
+      # ignores the difference.
+      c = "<unescaped-comment>" if c.match?(/[\\{}]/)
+      vars = (m.variations || []).map { |v| v.map { |mm| move_signature(mm) }.join("\x02") }.sort.join("\x03")
+      "#{m.notation}\x01#{(m.annotation || []).inspect}\x01#{c}\x01#{vars}"
+    end
+
+    def expect_moves_equal(expected, actual, ctx)
+      expect(actual.map(&:notation)).to eq(expected.map(&:notation)),
+        "#{ctx}: notation"
+      expected.each_with_index do |e, i|
+        expect(actual[i].annotation).to eq(e.annotation), "#{ctx}[#{i}]: annotation"
+        # The current parser cannot unescape braces, so comments containing
+        # literal braces do not round-trip byte-for-byte (design spec v1
+        # limitation). Skip the comparison for those.
+        unless e.comment.to_s.match?(/[\\{}]/)
+          expect(actual[i].comment).to eq(e.comment),
+            "#{ctx}[#{i}]: comment #{e.comment.inspect} vs #{actual[i].comment.inspect}"
+        end
+        # Variations compared as an order-independent set of signatures.
+        exp_sigs = (e.variations || []).map { |v| v.map { |mm| move_signature(mm) }.join("\x02") }.sort
+        act_sigs = (actual[i].variations || []).map { |v| v.map { |mm| move_signature(mm) }.join("\x02") }.sort
+        expect(act_sigs).to eq(exp_sigs), "#{ctx}[#{i}]: variations"
+      end
+    end
+
+    # Fixtures that do not round-trip byte-for-byte: doublequotes has
+    # unescaped inner quotes (serializer escapes them) and specialcharacters
+    # is multibyte and requires the Encoding::UTF_8 argument to parse.
+    NON_ROUND_TRIP = %w[doublequotes.pgn specialcharacters.pgn].freeze
+
+    it 'round-trips every tracked fixture' do
+      fixtures = `git ls-files spec/pgn_files/`.split.map { |p| File.expand_path(p) }
+      fixtures.reject! { |p| NON_ROUND_TRIP.include?(File.basename(p)) }
+      fixtures.each do |path|
+        PGN.parse(File.read(path)).each_with_index do |game, gi|
+          reparsed = PGN.parse(game.to_pgn).first
+
+          expect(reparsed.result).to eq(game.result),
+            "#{path}##{gi}: result"
+          expect_moves_equal(game.moves, reparsed.moves, "#{path}##{gi}")
+
+          # Reparsed tags must be a superset of the original (a no-tag game
+          # gains a synthesized Result tag).
+          original_tags = game.tags || {}
+          reparsed_tags = reparsed.tags || {}
+          original_tags.each do |k, v|
+            expect(reparsed_tags[k]).to eq(v),
+              "#{path}##{gi}: tag #{k} #{v.inspect} vs #{reparsed_tags[k].inspect}"
+          end
+        end
+      end
+    end
+  end
 end

data/spec/lexer_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+require 'pgn/lexer'
+
+RSpec.describe PGN::Lexer do
+  def lex(input)
+    PGN::Lexer.new(input).tokens
+  end
+
+  it 'returns nil on empty input' do
+    expect(PGN::Lexer.new('').next_token).to be_nil
+  end
+
+  it 'discards whitespace' do
+    toks = lex("   \n\t  e4")
+    expect(toks.map { |t| [t.type, t.value] }).to eq([[:san_move, 'e4']])
+  end
+
+  it 'discards % rest-of-line comments' do
+    toks = lex("% a comment line\n[Event \"X\"]")
+    expect(toks.map(&:type)).to eq([:lbracket, :tag_name, :string, :rbracket])
+  end
+
+  it 'tokenizes the four single-character literals' do
+    toks = lex('[]()')
+    expect(toks.map { |t| [t.type, t.value] }).to eq(
+      [[:lbracket, '['], [:rbracket, ']'], [:lparen, '('], [:rparen, ')']]
+    )
+  end
+
+  it 'tokenizes a tag pair' do
+    toks = lex('[White "Kasparov"]')
+    expect(toks.map { |t| [t.type, t.value] }).to eq(
+      [[:lbracket, '['], [:tag_name, 'White'], [:string, '"Kasparov"'], [:rbracket, ']']]
+    )
+  end
+
+  it 'allows unescaped double-quotes inside a string value' do
+    toks = lex('[Event "IRT BLITZ "Sub Zonal""]')
+    expect(toks[2].value).to eq('"IRT BLITZ "Sub Zonal""')
+  end
+
+  it 'handles an escaped backslash in a string' do
+    input = %([X "a\\\\b"])
+    expect(lex(input)[2].value).to eq(%("a\\\\b"))
+  end
+
+  it 'handles an escaped quote in a string' do
+    input = %([X "a\\"b"])
+    expect(lex(input)[2].value).to eq(%("a\\"b"))
+  end
+
+  it 'tokenizes a brace comment including newlines' do
+    toks = lex("{line one\nline two}")
+    expect(toks.size).to eq(1)
+    expect(toks[0].type).to eq(:comment)
+    expect(toks[0].value).to eq("{line one\nline two}")
+  end
+
+  it 'tokenizes nested brace comments recursively' do
+    toks = lex("{outer {inner} tail}")
+    expect(toks[0].value).to eq("{outer {inner} tail}")
+  end
+
+  it 'tokenizes all game terminations' do
+    %w[1-0 0-1 1/2-1/2 *].each do |term|
+      expect(lex(term).map { |t| [t.type, t.value] }).to eq([[:game_termination, term]])
+    end
+  end
+
+  it 'prefers a game termination over a move number (1-0, 0-1)' do
+    expect(lex('1-0')[0].type).to eq(:game_termination)
+    expect(lex('0-1')[0].type).to eq(:game_termination)
+  end
+
+  it 'prefers castling (0-0) over a move number (0)' do
+    t = lex('0-0')[0]
+    expect(t.type).to eq(:san_move)
+    expect(t.value).to eq('0-0')
+  end
+
+  it 'prefers a draw result (1/2-1/2) over a move number (1)' do
+    expect(lex('1/2-1/2')[0].value).to eq('1/2-1/2')
+  end
+
+  it 'tokenizes move number indications' do
+    expect(lex('1.')[0].value).to eq('1.')
+    expect(lex('12.')[0].value).to eq('12.')
+    expect(lex('1...')[0].value).to eq('1...')
+  end
+
+  it 'tokenizes san moves: pawn, capture, promotion, check, mate' do
+    expect(lex('e4')[0].value).to eq('e4')
+    expect(lex('exd5')[0].value).to eq('exd5')
+    expect(lex('e8=Q')[0].value).to eq('e8=Q')
+    expect(lex('Qe7+')[0].value).to eq('Qe7+')
+    expect(lex('Qxf7#')[0].value).to eq('Qxf7#')
+  end
+
+  it 'tokenizes castling (O and 0 forms) and the dont-care move' do
+    expect(lex('O-O')[0].value).to eq('O-O')
+    expect(lex('O-O-O')[0].value).to eq('O-O-O')
+    expect(lex('--')[0].value).to eq('--')
+  end
+
+  it 'tokenizes major-piece moves with disambiguation' do
+    expect(lex('Nf3')[0].value).to eq('Nf3')
+    expect(lex('Nef6')[0].value).to eq('Nef6')
+    expect(lex('Raxc1')[0].value).to eq('Raxc1')
+  end
+
+  it 'tokenizes numeric annotation glyphs and punctuation annotations' do
+    expect(lex('$4')[0].value).to eq('$4')
+    expect(lex('??')[0].value).to eq('??')
+    expect(lex('?!')[0].value).to eq('?!')
+    expect(lex('!?')[0].value).to eq('!?')
+  end
+
+  it 'records byte offsets on every token' do
+    toks = lex("1. e4 e5 1-0")
+    expect(toks[0].offset).to eq(0)   # "1."
+    expect(toks[1].offset).to eq(3)  # "e4"
+    expect(toks[2].offset).to eq(6)  # "e5"
+    expect(toks[3].offset).to eq(9)  # "1-0"
+  end
+
+  it 'counts lines as it consumes newlines' do
+    toks = lex("[X \"1\"]\n[Y \"2\"]")
+    expect(toks.last.line).to eq(2)
+  end
+
+  it 'records per-game content-start offsets' do
+    input = "[Event \"A\"]\n\n1. e4 e5 1-0\n\n[Event \"B\"]\n\n1. d4 d5 0-1"
+    lex = PGN::Lexer.new(input)
+    lex.tokens
+    # game_starts has one entry per game (game 0's is recorded but game 0's
+    # pgn span starts at 0 by construction; games 1+ start at their offset).
+    expect(lex.game_starts.size).to eq(2)
+    # game 1's content-start is the '[' of "[Event \"B\"]"
+    second_game = input.index('[Event "B"]')
+    expect(lex.game_starts[1]).to eq(second_game)
+  end
+
+  it 'tokenizes UTF-8 (multibyte) input without error' do
+    input = "[Site \"HOTEL – Pereira\"]\n1. e4 e5 *\n".force_encoding(Encoding::UTF_8)
+    toks = PGN::Lexer.new(input).tokens
+    expect(toks[1].value).to eq('Site')
+    expect(toks[2].value).to eq('"HOTEL – Pereira"')
+  end
+
+  it 'raises on unmatched input' do
+    expect { lex('@bogus') }.to raise_error(PGN::UnconsumedInputError)
+  end
+end

data/spec/move_calculator_spec.rb

@@ -0,0 +1,226 @@
+require 'spec_helper'
+
+# All tests exercise MoveCalculator *indirectly* through PGN::Position#move
+# so they remain valid across an internal refactor of the calculator.
+def position(fen)
+  PGN::FEN.new(fen).to_position
+end
+
+describe PGN::MoveCalculator do
+  describe 'pawn pushes' do
+    it 'white single push from start empties e2 and fills e4' do
+      nxt = PGN::Position.start.move('e4')
+      expect(nxt.board.at('e2')).to be_nil
+      expect(nxt.board.at('e4')).to eq('P')
+    end
+
+    it 'white double push leaves e3 empty (not just e2 cleared)' do
+      nxt = PGN::Position.start.move('e4')
+      expect(nxt.board.at('e3')).to be_nil
+    end
+
+    it 'black single push empties d7 and fills d5' do
+      nxt = position('rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1').move('d5')
+      expect(nxt.board.at('d7')).to be_nil
+      expect(nxt.board.at('d5')).to eq('p')
+      expect(nxt.board.at('d6')).to be_nil
+    end
+  end
+
+  describe 'pawn captures' do
+    it 'captures diagonally onto the target square' do
+      nxt = position('rnbqkbnr/3ppppp/8/8/3PP3/8/PPP2PPP/RNBQKBNR w KQkq - 0 1').move('exd5')
+      expect(nxt.board.at('e4')).to be_nil
+      expect(nxt.board.at('d5')).to eq('P')
+    end
+  end
+
+  describe 'en passant' do
+    let(:fen) { 'rnbqkbnr/ppp1pppp/8/3pP3/8/8/PPPP1PPP/RNBQKBNR w KQkq d6 0 3' }
+
+    it 'captures the pawn behind the destination' do
+      nxt = position(fen).move('exd6')
+      expect(nxt.board.at('e5')).to be_nil   # origin emptied
+      expect(nxt.board.at('d5')).to be_nil   # captured pawn removed
+      expect(nxt.board.at('d6')).to eq('P')  # landed on the en-passant square
+    end
+  end
+
+  describe 'piece moves with a single origin' do
+    it 'knight from g1 to f3' do
+      nxt = PGN::Position.start.move('Nf3')
+      expect(nxt.board.at('g1')).to be_nil
+      expect(nxt.board.at('f3')).to eq('N')
+    end
+
+    it 'bishop along a clear diagonal' do
+      nxt = position('rnbqkbnr/pppp1ppp/8/4p3/4P3/8/PPPP1PPP/RNBQKBNR w KQkq - 0 1').move('Bc4')
+      expect(nxt.board.at('f1')).to be_nil
+      expect(nxt.board.at('c4')).to eq('B')
+    end
+
+    it 'rook along a clear file' do
+      nxt = position('4k3/8/8/8/8/8/8/R3K3 w - - 0 1').move('Ra2')
+      expect(nxt.board.at('a1')).to be_nil
+      expect(nxt.board.at('a2')).to eq('R')
+    end
+
+    it 'queen along a ray' do
+      nxt = position('4k3/8/8/8/8/8/8/Q3K3 w - - 0 1').move('Qa4')
+      expect(nxt.board.at('a1')).to be_nil
+      expect(nxt.board.at('a4')).to eq('Q')
+    end
+
+    it 'king steps one square' do
+      nxt = position('4k3/8/8/8/8/8/8/4K3 w - - 0 1').move('Ke2')
+      expect(nxt.board.at('e1')).to be_nil
+      expect(nxt.board.at('e2')).to eq('K')
+    end
+  end
+
+  describe 'castling' do
+    let(:fen) { 'r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1' }
+
+    it 'white kingside places king on g1 and rook on f1' do
+      nxt = position(fen).move('O-O')
+      expect(nxt.board.at('e1')).to be_nil
+      expect(nxt.board.at('g1')).to eq('K')
+      expect(nxt.board.at('h1')).to be_nil
+      expect(nxt.board.at('f1')).to eq('R')
+      expect(nxt.castling.sort).to eq(%w[k q])
+    end
+
+    it 'white queenside places king on c1 and rook on d1' do
+      nxt = position(fen).move('O-O-O')
+      expect(nxt.board.at('e1')).to be_nil
+      expect(nxt.board.at('c1')).to eq('K')
+      expect(nxt.board.at('a1')).to be_nil
+      expect(nxt.board.at('d1')).to eq('R')
+      expect(nxt.castling.sort).to eq(%w[k q])
+    end
+
+    it 'black kingside places king on g8 and rook on f8' do
+      nxt = position('r3k2r/8/8/8/8/8/8/R3K2R b KQkq - 0 1').move('O-O')
+      expect(nxt.board.at('e8')).to be_nil
+      expect(nxt.board.at('g8')).to eq('k')
+      expect(nxt.board.at('f8')).to eq('r')
+      expect(nxt.castling.sort).to eq(%w[K Q])
+    end
+
+    it 'black queenside places king on c8 and rook on d8' do
+      nxt = position('r3k2r/8/8/8/8/8/8/R3K2R b KQkq - 0 1').move('O-O-O')
+      expect(nxt.board.at('e8')).to be_nil
+      expect(nxt.board.at('c8')).to eq('k')
+      expect(nxt.board.at('d8')).to eq('r')
+      expect(nxt.castling.sort).to eq(%w[K Q])
+    end
+  end
+
+  describe 'promotion' do
+    let(:fen) { '4k3/4P3/8/8/8/8/8/4K3 w - - 0 1' }
+
+    it 'promotes a white pawn to a queen on e8' do
+      nxt = position(fen).move('e8=Q')
+      expect(nxt.board.at('e7')).to be_nil
+      expect(nxt.board.at('e8')).to eq('Q')
+    end
+  end
+
+  describe 'disambiguation' do
+    it 'resolves by SAN file (Ndb5 empties the d-file knight)' do
+      nxt = position('r1bqkb1r/pp1p1ppp/2n1pn2/8/3NP3/2N5/PPP2PPP/R1BQKB1R w KQkq - 3 6').move('Ndb5')
+      expect(nxt.board.at('d4')).to be_nil
+      expect(nxt.board.at('c3')).to eq('N')
+    end
+
+    it 'resolves by SAN rank' do
+      # Two white rooks on the a-file (a1 and a3), both can reach a2.
+      # R1a2 must move the rook on rank 1.
+      nxt = position('4k3/8/8/8/8/R7/8/R3K3 w - - 0 1').move('R1a2')
+      expect(nxt.board.at('a1')).to be_nil
+      expect(nxt.board.at('a2')).to eq('R')
+      expect(nxt.board.at('a3')).to eq('R')
+    end
+
+    it 'resolves by discovered check (Ne2 empties g1, not c3)' do
+      nxt = position('rnbqk2r/p1pp1ppp/1p2pn2/8/1bPP4/2N1P3/PP3PPP/R1BQKBNR w KQkq - 0 5').move('Ne2')
+      expect(nxt.board.at('g1')).to be_nil
+      expect(nxt.board.at('c3')).to eq('N')
+    end
+
+    it 'resolves two pawns on a file by rejecting the double push when blocked' do
+      nxt = position('r2q1rk1/4bppp/p3n3/1p2n3/4N3/1B2BP2/PP3P1P/R2Q1RK1 w - - 4 19').move('f4')
+      expect(nxt.board.at('f3')).to be_nil
+      expect(nxt.board.at('f2')).to eq('P')
+    end
+  end
+
+  describe 'castling restrictions (observable via position.castling)' do
+    it 'moving the white king drops both white rights' do
+      nxt = position('r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1').move('Ke2')
+      expect(nxt.castling.sort).to eq(%w[k q])
+    end
+
+    it 'moving the a1 rook drops queenside white' do
+      nxt = position('r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1').move('Ra2')
+      expect(nxt.castling.sort).to eq(%w[K k q])
+    end
+
+    it 'moving the h1 rook drops kingside white' do
+      nxt = position('r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1').move('Rh2')
+      expect(nxt.castling.sort).to eq(%w[Q k q])
+    end
+
+    it 'capturing a corner rook drops the matching right' do
+      nxt = position('r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1').move('Rxa8')
+      expect(nxt.castling).not_to include('q')
+      expect(nxt.castling).to include('k')
+    end
+  end
+
+  describe 'halfmove and fullmove counters' do
+    it 'a pawn move resets the halfmove clock' do
+      nxt = position('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 5 3').move('e4')
+      expect(nxt.halfmove).to eq(0)
+    end
+
+    it 'a quiet non-pawn move increments the halfmove clock' do
+      nxt = position('rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1').move('Nf6')
+      expect(nxt.halfmove).to eq(1)
+    end
+
+    it 'a capture resets the halfmove clock' do
+      nxt = position('rnbqkbnr/3ppppp/8/8/3PP3/8/PPP2PPP/RNBQKBNR w KQkq - 7 4').move('exd5')
+      expect(nxt.halfmove).to eq(0)
+    end
+
+    it "black's move increments the fullmove counter" do
+      nxt = position('rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1').move('Nf6')
+      expect(nxt.fullmove).to eq(2)
+    end
+
+    it "white's move does not increment the fullmove counter" do
+      nxt = PGN::Position.start.move('e4')
+      expect(nxt.fullmove).to eq(1)
+    end
+  end
+
+  describe 'en passant square' do
+    it 'is set after a white double push' do
+      expect(PGN::Position.start.move('e4').en_passant).to eq('e3')
+    end
+
+    it 'is set after a black double push' do
+      nxt = position('rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1').move('d5')
+      expect(nxt.en_passant).to eq('d6')
+    end
+
+    it 'is nil after a single push' do
+      expect(PGN::Position.start.move('Nf3').en_passant).to be_nil
+    end
+
+    it 'is nil after castling' do
+      expect(position('r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1').move('O-O').en_passant).to be_nil
+    end
+  end
+end