GPQAPP

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

4
/**
5
 * Link to the project's GitHub page:
6
 * https://github.com/pickhardt/coffeescript-codemirror-mode
7
 */
8
(function(mod) {
9
  if (typeof exports == "object" && typeof module == "object") // CommonJS
10
    mod(require("../../lib/codemirror"));
11
  else if (typeof define == "function" && define.amd) // AMD
12
    define(["../../lib/codemirror"], mod);
13
  else // Plain browser env
14
    mod(CodeMirror);
15
})(function(CodeMirror) {
16
"use strict";
17

18
CodeMirror.defineMode("coffeescript", function(conf, parserConf) {
19
  var ERRORCLASS = "error";
20

21
  function wordRegexp(words) {
22
    return new RegExp("^((" + words.join(")|(") + "))\\b");
23
  }
24

25
  var operators = /^(?:->|=>|\+[+=]?|-[\-=]?|\*[\*=]?|\/[\/=]?|[=!]=|<[><]?=?|>>?=?|%=?|&=?|\|=?|\^=?|\~|!|\?|(or|and|\|\||&&|\?)=)/;
26
  var delimiters = /^(?:[()\[\]{},:`=;]|\.\.?\.?)/;
27
  var identifiers = /^[_A-Za-z$][_A-Za-z$0-9]*/;
28
  var atProp = /^@[_A-Za-z$][_A-Za-z$0-9]*/;
29

30
  var wordOperators = wordRegexp(["and", "or", "not",
31
                                  "is", "isnt", "in",
32
                                  "instanceof", "typeof"]);
33
  var indentKeywords = ["for", "while", "loop", "if", "unless", "else",
34
                        "switch", "try", "catch", "finally", "class"];
35
  var commonKeywords = ["break", "by", "continue", "debugger", "delete",
36
                        "do", "in", "of", "new", "return", "then",
37
                        "this", "@", "throw", "when", "until", "extends"];
38

39
  var keywords = wordRegexp(indentKeywords.concat(commonKeywords));
40

41
  indentKeywords = wordRegexp(indentKeywords);
42

43

44
  var stringPrefixes = /^('{3}|\"{3}|['\"])/;
45
  var regexPrefixes = /^(\/{3}|\/)/;
46
  var commonConstants = ["Infinity", "NaN", "undefined", "null", "true", "false", "on", "off", "yes", "no"];
47
  var constants = wordRegexp(commonConstants);
48

49
  // Tokenizers
50
  function tokenBase(stream, state) {
51
    // Handle scope changes
52
    if (stream.sol()) {
53
      if (state.scope.align === null) state.scope.align = false;
54
      var scopeOffset = state.scope.offset;
55
      if (stream.eatSpace()) {
56
        var lineOffset = stream.indentation();
57
        if (lineOffset > scopeOffset && state.scope.type == "coffee") {
58
          return "indent";
59
        } else if (lineOffset < scopeOffset) {
60
          return "dedent";
61
        }
62
        return null;
63
      } else {
64
        if (scopeOffset > 0) {
65
          dedent(stream, state);
66
        }
67
      }
68
    }
69
    if (stream.eatSpace()) {
70
      return null;
71
    }
72

73
    var ch = stream.peek();
74

75
    // Handle docco title comment (single line)
76
    if (stream.match("####")) {
77
      stream.skipToEnd();
78
      return "comment";
79
    }
80

81
    // Handle multi line comments
82
    if (stream.match("###")) {
83
      state.tokenize = longComment;
84
      return state.tokenize(stream, state);
85
    }
86

87
    // Single line comment
88
    if (ch === "#") {
89
      stream.skipToEnd();
90
      return "comment";
91
    }
92

93
    // Handle number literals
94
    if (stream.match(/^-?[0-9\.]/, false)) {
95
      var floatLiteral = false;
96
      // Floats
97
      if (stream.match(/^-?\d*\.\d+(e[\+\-]?\d+)?/i)) {
98
        floatLiteral = true;
99
      }
100
      if (stream.match(/^-?\d+\.\d*/)) {
101
        floatLiteral = true;
102
      }
103
      if (stream.match(/^-?\.\d+/)) {
104
        floatLiteral = true;
105
      }
106

107
      if (floatLiteral) {
108
        // prevent from getting extra . on 1..
109
        if (stream.peek() == "."){
110
          stream.backUp(1);
111
        }
112
        return "number";
113
      }
114
      // Integers
115
      var intLiteral = false;
116
      // Hex
117
      if (stream.match(/^-?0x[0-9a-f]+/i)) {
118
        intLiteral = true;
119
      }
120
      // Decimal
121
      if (stream.match(/^-?[1-9]\d*(e[\+\-]?\d+)?/)) {
122
        intLiteral = true;
123
      }
124
      // Zero by itself with no other piece of number.
125
      if (stream.match(/^-?0(?![\dx])/i)) {
126
        intLiteral = true;
127
      }
128
      if (intLiteral) {
129
        return "number";
130
      }
131
    }
132

133
    // Handle strings
134
    if (stream.match(stringPrefixes)) {
135
      state.tokenize = tokenFactory(stream.current(), false, "string");
136
      return state.tokenize(stream, state);
137
    }
138
    // Handle regex literals
139
    if (stream.match(regexPrefixes)) {
140
      if (stream.current() != "/" || stream.match(/^.*\//, false)) { // prevent highlight of division
141
        state.tokenize = tokenFactory(stream.current(), true, "string-2");
142
        return state.tokenize(stream, state);
143
      } else {
144
        stream.backUp(1);
145
      }
146
    }
147

148

149

150
    // Handle operators and delimiters
151
    if (stream.match(operators) || stream.match(wordOperators)) {
152
      return "operator";
153
    }
154
    if (stream.match(delimiters)) {
155
      return "punctuation";
156
    }
157

158
    if (stream.match(constants)) {
159
      return "atom";
160
    }
161

162
    if (stream.match(atProp) || state.prop && stream.match(identifiers)) {
163
      return "property";
164
    }
165

166
    if (stream.match(keywords)) {
167
      return "keyword";
168
    }
169

170
    if (stream.match(identifiers)) {
171
      return "variable";
172
    }
173

174
    // Handle non-detected items
175
    stream.next();
176
    return ERRORCLASS;
177
  }
178

179
  function tokenFactory(delimiter, singleline, outclass) {
180
    return function(stream, state) {
181
      while (!stream.eol()) {
182
        stream.eatWhile(/[^'"\/\\]/);
183
        if (stream.eat("\\")) {
184
          stream.next();
185
          if (singleline && stream.eol()) {
186
            return outclass;
187
          }
188
        } else if (stream.match(delimiter)) {
189
          state.tokenize = tokenBase;
190
          return outclass;
191
        } else {
192
          stream.eat(/['"\/]/);
193
        }
194
      }
195
      if (singleline) {
196
        if (parserConf.singleLineStringErrors) {
197
          outclass = ERRORCLASS;
198
        } else {
199
          state.tokenize = tokenBase;
200
        }
201
      }
202
      return outclass;
203
    };
204
  }
205

206
  function longComment(stream, state) {
207
    while (!stream.eol()) {
208
      stream.eatWhile(/[^#]/);
209
      if (stream.match("###")) {
210
        state.tokenize = tokenBase;
211
        break;
212
      }
213
      stream.eatWhile("#");
214
    }
215
    return "comment";
216
  }
217

218
  function indent(stream, state, type) {
219
    type = type || "coffee";
220
    var offset = 0, align = false, alignOffset = null;
221
    for (var scope = state.scope; scope; scope = scope.prev) {
222
      if (scope.type === "coffee" || scope.type == "}") {
223
        offset = scope.offset + conf.indentUnit;
224
        break;
225
      }
226
    }
227
    if (type !== "coffee") {
228
      align = null;
229
      alignOffset = stream.column() + stream.current().length;
230
    } else if (state.scope.align) {
231
      state.scope.align = false;
232
    }
233
    state.scope = {
234
      offset: offset,
235
      type: type,
236
      prev: state.scope,
237
      align: align,
238
      alignOffset: alignOffset
239
    };
240
  }
241

242
  function dedent(stream, state) {
243
    if (!state.scope.prev) return;
244
    if (state.scope.type === "coffee") {
245
      var _indent = stream.indentation();
246
      var matched = false;
247
      for (var scope = state.scope; scope; scope = scope.prev) {
248
        if (_indent === scope.offset) {
249
          matched = true;
250
          break;
251
        }
252
      }
253
      if (!matched) {
254
        return true;
255
      }
256
      while (state.scope.prev && state.scope.offset !== _indent) {
257
        state.scope = state.scope.prev;
258
      }
259
      return false;
260
    } else {
261
      state.scope = state.scope.prev;
262
      return false;
263
    }
264
  }
265

266
  function tokenLexer(stream, state) {
267
    var style = state.tokenize(stream, state);
268
    var current = stream.current();
269

270
    // Handle scope changes.
271
    if (current === "return") {
272
      state.dedent = true;
273
    }
274
    if (((current === "->" || current === "=>") && stream.eol())
275
        || style === "indent") {
276
      indent(stream, state);
277
    }
278
    var delimiter_index = "[({".indexOf(current);
279
    if (delimiter_index !== -1) {
280
      indent(stream, state, "])}".slice(delimiter_index, delimiter_index+1));
281
    }
282
    if (indentKeywords.exec(current)){
283
      indent(stream, state);
284
    }
285
    if (current == "then"){
286
      dedent(stream, state);
287
    }
288

289

290
    if (style === "dedent") {
291
      if (dedent(stream, state)) {
292
        return ERRORCLASS;
293
      }
294
    }
295
    delimiter_index = "])}".indexOf(current);
296
    if (delimiter_index !== -1) {
297
      while (state.scope.type == "coffee" && state.scope.prev)
298
        state.scope = state.scope.prev;
299
      if (state.scope.type == current)
300
        state.scope = state.scope.prev;
301
    }
302
    if (state.dedent && stream.eol()) {
303
      if (state.scope.type == "coffee" && state.scope.prev)
304
        state.scope = state.scope.prev;
305
      state.dedent = false;
306
    }
307

308
    return style;
309
  }
310

311
  var external = {
312
    startState: function(basecolumn) {
313
      return {
314
        tokenize: tokenBase,
315
        scope: {offset:basecolumn || 0, type:"coffee", prev: null, align: false},
316
        prop: false,
317
        dedent: 0
318
      };
319
    },
320

321
    token: function(stream, state) {
322
      var fillAlign = state.scope.align === null && state.scope;
323
      if (fillAlign && stream.sol()) fillAlign.align = false;
324

325
      var style = tokenLexer(stream, state);
326
      if (style && style != "comment") {
327
        if (fillAlign) fillAlign.align = true;
328
        state.prop = style == "punctuation" && stream.current() == "."
329
      }
330

331
      return style;
332
    },
333

334
    indent: function(state, text) {
335
      if (state.tokenize != tokenBase) return 0;
336
      var scope = state.scope;
337
      var closer = text && "])}".indexOf(text.charAt(0)) > -1;
338
      if (closer) while (scope.type == "coffee" && scope.prev) scope = scope.prev;
339
      var closes = closer && scope.type === text.charAt(0);
340
      if (scope.align)
341
        return scope.alignOffset - (closes ? 1 : 0);
342
      else
343
        return (closes ? scope.prev : scope).offset;
344
    },
345

346
    lineComment: "#",
347
    fold: "indent"
348
  };
349
  return external;
350
});
351

352
// IANA registered media type
353
// https://www.iana.org/assignments/media-types/
354
CodeMirror.defineMIME("application/vnd.coffeescript", "coffeescript");
355

356
CodeMirror.defineMIME("text/x-coffeescript", "coffeescript");
357
CodeMirror.defineMIME("text/coffeescript", "coffeescript");
358

359
});
360