pgn2 2.0.1 → 2.0.3

data/lib/pgn/node.rb

@@ -141,14 +141,7 @@ module PGN
         @line.push(*new_line)
       else
         normalize_branch_point(cont)
-        vars = cont.variations
-        pos = @index + 1
-        old_tail = @line[(pos + 1)..] || []
-        n0 = new_line[0]
-        @line[pos] = n0
-        @line[(pos + 1)..] = (new_line[1..] || [])
-        cont.variations = []
-        n0.variations = [[cont, *old_tail], *vars]
+        make_mainline(@line, @index + 1, cont, new_line, cont.variations, old_main_position: :first)
       end
       @game.root
     end
@@ -157,16 +150,9 @@ module PGN
     # No-op for the mainline (index 0) or the first variation (index 1).
     # Returns a fresh +game.root+.
     def promote
-      return @game.root if root?
-
-      i = sibling_index
-      return @game.root if i.nil? || i <= 1
-
-      cont = parent_continuation
-      normalize_branch_point(cont)
-      vars = cont.variations
-      vars[i - 1], vars[i - 2] = vars[i - 2], vars[i - 1]
-      @game.root
+      mutate_sibling(noop: ->(i) { i <= 1 }) do |i, _cont, vars|
+        vars[i - 1], vars[i - 2] = vars[i - 2], vars[i - 1]
+      end
     end
 
     # Move this node one slot toward the end among its siblings. At index 0
@@ -174,83 +160,54 @@ module PGN
     # mainline and the old mainline becomes variation #1. No-op at the last
     # index. Returns a fresh +game.root+.
     def demote
-      return @game.root if root?
-
-      i = sibling_index
-      sibs = @parent.children
-      return @game.root if i.nil? || i == sibs.size - 1
-
-      cont = parent_continuation
-      normalize_branch_point(cont)
-      vars = cont.variations
-      if i.zero?
-        v1 = vars.shift
-        make_mainline(cont, v1, vars, old_main_position: :first)
-      else
-        vars[i - 1], vars[i] = vars[i], vars[i - 1]
+      mutate_sibling(noop: ->(i) { i == @parent.children.size - 1 }) do |i, cont, vars|
+        if i.zero?
+          v1 = vars.shift
+          make_mainline(@parent.line, @parent.index + 1, cont, v1, vars, old_main_position: :first)
+        else
+          vars[i - 1], vars[i] = vars[i], vars[i - 1]
+        end
       end
-      @game.root
     end
 
     # Make this node the mainline at its branching point (the old mainline
     # becomes variation #1). No-op if already the mainline. Returns a
     # fresh +game.root+.
     def promote_to_main
-      return @game.root if root?
-
-      i = sibling_index
-      return @game.root if i.nil? || i.zero?
-
-      cont = parent_continuation
-      normalize_branch_point(cont)
-      vars = cont.variations
-      vk = vars.delete_at(i - 1)
-      make_mainline(cont, vk, vars, old_main_position: :first)
-      @game.root
+      mutate_sibling(noop: lambda(&:zero?)) do |i, cont, vars|
+        vk = vars.delete_at(i - 1)
+        make_mainline(@parent.line, @parent.index + 1, cont, vk, vars, old_main_position: :first)
+      end
     end
 
     # Move this node to the last position among its siblings. At index 0
     # the last variation becomes the new mainline and the old mainline
     # becomes the last variation. Returns a fresh +game.root+.
     def demote_to_last
-      return @game.root if root?
-
-      i = sibling_index
-      return @game.root if i.nil?
-
-      cont = parent_continuation
-      normalize_branch_point(cont)
-      vars = cont.variations
-      if i.zero?
-        return @game.root if vars.empty?
-
-        last = vars.pop
-        make_mainline(cont, last, vars, old_main_position: :last)
-      else
-        el = vars.delete_at(i - 1)
-        vars.push(el)
+      mutate_sibling do |i, cont, vars|
+        if i.zero?
+          unless vars.empty?
+            last = vars.pop
+            make_mainline(@parent.line, @parent.index + 1, cont, last, vars, old_main_position: :last)
+          end
+        else
+          el = vars.delete_at(i - 1)
+          vars.push(el)
+        end
       end
-      @game.root
     end
 
     # Remove this node and its subtree. If it is the mainline continuation,
     # the first remaining variation (if any) takes its place; otherwise the
     # line is truncated at this point. Returns a fresh +game.root+.
     def delete
-      return @game.root if root?
-
-      i = sibling_index
-      return @game.root if i.nil?
-
-      cont = parent_continuation
-      normalize_branch_point(cont)
-      vars = cont.variations
-      if i.zero?
-        delete_mainline_continuation(cont, vars)
-      else
-        vars.delete_at(i - 1)
+      mutate_sibling do |i, cont, vars|
+        if i.zero?
+          delete_mainline_continuation(cont, vars)
+        else
+          vars.delete_at(i - 1)
+        end
       end
-      @game.root
     end
 
     private
@@ -295,11 +252,25 @@ module PGN
     # SANs, applying the same castling 0->O normalization as Game#moves=.
     def build_movetexts(move_or_moves)
       sans = move_or_moves.is_a?(String) ? [move_or_moves] : move_or_moves
-      sans.map { |s| PGN::MoveText.new(normalize_castling(s)) }
+      sans.map { |s| PGN::MoveText.new(PGN::MoveText.normalize_castling(s)) }
     end
 
-    def normalize_castling(san)
-      san.include?('0') ? san.gsub('0', 'O') : san
+    # Shared prologue/epilogue for the sibling-reordering mutators (promote,
+    # demote, promote_to_main, demote_to_last, delete): no-op at the root or
+    # per +noop+ (checked against the sibling index before any mutation),
+    # otherwise normalize the branching point and yield the sibling index,
+    # the parent's mainline continuation, and its (now flat) variations to
+    # +block+ for the mutation proper. Always returns a fresh +game.root+.
+    def mutate_sibling(noop: nil)
+      return @game.root if root?
+
+      i = sibling_index
+      return @game.root if i.nil? || noop&.call(i)
+
+      cont = parent_continuation
+      normalize_branch_point(cont)
+      yield i, cont, cont.variations
+      @game.root
     end
 
     # Hoist every variation first-move branching at the position before
@@ -331,18 +302,24 @@ module PGN
       end
     end
 
-    # Make +vk+ (= [vk0, *tail]) the new mainline continuation at the
-    # parent's position, replacing +cont+. The old mainline (+cont+ and
-    # its tail) becomes a variation appended to +others+ either before
-    # (+old_main_position == :first+) or after (+:last+). +cont.variations+
-    # is cleared (its at-point variations are now +vk0+'s siblings).
-    def make_mainline(cont, variation, others, old_main_position:)
-      line = @parent.line
-      pos = @parent.index + 1
+    # Splice +movetexts+ (an Array<MoveText>) into +line+ starting at +pos+:
+    # its first entry replaces +line[pos]+, and the rest replace the tail
+    # after it (so a shorter +movetexts+ truncates +line+).
+    def splice_line!(line, pos, movetexts)
+      line[pos] = movetexts[0]
+      line[(pos + 1)..] = (movetexts[1..] || [])
+    end
+
+    # Make +vk+ (= [vk0, *tail]) the new mainline continuation at +line+/+pos+
+    # (the position before +cont+), replacing +cont+. The old mainline
+    # (+cont+ and its tail) becomes a variation appended to +others+ either
+    # before (+old_main_position == :first+) or after (+:last+).
+    # +cont.variations+ is cleared (its at-point variations are now +vk0+'s
+    # siblings).
+    def make_mainline(line, pos, cont, variation, others, old_main_position:)
       old_tail = line[(pos + 1)..] || []
       variation0 = variation[0]
-      line[pos] = variation0
-      line[(pos + 1)..] = (variation[1..] || [])
+      splice_line!(line, pos, variation)
       cont.variations = []
       old_var = [cont, *old_tail]
       variation0.variations =
@@ -361,11 +338,9 @@ module PGN
         line[pos..] = []
       else
         first_variation = vars.shift
-        first_variation_move = first_variation[0]
-        line[pos] = first_variation_move
-        line[(pos + 1)..] = (first_variation[1..] || [])
+        splice_line!(line, pos, first_variation)
         cont.variations = []
-        first_variation_move.variations = vars
+        first_variation[0].variations = vars
       end
     end
   end

data/lib/pgn/pgn_parser.rb

@@ -8,7 +8,7 @@ require 'racc/parser.rb'
 module PGN
   class PgnParser < Racc::Parser
 
-module_eval(<<'...end pgn_parser.y/module_eval...', 'pgn_parser.y', 96)
+module_eval(<<'...end pgn_parser.y/module_eval...', 'pgn_parser.y', 87)
 
   def parse(input)
     @lexer = PGN::Lexer.new(input)
@@ -29,6 +29,26 @@ module_eval(<<'...end pgn_parser.y/module_eval...', 'pgn_parser.y', 96)
 
   private
 
+  # Fold a move's trailing suffix (comments, NAGs, variations, in any
+  # order) onto a MoveText. Multiple comments are concatenated with a
+  # space after each is individually cleaned; NAGs are merged in order;
+  # variations are collected in source order and then reversed, preserving
+  # the legacy order the serializer and round-trip specs depend on.
+  def build_move(notation, suffix)
+    comment_parts = []
+    nags = nil
+    variations = []
+    suffix.each do |kind, payload|
+      case kind
+      when :comment   then comment_parts << MoveText.clean_text(payload)
+      when :nags       then nags = nags ? nags + payload : payload
+      when :variation  then variations << payload
+      end
+    end
+    comment = comment_parts.empty? ? nil : comment_parts.join(' ')
+    MoveText.new(notation, nags, comment, variations.reverse)
+  end
+
   # Punctuation tokens are racc'd by their literal character (taken from
   # PGN::Lexer::LITERAL_BYTES, the single source of truth for those
   # characters); everything else is racc'd by the upcased lexer symbol.
@@ -66,42 +86,44 @@ module_eval(<<'...end pgn_parser.y/module_eval...', 'pgn_parser.y', 96)
 ##### State transition tables begin ###
 
 racc_action_table = [
-     2,    16,     7,    17,    23,    14,     6,    25,    11,     6,
-    32,    16,    12,    17,    30,    14,    18,    31,    21,    26,
-    21,    25,    31 ]
+     2,    16,     7,    17,    21,    14,     6,    24,    21,     6,
+    30,    24,    25,    16,    12,    17,    25,    14,    11,    18,
+    26,    28 ]
 
 racc_action_check = [
-     1,    28,     2,    28,    17,    28,     4,    17,     6,     1,
-    28,    10,    10,    10,    24,    10,    11,    24,    15,    18,
-    19,    23,    29 ]
+     1,    29,     2,    29,    17,    29,     4,    17,    19,     1,
+    29,    19,    17,    10,    10,    10,    19,    10,     6,    11,
+    18,    22 ]
 
 racc_action_pointer = [
-   nil,     0,     2,   nil,    -3,   nil,     0,   nil,   nil,   nil,
-     8,    14,   nil,   nil,   nil,     7,   nil,     1,     9,     9,
-   nil,   nil,   nil,    15,    11,   nil,   nil,   nil,    -2,    16,
-   nil,   nil,   nil ]
+   nil,     0,     2,   nil,    -3,   nil,    10,   nil,   nil,   nil,
+    10,    17,   nil,   nil,   nil,   nil,   nil,     1,    10,     5,
+   nil,   nil,    15,   nil,   nil,   nil,   nil,   nil,   nil,    -2,
+   nil ]
 
 racc_action_default = [
-    -1,   -25,   -25,    -2,    -8,    -4,   -25,    33,    -3,    -5,
-   -25,   -25,    -7,    -9,   -10,   -11,   -13,   -14,   -25,   -12,
-   -22,    -8,   -15,   -16,   -17,   -20,    -6,   -23,   -25,   -19,
-   -18,   -21,   -24 ]
+    -1,   -23,   -23,    -2,    -8,    -4,   -23,    31,    -3,    -5,
+   -23,   -23,    -7,    -9,   -10,   -11,   -12,   -13,   -23,   -14,
+   -15,   -17,   -18,   -19,   -20,    -8,    -6,   -16,   -21,   -23,
+   -22 ]
 
 racc_goto_table = [
-    10,    24,    20,     1,     3,     5,    27,    29,     9,     4,
-     8,    19,    22,   nil,   nil,   nil,   nil,    28 ]
+    10,     5,     1,    20,     9,    27,     3,     4,     8,    19,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,    29 ]
 
 racc_goto_check = [
-     6,    11,    12,     1,     2,     5,    12,    11,     5,     3,
-     4,     9,    10,   nil,   nil,   nil,   nil,     6 ]
+     6,     5,     1,    10,     5,    10,     2,     3,     4,     9,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,     6 ]
 
 racc_goto_pointer = [
-   nil,     3,     3,     8,     6,     4,    -4,   nil,   nil,    -4,
-    -5,   -16,   -13 ]
+   nil,     2,     5,     6,     4,     0,    -4,   nil,   nil,    -8,
+   -14,   nil,   nil ]
 
 racc_goto_default = [
    nil,   nil,   nil,   nil,   nil,   nil,   nil,    13,    15,   nil,
-   nil,   nil,   nil ]
+   nil,    22,    23 ]
 
 racc_reduce_table = [
   0, 0, :racc_error,
@@ -116,23 +138,21 @@ racc_reduce_table = [
   2, 19, :_reduce_9,
   1, 20, :_reduce_10,
   1, 20, :_reduce_none,
-  2, 20, :_reduce_12,
-  1, 20, :_reduce_13,
-  1, 21, :_reduce_14,
-  2, 21, :_reduce_15,
-  1, 23, :_reduce_16,
+  1, 20, :_reduce_12,
+  1, 21, :_reduce_13,
+  2, 21, :_reduce_14,
+  1, 22, :_reduce_15,
+  2, 22, :_reduce_16,
   1, 23, :_reduce_17,
-  2, 23, :_reduce_18,
-  2, 23, :_reduce_19,
+  1, 23, :_reduce_18,
+  1, 23, :_reduce_19,
   1, 24, :_reduce_20,
   2, 24, :_reduce_21,
-  1, 22, :_reduce_22,
-  2, 22, :_reduce_23,
-  3, 25, :_reduce_24 ]
+  3, 25, :_reduce_22 ]
 
-racc_reduce_n = 25
+racc_reduce_n = 23
 
-racc_shift_n = 33
+racc_shift_n = 31
 
 racc_token_table = {
   false => 0,
@@ -193,8 +213,8 @@ Racc_token_to_s_table = [
   "element_sequence",
   "element",
   "san_move_annotated",
-  "variation_list",
-  "move_trailer",
+  "move_suffix",
+  "suffix_item",
   "annotation_list",
   "variation" ]
 Ractor.make_shareable(Racc_token_to_s_table) if defined?(Ractor)
@@ -293,101 +313,80 @@ module_eval(<<'.,.,', 'pgn_parser.y', 50)
 
 module_eval(<<'.,.,', 'pgn_parser.y', 54)
   def _reduce_12(val, _values, result)
-            result = val[0]
-        result.variations = val[1].reverse
-        result
+            # A standalone comment (not attached to a move) becomes the game
+        # comment; the last such comment in the game wins.
+        @game_comment = val[0]
+        result = nil
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'pgn_parser.y', 60)
+module_eval(<<'.,.,', 'pgn_parser.y', 61)
   def _reduce_13(val, _values, result)
-            # A standalone comment (not attached to a move) becomes the game
-        # comment; the last such comment in the game wins.
-        @game_comment = val[0]
-        result = nil
-
+     result = MoveText.new(val[0])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'pgn_parser.y', 67)
+module_eval(<<'.,.,', 'pgn_parser.y', 62)
   def _reduce_14(val, _values, result)
-     result = MoveText.new(val[0])
+     result = build_move(val[0], val[1])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'pgn_parser.y', 68)
+module_eval(<<'.,.,', 'pgn_parser.y', 70)
   def _reduce_15(val, _values, result)
-     result = MoveText.new(val[0], *val[1])
+     result = [val[0]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'pgn_parser.y', 72)
+module_eval(<<'.,.,', 'pgn_parser.y', 71)
   def _reduce_16(val, _values, result)
-     result = [nil, val[0]]
+     result = val[0] << val[1]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'pgn_parser.y', 73)
+module_eval(<<'.,.,', 'pgn_parser.y', 74)
   def _reduce_17(val, _values, result)
-     result = [val[0], nil]
+     result = [:comment, val[0]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'pgn_parser.y', 74)
+module_eval(<<'.,.,', 'pgn_parser.y', 75)
   def _reduce_18(val, _values, result)
-     result = [val[0], val[1]]
+     result = [:nags, val[0]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'pgn_parser.y', 75)
+module_eval(<<'.,.,', 'pgn_parser.y', 76)
   def _reduce_19(val, _values, result)
-     result = [val[1], val[0]]
+     result = [:variation, val[0]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'pgn_parser.y', 78)
+module_eval(<<'.,.,', 'pgn_parser.y', 79)
   def _reduce_20(val, _values, result)
      result = [val[0]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'pgn_parser.y', 79)
+module_eval(<<'.,.,', 'pgn_parser.y', 80)
   def _reduce_21(val, _values, result)
      result = val[0] << val[1]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'pgn_parser.y', 82)
+module_eval(<<'.,.,', 'pgn_parser.y', 83)
   def _reduce_22(val, _values, result)
-     result = [val[0]]
-    result
-  end
-.,.,
-
-module_eval(<<'.,.,', 'pgn_parser.y', 85)
-  def _reduce_23(val, _values, result)
-            # Left-recursive; the legacy variation-order reversal is applied as
-        # a single explicit `.reverse` where the list is consumed in
-        # {element}, instead of being implicit in recursion direction.
-        result = val[0] << val[1]
-
-    result
-  end
-.,.,
-
-module_eval(<<'.,.,', 'pgn_parser.y', 92)
-  def _reduce_24(val, _values, result)
      result = val[1]
     result
   end

data/lib/pgn/pgn_parser.y

@@ -50,12 +50,6 @@ rule
   element:
       MOVE_NUMBER                         { result = nil }
     | san_move_annotated
-    | san_move_annotated variation_list
-      {
-        result = val[0]
-        result.variations = val[1].reverse
-        result
-      }
     | COMMENT
       {
         # A standalone comment (not attached to a move) becomes the game
@@ -66,28 +60,25 @@ rule
 
   san_move_annotated:
       SAN_MOVE                            { result = MoveText.new(val[0]) }
-    | SAN_MOVE move_trailer                { result = MoveText.new(val[0], *val[1]) }
-
-  # [annotation_list, comment], in whichever order they followed the move.
-  move_trailer:
-      COMMENT                             { result = [nil, val[0]] }
-    | annotation_list                      { result = [val[0], nil] }
-    | annotation_list COMMENT              { result = [val[0], val[1]] }
-    | COMMENT annotation_list              { result = [val[1], val[0]] }
+    | SAN_MOVE move_suffix                { result = build_move(val[0], val[1]) }
+
+  # The trailing material after a move: any number of comments, NAGs, and
+  # variations, in any order (PGN spec §3.2.5). Each suffix item is tagged
+  # [:comment, c] | [:nags, a] | [:variation, v]; {build_move} folds them
+  # onto the MoveText. This generalizes the old single-comment move_trailer,
+  # which rejected two comments before a variation (`{a} {b} (...)`).
+  move_suffix:
+      suffix_item                        { result = [val[0]] }
+    | move_suffix suffix_item            { result = val[0] << val[1] }
+
+  suffix_item:
+      COMMENT                            { result = [:comment, val[0]] }
+    | annotation_list                    { result = [:nags, val[0]] }
+    | variation                          { result = [:variation, val[0]] }
 
   annotation_list:
-      NAG                                 { result = [val[0]] }
-    | annotation_list NAG                  { result = val[0] << val[1] }
-
-  variation_list:
-      variation                           { result = [val[0]] }
-    | variation_list variation
-      {
-        # Left-recursive; the legacy variation-order reversal is applied as
-        # a single explicit `.reverse` where the list is consumed in
-        # {element}, instead of being implicit in recursion direction.
-        result = val[0] << val[1]
-      }
+      NAG                                { result = [val[0]] }
+    | annotation_list NAG                 { result = val[0] << val[1] }
 
   variation:
       '(' element_sequence ')'            { result = val[1] }
@@ -113,6 +104,26 @@ rule
 
   private
 
+  # Fold a move's trailing suffix (comments, NAGs, variations, in any
+  # order) onto a MoveText. Multiple comments are concatenated with a
+  # space after each is individually cleaned; NAGs are merged in order;
+  # variations are collected in source order and then reversed, preserving
+  # the legacy order the serializer and round-trip specs depend on.
+  def build_move(notation, suffix)
+    comment_parts = []
+    nags = nil
+    variations = []
+    suffix.each do |kind, payload|
+      case kind
+      when :comment   then comment_parts << MoveText.clean_text(payload)
+      when :nags       then nags = nags ? nags + payload : payload
+      when :variation  then variations << payload
+      end
+    end
+    comment = comment_parts.empty? ? nil : comment_parts.join(' ')
+    MoveText.new(notation, nags, comment, variations.reverse)
+  end
+
   # Punctuation tokens are racc'd by their literal character (taken from
   # PGN::Lexer::LITERAL_BYTES, the single source of truth for those
   # characters); everything else is racc'd by the upcased lexer symbol.

data/lib/pgn/position.rb

@@ -179,8 +179,10 @@ module PGN
     #
     # @return [Boolean]
     def in_check?
+      return @in_check if defined?(@in_check)
+
       king = PGN::Attack.king_idx(board, mover_color)
-      !king.nil? && PGN::Attack.attacked?(board, king, opponent_color)
+      @in_check = !king.nil? && PGN::Attack.attacked?(board, king, opponent_color)
     end
 
     # The algebraic squares of every piece of the given color that attacks

data/lib/pgn/version.rb

@@ -1,3 +1,3 @@
 module PGN
-  VERSION = '2.0.1'.freeze
+  VERSION = '2.0.3'.freeze
 end

data/lib/pgn.rb

@@ -26,6 +26,10 @@ module PGN
   # @see http://www.chessclub.com/help/PGN-spec PGN Specification
   #
   def self.parse(pgn, encoding = Encoding::ISO_8859_1)
+    # Operate on a private copy so a frozen caller string is never mutated
+    # (force_encoding mutates its receiver; under frozen-string literals
+    # this would otherwise raise FrozenError on the target Ruby).
+    pgn = pgn.dup
     pgn.force_encoding(encoding) if encoding
 
     PGN::Parser.new.parse(pgn).map do |game|

data/spec/game_spec.rb

@@ -133,20 +133,6 @@ describe PGN::Game do
   describe 'node mutation round-trip' do
     non_round_trip = %w[doublequotes.pgn specialcharacters.pgn].freeze
 
-    # A node-sig tree with variations sorted, so the comparison is
-    # order-independent (the parser reverses variation order on each parse).
-    def node_sig(move)
-      [move.notation, (move.variations || []).map { line_sig(_1) }.sort]
-    end
-
-    def line_sig(line)
-      line.map { node_sig(_1) }
-    end
-
-    def tree_sig(game)
-      game.moves.map { node_sig(_1) }
-    end
-
     # First node (DFS over children) that has at least one variation. Such a
     # node always has a non-nil continuation, so add_variation can branch.
     def first_branch_with_variations(node)

data/spec/node_spec.rb

@@ -1,23 +1,5 @@
 require 'spec_helper'
 
-# Helpers for order-independent variation comparison. The parser's
-# `variation_list` rule is right-recursive, so a move's variations are stored
-# in reverse of their PGN-text order; round-tripping flips that order each
-# parse. We therefore compare variation trees as sorted signatures (the same
-# approach the existing game_spec round-trip gate uses), and reference
-# variations by notation rather than by index.
-def node_sig(move)
-  [move.notation, (move.variations || []).map { line_sig(_1) }.sort]
-end
-
-def line_sig(line)
-  line.map { node_sig(_1) }
-end
-
-def tree_sig(game)
-  game.moves.map { node_sig(_1) }
-end
-
 describe PGN::Node do
   let(:game) { PGN.parse(File.read(File.expand_path('pgn_files/variations.pgn', __dir__), encoding: Encoding::ISO_8859_1)).first }
   let(:root) { game.root }