GPQAPP

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

4
// Slim Highlighting for CodeMirror copyright (c) HicknHack Software Gmbh
5

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

16
  CodeMirror.defineMode("slim", function(config) {
17
    var htmlMode = CodeMirror.getMode(config, {name: "htmlmixed"});
18
    var rubyMode = CodeMirror.getMode(config, "ruby");
19
    var modes = { html: htmlMode, ruby: rubyMode };
20
    var embedded = {
21
      ruby: "ruby",
22
      javascript: "javascript",
23
      css: "text/css",
24
      sass: "text/x-sass",
25
      scss: "text/x-scss",
26
      less: "text/x-less",
27
      styl: "text/x-styl", // no highlighting so far
28
      coffee: "coffeescript",
29
      asciidoc: "text/x-asciidoc",
30
      markdown: "text/x-markdown",
31
      textile: "text/x-textile", // no highlighting so far
32
      creole: "text/x-creole", // no highlighting so far
33
      wiki: "text/x-wiki", // no highlighting so far
34
      mediawiki: "text/x-mediawiki", // no highlighting so far
35
      rdoc: "text/x-rdoc", // no highlighting so far
36
      builder: "text/x-builder", // no highlighting so far
37
      nokogiri: "text/x-nokogiri", // no highlighting so far
38
      erb: "application/x-erb"
39
    };
40
    var embeddedRegexp = function(map){
41
      var arr = [];
42
      for(var key in map) arr.push(key);
43
      return new RegExp("^("+arr.join('|')+"):");
44
    }(embedded);
45

46
    var styleMap = {
47
      "commentLine": "comment",
48
      "slimSwitch": "operator special",
49
      "slimTag": "tag",
50
      "slimId": "attribute def",
51
      "slimClass": "attribute qualifier",
52
      "slimAttribute": "attribute",
53
      "slimSubmode": "keyword special",
54
      "closeAttributeTag": null,
55
      "slimDoctype": null,
56
      "lineContinuation": null
57
    };
58
    var closing = {
59
      "{": "}",
60
      "[": "]",
61
      "(": ")"
62
    };
63

64
    var nameStartChar = "_a-zA-Z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD";
65
    var nameChar = nameStartChar + "\\-0-9\xB7\u0300-\u036F\u203F-\u2040";
66
    var nameRegexp = new RegExp("^[:"+nameStartChar+"](?::["+nameChar+"]|["+nameChar+"]*)");
67
    var attributeNameRegexp = new RegExp("^[:"+nameStartChar+"][:\\."+nameChar+"]*(?=\\s*=)");
68
    var wrappedAttributeNameRegexp = new RegExp("^[:"+nameStartChar+"][:\\."+nameChar+"]*");
69
    var classNameRegexp = /^\.-?[_a-zA-Z]+[\w\-]*/;
70
    var classIdRegexp = /^#[_a-zA-Z]+[\w\-]*/;
71

72
    function backup(pos, tokenize, style) {
73
      var restore = function(stream, state) {
74
        state.tokenize = tokenize;
75
        if (stream.pos < pos) {
76
          stream.pos = pos;
77
          return style;
78
        }
79
        return state.tokenize(stream, state);
80
      };
81
      return function(stream, state) {
82
        state.tokenize = restore;
83
        return tokenize(stream, state);
84
      };
85
    }
86

87
    function maybeBackup(stream, state, pat, offset, style) {
88
      var cur = stream.current();
89
      var idx = cur.search(pat);
90
      if (idx > -1) {
91
        state.tokenize = backup(stream.pos, state.tokenize, style);
92
        stream.backUp(cur.length - idx - offset);
93
      }
94
      return style;
95
    }
96

97
    function continueLine(state, column) {
98
      state.stack = {
99
        parent: state.stack,
100
        style: "continuation",
101
        indented: column,
102
        tokenize: state.line
103
      };
104
      state.line = state.tokenize;
105
    }
106
    function finishContinue(state) {
107
      if (state.line == state.tokenize) {
108
        state.line = state.stack.tokenize;
109
        state.stack = state.stack.parent;
110
      }
111
    }
112

113
    function lineContinuable(column, tokenize) {
114
      return function(stream, state) {
115
        finishContinue(state);
116
        if (stream.match(/^\\$/)) {
117
          continueLine(state, column);
118
          return "lineContinuation";
119
        }
120
        var style = tokenize(stream, state);
121
        if (stream.eol() && stream.current().match(/(?:^|[^\\])(?:\\\\)*\\$/)) {
122
          stream.backUp(1);
123
        }
124
        return style;
125
      };
126
    }
127
    function commaContinuable(column, tokenize) {
128
      return function(stream, state) {
129
        finishContinue(state);
130
        var style = tokenize(stream, state);
131
        if (stream.eol() && stream.current().match(/,$/)) {
132
          continueLine(state, column);
133
        }
134
        return style;
135
      };
136
    }
137

138
    function rubyInQuote(endQuote, tokenize) {
139
      // TODO: add multi line support
140
      return function(stream, state) {
141
        var ch = stream.peek();
142
        if (ch == endQuote && state.rubyState.tokenize.length == 1) {
143
          // step out of ruby context as it seems to complete processing all the braces
144
          stream.next();
145
          state.tokenize = tokenize;
146
          return "closeAttributeTag";
147
        } else {
148
          return ruby(stream, state);
149
        }
150
      };
151
    }
152
    function startRubySplat(tokenize) {
153
      var rubyState;
154
      var runSplat = function(stream, state) {
155
        if (state.rubyState.tokenize.length == 1 && !state.rubyState.context.prev) {
156
          stream.backUp(1);
157
          if (stream.eatSpace()) {
158
            state.rubyState = rubyState;
159
            state.tokenize = tokenize;
160
            return tokenize(stream, state);
161
          }
162
          stream.next();
163
        }
164
        return ruby(stream, state);
165
      };
166
      return function(stream, state) {
167
        rubyState = state.rubyState;
168
        state.rubyState = CodeMirror.startState(rubyMode);
169
        state.tokenize = runSplat;
170
        return ruby(stream, state);
171
      };
172
    }
173

174
    function ruby(stream, state) {
175
      return rubyMode.token(stream, state.rubyState);
176
    }
177

178
    function htmlLine(stream, state) {
179
      if (stream.match(/^\\$/)) {
180
        return "lineContinuation";
181
      }
182
      return html(stream, state);
183
    }
184
    function html(stream, state) {
185
      if (stream.match(/^#\{/)) {
186
        state.tokenize = rubyInQuote("}", state.tokenize);
187
        return null;
188
      }
189
      return maybeBackup(stream, state, /[^\\]#\{/, 1, htmlMode.token(stream, state.htmlState));
190
    }
191

192
    function startHtmlLine(lastTokenize) {
193
      return function(stream, state) {
194
        var style = htmlLine(stream, state);
195
        if (stream.eol()) state.tokenize = lastTokenize;
196
        return style;
197
      };
198
    }
199

200
    function startHtmlMode(stream, state, offset) {
201
      state.stack = {
202
        parent: state.stack,
203
        style: "html",
204
        indented: stream.column() + offset, // pipe + space
205
        tokenize: state.line
206
      };
207
      state.line = state.tokenize = html;
208
      return null;
209
    }
210

211
    function comment(stream, state) {
212
      stream.skipToEnd();
213
      return state.stack.style;
214
    }
215

216
    function commentMode(stream, state) {
217
      state.stack = {
218
        parent: state.stack,
219
        style: "comment",
220
        indented: state.indented + 1,
221
        tokenize: state.line
222
      };
223
      state.line = comment;
224
      return comment(stream, state);
225
    }
226

227
    function attributeWrapper(stream, state) {
228
      if (stream.eat(state.stack.endQuote)) {
229
        state.line = state.stack.line;
230
        state.tokenize = state.stack.tokenize;
231
        state.stack = state.stack.parent;
232
        return null;
233
      }
234
      if (stream.match(wrappedAttributeNameRegexp)) {
235
        state.tokenize = attributeWrapperAssign;
236
        return "slimAttribute";
237
      }
238
      stream.next();
239
      return null;
240
    }
241
    function attributeWrapperAssign(stream, state) {
242
      if (stream.match(/^==?/)) {
243
        state.tokenize = attributeWrapperValue;
244
        return null;
245
      }
246
      return attributeWrapper(stream, state);
247
    }
248
    function attributeWrapperValue(stream, state) {
249
      var ch = stream.peek();
250
      if (ch == '"' || ch == "\'") {
251
        state.tokenize = readQuoted(ch, "string", true, false, attributeWrapper);
252
        stream.next();
253
        return state.tokenize(stream, state);
254
      }
255
      if (ch == '[') {
256
        return startRubySplat(attributeWrapper)(stream, state);
257
      }
258
      if (stream.match(/^(true|false|nil)\b/)) {
259
        state.tokenize = attributeWrapper;
260
        return "keyword";
261
      }
262
      return startRubySplat(attributeWrapper)(stream, state);
263
    }
264

265
    function startAttributeWrapperMode(state, endQuote, tokenize) {
266
      state.stack = {
267
        parent: state.stack,
268
        style: "wrapper",
269
        indented: state.indented + 1,
270
        tokenize: tokenize,
271
        line: state.line,
272
        endQuote: endQuote
273
      };
274
      state.line = state.tokenize = attributeWrapper;
275
      return null;
276
    }
277

278
    function sub(stream, state) {
279
      if (stream.match(/^#\{/)) {
280
        state.tokenize = rubyInQuote("}", state.tokenize);
281
        return null;
282
      }
283
      var subStream = new CodeMirror.StringStream(stream.string.slice(state.stack.indented), stream.tabSize);
284
      subStream.pos = stream.pos - state.stack.indented;
285
      subStream.start = stream.start - state.stack.indented;
286
      subStream.lastColumnPos = stream.lastColumnPos - state.stack.indented;
287
      subStream.lastColumnValue = stream.lastColumnValue - state.stack.indented;
288
      var style = state.subMode.token(subStream, state.subState);
289
      stream.pos = subStream.pos + state.stack.indented;
290
      return style;
291
    }
292
    function firstSub(stream, state) {
293
      state.stack.indented = stream.column();
294
      state.line = state.tokenize = sub;
295
      return state.tokenize(stream, state);
296
    }
297

298
    function createMode(mode) {
299
      var query = embedded[mode];
300
      var spec = CodeMirror.mimeModes[query];
301
      if (spec) {
302
        return CodeMirror.getMode(config, spec);
303
      }
304
      var factory = CodeMirror.modes[query];
305
      if (factory) {
306
        return factory(config, {name: query});
307
      }
308
      return CodeMirror.getMode(config, "null");
309
    }
310

311
    function getMode(mode) {
312
      if (!modes.hasOwnProperty(mode)) {
313
        return modes[mode] = createMode(mode);
314
      }
315
      return modes[mode];
316
    }
317

318
    function startSubMode(mode, state) {
319
      var subMode = getMode(mode);
320
      var subState = CodeMirror.startState(subMode);
321

322
      state.subMode = subMode;
323
      state.subState = subState;
324

325
      state.stack = {
326
        parent: state.stack,
327
        style: "sub",
328
        indented: state.indented + 1,
329
        tokenize: state.line
330
      };
331
      state.line = state.tokenize = firstSub;
332
      return "slimSubmode";
333
    }
334

335
    function doctypeLine(stream, _state) {
336
      stream.skipToEnd();
337
      return "slimDoctype";
338
    }
339

340
    function startLine(stream, state) {
341
      var ch = stream.peek();
342
      if (ch == '<') {
343
        return (state.tokenize = startHtmlLine(state.tokenize))(stream, state);
344
      }
345
      if (stream.match(/^[|']/)) {
346
        return startHtmlMode(stream, state, 1);
347
      }
348
      if (stream.match(/^\/(!|\[\w+])?/)) {
349
        return commentMode(stream, state);
350
      }
351
      if (stream.match(/^(-|==?[<>]?)/)) {
352
        state.tokenize = lineContinuable(stream.column(), commaContinuable(stream.column(), ruby));
353
        return "slimSwitch";
354
      }
355
      if (stream.match(/^doctype\b/)) {
356
        state.tokenize = doctypeLine;
357
        return "keyword";
358
      }
359

360
      var m = stream.match(embeddedRegexp);
361
      if (m) {
362
        return startSubMode(m[1], state);
363
      }
364

365
      return slimTag(stream, state);
366
    }
367

368
    function slim(stream, state) {
369
      if (state.startOfLine) {
370
        return startLine(stream, state);
371
      }
372
      return slimTag(stream, state);
373
    }
374

375
    function slimTag(stream, state) {
376
      if (stream.eat('*')) {
377
        state.tokenize = startRubySplat(slimTagExtras);
378
        return null;
379
      }
380
      if (stream.match(nameRegexp)) {
381
        state.tokenize = slimTagExtras;
382
        return "slimTag";
383
      }
384
      return slimClass(stream, state);
385
    }
386
    function slimTagExtras(stream, state) {
387
      if (stream.match(/^(<>?|><?)/)) {
388
        state.tokenize = slimClass;
389
        return null;
390
      }
391
      return slimClass(stream, state);
392
    }
393
    function slimClass(stream, state) {
394
      if (stream.match(classIdRegexp)) {
395
        state.tokenize = slimClass;
396
        return "slimId";
397
      }
398
      if (stream.match(classNameRegexp)) {
399
        state.tokenize = slimClass;
400
        return "slimClass";
401
      }
402
      return slimAttribute(stream, state);
403
    }
404
    function slimAttribute(stream, state) {
405
      if (stream.match(/^([\[\{\(])/)) {
406
        return startAttributeWrapperMode(state, closing[RegExp.$1], slimAttribute);
407
      }
408
      if (stream.match(attributeNameRegexp)) {
409
        state.tokenize = slimAttributeAssign;
410
        return "slimAttribute";
411
      }
412
      if (stream.peek() == '*') {
413
        stream.next();
414
        state.tokenize = startRubySplat(slimContent);
415
        return null;
416
      }
417
      return slimContent(stream, state);
418
    }
419
    function slimAttributeAssign(stream, state) {
420
      if (stream.match(/^==?/)) {
421
        state.tokenize = slimAttributeValue;
422
        return null;
423
      }
424
      // should never happen, because of forward lookup
425
      return slimAttribute(stream, state);
426
    }
427

428
    function slimAttributeValue(stream, state) {
429
      var ch = stream.peek();
430
      if (ch == '"' || ch == "\'") {
431
        state.tokenize = readQuoted(ch, "string", true, false, slimAttribute);
432
        stream.next();
433
        return state.tokenize(stream, state);
434
      }
435
      if (ch == '[') {
436
        return startRubySplat(slimAttribute)(stream, state);
437
      }
438
      if (ch == ':') {
439
        return startRubySplat(slimAttributeSymbols)(stream, state);
440
      }
441
      if (stream.match(/^(true|false|nil)\b/)) {
442
        state.tokenize = slimAttribute;
443
        return "keyword";
444
      }
445
      return startRubySplat(slimAttribute)(stream, state);
446
    }
447
    function slimAttributeSymbols(stream, state) {
448
      stream.backUp(1);
449
      if (stream.match(/^[^\s],(?=:)/)) {
450
        state.tokenize = startRubySplat(slimAttributeSymbols);
451
        return null;
452
      }
453
      stream.next();
454
      return slimAttribute(stream, state);
455
    }
456
    function readQuoted(quote, style, embed, unescaped, nextTokenize) {
457
      return function(stream, state) {
458
        finishContinue(state);
459
        var fresh = stream.current().length == 0;
460
        if (stream.match(/^\\$/, fresh)) {
461
          if (!fresh) return style;
462
          continueLine(state, state.indented);
463
          return "lineContinuation";
464
        }
465
        if (stream.match(/^#\{/, fresh)) {
466
          if (!fresh) return style;
467
          state.tokenize = rubyInQuote("}", state.tokenize);
468
          return null;
469
        }
470
        var escaped = false, ch;
471
        while ((ch = stream.next()) != null) {
472
          if (ch == quote && (unescaped || !escaped)) {
473
            state.tokenize = nextTokenize;
474
            break;
475
          }
476
          if (embed && ch == "#" && !escaped) {
477
            if (stream.eat("{")) {
478
              stream.backUp(2);
479
              break;
480
            }
481
          }
482
          escaped = !escaped && ch == "\\";
483
        }
484
        if (stream.eol() && escaped) {
485
          stream.backUp(1);
486
        }
487
        return style;
488
      };
489
    }
490
    function slimContent(stream, state) {
491
      if (stream.match(/^==?/)) {
492
        state.tokenize = ruby;
493
        return "slimSwitch";
494
      }
495
      if (stream.match(/^\/$/)) { // tag close hint
496
        state.tokenize = slim;
497
        return null;
498
      }
499
      if (stream.match(/^:/)) { // inline tag
500
        state.tokenize = slimTag;
501
        return "slimSwitch";
502
      }
503
      startHtmlMode(stream, state, 0);
504
      return state.tokenize(stream, state);
505
    }
506

507
    var mode = {
508
      // default to html mode
509
      startState: function() {
510
        var htmlState = CodeMirror.startState(htmlMode);
511
        var rubyState = CodeMirror.startState(rubyMode);
512
        return {
513
          htmlState: htmlState,
514
          rubyState: rubyState,
515
          stack: null,
516
          last: null,
517
          tokenize: slim,
518
          line: slim,
519
          indented: 0
520
        };
521
      },
522

523
      copyState: function(state) {
524
        return {
525
          htmlState : CodeMirror.copyState(htmlMode, state.htmlState),
526
          rubyState: CodeMirror.copyState(rubyMode, state.rubyState),
527
          subMode: state.subMode,
528
          subState: state.subMode && CodeMirror.copyState(state.subMode, state.subState),
529
          stack: state.stack,
530
          last: state.last,
531
          tokenize: state.tokenize,
532
          line: state.line
533
        };
534
      },
535

536
      token: function(stream, state) {
537
        if (stream.sol()) {
538
          state.indented = stream.indentation();
539
          state.startOfLine = true;
540
          state.tokenize = state.line;
541
          while (state.stack && state.stack.indented > state.indented && state.last != "slimSubmode") {
542
            state.line = state.tokenize = state.stack.tokenize;
543
            state.stack = state.stack.parent;
544
            state.subMode = null;
545
            state.subState = null;
546
          }
547
        }
548
        if (stream.eatSpace()) return null;
549
        var style = state.tokenize(stream, state);
550
        state.startOfLine = false;
551
        if (style) state.last = style;
552
        return styleMap.hasOwnProperty(style) ? styleMap[style] : style;
553
      },
554

555
      blankLine: function(state) {
556
        if (state.subMode && state.subMode.blankLine) {
557
          return state.subMode.blankLine(state.subState);
558
        }
559
      },
560

561
      innerMode: function(state) {
562
        if (state.subMode) return {state: state.subState, mode: state.subMode};
563
        return {state: state, mode: mode};
564
      }
565

566
      //indent: function(state) {
567
      //  return state.indented;
568
      //}
569
    };
570
    return mode;
571
  }, "htmlmixed", "ruby");
572

573
  CodeMirror.defineMIME("text/x-slim", "slim");
574
  CodeMirror.defineMIME("application/x-slim", "slim");
575
});
576