pgn2 2.0.1 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6363546a03960706a76a2048b8e88aff387e1f475eb76add1e1cfd615c6b6ed
-  data.tar.gz: 3944288b73d63291f31c0218902206eb39e2d8173fca7a91bb80aea59e0981a5
+  metadata.gz: 26cc37d3385d1f5516a2cff916f3219198914295b2ea83b587f1a8a6ee267480
+  data.tar.gz: 7efabc9471ace989a11a48879fb496f3999d35dbb42b3c8c138bdc392beeb597
 SHA512:
-  metadata.gz: 1bb3c90fcc6afcf5a2a7ca8a285518035de7645a7627c8d64ed89200e16e364f4f687dfe2107a3b3d6f2b2d994ce8cac5620f2f2d9418bdcd874cc84d07dddc5
-  data.tar.gz: b8b0e3a0254a29397d2ac263e16ea51ed524d886e2a9c69107d9cfa3c3ae4b6ba5cbbbfd8d4a14d73d74c5525f03102cd4aacbcee93ce5a9263288b05fd4e089
+  metadata.gz: 3622fadf7c7918121f2c3e6700d1bb4284d9a258d76f56a2b47d20813f7f837ad357ff45892e252da96b6c52694909241809f203b97872b5bdb3dbe5a2b33023
+  data.tar.gz: e3205c5033d63601f1a64e175e7e1799ab9c698e736d216e15408c4eb358851ba8bf415139bf66780dbc5bd559fde6468ca06cf81a29df056d50c6ba52f9b6b9

data/CHANGELOG.md

@@ -1,5 +1,78 @@
 # Changelog
 
+## 2.0.3 (2026-08-20)
+
+### Summary
+
+Parser fix: a move may now be followed by any number of comments, NAGs,
+and variations, in any order (PGN spec §3.2.5). Previously the grammar
+accepted only a single trailing comment before a variation, so common
+real-world annotations like `1... Kxh7 {a} {[%cal ...]} (20... Kf8)` raised
+`parse error on value "("` and whole files were skipped. No public API
+changes; `MoveText#comment` and `#variations` keep their existing shapes.
+
+### Changed
+
+- **`PGN::PgnParser` (grammar)** — replace the single-comment
+  `move_trailer` + separate `variation_list` with a `move_suffix` list of
+  `[:comment, c] | [:nags, a] | [:variation, v]` items folded onto the
+  move by the new `build_move` helper. Multiple comments on one move are
+  concatenated with a space (each cleaned individually); variations keep
+  the legacy reversed storage order so round-trip and serializer behavior
+  are unchanged.
+- **`PGN::MoveText.clean_text`** — extracted as a class method so the
+  parser can clean each trailing comment before merging; the instance
+  method delegates to it (behavior unchanged).
+
+### Fixed
+
+- Two (or more) comments before a variation no longer abort parsing.
+- A comment appearing after a variation now attaches to the move it
+  follows instead of becoming a stray game comment.
+- `PGN.parse` no longer mutates the caller's input string (it dups before
+  `force_encoding`), so frozen-string-literal callers no longer raise
+  FrozenError on the target Ruby.
+
+### Known issues
+
+- A lone backslash inside a comment that is not part of `\\`, `\{`, or
+  `\}` (e.g. `{/\Ba3#}`) still raises an "Unmatched input" lexer error;
+  the comment escape grammar remains stricter than the PGN spec.
+
+---
+
+## 2.0.2 (2026-08-18)
+
+### Summary
+
+Internal refactor and performance pass — no public API changes. The
+`pgn2-bitboard` adapter drops its hand-rolled `Move`/`MoveList`/`uci_parse`
+layer in favor of `chessie`'s own `MoveList` and `Move: PartialEq<str>`
+(UCI comparison), and the Ruby side DRYs shared FEN/EPD parsing, memoizes
+`Position#in_check?`, and maintains `Game`'s position cache incrementally.
+
+### Changed
+
+- **`ext/pgn2_native`** — remove `pgn2-bitboard/src/moves.rs`;
+  `Board#legal_moves` returns `chessie::MoveList` directly and
+  `Engine#legal?` compares via `chessie::Move`'s `PartialEq<str>` (by
+  `to_uci()`), eliminating the separate UCI parser.
+- **`PGN::PositionFields`** — shared FEN/EPD module for board-string and
+  castling/en-passant field parsing; `FEN` and `EPD` now include it instead
+  of duplicating the logic.
+- **`PGN::Attack.attacked?`** — short-circuits pawn/knight/king checks before
+  the slider ray-walk (cheapest first), matching the previous result.
+- **`PGN::Position#in_check?`** — memoizes its result on first call.
+- **`PGN::Game`** — `push`/`pop` now grow/shrink the memoized `@positions`
+  list in step rather than invalidating it; `threefold?` reuses `#positions`.
+- **`PGN::MoveText.normalize_castling`** — castling `0`→`O` normalization
+  extracted as a class method (was a private `Node` helper).
+- **`PGN::Node`** — `promote`/`demote`/`promote_to_main`/`demote_to_last`/
+  `delete` share a `mutate_sibling` prologue/epilogue and a `splice_line!`
+  helper; behavior unchanged.
+
+---
+
 ## 2.0.1 (2026-08-15)
 
 ### Summary

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

@@ -1,5 +1,3 @@
-use crate::moves::{Move, MoveList};
-
 /// A chess position backed by `chessie::Game`. Holds no chess logic of
 /// its own; every operation delegates. `Copy` because `chessie::Game`
 /// is `Copy`; `Default` because the magnus `Engine` wraps it in a
@@ -20,13 +18,7 @@ impl Board {
         self.game.perft(depth as usize)
     }
 
-    pub fn legal_moves(&self) -> MoveList {
-        let moves: Vec<Move> = self
-            .game
-            .get_legal_moves()
-            .into_iter()
-            .map(Move::from_chessie)
-            .collect();
-        MoveList(moves)
+    pub fn legal_moves(&self) -> chessie::MoveList {
+        self.game.get_legal_moves()
     }
 }

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

@@ -5,8 +5,6 @@
 //! Ruby in the loop.
 
 pub mod board;
-pub mod moves;
 pub mod perft;
 
 pub use board::Board;
-pub use moves::{Move, MoveList};

data/ext/pgn2_native/pgn2_native/src/lib.rs

@@ -32,10 +32,10 @@ impl Engine {
     }
 
     fn legal_p(&self, uci: String) -> bool {
-        match pgn2_bitboard::moves::uci_parse(&uci) {
-            Some(parsed) => self.0.borrow().legal_moves().iter().any(|m| m.same_target(parsed)),
-            None => false,
-        }
+        // `chessie::Move`'s `PartialEq<str>` compares by `to_uci()`, so this
+        // matches on castle/promotion notation the same way `legal_moves_ruby`
+        // renders it — no separate UCI parser needed.
+        self.0.borrow().legal_moves().iter().any(|m| m == &uci)
     }
 }
 
@@ -49,6 +49,6 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     engine.define_method("initialize", method!(Engine::initialize, 1))?;
     engine.define_method("perft", method!(Engine::perft, 1))?;
     engine.define_method("legal_moves", method!(Engine::legal_moves_ruby, 0))?;
-    engine.define_method("legal?", method!(Engine::legal_p, 1))?;;
+    engine.define_method("legal?", method!(Engine::legal_p, 1))?;
     Ok(())
 }

data/lib/pgn/attack.rb

@@ -14,7 +14,7 @@ module PGN
 
     # The 0x88 index of the `color` king on +board+, or nil if absent.
     def self.king_idx(board, color)
-      king = color == 'w' ? 'K' : 'k'
+      king = piece_letter('K', color)
       (0...128).each do |idx|
         next if idx.anybits?(0x88)
 
@@ -24,8 +24,13 @@ module PGN
     end
 
     # Whether +target+ (a 0x88 index) is attacked by any `color` piece.
+    # Checked (and short-circuited) piece type by piece type, cheapest first,
+    # so a hit skips the pricier ray-walk sliders scan entirely.
     def self.attacked?(board, target, color)
-      attackers(board, target, color).any?
+      pawn_attackers(board, target, color).any? ||
+        knight_attackers(board, target, color).any? ||
+        king_attackers(board, target, color).any? ||
+        slider_attackers(board, target, color).any?
     end
 
     # The algebraic squares of every `color` piece on +board+ that attacks
@@ -40,9 +45,14 @@ module PGN
     class << self
       private
 
+      # 'w' -> the uppercase letter, 'b' -> the lowercase letter.
+      def piece_letter(letter, color)
+        color == 'w' ? letter : letter.downcase
+      end
+
       def pawn_attackers(board, target, color)
         offs = color == 'w' ? [-15, -17] : [15, 17]
-        pawn = color == 'w' ? 'P' : 'p'
+        pawn = piece_letter('P', color)
         offs.each_with_object([]) do |off, a|
           i = target + off
           a << board.square_name(i) if i.nobits?(0x88) && board.at_index(i) == pawn
@@ -50,23 +60,23 @@ module PGN
       end
 
       def knight_attackers(board, target, color)
-        knight = color == 'w' ? 'N' : 'n'
+        knight = piece_letter('N', color)
         Board::KNIGHT_ATTACKS[target].each_with_object([]) do |i, a|
           a << board.square_name(i) if board.at_index(i) == knight
         end
       end
 
       def king_attackers(board, target, color)
-        king = color == 'w' ? 'K' : 'k'
+        king = piece_letter('K', color)
         Board::KING_ATTACKS[target].each_with_object([]) do |i, a|
           a << board.square_name(i) if board.at_index(i) == king
         end
       end
 
       def slider_attackers(board, target, color)
-        bishop = color == 'w' ? 'B' : 'b'
-        rook = color == 'w' ? 'R' : 'r'
-        queen = color == 'w' ? 'Q' : 'q'
+        bishop = piece_letter('B', color)
+        rook = piece_letter('R', color)
+        queen = piece_letter('Q', color)
         squares = []
         ray_attackers(board, target, BISHOP_DIRS) do |piece, sq|
           squares << sq if piece == bishop || piece == queen

data/lib/pgn/epd.rb

@@ -14,6 +14,8 @@ module PGN
   #   PGN::FEN.start.to_epd #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq -"
   #
   class EPD
+    include PositionFields
+
     attr_accessor :board, :active, :ops
     attr_reader :castling, :en_passant
 
@@ -31,40 +33,11 @@ module PGN
       self.ops = fields[4]
     end
 
-    def castling=(val)
-      @castling = val.nil? || val.empty? ? '-' : val
-    end
-
-    def en_passant=(val)
-      @en_passant = val.nil? ? '-' : val
-    end
-
-    # @param board_fen [String] the FEN/EPD representation of the board
-    #
-    def board_string=(board_fen)
-      squares = board_fen.gsub(/\d/) { |match| '_' * match.to_i }
-                         .split('/')
-                         .map(&:chars)
-                         .map { |row| row.map { |e| e == '_' ? nil : e } }
-                         .reverse
-                         .transpose
-      self.board = PGN::Board.new(squares)
-    end
-
-    # @return [String] the EPD board-string portion
-    #
-    def board_string
-      board.fen_board_string
-    end
-
     # @return [PGN::Position] a {PGN::Position} for this EPD. Halfmove and
     #   fullmove default to 0 and 1 (EPD does not carry them).
     #
     def to_position
-      player = active == 'w' ? :white : :black
-      castling_rights = castling.chars - ['-']
-      ep = en_passant == '-' ? nil : en_passant
-
+      player, castling_rights, ep = position_fields
       PGN::Position.new(board, player, castling_rights, ep, 0, 1)
     end
 

data/lib/pgn/fen.rb

@@ -1,4 +1,44 @@
 module PGN
+  # Shared FEN/EPD board-field parsing and serialization: the piece-placement
+  # field, and the '-'-normalized castling/en-passant fields. {PGN::FEN} and
+  # {PGN::EPD} both include this rather than each carrying their own copy.
+  module PositionFields
+    def castling=(val)
+      @castling = val.nil? || val.empty? ? '-' : val
+    end
+
+    def en_passant=(val)
+      @en_passant = val.nil? ? '-' : val
+    end
+
+    # @param board_fen [String] the FEN/EPD representation of the board
+    def board_string=(board_fen)
+      squares = board_fen.gsub(/\d/) { |match| '_' * match.to_i }
+                         .split('/')
+                         .map(&:chars)
+                         .map { |row| row.map { |e| e == '_' ? nil : e } }
+                         .reverse
+                         .transpose
+      self.board = PGN::Board.new(squares)
+    end
+
+    # @return [String] the FEN/EPD board-string portion
+    def board_string
+      board.fen_board_string
+    end
+
+    private
+
+    # The player/castling-rights/en-passant args shared by FEN#to_position
+    # and EPD#to_position (which differ only in halfmove/fullmove).
+    def position_fields
+      player = active == 'w' ? :white : :black
+      castling_rights = castling.chars - ['-']
+      ep = en_passant == '-' ? nil : en_passant
+      [player, castling_rights, ep]
+    end
+  end
+
   # {PGN::FEN} is responsible for translating between strings in FEN
   # notation and an internal representation of the board.
   #
@@ -35,14 +75,17 @@ module PGN
   #     plays.
   #
   class FEN
+    include PositionFields
+
     # The FEN string representing the starting position in chess
     #
     INITIAL = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1'.freeze
 
     attr_accessor :board, :active, :halfmove, :fullmove
-    # `castling` and `en_passant` have custom writers below (normalize nil/empty
-    # to '-'), so expose readers here and define the writers explicitly to avoid
-    # redefining the accessors generated by attr_accessor (Lint/DuplicateMethods).
+    # `castling` and `en_passant` have custom writers in {PositionFields}
+    # (normalize nil/empty to '-'), so expose readers here and rely on the
+    # module for the writers, to avoid redefining the accessors generated by
+    # attr_accessor (Lint/DuplicateMethods).
     attr_reader :castling, :en_passant
 
     # @return [PGN::FEN] a {PGN::FEN} object representing the starting
@@ -75,52 +118,12 @@ module PGN
         self.fullmove = fen_string.split
     end
 
-    def en_passant=(val)
-      @en_passant = val.nil? ? '-' : val
-    end
-
-    def castling=(val)
-      @castling = val.nil? || val.empty? ? '-' : val
-    end
-
-    # @param board_fen [String] the fen representation of the board
-    # @example
-    #   fen.board_string = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
-    #
-    def board_string=(board_fen)
-      squares = board_fen.gsub(/\d/) { |match| '_' * match.to_i }
-                         .split('/')
-                         .map(&:chars)
-                         .map { |row| row.map { |e| e == '_' ? nil : e } }
-                         .reverse
-                         .transpose
-      self.board = PGN::Board.new(squares)
-    end
-
-    # @return [String] the fen representation of the board
-    # @example
-    #   PGN::FEN.start.board_string #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
-    #
-    def board_string
-      board.fen_board_string
-    end
-
     # @return [PGN::Position] a {PGN::Position} representing the current
     #   position
     #
     def to_position
-      player     = active == 'w' ? :white : :black
-      castling   = self.castling.chars - ['-']
-      en_passant = self.en_passant == '-' ? nil : self.en_passant
-
-      PGN::Position.new(
-        board,
-        player,
-        castling,
-        en_passant,
-        halfmove.to_i,
-        fullmove.to_i
-      )
+      player, castling_rights, ep = position_fields
+      PGN::Position.new(board, player, castling_rights, ep, halfmove.to_i, fullmove.to_i)
     end
 
     # @return [String] the EPD string for this position (the first four FEN

data/lib/pgn/game.rb

@@ -9,7 +9,7 @@ module PGN
     def initialize(notation, annotation = nil, comment = nil, variations = [])
       @notation = notation
       @annotation = annotation
-      @comment = clean_text(comment)
+      @comment = MoveText.clean_text(comment)
       @variations = variations
     end
 
@@ -29,16 +29,27 @@ module PGN
       @notation
     end
 
-    def clean_text(text)
+    # Normalize UCI-style castling ('0-0') to canonical SAN ('O-O').
+    def self.normalize_castling(san)
+      san.include?('0') ? san.gsub('0', 'O') : san
+    end
+
+    # Strip the single outermost brace pair, then unescape \{ \} \\ so
+    # the internal representation is the raw comment body. {Serializer}
+    # re-escapes on output, so parse -> serialize -> parse is byte-stable.
+    # Exposed as a class method so the parser can clean each trailing comment
+    # individually before concatenating multiple comments on one move.
+    def self.clean_text(text)
       return unless text
 
-      # Strip the single outermost brace pair, then unescape \{ \} \\ so
-      # the internal representation is the raw comment body. {Serializer}
-      # re-escapes on output, so parse -> serialize -> parse is byte-stable.
       text = text[1..-2] if text.start_with?('{') && text.end_with?('}')
       text = text.gsub(/\\([\\{}])/, '\1')
       text.gsub(/\s+/, ' ').strip
     end
+
+    def clean_text(text)
+      MoveText.clean_text(text)
+    end
   end
 
   # {PGN::Game} holds all of the information about a game. It is either
@@ -150,7 +161,7 @@ module PGN
 
     # Append a move in SAN, validating legality when the native engine is
     # available. Raises ArgumentError for an illegal move (when the engine is
-    # loaded) and invalidates the memoized position list.
+    # loaded). Grows the memoized position list in step, if it is populated.
     #
     # @param san [String, PGN::MoveText] the move to append
     # @return [self]
@@ -161,31 +172,31 @@ module PGN
       end
 
       @moves << move
-      @positions = nil
+      @positions << @positions.last.move(move.notation) if @positions
       self
     end
 
-    # Remove and return the last move, or nil if there are none. Invalidates
-    # the memoized position list.
+    # Remove and return the last move, or nil if there are none. Shrinks the
+    # memoized position list in step, if it is populated.
     #
     # @return [PGN::MoveText, nil]
     def pop
       return nil if @moves.empty?
 
       move = @moves.pop
-      @positions = nil
+      @positions&.pop
       move
     end
 
     # Whether any position has occurred three times in this game (the
     # threefold-repetition draw). Uses {PGN::Position#hash} (the Zobrist
-    # hash of the FEN-relevant state), streaming {#each_position} so the
-    # full position array need not be materialized for this check.
+    # hash of the FEN-relevant state) over {#positions}, so a prior or
+    # subsequent call that also needs the position list shares the replay.
     #
     # @return [Boolean]
     def threefold?
       counts = Hash.new(0)
-      each_position { |position| counts[position.hash] += 1 }
+      positions.each { |position| counts[position.hash] += 1 }
       counts.any? { |_, count| count >= 3 }
     end
 
@@ -245,9 +256,9 @@ module PGN
     # (it only strips a *single* outermost brace pair), so reusing or rebuilding
     # a MoveText never corrupts a comment that still contains inner braces.
     def standardize_castling(entry)
-      return MoveText.new(entry.include?('0') ? entry.gsub('0', 'O') : entry) if entry.is_a?(String)
+      return MoveText.new(MoveText.normalize_castling(entry)) if entry.is_a?(String)
 
-      notation = entry.notation.include?('0') ? entry.notation.gsub('0', 'O') : entry.notation
+      notation = MoveText.normalize_castling(entry.notation)
       return entry if notation.equal?(entry.notation)
 
       MoveText.new(notation, entry.annotation, entry.comment, entry.variations)