|
1
|
ace.define("ace/mode/crystal_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"], function (require, exports, module) {
|
|
2
|
"use strict";
|
|
3
|
|
|
4
|
var oop = require("../lib/oop");
|
|
5
|
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
|
|
6
|
|
|
7
|
var CrystalHighlightRules = function () {
|
|
8
|
|
|
9
|
var builtinFunctions = (
|
|
10
|
"puts|initialize|previous_def|typeof|as|pointerof|sizeof|instance_sizeof"
|
|
11
|
);
|
|
12
|
|
|
13
|
var keywords = (
|
|
14
|
"if|end|else|elsif|unless|case|when|break|while|next|until|def|return|class|new|getter|setter|property|lib"
|
|
15
|
+ "|fun|do|struct|private|protected|public|module|super|abstract|include|extend|begin|enum|raise|yield|with"
|
|
16
|
+ "|alias|rescue|ensure|macro|uninitialized|union|type|require"
|
|
17
|
);
|
|
18
|
|
|
19
|
var buildinConstants = (
|
|
20
|
"true|TRUE|false|FALSE|nil|NIL|__LINE__|__END_LINE__|__FILE__|__DIR__"
|
|
21
|
);
|
|
22
|
|
|
23
|
var builtinVariables = (
|
|
24
|
"$DEBUG|$defout|$FILENAME|$LOAD_PATH|$SAFE|$stdin|$stdout|$stderr|$VERBOSE|" +
|
|
25
|
"root_url|flash|session|cookies|params|request|response|logger|self"
|
|
26
|
);
|
|
27
|
|
|
28
|
var keywordMapper = this.$keywords = this.createKeywordMapper({
|
|
29
|
"keyword": keywords,
|
|
30
|
"constant.language": buildinConstants,
|
|
31
|
"variable.language": builtinVariables,
|
|
32
|
"support.function": builtinFunctions
|
|
33
|
}, "identifier");
|
|
34
|
|
|
35
|
var hexNumber = "(?:0[xX][\\dA-Fa-f]+)";
|
|
36
|
var decNumber = "(?:[0-9][\\d_]*)";
|
|
37
|
var octNumber = "(?:0o[0-7][0-7]*)";
|
|
38
|
var binNumber = "(?:0[bB][01]+)";
|
|
39
|
var intNumber = "(?:[+-]?)(?:" + hexNumber + "|" + decNumber + "|" + octNumber + "|" + binNumber + ")(?:_?[iIuU](?:8|16|32|64))?\\b";
|
|
40
|
var escapeExpression = /\\(?:[nsrtvfbae'"\\]|[0-7]{3}|x[\da-fA-F]{2}|u[\da-fA-F]{4}|u{[\da-fA-F]{1,6}})/;
|
|
41
|
var extEscapeExspresssion = /\\(?:[nsrtvfbae'"\\]|[0-7]{3}|x[\da-fA-F]{2}|u[\da-fA-F]{4}|u{[\da-fA-F]{1,6}}|u{(:?[\da-fA-F]{2}\s)*[\da-fA-F]{2}})/;
|
|
42
|
|
|
43
|
this.$rules = {
|
|
44
|
"start": [
|
|
45
|
{
|
|
46
|
token: "comment",
|
|
47
|
regex: "#.*$"
|
|
48
|
}, {
|
|
49
|
token: "string.regexp",
|
|
50
|
regex: "[/]",
|
|
51
|
push: [{
|
|
52
|
token: "constant.language.escape",
|
|
53
|
regex: extEscapeExspresssion
|
|
54
|
}, {
|
|
55
|
token: "string.regexp",
|
|
56
|
regex: "[/][imx]*(?=[).,;\\s]|$)",
|
|
57
|
next: "pop"
|
|
58
|
}, {
|
|
59
|
defaultToken: "string.regexp"
|
|
60
|
}]
|
|
61
|
},
|
|
62
|
[{
|
|
63
|
regex: "[{}]", onMatch: function (val, state, stack) {
|
|
64
|
this.next = val == "{" ? this.nextState : "";
|
|
65
|
if (val == "{" && stack.length) {
|
|
66
|
stack.unshift("start", state);
|
|
67
|
return "paren.lparen";
|
|
68
|
}
|
|
69
|
if (val == "}" && stack.length) {
|
|
70
|
stack.shift();
|
|
71
|
this.next = stack.shift();
|
|
72
|
if (this.next.indexOf("string") != -1)
|
|
73
|
return "paren.end";
|
|
74
|
}
|
|
75
|
return val == "{" ? "paren.lparen" : "paren.rparen";
|
|
76
|
},
|
|
77
|
nextState: "start"
|
|
78
|
}, {
|
|
79
|
token: "string.start",
|
|
80
|
regex: /"/,
|
|
81
|
push: [{
|
|
82
|
token: "constant.language.escape",
|
|
83
|
regex: extEscapeExspresssion
|
|
84
|
}, {
|
|
85
|
token: "string",
|
|
86
|
regex: /\\#{/
|
|
87
|
}, {
|
|
88
|
token: "paren.start",
|
|
89
|
regex: /#{/,
|
|
90
|
push: "start"
|
|
91
|
}, {
|
|
92
|
token: "string.end",
|
|
93
|
regex: /"/,
|
|
94
|
next: "pop"
|
|
95
|
}, {
|
|
96
|
defaultToken: "string"
|
|
97
|
}]
|
|
98
|
}, {
|
|
99
|
token: "string.start",
|
|
100
|
regex: /`/,
|
|
101
|
push: [{
|
|
102
|
token: "constant.language.escape",
|
|
103
|
regex: extEscapeExspresssion
|
|
104
|
}, {
|
|
105
|
token: "string",
|
|
106
|
regex: /\\#{/
|
|
107
|
}, {
|
|
108
|
token: "paren.start",
|
|
109
|
regex: /#{/,
|
|
110
|
push: "start"
|
|
111
|
}, {
|
|
112
|
token: "string.end",
|
|
113
|
regex: /`/,
|
|
114
|
next: "pop"
|
|
115
|
}, {
|
|
116
|
defaultToken: "string"
|
|
117
|
}]
|
|
118
|
}, {
|
|
119
|
stateName: "rpstring",
|
|
120
|
token: "string.start",
|
|
121
|
regex: /%[Qx]?\(/,
|
|
122
|
push: [{
|
|
123
|
token: "constant.language.escape",
|
|
124
|
regex: extEscapeExspresssion
|
|
125
|
}, {
|
|
126
|
token: "string.start",
|
|
127
|
regex: /\(/,
|
|
128
|
push: "rpstring"
|
|
129
|
}, {
|
|
130
|
token: "string.end",
|
|
131
|
regex: /\)/,
|
|
132
|
next: "pop"
|
|
133
|
}, {
|
|
134
|
token: "paren.start",
|
|
135
|
regex: /#{/,
|
|
136
|
push: "start"
|
|
137
|
}, {
|
|
138
|
defaultToken: "string"
|
|
139
|
}]
|
|
140
|
}, {
|
|
141
|
stateName: "spstring",
|
|
142
|
token: "string.start",
|
|
143
|
regex: /%[Qx]?\[/,
|
|
144
|
push: [{
|
|
145
|
token: "constant.language.escape",
|
|
146
|
regex: extEscapeExspresssion
|
|
147
|
}, {
|
|
148
|
token: "string.start",
|
|
149
|
regex: /\[/,
|
|
150
|
push: "spstring"
|
|
151
|
}, {
|
|
152
|
token: "string.end",
|
|
153
|
regex: /]/,
|
|
154
|
next: "pop"
|
|
155
|
}, {
|
|
156
|
token: "paren.start",
|
|
157
|
regex: /#{/,
|
|
158
|
push: "start"
|
|
159
|
}, {
|
|
160
|
defaultToken: "string"
|
|
161
|
}]
|
|
162
|
}, {
|
|
163
|
stateName: "fpstring",
|
|
164
|
token: "string.start",
|
|
165
|
regex: /%[Qx]?{/,
|
|
166
|
push: [{
|
|
167
|
token: "constant.language.escape",
|
|
168
|
regex: extEscapeExspresssion
|
|
169
|
}, {
|
|
170
|
token: "string.start",
|
|
171
|
regex: /{/,
|
|
172
|
push: "fpstring"
|
|
173
|
}, {
|
|
174
|
token: "string.end",
|
|
175
|
regex: /}/,
|
|
176
|
next: "pop"
|
|
177
|
}, {
|
|
178
|
token: "paren.start",
|
|
179
|
regex: /#{/,
|
|
180
|
push: "start"
|
|
181
|
}, {
|
|
182
|
defaultToken: "string"
|
|
183
|
}]
|
|
184
|
}, {
|
|
185
|
stateName: "tpstring",
|
|
186
|
token: "string.start",
|
|
187
|
regex: /%[Qx]?</,
|
|
188
|
push: [{
|
|
189
|
token: "constant.language.escape",
|
|
190
|
regex: extEscapeExspresssion
|
|
191
|
}, {
|
|
192
|
token: "string.start",
|
|
193
|
regex: /</,
|
|
194
|
push: "tpstring"
|
|
195
|
}, {
|
|
196
|
token: "string.end",
|
|
197
|
regex: />/,
|
|
198
|
next: "pop"
|
|
199
|
}, {
|
|
200
|
token: "paren.start",
|
|
201
|
regex: /#{/,
|
|
202
|
push: "start"
|
|
203
|
}, {
|
|
204
|
defaultToken: "string"
|
|
205
|
}]
|
|
206
|
}, {
|
|
207
|
stateName: "ppstring",
|
|
208
|
token: "string.start",
|
|
209
|
regex: /%[Qx]?\|/,
|
|
210
|
push: [{
|
|
211
|
token: "constant.language.escape",
|
|
212
|
regex: extEscapeExspresssion
|
|
213
|
}, {
|
|
214
|
token: "string.end",
|
|
215
|
regex: /\|/,
|
|
216
|
next: "pop"
|
|
217
|
}, {
|
|
218
|
token: "paren.start",
|
|
219
|
regex: /#{/,
|
|
220
|
push: "start"
|
|
221
|
}, {
|
|
222
|
defaultToken: "string"
|
|
223
|
}]
|
|
224
|
}, {
|
|
225
|
stateName: "rpqstring",
|
|
226
|
token: "string.start",
|
|
227
|
regex: /%[qwir]\(/,
|
|
228
|
push: [{
|
|
229
|
token: "string.start",
|
|
230
|
regex: /\(/,
|
|
231
|
push: "rpqstring"
|
|
232
|
}, {
|
|
233
|
token: "string.end",
|
|
234
|
regex: /\)/,
|
|
235
|
next: "pop"
|
|
236
|
}, {
|
|
237
|
defaultToken: "string"
|
|
238
|
}]
|
|
239
|
}, {
|
|
240
|
stateName: "spqstring",
|
|
241
|
token: "string.start",
|
|
242
|
regex: /%[qwir]\[/,
|
|
243
|
push: [{
|
|
244
|
token: "string.start",
|
|
245
|
regex: /\[/,
|
|
246
|
push: "spqstring"
|
|
247
|
}, {
|
|
248
|
token: "string.end",
|
|
249
|
regex: /]/,
|
|
250
|
next: "pop"
|
|
251
|
}, {
|
|
252
|
defaultToken: "string"
|
|
253
|
}]
|
|
254
|
}, {
|
|
255
|
stateName: "fpqstring",
|
|
256
|
token: "string.start",
|
|
257
|
regex: /%[qwir]{/,
|
|
258
|
push: [{
|
|
259
|
token: "string.start",
|
|
260
|
regex: /{/,
|
|
261
|
push: "fpqstring"
|
|
262
|
}, {
|
|
263
|
token: "string.end",
|
|
264
|
regex: /}/,
|
|
265
|
next: "pop"
|
|
266
|
}, {
|
|
267
|
defaultToken: "string"
|
|
268
|
}]
|
|
269
|
}, {
|
|
270
|
stateName: "tpqstring",
|
|
271
|
token: "string.start",
|
|
272
|
regex: /%[qwir]</,
|
|
273
|
push: [{
|
|
274
|
token: "string.start",
|
|
275
|
regex: /</,
|
|
276
|
push: "tpqstring"
|
|
277
|
}, {
|
|
278
|
token: "string.end",
|
|
279
|
regex: />/,
|
|
280
|
next: "pop"
|
|
281
|
}, {
|
|
282
|
defaultToken: "string"
|
|
283
|
}]
|
|
284
|
}, {
|
|
285
|
stateName: "ppqstring",
|
|
286
|
token: "string.start",
|
|
287
|
regex: /%[qwir]\|/,
|
|
288
|
push: [{
|
|
289
|
token: "string.end",
|
|
290
|
regex: /\|/,
|
|
291
|
next: "pop"
|
|
292
|
}, {
|
|
293
|
defaultToken: "string"
|
|
294
|
}]
|
|
295
|
}, {
|
|
296
|
token: "string.start",
|
|
297
|
regex: /'/,
|
|
298
|
push: [{
|
|
299
|
token: "constant.language.escape",
|
|
300
|
regex: escapeExpression
|
|
301
|
}, {
|
|
302
|
token: "string.end",
|
|
303
|
regex: /'|$/,
|
|
304
|
next: "pop"
|
|
305
|
}, {
|
|
306
|
defaultToken: "string"
|
|
307
|
}]
|
|
308
|
}], {
|
|
309
|
token: "text", // namespaces aren't symbols
|
|
310
|
regex: "::"
|
|
311
|
}, {
|
|
312
|
token: "variable.instance", // instance variable
|
|
313
|
regex: "@{1,2}[a-zA-Z_\\d]+"
|
|
314
|
}, {
|
|
315
|
token: "variable.fresh", // fresh variable
|
|
316
|
regex: "%[a-zA-Z_\\d]+"
|
|
317
|
}, {
|
|
318
|
token: "support.class", // class name
|
|
319
|
regex: "[A-Z][a-zA-Z_\\d]+"
|
|
320
|
}, {
|
|
321
|
token: "constant.other.symbol", // symbol
|
|
322
|
regex: "[:](?:(?:===|<=>|\\[]\\?|\\[]=|\\[]|>>|\\*\\*|<<|==|!=|>=|<=|!~|=~|<|\\+|-|\\*|\\/|%|&|\\||\\^|>|!|~)|(?:(?:[A-Za-z_]|[@$](?=[a-zA-Z0-9_]))[a-zA-Z0-9_]*[!=?]?))"
|
|
323
|
}, {
|
|
324
|
token: "constant.numeric", // float
|
|
325
|
regex: "[+-]?\\d(?:\\d|_(?=\\d))*(?:(?:\\.\\d(?:\\d|_(?=\\d))*)?(?:[eE][+-]?\\d+)?)?(?:_?[fF](?:32|64))?\\b"
|
|
326
|
}, {
|
|
327
|
token: "constant.numeric",
|
|
328
|
regex: intNumber
|
|
329
|
}, {
|
|
330
|
token: "constant.other.symbol",
|
|
331
|
regex: ':"',
|
|
332
|
push: [{
|
|
333
|
token: "constant.language.escape",
|
|
334
|
regex: extEscapeExspresssion
|
|
335
|
}, {
|
|
336
|
token: "constant.other.symbol",
|
|
337
|
regex: '"',
|
|
338
|
next: "pop"
|
|
339
|
}, {
|
|
340
|
defaultToken: "constant.other.symbol"
|
|
341
|
}]
|
|
342
|
}, {
|
|
343
|
token: "constant.language.boolean",
|
|
344
|
regex: "(?:true|false)\\b"
|
|
345
|
}, {
|
|
346
|
token: "support.function",
|
|
347
|
regex: "(?:is_a\\?|nil\\?|responds_to\\?|as\\?)"
|
|
348
|
}, {
|
|
349
|
token: keywordMapper,
|
|
350
|
regex: "[a-zA-Z_$][a-zA-Z0-9_$!?]*\\b"
|
|
351
|
}, {
|
|
352
|
token: "variable.system",
|
|
353
|
regex: "\\$\\!|\\$\\?"
|
|
354
|
}, {
|
|
355
|
token: "punctuation.separator.key-value",
|
|
356
|
regex: "=>"
|
|
357
|
}, {
|
|
358
|
stateName: "heredoc",
|
|
359
|
onMatch: function (value, currentState, stack) {
|
|
360
|
var next = "heredoc";
|
|
361
|
var tokens = value.split(this.splitRegex);
|
|
362
|
stack.push(next, tokens[3]);
|
|
363
|
return [
|
|
364
|
{type: "constant", value: tokens[1]},
|
|
365
|
{type: "string", value: tokens[2]},
|
|
366
|
{type: "support.class", value: tokens[3]},
|
|
367
|
{type: "string", value: tokens[4]}
|
|
368
|
];
|
|
369
|
},
|
|
370
|
regex: "(<<-)([']?)([\\w]+)([']?)",
|
|
371
|
rules: {
|
|
372
|
heredoc: [{
|
|
373
|
token: "string",
|
|
374
|
regex: "^ +"
|
|
375
|
}, {
|
|
376
|
onMatch: function (value, currentState, stack) {
|
|
377
|
if (value === stack[1]) {
|
|
378
|
stack.shift();
|
|
379
|
stack.shift();
|
|
380
|
this.next = stack[0] || "start";
|
|
381
|
return "support.class";
|
|
382
|
}
|
|
383
|
this.next = "";
|
|
384
|
return "string";
|
|
385
|
},
|
|
386
|
regex: ".*$",
|
|
387
|
next: "start"
|
|
388
|
}]
|
|
389
|
}
|
|
390
|
}, {
|
|
391
|
regex: "$",
|
|
392
|
token: "empty",
|
|
393
|
next: function (currentState, stack) {
|
|
394
|
if (stack[0] === "heredoc")
|
|
395
|
return stack[0];
|
|
396
|
return currentState;
|
|
397
|
}
|
|
398
|
}, {
|
|
399
|
token: "punctuation.operator",
|
|
400
|
regex: /[.]\s*(?![.])/,
|
|
401
|
push: [{
|
|
402
|
token : "punctuation.operator",
|
|
403
|
regex : /[.]\s*(?![.])/
|
|
404
|
}, {
|
|
405
|
token : "support.function",
|
|
406
|
regex : "[a-zA-Z_$][a-zA-Z0-9_$]*\\b"
|
|
407
|
}, {
|
|
408
|
regex: "",
|
|
409
|
token: "empty",
|
|
410
|
next: "pop"
|
|
411
|
}]
|
|
412
|
}, {
|
|
413
|
token: "keyword.operator",
|
|
414
|
regex: "!|\\$|%|&|\\*|\\-\\-|\\-|\\+\\+|\\+|~|===|==|=|!=|!==|<=|>=|<<=|>>=|>>>=|<>|<|>|!|\\?|\\:|&&|\\|\\||\\?\\:|\\*=|%=|\\+=|\\-=|&=|\\^=|\\^|\\|"
|
|
415
|
}, {
|
|
416
|
token: "punctuation.operator",
|
|
417
|
regex: /[?:,;.]/
|
|
418
|
}, {
|
|
419
|
token: "paren.lparen",
|
|
420
|
regex: "[[({]"
|
|
421
|
}, {
|
|
422
|
token: "paren.rparen",
|
|
423
|
regex: "[\\])}]"
|
|
424
|
}, {
|
|
425
|
token: "text",
|
|
426
|
regex: "\\s+"
|
|
427
|
}
|
|
428
|
]
|
|
429
|
};
|
|
430
|
|
|
431
|
this.normalizeRules();
|
|
432
|
};
|
|
433
|
|
|
434
|
oop.inherits(CrystalHighlightRules, TextHighlightRules);
|
|
435
|
|
|
436
|
exports.CrystalHighlightRules = CrystalHighlightRules;
|
|
437
|
});
|
|
438
|
|
|
439
|
ace.define("ace/mode/matching_brace_outdent",["require","exports","module","ace/range"], function(require, exports, module) {
|
|
440
|
"use strict";
|
|
441
|
|
|
442
|
var Range = require("../range").Range;
|
|
443
|
|
|
444
|
var MatchingBraceOutdent = function() {};
|
|
445
|
|
|
446
|
(function() {
|
|
447
|
|
|
448
|
this.checkOutdent = function(line, input) {
|
|
449
|
if (! /^\s+$/.test(line))
|
|
450
|
return false;
|
|
451
|
|
|
452
|
return /^\s*\}/.test(input);
|
|
453
|
};
|
|
454
|
|
|
455
|
this.autoOutdent = function(doc, row) {
|
|
456
|
var line = doc.getLine(row);
|
|
457
|
var match = line.match(/^(\s*\})/);
|
|
458
|
|
|
459
|
if (!match) return 0;
|
|
460
|
|
|
461
|
var column = match[1].length;
|
|
462
|
var openBracePos = doc.findMatchingBracket({row: row, column: column});
|
|
463
|
|
|
464
|
if (!openBracePos || openBracePos.row == row) return 0;
|
|
465
|
|
|
466
|
var indent = this.$getIndent(doc.getLine(openBracePos.row));
|
|
467
|
doc.replace(new Range(row, 0, row, column-1), indent);
|
|
468
|
};
|
|
469
|
|
|
470
|
this.$getIndent = function(line) {
|
|
471
|
return line.match(/^\s*/)[0];
|
|
472
|
};
|
|
473
|
|
|
474
|
}).call(MatchingBraceOutdent.prototype);
|
|
475
|
|
|
476
|
exports.MatchingBraceOutdent = MatchingBraceOutdent;
|
|
477
|
});
|
|
478
|
|
|
479
|
ace.define("ace/mode/folding/coffee",["require","exports","module","ace/lib/oop","ace/mode/folding/fold_mode","ace/range"], function(require, exports, module) {
|
|
480
|
"use strict";
|
|
481
|
|
|
482
|
var oop = require("../../lib/oop");
|
|
483
|
var BaseFoldMode = require("./fold_mode").FoldMode;
|
|
484
|
var Range = require("../../range").Range;
|
|
485
|
|
|
486
|
var FoldMode = exports.FoldMode = function() {};
|
|
487
|
oop.inherits(FoldMode, BaseFoldMode);
|
|
488
|
|
|
489
|
(function() {
|
|
490
|
|
|
491
|
this.getFoldWidgetRange = function(session, foldStyle, row) {
|
|
492
|
var range = this.indentationBlock(session, row);
|
|
493
|
if (range)
|
|
494
|
return range;
|
|
495
|
|
|
496
|
var re = /\S/;
|
|
497
|
var line = session.getLine(row);
|
|
498
|
var startLevel = line.search(re);
|
|
499
|
if (startLevel == -1 || line[startLevel] != "#")
|
|
500
|
return;
|
|
501
|
|
|
502
|
var startColumn = line.length;
|
|
503
|
var maxRow = session.getLength();
|
|
504
|
var startRow = row;
|
|
505
|
var endRow = row;
|
|
506
|
|
|
507
|
while (++row < maxRow) {
|
|
508
|
line = session.getLine(row);
|
|
509
|
var level = line.search(re);
|
|
510
|
|
|
511
|
if (level == -1)
|
|
512
|
continue;
|
|
513
|
|
|
514
|
if (line[level] != "#")
|
|
515
|
break;
|
|
516
|
|
|
517
|
endRow = row;
|
|
518
|
}
|
|
519
|
|
|
520
|
if (endRow > startRow) {
|
|
521
|
var endColumn = session.getLine(endRow).length;
|
|
522
|
return new Range(startRow, startColumn, endRow, endColumn);
|
|
523
|
}
|
|
524
|
};
|
|
525
|
this.getFoldWidget = function(session, foldStyle, row) {
|
|
526
|
var line = session.getLine(row);
|
|
527
|
var indent = line.search(/\S/);
|
|
528
|
var next = session.getLine(row + 1);
|
|
529
|
var prev = session.getLine(row - 1);
|
|
530
|
var prevIndent = prev.search(/\S/);
|
|
531
|
var nextIndent = next.search(/\S/);
|
|
532
|
|
|
533
|
if (indent == -1) {
|
|
534
|
session.foldWidgets[row - 1] = prevIndent!= -1 && prevIndent < nextIndent ? "start" : "";
|
|
535
|
return "";
|
|
536
|
}
|
|
537
|
if (prevIndent == -1) {
|
|
538
|
if (indent == nextIndent && line[indent] == "#" && next[indent] == "#") {
|
|
539
|
session.foldWidgets[row - 1] = "";
|
|
540
|
session.foldWidgets[row + 1] = "";
|
|
541
|
return "start";
|
|
542
|
}
|
|
543
|
} else if (prevIndent == indent && line[indent] == "#" && prev[indent] == "#") {
|
|
544
|
if (session.getLine(row - 2).search(/\S/) == -1) {
|
|
545
|
session.foldWidgets[row - 1] = "start";
|
|
546
|
session.foldWidgets[row + 1] = "";
|
|
547
|
return "";
|
|
548
|
}
|
|
549
|
}
|
|
550
|
|
|
551
|
if (prevIndent!= -1 && prevIndent < indent)
|
|
552
|
session.foldWidgets[row - 1] = "start";
|
|
553
|
else
|
|
554
|
session.foldWidgets[row - 1] = "";
|
|
555
|
|
|
556
|
if (indent < nextIndent)
|
|
557
|
return "start";
|
|
558
|
else
|
|
559
|
return "";
|
|
560
|
};
|
|
561
|
|
|
562
|
}).call(FoldMode.prototype);
|
|
563
|
|
|
564
|
});
|
|
565
|
|
|
566
|
ace.define("ace/mode/crystal",["require","exports","module","ace/lib/oop","ace/mode/text","ace/mode/crystal_highlight_rules","ace/mode/matching_brace_outdent","ace/range","ace/mode/behaviour/cstyle","ace/mode/folding/coffee"], function(require, exports, module) {
|
|
567
|
"use strict";
|
|
568
|
|
|
569
|
var oop = require("../lib/oop");
|
|
570
|
var TextMode = require("./text").Mode;
|
|
571
|
var CrystalHighlightRules = require("./crystal_highlight_rules").CrystalHighlightRules;
|
|
572
|
var MatchingBraceOutdent = require("./matching_brace_outdent").MatchingBraceOutdent;
|
|
573
|
var Range = require("../range").Range;
|
|
574
|
var CstyleBehaviour = require("./behaviour/cstyle").CstyleBehaviour;
|
|
575
|
var FoldMode = require("./folding/coffee").FoldMode;
|
|
576
|
|
|
577
|
var Mode = function() {
|
|
578
|
this.HighlightRules = CrystalHighlightRules;
|
|
579
|
this.$outdent = new MatchingBraceOutdent();
|
|
580
|
this.$behaviour = new CstyleBehaviour();
|
|
581
|
this.foldingRules = new FoldMode();
|
|
582
|
};
|
|
583
|
oop.inherits(Mode, TextMode);
|
|
584
|
|
|
585
|
(function() {
|
|
586
|
|
|
587
|
|
|
588
|
this.lineCommentStart = "#";
|
|
589
|
|
|
590
|
this.getNextLineIndent = function(state, line, tab) {
|
|
591
|
var indent = this.$getIndent(line);
|
|
592
|
|
|
593
|
var tokenizedLine = this.getTokenizer().getLineTokens(line, state);
|
|
594
|
var tokens = tokenizedLine.tokens;
|
|
595
|
|
|
596
|
if (tokens.length && tokens[tokens.length-1].type == "comment") {
|
|
597
|
return indent;
|
|
598
|
}
|
|
599
|
|
|
600
|
if (state == "start") {
|
|
601
|
var match = line.match(/^.*[\{\(\[]\s*$/);
|
|
602
|
var startingClassOrMethod = line.match(/^\s*(class|def|module)\s.*$/);
|
|
603
|
var startingDoBlock = line.match(/.*do(\s*|\s+\|.*\|\s*)$/);
|
|
604
|
var startingConditional = line.match(/^\s*(if|else|when)\s*/);
|
|
605
|
if (match || startingClassOrMethod || startingDoBlock || startingConditional) {
|
|
606
|
indent += tab;
|
|
607
|
}
|
|
608
|
}
|
|
609
|
|
|
610
|
return indent;
|
|
611
|
};
|
|
612
|
|
|
613
|
this.checkOutdent = function(state, line, input) {
|
|
614
|
return /^\s+(end|else)$/.test(line + input) || this.$outdent.checkOutdent(line, input);
|
|
615
|
};
|
|
616
|
|
|
617
|
this.autoOutdent = function(state, session, row) {
|
|
618
|
var line = session.getLine(row);
|
|
619
|
if (/}/.test(line))
|
|
620
|
return this.$outdent.autoOutdent(session, row);
|
|
621
|
var indent = this.$getIndent(line);
|
|
622
|
var prevLine = session.getLine(row - 1);
|
|
623
|
var prevIndent = this.$getIndent(prevLine);
|
|
624
|
var tab = session.getTabString();
|
|
625
|
if (prevIndent.length <= indent.length) {
|
|
626
|
if (indent.slice(-tab.length) == tab)
|
|
627
|
session.remove(new Range(row, indent.length-tab.length, row, indent.length));
|
|
628
|
}
|
|
629
|
};
|
|
630
|
|
|
631
|
this.$id = "ace/mode/crystal";
|
|
632
|
}).call(Mode.prototype);
|
|
633
|
|
|
634
|
exports.Mode = Mode;
|
|
635
|
}); (function() {
|
|
636
|
ace.require(["ace/mode/crystal"], function(m) {
|
|
637
|
if (typeof module == "object" && typeof exports == "object" && module) {
|
|
638
|
module.exports = m;
|
|
639
|
}
|
|
640
|
});
|
|
641
|
})();
|
|
642
|
|