Code coverage report for lib/pgn.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
1
 
1
 
 
 
1
1
1
1
 
 
1
 
17
17
17
17
1866
1866
 
 
1866
 
168
168
 
1113
1110
 
9
9
 
14
14
 
 
 
3
3
 
 
 
14
 
 
 
1
168
 
 
168
 
1
168
 
1
1
1
1
1
1
17
17
17
17
17
17
17
11166
18
 
11148
 
 
177
177
177
177
177
 
 
177
177
177
177
 
 
2878
1590
475
 
1115
1115
1115
562
 
1115
 
1288
576
562
 
576
576
576
 
712
 
7916
5389
 
2527
1682
 
1682
13
13
13
 
1669
1
1
1
 
 
2513
576
 
 
8791
8408
 
1
191
 
1
3364
3364
16820
 
3364
 
 
17
1
14
 
 
 
14
14
 
1
2045
175
 
1870
1854
1854
 
 
1854
1854
 
 
 
 
 
 
1870
1870
 
 
 
"use strict";
Object.defineProperties(exports, {
  PGN: {get: function() {
      return PGN;
    }},
  __esModule: {value: true}
});
var FEN = require('./fen').FEN;
var Game = require('./game').Game;
var ChessError = require('./error').ChessError;
var $__3 = require('./util'),
    partition = $__3.partition,
    last = $__3.last;
var PGN = {
  parse: function(pgnStr) {
    var tokens = tokenizePGN((" " + pgnStr.split(/[\n\r\r\t]+/g).join(' ') + " "));
    var game = new Game();
    try {
      tokens.forEach((function($__4) {
        var $__6;
        var $__5 = $traceurRuntime.assertObject($__4),
            mode = $__5.mode,
            source = $__5.source;
        switch (mode) {
          case MODE_TAG:
            ($__6 = game).addTag.apply($__6, $traceurRuntime.spread(parseTag(source)));
            break;
          case MODE_PLY_NOTATION:
            game.move(source);
            break;
          case MODE_ANNOTATION_NOTATION:
            game.annotate(source);
            break;
          case MODE_RESULT:
            game.finish(source);
            break;
        }
      }));
    } catch (err) {
      Eif (err instanceof ChessError) {
        err.lastPosition = FEN.stringify(last(game.ply).position);
      }
      throw err;
    }
    return game;
  },
  stringify: function(game) {}
};
function parseTag(line) {
  var $__4 = $traceurRuntime.assertObject(line.split(/\s+/)),
      key = $__4[0],
      value = $__4[1];
  return [key, cleanValue(value)];
}
function cleanValue(value) {
  return value.replace(/^[\"\']|[\"\']$/g, '');
}
var MODE_TAG = 'tag';
var MODE_RESULT = 'result';
var MODE_MOVE_NUMBER_NOTATION = 'move number';
var MODE_PLY_NOTATION = 'ply';
var MODE_ANNOTATION_NOTATION = 'annotation';
function tokenizePGN(transcript) {
  var tokens = [];
  var mode = null;
  var lastMode = null;
  var buffer = [];
  var halfMove = false;
  var skipping = 0;
  transcript.split('').forEach((function(char, i) {
    if (i < skipping) {
      return;
    }
    switch (char) {
      case '[':
      case '{':
        skip(1);
        lastMode = mode;
        finishToken();
        mode = char == '[' ? MODE_TAG : MODE_ANNOTATION_NOTATION;
        break;
      case '}':
      case ']':
        finishToken();
        mode = lastMode;
        lastMode = null;
        return;
      case ' ':
      case '.':
        if (mode === MODE_PLY_NOTATION) {
          if (buffer.length == 0) {
            return;
          }
          finishToken();
          halfMove = !halfMove;
          if (halfMove) {
            mode = MODE_PLY_NOTATION;
          }
          return;
        }
        if (mode === MODE_MOVE_NUMBER_NOTATION) {
          if ('.' === char) {
            buffer.push(char);
          }
          finishToken();
          mode = MODE_PLY_NOTATION;
          return;
        }
        break;
      default:
        if (!/\d/.test(char)) {
          break;
        }
        if (mode === null || mode === MODE_PLY_NOTATION) {
          var p3 = peek(3),
              p7 = peek(7);
          if (p3 === '1-0' || p3 === '0-1') {
            result(p3);
            skip(3);
            return;
          }
          if (p7 === '1/2-1/2') {
            result(p7);
            skip(7);
            return;
          }
        }
        if (mode === null) {
          mode = MODE_MOVE_NUMBER_NOTATION;
        }
    }
    if (mode !== null && skipping < i) {
      buffer.push(char);
    }
    function skip(n) {
      skipping = i + n - 1;
    }
    function peek(n) {
      var str = '';
      for (var j = 0; j < n; j++) {
        str += transcript[$traceurRuntime.toProperty(i + j)];
      }
      return str;
    }
  }));
  return tokens;
  function result(source) {
    tokens.push({
      mode: MODE_RESULT,
      source: source
    });
    mode = null;
    buffer = [];
  }
  function finishToken() {
    if (mode == null) {
      return;
    }
    if (buffer.length > 0) {
      try {
        throw undefined;
      } catch (source) {
        {
          source = buffer.join('');
          tokens.push({
            mode: mode,
            source: source
          });
        }
      }
    }
    mode = null;
    buffer = [];
  }
}