Simply place the text as .js file named like that in either the C:\Program Files\LightTable\core\node_modules\codemirror\modes folder or Linux/Mac equivalent folder. Restart Light Table, it should work automatically but may not at first. Ensure the file saved has the proper extension (or set one up on user behaviors) and persist to disk. Close the file, then reopen it. It should have the syntax highlight of that language.
Find more at: https://codemirror.net/mode/
| // CodeMirror, copyright (c) by Marijn Haverbeke and others | |
| // Distributed under an MIT license: http://codemirror.net/LICENSE | |
| // By the Neo4j Team and contributors. | |
| // https://github.com/neo4j-contrib/CodeMirror | |
| // Used with gratitude by Rob Jentzema for addition to the LightTable IDE | |
| // https://codemirror.net/mode/cypher/cypher.js | |
| (function(mod) { | |
| if (typeof exports == "object" && typeof module == "object") // CommonJS | |
| mod(require("../../lib/codemirror")); | |
| else if (typeof define == "function" && define.amd) // AMD | |
| define(["../../lib/codemirror"], mod); | |
| else // Plain browser env | |
| mod(CodeMirror); | |
| })(function(CodeMirror) { | |
| "use strict"; | |
| var wordRegexp = function(words) { | |
| return new RegExp("^(?:" + words.join("|") + ")$", "i"); | |
| }; | |
| CodeMirror.defineMode("cypher", function(config) { | |
| var tokenBase = function(stream/*, state*/) { | |
| var ch = stream.next(); | |
| if (ch === "\"" || ch === "'") { | |
| stream.match(/.+?["']/); | |
| return "string"; | |
| } | |
| if (/[{}\(\),\.;\[\]]/.test(ch)) { | |
| curPunc = ch; | |
| return "node"; | |
| } else if (ch === "/" && stream.eat("/")) { | |
| stream.skipToEnd(); | |
| return "comment"; | |
| } else if (operatorChars.test(ch)) { | |
| stream.eatWhile(operatorChars); | |
| return null; | |
| } else { | |
| stream.eatWhile(/[_\w\d]/); | |
| if (stream.eat(":")) { | |
| stream.eatWhile(/[\w\d_\-]/); | |
| return "atom"; | |
| } | |
| var word = stream.current(); | |
| if (funcs.test(word)) return "builtin"; | |
| if (preds.test(word)) return "def"; | |
| if (keywords.test(word)) return "keyword"; | |
| return "variable"; | |
| } | |
| }; | |
| var pushContext = function(state, type, col) { | |
| return state.context = { | |
| prev: state.context, | |
| indent: state.indent, | |
| col: col, | |
| type: type | |
| }; | |
| }; | |
| var popContext = function(state) { | |
| state.indent = state.context.indent; | |
| return state.context = state.context.prev; | |
| }; | |
| var indentUnit = config.indentUnit; | |
| var curPunc; | |
| var funcs = wordRegexp(["abs", "acos", "allShortestPaths", "asin", "atan", "atan2", "avg", "ceil", "coalesce", "collect", "cos", "cot", "count", "degrees", "e", "endnode", "exp", "extract", "filter", "floor", "haversin", "head", "id", "keys", "labels", "last", "left", "length", "log", "log10", "lower", "ltrim", "max", "min", "node", "nodes", "percentileCont", "percentileDisc", "pi", "radians", "rand", "range", "reduce", "rel", "relationship", "relationships", "replace", "right", "round", "rtrim", "shortestPath", "sign", "sin", "split", "sqrt", "startnode", "stdev", "stdevp", "str", "substring", "sum", "tail", "tan", "timestamp", "toFloat", "toInt", "trim", "type", "upper"]); | |
| var preds = wordRegexp(["all", "and", "any", "has", "in", "none", "not", "or", "single", "xor"]); | |
| var keywords = wordRegexp(["as", "asc", "ascending", "assert", "by", "case", "commit", "constraint", "create", "csv", "cypher", "delete", "desc", "descending", "distinct", "drop", "else", "end", "explain", "false", "fieldterminator", "foreach", "from", "headers", "in", "index", "is", "limit", "load", "match", "merge", "null", "on", "optional", "order", "periodic", "profile", "remove", "return", "scan", "set", "skip", "start", "then", "true", "union", "unique", "unwind", "using", "when", "where", "with"]); | |
| var operatorChars = /[*+\-<>=&|~%^]/; | |
| return { | |
| startState: function(/*base*/) { | |
| return { | |
| tokenize: tokenBase, | |
| context: null, | |
| indent: 0, | |
| col: 0 | |
| }; | |
| }, | |
| token: function(stream, state) { | |
| if (stream.sol()) { | |
| if (state.context && (state.context.align == null)) { | |
| state.context.align = false; | |
| } | |
| state.indent = stream.indentation(); | |
| } | |
| if (stream.eatSpace()) { | |
| return null; | |
| } | |
| var style = state.tokenize(stream, state); | |
| if (style !== "comment" && state.context && (state.context.align == null) && state.context.type !== "pattern") { | |
| state.context.align = true; | |
| } | |
| if (curPunc === "(") { | |
| pushContext(state, ")", stream.column()); | |
| } else if (curPunc === "[") { | |
| pushContext(state, "]", stream.column()); | |
| } else if (curPunc === "{") { | |
| pushContext(state, "}", stream.column()); | |
| } else if (/[\]\}\)]/.test(curPunc)) { | |
| while (state.context && state.context.type === "pattern") { | |
| popContext(state); | |
| } | |
| if (state.context && curPunc === state.context.type) { | |
| popContext(state); | |
| } | |
| } else if (curPunc === "." && state.context && state.context.type === "pattern") { | |
| popContext(state); | |
| } else if (/atom|string|variable/.test(style) && state.context) { | |
| if (/[\}\]]/.test(state.context.type)) { | |
| pushContext(state, "pattern", stream.column()); | |
| } else if (state.context.type === "pattern" && !state.context.align) { | |
| state.context.align = true; | |
| state.context.col = stream.column(); | |
| } | |
| } | |
| return style; | |
| }, | |
| indent: function(state, textAfter) { | |
| var firstChar = textAfter && textAfter.charAt(0); | |
| var context = state.context; | |
| if (/[\]\}]/.test(firstChar)) { | |
| while (context && context.type === "pattern") { | |
| context = context.prev; | |
| } | |
| } | |
| var closing = context && firstChar === context.type; | |
| if (!context) return 0; | |
| if (context.type === "keywords") return CodeMirror.commands.newlineAndIndent; | |
| if (context.align) return context.col + (closing ? 0 : 1); | |
| return context.indent + (closing ? 0 : indentUnit); | |
| } | |
| }; | |
| }); | |
| CodeMirror.modeExtensions["cypher"] = { | |
| autoFormatLineBreaks: function(text) { | |
| var i, lines, reProcessedPortion; | |
| var lines = text.split("\n"); | |
| var reProcessedPortion = /\s+\b(return|where|order by|match|with|skip|limit|create|delete|set)\b\s/g; | |
| for (var i = 0; i < lines.length; i++) | |
| lines[i] = lines[i].replace(reProcessedPortion, " \n$1 ").trim(); | |
| return lines.join("\n"); | |
| } | |
| }; | |
| CodeMirror.defineMIME("application/x-cypher-query", "cypher"); | |
| }); |
| // CodeMirror, copyright (c) by Marijn Haverbeke and others | |
| // Distributed under an MIT license: http://codemirror.net/LICENSE | |
| // Used with gratitude by Rob Jentzema for addition to the LightTable IDE | |
| // https://codemirror.net/mode/ebnf/ebnf.js | |
| (function(mod) { | |
| if (typeof exports == "object" && typeof module == "object") // CommonJS | |
| mod(require("../../lib/codemirror")); | |
| else if (typeof define == "function" && define.amd) // AMD | |
| define(["../../lib/codemirror"], mod); | |
| else // Plain browser env | |
| mod(CodeMirror); | |
| })(function(CodeMirror) { | |
| "use strict"; | |
| CodeMirror.defineMode("ebnf", function (config) { | |
| var commentType = {slash: 0, parenthesis: 1}; | |
| var stateType = {comment: 0, _string: 1, characterClass: 2}; | |
| var bracesMode = null; | |
| if (config.bracesMode) | |
| bracesMode = CodeMirror.getMode(config, config.bracesMode); | |
| return { | |
| startState: function () { | |
| return { | |
| stringType: null, | |
| commentType: null, | |
| braced: 0, | |
| lhs: true, | |
| localState: null, | |
| stack: [], | |
| inDefinition: false | |
| }; | |
| }, | |
| token: function (stream, state) { | |
| if (!stream) return; | |
| //check for state changes | |
| if (state.stack.length === 0) { | |
| //strings | |
| if ((stream.peek() == '"') || (stream.peek() == "'")) { | |
| state.stringType = stream.peek(); | |
| stream.next(); // Skip quote | |
| state.stack.unshift(stateType._string); | |
| } else if (stream.match(/^\/\*/)) { //comments starting with /* | |
| state.stack.unshift(stateType.comment); | |
| state.commentType = commentType.slash; | |
| } else if (stream.match(/^\(\*/)) { //comments starting with (* | |
| state.stack.unshift(stateType.comment); | |
| state.commentType = commentType.parenthesis; | |
| } | |
| } | |
| //return state | |
| //stack has | |
| switch (state.stack[0]) { | |
| case stateType._string: | |
| while (state.stack[0] === stateType._string && !stream.eol()) { | |
| if (stream.peek() === state.stringType) { | |
| stream.next(); // Skip quote | |
| state.stack.shift(); // Clear flag | |
| } else if (stream.peek() === "\\") { | |
| stream.next(); | |
| stream.next(); | |
| } else { | |
| stream.match(/^.[^\\\"\']*/); | |
| } | |
| } | |
| return state.lhs ? "property string" : "string"; // Token style | |
| case stateType.comment: | |
| while (state.stack[0] === stateType.comment && !stream.eol()) { | |
| if (state.commentType === commentType.slash && stream.match(/\*\//)) { | |
| state.stack.shift(); // Clear flag | |
| state.commentType = null; | |
| } else if (state.commentType === commentType.parenthesis && stream.match(/\*\)/)) { | |
| state.stack.shift(); // Clear flag | |
| state.commentType = null; | |
| } else { | |
| stream.match(/^.[^\*]*/); | |
| } | |
| } | |
| return "comment"; | |
| case stateType.characterClass: | |
| while (state.stack[0] === stateType.characterClass && !stream.eol()) { | |
| if (!(stream.match(/^[^\]\\]+/) || stream.match(/^\\./))) { | |
| state.stack.shift(); | |
| } | |
| } | |
| return "operator"; | |
| } | |
| var peek = stream.peek(); | |
| if (bracesMode !== null && (state.braced || peek === "{")) { | |
| if (state.localState === null) | |
| state.localState = bracesMode.startState(); | |
| var token = bracesMode.token(stream, state.localState), | |
| text = stream.current(); | |
| if (!token) { | |
| for (var i = 0; i < text.length; i++) { | |
| if (text[i] === "{") { | |
| if (state.braced === 0) { | |
| token = "matchingbracket"; | |
| } | |
| state.braced++; | |
| } else if (text[i] === "}") { | |
| state.braced--; | |
| if (state.braced === 0) { | |
| token = "matchingbracket"; | |
| } | |
| } | |
| } | |
| } | |
| return token; | |
| } | |
| //no stack | |
| switch (peek) { | |
| case "[": | |
| stream.next(); | |
| state.stack.unshift(stateType.characterClass); | |
| return "bracket"; | |
| case ":": | |
| case "|": | |
| case ";": | |
| stream.next(); | |
| return "operator"; | |
| case "%": | |
| if (stream.match("%%")) { | |
| return "header"; | |
| } else if (stream.match(/[%][A-Za-z]+/)) { | |
| return "keyword"; | |
| } else if (stream.match(/[%][}]/)) { | |
| return "matchingbracket"; | |
| } | |
| break; | |
| case "/": | |
| if (stream.match(/[\/][A-Za-z]+/)) { | |
| return "keyword"; | |
| } | |
| case "\\": | |
| if (stream.match(/[\][a-z]+/)) { | |
| return "string-2"; | |
| } | |
| case ".": | |
| if (stream.match(".")) { | |
| return "atom"; | |
| } | |
| case "*": | |
| case "-": | |
| case "+": | |
| case "^": | |
| if (stream.match(peek)) { | |
| return "atom"; | |
| } | |
| case "$": | |
| if (stream.match("$$")) { | |
| return "builtin"; | |
| } else if (stream.match(/[$][0-9]+/)) { | |
| return "variable-3"; | |
| } | |
| case "<": | |
| if (stream.match(/<<[a-zA-Z_]+>>/)) { | |
| return "builtin"; | |
| } | |
| } | |
| if (stream.match(/^\/\//)) { | |
| stream.skipToEnd(); | |
| return "comment"; | |
| } else if (stream.match(/return/)) { | |
| return "operator"; | |
| } else if (stream.match(/^[a-zA-Z_][a-zA-Z0-9_]*/)) { | |
| if (stream.match(/(?=[\(.])/)) { | |
| return "variable"; | |
| } else if (stream.match(/(?=[\s\n]*[:=])/)) { | |
| return "def"; | |
| } | |
| return "variable-2"; | |
| } else if (["[", "]", "(", ")"].indexOf(stream.peek()) != -1) { | |
| stream.next(); | |
| return "bracket"; | |
| } else if (!stream.eatSpace()) { | |
| stream.next(); | |
| } | |
| return null; | |
| } | |
| }; | |
| }); | |
| CodeMirror.defineMIME("text/x-ebnf", "ebnf"); | |
| }); |
| // CodeMirror, copyright (c) by Marijn Haverbeke and others | |
| // Distributed under an MIT license: http://codemirror.net/LICENSE | |
| // Adds support for FSharp: | |
| // https://codemirror.net/mode/mllike/mllike.js | |
| // [:files :lt.objs.files/file-types [{:name "Fsharp" | |
| // :exts [:fs] | |
| // :mime "text/x-fsharp" | |
| // :tags [:editor.fs]}]] | |
| CodeMirror.defineMode('mllike', function(_config, parserConfig) { | |
| var words = { | |
| 'let': 'keyword', | |
| 'rec': 'keyword', | |
| 'in': 'keyword', | |
| 'of': 'keyword', | |
| 'and': 'keyword', | |
| 'if': 'keyword', | |
| 'then': 'keyword', | |
| 'else': 'keyword', | |
| 'for': 'keyword', | |
| 'to': 'keyword', | |
| 'while': 'keyword', | |
| 'do': 'keyword', | |
| 'done': 'keyword', | |
| 'fun': 'keyword', | |
| 'function': 'keyword', | |
| 'val': 'keyword', | |
| 'type': 'keyword', | |
| 'mutable': 'keyword', | |
| 'match': 'keyword', | |
| 'with': 'keyword', | |
| 'try': 'keyword', | |
| 'open': 'builtin', | |
| 'ignore': 'builtin', | |
| 'begin': 'keyword', | |
| 'end': 'keyword' | |
| }; | |
| var extraWords = parserConfig.extraWords || {}; | |
| for (var prop in extraWords) { | |
| if (extraWords.hasOwnProperty(prop)) { | |
| words[prop] = parserConfig.extraWords[prop]; | |
| } | |
| } | |
| function tokenBase(stream, state) { | |
| var ch = stream.next(); | |
| if (ch === '"') { | |
| state.tokenize = tokenString; | |
| return state.tokenize(stream, state); | |
| } | |
| if (ch === '(') { | |
| if (stream.eat('*')) { | |
| state.commentLevel++; | |
| state.tokenize = tokenComment; | |
| return state.tokenize(stream, state); | |
| } | |
| } | |
| if (ch === '~') { | |
| stream.eatWhile(/\w/); | |
| return 'variable-2'; | |
| } | |
| if (ch === '`') { | |
| stream.eatWhile(/\w/); | |
| return 'quote'; | |
| } | |
| if (ch === '/' && parserConfig.slashComments && stream.eat('/')) { | |
| stream.skipToEnd(); | |
| return 'comment'; | |
| } | |
| if (/\d/.test(ch)) { | |
| stream.eatWhile(/[\d]/); | |
| if (stream.eat('.')) { | |
| stream.eatWhile(/[\d]/); | |
| } | |
| return 'number'; | |
| } | |
| if ( /[+\-*&%=<>!?|]/.test(ch)) { | |
| return 'operator'; | |
| } | |
| stream.eatWhile(/\w/); | |
| var cur = stream.current(); | |
| return words.hasOwnProperty(cur) ? words[cur] : 'variable'; | |
| } | |
| function tokenString(stream, state) { | |
| var next, end = false, escaped = false; | |
| while ((next = stream.next()) != null) { | |
| if (next === '"' && !escaped) { | |
| end = true; | |
| break; | |
| } | |
| escaped = !escaped && next === '\\'; | |
| } | |
| if (end && !escaped) { | |
| state.tokenize = tokenBase; | |
| } | |
| return 'string'; | |
| }; | |
| function tokenComment(stream, state) { | |
| var prev, next; | |
| while(state.commentLevel > 0 && (next = stream.next()) != null) { | |
| if (prev === '(' && next === '*') state.commentLevel++; | |
| if (prev === '*' && next === ')') state.commentLevel--; | |
| prev = next; | |
| } | |
| if (state.commentLevel <= 0) { | |
| state.tokenize = tokenBase; | |
| } | |
| return 'comment'; | |
| } | |
| return { | |
| startState: function() {return {tokenize: tokenBase, commentLevel: 0};}, | |
| token: function(stream, state) { | |
| if (stream.eatSpace()) return null; | |
| return state.tokenize(stream, state); | |
| }, | |
| blockCommentStart: "(*", | |
| blockCommentEnd: "*)", | |
| lineComment: parserConfig.slashComments ? "//" : null | |
| }; | |
| }); | |
| CodeMirror.defineMIME('text/x-ocaml', { | |
| name: 'mllike', | |
| extraWords: { | |
| 'succ': 'keyword', | |
| 'trace': 'builtin', | |
| 'exit': 'builtin', | |
| 'print_string': 'builtin', | |
| 'print_endline': 'builtin', | |
| 'true': 'atom', | |
| 'false': 'atom', | |
| 'raise': 'keyword' | |
| } | |
| }); | |
| CodeMirror.defineMIME('text/x-fsharp', { | |
| name: 'mllike', | |
| extraWords: { | |
| 'abstract': 'keyword', | |
| 'as': 'keyword', | |
| 'assert': 'keyword', | |
| 'base': 'keyword', | |
| 'class': 'keyword', | |
| 'default': 'keyword', | |
| 'delegate': 'keyword', | |
| 'downcast': 'keyword', | |
| 'downto': 'keyword', | |
| 'elif': 'keyword', | |
| 'exception': 'keyword', | |
| 'extern': 'keyword', | |
| 'finally': 'keyword', | |
| 'global': 'keyword', | |
| 'inherit': 'keyword', | |
| 'inline': 'keyword', | |
| 'interface': 'keyword', | |
| 'internal': 'keyword', | |
| 'lazy': 'keyword', | |
| 'let!': 'keyword', | |
| 'member' : 'keyword', | |
| 'module': 'keyword', | |
| 'namespace': 'keyword', | |
| 'new': 'keyword', | |
| 'null': 'keyword', | |
| 'override': 'keyword', | |
| 'private': 'keyword', | |
| 'public': 'keyword', | |
| 'return': 'keyword', | |
| 'return!': 'keyword', | |
| 'select': 'keyword', | |
| 'static': 'keyword', | |
| 'struct': 'keyword', | |
| 'upcast': 'keyword', | |
| 'use': 'keyword', | |
| 'use!': 'keyword', | |
| 'val': 'keyword', | |
| 'when': 'keyword', | |
| 'yield': 'keyword', | |
| 'yield!': 'keyword', | |
| 'List': 'builtin', | |
| 'Seq': 'builtin', | |
| 'Map': 'builtin', | |
| 'Set': 'builtin', | |
| 'int': 'builtin', | |
| 'string': 'builtin', | |
| 'raise': 'builtin', | |
| 'failwith': 'builtin', | |
| 'not': 'builtin', | |
| 'true': 'builtin', | |
| 'false': 'builtin' | |
| }, | |
| slashComments: true | |
| }); |