pgn 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b151e9dfbad65addcdbcc73985f280a1b7b42a55
+  data.tar.gz: 1aecd46315e114eec514ff627c442dd559bf5237
+SHA512:
+  metadata.gz: 4bb8e0a0e1ca54fb4fb4644e96a68ef3162a16c3dfc6e602993fe6e195dd1fcbe9b31e42239a61f608ca15698ff126a51ea5f0f202433e83aa52e2b5cd92e8d5
+  data.tar.gz: 6f070630bebabc25cd9261819cd2beb0d3d7a0309dcba56244f6712fcd339fab0db154c1ae785b3d33ca1e3f1888576d0b4143d7ddd8d1fe52f7941dd585ee84

data/.gitignore

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

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,122 @@
+# PGN
+
+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` to move backward and `d` to move
+forward. `^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 'pgn'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pgn
+
+## 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,4 @@
+# TODOs
+
+- `Game#to_pgn`
+- 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.rb

@@ -0,0 +1,22 @@
+require "pgn/board"
+require "pgn/fen"
+require "pgn/game"
+require "pgn/move"
+require "pgn/move_calculator"
+require "pgn/parser"
+require "pgn/position"
+require "pgn/version"
+
+module PGN
+
+  # @param pgn [String] a pgn representation of one or more chess games
+  # @return [Array<PGN::Game>] a list of games
+  #
+  def self.parse(pgn)
+    pgn.force_encoding(Encoding::ISO_8859_1)
+
+    PGN::Parser.new.parse(pgn).map do |game|
+      PGN::Game.new(game[:moves], game[:tags], game[:result])
+    end
+  end
+end

data/lib/pgn/board.rb

@@ -0,0 +1,183 @@
+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", "_", "_", "_", "_", "p", "r"],
+      ["N", "P", "_", "_", "_", "_", "p", "n"],
+      ["B", "P", "_", "_", "_", "_", "p", "b"],
+      ["Q", "P", "_", "_", "_", "_", "p", "q"],
+      ["K", "P", "_", "_", "_", "_", "p", "k"],
+      ["B", "P", "_", "_", "_", "_", "p", "b"],
+      ["N", "P", "_", "_", "_", "_", "p", "n"],
+      ["R", "P", "_", "_", "_", "_", "p", "r"],
+    ]
+
+    FILE_TO_INDEX = {
+      'a' => 0,
+      'b' => 1,
+      'c' => 2,
+      'd' => 3,
+      'e' => 4,
+      'f' => 5,
+      'g' => 6,
+      'h' => 7,
+    }
+    INDEX_TO_FILE = Hash[FILE_TO_INDEX.map(&:reverse)]
+
+    RANK_TO_INDEX = {
+      '1' => 0,
+      '2' => 1,
+      '3' => 2,
+      '4' => 3,
+      '5' => 4,
+      '6' => 5,
+      '7' => 6,
+      '8' => 7,
+    }
+    INDEX_TO_RANK = Hash[RANK_TO_INDEX.map(&:reverse)]
+
+    # 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}",
+      '_' => '_',
+    }
+
+    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", "_", "_", "_", "_", "p", "r"],
+    #       ["N", "P", "_", "_", "_", "_", "p", "n"],
+    #       ["B", "P", "_", "_", "_", "_", "p", "b"],
+    #       ["Q", "P", "_", "_", "_", "_", "p", "q"],
+    #       ["K", "P", "_", "_", "_", "_", "p", "k"],
+    #       ["B", "P", "_", "_", "_", "_", "p", "b"],
+    #       ["N", "P", "_", "_", "_", "_", "p", "n"],
+    #       ["R", "P", "_", "_", "_", "_", "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)
+      str = case args.length
+      when 1
+        self.at(*coordinates_for(args.first))
+      when 2
+        self.squares[args[0]][args[1]]
+      end
+
+      str == "_" ? nil : str
+    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|
+        self.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)
+      self.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
+      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
+      self.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(self.squares.map(&:dup))
+    end
+
+  end
+end

data/lib/pgn/fen.rb

@@ -0,0 +1,146 @@
+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('') }
+                         .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.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:   castling,
+        en_passant: en_passant,
+        halfmove:   self.halfmove.to_i,
+        fullmove:   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.fen_string,
+        self.active,
+        self.castling,
+        self.en_passant,
+        self.halfmove,
+        self.fullmove,
+      ].join(" ")
+    end
+
+    def inspect
+      self.to_s
+    end
+  end
+end