← Back to branch summary

~elof-bigestans/lenasys/elofsbranch

« back to all changes in this revision

Viewing changes to js/ace/mode-livescript.js

  • Committer: Gustav Hartvigsson
  • Date: 2013-04-04 18:10:23 UTC
  • mfrom: (12.2.4 lenasys)
  • Revision ID: gustav.hartvigsson@gmail.com-20130404181023-um5z5jx0jwth4hv9
Merging with implementation group 2's branch, containts an error,
will be fixed. (hopefully).

Show diffs side-by-side

added added

removed removed

Lines of Context:
js/ace/mode-livescript.js
 
1
define('ace/mode/livescript', ['require', 'exports', 'module' , 'ace/tokenizer', 'ace/mode/matching_brace_outdent', 'ace/range', 'ace/mode/text'], function(require, exports, module) {
 
2
  var identifier, LiveScriptMode, keywordend, stringfill;
 
3
  identifier = '(?![\\d\\s])[$\\w\\xAA-\\uFFDC](?:(?!\\s)[$\\w\\xAA-\\uFFDC]|-[A-Za-z])*';
 
4
  exports.Mode = LiveScriptMode = (function(superclass){
 
5
    var indenter, prototype = extend$((import$(LiveScriptMode, superclass).displayName = 'LiveScriptMode', LiveScriptMode), superclass).prototype, constructor = LiveScriptMode;
 
6
    function LiveScriptMode(){
 
7
      var that;
 
8
      this.$tokenizer = new (require('ace/tokenizer')).Tokenizer(LiveScriptMode.Rules);
 
9
      if (that = require('ace/mode/matching_brace_outdent')) {
 
10
        this.$outdent = new that.MatchingBraceOutdent;
 
11
      }
 
12
    }
 
13
    indenter = RegExp('(?:[({[=:]|[-~]>|\\b(?:e(?:lse|xport)|d(?:o|efault)|t(?:ry|hen)|finally|import(?:\\s*all)?|const|var|let|new|catch(?:\\s*' + identifier + ')?))\\s*$');
 
14
    prototype.getNextLineIndent = function(state, line, tab){
 
15
      var indent, tokens;
 
16
      indent = this.$getIndent(line);
 
17
      tokens = this.$tokenizer.getLineTokens(line, state).tokens;
 
18
      if (!(tokens.length && tokens[tokens.length - 1].type === 'comment')) {
 
19
        if (state === 'start' && indenter.test(line)) {
 
20
          indent += tab;
 
21
        }
 
22
      }
 
23
      return indent;
 
24
    };
 
25
    prototype.toggleCommentLines = function(state, doc, startRow, endRow){
 
26
      var comment, range, i$, i, out, line;
 
27
      comment = /^(\s*)#/;
 
28
      range = new (require('ace/range')).Range(0, 0, 0, 0);
 
29
      for (i$ = startRow; i$ <= endRow; ++i$) {
 
30
        i = i$;
 
31
        if (out = comment.test(line = doc.getLine(i))) {
 
32
          line = line.replace(comment, '$1');
 
33
        } else {
 
34
          line = line.replace(/^\s*/, '$&#');
 
35
        }
 
36
        range.end.row = range.start.row = i;
 
37
        range.end.column = line.length + 1;
 
38
        doc.replace(range, line);
 
39
      }
 
40
      return 1 - out * 2;
 
41
    };
 
42
    prototype.checkOutdent = function(state, line, input){
 
43
      var ref$;
 
44
      return (ref$ = this.$outdent) != null ? ref$.checkOutdent(line, input) : void 8;
 
45
    };
 
46
    prototype.autoOutdent = function(state, doc, row){
 
47
      var ref$;
 
48
      return (ref$ = this.$outdent) != null ? ref$.autoOutdent(doc, row) : void 8;
 
49
    };
 
50
    return LiveScriptMode;
 
51
  }(require('ace/mode/text').Mode));
 
52
  keywordend = '(?![$\\w]|-[A-Za-z]|\\s*:(?![:=]))';
 
53
  stringfill = {
 
54
    token: 'string',
 
55
    regex: '.+'
 
56
  };
 
57
  LiveScriptMode.Rules = {
 
58
    start: [
 
59
      {
 
60
        token: 'keyword',
 
61
        regex: '(?:t(?:h(?:is|row|en)|ry|ypeof!?)|c(?:on(?:tinue|st)|a(?:se|tch)|lass)|i(?:n(?:stanceof)?|mp(?:ort(?:\\s+all)?|lements)|[fs])|d(?:e(?:fault|lete|bugger)|o)|f(?:or(?:\\s+own)?|inally|unction)|s(?:uper|witch)|e(?:lse|x(?:tends|port)|val)|a(?:nd|rguments)|n(?:ew|ot)|un(?:less|til)|w(?:hile|ith)|o[fr]|return|break|let|var|loop)' + keywordend
 
62
      }, {
 
63
        token: 'constant.language',
 
64
        regex: '(?:true|false|yes|no|on|off|null|void|undefined)' + keywordend
 
65
      }, {
 
66
        token: 'invalid.illegal',
 
67
        regex: '(?:p(?:ackage|r(?:ivate|otected)|ublic)|i(?:mplements|nterface)|enum|static|yield)' + keywordend
 
68
      }, {
 
69
        token: 'language.support.class',
 
70
        regex: '(?:R(?:e(?:gExp|ferenceError)|angeError)|S(?:tring|yntaxError)|E(?:rror|valError)|Array|Boolean|Date|Function|Number|Object|TypeError|URIError)' + keywordend
 
71
      }, {
 
72
        token: 'language.support.function',
 
73
        regex: '(?:is(?:NaN|Finite)|parse(?:Int|Float)|Math|JSON|(?:en|de)codeURI(?:Component)?)' + keywordend
 
74
      }, {
 
75
        token: 'variable.language',
 
76
        regex: '(?:t(?:hat|il|o)|f(?:rom|allthrough)|it|by|e)' + keywordend
 
77
      }, {
 
78
        token: 'identifier',
 
79
        regex: identifier + '\\s*:(?![:=])'
 
80
      }, {
 
81
        token: 'variable',
 
82
        regex: identifier
 
83
      }, {
 
84
        token: 'keyword.operator',
 
85
        regex: '(?:\\.{3}|\\s+\\?)'
 
86
      }, {
 
87
        token: 'keyword.variable',
 
88
        regex: '(?:@+|::|\\.\\.)',
 
89
        next: 'key'
 
90
      }, {
 
91
        token: 'keyword.operator',
 
92
        regex: '\\.\\s*',
 
93
        next: 'key'
 
94
      }, {
 
95
        token: 'string',
 
96
        regex: '\\\\\\S[^\\s,;)}\\]]*'
 
97
      }, {
 
98
        token: 'string.doc',
 
99
        regex: '\'\'\'',
 
100
        next: 'qdoc'
 
101
      }, {
 
102
        token: 'string.doc',
 
103
        regex: '"""',
 
104
        next: 'qqdoc'
 
105
      }, {
 
106
        token: 'string',
 
107
        regex: '\'',
 
108
        next: 'qstring'
 
109
      }, {
 
110
        token: 'string',
 
111
        regex: '"',
 
112
        next: 'qqstring'
 
113
      }, {
 
114
        token: 'string',
 
115
        regex: '`',
 
116
        next: 'js'
 
117
      }, {
 
118
        token: 'string',
 
119
        regex: '<\\[',
 
120
        next: 'words'
 
121
      }, {
 
122
        token: 'string.regex',
 
123
        regex: '//',
 
124
        next: 'heregex'
 
125
      }, {
 
126
        token: 'comment.doc',
 
127
        regex: '/\\*',
 
128
        next: 'comment'
 
129
      }, {
 
130
        token: 'comment',
 
131
        regex: '#.*'
 
132
      }, {
 
133
        token: 'string.regex',
 
134
        regex: '\\/(?:[^[\\/\\n\\\\]*(?:(?:\\\\.|\\[[^\\]\\n\\\\]*(?:\\\\.[^\\]\\n\\\\]*)*\\])[^[\\/\\n\\\\]*)*)\\/[gimy$]{0,4}',
 
135
        next: 'key'
 
136
      }, {
 
137
        token: 'constant.numeric',
 
138
        regex: '(?:0x[\\da-fA-F][\\da-fA-F_]*|(?:[2-9]|[12]\\d|3[0-6])r[\\da-zA-Z][\\da-zA-Z_]*|(?:\\d[\\d_]*(?:\\.\\d[\\d_]*)?|\\.\\d[\\d_]*)(?:e[+-]?\\d[\\d_]*)?[\\w$]*)'
 
139
      }, {
 
140
        token: 'lparen',
 
141
        regex: '[({[]'
 
142
      }, {
 
143
        token: 'rparen',
 
144
        regex: '[)}\\]]',
 
145
        next: 'key'
 
146
      }, {
 
147
        token: 'keyword.operator',
 
148
        regex: '\\S+'
 
149
      }, {
 
150
        token: 'text',
 
151
        regex: '\\s+'
 
152
      }
 
153
    ],
 
154
    heregex: [
 
155
      {
 
156
        token: 'string.regex',
 
157
        regex: '.*?//[gimy$?]{0,4}',
 
158
        next: 'start'
 
159
      }, {
 
160
        token: 'string.regex',
 
161
        regex: '\\s*#{'
 
162
      }, {
 
163
        token: 'comment.regex',
 
164
        regex: '\\s+(?:#.*)?'
 
165
      }, {
 
166
        token: 'string.regex',
 
167
        regex: '\\S+'
 
168
      }
 
169
    ],
 
170
    key: [
 
171
      {
 
172
        token: 'keyword.operator',
 
173
        regex: '[.?@!]+'
 
174
      }, {
 
175
        token: 'identifier',
 
176
        regex: identifier,
 
177
        next: 'start'
 
178
      }, {
 
179
        token: 'text',
 
180
        regex: '.',
 
181
        next: 'start'
 
182
      }
 
183
    ],
 
184
    comment: [
 
185
      {
 
186
        token: 'comment.doc',
 
187
        regex: '.*?\\*/',
 
188
        next: 'start'
 
189
      }, {
 
190
        token: 'comment.doc',
 
191
        regex: '.+'
 
192
      }
 
193
    ],
 
194
    qdoc: [
 
195
      {
 
196
        token: 'string',
 
197
        regex: ".*?'''",
 
198
        next: 'key'
 
199
      }, stringfill
 
200
    ],
 
201
    qqdoc: [
 
202
      {
 
203
        token: 'string',
 
204
        regex: '.*?"""',
 
205
        next: 'key'
 
206
      }, stringfill
 
207
    ],
 
208
    qstring: [
 
209
      {
 
210
        token: 'string',
 
211
        regex: '[^\\\\\']*(?:\\\\.[^\\\\\']*)*\'',
 
212
        next: 'key'
 
213
      }, stringfill
 
214
    ],
 
215
    qqstring: [
 
216
      {
 
217
        token: 'string',
 
218
        regex: '[^\\\\"]*(?:\\\\.[^\\\\"]*)*"',
 
219
        next: 'key'
 
220
      }, stringfill
 
221
    ],
 
222
    js: [
 
223
      {
 
224
        token: 'string',
 
225
        regex: '[^\\\\`]*(?:\\\\.[^\\\\`]*)*`',
 
226
        next: 'key'
 
227
      }, stringfill
 
228
    ],
 
229
    words: [
 
230
      {
 
231
        token: 'string',
 
232
        regex: '.*?\\]>',
 
233
        next: 'key'
 
234
      }, stringfill
 
235
    ]
 
236
  };
 
237
function extend$(sub, sup){
 
238
  function fun(){} fun.prototype = (sub.superclass = sup).prototype;
 
239
  (sub.prototype = new fun).constructor = sub;
 
240
  if (typeof sup.extended == 'function') sup.extended(sub);
 
241
  return sub;
 
242
}
 
243
function import$(obj, src){
 
244
  var own = {}.hasOwnProperty;
 
245
  for (var key in src) if (own.call(src, key)) obj[key] = src[key];
 
246
  return obj;
 
247
}
 
248
});
 
249
 
 
250
define('ace/mode/matching_brace_outdent', ['require', 'exports', 'module' , 'ace/range'], function(require, exports, module) {
 
251
 
 
252
 
 
253
var Range = require("../range").Range;
 
254
 
 
255
var MatchingBraceOutdent = function() {};
 
256
 
 
257
(function() {
 
258
 
 
259
    this.checkOutdent = function(line, input) {
 
260
        if (! /^\s+$/.test(line))
 
261
            return false;
 
262
 
 
263
        return /^\s*\}/.test(input);
 
264
    };
 
265
 
 
266
    this.autoOutdent = function(doc, row) {
 
267
        var line = doc.getLine(row);
 
268
        var match = line.match(/^(\s*\})/);
 
269
 
 
270
        if (!match) return 0;
 
271
 
 
272
        var column = match[1].length;
 
273
        var openBracePos = doc.findMatchingBracket({row: row, column: column});
 
274
 
 
275
        if (!openBracePos || openBracePos.row == row) return 0;
 
276
 
 
277
        var indent = this.$getIndent(doc.getLine(openBracePos.row));
 
278
        doc.replace(new Range(row, 0, row, column-1), indent);
 
279
    };
 
280
 
 
281
    this.$getIndent = function(line) {
 
282
        return line.match(/^\s*/)[0];
 
283
    };
 
284
 
 
285
}).call(MatchingBraceOutdent.prototype);
 
286
 
 
287
exports.MatchingBraceOutdent = MatchingBraceOutdent;
 
288
});