pgn3 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 20fb2f8fb76ff182d4a77f001b3bf55b8d6ba0abc452094bdfe896c754b62501
+  data.tar.gz: a898ca24052f81028014c24e49dd2b84d91e12096ab1d4783e71432d8b537d90
+SHA512:
+  metadata.gz: 84dbdb900720a5766209979bacf401279873028d35e89ec83c3e0457e0c6ec9325362dccb5cf6e7a7e923a1d1314565627fa4d1cc102b0fed400275973059a67
+  data.tar.gz: 5d74af5952a5ad2b4015a666fc24c4cb88e065c7320fc56e576e299dd33eb891ae2501c7b51061cb50f71269f831a17fa2dcaaf48ca8591efd48cee78ae62883

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+
+tags

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pgn.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Stacey Touset
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,123 @@
+# PGN2
+
+This is a fork from [pgn](https://github.com/capicue/pgn) gem.
+A PGN parser and FEN generator for ruby.
+
+## Usage
+
+### Creating games from pgn files
+
+On the command line, it is easy to read in and play through chess games
+in [portable game notation](http://en.wikipedia.org/wiki/Portable_Game_Notation) format.
+
+```
+> games = PGN.parse(File.read("./examples/immortal_game.pgn"))
+> game  = games.first
+> game.play
+```
+
+Play through the game using `a` or left arrow to move backward, and `d`
+or right arrow to move forward. `q` or `^C` quits play mode.
+
+    ♜ ♞ ♝ ♛ ♚ ♝ ♞ ♜
+    ♟ ♟ ♟ ♟ ♟ ♟ ♟ ♟
+    _ _ _ _ _ _ _ _
+    _ _ _ _ _ _ _ _
+    _ _ _ _ _ _ _ _
+    _ _ _ _ _ _ _ _
+    ♙ ♙ ♙ ♙ ♙ ♙ ♙ ♙
+    ♖ ♘ ♗ ♕ ♔ ♗ ♘ ♖
+
+    ♜ ♞ ♝ ♛ ♚ ♝ ♞ ♜
+    ♟ ♟ ♟ ♟ ♟ ♟ ♟ ♟
+    _ _ _ _ _ _ _ _
+    _ _ _ _ _ _ _ _
+    _ _ _ _ _ _ _ _
+    _ _ _ _ ♙ _ _ _
+    _ _ _ _ _ _ _ _
+    ♙ ♙ ♙ ♙ _ ♙ ♙ ♙
+    ♖ ♘ ♗ ♕ ♔ ♗ ♘ ♖
+
+    ...
+
+You can also access all of the information about a game.
+
+```
+> game.positions.last
+=>
+♜ _ ♝ ♚ _ _ _ ♜
+♟ _ _ ♟ ♗ ♟ ♘ ♟
+♞ _ _ _ _ ♞ _ _
+_ ♟ _ ♘ ♙ _ _ ♙
+_ _ _ _ _ _ ♙ _
+_ _ _ ♙ _ _ _ _
+♙ _ ♙ _ ♔ _ _ _
+♛ _ _ _ _ _ ♝ _
+
+> game.positions.last.to_fen
+=> r1bk3r/p2pBpNp/n4n2/1p1NP2P/6P1/3P4/P1P1K3/q5b1 b - - 1 22
+
+> game.result
+=> "1-0"
+
+> game.tags["White"]
+=> "Adolf Anderssen"
+```
+
+It is possible to create a game without parsing a pgn file.
+
+```
+moves = %w{e4 c5 c3 d5 exd5 Qxd5 d4 Nf6}
+game = PGN::Game.new(moves)
+```
+
+Note that if you simply want an abstract syntax tree from the pgn file,
+you can use `PGN::Parser.parse`.
+
+### Dealing with FEN strings
+
+[Forsyth Edwards Notation](http://en.wikipedia.org/wiki/Forsyth%E2%80%93Edwards_Notation)
+is a compact way to represent all of the information about a given chess
+position. It is easy to convert between FEN strings and chess positions.
+
+```
+> fen = PGN::FEN.start
+=> rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1
+
+> fen = PGN::FEN.new("r1bk3r/p2pBpNp/n4n2/1p1NP2P/6P1/3P4/P1P1K3/q5b1 b - - 1 22")
+> position = fen.to_position
+=>
+♜ _ ♝ ♚ _ _ _ ♜
+♟ _ _ ♟ ♗ ♟ ♘ ♟
+♞ _ _ _ _ ♞ _ _
+_ ♟ _ ♘ ♙ _ _ ♙
+_ _ _ _ _ _ ♙ _
+_ _ _ ♙ _ _ _ _
+♙ _ ♙ _ ♔ _ _ _
+♛ _ _ _ _ _ ♝ _
+
+> position.to_fen
+=> r1bk3r/p2pBpNp/n4n2/1p1NP2P/6P1/3P4/P1P1K3/q5b1 b - - 1 22
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'pgn2'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pgn2
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/TODO.md

@@ -0,0 +1,12 @@
+# TODOs
+
+## Parsing
+
+- Accept a more flexible input format
+- Support recursive variations
+- Support numeric annotation glyphs
+
+## Misc
+
+- Support converting a game to pgn format
+- Speed up parsing

data/examples/immortal_game.pgn

@@ -0,0 +1,17 @@
+[Event "London"]
+[Site "London"]
+[Date "1851.??.??"]
+[EventDate "?"]
+[Round "?"]
+[Result "1-0"]
+[White "Adolf Anderssen"]
+[Black "Kieseritzky"]
+[ECO "C33"]
+[WhiteElo "?"]
+[BlackElo "?"]
+[PlyCount "45"]
+
+1.e4 e5 2.f4 exf4 3.Bc4 Qh4+ 4.Kf1 b5 5.Bxb5 Nf6 6.Nf3 Qh6 7.d3 Nh5 8.Nh4 Qg5
+9.Nf5 c6 10.g4 Nf6 11.Rg1 cxb5 12.h4 Qg6 13.h5 Qg5 14.Qf3 Ng8 15.Bxf4 Qf6
+16.Nc3 Bc5 17.Nd5 Qxb2 18.Bd6 Bxg1 19. e5 Qxa1+ 20. Ke2 Na6 21.Nxg7+ Kd8
+22.Qf6+ Nxf6 23.Be7# 1-0

data/lib/pgn/board.rb

@@ -0,0 +1,163 @@
+module PGN
+  # {PGN::Board} represents the squares of a chess board and the pieces on
+  # each square. It is responsible for translating between a human readable
+  # format (white queen's rook on the bottom left) and the obvious
+  # internal representation (white queen's rook is position [0,0]). It
+  # takes care of converting square names (e4) to actual locations, and
+  # can convert to unicode chess pieces for display purposes.
+  #
+  # @!attribute squares
+  #   @return [Array<Array<String>>] the pieces on the board
+  #
+
+  class Board
+    # The starting, internal representation of a chess board
+    #
+    START = [
+      ['R', 'P', nil, nil, nil, nil, 'p', 'r'],
+      ['N', 'P', nil, nil, nil, nil, 'p', 'n'],
+      ['B', 'P', nil, nil, nil, nil, 'p', 'b'],
+      ['Q', 'P', nil, nil, nil, nil, 'p', 'q'],
+      ['K', 'P', nil, nil, nil, nil, 'p', 'k'],
+      ['B', 'P', nil, nil, nil, nil, 'p', 'b'],
+      ['N', 'P', nil, nil, nil, nil, 'p', 'n'],
+      ['R', 'P', nil, nil, nil, nil, 'p', 'r']
+    ].freeze
+
+    FILE_TO_INDEX = ('a'..'h').each_with_index.to_h
+    INDEX_TO_FILE = FILE_TO_INDEX.map(&:reverse).to_h
+
+    RANK_TO_INDEX = ('1'..'8').each_with_index.to_h
+    INDEX_TO_RANK = RANK_TO_INDEX.map(&:reverse).to_h
+
+    # algebraic to unicode piece lookup
+    #
+    UNICODE_PIECES = {
+      'k' => "\u{265A}",
+      'q' => "\u{265B}",
+      'r' => "\u{265C}",
+      'b' => "\u{265D}",
+      'n' => "\u{265E}",
+      'p' => "\u{265F}",
+      'K' => "\u{2654}",
+      'Q' => "\u{2655}",
+      'R' => "\u{2656}",
+      'B' => "\u{2657}",
+      'N' => "\u{2658}",
+      'P' => "\u{2659}",
+      nil => '_'
+    }.freeze
+
+    attr_accessor :squares
+
+    # @return [PGN::Board] a board in the starting position
+    #
+    def self.start
+      PGN::Board.new(START)
+    end
+
+    # @param squares [<Array<Array<String>>>] the squares of the board
+    # @example
+    #   PGN::Board.new(
+    #     [
+    #       ["R", "P", nil, nil, nil, nil, "p", "r"],
+    #       ["N", "P", nil, nil, nil, nil, "p", "n"],
+    #       ["B", "P", nil, nil, nil, nil, "p", "b"],
+    #       ["Q", "P", nil, nil, nil, nil, "p", "q"],
+    #       ["K", "P", nil, nil, nil, nil, "p", "k"],
+    #       ["B", "P", nil, nil, nil, nil, "p", "b"],
+    #       ["N", "P", nil, nil, nil, nil, "p", "n"],
+    #       ["R", "P", nil, nil, nil, nil, "p", "r"],
+    #     ]
+    #   )
+    #
+    def initialize(squares)
+      self.squares = squares
+    end
+
+    # @overload at(str)
+    #   Looks up a piece based on the string representation of a square (e4)
+    #   @param str [String] the square in algebraic notation
+    # @overload at(file, rank)
+    #   Looks up a piece based on zero-indexed coordinates (4, 3)
+    #   @param file [Integer] the file the piece is on
+    #   @param rank [Integer] the rank the piece is on
+    # @return [String, nil] the piece on the square, or nil if it is
+    #   empty
+    # @example
+    #   board.at(4,3)  #=> "P"
+    #   board.at("e4") #=> "P"
+    #
+    def at(*args)
+      case args.length
+      when 1
+        at(*coordinates_for(args.first))
+      when 2
+        squares[args[0]][args[1]]
+      end
+    end
+
+    # @param changes [Hash<String, <String, nil>>] changes to make to the board
+    # @return [self]
+    # @example
+    #   board.change!({"e2" => nil, "e4" => "P"})
+    #
+    def change!(changes)
+      changes.each do |square, piece|
+        update(square, piece)
+      end
+      self
+    end
+
+    # @param square [String] the square in algebraic notation
+    # @param piece [String, nil] the piece to put on the square
+    # @return [self]
+    # @example
+    #   board.update("e4", "P")
+    #
+    def update(square, piece)
+      coords = coordinates_for(square)
+      squares[coords[0]][coords[1]] = piece
+      self
+    end
+
+    # @param position [String] the square in algebraic notation
+    # @return [Array<Integer>] the coordinates of the square
+    # @example
+    #   board.coordinates_for("e4") #=> [4, 3]
+    #
+    def coordinates_for(position)
+      file_chr, rank_chr = position.chars.to_a
+      file = FILE_TO_INDEX[file_chr]
+      rank = RANK_TO_INDEX[rank_chr]
+      [file, rank]
+    end
+
+    # @param coordinates [Array<Integer>] the coordinates of the square
+    # @return [String] the square in algebraic notation
+    # @example
+    #   board.position_for([4, 3]) #=> "e4"
+    #
+    def position_for(coordinates)
+      file, rank = coordinates
+      file_chr = INDEX_TO_FILE[file]
+      rank_chr = INDEX_TO_RANK[rank]
+      [file_chr, rank_chr].join('')
+    end
+
+    # @return [String] the board in human readable format with unicode
+    #   pieces
+    #
+    def inspect
+      squares.transpose.reverse.map do |row|
+        row.map { |chr| UNICODE_PIECES[chr] }.join(' ')
+      end.join("\n")
+    end
+
+    # @return [PGN::Board] a copy of self with duplicated squares
+    #
+    def dup
+      PGN::Board.new(squares.map(&:dup))
+    end
+  end
+end

data/lib/pgn/fen.rb

@@ -0,0 +1,148 @@
+module PGN
+  # {PGN::FEN} is responsible for translating between strings in FEN
+  # notation and an internal representation of the board.
+  #
+  # @see http://en.wikipedia.org/wiki/Forsyth-Edwards_Notation
+  #   Forsyth-Edwards notation
+  #
+  # @!attribute board
+  #   @return [PGN::Board] a {PGN::Board} object for the current board
+  #     state
+  #
+  # @!attribute active
+  #   @return ['w', 't'] the current player
+  #
+  # @!attribute castling
+  #   @return [String] the castling availability
+  #   @example
+  #     "Kq" # white can castle kingside and black queenside
+  #   @example
+  #     "-"  # no one can castle
+  #
+  # @!attribute en_passant
+  #   @return [String] the current en passant square
+  #   @example
+  #     "e3" # white just moved e2 -> e4
+  #     "-"  # no current en passant square
+  #
+  # @!attribute halfmove
+  #   @return [String] the halfmove clock
+  #   @note This is the number of halfmoves since the last pawn advance or capture
+  #
+  # @!attribute fullmove
+  #   @return [String] the fullmove counter
+  #   @note The number of full moves. This is incremented after black
+  #     plays.
+  #
+  class FEN
+    # The FEN string representing the starting position in chess
+    #
+    INITIAL = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+
+    attr_accessor :board, :active, :castling, :en_passant, :halfmove, :fullmove
+
+    # @return [PGN::FEN] a {PGN::FEN} object representing the starting
+    #   position
+    #
+    def self.start
+      PGN::FEN.new(INITIAL)
+    end
+
+    # @return [PGN::FEN] a {PGN::FEN} object with the given attributes
+    #
+    def self.from_attributes(attrs)
+      fen = PGN::FEN.new
+      attrs.each do |key, val|
+        fen.send("#{key}=", val)
+      end
+      fen
+    end
+
+    # @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
+    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 {|row| row.split('') }
+                         .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
+      self.board
+          .squares
+          .transpose
+          .reverse
+          .map {|row| row.map {|e| e.nil? ? "_" : e } }
+          .map {|row| row.join }
+          .join("/")
+          .gsub(/_+/) {|match| match.length }
+    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
+
+      PGN::Position.new(
+        self.board,
+        player,
+        castling,
+        en_passant,
+        self.halfmove.to_i,
+        self.fullmove.to_i,
+      )
+    end
+
+    # @return [String] the FEN string
+    # @example
+    #   PGN::FEN.start.to_s #=> "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+    #
+    def to_s
+      [
+        self.board_string,
+        self.active,
+        self.castling,
+        self.en_passant,
+        self.halfmove,
+        self.fullmove,
+      ].join(" ")
+    end
+
+    def inspect
+      self.to_s
+    end
+  end
+end

data/lib/pgn/game.rb

@@ -0,0 +1,148 @@
+require 'io/console'
+
+module PGN
+  class MoveText
+    attr_accessor :notation, :annotation, :comment, :variations
+
+    def initialize(notation, annotation = nil, comment = nil, variations = [])
+      @notation = notation
+      @annotation = annotation
+      @comment = clean_text(comment)
+      @variations = variations
+    end
+
+    def ==(m)
+      to_s == m.to_s
+    end
+
+    def eql?(m)
+      self == m
+    end
+
+    def hash
+      @notation.hash
+    end
+
+    def to_s
+      @notation
+    end
+
+    def clean_text(text)
+      text&.gsub(/{(.*)}/, '\1')&.gsub(/\s+/, ' ')&.strip
+    end
+  end
+  # {PGN::Game} holds all of the information about a game. It is either
+  # the result of parsing a PGN file, or created by hand.
+  #
+  # A {PGN::Game} has an interactive {#play} method, and can also return
+  # a list of positions in {PGN::Position} format or FEN.
+  #
+  # @!attribute tags
+  #   @return [Hash<String, String>] metadata about the game
+  #   @example
+  #     game.tags #=> {"White" => "Kasparov", "Black" => "Deep Blue"}
+  #
+  # @!attribute moves
+  #   @return [Array<String>] a list of the moves in standard algebraic
+  #     notation
+  #   @example
+  #     game.moves #=> ["e4", "c5", "Nf3", "d6", "d4", "cxd4"]
+  #
+  # @!attribute result
+  #   @return [String] the outcome of the game
+  #   @example
+  #     game.result #=> "1-0"
+  #
+  class Game
+    attr_accessor :tags, :result, :pgn, :comment
+    attr_reader :moves
+
+    LEFT  = /(a|\x1B\[D)\z/.freeze
+    RIGHT = /(d|\x1B\[C)\z/.freeze
+    EXIT  = /(q|\x03)\z/.freeze
+
+    # @param moves [Array<String>] a list of moves in SAN
+    # @param tags [Hash<String, String>] metadata about the game
+    # @param result [String] the outcome of the game
+    #
+    def initialize(moves, tags = nil, result = nil, pgn = nil, comment = nil)
+      self.moves   = moves
+      self.tags    = tags
+      self.result  = result
+      self.pgn     = pgn
+      self.comment = comment
+    end
+
+    # @param moves [Array<String>] a list of moves in SAN
+    #
+    # Standardize castling moves to use O's instead of 0's
+    #
+    def moves=(moves)
+      @moves =
+        moves.map do |m|
+          if m.is_a? String
+            MoveText.new(m.gsub('0', 'O'))
+          else
+            MoveText.new(m.notation.gsub('0', 'O'), m.annotation, m.comment, m.variations)
+          end
+        end
+    end
+
+    def initial_fen
+      tags && tags['FEN']
+    end
+
+    def starting_position
+      @starting_position ||= if initial_fen
+                               PGN::FEN.new(initial_fen).to_position
+                             else
+                               PGN::Position.start
+                             end
+    end
+
+    # @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
+      end
+    end
+
+    # @return [Array<String>] list of the fen representations of the positions
+    #
+    def fen_list
+      positions.map { |p| p.to_fen.inspect }
+    end
+
+    # Interactively step through the game
+    #
+    # Use +d+ to move forward, +a+ to move backward, and +^C+ to exit.
+    #
+    def play
+      index = 0
+      hist = Array.new(3, '')
+
+      loop do
+        puts "\e[H\e[2J"
+        puts positions[index].inspect
+        hist[0..2] = (hist[1..2] << STDIN.getch)
+
+        case hist.join
+        when LEFT
+          index -= 1 if index > 0
+        when RIGHT
+          index += 1 if index < moves.length
+        when EXIT
+          break
+        end
+      end
+    end
+  end
+end