Mercurial
comparison .cms/lib/codemirror/mode/crystal/crystal.js @ 0:78edf6b517a0 draft
24.10
author | Coffee CMS <info@coffee-cms.ru> |
---|---|
date | Fri, 11 Oct 2024 22:40:23 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:78edf6b517a0 |
---|---|
1 // CodeMirror, copyright (c) by Marijn Haverbeke and others | |
2 // Distributed under an MIT license: https://codemirror.net/5/LICENSE | |
3 | |
4 (function(mod) { | |
5 if (typeof exports == "object" && typeof module == "object") // CommonJS | |
6 mod(require("../../lib/codemirror")); | |
7 else if (typeof define == "function" && define.amd) // AMD | |
8 define(["../../lib/codemirror"], mod); | |
9 else // Plain browser env | |
10 mod(CodeMirror); | |
11 })(function(CodeMirror) { | |
12 "use strict"; | |
13 | |
14 CodeMirror.defineMode("crystal", function(config) { | |
15 function wordRegExp(words, end) { | |
16 return new RegExp((end ? "" : "^") + "(?:" + words.join("|") + ")" + (end ? "$" : "\\b")); | |
17 } | |
18 | |
19 function chain(tokenize, stream, state) { | |
20 state.tokenize.push(tokenize); | |
21 return tokenize(stream, state); | |
22 } | |
23 | |
24 var operators = /^(?:[-+/%|&^]|\*\*?|[<>]{2})/; | |
25 var conditionalOperators = /^(?:[=!]~|===|<=>|[<>=!]=?|[|&]{2}|~)/; | |
26 var indexingOperators = /^(?:\[\][?=]?)/; | |
27 var anotherOperators = /^(?:\.(?:\.{2})?|->|[?:])/; | |
28 var idents = /^[a-z_\u009F-\uFFFF][a-zA-Z0-9_\u009F-\uFFFF]*/; | |
29 var types = /^[A-Z_\u009F-\uFFFF][a-zA-Z0-9_\u009F-\uFFFF]*/; | |
30 var keywords = wordRegExp([ | |
31 "abstract", "alias", "as", "asm", "begin", "break", "case", "class", "def", "do", | |
32 "else", "elsif", "end", "ensure", "enum", "extend", "for", "fun", "if", | |
33 "include", "instance_sizeof", "lib", "macro", "module", "next", "of", "out", "pointerof", | |
34 "private", "protected", "rescue", "return", "require", "select", "sizeof", "struct", | |
35 "super", "then", "type", "typeof", "uninitialized", "union", "unless", "until", "when", "while", "with", | |
36 "yield", "__DIR__", "__END_LINE__", "__FILE__", "__LINE__" | |
37 ]); | |
38 var atomWords = wordRegExp(["true", "false", "nil", "self"]); | |
39 var indentKeywordsArray = [ | |
40 "def", "fun", "macro", | |
41 "class", "module", "struct", "lib", "enum", "union", | |
42 "do", "for" | |
43 ]; | |
44 var indentKeywords = wordRegExp(indentKeywordsArray); | |
45 var indentExpressionKeywordsArray = ["if", "unless", "case", "while", "until", "begin", "then"]; | |
46 var indentExpressionKeywords = wordRegExp(indentExpressionKeywordsArray); | |
47 var dedentKeywordsArray = ["end", "else", "elsif", "rescue", "ensure"]; | |
48 var dedentKeywords = wordRegExp(dedentKeywordsArray); | |
49 var dedentPunctualsArray = ["\\)", "\\}", "\\]"]; | |
50 var dedentPunctuals = new RegExp("^(?:" + dedentPunctualsArray.join("|") + ")$"); | |
51 var nextTokenizer = { | |
52 "def": tokenFollowIdent, "fun": tokenFollowIdent, "macro": tokenMacroDef, | |
53 "class": tokenFollowType, "module": tokenFollowType, "struct": tokenFollowType, | |
54 "lib": tokenFollowType, "enum": tokenFollowType, "union": tokenFollowType | |
55 }; | |
56 var matching = {"[": "]", "{": "}", "(": ")", "<": ">"}; | |
57 | |
58 function tokenBase(stream, state) { | |
59 if (stream.eatSpace()) { | |
60 return null; | |
61 } | |
62 | |
63 // Macros | |
64 if (state.lastToken != "\\" && stream.match("{%", false)) { | |
65 return chain(tokenMacro("%", "%"), stream, state); | |
66 } | |
67 | |
68 if (state.lastToken != "\\" && stream.match("{{", false)) { | |
69 return chain(tokenMacro("{", "}"), stream, state); | |
70 } | |
71 | |
72 // Comments | |
73 if (stream.peek() == "#") { | |
74 stream.skipToEnd(); | |
75 return "comment"; | |
76 } | |
77 | |
78 // Variables and keywords | |
79 var matched; | |
80 if (stream.match(idents)) { | |
81 stream.eat(/[?!]/); | |
82 | |
83 matched = stream.current(); | |
84 if (stream.eat(":")) { | |
85 return "atom"; | |
86 } else if (state.lastToken == ".") { | |
87 return "property"; | |
88 } else if (keywords.test(matched)) { | |
89 if (indentKeywords.test(matched)) { | |
90 if (!(matched == "fun" && state.blocks.indexOf("lib") >= 0) && !(matched == "def" && state.lastToken == "abstract")) { | |
91 state.blocks.push(matched); | |
92 state.currentIndent += 1; | |
93 } | |
94 } else if ((state.lastStyle == "operator" || !state.lastStyle) && indentExpressionKeywords.test(matched)) { | |
95 state.blocks.push(matched); | |
96 state.currentIndent += 1; | |
97 } else if (matched == "end") { | |
98 state.blocks.pop(); | |
99 state.currentIndent -= 1; | |
100 } | |
101 | |
102 if (nextTokenizer.hasOwnProperty(matched)) { | |
103 state.tokenize.push(nextTokenizer[matched]); | |
104 } | |
105 | |
106 return "keyword"; | |
107 } else if (atomWords.test(matched)) { | |
108 return "atom"; | |
109 } | |
110 | |
111 return "variable"; | |
112 } | |
113 | |
114 // Class variables and instance variables | |
115 // or attributes | |
116 if (stream.eat("@")) { | |
117 if (stream.peek() == "[") { | |
118 return chain(tokenNest("[", "]", "meta"), stream, state); | |
119 } | |
120 | |
121 stream.eat("@"); | |
122 stream.match(idents) || stream.match(types); | |
123 return "variable-2"; | |
124 } | |
125 | |
126 // Constants and types | |
127 if (stream.match(types)) { | |
128 return "tag"; | |
129 } | |
130 | |
131 // Symbols or ':' operator | |
132 if (stream.eat(":")) { | |
133 if (stream.eat("\"")) { | |
134 return chain(tokenQuote("\"", "atom", false), stream, state); | |
135 } else if (stream.match(idents) || stream.match(types) || | |
136 stream.match(operators) || stream.match(conditionalOperators) || stream.match(indexingOperators)) { | |
137 return "atom"; | |
138 } | |
139 stream.eat(":"); | |
140 return "operator"; | |
141 } | |
142 | |
143 // Strings | |
144 if (stream.eat("\"")) { | |
145 return chain(tokenQuote("\"", "string", true), stream, state); | |
146 } | |
147 | |
148 // Strings or regexps or macro variables or '%' operator | |
149 if (stream.peek() == "%") { | |
150 var style = "string"; | |
151 var embed = true; | |
152 var delim; | |
153 | |
154 if (stream.match("%r")) { | |
155 // Regexps | |
156 style = "string-2"; | |
157 delim = stream.next(); | |
158 } else if (stream.match("%w")) { | |
159 embed = false; | |
160 delim = stream.next(); | |
161 } else if (stream.match("%q")) { | |
162 embed = false; | |
163 delim = stream.next(); | |
164 } else { | |
165 if(delim = stream.match(/^%([^\w\s=])/)) { | |
166 delim = delim[1]; | |
167 } else if (stream.match(/^%[a-zA-Z_\u009F-\uFFFF][\w\u009F-\uFFFF]*/)) { | |
168 // Macro variables | |
169 return "meta"; | |
170 } else if (stream.eat('%')) { | |
171 // '%' operator | |
172 return "operator"; | |
173 } | |
174 } | |
175 | |
176 if (matching.hasOwnProperty(delim)) { | |
177 delim = matching[delim]; | |
178 } | |
179 return chain(tokenQuote(delim, style, embed), stream, state); | |
180 } | |
181 | |
182 // Here Docs | |
183 if (matched = stream.match(/^<<-('?)([A-Z]\w*)\1/)) { | |
184 return chain(tokenHereDoc(matched[2], !matched[1]), stream, state) | |
185 } | |
186 | |
187 // Characters | |
188 if (stream.eat("'")) { | |
189 stream.match(/^(?:[^']|\\(?:[befnrtv0'"]|[0-7]{3}|u(?:[0-9a-fA-F]{4}|\{[0-9a-fA-F]{1,6}\})))/); | |
190 stream.eat("'"); | |
191 return "atom"; | |
192 } | |
193 | |
194 // Numbers | |
195 if (stream.eat("0")) { | |
196 if (stream.eat("x")) { | |
197 stream.match(/^[0-9a-fA-F_]+/); | |
198 } else if (stream.eat("o")) { | |
199 stream.match(/^[0-7_]+/); | |
200 } else if (stream.eat("b")) { | |
201 stream.match(/^[01_]+/); | |
202 } | |
203 return "number"; | |
204 } | |
205 | |
206 if (stream.eat(/^\d/)) { | |
207 stream.match(/^[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?/); | |
208 return "number"; | |
209 } | |
210 | |
211 // Operators | |
212 if (stream.match(operators)) { | |
213 stream.eat("="); // Operators can follow assign symbol. | |
214 return "operator"; | |
215 } | |
216 | |
217 if (stream.match(conditionalOperators) || stream.match(anotherOperators)) { | |
218 return "operator"; | |
219 } | |
220 | |
221 // Parens and braces | |
222 if (matched = stream.match(/[({[]/, false)) { | |
223 matched = matched[0]; | |
224 return chain(tokenNest(matched, matching[matched], null), stream, state); | |
225 } | |
226 | |
227 // Escapes | |
228 if (stream.eat("\\")) { | |
229 stream.next(); | |
230 return "meta"; | |
231 } | |
232 | |
233 stream.next(); | |
234 return null; | |
235 } | |
236 | |
237 function tokenNest(begin, end, style, started) { | |
238 return function (stream, state) { | |
239 if (!started && stream.match(begin)) { | |
240 state.tokenize[state.tokenize.length - 1] = tokenNest(begin, end, style, true); | |
241 state.currentIndent += 1; | |
242 return style; | |
243 } | |
244 | |
245 var nextStyle = tokenBase(stream, state); | |
246 if (stream.current() === end) { | |
247 state.tokenize.pop(); | |
248 state.currentIndent -= 1; | |
249 nextStyle = style; | |
250 } | |
251 | |
252 return nextStyle; | |
253 }; | |
254 } | |
255 | |
256 function tokenMacro(begin, end, started) { | |
257 return function (stream, state) { | |
258 if (!started && stream.match("{" + begin)) { | |
259 state.currentIndent += 1; | |
260 state.tokenize[state.tokenize.length - 1] = tokenMacro(begin, end, true); | |
261 return "meta"; | |
262 } | |
263 | |
264 if (stream.match(end + "}")) { | |
265 state.currentIndent -= 1; | |
266 state.tokenize.pop(); | |
267 return "meta"; | |
268 } | |
269 | |
270 return tokenBase(stream, state); | |
271 }; | |
272 } | |
273 | |
274 function tokenMacroDef(stream, state) { | |
275 if (stream.eatSpace()) { | |
276 return null; | |
277 } | |
278 | |
279 var matched; | |
280 if (matched = stream.match(idents)) { | |
281 if (matched == "def") { | |
282 return "keyword"; | |
283 } | |
284 stream.eat(/[?!]/); | |
285 } | |
286 | |
287 state.tokenize.pop(); | |
288 return "def"; | |
289 } | |
290 | |
291 function tokenFollowIdent(stream, state) { | |
292 if (stream.eatSpace()) { | |
293 return null; | |
294 } | |
295 | |
296 if (stream.match(idents)) { | |
297 stream.eat(/[!?]/); | |
298 } else { | |
299 stream.match(operators) || stream.match(conditionalOperators) || stream.match(indexingOperators); | |
300 } | |
301 state.tokenize.pop(); | |
302 return "def"; | |
303 } | |
304 | |
305 function tokenFollowType(stream, state) { | |
306 if (stream.eatSpace()) { | |
307 return null; | |
308 } | |
309 | |
310 stream.match(types); | |
311 state.tokenize.pop(); | |
312 return "def"; | |
313 } | |
314 | |
315 function tokenQuote(end, style, embed) { | |
316 return function (stream, state) { | |
317 var escaped = false; | |
318 | |
319 while (stream.peek()) { | |
320 if (!escaped) { | |
321 if (stream.match("{%", false)) { | |
322 state.tokenize.push(tokenMacro("%", "%")); | |
323 return style; | |
324 } | |
325 | |
326 if (stream.match("{{", false)) { | |
327 state.tokenize.push(tokenMacro("{", "}")); | |
328 return style; | |
329 } | |
330 | |
331 if (embed && stream.match("#{", false)) { | |
332 state.tokenize.push(tokenNest("#{", "}", "meta")); | |
333 return style; | |
334 } | |
335 | |
336 var ch = stream.next(); | |
337 | |
338 if (ch == end) { | |
339 state.tokenize.pop(); | |
340 return style; | |
341 } | |
342 | |
343 escaped = embed && ch == "\\"; | |
344 } else { | |
345 stream.next(); | |
346 escaped = false; | |
347 } | |
348 } | |
349 | |
350 return style; | |
351 }; | |
352 } | |
353 | |
354 function tokenHereDoc(phrase, embed) { | |
355 return function (stream, state) { | |
356 if (stream.sol()) { | |
357 stream.eatSpace() | |
358 if (stream.match(phrase)) { | |
359 state.tokenize.pop(); | |
360 return "string"; | |
361 } | |
362 } | |
363 | |
364 var escaped = false; | |
365 while (stream.peek()) { | |
366 if (!escaped) { | |
367 if (stream.match("{%", false)) { | |
368 state.tokenize.push(tokenMacro("%", "%")); | |
369 return "string"; | |
370 } | |
371 | |
372 if (stream.match("{{", false)) { | |
373 state.tokenize.push(tokenMacro("{", "}")); | |
374 return "string"; | |
375 } | |
376 | |
377 if (embed && stream.match("#{", false)) { | |
378 state.tokenize.push(tokenNest("#{", "}", "meta")); | |
379 return "string"; | |
380 } | |
381 | |
382 escaped = stream.next() == "\\" && embed; | |
383 } else { | |
384 stream.next(); | |
385 escaped = false; | |
386 } | |
387 } | |
388 | |
389 return "string"; | |
390 } | |
391 } | |
392 | |
393 return { | |
394 startState: function () { | |
395 return { | |
396 tokenize: [tokenBase], | |
397 currentIndent: 0, | |
398 lastToken: null, | |
399 lastStyle: null, | |
400 blocks: [] | |
401 }; | |
402 }, | |
403 | |
404 token: function (stream, state) { | |
405 var style = state.tokenize[state.tokenize.length - 1](stream, state); | |
406 var token = stream.current(); | |
407 | |
408 if (style && style != "comment") { | |
409 state.lastToken = token; | |
410 state.lastStyle = style; | |
411 } | |
412 | |
413 return style; | |
414 }, | |
415 | |
416 indent: function (state, textAfter) { | |
417 textAfter = textAfter.replace(/^\s*(?:\{%)?\s*|\s*(?:%\})?\s*$/g, ""); | |
418 | |
419 if (dedentKeywords.test(textAfter) || dedentPunctuals.test(textAfter)) { | |
420 return config.indentUnit * (state.currentIndent - 1); | |
421 } | |
422 | |
423 return config.indentUnit * state.currentIndent; | |
424 }, | |
425 | |
426 fold: "indent", | |
427 electricInput: wordRegExp(dedentPunctualsArray.concat(dedentKeywordsArray), true), | |
428 lineComment: '#' | |
429 }; | |
430 }); | |
431 | |
432 CodeMirror.defineMIME("text/x-crystal", "crystal"); | |
433 }); |