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
  }
12
})(function(CodeMirror) {
13
  "use strict";
14

15
  var TOKEN_STYLES = {
16
    addition: "positive",
17
    attributes: "attribute",
18
    bold: "strong",
19
    cite: "keyword",
20
    code: "atom",
21
    definitionList: "number",
22
    deletion: "negative",
23
    div: "punctuation",
24
    em: "em",
25
    footnote: "variable",
26
    footCite: "qualifier",
27
    header: "header",
28
    html: "comment",
29
    image: "string",
30
    italic: "em",
31
    link: "link",
32
    linkDefinition: "link",
33
    list1: "variable-2",
34
    list2: "variable-3",
35
    list3: "keyword",
36
    notextile: "string-2",
37
    pre: "operator",
38
    p: "property",
39
    quote: "bracket",
40
    span: "quote",
41
    specialChar: "tag",
42
    strong: "strong",
43
    sub: "builtin",
44
    sup: "builtin",
45
    table: "variable-3",
46
    tableHeading: "operator"
47
  };
48

49
  function startNewLine(stream, state) {
50
    state.mode = Modes.newLayout;
51
    state.tableHeading = false;
52

53
    if (state.layoutType === "definitionList" && state.spanningLayout &&
54
        stream.match(RE("definitionListEnd"), false))
55
      state.spanningLayout = false;
56
  }
57

58
  function handlePhraseModifier(stream, state, ch) {
59
    if (ch === "_") {
60
      if (stream.eat("_"))
61
        return togglePhraseModifier(stream, state, "italic", /__/, 2);
62
      else
63
        return togglePhraseModifier(stream, state, "em", /_/, 1);
64
    }
65

66
    if (ch === "*") {
67
      if (stream.eat("*")) {
68
        return togglePhraseModifier(stream, state, "bold", /\*\*/, 2);
69
      }
70
      return togglePhraseModifier(stream, state, "strong", /\*/, 1);
71
    }
72

73
    if (ch === "[") {
74
      if (stream.match(/\d+\]/)) state.footCite = true;
75
      return tokenStyles(state);
76
    }
77

78
    if (ch === "(") {
79
      var spec = stream.match(/^(r|tm|c)\)/);
80
      if (spec)
81
        return tokenStylesWith(state, TOKEN_STYLES.specialChar);
82
    }
83

84
    if (ch === "<" && stream.match(/(\w+)[^>]+>[^<]+<\/\1>/))
85
      return tokenStylesWith(state, TOKEN_STYLES.html);
86

87
    if (ch === "?" && stream.eat("?"))
88
      return togglePhraseModifier(stream, state, "cite", /\?\?/, 2);
89

90
    if (ch === "=" && stream.eat("="))
91
      return togglePhraseModifier(stream, state, "notextile", /==/, 2);
92

93
    if (ch === "-" && !stream.eat("-"))
94
      return togglePhraseModifier(stream, state, "deletion", /-/, 1);
95

96
    if (ch === "+")
97
      return togglePhraseModifier(stream, state, "addition", /\+/, 1);
98

99
    if (ch === "~")
100
      return togglePhraseModifier(stream, state, "sub", /~/, 1);
101

102
    if (ch === "^")
103
      return togglePhraseModifier(stream, state, "sup", /\^/, 1);
104

105
    if (ch === "%")
106
      return togglePhraseModifier(stream, state, "span", /%/, 1);
107

108
    if (ch === "@")
109
      return togglePhraseModifier(stream, state, "code", /@/, 1);
110

111
    if (ch === "!") {
112
      var type = togglePhraseModifier(stream, state, "image", /(?:\([^\)]+\))?!/, 1);
113
      stream.match(/^:\S+/); // optional Url portion
114
      return type;
115
    }
116
    return tokenStyles(state);
117
  }
118

119
  function togglePhraseModifier(stream, state, phraseModifier, closeRE, openSize) {
120
    var charBefore = stream.pos > openSize ? stream.string.charAt(stream.pos - openSize - 1) : null;
121
    var charAfter = stream.peek();
122
    if (state[phraseModifier]) {
123
      if ((!charAfter || /\W/.test(charAfter)) && charBefore && /\S/.test(charBefore)) {
124
        var type = tokenStyles(state);
125
        state[phraseModifier] = false;
126
        return type;
127
      }
128
    } else if ((!charBefore || /\W/.test(charBefore)) && charAfter && /\S/.test(charAfter) &&
129
               stream.match(new RegExp("^.*\\S" + closeRE.source + "(?:\\W|$)"), false)) {
130
      state[phraseModifier] = true;
131
      state.mode = Modes.attributes;
132
    }
133
    return tokenStyles(state);
134
  };
135

136
  function tokenStyles(state) {
137
    var disabled = textileDisabled(state);
138
    if (disabled) return disabled;
139

140
    var styles = [];
141
    if (state.layoutType) styles.push(TOKEN_STYLES[state.layoutType]);
142

143
    styles = styles.concat(activeStyles(
144
      state, "addition", "bold", "cite", "code", "deletion", "em", "footCite",
145
      "image", "italic", "link", "span", "strong", "sub", "sup", "table", "tableHeading"));
146

147
    if (state.layoutType === "header")
148
      styles.push(TOKEN_STYLES.header + "-" + state.header);
149

150
    return styles.length ? styles.join(" ") : null;
151
  }
152

153
  function textileDisabled(state) {
154
    var type = state.layoutType;
155

156
    switch(type) {
157
    case "notextile":
158
    case "code":
159
    case "pre":
160
      return TOKEN_STYLES[type];
161
    default:
162
      if (state.notextile)
163
        return TOKEN_STYLES.notextile + (type ? (" " + TOKEN_STYLES[type]) : "");
164
      return null;
165
    }
166
  }
167

168
  function tokenStylesWith(state, extraStyles) {
169
    var disabled = textileDisabled(state);
170
    if (disabled) return disabled;
171

172
    var type = tokenStyles(state);
173
    if (extraStyles)
174
      return type ? (type + " " + extraStyles) : extraStyles;
175
    else
176
      return type;
177
  }
178

179
  function activeStyles(state) {
180
    var styles = [];
181
    for (var i = 1; i < arguments.length; ++i) {
182
      if (state[arguments[i]])
183
        styles.push(TOKEN_STYLES[arguments[i]]);
184
    }
185
    return styles;
186
  }
187

188
  function blankLine(state) {
189
    var spanningLayout = state.spanningLayout, type = state.layoutType;
190

191
    for (var key in state) if (state.hasOwnProperty(key))
192
      delete state[key];
193

194
    state.mode = Modes.newLayout;
195
    if (spanningLayout) {
196
      state.layoutType = type;
197
      state.spanningLayout = true;
198
    }
199
  }
200

201
  var REs = {
202
    cache: {},
203
    single: {
204
      bc: "bc",
205
      bq: "bq",
206
      definitionList: /- .*?:=+/,
207
      definitionListEnd: /.*=:\s*$/,
208
      div: "div",
209
      drawTable: /\|.*\|/,
210
      foot: /fn\d+/,
211
      header: /h[1-6]/,
212
      html: /\s*<(?:\/)?(\w+)(?:[^>]+)?>(?:[^<]+<\/\1>)?/,
213
      link: /[^"]+":\S/,
214
      linkDefinition: /\[[^\s\]]+\]\S+/,
215
      list: /(?:#+|\*+)/,
216
      notextile: "notextile",
217
      para: "p",
218
      pre: "pre",
219
      table: "table",
220
      tableCellAttributes: /[\/\\]\d+/,
221
      tableHeading: /\|_\./,
222
      tableText: /[^"_\*\[\(\?\+~\^%@|-]+/,
223
      text: /[^!"_=\*\[\(<\?\+~\^%@-]+/
224
    },
225
    attributes: {
226
      align: /(?:<>|<|>|=)/,
227
      selector: /\([^\(][^\)]+\)/,
228
      lang: /\[[^\[\]]+\]/,
229
      pad: /(?:\(+|\)+){1,2}/,
230
      css: /\{[^\}]+\}/
231
    },
232
    createRe: function(name) {
233
      switch (name) {
234
      case "drawTable":
235
        return REs.makeRe("^", REs.single.drawTable, "$");
236
      case "html":
237
        return REs.makeRe("^", REs.single.html, "(?:", REs.single.html, ")*", "$");
238
      case "linkDefinition":
239
        return REs.makeRe("^", REs.single.linkDefinition, "$");
240
      case "listLayout":
241
        return REs.makeRe("^", REs.single.list, RE("allAttributes"), "*\\s+");
242
      case "tableCellAttributes":
243
        return REs.makeRe("^", REs.choiceRe(REs.single.tableCellAttributes,
244
                                            RE("allAttributes")), "+\\.");
245
      case "type":
246
        return REs.makeRe("^", RE("allTypes"));
247
      case "typeLayout":
248
        return REs.makeRe("^", RE("allTypes"), RE("allAttributes"),
249
                          "*\\.\\.?", "(\\s+|$)");
250
      case "attributes":
251
        return REs.makeRe("^", RE("allAttributes"), "+");
252

253
      case "allTypes":
254
        return REs.choiceRe(REs.single.div, REs.single.foot,
255
                            REs.single.header, REs.single.bc, REs.single.bq,
256
                            REs.single.notextile, REs.single.pre, REs.single.table,
257
                            REs.single.para);
258

259
      case "allAttributes":
260
        return REs.choiceRe(REs.attributes.selector, REs.attributes.css,
261
                            REs.attributes.lang, REs.attributes.align, REs.attributes.pad);
262

263
      default:
264
        return REs.makeRe("^", REs.single[name]);
265
      }
266
    },
267
    makeRe: function() {
268
      var pattern = "";
269
      for (var i = 0; i < arguments.length; ++i) {
270
        var arg = arguments[i];
271
        pattern += (typeof arg === "string") ? arg : arg.source;
272
      }
273
      return new RegExp(pattern);
274
    },
275
    choiceRe: function() {
276
      var parts = [arguments[0]];
277
      for (var i = 1; i < arguments.length; ++i) {
278
        parts[i * 2 - 1] = "|";
279
        parts[i * 2] = arguments[i];
280
      }
281

282
      parts.unshift("(?:");
283
      parts.push(")");
284
      return REs.makeRe.apply(null, parts);
285
    }
286
  };
287

288
  function RE(name) {
289
    return (REs.cache[name] || (REs.cache[name] = REs.createRe(name)));
290
  }
291

292
  var Modes = {
293
    newLayout: function(stream, state) {
294
      if (stream.match(RE("typeLayout"), false)) {
295
        state.spanningLayout = false;
296
        return (state.mode = Modes.blockType)(stream, state);
297
      }
298
      var newMode;
299
      if (!textileDisabled(state)) {
300
        if (stream.match(RE("listLayout"), false))
301
          newMode = Modes.list;
302
        else if (stream.match(RE("drawTable"), false))
303
          newMode = Modes.table;
304
        else if (stream.match(RE("linkDefinition"), false))
305
          newMode = Modes.linkDefinition;
306
        else if (stream.match(RE("definitionList")))
307
          newMode = Modes.definitionList;
308
        else if (stream.match(RE("html"), false))
309
          newMode = Modes.html;
310
      }
311
      return (state.mode = (newMode || Modes.text))(stream, state);
312
    },
313

314
    blockType: function(stream, state) {
315
      var match, type;
316
      state.layoutType = null;
317

318
      if (match = stream.match(RE("type")))
319
        type = match[0];
320
      else
321
        return (state.mode = Modes.text)(stream, state);
322

323
      if (match = type.match(RE("header"))) {
324
        state.layoutType = "header";
325
        state.header = parseInt(match[0][1]);
326
      } else if (type.match(RE("bq"))) {
327
        state.layoutType = "quote";
328
      } else if (type.match(RE("bc"))) {
329
        state.layoutType = "code";
330
      } else if (type.match(RE("foot"))) {
331
        state.layoutType = "footnote";
332
      } else if (type.match(RE("notextile"))) {
333
        state.layoutType = "notextile";
334
      } else if (type.match(RE("pre"))) {
335
        state.layoutType = "pre";
336
      } else if (type.match(RE("div"))) {
337
        state.layoutType = "div";
338
      } else if (type.match(RE("table"))) {
339
        state.layoutType = "table";
340
      }
341

342
      state.mode = Modes.attributes;
343
      return tokenStyles(state);
344
    },
345

346
    text: function(stream, state) {
347
      if (stream.match(RE("text"))) return tokenStyles(state);
348

349
      var ch = stream.next();
350
      if (ch === '"')
351
        return (state.mode = Modes.link)(stream, state);
352
      return handlePhraseModifier(stream, state, ch);
353
    },
354

355
    attributes: function(stream, state) {
356
      state.mode = Modes.layoutLength;
357

358
      if (stream.match(RE("attributes")))
359
        return tokenStylesWith(state, TOKEN_STYLES.attributes);
360
      else
361
        return tokenStyles(state);
362
    },
363

364
    layoutLength: function(stream, state) {
365
      if (stream.eat(".") && stream.eat("."))
366
        state.spanningLayout = true;
367

368
      state.mode = Modes.text;
369
      return tokenStyles(state);
370
    },
371

372
    list: function(stream, state) {
373
      var match = stream.match(RE("list"));
374
      state.listDepth = match[0].length;
375
      var listMod = (state.listDepth - 1) % 3;
376
      if (!listMod)
377
        state.layoutType = "list1";
378
      else if (listMod === 1)
379
        state.layoutType = "list2";
380
      else
381
        state.layoutType = "list3";
382

383
      state.mode = Modes.attributes;
384
      return tokenStyles(state);
385
    },
386

387
    link: function(stream, state) {
388
      state.mode = Modes.text;
389
      if (stream.match(RE("link"))) {
390
        stream.match(/\S+/);
391
        return tokenStylesWith(state, TOKEN_STYLES.link);
392
      }
393
      return tokenStyles(state);
394
    },
395

396
    linkDefinition: function(stream, state) {
397
      stream.skipToEnd();
398
      return tokenStylesWith(state, TOKEN_STYLES.linkDefinition);
399
    },
400

401
    definitionList: function(stream, state) {
402
      stream.match(RE("definitionList"));
403

404
      state.layoutType = "definitionList";
405

406
      if (stream.match(/\s*$/))
407
        state.spanningLayout = true;
408
      else
409
        state.mode = Modes.attributes;
410

411
      return tokenStyles(state);
412
    },
413

414
    html: function(stream, state) {
415
      stream.skipToEnd();
416
      return tokenStylesWith(state, TOKEN_STYLES.html);
417
    },
418

419
    table: function(stream, state) {
420
      state.layoutType = "table";
421
      return (state.mode = Modes.tableCell)(stream, state);
422
    },
423

424
    tableCell: function(stream, state) {
425
      if (stream.match(RE("tableHeading")))
426
        state.tableHeading = true;
427
      else
428
        stream.eat("|");
429

430
      state.mode = Modes.tableCellAttributes;
431
      return tokenStyles(state);
432
    },
433

434
    tableCellAttributes: function(stream, state) {
435
      state.mode = Modes.tableText;
436

437
      if (stream.match(RE("tableCellAttributes")))
438
        return tokenStylesWith(state, TOKEN_STYLES.attributes);
439
      else
440
        return tokenStyles(state);
441
    },
442

443
    tableText: function(stream, state) {
444
      if (stream.match(RE("tableText")))
445
        return tokenStyles(state);
446

447
      if (stream.peek() === "|") { // end of cell
448
        state.mode = Modes.tableCell;
449
        return tokenStyles(state);
450
      }
451
      return handlePhraseModifier(stream, state, stream.next());
452
    }
453
  };
454

455
  CodeMirror.defineMode("textile", function() {
456
    return {
457
      startState: function() {
458
        return { mode: Modes.newLayout };
459
      },
460
      token: function(stream, state) {
461
        if (stream.sol()) startNewLine(stream, state);
462
        return state.mode(stream, state);
463
      },
464
      blankLine: blankLine
465
    };
466
  });
467

468
  CodeMirror.defineMIME("text/x-textile", "textile");
469
});
470