pgn2 1.2.1 → 1.4.0

data/lib/pgn/notation.rb

@@ -0,0 +1,474 @@
+# frozen_string_literal: true
+
+module PGN
+  # {PGN::Notation} generates Standard Algebraic Notation (SAN) for a single
+  # move described in coordinate form -- an origin square, a destination
+  # square, and an optional promotion piece -- given the {PGN::Position}
+  # *before* the move is played.
+  #
+  # Unlike {PGN::Move}, which *parses* an existing SAN string, {PGN::Notation}
+  # *builds* SAN from coordinates. This requires the kind of legality analysis
+  # the rest of the gem does not perform: attack detection, "does this move
+  # leave the mover's king in check", disambiguation among same-type pieces
+  # that can legally reach the destination, and check (+) / checkmate (#)
+  # suffix detection (the latter needing full legal-move generation for the
+  # side to move).
+  #
+  # The board is addressed with the same 0x88 integer indices the rest of the
+  # gem uses (see {PGN::Board}); an index is on-board when
+  # `(idx & 0x88).zero?`.
+  #
+  # @example
+  #   PGN::Notation.san(PGN::Position.start, 'g1', 'f3') #=> "Nf3"
+  #   PGN::Notation.san_from_fen(PGN::FEN::INITIAL, 'e2', 'e4') #=> "e4"
+  #
+  class Notation
+    # 0x88 single-step offsets for a knight (symmetric, so they double as
+    # attack deltas).
+    KNIGHT_OFFS = [33, 31, -31, -33, 18, 14, -14, -18].freeze
+    # 0x88 single-step offsets for a king (symmetric).
+    KING_OFFS = [-1, 1, -16, 16, -15, 15, -17, 17].freeze
+    BISHOP_DIRS = [-15, 15, -17, 17].freeze
+    ROOK_DIRS = [-1, 1, -16, 16].freeze
+
+    # Build SAN for a coordinate move from a {PGN::Position}.
+    #
+    # @param position [PGN::Position] the position *before* the move
+    # @param from [String] origin square in algebraic notation ("e2")
+    # @param to [String] destination square in algebraic notation ("e4")
+    # @param promotion [String, nil] promotion piece letter ("q"/"Q"/"n"...);
+    #   case-insensitive; SAN always emits an uppercase letter
+    # @return [String] the move in SAN, e.g. "Nf3", "exd5", "O-O", "Ra8#"
+    #
+    def self.san(position, from, to, promotion = nil)
+      new(position).san(from, to, promotion)
+    end
+
+    # Convenience: build SAN directly from a FEN string.
+    #
+    # @param fen [String] the FEN of the position *before* the move
+    # @param (see .san)
+    # @return [String] the move in SAN
+    #
+    def self.san_from_fen(fen, from, to, promotion = nil)
+      san(PGN::FEN.new(fen).to_position, from, to, promotion)
+    end
+
+    def initialize(position)
+      @position = position
+      @board = position.board
+      @player = position.player
+      @mover = (@player == :white ? 'w' : 'b')
+      @enemy = (@player == :white ? 'b' : 'w')
+    end
+
+    # @param (see .san)
+    # @return [String]
+    def san(from, to, promotion = nil)
+      from_idx = @board.index_of(from)
+      to_idx = @board.index_of(to)
+      piece = @board.at_index(from_idx)
+      raise ArgumentError, "no piece on #{from}" if piece.nil?
+
+      promotion = promotion.upcase if promotion
+
+      castling = piece.upcase == 'K' && ((from_idx & 0x0F) - (to_idx & 0x0F)).abs == 2
+      capture = castling ? false : capture?(piece, from_idx, to_idx)
+
+      body =
+        if castling
+          to_idx < from_idx ? 'O-O-O' : 'O-O'
+        elsif piece.upcase == 'P'
+          pawn_body(from_idx, to_idx, capture, promotion)
+        else
+          piece_body(piece, from_idx, to_idx, capture)
+        end
+
+      body + suffix(from_idx, to_idx, piece, promotion, castling)
+    end
+
+    private
+
+    # -- body construction -------------------------------------------------
+
+    def pawn_body(from_idx, to_idx, capture, promotion)
+      dest = @board.position_for([to_idx & 0x0F, to_idx >> 4])
+      promo = promotion ? "=#{promotion}" : ''
+      if capture
+        "#{Board::INDEX_TO_FILE[from_idx & 0x0F]}x#{dest}#{promo}"
+      else
+        "#{dest}#{promo}"
+      end
+    end
+
+    def piece_body(piece, from_idx, to_idx, capture)
+      disamb = disambiguation(piece, from_idx, to_idx)
+      dest = @board.position_for([to_idx & 0x0F, to_idx >> 4])
+      parts = [piece.upcase, disamb]
+      parts << 'x' if capture
+      parts << dest
+      parts.join
+    end
+
+    # Disambiguate a non-pawn, non-castling move among same-type pieces that
+    # can *legally* reach the destination. Returns '' when none can.
+    def disambiguation(piece, from_idx, to_idx)
+      others = same_type_legals(piece, from_idx, to_idx)
+      return '' if others.empty?
+
+      from_file = from_idx & 0x0F
+      from_rank = from_idx >> 4
+      file_clash = others.any? { |o| (o & 0x0F) == from_file }
+      rank_clash = others.any? { |o| (o >> 4) == from_rank }
+
+      if !file_clash
+        Board::INDEX_TO_FILE[from_file]
+      elsif !rank_clash
+        Board::INDEX_TO_RANK[from_rank]
+      else
+        Board::INDEX_TO_FILE[from_file] + Board::INDEX_TO_RANK[from_rank]
+      end
+    end
+
+    # Other squares holding `piece` whose move to `to_idx` is legal.
+    def same_type_legals(piece, from_idx, to_idx)
+      (0...128).each_with_object([]) do |idx, acc|
+        next if (idx & 0x88) != 0
+        next if idx == from_idx
+        next unless @board.at_index(idx) == piece
+
+        acc << idx if reaches?(piece, idx, to_idx) && legal_after?(idx, to_idx, piece)
+      end
+    end
+
+    # -- check / checkmate suffix -----------------------------------------
+
+    def suffix(from_idx, to_idx, piece, promotion, castling)
+      nb = apply_move(from_idx, to_idx, piece, promotion, castling)
+      opp_king = king_idx(nb, @enemy)
+      return '' unless opp_king && attacked?(nb, opp_king, @mover)
+
+      result_pos = PGN::Position.new(
+        nb,
+        @player == :white ? :black : :white,
+        [],
+        new_ep_square(piece, from_idx, to_idx),
+        0,
+        @position.fullmove
+      )
+      any_legal_move?(result_pos) ? '+' : '#'
+    end
+
+    # -- move application -------------------------------------------------
+
+    def apply_move(from_idx, to_idx, piece, promotion, castling)
+      nb = @board.dup
+      return castle!(nb, from_idx, to_idx, piece) if castling
+
+      ep = ep_capture_square(piece, from_idx, to_idx)
+      nb.update_index(ep, nil) if ep
+      nb.update_index(from_idx, nil)
+      nb.update_index(to_idx, promotion ? promoted(promotion) : piece)
+      nb
+    end
+
+    def castle!(board, from_idx, to_idx, piece)
+      rank = from_idx >> 4
+      rook = piece.upcase == 'K' ? 'R' : 'r'
+      board.update_index(from_idx, nil)
+      board.update_index(to_idx, piece)
+      if to_idx < from_idx # queenside
+        board.update_index(rank * 16, nil)
+        board.update_index((rank * 16) + 3, rook)
+      else # kingside
+        board.update_index((rank * 16) + 7, nil)
+        board.update_index((rank * 16) + 5, rook)
+      end
+      board
+    end
+
+    def promoted(promotion)
+      @player == :white ? promotion.upcase : promotion.downcase
+    end
+
+    # En-passant captured-pawn square (or nil): a pawn moving diagonally to
+    # an empty destination must be capturing en passant.
+    def ep_capture_square(piece, from_idx, to_idx)
+      return nil unless piece.upcase == 'P'
+      return nil if (from_idx & 0x0F) == (to_idx & 0x0F)
+
+      @board.at_index(to_idx).nil? ? ((from_idx >> 4) * 16) + (to_idx & 0x0F) : nil
+    end
+
+    # The en-passant target square left behind by a double pawn push, for the
+    # resulting position (so an escaping ep capture is considered for mate).
+    def new_ep_square(piece, from_idx, to_idx)
+      return nil unless piece.upcase == 'P'
+      return nil if ((from_idx >> 4) - (to_idx >> 4)).abs != 2
+
+      mid = ((from_idx >> 4) + (to_idx >> 4)) / 2
+      Board::INDEX_TO_FILE[from_idx & 0x0F] + Board::INDEX_TO_RANK[mid]
+    end
+
+    # -- legality ---------------------------------------------------------
+
+    # Is `piece` from `from_idx` to `to_idx` legal (own king safe after)?
+    def legal_after?(from_idx, to_idx, piece)
+      nb = @board.dup
+      ep = ep_capture_square(piece, from_idx, to_idx)
+      nb.update_index(ep, nil) if ep
+      nb.update_index(from_idx, nil)
+      nb.update_index(to_idx, piece)
+      king = king_idx(nb, @mover)
+      king && !attacked?(nb, king, @enemy)
+    end
+
+    # Does `piece` at `from_idx` pseudo-legally reach `to_idx` on the board?
+    # (Sliders honor blockers; the destination may be empty or enemy-occupied.)
+    def reaches?(piece, from_idx, to_idx)
+      return false if from_idx == to_idx
+
+      case piece.upcase
+      when 'N'
+        KNIGHT_OFFS.any? { |o| (from_idx + o) == to_idx }
+      when 'K'
+        KING_OFFS.any? { |o| (from_idx + o) == to_idx }
+      when 'B', 'R', 'Q'
+        slider_reaches?(piece.upcase, from_idx, to_idx)
+      else
+        false
+      end
+    end
+
+    def slider_reaches?(piece_up, from_idx, to_idx)
+      slider_dirs(piece_up).any? do |off|
+        i = from_idx + off
+        while (i & 0x88).zero?
+          return true if i == to_idx
+          break if @board.at_index(i)
+
+          i += off
+        end
+        false
+      end
+    end
+
+    # Capture detection for the *played* move (used in the SAN body).
+    def capture?(piece, from_idx, to_idx)
+      if piece.upcase == 'P'
+        (from_idx & 0x0F) != (to_idx & 0x0F) # any diagonal pawn move captures
+      else
+        target = @board.at_index(to_idx)
+        target && !own?(target, @mover)
+      end
+    end
+
+    def own?(piece, color)
+      color == 'w' ? piece == piece.upcase : piece == piece.downcase
+    end
+
+    # Slider ray directions for a piece letter ('B'/'R'/'Q').
+    def slider_dirs(piece_up)
+      case piece_up
+      when 'B' then BISHOP_DIRS
+      when 'R' then ROOK_DIRS
+      else BISHOP_DIRS + ROOK_DIRS
+      end
+    end
+
+    # -- attack / legality helpers ----------------------------------------
+
+    def king_idx(board, color)
+      king = color == 'w' ? 'K' : 'k'
+      (0...128).each do |idx|
+        next if (idx & 0x88) != 0
+
+        return idx if board.at_index(idx) == king
+      end
+      nil
+    end
+
+    # Is `target` attacked by `color`-colored pieces on `board`?
+    def attacked?(board, target, color)
+      pawn_attacked?(board, target, color) ||
+        knight_attacked?(board, target, color) ||
+        king_attacked?(board, target, color) ||
+        slider_attacked?(board, target, color)
+    end
+
+    def pawn_attacked?(board, target, color)
+      offs = color == 'w' ? [-15, -17] : [15, 17]
+      pawn = color == 'w' ? 'P' : 'p'
+      offs.any? do |off|
+        i = target + off
+        (i & 0x88).zero? && board.at_index(i) == pawn
+      end
+    end
+
+    def knight_attacked?(board, target, color)
+      knight = color == 'w' ? 'N' : 'n'
+      KNIGHT_OFFS.any? do |off|
+        i = target + off
+        (i & 0x88).zero? && board.at_index(i) == knight
+      end
+    end
+
+    def king_attacked?(board, target, color)
+      king = color == 'w' ? 'K' : 'k'
+      KING_OFFS.any? do |off|
+        i = target + off
+        (i & 0x88).zero? && board.at_index(i) == king
+      end
+    end
+
+    def slider_attacked?(board, target, color)
+      bishop = color == 'w' ? 'B' : 'b'
+      rook = color == 'w' ? 'R' : 'r'
+      queen = color == 'w' ? 'Q' : 'q'
+      ray_hit?(board, target, BISHOP_DIRS) { |p| p == bishop || p == queen } ||
+        ray_hit?(board, target, ROOK_DIRS) { |p| p == rook || p == queen }
+    end
+
+    def ray_hit?(board, target, dirs)
+      dirs.each do |off|
+        i = target + off
+        while (i & 0x88).zero?
+          piece = board.at_index(i)
+          if piece
+            return true if yield(piece)
+            break
+          end
+          i += off
+        end
+      end
+      false
+    end
+
+    # -- legal-move generation (for checkmate detection) ------------------
+
+    def any_legal_move?(position)
+      board = position.board
+      color = position.player == :white ? 'w' : 'b'
+      ep_idx = ep_target_idx(position, board)
+
+      (0...128).any? do |idx|
+        next if (idx & 0x88) != 0
+
+        piece = board.at_index(idx)
+        piece && own?(piece, color) && move_from?(board, idx, piece, color, ep_idx)
+      end
+    end
+
+    def ep_target_idx(position, board)
+      ep = position.en_passant
+      return nil if ep.nil? || ep == '-' || ep.empty?
+
+      board.index_of(ep)
+    end
+
+    # Yields true if `piece` at `idx` has any legal move (escapes check).
+    def move_from?(board, idx, piece, color, ep_idx)
+      up = piece.upcase
+      case up
+      when 'N' then leaper_moves?(board, idx, piece, color, KNIGHT_OFFS)
+      when 'K' then leaper_moves?(board, idx, piece, color, KING_OFFS)
+      when 'B', 'R', 'Q'
+        slider_moves?(board, idx, piece, color, slider_dirs(up))
+      when 'P'
+        pawn_moves?(board, idx, piece, color, ep_idx)
+      else
+        false
+      end
+    end
+
+    def leaper_moves?(board, idx, piece, color, offs)
+      offs.any? do |off|
+        t = idx + off
+        (t & 0x88).zero? && landable?(board, t, color) && safe?(board, idx, t, piece, nil)
+      end
+    end
+
+    def slider_moves?(board, idx, piece, color, dirs)
+      dirs.any? do |off|
+        t = idx + off
+        while (t & 0x88).zero?
+          tp = board.at_index(t)
+          if tp.nil?
+            return true if safe?(board, idx, t, piece, nil)
+          else
+            return true if !own?(tp, color) && safe?(board, idx, t, piece, nil)
+            break
+          end
+          t += off
+        end
+        false
+      end
+    end
+
+    def pawn_moves?(board, idx, piece, color, ep_idx)
+      pawn_pushes?(board, idx, piece, color) ||
+        pawn_captures?(board, idx, piece, color, ep_idx)
+    end
+
+    def pawn_pushes?(board, idx, piece, color)
+      dir = color == 'w' ? 16 : -16
+      start_rank = color == 'w' ? 1 : 6
+      promo_rank = color == 'w' ? 7 : 0
+
+      t = idx + dir
+      return false unless (t & 0x88).zero? && board.at_index(t).nil?
+
+      promo = (t >> 4 == promo_rank) ? 'Q' : nil
+      return true if safe?(board, idx, t, piece, promo)
+
+      t2 = idx + (dir * 2)
+      (idx >> 4) == start_rank && board.at_index(t2).nil? && safe?(board, idx, t2, piece, nil)
+    end
+
+    def pawn_captures?(board, idx, piece, color, ep_idx) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      promo_rank = color == 'w' ? 7 : 0
+      caps = color == 'w' ? [15, 17] : [-15, -17]
+      caps.any? do |off|
+        t = idx + off
+        next false unless (t & 0x88).zero?
+
+        tp = board.at_index(t)
+        promo = (t >> 4 == promo_rank) ? 'Q' : nil
+        if tp && !own?(tp, color)
+          safe?(board, idx, t, piece, promo)
+        elsif tp.nil? && t == ep_idx
+          safe?(board, idx, t, piece, nil)
+        else
+          false
+        end
+      end
+    end
+
+    def landable?(board, target, color)
+      tp = board.at_index(target)
+      tp.nil? || !own?(tp, color)
+    end
+
+    # Apply a pseudo-move (with ep + promotion) on a copy and test own-king
+    # safety. The moving side is derived from `piece`'s case.
+    def safe?(board, from_idx, to_idx, piece, promotion)
+      nb = board.dup
+      if piece.upcase == 'P' && (from_idx & 0x0F) != (to_idx & 0x0F) && board.at_index(to_idx).nil?
+        nb.update_index(((from_idx >> 4) * 16) + (to_idx & 0x0F), nil) # ep capture
+      end
+      nb.update_index(from_idx, nil)
+      nb.update_index(to_idx, place_piece(piece, promotion))
+      color = own?(piece, 'w') ? 'w' : 'b'
+      king = king_idx(nb, color)
+      king && !attacked?(nb, king, color == 'w' ? 'b' : 'w')
+    end
+
+    # The piece letter to place on the destination after a pseudo-move.
+    def place_piece(piece, promotion)
+      return piece unless promotion
+
+      white = piece == piece.upcase
+      white ? promotion.upcase : promotion.downcase
+    end
+  end
+end

data/lib/pgn/pgn_parser.rb

@@ -21,8 +21,10 @@ module_eval(<<'...end pgn_parser.y/module_eval...', 'pgn_parser.y', 97)
   def next_token
     pair = @lexer.next_token_pair
     return [false, false] unless pair
-    type, value = pair
-    [translate_type(type), value]
+    # Mutate the lexer's [type, value] pair in place rather than allocating
+    # a second translated pair -- one array per token is the Racc floor.
+    pair[0] = translate_type(pair[0])
+    pair
   end
 
   private

data/lib/pgn/pgn_parser.y

@@ -106,8 +106,10 @@ rule
   def next_token
     pair = @lexer.next_token_pair
     return [false, false] unless pair
-    type, value = pair
-    [translate_type(type), value]
+    # Mutate the lexer's [type, value] pair in place rather than allocating
+    # a second translated pair -- one array per token is the Racc floor.
+    pair[0] = translate_type(pair[0])
+    pair
   end
 
   private

data/lib/pgn/version.rb

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

data/lib/pgn.rb

@@ -4,6 +4,7 @@ require 'pgn/game'
 require 'pgn/move'
 require 'pgn/move_calculator'
 require 'pgn/lexer'
+require 'pgn/notation'
 require 'pgn/pgn_parser'
 require 'pgn/parser'
 require 'pgn/position'

data/spec/notation_spec.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# Helper: build a Position from a FEN string.
+def pos(fen)
+  PGN::FEN.new(fen).to_position
+end
+
+describe PGN::Notation do
+  # ------------------------------------------------------------------
+  # Public API
+  # ------------------------------------------------------------------
+  describe '.san' do
+    it 'generates a plain pawn push from coordinates' do
+      expect(PGN::Notation.san(pos('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1'),
+                               'e2', 'e4')).to eq('e4')
+    end
+
+    it 'generates a knight move with the piece letter' do
+      expect(PGN::Notation.san(pos('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1'),
+                               'g1', 'f3')).to eq('Nf3')
+    end
+
+    it 'generates a pawn capture with the origin file' do
+      fen = 'rnbqkbnr/ppp1pppp/8/3p4/4P3/8/PPPP1PPP/RNBQKBNR w KQkq d6 0 2'
+      expect(PGN::Notation.san(pos(fen), 'e4', 'd5')).to eq('exd5')
+    end
+
+    it 'generates an en passant capture' do
+      fen = 'rnbqkbnr/ppp1pppp/8/3pP3/8/8/PPPP1PPP/RNBQKBNR w KQkq d6 0 3'
+      expect(PGN::Notation.san(pos(fen), 'e5', 'd6')).to eq('exd6')
+    end
+
+    it 'generates a pawn promotion' do
+      fen = '8/P7/6k1/8/8/8/8/4K3 w - - 0 1'
+      expect(PGN::Notation.san(pos(fen), 'a7', 'a8', 'q')).to eq('a8=Q')
+    end
+
+    it 'generates a capture promotion' do
+      fen = '1n6/P7/6k1/8/8/8/8/4K3 w - - 0 1'
+      expect(PGN::Notation.san(pos(fen), 'a7', 'b8', 'q')).to eq('axb8=Q')
+    end
+
+    it 'generates kingside castling' do
+      fen = 'r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1'
+      expect(PGN::Notation.san(pos(fen), 'e1', 'g1')).to eq('O-O')
+    end
+
+    it 'generates queenside castling' do
+      fen = 'r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 0 1'
+      expect(PGN::Notation.san(pos(fen), 'e1', 'c1')).to eq('O-O-O')
+    end
+
+    it 'generates kingside castling for black' do
+      fen = 'r3k2r/8/8/8/8/8/8/R3K2R b KQkq - 0 1'
+      expect(PGN::Notation.san(pos(fen), 'e8', 'g8')).to eq('O-O')
+    end
+  end
+
+  describe '.san disambiguation' do
+    it 'disambiguates knights by file' do
+      # Knights on c3 and d4 both reach b5.
+      fen = 'r1bqkb1r/pp1p1ppp/2n1pn2/8/3NP3/2N5/PPP2PPP/R1BQKB1R w KQkq - 3 6'
+      expect(PGN::Notation.san(pos(fen), 'd4', 'b5')).to eq('Ndb5')
+      expect(PGN::Notation.san(pos(fen), 'c3', 'b5')).to eq('Ncb5')
+    end
+
+    it 'disambiguates rooks by rank when on the same file' do
+      # White rooks on a1 and a8 both reach a4 (file a clear).
+      fen = 'R7/8/8/4k3/8/8/8/R3K3 w - - 0 1'
+      expect(PGN::Notation.san(pos(fen), 'a1', 'a4')).to eq('R1a4')
+      expect(PGN::Notation.san(pos(fen), 'a8', 'a4')).to eq('R8a4')
+    end
+
+    it 'disambiguates queens by full square when file and rank both clash' do
+      # Queens on c1, f1, f4 all reach c4. The f1 queen shares file f with
+      # f4 and rank 1 with c1, so only the full square disambiguates.
+      fen = '7k/8/8/8/5Q2/8/8/2Q2Q1K w - - 0 1'
+      expect(PGN::Notation.san(pos(fen), 'f1', 'c4')).to eq('Qf1c4')
+    end
+
+    it 'omits disambiguation when only one piece can legally move there' do
+      # Two knights both pseudo-reach d2, but the e4 knight is pinned
+      # on the e-file (moving it exposes the king on e1 to the rook on e8),
+      # so only the b1 knight can legally play Nd2 — no disambiguation.
+      fen = '4r2k/8/8/8/4N3/8/8/1N2K3 w - - 0 1'
+      expect(PGN::Notation.san(pos(fen), 'b1', 'd2')).to eq('Nd2')
+    end
+  end
+
+  describe '.san check and checkmate suffixes' do
+    it 'appends + for a checking move' do
+      fen = '7k/8/8/8/8/8/6R1/6K1 w - - 0 1'
+      expect(PGN::Notation.san(pos(fen), 'g2', 'g8')).to eq('Rg8+')
+    end
+
+    it 'appends # for a checkmating move' do
+      fen = '6k1/5ppp/8/8/8/8/8/R6K w - - 0 1'
+      expect(PGN::Notation.san(pos(fen), 'a1', 'a8')).to eq('Ra8#')
+    end
+
+    it 'appends # to a promotion that gives checkmate' do
+      # White pawn b7 promotes with check on a king cornered on h8.
+      fen = '7k/1P6/8/8/8/8/8/6K1 w - - 0 1'
+      expect(PGN::Notation.san(pos(fen), 'b7', 'b8', 'q')).to eq('b8=Q+')
+    end
+
+    it 'does not append a suffix for a quiet move' do
+      fen = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1'
+      expect(PGN::Notation.san(pos(fen), 'd2', 'd4')).to eq('d4')
+    end
+  end
+
+  describe '.san_from_fen' do
+    it 'computes SAN directly from a FEN string' do
+      expect(PGN::Notation.san_from_fen('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1',
+                                        'e2', 'e4')).to eq('e4')
+    end
+
+    it 'computes SAN for black to move' do
+      fen = 'rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1'
+      expect(PGN::Notation.san_from_fen(fen, 'd7', 'd5')).to eq('d5')
+    end
+  end
+end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pgn2
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Stacey Touset
 - Murilo Vasconcelos
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -168,6 +167,7 @@ files:
 - lib/pgn/lexer.rb
 - lib/pgn/move.rb
 - lib/pgn/move_calculator.rb
+- lib/pgn/notation.rb
 - lib/pgn/parser.rb
 - lib/pgn/pgn_parser.rb
 - lib/pgn/pgn_parser.y
@@ -181,6 +181,7 @@ files:
 - spec/lexer_spec.rb
 - spec/move_calculator_spec.rb
 - spec/move_spec.rb
+- spec/notation_spec.rb
 - spec/parser_explicit_spec.rb
 - spec/parser_spec.rb
 - spec/pgn_files/alternate_castling.pgn
@@ -208,7 +209,6 @@ metadata:
   source_code_uri: https://github.com/muriloime/pgn
   bug_tracker_uri: https://github.com/muriloime/pgn/issues
   changelog_uri: https://github.com/muriloime/pgn/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -223,8 +223,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.10
 specification_version: 4
 summary: A PGN parser for Ruby
 test_files:
@@ -234,6 +233,7 @@ test_files:
 - spec/lexer_spec.rb
 - spec/move_calculator_spec.rb
 - spec/move_spec.rb
+- spec/notation_spec.rb
 - spec/parser_explicit_spec.rb
 - spec/parser_spec.rb
 - spec/pgn_files/alternate_castling.pgn