GPQAPP

1
// CodeMirror, copyright (c) by Marijn Haverbeke and others
2
// Distributed under an MIT license: https://codemirror.net/LICENSE
3

4
(function(mod) {
5
  if (typeof exports == "object" && typeof module == "object") // CommonJS
6
    mod(require("../../lib/codemirror"));
7
  else if (typeof define == "function" && define.amd) // AMD
8
    define(["../../lib/codemirror"], mod);
9
  else // Plain browser env
10
    mod(CodeMirror);
11
})(function(CodeMirror) {
12
  "use strict";
13

14
  CodeMirror.defineMode("crystal", function(config) {
15
    function wordRegExp(words, end) {
16
      return new RegExp((end ? "" : "^") + "(?:" + words.join("|") + ")" + (end ? "$" : "\\b"));
17
    }
18

19
    function chain(tokenize, stream, state) {
20
      state.tokenize.push(tokenize);
21
      return tokenize(stream, state);
22
    }
23

24
    var operators = /^(?:[-+/%|&^]|\*\*?|[<>]{2})/;
25
    var conditionalOperators = /^(?:[=!]~|===|<=>|[<>=!]=?|[|&]{2}|~)/;
26
    var indexingOperators = /^(?:\[\][?=]?)/;
27
    var anotherOperators = /^(?:\.(?:\.{2})?|->|[?:])/;
28
    var idents = /^[a-z_\u009F-\uFFFF][a-zA-Z0-9_\u009F-\uFFFF]*/;
29
    var types = /^[A-Z_\u009F-\uFFFF][a-zA-Z0-9_\u009F-\uFFFF]*/;
30
    var keywords = wordRegExp([
31
      "abstract", "alias", "as", "asm", "begin", "break", "case", "class", "def", "do",
32
      "else", "elsif", "end", "ensure", "enum", "extend", "for", "fun", "if",
33
      "include", "instance_sizeof", "lib", "macro", "module", "next", "of", "out", "pointerof",
34
      "private", "protected", "rescue", "return", "require", "select", "sizeof", "struct",
35
      "super", "then", "type", "typeof", "uninitialized", "union", "unless", "until", "when", "while", "with",
36
      "yield", "__DIR__", "__END_LINE__", "__FILE__", "__LINE__"
37
    ]);
38
    var atomWords = wordRegExp(["true", "false", "nil", "self"]);
39
    var indentKeywordsArray = [
40
      "def", "fun", "macro",
41
      "class", "module", "struct", "lib", "enum", "union",
42
      "do", "for"
43
    ];
44
    var indentKeywords = wordRegExp(indentKeywordsArray);
45
    var indentExpressionKeywordsArray = ["if", "unless", "case", "while", "until", "begin", "then"];
46
    var indentExpressionKeywords = wordRegExp(indentExpressionKeywordsArray);
47
    var dedentKeywordsArray = ["end", "else", "elsif", "rescue", "ensure"];
48
    var dedentKeywords = wordRegExp(dedentKeywordsArray);
49
    var dedentPunctualsArray = ["\\)", "\\}", "\\]"];
50
    var dedentPunctuals = new RegExp("^(?:" + dedentPunctualsArray.join("|") + ")$");
51
    var nextTokenizer = {
52
      "def": tokenFollowIdent, "fun": tokenFollowIdent, "macro": tokenMacroDef,
53
      "class": tokenFollowType, "module": tokenFollowType, "struct": tokenFollowType,
54
      "lib": tokenFollowType, "enum": tokenFollowType, "union": tokenFollowType
55
    };
56
    var matching = {"[": "]", "{": "}", "(": ")", "<": ">"};
57

58
    function tokenBase(stream, state) {
59
      if (stream.eatSpace()) {
60
        return null;
61
      }
62

63
      // Macros
64
      if (state.lastToken != "\\" && stream.match("{%", false)) {
65
        return chain(tokenMacro("%", "%"), stream, state);
66
      }
67

68
      if (state.lastToken != "\\" && stream.match("{{", false)) {
69
        return chain(tokenMacro("{", "}"), stream, state);
70
      }
71

72
      // Comments
73
      if (stream.peek() == "#") {
74
        stream.skipToEnd();
75
        return "comment";
76
      }
77

78
      // Variables and keywords
79
      var matched;
80
      if (stream.match(idents)) {
81
        stream.eat(/[?!]/);
82

83
        matched = stream.current();
84
        if (stream.eat(":")) {
85
          return "atom";
86
        } else if (state.lastToken == ".") {
87
          return "property";
88
        } else if (keywords.test(matched)) {
89
          if (indentKeywords.test(matched)) {
90
            if (!(matched == "fun" && state.blocks.indexOf("lib") >= 0) && !(matched == "def" && state.lastToken == "abstract")) {
91
              state.blocks.push(matched);
92
              state.currentIndent += 1;
93
            }
94
          } else if ((state.lastStyle == "operator" || !state.lastStyle) && indentExpressionKeywords.test(matched)) {
95
            state.blocks.push(matched);
96
            state.currentIndent += 1;
97
          } else if (matched == "end") {
98
            state.blocks.pop();
99
            state.currentIndent -= 1;
100
          }
101

102
          if (nextTokenizer.hasOwnProperty(matched)) {
103
            state.tokenize.push(nextTokenizer[matched]);
104
          }
105

106
          return "keyword";
107
        } else if (atomWords.test(matched)) {
108
          return "atom";
109
        }
110

111
        return "variable";
112
      }
113

114
      // Class variables and instance variables
115
      // or attributes
116
      if (stream.eat("@")) {
117
        if (stream.peek() == "[") {
118
          return chain(tokenNest("[", "]", "meta"), stream, state);
119
        }
120

121
        stream.eat("@");
122
        stream.match(idents) || stream.match(types);
123
        return "variable-2";
124
      }
125

126
      // Constants and types
127
      if (stream.match(types)) {
128
        return "tag";
129
      }
130

131
      // Symbols or ':' operator
132
      if (stream.eat(":")) {
133
        if (stream.eat("\"")) {
134
          return chain(tokenQuote("\"", "atom", false), stream, state);
135
        } else if (stream.match(idents) || stream.match(types) ||
136
                   stream.match(operators) || stream.match(conditionalOperators) || stream.match(indexingOperators)) {
137
          return "atom";
138
        }
139
        stream.eat(":");
140
        return "operator";
141
      }
142

143
      // Strings
144
      if (stream.eat("\"")) {
145
        return chain(tokenQuote("\"", "string", true), stream, state);
146
      }
147

148
      // Strings or regexps or macro variables or '%' operator
149
      if (stream.peek() == "%") {
150
        var style = "string";
151
        var embed = true;
152
        var delim;
153

154
        if (stream.match("%r")) {
155
          // Regexps
156
          style = "string-2";
157
          delim = stream.next();
158
        } else if (stream.match("%w")) {
159
          embed = false;
160
          delim = stream.next();
161
        } else if (stream.match("%q")) {
162
          embed = false;
163
          delim = stream.next();
164
        } else {
165
          if(delim = stream.match(/^%([^\w\s=])/)) {
166
            delim = delim[1];
167
          } else if (stream.match(/^%[a-zA-Z_\u009F-\uFFFF][\w\u009F-\uFFFF]*/)) {
168
            // Macro variables
169
            return "meta";
170
          } else if (stream.eat('%')) {
171
            // '%' operator
172
            return "operator";
173
          }
174
        }
175

176
        if (matching.hasOwnProperty(delim)) {
177
          delim = matching[delim];
178
        }
179
        return chain(tokenQuote(delim, style, embed), stream, state);
180
      }
181

182
      // Here Docs
183
      if (matched = stream.match(/^<<-('?)([A-Z]\w*)\1/)) {
184
        return chain(tokenHereDoc(matched[2], !matched[1]), stream, state)
185
      }
186

187
      // Characters
188
      if (stream.eat("'")) {
189
        stream.match(/^(?:[^']|\\(?:[befnrtv0'"]|[0-7]{3}|u(?:[0-9a-fA-F]{4}|\{[0-9a-fA-F]{1,6}\})))/);
190
        stream.eat("'");
191
        return "atom";
192
      }
193

194
      // Numbers
195
      if (stream.eat("0")) {
196
        if (stream.eat("x")) {
197
          stream.match(/^[0-9a-fA-F_]+/);
198
        } else if (stream.eat("o")) {
199
          stream.match(/^[0-7_]+/);
200
        } else if (stream.eat("b")) {
201
          stream.match(/^[01_]+/);
202
        }
203
        return "number";
204
      }
205

206
      if (stream.eat(/^\d/)) {
207
        stream.match(/^[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?/);
208
        return "number";
209
      }
210

211
      // Operators
212
      if (stream.match(operators)) {
213
        stream.eat("="); // Operators can follow assign symbol.
214
        return "operator";
215
      }
216

217
      if (stream.match(conditionalOperators) || stream.match(anotherOperators)) {
218
        return "operator";
219
      }
220

221
      // Parens and braces
222
      if (matched = stream.match(/[({[]/, false)) {
223
        matched = matched[0];
224
        return chain(tokenNest(matched, matching[matched], null), stream, state);
225
      }
226

227
      // Escapes
228
      if (stream.eat("\\")) {
229
        stream.next();
230
        return "meta";
231
      }
232

233
      stream.next();
234
      return null;
235
    }
236

237
    function tokenNest(begin, end, style, started) {
238
      return function (stream, state) {
239
        if (!started && stream.match(begin)) {
240
          state.tokenize[state.tokenize.length - 1] = tokenNest(begin, end, style, true);
241
          state.currentIndent += 1;
242
          return style;
243
        }
244

245
        var nextStyle = tokenBase(stream, state);
246
        if (stream.current() === end) {
247
          state.tokenize.pop();
248
          state.currentIndent -= 1;
249
          nextStyle = style;
250
        }
251

252
        return nextStyle;
253
      };
254
    }
255

256
    function tokenMacro(begin, end, started) {
257
      return function (stream, state) {
258
        if (!started && stream.match("{" + begin)) {
259
          state.currentIndent += 1;
260
          state.tokenize[state.tokenize.length - 1] = tokenMacro(begin, end, true);
261
          return "meta";
262
        }
263

264
        if (stream.match(end + "}")) {
265
          state.currentIndent -= 1;
266
          state.tokenize.pop();
267
          return "meta";
268
        }
269

270
        return tokenBase(stream, state);
271
      };
272
    }
273

274
    function tokenMacroDef(stream, state) {
275
      if (stream.eatSpace()) {
276
        return null;
277
      }
278

279
      var matched;
280
      if (matched = stream.match(idents)) {
281
        if (matched == "def") {
282
          return "keyword";
283
        }
284
        stream.eat(/[?!]/);
285
      }
286

287
      state.tokenize.pop();
288
      return "def";
289
    }
290

291
    function tokenFollowIdent(stream, state) {
292
      if (stream.eatSpace()) {
293
        return null;
294
      }
295

296
      if (stream.match(idents)) {
297
        stream.eat(/[!?]/);
298
      } else {
299
        stream.match(operators) || stream.match(conditionalOperators) || stream.match(indexingOperators);
300
      }
301
      state.tokenize.pop();
302
      return "def";
303
    }
304

305
    function tokenFollowType(stream, state) {
306
      if (stream.eatSpace()) {
307
        return null;
308
      }
309

310
      stream.match(types);
311
      state.tokenize.pop();
312
      return "def";
313
    }
314

315
    function tokenQuote(end, style, embed) {
316
      return function (stream, state) {
317
        var escaped = false;
318

319
        while (stream.peek()) {
320
          if (!escaped) {
321
            if (stream.match("{%", false)) {
322
              state.tokenize.push(tokenMacro("%", "%"));
323
              return style;
324
            }
325

326
            if (stream.match("{{", false)) {
327
              state.tokenize.push(tokenMacro("{", "}"));
328
              return style;
329
            }
330

331
            if (embed && stream.match("#{", false)) {
332
              state.tokenize.push(tokenNest("#{", "}", "meta"));
333
              return style;
334
            }
335

336
            var ch = stream.next();
337

338
            if (ch == end) {
339
              state.tokenize.pop();
340
              return style;
341
            }
342

343
            escaped = embed && ch == "\\";
344
          } else {
345
            stream.next();
346
            escaped = false;
347
          }
348
        }
349

350
        return style;
351
      };
352
    }
353

354
    function tokenHereDoc(phrase, embed) {
355
      return function (stream, state) {
356
        if (stream.sol()) {
357
          stream.eatSpace()
358
          if (stream.match(phrase)) {
359
            state.tokenize.pop();
360
            return "string";
361
          }
362
        }
363

364
        var escaped = false;
365
        while (stream.peek()) {
366
          if (!escaped) {
367
            if (stream.match("{%", false)) {
368
              state.tokenize.push(tokenMacro("%", "%"));
369
              return "string";
370
            }
371

372
            if (stream.match("{{", false)) {
373
              state.tokenize.push(tokenMacro("{", "}"));
374
              return "string";
375
            }
376

377
            if (embed && stream.match("#{", false)) {
378
              state.tokenize.push(tokenNest("#{", "}", "meta"));
379
              return "string";
380
            }
381

382
            escaped = embed && stream.next() == "\\";
383
          } else {
384
            stream.next();
385
            escaped = false;
386
          }
387
        }
388

389
        return "string";
390
      }
391
    }
392

393
    return {
394
      startState: function () {
395
        return {
396
          tokenize: [tokenBase],
397
          currentIndent: 0,
398
          lastToken: null,
399
          lastStyle: null,
400
          blocks: []
401
        };
402
      },
403

404
      token: function (stream, state) {
405
        var style = state.tokenize[state.tokenize.length - 1](stream, state);
406
        var token = stream.current();
407

408
        if (style && style != "comment") {
409
          state.lastToken = token;
410
          state.lastStyle = style;
411
        }
412

413
        return style;
414
      },
415

416
      indent: function (state, textAfter) {
417
        textAfter = textAfter.replace(/^\s*(?:\{%)?\s*|\s*(?:%\})?\s*$/g, "");
418

419
        if (dedentKeywords.test(textAfter) || dedentPunctuals.test(textAfter)) {
420
          return config.indentUnit * (state.currentIndent - 1);
421
        }
422

423
        return config.indentUnit * state.currentIndent;
424
      },
425

426
      fold: "indent",
427
      electricInput: wordRegExp(dedentPunctualsArray.concat(dedentKeywordsArray), true),
428
      lineComment: '#'
429
    };
430
  });
431

432
  CodeMirror.defineMIME("text/x-crystal", "crystal");
433
});
434