pgn2 0.4.0 → 1.1.0

data/lib/pgn/move_calculator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 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
@@ -80,9 +82,12 @@ module PGN
       }
     }.freeze
 
-    attr_accessor :board
-    attr_accessor :move
-    attr_accessor :origin
+    # Frozen rook-origin -> castling-restriction lookup, shared by both
+    # white ('R') and black ('r') since their rook origins (a1/h1, a8/h8)
+    # are distinct keys. Replaces a per-call hash literal.
+    ROOK_RESTRICTIONS = { 'a1' => 'Q', 'h1' => 'K', 'a8' => 'q', 'h8' => 'k' }.freeze
+
+    attr_accessor :board, :move, :origin
 
     # @param board [PGN::Board] the current board
     # @param move [PGN::Move] the current move
@@ -114,9 +119,9 @@ module PGN
       when 'k'
         restrict += %w[k q]
       when 'R'
-        restrict << { 'a1' => 'Q', 'h1' => 'K' }[origin]
+        restrict << ROOK_RESTRICTIONS[origin]
       when 'r'
-        restrict << { 'a8' => 'q', 'h8' => 'k' }[origin]
+        restrict << ROOK_RESTRICTIONS[origin]
       end
 
       # when castling occurs
@@ -129,7 +134,7 @@ module PGN
       restrict << 'K' if move.destination == 'h1'
       restrict << 'k' if move.destination == 'h8'
 
-      restrict.compact.uniq
+      restrict.empty? ? restrict : restrict.compact.uniq
     end
 
     # @return [Boolean] whether to increment the halfmove clock
@@ -149,12 +154,12 @@ module PGN
     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
+      return unless 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
 
@@ -260,7 +265,7 @@ end
         possibilities.select { |p| board.position_for(p).match(move.disambiguation) }
       else
         possibilities
-end
+      end
     end
 
     # A pawn can't move two spaces if there is a pawn in front of it.
@@ -270,17 +275,19 @@ end
         possibilities.reject { |p| board.position_for(p).match(/2|7/) }
       else
         possibilities
-end
+      end
     end
 
     # A piece can't move if it would result in a discovered check.
     #
     def disambiguate_discovered_check(possibilities)
+      king_pos = king_position
+
       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)
+          piece, square = first_piece(king_pos, dir)
           next unless piece == move.piece && possibilities.include?(square)
 
           piece, = first_piece(square, dir)
@@ -298,7 +305,7 @@ end
       piece = nil
 
       while valid_square?(file += i, rank += j)
-        break if piece = board.at(file, rank)
+        break if (piece = board.at(file, rank))
       end
 
       [piece, [file, rank]]
@@ -316,22 +323,21 @@ 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
+          return [file, rank] if board.at(file, rank) == king
         end
       end
 
-      coords
+      nil
     end
 
     def valid_square?(file, rank)
-      (0..7) === file && (0..7) === rank
+      (0..7).include?(file) && (0..7).include?(rank)
     end
 
     def destination_coords
-      board.coordinates_for(move.destination)
+      @dest_coords ||= board.coordinates_for(move.destination)
     end
   end
 end

data/lib/pgn/parser.rb

@@ -1,208 +1,18 @@
-require 'whittle'
+# frozen_string_literal: true
 
-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
+require 'pgn/pgn_parser'
 
-    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 }
+module PGN
+  # {PGN::Parser} is the public entry point for parsing PGN text into a list
+  # of game hashes. It delegates to the stdlib Racc + StringScanner parser
+  # {PGN::PgnParser}.
+  class Parser
+    # @param input [String] the raw PGN text (already force-encoded by the
+    #   caller, e.g. via {PGN.parse}).
+    # @return [Array<Hash>] one Hash per game, with keys +:tags+, +:result+,
+    #   +:moves+, +:pgn+, +:comment+.
+    def parse(input)
+      PGN::PgnParser.new.parse(input)
     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