|
0
|
1 // CodeMirror, copyright (c) by Marijn Haverbeke and others
|
|
|
2 // Distributed under an MIT license: https://codemirror.net/5/LICENSE
|
|
|
3
|
|
|
4 // Slim Highlighting for CodeMirror copyright (c) HicknHack Software Gmbh
|
|
|
5
|
|
|
6 (function(mod) {
|
|
|
7 if (typeof exports == "object" && typeof module == "object") // CommonJS
|
|
|
8 mod(require("../../lib/codemirror"), require("../htmlmixed/htmlmixed"), require("../ruby/ruby"));
|
|
|
9 else if (typeof define == "function" && define.amd) // AMD
|
|
|
10 define(["../../lib/codemirror", "../htmlmixed/htmlmixed", "../ruby/ruby"], mod);
|
|
|
11 else // Plain browser env
|
|
|
12 mod(CodeMirror);
|
|
|
13 })(function(CodeMirror) {
|
|
|
14 "use strict";
|
|
|
15
|
|
|
16 CodeMirror.defineMode("slim", function(config) {
|
|
|
17 var htmlMode = CodeMirror.getMode(config, {name: "htmlmixed"});
|
|
|
18 var rubyMode = CodeMirror.getMode(config, "ruby");
|
|
|
19 var modes = { html: htmlMode, ruby: rubyMode };
|
|
|
20 var embedded = {
|
|
|
21 ruby: "ruby",
|
|
|
22 javascript: "javascript",
|
|
|
23 css: "text/css",
|
|
|
24 sass: "text/x-sass",
|
|
|
25 scss: "text/x-scss",
|
|
|
26 less: "text/x-less",
|
|
|
27 styl: "text/x-styl", // no highlighting so far
|
|
|
28 coffee: "coffeescript",
|
|
|
29 asciidoc: "text/x-asciidoc",
|
|
|
30 markdown: "text/x-markdown",
|
|
|
31 textile: "text/x-textile", // no highlighting so far
|
|
|
32 creole: "text/x-creole", // no highlighting so far
|
|
|
33 wiki: "text/x-wiki", // no highlighting so far
|
|
|
34 mediawiki: "text/x-mediawiki", // no highlighting so far
|
|
|
35 rdoc: "text/x-rdoc", // no highlighting so far
|
|
|
36 builder: "text/x-builder", // no highlighting so far
|
|
|
37 nokogiri: "text/x-nokogiri", // no highlighting so far
|
|
|
38 erb: "application/x-erb"
|
|
|
39 };
|
|
|
40 var embeddedRegexp = function(map){
|
|
|
41 var arr = [];
|
|
|
42 for(var key in map) arr.push(key);
|
|
|
43 return new RegExp("^("+arr.join('|')+"):");
|
|
|
44 }(embedded);
|
|
|
45
|
|
|
46 var styleMap = {
|
|
|
47 "commentLine": "comment",
|
|
|
48 "slimSwitch": "operator special",
|
|
|
49 "slimTag": "tag",
|
|
|
50 "slimId": "attribute def",
|
|
|
51 "slimClass": "attribute qualifier",
|
|
|
52 "slimAttribute": "attribute",
|
|
|
53 "slimSubmode": "keyword special",
|
|
|
54 "closeAttributeTag": null,
|
|
|
55 "slimDoctype": null,
|
|
|
56 "lineContinuation": null
|
|
|
57 };
|
|
|
58 var closing = {
|
|
|
59 "{": "}",
|
|
|
60 "[": "]",
|
|
|
61 "(": ")"
|
|
|
62 };
|
|
|
63
|
|
|
64 var nameStartChar = "_a-zA-Z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD";
|
|
|
65 var nameChar = nameStartChar + "\\-0-9\xB7\u0300-\u036F\u203F-\u2040";
|
|
|
66 var nameRegexp = new RegExp("^[:"+nameStartChar+"](?::["+nameChar+"]|["+nameChar+"]*)");
|
|
|
67 var attributeNameRegexp = new RegExp("^[:"+nameStartChar+"][:\\."+nameChar+"]*(?=\\s*=)");
|
|
|
68 var wrappedAttributeNameRegexp = new RegExp("^[:"+nameStartChar+"][:\\."+nameChar+"]*");
|
|
|
69 var classNameRegexp = /^\.-?[_a-zA-Z]+[\w\-]*/;
|
|
|
70 var classIdRegexp = /^#[_a-zA-Z]+[\w\-]*/;
|
|
|
71
|
|
|
72 function backup(pos, tokenize, style) {
|
|
|
73 var restore = function(stream, state) {
|
|
|
74 state.tokenize = tokenize;
|
|
|
75 if (stream.pos < pos) {
|
|
|
76 stream.pos = pos;
|
|
|
77 return style;
|
|
|
78 }
|
|
|
79 return state.tokenize(stream, state);
|
|
|
80 };
|
|
|
81 return function(stream, state) {
|
|
|
82 state.tokenize = restore;
|
|
|
83 return tokenize(stream, state);
|
|
|
84 };
|
|
|
85 }
|
|
|
86
|
|
|
87 function maybeBackup(stream, state, pat, offset, style) {
|
|
|
88 var cur = stream.current();
|
|
|
89 var idx = cur.search(pat);
|
|
|
90 if (idx > -1) {
|
|
|
91 state.tokenize = backup(stream.pos, state.tokenize, style);
|
|
|
92 stream.backUp(cur.length - idx - offset);
|
|
|
93 }
|
|
|
94 return style;
|
|
|
95 }
|
|
|
96
|
|
|
97 function continueLine(state, column) {
|
|
|
98 state.stack = {
|
|
|
99 parent: state.stack,
|
|
|
100 style: "continuation",
|
|
|
101 indented: column,
|
|
|
102 tokenize: state.line
|
|
|
103 };
|
|
|
104 state.line = state.tokenize;
|
|
|
105 }
|
|
|
106 function finishContinue(state) {
|
|
|
107 if (state.line == state.tokenize) {
|
|
|
108 state.line = state.stack.tokenize;
|
|
|
109 state.stack = state.stack.parent;
|
|
|
110 }
|
|
|
111 }
|
|
|
112
|
|
|
113 function lineContinuable(column, tokenize) {
|
|
|
114 return function(stream, state) {
|
|
|
115 finishContinue(state);
|
|
|
116 if (stream.match(/^\\$/)) {
|
|
|
117 continueLine(state, column);
|
|
|
118 return "lineContinuation";
|
|
|
119 }
|
|
|
120 var style = tokenize(stream, state);
|
|
|
121 if (stream.eol() && stream.current().match(/(?:^|[^\\])(?:\\\\)*\\$/)) {
|
|
|
122 stream.backUp(1);
|
|
|
123 }
|
|
|
124 return style;
|
|
|
125 };
|
|
|
126 }
|
|
|
127 function commaContinuable(column, tokenize) {
|
|
|
128 return function(stream, state) {
|
|
|
129 finishContinue(state);
|
|
|
130 var style = tokenize(stream, state);
|
|
|
131 if (stream.eol() && stream.current().match(/,$/)) {
|
|
|
132 continueLine(state, column);
|
|
|
133 }
|
|
|
134 return style;
|
|
|
135 };
|
|
|
136 }
|
|
|
137
|
|
|
138 function rubyInQuote(endQuote, tokenize) {
|
|
|
139 // TODO: add multi line support
|
|
|
140 return function(stream, state) {
|
|
|
141 var ch = stream.peek();
|
|
|
142 if (ch == endQuote && state.rubyState.tokenize.length == 1) {
|
|
|
143 // step out of ruby context as it seems to complete processing all the braces
|
|
|
144 stream.next();
|
|
|
145 state.tokenize = tokenize;
|
|
|
146 return "closeAttributeTag";
|
|
|
147 } else {
|
|
|
148 return ruby(stream, state);
|
|
|
149 }
|
|
|
150 };
|
|
|
151 }
|
|
|
152 function startRubySplat(tokenize) {
|
|
|
153 var rubyState;
|
|
|
154 var runSplat = function(stream, state) {
|
|
|
155 if (state.rubyState.tokenize.length == 1 && !state.rubyState.context.prev) {
|
|
|
156 stream.backUp(1);
|
|
|
157 if (stream.eatSpace()) {
|
|
|
158 state.rubyState = rubyState;
|
|
|
159 state.tokenize = tokenize;
|
|
|
160 return tokenize(stream, state);
|
|
|
161 }
|
|
|
162 stream.next();
|
|
|
163 }
|
|
|
164 return ruby(stream, state);
|
|
|
165 };
|
|
|
166 return function(stream, state) {
|
|
|
167 rubyState = state.rubyState;
|
|
|
168 state.rubyState = CodeMirror.startState(rubyMode);
|
|
|
169 state.tokenize = runSplat;
|
|
|
170 return ruby(stream, state);
|
|
|
171 };
|
|
|
172 }
|
|
|
173
|
|
|
174 function ruby(stream, state) {
|
|
|
175 return rubyMode.token(stream, state.rubyState);
|
|
|
176 }
|
|
|
177
|
|
|
178 function htmlLine(stream, state) {
|
|
|
179 if (stream.match(/^\\$/)) {
|
|
|
180 return "lineContinuation";
|
|
|
181 }
|
|
|
182 return html(stream, state);
|
|
|
183 }
|
|
|
184 function html(stream, state) {
|
|
|
185 if (stream.match(/^#\{/)) {
|
|
|
186 state.tokenize = rubyInQuote("}", state.tokenize);
|
|
|
187 return null;
|
|
|
188 }
|
|
|
189 return maybeBackup(stream, state, /[^\\]#\{/, 1, htmlMode.token(stream, state.htmlState));
|
|
|
190 }
|
|
|
191
|
|
|
192 function startHtmlLine(lastTokenize) {
|
|
|
193 return function(stream, state) {
|
|
|
194 var style = htmlLine(stream, state);
|
|
|
195 if (stream.eol()) state.tokenize = lastTokenize;
|
|
|
196 return style;
|
|
|
197 };
|
|
|
198 }
|
|
|
199
|
|
|
200 function startHtmlMode(stream, state, offset) {
|
|
|
201 state.stack = {
|
|
|
202 parent: state.stack,
|
|
|
203 style: "html",
|
|
|
204 indented: stream.column() + offset, // pipe + space
|
|
|
205 tokenize: state.line
|
|
|
206 };
|
|
|
207 state.line = state.tokenize = html;
|
|
|
208 return null;
|
|
|
209 }
|
|
|
210
|
|
|
211 function comment(stream, state) {
|
|
|
212 stream.skipToEnd();
|
|
|
213 return state.stack.style;
|
|
|
214 }
|
|
|
215
|
|
|
216 function commentMode(stream, state) {
|
|
|
217 state.stack = {
|
|
|
218 parent: state.stack,
|
|
|
219 style: "comment",
|
|
|
220 indented: state.indented + 1,
|
|
|
221 tokenize: state.line
|
|
|
222 };
|
|
|
223 state.line = comment;
|
|
|
224 return comment(stream, state);
|
|
|
225 }
|
|
|
226
|
|
|
227 function attributeWrapper(stream, state) {
|
|
|
228 if (stream.eat(state.stack.endQuote)) {
|
|
|
229 state.line = state.stack.line;
|
|
|
230 state.tokenize = state.stack.tokenize;
|
|
|
231 state.stack = state.stack.parent;
|
|
|
232 return null;
|
|
|
233 }
|
|
|
234 if (stream.match(wrappedAttributeNameRegexp)) {
|
|
|
235 state.tokenize = attributeWrapperAssign;
|
|
|
236 return "slimAttribute";
|
|
|
237 }
|
|
|
238 stream.next();
|
|
|
239 return null;
|
|
|
240 }
|
|
|
241 function attributeWrapperAssign(stream, state) {
|
|
|
242 if (stream.match(/^==?/)) {
|
|
|
243 state.tokenize = attributeWrapperValue;
|
|
|
244 return null;
|
|
|
245 }
|
|
|
246 return attributeWrapper(stream, state);
|
|
|
247 }
|
|
|
248 function attributeWrapperValue(stream, state) {
|
|
|
249 var ch = stream.peek();
|
|
|
250 if (ch == '"' || ch == "\'") {
|
|
|
251 state.tokenize = readQuoted(ch, "string", true, false, attributeWrapper);
|
|
|
252 stream.next();
|
|
|
253 return state.tokenize(stream, state);
|
|
|
254 }
|
|
|
255 if (ch == '[') {
|
|
|
256 return startRubySplat(attributeWrapper)(stream, state);
|
|
|
257 }
|
|
|
258 if (stream.match(/^(true|false|nil)\b/)) {
|
|
|
259 state.tokenize = attributeWrapper;
|
|
|
260 return "keyword";
|
|
|
261 }
|
|
|
262 return startRubySplat(attributeWrapper)(stream, state);
|
|
|
263 }
|
|
|
264
|
|
|
265 function startAttributeWrapperMode(state, endQuote, tokenize) {
|
|
|
266 state.stack = {
|
|
|
267 parent: state.stack,
|
|
|
268 style: "wrapper",
|
|
|
269 indented: state.indented + 1,
|
|
|
270 tokenize: tokenize,
|
|
|
271 line: state.line,
|
|
|
272 endQuote: endQuote
|
|
|
273 };
|
|
|
274 state.line = state.tokenize = attributeWrapper;
|
|
|
275 return null;
|
|
|
276 }
|
|
|
277
|
|
|
278 function sub(stream, state) {
|
|
|
279 if (stream.match(/^#\{/)) {
|
|
|
280 state.tokenize = rubyInQuote("}", state.tokenize);
|
|
|
281 return null;
|
|
|
282 }
|
|
|
283 var subStream = new CodeMirror.StringStream(stream.string.slice(state.stack.indented), stream.tabSize);
|
|
|
284 subStream.pos = stream.pos - state.stack.indented;
|
|
|
285 subStream.start = stream.start - state.stack.indented;
|
|
|
286 subStream.lastColumnPos = stream.lastColumnPos - state.stack.indented;
|
|
|
287 subStream.lastColumnValue = stream.lastColumnValue - state.stack.indented;
|
|
|
288 var style = state.subMode.token(subStream, state.subState);
|
|
|
289 stream.pos = subStream.pos + state.stack.indented;
|
|
|
290 return style;
|
|
|
291 }
|
|
|
292 function firstSub(stream, state) {
|
|
|
293 state.stack.indented = stream.column();
|
|
|
294 state.line = state.tokenize = sub;
|
|
|
295 return state.tokenize(stream, state);
|
|
|
296 }
|
|
|
297
|
|
|
298 function createMode(mode) {
|
|
|
299 var query = embedded[mode];
|
|
|
300 var spec = CodeMirror.mimeModes[query];
|
|
|
301 if (spec) {
|
|
|
302 return CodeMirror.getMode(config, spec);
|
|
|
303 }
|
|
|
304 var factory = CodeMirror.modes[query];
|
|
|
305 if (factory) {
|
|
|
306 return factory(config, {name: query});
|
|
|
307 }
|
|
|
308 return CodeMirror.getMode(config, "null");
|
|
|
309 }
|
|
|
310
|
|
|
311 function getMode(mode) {
|
|
|
312 if (!modes.hasOwnProperty(mode)) {
|
|
|
313 return modes[mode] = createMode(mode);
|
|
|
314 }
|
|
|
315 return modes[mode];
|
|
|
316 }
|
|
|
317
|
|
|
318 function startSubMode(mode, state) {
|
|
|
319 var subMode = getMode(mode);
|
|
|
320 var subState = CodeMirror.startState(subMode);
|
|
|
321
|
|
|
322 state.subMode = subMode;
|
|
|
323 state.subState = subState;
|
|
|
324
|
|
|
325 state.stack = {
|
|
|
326 parent: state.stack,
|
|
|
327 style: "sub",
|
|
|
328 indented: state.indented + 1,
|
|
|
329 tokenize: state.line
|
|
|
330 };
|
|
|
331 state.line = state.tokenize = firstSub;
|
|
|
332 return "slimSubmode";
|
|
|
333 }
|
|
|
334
|
|
|
335 function doctypeLine(stream, _state) {
|
|
|
336 stream.skipToEnd();
|
|
|
337 return "slimDoctype";
|
|
|
338 }
|
|
|
339
|
|
|
340 function startLine(stream, state) {
|
|
|
341 var ch = stream.peek();
|
|
|
342 if (ch == '<') {
|
|
|
343 return (state.tokenize = startHtmlLine(state.tokenize))(stream, state);
|
|
|
344 }
|
|
|
345 if (stream.match(/^[|']/)) {
|
|
|
346 return startHtmlMode(stream, state, 1);
|
|
|
347 }
|
|
|
348 if (stream.match(/^\/(!|\[\w+])?/)) {
|
|
|
349 return commentMode(stream, state);
|
|
|
350 }
|
|
|
351 if (stream.match(/^(-|==?[<>]?)/)) {
|
|
|
352 state.tokenize = lineContinuable(stream.column(), commaContinuable(stream.column(), ruby));
|
|
|
353 return "slimSwitch";
|
|
|
354 }
|
|
|
355 if (stream.match(/^doctype\b/)) {
|
|
|
356 state.tokenize = doctypeLine;
|
|
|
357 return "keyword";
|
|
|
358 }
|
|
|
359
|
|
|
360 var m = stream.match(embeddedRegexp);
|
|
|
361 if (m) {
|
|
|
362 return startSubMode(m[1], state);
|
|
|
363 }
|
|
|
364
|
|
|
365 return slimTag(stream, state);
|
|
|
366 }
|
|
|
367
|
|
|
368 function slim(stream, state) {
|
|
|
369 if (state.startOfLine) {
|
|
|
370 return startLine(stream, state);
|
|
|
371 }
|
|
|
372 return slimTag(stream, state);
|
|
|
373 }
|
|
|
374
|
|
|
375 function slimTag(stream, state) {
|
|
|
376 if (stream.eat('*')) {
|
|
|
377 state.tokenize = startRubySplat(slimTagExtras);
|
|
|
378 return null;
|
|
|
379 }
|
|
|
380 if (stream.match(nameRegexp)) {
|
|
|
381 state.tokenize = slimTagExtras;
|
|
|
382 return "slimTag";
|
|
|
383 }
|
|
|
384 return slimClass(stream, state);
|
|
|
385 }
|
|
|
386 function slimTagExtras(stream, state) {
|
|
|
387 if (stream.match(/^(<>?|><?)/)) {
|
|
|
388 state.tokenize = slimClass;
|
|
|
389 return null;
|
|
|
390 }
|
|
|
391 return slimClass(stream, state);
|
|
|
392 }
|
|
|
393 function slimClass(stream, state) {
|
|
|
394 if (stream.match(classIdRegexp)) {
|
|
|
395 state.tokenize = slimClass;
|
|
|
396 return "slimId";
|
|
|
397 }
|
|
|
398 if (stream.match(classNameRegexp)) {
|
|
|
399 state.tokenize = slimClass;
|
|
|
400 return "slimClass";
|
|
|
401 }
|
|
|
402 return slimAttribute(stream, state);
|
|
|
403 }
|
|
|
404 function slimAttribute(stream, state) {
|
|
|
405 if (stream.match(/^([\[\{\(])/)) {
|
|
|
406 return startAttributeWrapperMode(state, closing[RegExp.$1], slimAttribute);
|
|
|
407 }
|
|
|
408 if (stream.match(attributeNameRegexp)) {
|
|
|
409 state.tokenize = slimAttributeAssign;
|
|
|
410 return "slimAttribute";
|
|
|
411 }
|
|
|
412 if (stream.peek() == '*') {
|
|
|
413 stream.next();
|
|
|
414 state.tokenize = startRubySplat(slimContent);
|
|
|
415 return null;
|
|
|
416 }
|
|
|
417 return slimContent(stream, state);
|
|
|
418 }
|
|
|
419 function slimAttributeAssign(stream, state) {
|
|
|
420 if (stream.match(/^==?/)) {
|
|
|
421 state.tokenize = slimAttributeValue;
|
|
|
422 return null;
|
|
|
423 }
|
|
|
424 // should never happen, because of forward lookup
|
|
|
425 return slimAttribute(stream, state);
|
|
|
426 }
|
|
|
427
|
|
|
428 function slimAttributeValue(stream, state) {
|
|
|
429 var ch = stream.peek();
|
|
|
430 if (ch == '"' || ch == "\'") {
|
|
|
431 state.tokenize = readQuoted(ch, "string", true, false, slimAttribute);
|
|
|
432 stream.next();
|
|
|
433 return state.tokenize(stream, state);
|
|
|
434 }
|
|
|
435 if (ch == '[') {
|
|
|
436 return startRubySplat(slimAttribute)(stream, state);
|
|
|
437 }
|
|
|
438 if (ch == ':') {
|
|
|
439 return startRubySplat(slimAttributeSymbols)(stream, state);
|
|
|
440 }
|
|
|
441 if (stream.match(/^(true|false|nil)\b/)) {
|
|
|
442 state.tokenize = slimAttribute;
|
|
|
443 return "keyword";
|
|
|
444 }
|
|
|
445 return startRubySplat(slimAttribute)(stream, state);
|
|
|
446 }
|
|
|
447 function slimAttributeSymbols(stream, state) {
|
|
|
448 stream.backUp(1);
|
|
|
449 if (stream.match(/^[^\s],(?=:)/)) {
|
|
|
450 state.tokenize = startRubySplat(slimAttributeSymbols);
|
|
|
451 return null;
|
|
|
452 }
|
|
|
453 stream.next();
|
|
|
454 return slimAttribute(stream, state);
|
|
|
455 }
|
|
|
456 function readQuoted(quote, style, embed, unescaped, nextTokenize) {
|
|
|
457 return function(stream, state) {
|
|
|
458 finishContinue(state);
|
|
|
459 var fresh = stream.current().length == 0;
|
|
|
460 if (stream.match(/^\\$/, fresh)) {
|
|
|
461 if (!fresh) return style;
|
|
|
462 continueLine(state, state.indented);
|
|
|
463 return "lineContinuation";
|
|
|
464 }
|
|
|
465 if (stream.match(/^#\{/, fresh)) {
|
|
|
466 if (!fresh) return style;
|
|
|
467 state.tokenize = rubyInQuote("}", state.tokenize);
|
|
|
468 return null;
|
|
|
469 }
|
|
|
470 var escaped = false, ch;
|
|
|
471 while ((ch = stream.next()) != null) {
|
|
|
472 if (ch == quote && (unescaped || !escaped)) {
|
|
|
473 state.tokenize = nextTokenize;
|
|
|
474 break;
|
|
|
475 }
|
|
|
476 if (embed && ch == "#" && !escaped) {
|
|
|
477 if (stream.eat("{")) {
|
|
|
478 stream.backUp(2);
|
|
|
479 break;
|
|
|
480 }
|
|
|
481 }
|
|
|
482 escaped = !escaped && ch == "\\";
|
|
|
483 }
|
|
|
484 if (stream.eol() && escaped) {
|
|
|
485 stream.backUp(1);
|
|
|
486 }
|
|
|
487 return style;
|
|
|
488 };
|
|
|
489 }
|
|
|
490 function slimContent(stream, state) {
|
|
|
491 if (stream.match(/^==?/)) {
|
|
|
492 state.tokenize = ruby;
|
|
|
493 return "slimSwitch";
|
|
|
494 }
|
|
|
495 if (stream.match(/^\/$/)) { // tag close hint
|
|
|
496 state.tokenize = slim;
|
|
|
497 return null;
|
|
|
498 }
|
|
|
499 if (stream.match(/^:/)) { // inline tag
|
|
|
500 state.tokenize = slimTag;
|
|
|
501 return "slimSwitch";
|
|
|
502 }
|
|
|
503 startHtmlMode(stream, state, 0);
|
|
|
504 return state.tokenize(stream, state);
|
|
|
505 }
|
|
|
506
|
|
|
507 var mode = {
|
|
|
508 // default to html mode
|
|
|
509 startState: function() {
|
|
|
510 var htmlState = CodeMirror.startState(htmlMode);
|
|
|
511 var rubyState = CodeMirror.startState(rubyMode);
|
|
|
512 return {
|
|
|
513 htmlState: htmlState,
|
|
|
514 rubyState: rubyState,
|
|
|
515 stack: null,
|
|
|
516 last: null,
|
|
|
517 tokenize: slim,
|
|
|
518 line: slim,
|
|
|
519 indented: 0
|
|
|
520 };
|
|
|
521 },
|
|
|
522
|
|
|
523 copyState: function(state) {
|
|
|
524 return {
|
|
|
525 htmlState : CodeMirror.copyState(htmlMode, state.htmlState),
|
|
|
526 rubyState: CodeMirror.copyState(rubyMode, state.rubyState),
|
|
|
527 subMode: state.subMode,
|
|
|
528 subState: state.subMode && CodeMirror.copyState(state.subMode, state.subState),
|
|
|
529 stack: state.stack,
|
|
|
530 last: state.last,
|
|
|
531 tokenize: state.tokenize,
|
|
|
532 line: state.line
|
|
|
533 };
|
|
|
534 },
|
|
|
535
|
|
|
536 token: function(stream, state) {
|
|
|
537 if (stream.sol()) {
|
|
|
538 state.indented = stream.indentation();
|
|
|
539 state.startOfLine = true;
|
|
|
540 state.tokenize = state.line;
|
|
|
541 while (state.stack && state.stack.indented > state.indented && state.last != "slimSubmode") {
|
|
|
542 state.line = state.tokenize = state.stack.tokenize;
|
|
|
543 state.stack = state.stack.parent;
|
|
|
544 state.subMode = null;
|
|
|
545 state.subState = null;
|
|
|
546 }
|
|
|
547 }
|
|
|
548 if (stream.eatSpace()) return null;
|
|
|
549 var style = state.tokenize(stream, state);
|
|
|
550 state.startOfLine = false;
|
|
|
551 if (style) state.last = style;
|
|
|
552 return styleMap.hasOwnProperty(style) ? styleMap[style] : style;
|
|
|
553 },
|
|
|
554
|
|
|
555 blankLine: function(state) {
|
|
|
556 if (state.subMode && state.subMode.blankLine) {
|
|
|
557 return state.subMode.blankLine(state.subState);
|
|
|
558 }
|
|
|
559 },
|
|
|
560
|
|
|
561 innerMode: function(state) {
|
|
|
562 if (state.subMode) return {state: state.subState, mode: state.subMode};
|
|
|
563 return {state: state, mode: mode};
|
|
|
564 }
|
|
|
565
|
|
|
566 //indent: function(state) {
|
|
|
567 // return state.indented;
|
|
|
568 //}
|
|
|
569 };
|
|
|
570 return mode;
|
|
|
571 }, "htmlmixed", "ruby");
|
|
|
572
|
|
|
573 CodeMirror.defineMIME("text/x-slim", "slim");
|
|
|
574 CodeMirror.defineMIME("application/x-slim", "slim");
|
|
|
575 });
|
