pgn2 1.4.0 → 2.0.0

data/lib/pgn/board.rb

@@ -27,10 +27,35 @@ module PGN
     ].freeze
 
     FILE_TO_INDEX = ('a'..'h').each_with_index.to_h
-    INDEX_TO_FILE = FILE_TO_INDEX.map(&:reverse).to_h
+    INDEX_TO_FILE = FILE_TO_INDEX.invert
 
     RANK_TO_INDEX = ('1'..'8').each_with_index.to_h
-    INDEX_TO_RANK = RANK_TO_INDEX.map(&:reverse).to_h
+    INDEX_TO_RANK = RANK_TO_INDEX.invert
+
+    # 0x88 knight offsets (a1 + 33 = b3, etc.).
+    KNIGHT_OFFS = [33, 31, -31, -33, 18, 14, -14, -18].freeze
+    KING_OFFS = [-1, 1, -16, 16, -15, 15, -17, 17].freeze
+
+    # Precomputed on-board attack masks: entry `idx` is the frozen Array of
+    # on-board 0x88 target indices reachable from `idx` by that piece. Built
+    # once at load time so the per-call offset + off-board test is replaced by
+    # a direct array iteration.
+    KNIGHT_ATTACKS = Array.new(128) do |idx|
+      next nil if (idx & 0x88) != 0 # rubocop:disable Style/BitwisePredicate
+
+      KNIGHT_OFFS.each_with_object([]) do |off, a|
+        t = idx + off
+        a << t if (t & 0x88).zero? # rubocop:disable Style/BitwisePredicate
+      end.freeze
+    end.freeze
+    KING_ATTACKS = Array.new(128) do |idx|
+      next nil if (idx & 0x88) != 0 # rubocop:disable Style/BitwisePredicate
+
+      KING_OFFS.each_with_object([]) do |off, a|
+        t = idx + off
+        a << t if (t & 0x88).zero? # rubocop:disable Style/BitwisePredicate
+      end.freeze
+    end.freeze
 
     # algebraic to unicode piece lookup
     #
@@ -102,7 +127,6 @@ module PGN
           @cells[(r * 16) + f] = squares[f][r]
         end
       end
-      @cells
     end
 
     # @overload at(str)
@@ -119,9 +143,9 @@ module PGN
     #   board.at("e4") #=> "P"
     #
     def at(arg0, arg1 = nil)
-      return @cells[(arg1 * 16) + arg0] unless arg1.nil?
+      return at_index(index_for(arg0, arg1)) unless arg1.nil?
 
-      @cells[(rank_of(arg0) * 16) + file_of(arg0)]
+      at_index(index_of(arg0))
     end
 
     # @param changes [Hash<String, <String, nil>>] changes to make to the board
@@ -141,8 +165,7 @@ module PGN
     #   board.update("e4", "P")
     #
     def update(square, piece)
-      @cells[(rank_of(square) * 16) + file_of(square)] = piece
-      self
+      update_index(index_of(square), piece)
     end
 
     # @param position [String] the square in algebraic notation
@@ -173,13 +196,25 @@ module PGN
       end.join("\n")
     end
 
+    # Build a {Board} directly from a 0x88 cell array, bypassing the 8x8
+    # -> 0x88 conversion in {#initialize}. Used by {#dup} (which runs every
+    # move) to skip the per-square rebuild; the cell array is already in the
+    # canonical 128-cell layout.
+    #
+    # @param cells [Array<String, nil>] a 128-cell 0x88 array
+    # @return [PGN::Board]
+    #
+    def self.from_cells(cells)
+      board = allocate
+      board.instance_variable_set(:@cells, cells)
+      board
+    end
+
     # @return [PGN::Board] a copy of self. Copies the 128-cell 0x88 array;
     #   mutations to the copy do not affect the original.
     #
     def dup
-      copy = PGN::Board.allocate
-      copy.instance_variable_set(:@cells, @cells.dup)
-      copy
+      self.class.from_cells(@cells.dup)
     end
 
     # -- 0x88 hot-path API (integer indices) ---------------------------------
@@ -235,6 +270,64 @@ module PGN
       self
     end
 
+    # Whether a 0x88 index is on the board (see the class doc for the
+    # bitmask this tests).
+    #
+    # @param idx [Integer] a 0x88 square index
+    # @return [Boolean]
+    #
+    def on_board?(idx)
+      (idx & 0x88).zero? # rubocop:disable Style/BitwisePredicate
+    end
+
+    # The algebraic square name of a 0x88 index.
+    #
+    # @param idx [Integer] a 0x88 square index
+    # @return [String] e.g. "e4"
+    #
+    def square_name(idx)
+      INDEX_TO_FILE[idx & 0x0F] + INDEX_TO_RANK[idx >> 4]
+    end
+
+    # Serializes the board to the FEN board-string portion (ranks 8→1,
+    # files a→h, runs of empty squares collapsed to a digit) by walking
+    # the 0x88 `@cells` array directly. This avoids rebuilding the 8x8
+    # `squares` array on every FEN generation.
+    #
+    # @return [String] e.g. "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
+    def fen_board_string
+      rows = []
+      7.downto(0) do |rank|
+        s = String.new
+        run = 0
+        0.upto(7) do |file|
+          piece = @cells[(rank * 16) + file]
+          if piece.nil?
+            run += 1
+          else
+            s << run.to_s if run.positive?
+            run = 0
+            s << piece
+          end
+        end
+        s << run.to_s if run.positive?
+        rows << s
+      end
+      rows.join('/')
+    end
+
+    # Boards are equal when every cell holds the same piece (or is
+    # empty), including off-board padding, which is always nil on both.
+    def eql?(other)
+      other.is_a?(Board) && cells == other.cells
+    end
+
+    alias == eql?
+
+    protected
+
+    attr_reader :cells
+
     private
 
     def file_of(square)

data/lib/pgn/fen.rb

@@ -37,9 +37,13 @@ module PGN
   class FEN
     # The FEN string representing the starting position in chess
     #
-    INITIAL = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+    INITIAL = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1'.freeze
 
-    attr_accessor :board, :active, :castling, :en_passant, :halfmove, :fullmove
+    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).
+    attr_reader :castling, :en_passant
 
     # @return [PGN::FEN] a {PGN::FEN} object representing the starting
     #   position
@@ -61,22 +65,22 @@ module PGN
     # @param fen_string [String] a string in Forsyth-Edwards Notation
     #
     def initialize(fen_string = nil)
-      if fen_string
-        self.board_string,
-          self.active,
-          self.castling,
-          self.en_passant,
-          self.halfmove,
-          self.fullmove = fen_string.split
-      end
+      return unless fen_string
+
+      self.board_string,
+        self.active,
+        self.castling,
+        self.en_passant,
+        self.halfmove,
+        self.fullmove = fen_string.split
     end
 
     def en_passant=(val)
-      @en_passant = val.nil? ? "-" : val
+      @en_passant = val.nil? ? '-' : val
     end
 
     def castling=(val)
-      @castling = (val.nil? || val.empty?) ? "-" : val
+      @castling = val.nil? || val.empty? ? '-' : val
     end
 
     # @param board_fen [String] the fen representation of the board
@@ -84,10 +88,10 @@ module PGN
     #   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 {|row| row.split('') }
-                         .map {|row| row.map {|e| e == "_" ? nil : e } }
+      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)
@@ -98,39 +102,24 @@ module PGN
     #   PGN::FEN.start.board_string #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
     #
     def board_string
-      rows = self.board.squares.transpose.reverse
-      rows.map do |row|
-        s = +""
-        run = 0
-        row.each do |e|
-          if e.nil?
-            run += 1
-          else
-            s << run.to_s if run > 0
-            run = 0
-            s << e
-          end
-        end
-        s << run.to_s if run > 0
-        s
-      end.join("/")
+      board.fen_board_string
     end
 
     # @return [PGN::Position] a {PGN::Position} representing the current
     #   position
     #
     def to_position
-      player     = self.active == 'w' ? :white : :black
-      castling   = self.castling.split('') - ['-']
-      en_passant = self.en_passant == '-' ? nil : en_passant
+      player     = active == 'w' ? :white : :black
+      castling   = self.castling.chars - ['-']
+      en_passant = nil if self.en_passant == '-'
 
       PGN::Position.new(
-        self.board,
+        board,
         player,
         castling,
         en_passant,
-        self.halfmove.to_i,
-        self.fullmove.to_i,
+        halfmove.to_i,
+        fullmove.to_i
       )
     end
 
@@ -140,17 +129,17 @@ module PGN
     #
     def to_s
       [
-        self.board_string,
-        self.active,
-        self.castling,
-        self.en_passant,
-        self.halfmove,
-        self.fullmove,
-      ].join(" ")
+        board_string,
+        active,
+        castling,
+        en_passant,
+        halfmove,
+        fullmove
+      ].join(' ')
     end
 
     def inspect
-      self.to_s
+      to_s
     end
   end
 end

data/lib/pgn/game.rb

@@ -30,7 +30,9 @@ module PGN
     end
 
     def clean_text(text)
-      text&.gsub(/{(.*)}/, '\1')&.gsub(/\s+/, ' ')&.strip
+      return unless text
+
+      text.gsub(/{(.*)}/, '\1').gsub(/\s+/, ' ').strip
     end
   end
 
@@ -106,16 +108,25 @@ module PGN
     # @return [Array<PGN::Position>] list of the {PGN::Position}s in the game
     #
     def positions
-      @positions ||= begin
-        position = starting_position
-        arr = [position]
-        moves.each do |move|
-          new_pos = position.move(move.notation)
-          arr << new_pos
-          position = new_pos
-        end
-        arr
+      @positions ||= each_position.to_a
+    end
+
+    # @return [Enumerator, self] with a block: yields each {PGN::Position}
+    #   in order (starting position, then one per move) and returns self.
+    #   Without a block: returns an Enumerator that yields the same.
+    #
+    # The replay loop is shared with {#positions} so eager and lazy paths
+    # produce identical position objects in identical order.
+    def each_position
+      return enum_for(:each_position) unless block_given?
+
+      position = starting_position
+      yield position
+      moves.each do |move|
+        position = position.move(move.notation)
+        yield position
       end
+      self
     end
 
     # @return [Array<String>] list of the fen representations of the positions
@@ -158,9 +169,7 @@ module PGN
       return MoveText.new(entry.include?('0') ? entry.gsub('0', 'O') : entry) if entry.is_a?(String)
 
       notation = entry.notation.include?('0') ? entry.notation.gsub('0', 'O') : entry.notation
-      if notation.equal?(entry.notation) && (entry.comment.nil? || !entry.comment.include?('{'))
-        return entry
-      end
+      return entry if notation.equal?(entry.notation) && (entry.comment.nil? || !entry.comment.include?('{'))
 
       MoveText.new(notation, entry.annotation, entry.comment, entry.variations)
     end

data/lib/pgn/lexer.rb

@@ -161,7 +161,6 @@ module PGN
     def initialize(input)
       @input = input
       @ss = StringScanner.new(input)
-      @line = 1
       @game_starts = []
       @between_games = true # at start we are "between" games
     end
@@ -182,7 +181,8 @@ module PGN
       type, value = next_token_pair
       return nil unless type
 
-      Token.new(type: type, value: value, offset: @last_offset, line: @line)
+      Token.new(type: type, value: value, offset: @last_offset,
+                line: line_at(@last_offset))
     end
 
     # Fast path for the parser: returns [type, value] for the next
@@ -203,7 +203,6 @@ module PGN
         end
 
         value = scan_one
-        advance_line(value)
         next if @scan_discarded
 
         note_token(@scan_type, off)
@@ -231,7 +230,7 @@ module PGN
         return m
       end
       raise UnconsumedInputError,
-            "Unmatched input #{@input.byteslice(@ss.pos..).inspect} on line #{@line}"
+            "Unmatched input #{@input.byteslice(@ss.pos..).inspect} on line #{line_at(@ss.pos)}"
     end
 
     # Track per-game content-start offsets for verbatim pgn slicing.
@@ -246,8 +245,12 @@ module PGN
       end
     end
 
-    def advance_line(str)
-      @line += str.count("\n")
+    # Line number at a byte offset, computed lazily only for error messages
+    # and the spec `tokens` helper. Keeping a running `@line` on the parse hot
+    # path (one `str.count("\n")` per token) was ~6% of parse CPU for a value
+    # the parser never reads.
+    def line_at(off)
+      1 + @input.byteslice(0, off).count("\n")
     end
   end
 

data/lib/pgn/move.rb

@@ -57,8 +57,12 @@ module PGN
   #
 
   class Move
-    attr_accessor :san, :player
-    attr_accessor :piece, :destination, :promotion, :check, :capture, :disambiguation, :castle
+    attr_accessor :san, :player, :destination, :check
+    # piece/promotion/capture/disambiguation/castle have custom writers below
+    # (color normalization, nil-coalescing, etc.), so expose only readers here
+    # to avoid redefining attr_accessor setters (Lint/DuplicateMethods).
+    attr_reader :piece, :promotion, :capture, :disambiguation, :castle
+
     # A regular expression for matching moves in standard algebraic
     # notation
     #
@@ -70,7 +74,7 @@ module PGN
       (?<capture>        x            ){0}
       (?<disambiguation> [a-h]?[1-8]? ){0}
 
-      (?<castle>         O-O(-O)?     ){0}
+      (?<castle>         O-O(?:-O)?    ){0}
 
       (?<normal>
         \g<piece>?
@@ -80,8 +84,8 @@ module PGN
         \g<promotion>?
       ){0}
 
-      \A (\g<castle> | \g<normal>) \g<check>? \z
-    /x.freeze
+      \A (?:\g<castle> | \g<normal>) \g<check>? \z
+    /x
 
     # @param move [String] the move in SAN
     # @param player [Symbol] the player making the move
@@ -115,10 +119,10 @@ module PGN
     end
 
     def promotion=(val)
-      if val
-        val.downcase! if black?
-        @promotion = val.delete('=')
-      end
+      return unless val
+
+      val.downcase! if black?
+      @promotion = val.delete('=')
     end
 
     def capture=(val)
@@ -130,11 +134,11 @@ module PGN
     end
 
     def castle=(val)
-      if val
-        @castle = 'K' if val == 'O-O'
-        @castle = 'Q' if val == 'O-O-O'
-        @castle.downcase! if black?
-      end
+      return unless val
+
+      @castle = 'K' if val == 'O-O'
+      @castle = 'Q' if val == 'O-O-O'
+      @castle.downcase! if black?
     end
 
     # @return [Boolean] whether the move results in check
@@ -164,7 +168,7 @@ module PGN
     # @return [Boolean] whether the piece being moved is a pawn
     #
     def pawn?
-      piece == 'P' || piece == 'p'
+      %w[P p].include?(piece)
     end
   end
 end

data/lib/pgn/move_calculator.rb

@@ -30,7 +30,7 @@ module PGN
     # 0x88 single-step offsets for knight and king.
     #
     STEP = {
-      'k' => [-1, 1, -16, 16, -15, 15, -17, 17],
+      'k' => SLIDE['q'],
       'n' => [33, 31, -31, -33, 18, 14, -14, -18]
     }.freeze
 
@@ -42,15 +42,6 @@ module PGN
       'p' => { capture: [15, 17], normal: [16], double: [32] }
     }.freeze
 
-    # The squares to update for each castling move, keyed by 0x88 index.
-    #
-    CASTLING = {
-      'Q' => { 0 => nil, 2 => 'K', 3 => 'R', 4 => nil },
-      'K' => { 4 => nil, 5 => 'R', 6 => 'K', 7 => nil },
-      'q' => { 112 => nil, 114 => 'k', 115 => 'r', 116 => nil },
-      'k' => { 116 => nil, 117 => 'r', 118 => 'k', 119 => nil }
-    }.freeze
-
     # Corner-square 0x88 indices, used for castling-restriction bookkeeping
     # (a rook leaving or being captured on a corner drops the matching right).
     #
@@ -59,6 +50,29 @@ module PGN
     A8 = 112
     H8 = 119
 
+    # King/rook landing squares for castling, named for readability in
+    # {CASTLING} below.
+    #
+    C1 = 2
+    D1 = 3
+    E1 = 4
+    F1 = 5
+    G1 = 6
+    C8 = 114
+    D8 = 115
+    E8 = 116
+    F8 = 117
+    G8 = 118
+
+    # The squares to update for each castling move, keyed by 0x88 index.
+    #
+    CASTLING = {
+      'Q' => { A1 => nil, C1 => 'K', D1 => 'R', E1 => nil },
+      'K' => { E1 => nil, F1 => 'R', G1 => 'K', H1 => nil },
+      'q' => { A8 => nil, C8 => 'k', D8 => 'r', E8 => nil },
+      'k' => { E8 => nil, F8 => 'r', G8 => 'k', H8 => nil }
+    }.freeze
+
     # rook-origin (0x88 index) -> castling restriction it drops.
     #
     ROOK_RESTRICTIONS = { A1 => 'Q', H1 => 'K', A8 => 'q', H8 => 'k' }.freeze
@@ -69,14 +83,14 @@ module PGN
     WHITE_CASTLE = %w[K Q].freeze
     BLACK_CASTLE = %w[k q].freeze
 
-    attr_accessor :board, :move
+    attr_reader :board, :move
 
     # @param board [PGN::Board] the current board
     # @param move [PGN::Move] the current move
     #
     def initialize(board, move)
-      self.board = board
-      self.move  = move
+      @board = board
+      @move  = move
       @origin_idx = compute_origin
     end
 
@@ -87,7 +101,7 @@ module PGN
     def origin
       return nil if @origin_idx.nil?
 
-      board.position_for([@origin_idx & 0x0F, @origin_idx >> 4])
+      board.square_name(@origin_idx)
     end
 
     # @return [PGN::Board] the board after the move is made
@@ -177,7 +191,7 @@ module PGN
 
       possibilities = case move.piece
                       when 'B', 'R', 'Q', 'b', 'r', 'q' then direction_origins
-                      when 'K', 'N', 'k', 'n' then move_origins
+                      when 'K', 'N', 'k', 'n' then leaper_origins
                       when 'P', 'p' then pawn_origins
                       else # don't care move, used in variations
                         return nil
@@ -215,7 +229,7 @@ module PGN
       possibilities = []
       offsets.each do |off|
         target = dest + off
-        next unless (target & 0x88).zero? # rubocop:disable Style/BitwisePredicate
+        next unless board.on_board?(target)
 
         possibilities << target if board.at_index(target) == move.piece
       end
@@ -223,6 +237,18 @@ module PGN
       possibilities
     end
 
+    # Knight/king origins use the precomputed on-board attack masks on
+    # {PGN::Board}, skipping the per-call off-board test.
+    def leaper_origins
+      dest  = dest_idx
+      mask  = move.piece.upcase == 'N' ? Board::KNIGHT_ATTACKS[dest] : Board::KING_ATTACKS[dest]
+      piece = move.piece
+
+      possibilities = []
+      mask.each { |t| possibilities << t if board.at_index(t) == piece }
+      possibilities
+    end
+
     # Computes the possible pawn origins based on the destination square
     # and whether or not the move is a capture.
     #
@@ -250,7 +276,7 @@ module PGN
       return possibilities unless move.disambiguation
 
       possibilities.select do |idx|
-        board.position_for([idx & 0x0F, idx >> 4]).match(move.disambiguation)
+        board.square_name(idx).match(move.disambiguation)
       end
     end
 
@@ -290,7 +316,7 @@ module PGN
     #
     def first_piece(idx, off)
       idx += off
-      while (idx & 0x88).zero? # rubocop:disable Style/BitwisePredicate
+      while board.on_board?(idx)
         square = board.at_index(idx)
         return idx if square
 
@@ -315,7 +341,7 @@ module PGN
       return nil if move.castle
       return nil unless move.capture && board.at_index(dest_idx).nil?
 
-      (origin_rank * 16) + (dest_idx & 0x0F)
+      board.index_for(dest_idx & 0x0F, origin_rank)
     end
 
     def king_position
@@ -323,7 +349,7 @@ module PGN
 
       0.upto(7) do |rank|
         0.upto(7) do |file|
-          idx = (rank * 16) + file
+          idx = board.index_for(file, rank)
           return idx if board.at_index(idx) == king
         end
       end