pgn2 2.0.1 → 2.0.3

data/spec/parser_explicit_spec.rb

@@ -176,12 +176,51 @@ RSpec.describe PGN, '.parse (racc parser)' do
     end
   end
 
+  describe 'move suffix (comments, NAGs, variations in any order)' do
+    it 'attaches two comments before a variation to the move' do
+      game = PGN.parse('[White "A"] 1. Bxh7+ Kxh7 {a} {b} (20... Kf8) 2. Ng5+ *').first
+      move = game.moves[1]
+      expect(move.notation).to eq('Kxh7')
+      expect(move.comment).to eq('a b')
+      expect(variations_as(move)).to eq([%w[Kf8]])
+    end
+
+    it 'attaches a comment after a variation to the same move' do
+      game = PGN.parse('[White "A"] 1. e4 (1... c5) {a} (2... f5) 2. Nf3 *').first
+      move = game.moves.first
+      expect(move.comment).to eq('a')
+      expect(variations_as(move).sort).to eq([%w[c5], %w[f5]].sort)
+    end
+
+    it 'merges an arbitrary mix of comments, NAGs, and variations' do
+      game = PGN.parse('[White "A"] 1. e4 {c1} $1 (1... d5) {c2} $2 *').first
+      move = game.moves.first
+      expect(move.comment).to eq('c1 c2')
+      expect(move.annotation).to eq(%w[$1 $2])
+      expect(variations_as(move)).to eq([%w[d5]])
+    end
+
+    it 'round-trips a multi-comment move through parse -> serialize -> parse' do
+      input = +"[White \"A\"]\n\n1. e4 {a} {b} (1... d5) *\n"
+      once = PGN.parse(input, Encoding::UTF_8).first.to_pgn
+      twice = PGN.parse(once, Encoding::UTF_8).first.to_pgn
+      expect(twice).to eq(once)
+    end
+  end
+
   describe 'pgn (verbatim raw text)' do
     it 'returns the verbatim text for a single game' do
       input = "[White \"A\"] 1. e4 1-0\n"
       expect(PGN.parse(input).first.pgn).to eq(input)
     end
 
+    it 'does not mutate a frozen input string' do
+      input = "[White \"A\"] 1. e4 1-0\n".freeze
+      expect { PGN.parse(input, Encoding::UTF_8) }.not_to raise_error
+      expect(input.encoding).to eq(Encoding::UTF_8)
+      expect(PGN.parse(input, Encoding::UTF_8).first.pgn).to eq(input)
+    end
+
     it 'partitions consecutive games contiguously' do
       input = "[White \"A\"] 1. e4 1-0\n\n[White \"B\"] 1. d4 0-1\n"
       games = PGN.parse(input)

data/spec/spec_helper.rb

@@ -1,5 +1,22 @@
 require 'pgn'
 
+# Helpers for order-independent variation comparison. The parser's
+# `variation_list` rule is right-recursive, so a move's variations are stored
+# in reverse of their PGN-text order; round-tripping flips that order each
+# parse. We therefore compare variation trees as sorted signatures, and
+# reference variations by notation rather than by index.
+def node_sig(move)
+  [move.notation, (move.variations || []).map { line_sig(_1) }.sort]
+end
+
+def line_sig(line)
+  line.map { node_sig(_1) }
+end
+
+def tree_sig(game)
+  game.moves.map { node_sig(_1) }
+end
+
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
 # Require this file using `require "spec_helper"` to ensure that it is only

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgn2
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.3
 platform: ruby
 authors:
 - Stacey Touset
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-15 00:00:00.000000000 Z
+date: 2026-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -242,7 +242,6 @@ files:
 - ext/pgn2_native/pgn2-bitboard/Cargo.toml
 - ext/pgn2_native/pgn2-bitboard/src/board.rs
 - ext/pgn2_native/pgn2-bitboard/src/lib.rs
-- ext/pgn2_native/pgn2-bitboard/src/moves.rs
 - ext/pgn2_native/pgn2-bitboard/src/perft.rs
 - ext/pgn2_native/pgn2_native/Cargo.toml
 - ext/pgn2_native/pgn2_native/src/lib.rs

data/ext/pgn2_native/pgn2-bitboard/src/moves.rs

@@ -1,121 +0,0 @@
-/// Adapter move carrying exactly what `to_uci` and `same_target` need:
-/// from-square, to-square, and optional promotion kind. No flag bits,
-/// so a position-free `uci_parse` can produce a comparable token — this
-/// preserves the existing `same_target` semantics (match on
-/// from + to + promo only), so `legal?("e1g1")` finds the castle and
-/// `legal?("e7e8q")` finds that exact promotion.
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub struct Move {
-    from: u8, // 0..=63, index = rank * 8 + file
-    to: u8,
-    promo: Option<Promo>,
-}
-
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum Promo {
-    Knight,
-    Bishop,
-    Rook,
-    Queen,
-}
-
-impl Move {
-    /// Build an adapter `Move` from a `chessie::Move` (a legal move).
-    ///
-    /// chessie encodes castling internally as "King takes Rook"
-    /// (`to` = the rook's square, Chess960 style). `into_standard_castle`
-    /// rewrites the `to` square to the king's destination (`e1g1`/`e1c1`),
-    /// matching the standard-UCI output the previous engine produced and
-    /// that `uci_parse` / `bitboard_spec.rb` expect. No-op for non-castle
-    /// moves.
-    pub(crate) fn from_chessie(m: chessie::Move) -> Self {
-        let m = m.into_standard_castle();
-        Move {
-            from: m.from().index() as u8,
-            to: m.to().index() as u8,
-            promo: m.promotion().map(|kind| match kind {
-                chessie::PieceKind::Knight => Promo::Knight,
-                chessie::PieceKind::Bishop => Promo::Bishop,
-                chessie::PieceKind::Rook => Promo::Rook,
-                chessie::PieceKind::Queen => Promo::Queen,
-                // Pawns/Kings never appear as a promotion kind.
-                _ => unreachable!("non-promotion PieceKind in Move::promotion"),
-            }),
-        }
-    }
-
-    /// UCI string: `"e2e4"`, `"e1g1"` (castle, king from→to),
-    /// `"e7e8q"` (promotion). Equal to `chessie::Move::to_uci` for
-    /// every legal move (castle and en-passant both reduce to from+to
-    /// in UCI), so the sorted-UCI output is unchanged.
-    pub fn to_uci(self) -> String {
-        let mut s = String::with_capacity(5);
-        s.push_str(&sq_name(self.from));
-        s.push_str(&sq_name(self.to));
-        if let Some(p) = self.promo {
-            s.push(match p {
-                Promo::Knight => 'n',
-                Promo::Bishop => 'b',
-                Promo::Rook => 'r',
-                Promo::Queen => 'q',
-            });
-        }
-        s
-    }
-
-    /// Match on from + to + promo (the pre-existing semantics).
-    pub fn same_target(self, other: Move) -> bool {
-        self.from == other.from && self.to == other.to && self.promo == other.promo
-    }
-}
-
-/// Thin wrapper around `Vec<Move>`; the binding calls `.iter()` on it.
-pub struct MoveList(pub Vec<Move>);
-
-impl MoveList {
-    pub fn iter(&self) -> std::slice::Iter<'_, Move> {
-        self.0.iter()
-    }
-}
-
-/// Parse a UCI string into a `Move` token **without** a position.
-/// Only `to_uci`/`same_target` consume the result, so from + to + promo
-/// is all that is needed. Returns `None` on any malformed input.
-pub fn uci_parse(s: &str) -> Option<Move> {
-    let b = s.as_bytes();
-    if b.len() < 4 {
-        return None;
-    }
-    let from = parse_sq(&b[0..2])?;
-    let to = parse_sq(&b[2..4])?;
-    let promo = if b.len() >= 5 {
-        Some(match b[4] {
-            b'n' => Promo::Knight,
-            b'b' => Promo::Bishop,
-            b'r' => Promo::Rook,
-            b'q' => Promo::Queen,
-            _ => return None,
-        })
-    } else {
-        None
-    };
-    Some(Move { from, to, promo })
-}
-
-fn parse_sq(t: &[u8]) -> Option<u8> {
-    let f = t[0].checked_sub(b'a')?;
-    let r = t[1].checked_sub(b'1')?;
-    if f > 7 || r > 7 {
-        return None;
-    }
-    Some(r * 8 + f)
-}
-
-fn sq_name(idx: u8) -> String {
-    let file = (b'a' + (idx & 7)) as char;
-    let rank = (b'1' + (idx >> 3)) as char;
-    let mut s = String::with_capacity(2);
-    s.push(file);
-    s.push(rank);
-    s
-}