pgn2 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6363546a03960706a76a2048b8e88aff387e1f475eb76add1e1cfd615c6b6ed
-  data.tar.gz: 3944288b73d63291f31c0218902206eb39e2d8173fca7a91bb80aea59e0981a5
+  metadata.gz: 8fdc6dcb9543c25e2e1102902d031f9d733463780b6f5d16a1a4713c6cfe16b9
+  data.tar.gz: 051ba77cdb0e657909ef5a22c1470f229c883e2bcb70cbfd3b9dbfbb83e92b8e
 SHA512:
-  metadata.gz: 1bb3c90fcc6afcf5a2a7ca8a285518035de7645a7627c8d64ed89200e16e364f4f687dfe2107a3b3d6f2b2d994ce8cac5620f2f2d9418bdcd874cc84d07dddc5
-  data.tar.gz: b8b0e3a0254a29397d2ac263e16ea51ed524d886e2a9c69107d9cfa3c3ae4b6ba5cbbbfd8d4a14d73d74c5525f03102cd4aacbcee93ce5a9263288b05fd4e089
+  metadata.gz: 3999930da7369748415bfb222108d436a64c67bf8e91c5b0d12d9dc5ab38f64c78f1e1e56abca9454ed8e1a215df0918d152e37b1271808d8e1962088029a0e7
+  data.tar.gz: 2dec3d79ee03350d252bd846a789b3b96091f6ec34cd788d60e267506c2837436659395472fef192f3aeec8290ef32e3f7bd235308062a1de12f1add0e110ab7

data/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 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

@@ -29,6 +29,11 @@ module PGN
       @notation
     end
 
+    # 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
+
     def clean_text(text)
       return unless text
 
@@ -150,7 +155,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 +166,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 +250,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)

data/lib/pgn/node.rb

@@ -141,14 +141,7 @@ module PGN
         @line.push(*new_line)
       else
         normalize_branch_point(cont)
-        vars = cont.variations
-        pos = @index + 1
-        old_tail = @line[(pos + 1)..] || []
-        n0 = new_line[0]
-        @line[pos] = n0
-        @line[(pos + 1)..] = (new_line[1..] || [])
-        cont.variations = []
-        n0.variations = [[cont, *old_tail], *vars]
+        make_mainline(@line, @index + 1, cont, new_line, cont.variations, old_main_position: :first)
       end
       @game.root
     end
@@ -157,16 +150,9 @@ module PGN
     # No-op for the mainline (index 0) or the first variation (index 1).
     # Returns a fresh +game.root+.
     def promote
-      return @game.root if root?
-
-      i = sibling_index
-      return @game.root if i.nil? || i <= 1
-
-      cont = parent_continuation
-      normalize_branch_point(cont)
-      vars = cont.variations
-      vars[i - 1], vars[i - 2] = vars[i - 2], vars[i - 1]
-      @game.root
+      mutate_sibling(noop: ->(i) { i <= 1 }) do |i, _cont, vars|
+        vars[i - 1], vars[i - 2] = vars[i - 2], vars[i - 1]
+      end
     end
 
     # Move this node one slot toward the end among its siblings. At index 0
@@ -174,83 +160,54 @@ module PGN
     # mainline and the old mainline becomes variation #1. No-op at the last
     # index. Returns a fresh +game.root+.
     def demote
-      return @game.root if root?
-
-      i = sibling_index
-      sibs = @parent.children
-      return @game.root if i.nil? || i == sibs.size - 1
-
-      cont = parent_continuation
-      normalize_branch_point(cont)
-      vars = cont.variations
-      if i.zero?
-        v1 = vars.shift
-        make_mainline(cont, v1, vars, old_main_position: :first)
-      else
-        vars[i - 1], vars[i] = vars[i], vars[i - 1]
+      mutate_sibling(noop: ->(i) { i == @parent.children.size - 1 }) do |i, cont, vars|
+        if i.zero?
+          v1 = vars.shift
+          make_mainline(@parent.line, @parent.index + 1, cont, v1, vars, old_main_position: :first)
+        else
+          vars[i - 1], vars[i] = vars[i], vars[i - 1]
+        end
       end
-      @game.root
     end
 
     # Make this node the mainline at its branching point (the old mainline
     # becomes variation #1). No-op if already the mainline. Returns a
     # fresh +game.root+.
     def promote_to_main
-      return @game.root if root?
-
-      i = sibling_index
-      return @game.root if i.nil? || i.zero?
-
-      cont = parent_continuation
-      normalize_branch_point(cont)
-      vars = cont.variations
-      vk = vars.delete_at(i - 1)
-      make_mainline(cont, vk, vars, old_main_position: :first)
-      @game.root
+      mutate_sibling(noop: lambda(&:zero?)) do |i, cont, vars|
+        vk = vars.delete_at(i - 1)
+        make_mainline(@parent.line, @parent.index + 1, cont, vk, vars, old_main_position: :first)
+      end
     end
 
     # Move this node to the last position among its siblings. At index 0
     # the last variation becomes the new mainline and the old mainline
     # becomes the last variation. Returns a fresh +game.root+.
     def demote_to_last
-      return @game.root if root?
-
-      i = sibling_index
-      return @game.root if i.nil?
-
-      cont = parent_continuation
-      normalize_branch_point(cont)
-      vars = cont.variations
-      if i.zero?
-        return @game.root if vars.empty?
-
-        last = vars.pop
-        make_mainline(cont, last, vars, old_main_position: :last)
-      else
-        el = vars.delete_at(i - 1)
-        vars.push(el)
+      mutate_sibling do |i, cont, vars|
+        if i.zero?
+          unless vars.empty?
+            last = vars.pop
+            make_mainline(@parent.line, @parent.index + 1, cont, last, vars, old_main_position: :last)
+          end
+        else
+          el = vars.delete_at(i - 1)
+          vars.push(el)
+        end
       end
-      @game.root
     end
 
     # Remove this node and its subtree. If it is the mainline continuation,
     # the first remaining variation (if any) takes its place; otherwise the
     # line is truncated at this point. Returns a fresh +game.root+.
     def delete
-      return @game.root if root?
-
-      i = sibling_index
-      return @game.root if i.nil?
-
-      cont = parent_continuation
-      normalize_branch_point(cont)
-      vars = cont.variations
-      if i.zero?
-        delete_mainline_continuation(cont, vars)
-      else
-        vars.delete_at(i - 1)
+      mutate_sibling do |i, cont, vars|
+        if i.zero?
+          delete_mainline_continuation(cont, vars)
+        else
+          vars.delete_at(i - 1)
+        end
       end
-      @game.root
     end
 
     private
@@ -295,11 +252,25 @@ module PGN
     # SANs, applying the same castling 0->O normalization as Game#moves=.
     def build_movetexts(move_or_moves)
       sans = move_or_moves.is_a?(String) ? [move_or_moves] : move_or_moves
-      sans.map { |s| PGN::MoveText.new(normalize_castling(s)) }
+      sans.map { |s| PGN::MoveText.new(PGN::MoveText.normalize_castling(s)) }
     end
 
-    def normalize_castling(san)
-      san.include?('0') ? san.gsub('0', 'O') : san
+    # Shared prologue/epilogue for the sibling-reordering mutators (promote,
+    # demote, promote_to_main, demote_to_last, delete): no-op at the root or
+    # per +noop+ (checked against the sibling index before any mutation),
+    # otherwise normalize the branching point and yield the sibling index,
+    # the parent's mainline continuation, and its (now flat) variations to
+    # +block+ for the mutation proper. Always returns a fresh +game.root+.
+    def mutate_sibling(noop: nil)
+      return @game.root if root?
+
+      i = sibling_index
+      return @game.root if i.nil? || noop&.call(i)
+
+      cont = parent_continuation
+      normalize_branch_point(cont)
+      yield i, cont, cont.variations
+      @game.root
     end
 
     # Hoist every variation first-move branching at the position before
@@ -331,18 +302,24 @@ module PGN
       end
     end
 
-    # Make +vk+ (= [vk0, *tail]) the new mainline continuation at the
-    # parent's position, replacing +cont+. The old mainline (+cont+ and
-    # its tail) becomes a variation appended to +others+ either before
-    # (+old_main_position == :first+) or after (+:last+). +cont.variations+
-    # is cleared (its at-point variations are now +vk0+'s siblings).
-    def make_mainline(cont, variation, others, old_main_position:)
-      line = @parent.line
-      pos = @parent.index + 1
+    # Splice +movetexts+ (an Array<MoveText>) into +line+ starting at +pos+:
+    # its first entry replaces +line[pos]+, and the rest replace the tail
+    # after it (so a shorter +movetexts+ truncates +line+).
+    def splice_line!(line, pos, movetexts)
+      line[pos] = movetexts[0]
+      line[(pos + 1)..] = (movetexts[1..] || [])
+    end
+
+    # Make +vk+ (= [vk0, *tail]) the new mainline continuation at +line+/+pos+
+    # (the position before +cont+), replacing +cont+. The old mainline
+    # (+cont+ and its tail) becomes a variation appended to +others+ either
+    # before (+old_main_position == :first+) or after (+:last+).
+    # +cont.variations+ is cleared (its at-point variations are now +vk0+'s
+    # siblings).
+    def make_mainline(line, pos, cont, variation, others, old_main_position:)
       old_tail = line[(pos + 1)..] || []
       variation0 = variation[0]
-      line[pos] = variation0
-      line[(pos + 1)..] = (variation[1..] || [])
+      splice_line!(line, pos, variation)
       cont.variations = []
       old_var = [cont, *old_tail]
       variation0.variations =
@@ -361,11 +338,9 @@ module PGN
         line[pos..] = []
       else
         first_variation = vars.shift
-        first_variation_move = first_variation[0]
-        line[pos] = first_variation_move
-        line[(pos + 1)..] = (first_variation[1..] || [])
+        splice_line!(line, pos, first_variation)
         cont.variations = []
-        first_variation_move.variations = vars
+        first_variation[0].variations = vars
       end
     end
   end

data/lib/pgn/position.rb

@@ -179,8 +179,10 @@ module PGN
     #
     # @return [Boolean]
     def in_check?
+      return @in_check if defined?(@in_check)
+
       king = PGN::Attack.king_idx(board, mover_color)
-      !king.nil? && PGN::Attack.attacked?(board, king, opponent_color)
+      @in_check = !king.nil? && PGN::Attack.attacked?(board, king, opponent_color)
     end
 
     # The algebraic squares of every piece of the given color that attacks

data/lib/pgn/version.rb

@@ -1,3 +1,3 @@
 module PGN
-  VERSION = '2.0.1'.freeze
+  VERSION = '2.0.2'.freeze
 end

data/spec/game_spec.rb

@@ -133,20 +133,6 @@ describe PGN::Game do
   describe 'node mutation round-trip' do
     non_round_trip = %w[doublequotes.pgn specialcharacters.pgn].freeze
 
-    # A node-sig tree with variations sorted, so the comparison is
-    # order-independent (the parser reverses variation order on each parse).
-    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
-
     # First node (DFS over children) that has at least one variation. Such a
     # node always has a non-nil continuation, so add_variation can branch.
     def first_branch_with_variations(node)

data/spec/node_spec.rb

@@ -1,23 +1,5 @@
 require 'spec_helper'
 
-# 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 (the same
-# approach the existing game_spec round-trip gate uses), 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
-
 describe PGN::Node do
   let(:game) { PGN.parse(File.read(File.expand_path('pgn_files/variations.pgn', __dir__), encoding: Encoding::ISO_8859_1)).first }
   let(:root) { game.root }

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.2
 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-18 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
-}