pgn 0.0.1

data/lib/pgn/parser.rb

@@ -0,0 +1,119 @@
+require 'whittle'
+
+module PGN
+  # {PGN::Parser} uses the whittle gem to parse pgn files based on their
+  # context free grammar.
+  #
+  class Parser < Whittle::Parser
+    rule(:wsp => /\s+/).skip!
+
+    rule("[")
+    rule("]")
+    rule("(")
+    rule(")")
+
+    start(:pgn_database)
+
+    rule(:pgn_database) do |r|
+      r[].as { [] }
+      r[:pgn_game, :pgn_database].as {|game, database| database << game }
+    end
+
+    rule(:pgn_game) do |r|
+      r[:tag_section, :movetext_section].as {|tags, moves| {tags: tags, result: moves.pop, moves: moves} }
+    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.reverse << b }
+    end
+
+    rule(:element_sequence) do |r|
+      r[:element, :element_sequence].as {|element, sequence| element.nil? ? sequence : sequence << element }
+      r[].as { [] }
+      #r[:recursive_variation, :element_sequence]
+      #r[:recursive_variation]
+    end
+
+    rule(:element) do |r|
+      r[:move_number_indication].as { nil }
+      r[:san_move]
+      #r[:numeric_annotation_glyph]
+    end
+
+    #rule(:recursive_variation) do |r|
+      #r["(", :element_sequence, ")"]
+    #end
+
+    rule(
+      :string => %r{
+        "                          # 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(
+      :game_termination => %r{
+        1-0       |    # white wins
+        0-1       |    # black wins
+        1\/2-1\/2 |    # draw
+        \*             # ?
+      }x
+    )
+
+    rule(
+      :move_number_indication => %r{
+        [[:digit:]]+\.*    # one or more digits followed by zero or more periods
+      }x
+    )
+
+    rule(
+      :san_move => %r{
+        (
+          O(-O){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 => %r{
+        [A-Za-z0-9_]+    # letters, digits and underscores only
+      }x
+    )
+
+    rule(
+      :numeric_annotation_glyph => %r{
+        \$\d+    # dollar sign followed by an integer from 0 to 255
+      }x
+    )
+  end
+end

data/lib/pgn/position.rb

@@ -0,0 +1,129 @@
+module PGN
+  # {PGN::Position} encapsulates all of the information necessary to
+  # completely understand a chess position. It can be turned into a FEN string
+  # or perform a move.
+  #
+  # @!attribute board
+  #   @return [PGN::Board] the board for the position
+  #
+  # @!attribute player
+  #   @return [Symbol] the player who moves next
+  #   @example
+  #     position.player #=> :white
+  #
+  # @!attribute castling
+  #   @return [Array<String>] the castling moves that are still available
+  #   @example
+  #     position.castling #=> ["K", "k", "q"]
+  #
+  # @!attribute en_passant
+  #   @return [String] the en passant square if applicable
+  #
+  # @!attribute halfmove
+  #   @return [Integer] the number of halfmoves since the last pawn move or
+  #     capture
+  #
+  # @!attribute fullmove
+  #   @return [Integer] the number of fullmoves made so far
+  #
+  class Position
+    PLAYERS  = [:white, :black]
+    CASTLING = %w{K Q k q}
+
+    attr_accessor :board
+    attr_accessor :player
+    attr_accessor :castling
+    attr_accessor :en_passant
+    attr_accessor :halfmove
+    attr_accessor :fullmove
+
+    # @return [PGN::Position] the starting position of a chess game
+    #
+    def self.start
+      PGN::Position.new(
+        PGN::Board.start,
+        PLAYERS.first,
+        castling: CASTLING,
+        en_passant: nil,
+        halfmove: 0,
+        fullmove: 0,
+      )
+    end
+
+    # @param board [PGN::Board] the board for the position
+    # @param player [Symbol] the player who moves next
+    # @param castling [Array<String>] the castling moves that are still
+    #   available
+    # @param en_passant [String, nil] the en passant square if applicable
+    # @param halfmove [Integer] the number of halfmoves since the last pawn
+    #   move or capture
+    # @param fullmove [Integer] the number of fullmoves made so far
+    #
+    # @example
+    #   PGN::Position.new(
+    #     PGN::Board.start,
+    #     :white,
+    #   )
+    #
+    def initialize(board, player, castling: CASTLING, en_passant: nil, halfmove: 0, fullmove: 0)
+      self.board      = board
+      self.player     = player
+      self.castling   = castling
+      self.en_passant = en_passant
+      self.halfmove   = halfmove
+      self.fullmove   = fullmove
+    end 
+
+    # @param str [String] the move to make in SAN
+    # @return [PGN::Position] the resulting position
+    #
+    # @example
+    #   queens_pawn = PGN::Position.start.move("d4")
+    #
+    def move(str)
+      move       = PGN::Move.new(str, self.player)
+      calculator = PGN::MoveCalculator.new(self.board, move)
+
+      new_castling = self.castling - calculator.castling_restrictions
+      new_halfmove = calculator.increment_halfmove? ?
+        self.halfmove + 1 :
+        0
+      new_fullmove = calculator.increment_fullmove? ?
+        self.fullmove + 1 :
+        self.fullmove
+
+      PGN::Position.new(
+        calculator.result_board,
+        self.next_player,
+        castling:   new_castling,
+        en_passant: calculator.en_passant_square,
+        halfmove:   new_halfmove,
+        fullmove:   new_fullmove,
+      )
+    end
+
+    # @return [Symbol] the next player to move
+    #
+    def next_player
+      (PLAYERS - [self.player]).first
+    end
+
+    def inspect
+      "\n" + self.board.inspect
+    end
+
+    # @return [PGN::FEN] a {PGN::FEN} object representing the current position
+    #
+    def to_fen
+      PGN::FEN.from_attributes(
+        board:      self.board,
+        active:     self.player == :white ? 'w' : 'b',
+        castling:   self.castling.join(''),
+        en_passant: self.en_passant,
+        halfmove:   self.halfmove.to_s,
+        fullmove:   self.fullmove.to_s,
+      )
+    end
+
+  end
+end

data/lib/pgn/version.rb

@@ -0,0 +1,3 @@
+module PGN
+  VERSION = "0.0.1"
+end

data/pgn.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pgn/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pgn"
+  spec.version       = PGN::VERSION
+  spec.authors       = ["Stacey Touset"]
+  spec.email         = ["stacey@touset.org"]
+  spec.description   = %q{A PGN parser and FEN generator for Ruby}
+  spec.summary       = %q{A PGN parser for Ruby}
+  spec.homepage      = "https://github.com/capicue/pgn"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "whittle"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/fen_spec.rb

@@ -0,0 +1,87 @@
+require "spec_helper"
+
+describe PGN::FEN do
+  describe "castling availability" do
+    it "should remove all castling availabilitiy after castling" do
+      pos = PGN::FEN.new("rnbqk2r/1p3pbp/p2p1np1/2pP4/P3PB2/2N2N2/1P3PPP/R2QKB1R b KQkq e3 0 8").to_position
+      next_pos = pos.move("O-O")
+      next_pos.to_fen.castling.should_not match(/k|q/)
+    end
+
+    it "should remove all castling availability after moving a king" do
+      pos = PGN::FEN.new("r1b1kb1r/pp2pppp/2n5/4P3/1nB5/P4N2/1P3PPP/RNBqK2R w KQkq - 0 9").to_position
+      next_pos = pos.move("Kxd1")
+      next_pos.to_fen.castling.should_not match(/K|Q/)
+    end
+
+    it "should remove only the one castling option after moving a rook" do
+      pos = PGN::FEN.new("r3k2r/1pp2pp1/p1pb1qn1/4p3/3PP1p1/8/PPPN1PPN/R1BQR1K1 b kq - 1 11").to_position
+      next_pos = pos.move("Rxh2")
+      next_pos.to_fen.castling.should_not match(/k/)
+      next_pos.to_fen.castling.should match(/q/)
+    end
+
+    it "should change to a hyphen once no side can castle" do
+      pos = PGN::FEN.new("r1bq1rk1/pp1nbppp/3ppn2/8/2PP1N2/P1N5/1P2BPPP/R1BQK2R w KQ - 2 9").to_position
+      pos.to_fen.castling.should_not == "-"
+      next_pos = pos.move("O-O")
+      next_pos.to_fen.castling.should == "-"
+    end
+  end
+
+  describe "en passant" do
+    it "should display the en passant square whenever a pawn moves two spaces" do
+      pos = PGN::FEN.new("rnbqkb1r/pppppppp/5n2/8/8/5N2/PPPPPPPP/RNBQKB1R w KQkq - 2 1").to_position
+      next_pos = pos.move("c4")
+      next_pos.to_fen.en_passant.should == "c3"
+    end
+
+    it "should be a hyphen if no pawn moved two spaces the previous move" do
+      pos = PGN::FEN.new("rnbqkb1r/pppppppp/5n2/8/2P5/5N2/PP1PPPPP/RNBQKB1R b KQkq c3 0 1").to_position
+      next_pos = pos.move("d6")
+      next_pos.to_fen.en_passant.should == "-"
+    end
+  end
+
+  describe "halfmove counter" do
+    it "should reset after a pawn advance" do
+      pos = PGN::FEN.new("2b2rk1/2pp1ppp/1p6/r3P2q/3Q4/2P5/PP3PPP/RN3RK1 w - - 3 15").to_position
+      pos.to_fen.halfmove.should == "3"
+      next_pos = pos.move("f4")
+      next_pos.to_fen.halfmove.should == "0"
+    end
+
+    it "should reset after a capture" do
+      pos = PGN::FEN.new("2r2rk1/1p2ppbp/1q1p1np1/pN4B1/Pnb1PP2/2N5/1PP1B1PP/R2Q1R1K w - - 5 14").to_position
+      pos.to_fen.halfmove.should == "5"
+      next_pos = pos.move("Bxc4")
+      next_pos.to_fen.halfmove.should == "0"
+    end
+
+    it "should not reset otherwise" do
+      pos = PGN::FEN.new("2k2b1r/p4p1p/q1p2p2/8/2br4/5P2/PPQB2PP/R1N1K2R w KQ - 0 17").to_position
+      pos.to_fen.halfmove.should == "0"
+      moves = %w{Qf5+ Rd7 Bc3 Bh6 Qa5 Re8+ Kf2 Be3+ Kg3 Rg8+ Kh4}
+      moves.each_with_index do |move, i|
+        pos = pos.move(move)
+        pos.to_fen.halfmove.should == (i+1).to_s
+      end
+    end
+  end
+
+  describe "fullmove counter" do
+    it "should not increase after white moves" do
+      pos = PGN::FEN.new("4br1k/ppqnr1b1/3p3p/P1pP1p2/2P1pB2/6PP/1P2BP1N/R2QR1K1 w - - 3 25").to_position
+      pos.to_fen.fullmove.should == "25"
+      next_pos = pos.move("Qd2")
+      next_pos.to_fen.fullmove.should == "25"
+    end
+
+    it "should increase after black moves" do
+      pos = PGN::FEN.new("4br1k/ppqnr1b1/3p3p/P1pP1p2/2P1pB2/6PP/1P1QBP1N/R3R1K1 b - - 4 25").to_position
+      pos.to_fen.fullmove.should == "25"
+      next_pos = pos.move("Kh7")
+      next_pos.to_fen.fullmove.should == "26"
+    end
+  end
+end

data/spec/game_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe PGN::Game do
+  describe "#positions" do
+    it "should not raise an error" do
+      tags   = {"White" => "Deep Blue", "Black" => "Kasparov"}
+      moves  = %w{e4 c5 c3 d5 exd5 Qxd5 d4 Nf6 Nf3 Bg4 Be2 e6 h3 Bh5 O-O Nc6 Be3 cxd4 cxd4 Bb4 a3 Ba5 Nc3 Qd6 Nb5 Qe7 Ne5 Bxe2 Qxe2 O-O Rac1 Rac8 Bg5 Bb6 Bxf6 gxf6 Nc4 Rfd8 Nxb6 axb6 Rfd1 f5 Qe3 Qf6 d5 Rxd5 Rxd5 exd5 b3 Kh8 Qxb6 Rg8 Qc5 d4 Nd6 f4 Nxb7 Ne5 Qd5 f3 g3 Nd3 Rc7 Re8 Nd6 Re1+ Kh2 Nxf2 Nxf7+ Kg7 Ng5+ Kh6 Rxh7+}
+      result = "1-0"
+      game = PGN::Game.new(moves, tags, result)
+      lambda { game.positions }.should_not raise_error
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe PGN do
+  describe "parsing a file" do
+    it "should return a list of games" do
+      games = PGN.parse(File.read("./examples/immortal_game.pgn"))
+      games.length.should == 1
+      game = games.first
+      game.result.should == "1-0"
+      game.tags["White"].should == "Adolf Anderssen"
+      game.moves.last.should == "Be7#"
+    end
+  end
+end

data/spec/position_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe PGN::Position do
+  context "disambiguating moves" do
+    describe "using SAN square disambiguation" do
+      pos = PGN::FEN.new("r1bqkb1r/pp1p1ppp/2n1pn2/8/3NP3/2N5/PPP2PPP/R1BQKB1R w KQkq - 3 6").to_position
+      next_pos = pos.move("Ndb5")
+
+      it "should move the specified piece" do
+        next_pos.board.at("d4").should be_nil
+      end
+
+      it "should not move the other piece" do
+        next_pos.board.at("c3").should == "N"
+      end
+    end
+
+    describe "using discovered check" do
+      pos = PGN::FEN.new("rnbqk2r/p1pp1ppp/1p2pn2/8/1bPP4/2N1P3/PP3PPP/R1BQKBNR w KQkq - 0 5").to_position
+      next_pos = pos.move("Ne2")
+
+      it "should move the piece that doesn't give discovered check" do
+        next_pos.board.at("g1").should be_nil
+      end
+
+      it "shouldn't move the other piece" do
+        next_pos.board.at("c3").should == "N"
+      end
+    end
+
+    describe "with two pawns on the same file" do
+      pos = PGN::FEN.new("r2q1rk1/4bppp/p3n3/1p2n3/4N3/1B2BP2/PP3P1P/R2Q1RK1 w - - 4 19").to_position
+      next_pos = pos.move("f4")
+
+      it "should move the pawn in front" do
+        next_pos.board.at("f3").should be_nil
+      end
+
+      it "should not move the other pawn" do
+        next_pos.board.at("f2").should == "P"
+      end
+    end
+  end
+end