pgn2 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a5ce857277684a9f89c02d35941d7c455df2ca8a18f557985f3ca92eed414b3
-  data.tar.gz: 5f126a3da7a6f314748495919168336bb7b97d07e5ad0c9f2ac9b9956a8bb4be
+  metadata.gz: 963f48df8fbfe5d69097030a9434a05b82e211c235772273f03bd11178afb8a5
+  data.tar.gz: 6bc38e0387e7061e3649fe52d22e5f01dabdc7029f8c27294d56b62a3779a76c
 SHA512:
-  metadata.gz: '079c4e3c1dd292c58fac802349c8d9d8054efa4a01288090bd0a38472029b8848a162cd4264fe83135c80d14fb9ea65d531009ddc6dbd6237e30c4f4bb9efda8'
-  data.tar.gz: e3ec9dbcf8dad46e7e8ec623642d468253a4ee6d5899dd9d1ac7486e60416b9069a49e34de092e08744439b9c40dce84074a6ddcaed91a584d88a65be6646b9a
+  metadata.gz: e81b88377f5d1ab6102a5b15d4d006feb4201647125b5b3d434b826dfa55cac60c82048fc8d4d2a4c8aa7d1600d6ba4edd472f27d063d258703d8e225c0832cc
+  data.tar.gz: 06cb00152b81f2124749fbc743356a25a7ee44e049c7779fb397660a84ebfefee8afcf4679f86ac633ff12b771db007123308cd5c65520ae8329e7334b340ab9

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 1.2.1 (2026-08-13)
+
+### Summary
+
+Replay (move-application) throughput quick win on the `MoveCalculator`
+hot path. No public API changes; serialized PGN/FEN output stays
+byte-identical. See `bench/IMPROVEMENTS.md` for the per-step deltas.
+
+### Changed
+- **`MoveCalculator#valid_square?`**: integer compares (`file >= 0 &&
+  file < 8`) instead of `(0..7).include?(file)`, which both allocates a
+  `Range` per call and is ~3.4x slower. This predicate sits inside the
+  `first_piece` / `move_origins` / `king_position` inner board-scanning
+  loops — the dominant replay compute site (~46% of replay CPU via
+  per-method timing, not the SAN regex parse as had been assumed).
+- **`MoveCalculator#compute_origin`**: string `case` (`when 'B','R','Q',...`)
+  instead of `/[brq]/i` regex `===` matches, removing 4 `MatchData`
+  allocations per move.
+- **`MoveCalculator#first_piece`**: returns only the `[file, rank]` square
+  (`nil` when the scan runs off the edge) instead of a `[piece, square]`
+  wrapper tuple; callers read the piece via a new `piece_at` helper. Removes
+  one array allocation per direction scan.
+- Performance vs 1.2.0 (immortal game, 45 plies, fresh process each):
+  replay throughput 814.65 us/i -> 752.54 us/i (+8.2%); replay allocations
+  1709 -> 1571 objects (-138, -8.1%) and 103720 -> 92440 bytes (-10.9%).
+  182 specs pass; byte-identical FEN/PGN output; zero new rubocop offenses
+  vs 1.2.0. The piece-location-index rewrite (the real ~46% ceiling,
+  deferred "Approach B") is unchanged.
+
 ## 1.2.0 (2026-08-13)
 
 ### Summary

data/lib/pgn/move_calculator.rb

@@ -185,9 +185,9 @@ module PGN
       return nil if move.castle
 
       possibilities = case move.piece
-                      when /[brq]/i then direction_origins
-                      when /[kn]/i  then move_origins
-                      when /p/i     then pawn_origins
+                      when 'B', 'R', 'Q', 'b', 'r', 'q' then direction_origins
+                      when 'K', 'N', 'k', 'n' then move_origins
+                      when 'P', 'p' then pawn_origins
                       else # don't care move, used in variations
                         return nil
                       end
@@ -207,8 +207,8 @@ module PGN
       possibilities = []
 
       directions.each do |dir|
-        piece, square = first_piece(destination_coords, dir)
-        possibilities << square if piece == move.piece
+        square = first_piece(destination_coords, dir)
+        possibilities << square if piece_at(square) == move.piece
       end
 
       possibilities
@@ -285,28 +285,44 @@ module PGN
         attacking_piece = attacking_piece.upcase if move.black?
 
         directions.each do |dir|
-          piece, square = first_piece(king_pos, dir)
-          next unless piece == move.piece && possibilities.include?(square)
+          square = first_piece(king_pos, dir)
+          next unless piece_at(square) == move.piece && possibilities.include?(square)
 
-          piece, = first_piece(square, dir)
-          possibilities.reject! { |p| p == square } if piece == attacking_piece
+          next_square = first_piece(square, dir)
+          possibilities.reject! { |p| p == square } if piece_at(next_square) == attacking_piece
         end
       end
 
       possibilities
     end
 
+    # Walks from `from` in `direction` until it reaches the edge of the board
+    # or the first occupied square. Returns that square's `[file, rank]`
+    # coordinates, or `nil` if no piece was encountered before the edge. The
+    # caller reads the piece off the board itself, so this avoids allocating
+    # the `[piece, square]` wrapper tuple per direction scan.
+    #
     def first_piece(from, direction)
       file, rank = from
       i,    j    = direction
 
-      piece = nil
+      loop do
+        file += i
+        rank += j
+        return nil if file.negative? || file > 7 || rank.negative? || rank > 7
 
-      while valid_square?(file += i, rank += j)
-        break if (piece = board.at(file, rank))
+        square = [file, rank]
+        return square if board.at(file, rank)
       end
+    end
 
-      [piece, [file, rank]]
+    # Reads the piece on a square, tolerating a nil square (returned by
+    # {#first_piece} when the scan ran off the edge). Kept as a helper so the
+    # callers read the piece once instead of unpacking a `[piece, square]`
+    # tuple per direction scan.
+    #
+    def piece_at(square)
+      square && board.at(square[0], square[1])
     end
 
     # If the move is a capture and there is no piece on the
@@ -331,7 +347,7 @@ module PGN
     end
 
     def valid_square?(file, rank)
-      (0..7).include?(file) && (0..7).include?(rank)
+      file >= 0 && file < 8 && rank >= 0 && rank < 8
     end
 
     def destination_coords

data/lib/pgn/version.rb

@@ -1,3 +1,3 @@
 module PGN
-  VERSION = '1.2.0'.freeze
+  VERSION = '1.2.1'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgn2
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Stacey Touset