corrade-nucleus-nucleons – Blame information for rev 20

Subversion Repositories:
Rev:
Rev Author Line No. Line
20 office 1 ace.define("ace/mode/elixir_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 ElixirHighlightRules = function() {
8  
9 this.$rules = { start:
10 [ { token:
11 [ 'meta.module.elixir',
12 'keyword.control.module.elixir',
13 'meta.module.elixir',
14 'entity.name.type.module.elixir' ],
15 regex: '^(\\s*)(defmodule)(\\s+)((?:[A-Z]\\w*\\s*\\.\\s*)*[A-Z]\\w*)' },
16 { token: 'comment.documentation.heredoc',
17 regex: '@(?:module|type)?doc (?:~[a-z])?"""',
18 push:
19 [ { token: 'comment.documentation.heredoc',
20 regex: '\\s*"""',
21 next: 'pop' },
22 { include: '#interpolated_elixir' },
23 { include: '#escaped_char' },
24 { defaultToken: 'comment.documentation.heredoc' } ],
25 comment: '@doc with heredocs is treated as documentation' },
26 { token: 'comment.documentation.heredoc',
27 regex: '@(?:module|type)?doc ~[A-Z]"""',
28 push:
29 [ { token: 'comment.documentation.heredoc',
30 regex: '\\s*"""',
31 next: 'pop' },
32 { defaultToken: 'comment.documentation.heredoc' } ],
33 comment: '@doc with heredocs is treated as documentation' },
34 { token: 'comment.documentation.heredoc',
35 regex: '@(?:module|type)?doc (?:~[a-z])?\'\'\'',
36 push:
37 [ { token: 'comment.documentation.heredoc',
38 regex: '\\s*\'\'\'',
39 next: 'pop' },
40 { include: '#interpolated_elixir' },
41 { include: '#escaped_char' },
42 { defaultToken: 'comment.documentation.heredoc' } ],
43 comment: '@doc with heredocs is treated as documentation' },
44 { token: 'comment.documentation.heredoc',
45 regex: '@(?:module|type)?doc ~[A-Z]\'\'\'',
46 push:
47 [ { token: 'comment.documentation.heredoc',
48 regex: '\\s*\'\'\'',
49 next: 'pop' },
50 { defaultToken: 'comment.documentation.heredoc' } ],
51 comment: '@doc with heredocs is treated as documentation' },
52 { token: 'comment.documentation.false',
53 regex: '@(?:module|type)?doc false',
54 comment: '@doc false is treated as documentation' },
55 { token: 'comment.documentation.string',
56 regex: '@(?:module|type)?doc "',
57 push:
58 [ { token: 'comment.documentation.string',
59 regex: '"',
60 next: 'pop' },
61 { include: '#interpolated_elixir' },
62 { include: '#escaped_char' },
63 { defaultToken: 'comment.documentation.string' } ],
64 comment: '@doc with string is treated as documentation' },
65 { token: 'keyword.control.elixir',
66 regex: '\\b(?:do|end|case|bc|lc|for|if|cond|unless|try|receive|fn|defmodule|defp?|defprotocol|defimpl|defrecord|defstruct|defmacrop?|defdelegate|defcallback|defmacrocallback|defexception|defoverridable|exit|after|rescue|catch|else|raise|throw|import|require|alias|use|quote|unquote|super)\\b(?![?!])',
67 TODO: 'FIXME: regexp doesn\'t have js equivalent',
68 originalRegex: '(?<!\\.)\\b(do|end|case|bc|lc|for|if|cond|unless|try|receive|fn|defmodule|defp?|defprotocol|defimpl|defrecord|defstruct|defmacrop?|defdelegate|defcallback|defmacrocallback|defexception|defoverridable|exit|after|rescue|catch|else|raise|throw|import|require|alias|use|quote|unquote|super)\\b(?![?!])' },
69 { token: 'keyword.operator.elixir',
70 regex: '\\b(?:and|not|or|when|xor|in|inlist|inbits)\\b',
71 TODO: 'FIXME: regexp doesn\'t have js equivalent',
72 originalRegex: '(?<!\\.)\\b(and|not|or|when|xor|in|inlist|inbits)\\b',
73 comment: ' as above, just doesn\'t need a \'end\' and does a logic operation' },
74 { token: 'constant.language.elixir',
75 regex: '\\b(?:nil|true|false)\\b(?![?!])' },
76 { token: 'variable.language.elixir',
77 regex: '\\b__(?:CALLER|ENV|MODULE|DIR)__\\b(?![?!])' },
78 { token:
79 [ 'punctuation.definition.variable.elixir',
80 'variable.other.readwrite.module.elixir' ],
81 regex: '(@)([a-zA-Z_]\\w*)' },
82 { token:
83 [ 'punctuation.definition.variable.elixir',
84 'variable.other.anonymous.elixir' ],
85 regex: '(&)(\\d*)' },
86 { token: 'variable.other.constant.elixir',
87 regex: '\\b[A-Z]\\w*\\b' },
88 { token: 'constant.numeric.elixir',
89 regex: '\\b(?:0x[\\da-fA-F](?:_?[\\da-fA-F])*|\\d(?:_?\\d)*(?:\\.(?![^[:space:][:digit:]])(?:_?\\d)*)?(?:[eE][-+]?\\d(?:_?\\d)*)?|0b[01]+|0o[0-7]+)\\b',
90 TODO: 'FIXME: regexp doesn\'t have js equivalent',
91 originalRegex: '\\b(0x\\h(?>_?\\h)*|\\d(?>_?\\d)*(\\.(?![^[:space:][:digit:]])(?>_?\\d)*)?([eE][-+]?\\d(?>_?\\d)*)?|0b[01]+|0o[0-7]+)\\b' },
92 { token: 'punctuation.definition.constant.elixir',
93 regex: ':\'',
94 push:
95 [ { token: 'punctuation.definition.constant.elixir',
96 regex: '\'',
97 next: 'pop' },
98 { include: '#interpolated_elixir' },
99 { include: '#escaped_char' },
100 { defaultToken: 'constant.other.symbol.single-quoted.elixir' } ] },
101 { token: 'punctuation.definition.constant.elixir',
102 regex: ':"',
103 push:
104 [ { token: 'punctuation.definition.constant.elixir',
105 regex: '"',
106 next: 'pop' },
107 { include: '#interpolated_elixir' },
108 { include: '#escaped_char' },
109 { defaultToken: 'constant.other.symbol.double-quoted.elixir' } ] },
110 { token: 'punctuation.definition.string.begin.elixir',
111 regex: '(?:\'\'\')',
112 TODO: 'FIXME: regexp doesn\'t have js equivalent',
113 originalRegex: '(?>\'\'\')',
114 push:
115 [ { token: 'punctuation.definition.string.end.elixir',
116 regex: '^\\s*\'\'\'',
117 next: 'pop' },
118 { include: '#interpolated_elixir' },
119 { include: '#escaped_char' },
120 { defaultToken: 'support.function.variable.quoted.single.heredoc.elixir' } ],
121 comment: 'Single-quoted heredocs' },
122 { token: 'punctuation.definition.string.begin.elixir',
123 regex: '\'',
124 push:
125 [ { token: 'punctuation.definition.string.end.elixir',
126 regex: '\'',
127 next: 'pop' },
128 { include: '#interpolated_elixir' },
129 { include: '#escaped_char' },
130 { defaultToken: 'support.function.variable.quoted.single.elixir' } ],
131 comment: 'single quoted string (allows for interpolation)' },
132 { token: 'punctuation.definition.string.begin.elixir',
133 regex: '(?:""")',
134 TODO: 'FIXME: regexp doesn\'t have js equivalent',
135 originalRegex: '(?>""")',
136 push:
137 [ { token: 'punctuation.definition.string.end.elixir',
138 regex: '^\\s*"""',
139 next: 'pop' },
140 { include: '#interpolated_elixir' },
141 { include: '#escaped_char' },
142 { defaultToken: 'string.quoted.double.heredoc.elixir' } ],
143 comment: 'Double-quoted heredocs' },
144 { token: 'punctuation.definition.string.begin.elixir',
145 regex: '"',
146 push:
147 [ { token: 'punctuation.definition.string.end.elixir',
148 regex: '"',
149 next: 'pop' },
150 { include: '#interpolated_elixir' },
151 { include: '#escaped_char' },
152 { defaultToken: 'string.quoted.double.elixir' } ],
153 comment: 'double quoted string (allows for interpolation)' },
154 { token: 'punctuation.definition.string.begin.elixir',
155 regex: '~[a-z](?:""")',
156 TODO: 'FIXME: regexp doesn\'t have js equivalent',
157 originalRegex: '~[a-z](?>""")',
158 push:
159 [ { token: 'punctuation.definition.string.end.elixir',
160 regex: '^\\s*"""',
161 next: 'pop' },
162 { include: '#interpolated_elixir' },
163 { include: '#escaped_char' },
164 { defaultToken: 'string.quoted.double.heredoc.elixir' } ],
165 comment: 'Double-quoted heredocs sigils' },
166 { token: 'punctuation.definition.string.begin.elixir',
167 regex: '~[a-z]\\{',
168 push:
169 [ { token: 'punctuation.definition.string.end.elixir',
170 regex: '\\}[a-z]*',
171 next: 'pop' },
172 { include: '#interpolated_elixir' },
173 { include: '#escaped_char' },
174 { defaultToken: 'string.interpolated.elixir' } ],
175 comment: 'sigil (allow for interpolation)' },
176 { token: 'punctuation.definition.string.begin.elixir',
177 regex: '~[a-z]\\[',
178 push:
179 [ { token: 'punctuation.definition.string.end.elixir',
180 regex: '\\][a-z]*',
181 next: 'pop' },
182 { include: '#interpolated_elixir' },
183 { include: '#escaped_char' },
184 { defaultToken: 'string.interpolated.elixir' } ],
185 comment: 'sigil (allow for interpolation)' },
186 { token: 'punctuation.definition.string.begin.elixir',
187 regex: '~[a-z]\\<',
188 push:
189 [ { token: 'punctuation.definition.string.end.elixir',
190 regex: '\\>[a-z]*',
191 next: 'pop' },
192 { include: '#interpolated_elixir' },
193 { include: '#escaped_char' },
194 { defaultToken: 'string.interpolated.elixir' } ],
195 comment: 'sigil (allow for interpolation)' },
196 { token: 'punctuation.definition.string.begin.elixir',
197 regex: '~[a-z]\\(',
198 push:
199 [ { token: 'punctuation.definition.string.end.elixir',
200 regex: '\\)[a-z]*',
201 next: 'pop' },
202 { include: '#interpolated_elixir' },
203 { include: '#escaped_char' },
204 { defaultToken: 'string.interpolated.elixir' } ],
205 comment: 'sigil (allow for interpolation)' },
206 { token: 'punctuation.definition.string.begin.elixir',
207 regex: '~[a-z][^\\w]',
208 push:
209 [ { token: 'punctuation.definition.string.end.elixir',
210 regex: '[^\\w][a-z]*',
211 next: 'pop' },
212 { include: '#interpolated_elixir' },
213 { include: '#escaped_char' },
214 { include: '#escaped_char' },
215 { defaultToken: 'string.interpolated.elixir' } ],
216 comment: 'sigil (allow for interpolation)' },
217 { token: 'punctuation.definition.string.begin.elixir',
218 regex: '~[A-Z](?:""")',
219 TODO: 'FIXME: regexp doesn\'t have js equivalent',
220 originalRegex: '~[A-Z](?>""")',
221 push:
222 [ { token: 'punctuation.definition.string.end.elixir',
223 regex: '^\\s*"""',
224 next: 'pop' },
225 { defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
226 comment: 'Double-quoted heredocs sigils' },
227 { token: 'punctuation.definition.string.begin.elixir',
228 regex: '~[A-Z]\\{',
229 push:
230 [ { token: 'punctuation.definition.string.end.elixir',
231 regex: '\\}[a-z]*',
232 next: 'pop' },
233 { defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
234 comment: 'sigil (without interpolation)' },
235 { token: 'punctuation.definition.string.begin.elixir',
236 regex: '~[A-Z]\\[',
237 push:
238 [ { token: 'punctuation.definition.string.end.elixir',
239 regex: '\\][a-z]*',
240 next: 'pop' },
241 { defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
242 comment: 'sigil (without interpolation)' },
243 { token: 'punctuation.definition.string.begin.elixir',
244 regex: '~[A-Z]\\<',
245 push:
246 [ { token: 'punctuation.definition.string.end.elixir',
247 regex: '\\>[a-z]*',
248 next: 'pop' },
249 { defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
250 comment: 'sigil (without interpolation)' },
251 { token: 'punctuation.definition.string.begin.elixir',
252 regex: '~[A-Z]\\(',
253 push:
254 [ { token: 'punctuation.definition.string.end.elixir',
255 regex: '\\)[a-z]*',
256 next: 'pop' },
257 { defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
258 comment: 'sigil (without interpolation)' },
259 { token: 'punctuation.definition.string.begin.elixir',
260 regex: '~[A-Z][^\\w]',
261 push:
262 [ { token: 'punctuation.definition.string.end.elixir',
263 regex: '[^\\w][a-z]*',
264 next: 'pop' },
265 { defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
266 comment: 'sigil (without interpolation)' },
267 { token: ['punctuation.definition.constant.elixir', 'constant.other.symbol.elixir'],
268 regex: '(:)([a-zA-Z_][\\w@]*(?:[?!]|=(?![>=]))?|\\<\\>|===?|!==?|<<>>|<<<|>>>|~~~|::|<\\-|\\|>|=>|~|~=|=|/|\\\\\\\\|\\*\\*?|\\.\\.?\\.?|>=?|<=?|&&?&?|\\+\\+?|\\-\\-?|\\|\\|?\\|?|\\!|@|\\%?\\{\\}|%|\\[\\]|\\^(?:\\^\\^)?)',
269 TODO: 'FIXME: regexp doesn\'t have js equivalent',
270 originalRegex: '(?<!:)(:)(?>[a-zA-Z_][\\w@]*(?>[?!]|=(?![>=]))?|\\<\\>|===?|!==?|<<>>|<<<|>>>|~~~|::|<\\-|\\|>|=>|~|~=|=|/|\\\\\\\\|\\*\\*?|\\.\\.?\\.?|>=?|<=?|&&?&?|\\+\\+?|\\-\\-?|\\|\\|?\\|?|\\!|@|\\%?\\{\\}|%|\\[\\]|\\^(\\^\\^)?)',
271 comment: 'symbols' },
272 { token: 'punctuation.definition.constant.elixir',
273 regex: '(?:[a-zA-Z_][\\w@]*(?:[?!])?):(?!:)',
274 TODO: 'FIXME: regexp doesn\'t have js equivalent',
275 originalRegex: '(?>[a-zA-Z_][\\w@]*(?>[?!])?)(:)(?!:)',
276 comment: 'symbols' },
277 { token:
278 [ 'punctuation.definition.comment.elixir',
279 'comment.line.number-sign.elixir' ],
280 regex: '(#)(.*)' },
281 { token: 'constant.numeric.elixir',
282 regex: '\\?(?:\\\\(?:x[\\da-fA-F]{1,2}(?![\\da-fA-F])\\b|[^xMC])|[^\\s\\\\])',
283 TODO: 'FIXME: regexp doesn\'t have js equivalent',
284 originalRegex: '(?<!\\w)\\?(\\\\(x\\h{1,2}(?!\\h)\\b|[^xMC])|[^\\s\\\\])',
285 comment: '\n\t\t\tmatches questionmark-letters.\n\n\t\t\texamples (1st alternation = hex):\n\t\t\t?\\x1 ?\\x61\n\n\t\t\texamples (2rd alternation = escaped):\n\t\t\t?\\n ?\\b\n\n\t\t\texamples (3rd alternation = normal):\n\t\t\t?a ?A ?0 \n\t\t\t?* ?" ?( \n\t\t\t?. ?#\n\t\t\t\n\t\t\tthe negative lookbehind prevents against matching\n\t\t\tp(42.tainted?)\n\t\t\t' },
286 { token: 'keyword.operator.assignment.augmented.elixir',
287 regex: '\\+=|\\-=|\\|\\|=|~=|&&=' },
288 { token: 'keyword.operator.comparison.elixir',
289 regex: '===?|!==?|<=?|>=?' },
290 { token: 'keyword.operator.bitwise.elixir',
291 regex: '\\|{3}|&{3}|\\^{3}|<{3}|>{3}|~{3}' },
292 { token: 'keyword.operator.logical.elixir',
293 regex: '!+|\\bnot\\b|&&|\\band\\b|\\|\\||\\bor\\b|\\bxor\\b',
294 originalRegex: '(?<=[ \\t])!+|\\bnot\\b|&&|\\band\\b|\\|\\||\\bor\\b|\\bxor\\b' },
295 { token: 'keyword.operator.arithmetic.elixir',
296 regex: '\\*|\\+|\\-|/' },
297 { token: 'keyword.operator.other.elixir',
298 regex: '\\||\\+\\+|\\-\\-|\\*\\*|\\\\\\\\|\\<\\-|\\<\\>|\\<\\<|\\>\\>|\\:\\:|\\.\\.|\\|>|~|=>' },
299 { token: 'keyword.operator.assignment.elixir', regex: '=' },
300 { token: 'punctuation.separator.other.elixir', regex: ':' },
301 { token: 'punctuation.separator.statement.elixir',
302 regex: '\\;' },
303 { token: 'punctuation.separator.object.elixir', regex: ',' },
304 { token: 'punctuation.separator.method.elixir', regex: '\\.' },
305 { token: 'punctuation.section.scope.elixir', regex: '\\{|\\}' },
306 { token: 'punctuation.section.array.elixir', regex: '\\[|\\]' },
307 { token: 'punctuation.section.function.elixir',
308 regex: '\\(|\\)' } ],
309 '#escaped_char':
310 [ { token: 'constant.character.escape.elixir',
311 regex: '\\\\(?:x[\\da-fA-F]{1,2}|.)' } ],
312 '#interpolated_elixir':
313 [ { token:
314 [ 'source.elixir.embedded.source',
315 'source.elixir.embedded.source.empty' ],
316 regex: '(#\\{)(\\})' },
317 { todo:
318 { token: 'punctuation.section.embedded.elixir',
319 regex: '#\\{',
320 push:
321 [ { token: 'punctuation.section.embedded.elixir',
322 regex: '\\}',
323 next: 'pop' },
324 { include: '#nest_curly_and_self' },
325 { include: '$self' },
326 { defaultToken: 'source.elixir.embedded.source' } ] } } ],
327 '#nest_curly_and_self':
328 [ { token: 'punctuation.section.scope.elixir',
329 regex: '\\{',
330 push:
331 [ { token: 'punctuation.section.scope.elixir',
332 regex: '\\}',
333 next: 'pop' },
334 { include: '#nest_curly_and_self' } ] },
335 { include: '$self' } ],
336 '#regex_sub':
337 [ { include: '#interpolated_elixir' },
338 { include: '#escaped_char' },
339 { token:
340 [ 'punctuation.definition.arbitrary-repitition.elixir',
341 'string.regexp.arbitrary-repitition.elixir',
342 'string.regexp.arbitrary-repitition.elixir',
343 'punctuation.definition.arbitrary-repitition.elixir' ],
344 regex: '(\\{)(\\d+)((?:,\\d+)?)(\\})' },
345 { token: 'punctuation.definition.character-class.elixir',
346 regex: '\\[(?:\\^?\\])?',
347 push:
348 [ { token: 'punctuation.definition.character-class.elixir',
349 regex: '\\]',
350 next: 'pop' },
351 { include: '#escaped_char' },
352 { defaultToken: 'string.regexp.character-class.elixir' } ] },
353 { token: 'punctuation.definition.group.elixir',
354 regex: '\\(',
355 push:
356 [ { token: 'punctuation.definition.group.elixir',
357 regex: '\\)',
358 next: 'pop' },
359 { include: '#regex_sub' },
360 { defaultToken: 'string.regexp.group.elixir' } ] },
361 { token:
362 [ 'punctuation.definition.comment.elixir',
363 'comment.line.number-sign.elixir' ],
364 regex: '(?:^|\\s)(#)(\\s[[a-zA-Z0-9,. \\t?!-][^\\x00-\\x7F]]*$)',
365 originalRegex: '(?<=^|\\s)(#)\\s[[a-zA-Z0-9,. \\t?!-][^\\x{00}-\\x{7F}]]*$',
366 comment: 'We are restrictive in what we allow to go after the comment character to avoid false positives, since the availability of comments depend on regexp flags.' } ] }
367  
368 this.normalizeRules();
369 };
370  
371 ElixirHighlightRules.metaData = { comment: 'Textmate bundle for Elixir Programming Language.',
372 fileTypes: [ 'ex', 'exs' ],
373 firstLineMatch: '^#!/.*\\belixir',
374 foldingStartMarker: '(after|else|catch|rescue|\\-\\>|\\{|\\[|do)\\s*$',
375 foldingStopMarker: '^\\s*((\\}|\\]|after|else|catch|rescue)\\s*$|end\\b)',
376 keyEquivalent: '^~E',
377 name: 'Elixir',
378 scopeName: 'source.elixir' }
379  
380  
381 oop.inherits(ElixirHighlightRules, TextHighlightRules);
382  
383 exports.ElixirHighlightRules = ElixirHighlightRules;
384 });
385  
386 ace.define("ace/mode/folding/coffee",["require","exports","module","ace/lib/oop","ace/mode/folding/fold_mode","ace/range"], function(require, exports, module) {
387 "use strict";
388  
389 var oop = require("../../lib/oop");
390 var BaseFoldMode = require("./fold_mode").FoldMode;
391 var Range = require("../../range").Range;
392  
393 var FoldMode = exports.FoldMode = function() {};
394 oop.inherits(FoldMode, BaseFoldMode);
395  
396 (function() {
397  
398 this.getFoldWidgetRange = function(session, foldStyle, row) {
399 var range = this.indentationBlock(session, row);
400 if (range)
401 return range;
402  
403 var re = /\S/;
404 var line = session.getLine(row);
405 var startLevel = line.search(re);
406 if (startLevel == -1 || line[startLevel] != "#")
407 return;
408  
409 var startColumn = line.length;
410 var maxRow = session.getLength();
411 var startRow = row;
412 var endRow = row;
413  
414 while (++row < maxRow) {
415 line = session.getLine(row);
416 var level = line.search(re);
417  
418 if (level == -1)
419 continue;
420  
421 if (line[level] != "#")
422 break;
423  
424 endRow = row;
425 }
426  
427 if (endRow > startRow) {
428 var endColumn = session.getLine(endRow).length;
429 return new Range(startRow, startColumn, endRow, endColumn);
430 }
431 };
432 this.getFoldWidget = function(session, foldStyle, row) {
433 var line = session.getLine(row);
434 var indent = line.search(/\S/);
435 var next = session.getLine(row + 1);
436 var prev = session.getLine(row - 1);
437 var prevIndent = prev.search(/\S/);
438 var nextIndent = next.search(/\S/);
439  
440 if (indent == -1) {
441 session.foldWidgets[row - 1] = prevIndent!= -1 && prevIndent < nextIndent ? "start" : "";
442 return "";
443 }
444 if (prevIndent == -1) {
445 if (indent == nextIndent && line[indent] == "#" && next[indent] == "#") {
446 session.foldWidgets[row - 1] = "";
447 session.foldWidgets[row + 1] = "";
448 return "start";
449 }
450 } else if (prevIndent == indent && line[indent] == "#" && prev[indent] == "#") {
451 if (session.getLine(row - 2).search(/\S/) == -1) {
452 session.foldWidgets[row - 1] = "start";
453 session.foldWidgets[row + 1] = "";
454 return "";
455 }
456 }
457  
458 if (prevIndent!= -1 && prevIndent < indent)
459 session.foldWidgets[row - 1] = "start";
460 else
461 session.foldWidgets[row - 1] = "";
462  
463 if (indent < nextIndent)
464 return "start";
465 else
466 return "";
467 };
468  
469 }).call(FoldMode.prototype);
470  
471 });
472  
473 ace.define("ace/mode/elixir",["require","exports","module","ace/lib/oop","ace/mode/text","ace/mode/elixir_highlight_rules","ace/mode/folding/coffee"], function(require, exports, module) {
474 "use strict";
475  
476 var oop = require("../lib/oop");
477 var TextMode = require("./text").Mode;
478 var ElixirHighlightRules = require("./elixir_highlight_rules").ElixirHighlightRules;
479 var FoldMode = require("./folding/coffee").FoldMode;
480  
481 var Mode = function() {
482 this.HighlightRules = ElixirHighlightRules;
483 this.foldingRules = new FoldMode();
484 this.$behaviour = this.$defaultBehaviour;
485 };
486 oop.inherits(Mode, TextMode);
487  
488 (function() {
489 this.lineCommentStart = "#";
490 this.$id = "ace/mode/elixir"
491 }).call(Mode.prototype);
492  
493 exports.Mode = Mode;
494 });