|
|
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
|
|
// Distributed under an MIT license: https://codemirror.net/LICENSE
|
|
|
|
|
|
(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("clojure", function (options) {
|
|
|
var atoms = ["false", "nil", "true"];
|
|
|
var specialForms = [".", "catch", "def", "do", "if", "monitor-enter",
|
|
|
"monitor-exit", "new", "quote", "recur", "set!", "throw", "try", "var"];
|
|
|
var coreSymbols = ["*", "*'", "*1", "*2", "*3", "*agent*",
|
|
|
"*allow-unresolved-vars*", "*assert*", "*clojure-version*",
|
|
|
"*command-line-args*", "*compile-files*", "*compile-path*",
|
|
|
"*compiler-options*", "*data-readers*", "*default-data-reader-fn*", "*e",
|
|
|
"*err*", "*file*", "*flush-on-newline*", "*fn-loader*", "*in*",
|
|
|
"*math-context*", "*ns*", "*out*", "*print-dup*", "*print-length*",
|
|
|
"*print-level*", "*print-meta*", "*print-namespace-maps*",
|
|
|
"*print-readably*", "*read-eval*", "*reader-resolver*", "*source-path*",
|
|
|
"*suppress-read*", "*unchecked-math*", "*use-context-classloader*",
|
|
|
"*verbose-defrecords*", "*warn-on-reflection*", "+", "+'", "-", "-'",
|
|
|
"->", "->>", "->ArrayChunk", "->Eduction", "->Vec", "->VecNode",
|
|
|
"->VecSeq", "-cache-protocol-fn", "-reset-methods", "..", "/", "<", "<=",
|
|
|
"=", "==", ">", ">=", "EMPTY-NODE", "Inst", "StackTraceElement->vec",
|
|
|
"Throwable->map", "accessor", "aclone", "add-classpath", "add-watch",
|
|
|
"agent", "agent-error", "agent-errors", "aget", "alength", "alias",
|
|
|
"all-ns", "alter", "alter-meta!", "alter-var-root", "amap", "ancestors",
|
|
|
"and", "any?", "apply", "areduce", "array-map", "as->", "aset",
|
|
|
"aset-boolean", "aset-byte", "aset-char", "aset-double", "aset-float",
|
|
|
"aset-int", "aset-long", "aset-short", "assert", "assoc", "assoc!",
|
|
|
"assoc-in", "associative?", "atom", "await", "await-for", "await1",
|
|
|
"bases", "bean", "bigdec", "bigint", "biginteger", "binding", "bit-and",
|
|
|
"bit-and-not", "bit-clear", "bit-flip", "bit-not", "bit-or", "bit-set",
|
|
|
"bit-shift-left", "bit-shift-right", "bit-test", "bit-xor", "boolean",
|
|
|
"boolean-array", "boolean?", "booleans", "bound-fn", "bound-fn*",
|
|
|
"bound?", "bounded-count", "butlast", "byte", "byte-array", "bytes",
|
|
|
"bytes?", "case", "cast", "cat", "char", "char-array",
|
|
|
"char-escape-string", "char-name-string", "char?", "chars", "chunk",
|
|
|
"chunk-append", "chunk-buffer", "chunk-cons", "chunk-first", "chunk-next",
|
|
|
"chunk-rest", "chunked-seq?", "class", "class?", "clear-agent-errors",
|
|
|
"clojure-version", "coll?", "comment", "commute", "comp", "comparator",
|
|
|
"compare", "compare-and-set!", "compile", "complement", "completing",
|
|
|
"concat", "cond", "cond->", "cond->>", "condp", "conj", "conj!", "cons",
|
|
|
"constantly", "construct-proxy", "contains?", "count", "counted?",
|
|
|
"create-ns", "create-struct", "cycle", "dec", "dec'", "decimal?",
|
|
|
"declare", "dedupe", "default-data-readers", "definline", "definterface",
|
|
|
"defmacro", "defmethod", "defmulti", "defn", "defn-", "defonce",
|
|
|
"defprotocol", "defrecord", "defstruct", "deftype", "delay", "delay?",
|
|
|
"deliver", "denominator", "deref", "derive", "descendants", "destructure",
|
|
|
"disj", "disj!", "dissoc", "dissoc!", "distinct", "distinct?", "doall",
|
|
|
"dorun", "doseq", "dosync", "dotimes", "doto", "double", "double-array",
|
|
|
"double?", "doubles", "drop", "drop-last", "drop-while", "eduction",
|
|
|
"empty", "empty?", "ensure", "ensure-reduced", "enumeration-seq",
|
|
|
"error-handler", "error-mode", "eval", "even?", "every-pred", "every?",
|
|
|
"ex-data", "ex-info", "extend", "extend-protocol", "extend-type",
|
|
|
"extenders", "extends?", "false?", "ffirst", "file-seq", "filter",
|
|
|
"filterv", "find", "find-keyword", "find-ns", "find-protocol-impl",
|
|
|
"find-protocol-method", "find-var", "first", "flatten", "float",
|
|
|
"float-array", "float?", "floats", "flush", "fn", "fn?", "fnext", "fnil",
|
|
|
"for", "force", "format", "frequencies", "future", "future-call",
|
|
|
"future-cancel", "future-cancelled?", "future-done?", "future?",
|
|
|
"gen-class", "gen-interface", "gensym", "get", "get-in", "get-method",
|
|
|
"get-proxy-class", "get-thread-bindings", "get-validator", "group-by",
|
|
|
"halt-when", "hash", "hash-combine", "hash-map", "hash-ordered-coll",
|
|
|
"hash-set", "hash-unordered-coll", "ident?", "identical?", "identity",
|
|
|
"if-let", "if-not", "if-some", "ifn?", "import", "in-ns", "inc", "inc'",
|
|
|
"indexed?", "init-proxy", "inst-ms", "inst-ms*", "inst?", "instance?",
|
|
|
"int", "int-array", "int?", "integer?", "interleave", "intern",
|
|
|
"interpose", "into", "into-array", "ints", "io!", "isa?", "iterate",
|
|
|
"iterator-seq", "juxt", "keep", "keep-indexed", "key", "keys", "keyword",
|
|
|
"keyword?", "last", "lazy-cat", "lazy-seq", "let", "letfn", "line-seq",
|
|
|
"list", "list*", "list?", "load", "load-file", "load-reader",
|
|
|
"load-string", "loaded-libs", "locking", "long", "long-array", "longs",
|
|
|
"loop", "macroexpand", "macroexpand-1", "make-array", "make-hierarchy",
|
|
|
"map", "map-entry?", "map-indexed", "map?", "mapcat", "mapv", "max",
|
|
|
"max-key", "memfn", "memoize", "merge", "merge-with", "meta",
|
|
|
"method-sig", "methods", "min", "min-key", "mix-collection-hash", "mod",
|
|
|
"munge", "name", "namespace", "namespace-munge", "nat-int?", "neg-int?",
|
|
|
"neg?", "newline", "next", "nfirst", "nil?", "nnext", "not", "not-any?",
|
|
|
"not-empty", "not-every?", "not=", "ns", "ns-aliases", "ns-imports",
|
|
|
"ns-interns", "ns-map", "ns-name", "ns-publics", "ns-refers",
|
|
|
"ns-resolve", "ns-unalias", "ns-unmap", "nth", "nthnext", "nthrest",
|
|
|
"num", "number?", "numerator", "object-array", "odd?", "or", "parents",
|
|
|
"partial", "partition", "partition-all", "partition-by", "pcalls", "peek",
|
|
|
"persistent!", "pmap", "pop", "pop!", "pop-thread-bindings", "pos-int?",
|
|
|
"pos?", "pr", "pr-str", "prefer-method", "prefers",
|
|
|
"primitives-classnames", "print", "print-ctor", "print-dup",
|
|
|
"print-method", "print-simple", "print-str", "printf", "println",
|
|
|
"println-str", "prn", "prn-str", "promise", "proxy",
|
|
|
"proxy-call-with-super", "proxy-mappings", "proxy-name", "proxy-super",
|
|
|
"push-thread-bindings", "pvalues", "qualified-ident?",
|
|
|
"qualified-keyword?", "qualified-symbol?", "quot", "rand", "rand-int",
|
|
|
"rand-nth", "random-sample", "range", "ratio?", "rational?",
|
|
|
"rationalize", "re-find", "re-groups", "re-matcher", "re-matches",
|
|
|
"re-pattern", "re-seq", "read", "read-line", "read-string",
|
|
|
"reader-conditional", "reader-conditional?", "realized?", "record?",
|
|
|
"reduce", "reduce-kv", "reduced", "reduced?", "reductions", "ref",
|
|
|
"ref-history-count", "ref-max-history", "ref-min-history", "ref-set",
|
|
|
"refer", "refer-clojure", "reify", "release-pending-sends", "rem",
|
|
|
"remove", "remove-all-methods", "remove-method", "remove-ns",
|
|
|
"remove-watch", "repeat", "repeatedly", "replace", "replicate", "require",
|
|
|
"reset!", "reset-meta!", "reset-vals!", "resolve", "rest",
|
|
|
"restart-agent", "resultset-seq", "reverse", "reversible?", "rseq",
|
|
|
"rsubseq", "run!", "satisfies?", "second", "select-keys", "send",
|
|
|
"send-off", "send-via", "seq", "seq?", "seqable?", "seque", "sequence",
|
|
|
"sequential?", "set", "set-agent-send-executor!",
|
|
|
"set-agent-send-off-executor!", "set-error-handler!", "set-error-mode!",
|
|
|
"set-validator!", "set?", "short", "short-array", "shorts", "shuffle",
|
|
|
"shutdown-agents", "simple-ident?", "simple-keyword?", "simple-symbol?",
|
|
|
"slurp", "some", "some->", "some->>", "some-fn", "some?", "sort",
|
|
|
"sort-by", "sorted-map", "sorted-map-by", "sorted-set", "sorted-set-by",
|
|
|
"sorted?", "special-symbol?", "spit", "split-at", "split-with", "str",
|
|
|
"string?", "struct", "struct-map", "subs", "subseq", "subvec", "supers",
|
|
|
"swap!", "swap-vals!", "symbol", "symbol?", "sync", "tagged-literal",
|
|
|
"tagged-literal?", "take", "take-last", "take-nth", "take-while", "test",
|
|
|
"the-ns", "thread-bound?", "time", "to-array", "to-array-2d",
|
|
|
"trampoline", "transduce", "transient", "tree-seq", "true?", "type",
|
|
|
"unchecked-add", "unchecked-add-int", "unchecked-byte", "unchecked-char",
|
|
|
"unchecked-dec", "unchecked-dec-int", "unchecked-divide-int",
|
|
|
"unchecked-double", "unchecked-float", "unchecked-inc",
|
|
|
"unchecked-inc-int", "unchecked-int", "unchecked-long",
|
|
|
"unchecked-multiply", "unchecked-multiply-int", "unchecked-negate",
|
|
|
"unchecked-negate-int", "unchecked-remainder-int", "unchecked-short",
|
|
|
"unchecked-subtract", "unchecked-subtract-int", "underive", "unquote",
|
|
|
"unquote-splicing", "unreduced", "unsigned-bit-shift-right", "update",
|
|
|
"update-in", "update-proxy", "uri?", "use", "uuid?", "val", "vals",
|
|
|
"var-get", "var-set", "var?", "vary-meta", "vec", "vector", "vector-of",
|
|
|
"vector?", "volatile!", "volatile?", "vreset!", "vswap!", "when",
|
|
|
"when-first", "when-let", "when-not", "when-some", "while",
|
|
|
"with-bindings", "with-bindings*", "with-in-str", "with-loading-context",
|
|
|
"with-local-vars", "with-meta", "with-open", "with-out-str",
|
|
|
"with-precision", "with-redefs", "with-redefs-fn", "xml-seq", "zero?",
|
|
|
"zipmap"];
|
|
|
var haveBodyParameter = [
|
|
|
"->", "->>", "as->", "binding", "bound-fn", "case", "catch", "comment",
|
|
|
"cond", "cond->", "cond->>", "condp", "def", "definterface", "defmethod",
|
|
|
"defn", "defmacro", "defprotocol", "defrecord", "defstruct", "deftype",
|
|
|
"do", "doseq", "dotimes", "doto", "extend", "extend-protocol",
|
|
|
"extend-type", "fn", "for", "future", "if", "if-let", "if-not", "if-some",
|
|
|
"let", "letfn", "locking", "loop", "ns", "proxy", "reify", "struct-map",
|
|
|
"some->", "some->>", "try", "when", "when-first", "when-let", "when-not",
|
|
|
"when-some", "while", "with-bindings", "with-bindings*", "with-in-str",
|
|
|
"with-loading-context", "with-local-vars", "with-meta", "with-open",
|
|
|
"with-out-str", "with-precision", "with-redefs", "with-redefs-fn"];
|
|
|
|
|
|
CodeMirror.registerHelper("hintWords", "clojure",
|
|
|
[].concat(atoms, specialForms, coreSymbols));
|
|
|
|
|
|
var atom = createLookupMap(atoms);
|
|
|
var specialForm = createLookupMap(specialForms);
|
|
|
var coreSymbol = createLookupMap(coreSymbols);
|
|
|
var hasBodyParameter = createLookupMap(haveBodyParameter);
|
|
|
var delimiter = /^(?:[\\\[\]\s"(),;@^`{}~]|$)/;
|
|
|
var numberLiteral = /^(?:[+\-]?\d+(?:(?:N|(?:[eE][+\-]?\d+))|(?:\.?\d*(?:M|(?:[eE][+\-]?\d+))?)|\/\d+|[xX][0-9a-fA-F]+|r[0-9a-zA-Z]+)?(?=[\\\[\]\s"#'(),;@^`{}~]|$))/;
|
|
|
var characterLiteral = /^(?:\\(?:backspace|formfeed|newline|return|space|tab|o[0-7]{3}|u[0-9A-Fa-f]{4}|x[0-9A-Fa-f]{4}|.)?(?=[\\\[\]\s"(),;@^`{}~]|$))/;
|
|
|
|
|
|
// simple-namespace := /^[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*/
|
|
|
// simple-symbol := /^(?:\/|[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)/
|
|
|
// qualified-symbol := (<simple-namespace>(<.><simple-namespace>)*</>)?<simple-symbol>
|
|
|
var qualifiedSymbol = /^(?:(?:[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*(?:\.[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)*\/)?(?:\/|[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)*(?=[\\\[\]\s"(),;@^`{}~]|$))/;
|
|
|
|
|
|
function base(stream, state) {
|
|
|
if (stream.eatSpace() || stream.eat(",")) return ["space", null];
|
|
|
if (stream.match(numberLiteral)) return [null, "number"];
|
|
|
if (stream.match(characterLiteral)) return [null, "string-2"];
|
|
|
if (stream.eat(/^"/)) return (state.tokenize = inString)(stream, state);
|
|
|
if (stream.eat(/^[(\[{]/)) return ["open", "bracket"];
|
|
|
if (stream.eat(/^[)\]}]/)) return ["close", "bracket"];
|
|
|
if (stream.eat(/^;/)) {stream.skipToEnd(); return ["space", "comment"];}
|
|
|
if (stream.eat(/^[#'@^`~]/)) return [null, "meta"];
|
|
|
|
|
|
var matches = stream.match(qualifiedSymbol);
|
|
|
var symbol = matches && matches[0];
|
|
|
|
|
|
if (!symbol) {
|
|
|
// advance stream by at least one character so we don't get stuck.
|
|
|
stream.next();
|
|
|
stream.eatWhile(function (c) {return !is(c, delimiter);});
|
|
|
return [null, "error"];
|
|
|
}
|
|
|
|
|
|
if (symbol === "comment" && state.lastToken === "(")
|
|
|
return (state.tokenize = inComment)(stream, state);
|
|
|
if (is(symbol, atom) || symbol.charAt(0) === ":") return ["symbol", "atom"];
|
|
|
if (is(symbol, specialForm) || is(symbol, coreSymbol)) return ["symbol", "keyword"];
|
|
|
if (state.lastToken === "(") return ["symbol", "builtin"]; // other operator
|
|
|
|
|
|
return ["symbol", "variable"];
|
|
|
}
|
|
|
|
|
|
function inString(stream, state) {
|
|
|
var escaped = false, next;
|
|
|
|
|
|
while (next = stream.next()) {
|
|
|
if (next === "\"" && !escaped) {state.tokenize = base; break;}
|
|
|
escaped = !escaped && next === "\\";
|
|
|
}
|
|
|
|
|
|
return [null, "string"];
|
|
|
}
|
|
|
|
|
|
function inComment(stream, state) {
|
|
|
var parenthesisCount = 1;
|
|
|
var next;
|
|
|
|
|
|
while (next = stream.next()) {
|
|
|
if (next === ")") parenthesisCount--;
|
|
|
if (next === "(") parenthesisCount++;
|
|
|
if (parenthesisCount === 0) {
|
|
|
stream.backUp(1);
|
|
|
state.tokenize = base;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return ["space", "comment"];
|
|
|
}
|
|
|
|
|
|
function createLookupMap(words) {
|
|
|
var obj = {};
|
|
|
|
|
|
for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
|
|
|
|
|
|
return obj;
|
|
|
}
|
|
|
|
|
|
function is(value, test) {
|
|
|
if (test instanceof RegExp) return test.test(value);
|
|
|
if (test instanceof Object) return test.propertyIsEnumerable(value);
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
startState: function () {
|
|
|
return {
|
|
|
ctx: {prev: null, start: 0, indentTo: 0},
|
|
|
lastToken: null,
|
|
|
tokenize: base
|
|
|
};
|
|
|
},
|
|
|
|
|
|
token: function (stream, state) {
|
|
|
if (stream.sol() && (typeof state.ctx.indentTo !== "number"))
|
|
|
state.ctx.indentTo = state.ctx.start + 1;
|
|
|
|
|
|
var typeStylePair = state.tokenize(stream, state);
|
|
|
var type = typeStylePair[0];
|
|
|
var style = typeStylePair[1];
|
|
|
var current = stream.current();
|
|
|
|
|
|
if (type !== "space") {
|
|
|
if (state.lastToken === "(" && state.ctx.indentTo === null) {
|
|
|
if (type === "symbol" && is(current, hasBodyParameter))
|
|
|
state.ctx.indentTo = state.ctx.start + options.indentUnit;
|
|
|
else state.ctx.indentTo = "next";
|
|
|
} else if (state.ctx.indentTo === "next") {
|
|
|
state.ctx.indentTo = stream.column();
|
|
|
}
|
|
|
|
|
|
state.lastToken = current;
|
|
|
}
|
|
|
|
|
|
if (type === "open")
|
|
|
state.ctx = {prev: state.ctx, start: stream.column(), indentTo: null};
|
|
|
else if (type === "close") state.ctx = state.ctx.prev || state.ctx;
|
|
|
|
|
|
return style;
|
|
|
},
|
|
|
|
|
|
indent: function (state) {
|
|
|
var i = state.ctx.indentTo;
|
|
|
|
|
|
return (typeof i === "number") ?
|
|
|
i :
|
|
|
state.ctx.start + 1;
|
|
|
},
|
|
|
|
|
|
closeBrackets: {pairs: "()[]{}\"\""},
|
|
|
lineComment: ";;"
|
|
|
};
|
|
|
});
|
|
|
|
|
|
CodeMirror.defineMIME("text/x-clojure", "clojure");
|
|
|
CodeMirror.defineMIME("text/x-clojurescript", "clojure");
|
|
|
CodeMirror.defineMIME("application/edn", "clojure");
|
|
|
|
|
|
});
|
|
|
|
