pgn3 0.0.0

data/lib/pgn/move.rb

@@ -0,0 +1,163 @@
+module PGN
+  # {PGN::Move} knows how to parse a move string in standard algebraic
+  # notation to extract all relevant information.
+  #
+  # @see http://en.wikipedia.org/wiki/Algebraic_notation_(chess) Standard
+  #   Algebraic Notation
+  #
+  # @!attribute san
+  #   @return [String] the move string
+  #   @example
+  #     move1.san #=> "O-O-O+"
+  #     move2.san #=> "Raxe1"
+  #     move3.san #=> "e8=Q#"
+  #
+  # @!attribute player
+  #   @return [Symbol] the current player
+  #   @example
+  #     move.player #=> :white
+  #
+  # @!attribute piece
+  #   @return [String, nil] the piece being moved
+  #   @example
+  #     move1.piece #=> "Q"
+  #     move2.piece #=> "r"
+  #   @note this is nil for castling
+  #   @note uppercase represents white, lowercase represents black
+  #
+  # @!attribute destination
+  #   @return [String, nil] the destination square of the piece
+  #   @example
+  #     move.destination #=> "e4"
+  #
+  # @!attribute promotion
+  #   @return [String, nil] the promotion piece, if applicable
+  #
+  # @!attribute check
+  #   @return [String, nil] whether the move results in check or mate
+  #   @example
+  #     move1.check #=> "+"
+  #     move2.check #=> "#"
+  #
+  # @!attribute capture
+  #   @return [String, nil] whether the move is a capture
+  #   @example
+  #     move.capture #=> "x"
+  #
+  # @!attribute disambiguation
+  #   @return [String, nil] the disambiguation string if there is one
+  #   @example
+  #     move.disambiguation #=> "3"
+  #
+  # @!attribute castle
+  #   @return [String, nil] the castle string if applicable
+  #   @example
+  #     move1.castle #=> "O-O-O"
+  #     move2.castle #=> "O-O"
+  #
+
+  class Move
+    attr_accessor :san, :player
+    attr_accessor :piece, :destination, :promotion, :check, :capture, :disambiguation, :castle
+    # A regular expression for matching moves in standard algebraic
+    # notation
+    #
+    SAN_REGEX = /
+      (?<piece>          [BKNQR]      ){0}
+      (?<destination>    [a-h][1-8]   ){0}
+      (?<promotion>      =[BNQR]      ){0}
+      (?<check>          [#+]         ){0}
+      (?<capture>        x            ){0}
+      (?<disambiguation> [a-h]?[1-8]? ){0}
+
+      (?<castle>         O-O(-O)?     ){0}
+
+      (?<normal>
+        \g<piece>?
+        \g<disambiguation>
+        \g<capture>?
+        \g<destination>
+        \g<promotion>?
+      ){0}
+
+      \A (\g<castle> | \g<normal>) \g<check>? \z
+    /x.freeze
+
+    # @param move [String] the move in SAN
+    # @param player [Symbol] the player making the move
+    # @example
+    #   PGN::Move.new("e4", :white)
+    #
+    def initialize(move, player)
+      self.player = player
+      self.san    = move
+
+      match = move.match(SAN_REGEX)
+      return  if match.nil?
+
+      match.names.each do |name|
+        send("#{name}=", match[name]) if respond_to?(name)
+      end
+    end
+
+    def piece=(val)
+      return if san.match('O-O')
+
+      val ||= 'P'
+      @piece = black? ? val.downcase : val
+    end
+
+    def promotion=(val)
+      if val
+        val.downcase! if black?
+        @promotion = val.delete('=')
+      end
+    end
+
+    def capture=(val)
+      @capture = !!val
+    end
+
+    def disambiguation=(val)
+      @disambiguation = (val == '' ? nil : val)
+    end
+
+    def castle=(val)
+      if val
+        @castle = 'K' if val == 'O-O'
+        @castle = 'Q' if val == 'O-O-O'
+        @castle.downcase! if black?
+      end
+    end
+
+    # @return [Boolean] whether the move results in check
+    #
+    def check?
+      check == '+'
+    end
+
+    # @return [Boolean] whether the move results in checkmate
+    #
+    def checkmate?
+      check == '#'
+    end
+
+    # @return [Boolean] whether it's white's turn
+    #
+    def white?
+      player == :white
+    end
+
+    # @return [Boolean] whether it's black's turn
+    #
+    def black?
+      player == :black
+    end
+
+    # @return [Boolean] whether the piece being moved is a pawn
+    #
+    def pawn?
+      %w[P p].include?(piece)
+    end
+  end
+end

data/lib/pgn/move_calculator.rb

@@ -0,0 +1,337 @@
+module PGN
+  # {PGN::MoveCalculator} is responsible for computing all of the ways that a
+  # specific move changes the current position. This includes which squares on
+  # the board need to be updated, new castling restrictions, the en passant
+  # square and whether to update fullmove and halfmove counters.
+  #
+  # @!attribute board
+  #   @return [PGN::Board] the current board
+  #
+  # @!attribute move
+  #   @return [PGN::Move] the current move
+  #
+  # @!attribute origin
+  #   @return [String, nil] the origin square in SAN
+  #
+  class MoveCalculator
+    # Specifies the movement of pieces who are allowed to move in a
+    # given direction until they reach an obstacle or the end of the
+    # board.
+    #
+    DIRECTIONS = {
+      'b' => [[1, 1], [-1,  1], [-1, -1], [1, -1]],
+      'r' => [[-1, 0], [1,  0], [0, -1], [0,  1]],
+      'q' => [[1,  1], [-1,  1], [-1, -1], [1, -1],
+              [-1, 0], [1,  0], [0, -1], [0, 1]]
+    }.freeze
+
+    # Specifies the movement of pieces that have a limited set of moves
+    # they are allowed to make.
+    #
+    MOVES = {
+      'k' => [[-1, -1], [0, -1], [1, -1], [1,  0],
+              [1,  1], [0,  1], [-1,  1], [-1, 0]],
+      'n' => [[-1, -2], [-1, 2], [1, -2], [1,  2],
+              [-2, -1], [2, -1], [-2, 1], [2,  1]]
+    }.freeze
+
+    # Specifies possible pawn movements. It may seem backwards since it is
+    # used to compute the origin square and not the destination.
+    #
+    PAWN_MOVES = {
+      'P' => {
+        capture: [[-1, -1], [1, -1]],
+        normal: [[0, -1]],
+        double: [[0, -2]]
+      },
+      'p' => {
+        capture: [[-1, 1], [1, 1]],
+        normal: [[0,  1]],
+        double: [[0,  2]]
+      }
+    }.freeze
+
+    # The squares to update for each possible castling move.
+    #
+    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
+
+    attr_accessor :board
+    attr_accessor :move
+    attr_accessor :origin
+
+    # @param board [PGN::Board] the current board
+    # @param move [PGN::Move] the current move
+    #
+    def initialize(board, move)
+      self.board = board
+      self.move  = move
+      self.origin = compute_origin
+    end
+
+    # @return [PGN::Board] the board after the move is made
+    #
+    def result_board
+      new_board = board.dup
+      new_board.change!(changes)
+
+      new_board
+    end
+
+    # @return [Array<String>] which castling moves are no longer available
+    #
+    def castling_restrictions
+      restrict = []
+
+      # when a king or rook is moved
+      case move.piece
+      when 'K'
+        restrict += %w[K Q]
+      when 'k'
+        restrict += %w[k q]
+      when 'R'
+        restrict << { 'a1' => 'Q', 'h1' => 'K' }[origin]
+      when 'r'
+        restrict << { 'a8' => 'q', 'h8' => 'k' }[origin]
+      end
+
+      # when castling occurs
+      restrict += %w[K Q] if %w[K Q].include? move.castle
+      restrict += %w[k q] if %w[k q].include? move.castle
+
+      # when a rook is taken
+      restrict << 'Q' if move.destination == 'a1'
+      restrict << 'q' if move.destination == 'a8'
+      restrict << 'K' if move.destination == 'h1'
+      restrict << 'k' if move.destination == 'h8'
+
+      restrict.compact.uniq
+    end
+
+    # @return [Boolean] whether to increment the halfmove clock
+    #
+    def increment_halfmove?
+      !(move.capture || move.pawn?)
+    end
+
+    # @return [Boolean] whether to increment the fullmove counter
+    #
+    def increment_fullmove?
+      move.black?
+    end
+
+    # @return [String, nil] the en passant square if applicable
+    #
+    def en_passant_square
+      return nil if move.castle
+
+      if move.pawn? && (origin[1].to_i - move.destination[1].to_i).abs == 2
+        if move.white?
+          origin[0] + '3'
+        else
+          origin[0] + '6'
+end
+      end
+    end
+
+    private
+
+    def changes
+      changes = {}
+      changes.merge!(CASTLING[move.castle]) if move.castle
+      changes.merge!(
+        origin => nil,
+        move.destination => move.piece,
+        en_passant_capture => nil
+      )
+      changes[move.destination] = move.promotion if move.promotion
+
+      changes.reject! { |key, _| key.nil? or key.empty? }
+
+      changes
+    end
+
+    # Using the current position and move, figure out where the piece
+    # came from.
+    #
+    def compute_origin
+      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
+                      else # don't care move, used in variations
+                        return nil
+                      end
+
+      possibilities = disambiguate(possibilities) if possibilities.length > 1
+
+      board.position_for(possibilities.first)
+    end
+
+    # From the destination square, move in each direction stopping if we
+    # reach the end of the board. If we encounter a piece, add it to the
+    # list of origin possibilities if it is the moving piece, or else
+    # check the next direction.
+    #
+    def direction_origins
+      directions    = DIRECTIONS[move.piece.downcase]
+      possibilities = []
+
+      directions.each do |dir|
+        piece, square = first_piece(destination_coords, dir)
+        possibilities << square if piece == move.piece
+      end
+
+      possibilities
+    end
+
+    # From the destination square, make each move. If it is a valid
+    # square and matches the moving piece, add it to the list of origin
+    # possibilities.
+    #
+    def move_origins(moves = nil)
+      moves         ||= MOVES[move.piece.downcase]
+      possibilities   = []
+      file, rank      = destination_coords
+
+      moves.each do |i, j|
+        f = file + i
+        r = rank + j
+
+        possibilities << [f, r] if valid_square?(f, r) && board.at(f, r) == move.piece
+      end
+
+      possibilities
+    end
+
+    # Computes the possbile pawn origins based on the destination square
+    # and whether or not the move is a capture.
+    #
+    def pawn_origins
+      _, rank     = destination_coords
+      double_rank = (rank == 3 && move.white?) || (rank == 4 && move.black?)
+
+      pawn_moves = PAWN_MOVES[move.piece]
+
+      moves = move.capture ? pawn_moves[:capture] : pawn_moves[:normal]
+      moves += pawn_moves[:double] if double_rank
+
+      move_origins(moves)
+    end
+
+    def disambiguate(possibilities)
+      possibilities = disambiguate_san(possibilities)
+      possibilities = disambiguate_pawns(possibilities)            if possibilities.length > 1
+      possibilities = disambiguate_discovered_check(possibilities) if possibilities.length > 1
+
+      possibilities
+    end
+
+    # Try to disambiguate based on the standard algebraic notation.
+    #
+    def disambiguate_san(possibilities)
+      if move.disambiguation
+        possibilities.select { |p| board.position_for(p).match(move.disambiguation) }
+      else
+        possibilities
+end
+    end
+
+    # A pawn can't move two spaces if there is a pawn in front of it.
+    #
+    def disambiguate_pawns(possibilities)
+      if move.piece.match(/p/i) && !move.capture
+        possibilities.reject { |p| board.position_for(p).match(/2|7/) }
+      else
+        possibilities
+end
+    end
+
+    # A piece can't move if it would result in a discovered check.
+    #
+    def disambiguate_discovered_check(possibilities)
+      DIRECTIONS.each do |attacking_piece, directions|
+        attacking_piece = attacking_piece.upcase if move.black?
+
+        directions.each do |dir|
+          piece, square = first_piece(king_position, dir)
+          next unless piece == move.piece && possibilities.include?(square)
+
+          piece, = first_piece(square, dir)
+          possibilities.reject! { |p| p == square } if piece == attacking_piece
+        end
+      end
+
+      possibilities
+    end
+
+    def first_piece(from, direction)
+      file, rank = from
+      i,    j    = direction
+
+      piece = nil
+
+      while valid_square?(file += i, rank += j)
+        break if piece = board.at(file, rank)
+      end
+
+      [piece, [file, rank]]
+    end
+
+    # If the move is a capture and there is no piece on the
+    # destination square, it must be an en passant capture.
+    #
+    def en_passant_capture
+      return nil if move.castle
+
+      move.destination[0] + origin[1] if !board.at(move.destination) && move.capture
+    end
+
+    def king_position
+      king = move.white? ? 'K' : 'k'
+
+      coords = nil
+      0.upto(7) do |file|
+        0.upto(7) do |rank|
+          coords = [file, rank] if board.at(file, rank) == king
+        end
+      end
+
+      coords
+    end
+
+    def valid_square?(file, rank)
+      (0..7) === file && (0..7) === rank
+    end
+
+    def destination_coords
+      board.coordinates_for(move.destination)
+    end
+  end
+end

data/lib/pgn/parser.rb

@@ -0,0 +1,208 @@
+require 'whittle'
+
+module PGN
+  # {PGN::Parser} uses the whittle gem to parse pgn files based on their
+  # context free grammar.
+  #
+  class Parser < Whittle::Parser
+    def lex(input)
+      line   = 1
+      offset = 0
+      ending = input.length
+      @@pgn ||= ''
+      @@game_comment ||= nil
+
+      until offset == ending
+        next_token(input, offset, line).tap do |token|
+          if !token.nil?
+            token[:offset] = offset
+            line, token[:line] = token[:line], line
+            yield token unless token[:discarded]
+            @@pgn += token[:value]
+            offset += token[:value].length
+          else
+            raise Whittle::UnconsumedInputError,
+                  "Unmatched input #{input[offset..-1].inspect} on line #{line}"
+            # offset += 1
+          end
+        end
+      end
+
+      yield ({ name: :$end, line: line, value: nil, offset: offset })
+    end
+
+    rule(wsp: /\s+/).skip!
+    rule(
+      pgn_comment: /\A% .*/x
+    ).skip!
+
+    rule('[')
+    rule(']')
+    rule('(')
+    rule(')')
+
+    start(:pgn_database)
+
+    rule(:pgn_database) do |r|
+      r[].as { [] }
+      r[:pgn_comment, :pgn_database].as { |_title, db| db }
+      r[:pgn_database, :pgn_game].as { |database, game| database << game }
+    end
+
+    rule(:pgn_game) do |r|
+      r[:tag_section, :movetext_section].as do |tags, moves|
+        old_pgn = @@pgn
+        @@pgn = ''
+        comment = @@game_comment
+        @@game_comment = nil
+        { tags: tags, result: moves.pop, moves: moves, pgn: old_pgn, comment: comment }
+      end
+    end
+
+    rule(:tag_section) do |r|
+      r[:tag_pair, :tag_section].as { |pair, section| section.merge(pair) }
+      r[:tag_pair]
+    end
+
+    rule(:tag_pair) do |r|
+      r['[', :tag_name, :tag_value, ']'].as { |_, a, b, _| { a => b } }
+    end
+
+    rule(:tag_value) do |r|
+      r[:string].as { |value| value[1...-1] }
+    end
+
+    rule(:movetext_section) do |r|
+      r[:element_sequence, :game_termination].as { |a, b| a << b }
+    end
+
+    rule(:element_sequence) do |r|
+      r[:element_sequence, :element].as do |sequence, element|
+        element.nil? ? sequence : sequence << element
+      end
+      r[].as { [] }
+    end
+
+    rule(:element) do |r|
+      r[:move_number_indication].as { nil }
+      r[:san_move_annotated]
+      r[:san_move_annotated, :variation_list].as do |move, variations|
+        move.variations = variations
+        move
+      end
+      r[:comment].as { |c| @@game_comment = c; nil }
+    end
+
+    rule(:san_move_annotated) do |r|
+      r[:san_move].as { |move| MoveText.new(move) }
+      r[:san_move, :comment].as do |move, comment|
+        MoveText.new(move, nil, comment)
+      end
+      r[:san_move, :annotation_list].as do |move, annotation|
+        MoveText.new(move, annotation)
+      end
+      r[:san_move, :annotation_list, :comment].as do |move, annotation, comment|
+        MoveText.new(move, annotation, comment)
+      end
+      r[:san_move, :comment, :annotation_list].as do |move, comment, annotation|
+        MoveText.new(move, annotation, comment)
+      end
+    end
+
+    rule(:annotation_list) do |r|
+      r[:annotation_list, :numeric_annotation_glyph].as do |sequence, element|
+        element.nil? ? sequence : sequence << element
+      end
+      r[:numeric_annotation_glyph].as { |v| [v] }
+    end
+
+    rule(:variation_list) do |r|
+      r[:variation, :variation_list].as do |variation, sequence|
+        sequence << variation
+      end
+      r[:variation].as { |v| [v] }
+    end
+
+    rule(:variation) do |r|
+      r['(', :element_sequence, ')'].as { |_, sequence, _| sequence }
+    end
+
+    rule(
+      string: /
+        "                          # beginning of string
+        (
+          [[:print:]&&[^\\"]] |    # printing characters except quote and backslash
+          \\\\                |    # escaped backslashes
+          \\"                      # escaped quotation marks
+        )*                         # zero or more of the above
+        "                          # end of string
+      /x
+    )
+
+    rule(
+      comment: /
+        (
+          \{                           # beginning of comment
+          (
+            [[:print:]&&[^\\\{\}]] |   # printing characters except brace and backslash
+            \n                     |
+            \\\\                   |   # escaped backslashes
+            \\\{|\\\}              |   # escaped braces
+            \n                     |   # newlines
+            \g<1>                      # recursive
+          )*                           # zero or more of the above
+          \}                           # end of comment
+        )
+      /x
+    )
+
+    rule(
+      game_termination: %r{
+        1-0       |    # white wins
+        0-1       |    # black wins
+        1\/2-1\/2 |    # draw
+        \*             # ?
+      }x
+    )
+
+    rule(
+      move_number_indication: /
+        [[:digit:]]+\.*    # one or more digits followed by zero or more periods
+      /x
+    )
+
+    rule(
+      san_move: %r{
+        (
+          --                           |    # "don't care" move (used in variations)
+          [O0](-[O0]){1,2}             |    # castling (O-O, O-O-O)
+          [a-h][1-8]                   |    # pawn moves (e4, d7)
+          [BKNQR][a-h1-8]?x?[a-h][1-8] |    # major piece moves w/ optional specifier
+                                            # and capture
+                                            # (Bd2, N4c3, Raxc1)
+          [a-h][1-8]?x[a-h][1-8]            # pawn captures
+        )
+        (
+          =[BNQR]                            # optional promotion (d8=Q)
+        )?
+        (
+          \+                            |    # check (g5+)
+          \#                                 # checkmate (Qe7#)
+        )?
+      }x
+    )
+
+    rule(
+      tag_name: /
+        [A-Za-z0-9_]+    # letters, digits and underscores only
+      /x
+    )
+
+    rule(
+      numeric_annotation_glyph: /
+        \$\d+       | # dollar sign followed by an integer from 0 to 255
+        [\?!][\?!]?   # support the most used annotations directly
+      /x
+    )
+  end
+end