* Update CodeMirror to version 5.49.0 * Update CodeMirror versions in librejs and VERSIONSfor-closed-social
@ -0,0 +1,209 @@ | |||
// 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"; | |||
var noOptions = {}; | |||
var nonWS = /[^\s\u00a0]/; | |||
var Pos = CodeMirror.Pos; | |||
function firstNonWS(str) { | |||
var found = str.search(nonWS); | |||
return found == -1 ? 0 : found; | |||
} | |||
CodeMirror.commands.toggleComment = function(cm) { | |||
cm.toggleComment(); | |||
}; | |||
CodeMirror.defineExtension("toggleComment", function(options) { | |||
if (!options) options = noOptions; | |||
var cm = this; | |||
var minLine = Infinity, ranges = this.listSelections(), mode = null; | |||
for (var i = ranges.length - 1; i >= 0; i--) { | |||
var from = ranges[i].from(), to = ranges[i].to(); | |||
if (from.line >= minLine) continue; | |||
if (to.line >= minLine) to = Pos(minLine, 0); | |||
minLine = from.line; | |||
if (mode == null) { | |||
if (cm.uncomment(from, to, options)) mode = "un"; | |||
else { cm.lineComment(from, to, options); mode = "line"; } | |||
} else if (mode == "un") { | |||
cm.uncomment(from, to, options); | |||
} else { | |||
cm.lineComment(from, to, options); | |||
} | |||
} | |||
}); | |||
// Rough heuristic to try and detect lines that are part of multi-line string | |||
function probablyInsideString(cm, pos, line) { | |||
return /\bstring\b/.test(cm.getTokenTypeAt(Pos(pos.line, 0))) && !/^[\'\"\`]/.test(line) | |||
} | |||
function getMode(cm, pos) { | |||
var mode = cm.getMode() | |||
return mode.useInnerComments === false || !mode.innerMode ? mode : cm.getModeAt(pos) | |||
} | |||
CodeMirror.defineExtension("lineComment", function(from, to, options) { | |||
if (!options) options = noOptions; | |||
var self = this, mode = getMode(self, from); | |||
var firstLine = self.getLine(from.line); | |||
if (firstLine == null || probablyInsideString(self, from, firstLine)) return; | |||
var commentString = options.lineComment || mode.lineComment; | |||
if (!commentString) { | |||
if (options.blockCommentStart || mode.blockCommentStart) { | |||
options.fullLines = true; | |||
self.blockComment(from, to, options); | |||
} | |||
return; | |||
} | |||
var end = Math.min(to.ch != 0 || to.line == from.line ? to.line + 1 : to.line, self.lastLine() + 1); | |||
var pad = options.padding == null ? " " : options.padding; | |||
var blankLines = options.commentBlankLines || from.line == to.line; | |||
self.operation(function() { | |||
if (options.indent) { | |||
var baseString = null; | |||
for (var i = from.line; i < end; ++i) { | |||
var line = self.getLine(i); | |||
var whitespace = line.slice(0, firstNonWS(line)); | |||
if (baseString == null || baseString.length > whitespace.length) { | |||
baseString = whitespace; | |||
} | |||
} | |||
for (var i = from.line; i < end; ++i) { | |||
var line = self.getLine(i), cut = baseString.length; | |||
if (!blankLines && !nonWS.test(line)) continue; | |||
if (line.slice(0, cut) != baseString) cut = firstNonWS(line); | |||
self.replaceRange(baseString + commentString + pad, Pos(i, 0), Pos(i, cut)); | |||
} | |||
} else { | |||
for (var i = from.line; i < end; ++i) { | |||
if (blankLines || nonWS.test(self.getLine(i))) | |||
self.replaceRange(commentString + pad, Pos(i, 0)); | |||
} | |||
} | |||
}); | |||
}); | |||
CodeMirror.defineExtension("blockComment", function(from, to, options) { | |||
if (!options) options = noOptions; | |||
var self = this, mode = getMode(self, from); | |||
var startString = options.blockCommentStart || mode.blockCommentStart; | |||
var endString = options.blockCommentEnd || mode.blockCommentEnd; | |||
if (!startString || !endString) { | |||
if ((options.lineComment || mode.lineComment) && options.fullLines != false) | |||
self.lineComment(from, to, options); | |||
return; | |||
} | |||
if (/\bcomment\b/.test(self.getTokenTypeAt(Pos(from.line, 0)))) return | |||
var end = Math.min(to.line, self.lastLine()); | |||
if (end != from.line && to.ch == 0 && nonWS.test(self.getLine(end))) --end; | |||
var pad = options.padding == null ? " " : options.padding; | |||
if (from.line > end) return; | |||
self.operation(function() { | |||
if (options.fullLines != false) { | |||
var lastLineHasText = nonWS.test(self.getLine(end)); | |||
self.replaceRange(pad + endString, Pos(end)); | |||
self.replaceRange(startString + pad, Pos(from.line, 0)); | |||
var lead = options.blockCommentLead || mode.blockCommentLead; | |||
if (lead != null) for (var i = from.line + 1; i <= end; ++i) | |||
if (i != end || lastLineHasText) | |||
self.replaceRange(lead + pad, Pos(i, 0)); | |||
} else { | |||
self.replaceRange(endString, to); | |||
self.replaceRange(startString, from); | |||
} | |||
}); | |||
}); | |||
CodeMirror.defineExtension("uncomment", function(from, to, options) { | |||
if (!options) options = noOptions; | |||
var self = this, mode = getMode(self, from); | |||
var end = Math.min(to.ch != 0 || to.line == from.line ? to.line : to.line - 1, self.lastLine()), start = Math.min(from.line, end); | |||
// Try finding line comments | |||
var lineString = options.lineComment || mode.lineComment, lines = []; | |||
var pad = options.padding == null ? " " : options.padding, didSomething; | |||
lineComment: { | |||
if (!lineString) break lineComment; | |||
for (var i = start; i <= end; ++i) { | |||
var line = self.getLine(i); | |||
var found = line.indexOf(lineString); | |||
if (found > -1 && !/comment/.test(self.getTokenTypeAt(Pos(i, found + 1)))) found = -1; | |||
if (found == -1 && nonWS.test(line)) break lineComment; | |||
if (found > -1 && nonWS.test(line.slice(0, found))) break lineComment; | |||
lines.push(line); | |||
} | |||
self.operation(function() { | |||
for (var i = start; i <= end; ++i) { | |||
var line = lines[i - start]; | |||
var pos = line.indexOf(lineString), endPos = pos + lineString.length; | |||
if (pos < 0) continue; | |||
if (line.slice(endPos, endPos + pad.length) == pad) endPos += pad.length; | |||
didSomething = true; | |||
self.replaceRange("", Pos(i, pos), Pos(i, endPos)); | |||
} | |||
}); | |||
if (didSomething) return true; | |||
} | |||
// Try block comments | |||
var startString = options.blockCommentStart || mode.blockCommentStart; | |||
var endString = options.blockCommentEnd || mode.blockCommentEnd; | |||
if (!startString || !endString) return false; | |||
var lead = options.blockCommentLead || mode.blockCommentLead; | |||
var startLine = self.getLine(start), open = startLine.indexOf(startString) | |||
if (open == -1) return false | |||
var endLine = end == start ? startLine : self.getLine(end) | |||
var close = endLine.indexOf(endString, end == start ? open + startString.length : 0); | |||
var insideStart = Pos(start, open + 1), insideEnd = Pos(end, close + 1) | |||
if (close == -1 || | |||
!/comment/.test(self.getTokenTypeAt(insideStart)) || | |||
!/comment/.test(self.getTokenTypeAt(insideEnd)) || | |||
self.getRange(insideStart, insideEnd, "\n").indexOf(endString) > -1) | |||
return false; | |||
// Avoid killing block comments completely outside the selection. | |||
// Positions of the last startString before the start of the selection, and the first endString after it. | |||
var lastStart = startLine.lastIndexOf(startString, from.ch); | |||
var firstEnd = lastStart == -1 ? -1 : startLine.slice(0, from.ch).indexOf(endString, lastStart + startString.length); | |||
if (lastStart != -1 && firstEnd != -1 && firstEnd + endString.length != from.ch) return false; | |||
// Positions of the first endString after the end of the selection, and the last startString before it. | |||
firstEnd = endLine.indexOf(endString, to.ch); | |||
var almostLastStart = endLine.slice(to.ch).lastIndexOf(startString, firstEnd - to.ch); | |||
lastStart = (firstEnd == -1 || almostLastStart == -1) ? -1 : to.ch + almostLastStart; | |||
if (firstEnd != -1 && lastStart != -1 && lastStart != to.ch) return false; | |||
self.operation(function() { | |||
self.replaceRange("", Pos(end, close - (pad && endLine.slice(close - pad.length, close) == pad ? pad.length : 0)), | |||
Pos(end, close + endString.length)); | |||
var openEnd = open + startString.length; | |||
if (pad && startLine.slice(openEnd, openEnd + pad.length) == pad) openEnd += pad.length; | |||
self.replaceRange("", Pos(start, open), Pos(start, openEnd)); | |||
if (lead) for (var i = start + 1; i <= end; ++i) { | |||
var line = self.getLine(i), found = line.indexOf(lead); | |||
if (found == -1 || nonWS.test(line.slice(0, found))) continue; | |||
var foundEnd = found + lead.length; | |||
if (pad && line.slice(foundEnd, foundEnd + pad.length) == pad) foundEnd += pad.length; | |||
self.replaceRange("", Pos(i, found), Pos(i, foundEnd)); | |||
} | |||
}); | |||
return true; | |||
}); | |||
}); |
@ -0,0 +1,78 @@ | |||
// 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) { | |||
function continueComment(cm) { | |||
if (cm.getOption("disableInput")) return CodeMirror.Pass; | |||
var ranges = cm.listSelections(), mode, inserts = []; | |||
for (var i = 0; i < ranges.length; i++) { | |||
var pos = ranges[i].head | |||
if (!/\bcomment\b/.test(cm.getTokenTypeAt(pos))) return CodeMirror.Pass; | |||
var modeHere = cm.getModeAt(pos) | |||
if (!mode) mode = modeHere; | |||
else if (mode != modeHere) return CodeMirror.Pass; | |||
var insert = null; | |||
if (mode.blockCommentStart && mode.blockCommentContinue) { | |||
var line = cm.getLine(pos.line).slice(0, pos.ch) | |||
var end = line.lastIndexOf(mode.blockCommentEnd), found | |||
if (end != -1 && end == pos.ch - mode.blockCommentEnd.length) { | |||
// Comment ended, don't continue it | |||
} else if ((found = line.lastIndexOf(mode.blockCommentStart)) > -1 && found > end) { | |||
insert = line.slice(0, found) | |||
if (/\S/.test(insert)) { | |||
insert = "" | |||
for (var j = 0; j < found; ++j) insert += " " | |||
} | |||
} else if ((found = line.indexOf(mode.blockCommentContinue)) > -1 && !/\S/.test(line.slice(0, found))) { | |||
insert = line.slice(0, found) | |||
} | |||
if (insert != null) insert += mode.blockCommentContinue | |||
} | |||
if (insert == null && mode.lineComment && continueLineCommentEnabled(cm)) { | |||
var line = cm.getLine(pos.line), found = line.indexOf(mode.lineComment); | |||
if (found > -1) { | |||
insert = line.slice(0, found); | |||
if (/\S/.test(insert)) insert = null; | |||
else insert += mode.lineComment + line.slice(found + mode.lineComment.length).match(/^\s*/)[0]; | |||
} | |||
} | |||
if (insert == null) return CodeMirror.Pass; | |||
inserts[i] = "\n" + insert; | |||
} | |||
cm.operation(function() { | |||
for (var i = ranges.length - 1; i >= 0; i--) | |||
cm.replaceRange(inserts[i], ranges[i].from(), ranges[i].to(), "+insert"); | |||
}); | |||
} | |||
function continueLineCommentEnabled(cm) { | |||
var opt = cm.getOption("continueComments"); | |||
if (opt && typeof opt == "object") | |||
return opt.continueLineComment !== false; | |||
return true; | |||
} | |||
CodeMirror.defineOption("continueComments", null, function(cm, val, prev) { | |||
if (prev && prev != CodeMirror.Init) | |||
cm.removeKeyMap("continueComment"); | |||
if (val) { | |||
var key = "Enter"; | |||
if (typeof val == "string") | |||
key = val; | |||
else if (typeof val == "object" && val.key) | |||
key = val.key; | |||
var map = {name: "continueComment"}; | |||
map[key] = continueComment; | |||
cm.addKeyMap(map); | |||
} | |||
}); | |||
}); |
@ -0,0 +1,32 @@ | |||
.CodeMirror-dialog { | |||
position: absolute; | |||
left: 0; right: 0; | |||
background: inherit; | |||
z-index: 15; | |||
padding: .1em .8em; | |||
overflow: hidden; | |||
color: inherit; | |||
} | |||
.CodeMirror-dialog-top { | |||
border-bottom: 1px solid #eee; | |||
top: 0; | |||
} | |||
.CodeMirror-dialog-bottom { | |||
border-top: 1px solid #eee; | |||
bottom: 0; | |||
} | |||
.CodeMirror-dialog input { | |||
border: none; | |||
outline: none; | |||
background: transparent; | |||
width: 20em; | |||
color: inherit; | |||
font-family: monospace; | |||
} | |||
.CodeMirror-dialog button { | |||
font-size: 70%; | |||
} |
@ -0,0 +1,161 @@ | |||
// CodeMirror, copyright (c) by Marijn Haverbeke and others | |||
// Distributed under an MIT license: https://codemirror.net/LICENSE | |||
// Open simple dialogs on top of an editor. Relies on dialog.css. | |||
(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) { | |||
function dialogDiv(cm, template, bottom) { | |||
var wrap = cm.getWrapperElement(); | |||
var dialog; | |||
dialog = wrap.appendChild(document.createElement("div")); | |||
if (bottom) | |||
dialog.className = "CodeMirror-dialog CodeMirror-dialog-bottom"; | |||
else | |||
dialog.className = "CodeMirror-dialog CodeMirror-dialog-top"; | |||
if (typeof template == "string") { | |||
dialog.innerHTML = template; | |||
} else { // Assuming it's a detached DOM element. | |||
dialog.appendChild(template); | |||
} | |||
CodeMirror.addClass(wrap, 'dialog-opened'); | |||
return dialog; | |||
} | |||
function closeNotification(cm, newVal) { | |||
if (cm.state.currentNotificationClose) | |||
cm.state.currentNotificationClose(); | |||
cm.state.currentNotificationClose = newVal; | |||
} | |||
CodeMirror.defineExtension("openDialog", function(template, callback, options) { | |||
if (!options) options = {}; | |||
closeNotification(this, null); | |||
var dialog = dialogDiv(this, template, options.bottom); | |||
var closed = false, me = this; | |||
function close(newVal) { | |||
if (typeof newVal == 'string') { | |||
inp.value = newVal; | |||
} else { | |||
if (closed) return; | |||
closed = true; | |||
CodeMirror.rmClass(dialog.parentNode, 'dialog-opened'); | |||
dialog.parentNode.removeChild(dialog); | |||
me.focus(); | |||
if (options.onClose) options.onClose(dialog); | |||
} | |||
} | |||
var inp = dialog.getElementsByTagName("input")[0], button; | |||
if (inp) { | |||
inp.focus(); | |||
if (options.value) { | |||
inp.value = options.value; | |||
if (options.selectValueOnOpen !== false) { | |||
inp.select(); | |||
} | |||
} | |||
if (options.onInput) | |||
CodeMirror.on(inp, "input", function(e) { options.onInput(e, inp.value, close);}); | |||
if (options.onKeyUp) | |||
CodeMirror.on(inp, "keyup", function(e) {options.onKeyUp(e, inp.value, close);}); | |||
CodeMirror.on(inp, "keydown", function(e) { | |||
if (options && options.onKeyDown && options.onKeyDown(e, inp.value, close)) { return; } | |||
if (e.keyCode == 27 || (options.closeOnEnter !== false && e.keyCode == 13)) { | |||
inp.blur(); | |||
CodeMirror.e_stop(e); | |||
close(); | |||
} | |||
if (e.keyCode == 13) callback(inp.value, e); | |||
}); | |||
if (options.closeOnBlur !== false) CodeMirror.on(inp, "blur", close); | |||
} else if (button = dialog.getElementsByTagName("button")[0]) { | |||
CodeMirror.on(button, "click", function() { | |||
close(); | |||
me.focus(); | |||
}); | |||
if (options.closeOnBlur !== false) CodeMirror.on(button, "blur", close); | |||
button.focus(); | |||
} | |||
return close; | |||
}); | |||
CodeMirror.defineExtension("openConfirm", function(template, callbacks, options) { | |||
closeNotification(this, null); | |||
var dialog = dialogDiv(this, template, options && options.bottom); | |||
var buttons = dialog.getElementsByTagName("button"); | |||
var closed = false, me = this, blurring = 1; | |||
function close() { | |||
if (closed) return; | |||
closed = true; | |||
CodeMirror.rmClass(dialog.parentNode, 'dialog-opened'); | |||
dialog.parentNode.removeChild(dialog); | |||
me.focus(); | |||
} | |||
buttons[0].focus(); | |||
for (var i = 0; i < buttons.length; ++i) { | |||
var b = buttons[i]; | |||
(function(callback) { | |||
CodeMirror.on(b, "click", function(e) { | |||
CodeMirror.e_preventDefault(e); | |||
close(); | |||
if (callback) callback(me); | |||
}); | |||
})(callbacks[i]); | |||
CodeMirror.on(b, "blur", function() { | |||
--blurring; | |||
setTimeout(function() { if (blurring <= 0) close(); }, 200); | |||
}); | |||
CodeMirror.on(b, "focus", function() { ++blurring; }); | |||
} | |||
}); | |||
/* | |||
* openNotification | |||
* Opens a notification, that can be closed with an optional timer | |||
* (default 5000ms timer) and always closes on click. | |||
* | |||
* If a notification is opened while another is opened, it will close the | |||
* currently opened one and open the new one immediately. | |||
*/ | |||
CodeMirror.defineExtension("openNotification", function(template, options) { | |||
closeNotification(this, close); | |||
var dialog = dialogDiv(this, template, options && options.bottom); | |||
var closed = false, doneTimer; | |||
var duration = options && typeof options.duration !== "undefined" ? options.duration : 5000; | |||
function close() { | |||
if (closed) return; | |||
closed = true; | |||
clearTimeout(doneTimer); | |||
CodeMirror.rmClass(dialog.parentNode, 'dialog-opened'); | |||
dialog.parentNode.removeChild(dialog); | |||
} | |||
CodeMirror.on(dialog, 'click', function(e) { | |||
CodeMirror.e_preventDefault(e); | |||
close(); | |||
}); | |||
if (duration) | |||
doneTimer = setTimeout(close, duration); | |||
return close; | |||
}); | |||
}); |
@ -0,0 +1,47 @@ | |||
// 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.defineOption("autoRefresh", false, function(cm, val) { | |||
if (cm.state.autoRefresh) { | |||
stopListening(cm, cm.state.autoRefresh) | |||
cm.state.autoRefresh = null | |||
} | |||
if (val && cm.display.wrapper.offsetHeight == 0) | |||
startListening(cm, cm.state.autoRefresh = {delay: val.delay || 250}) | |||
}) | |||
function startListening(cm, state) { | |||
function check() { | |||
if (cm.display.wrapper.offsetHeight) { | |||
stopListening(cm, state) | |||
if (cm.display.lastWrapHeight != cm.display.wrapper.clientHeight) | |||
cm.refresh() | |||
} else { | |||
state.timeout = setTimeout(check, state.delay) | |||
} | |||
} | |||
state.timeout = setTimeout(check, state.delay) | |||
state.hurry = function() { | |||
clearTimeout(state.timeout) | |||
state.timeout = setTimeout(check, 50) | |||
} | |||
CodeMirror.on(window, "mouseup", state.hurry) | |||
CodeMirror.on(window, "keyup", state.hurry) | |||
} | |||
function stopListening(_cm, state) { | |||
clearTimeout(state.timeout) | |||
CodeMirror.off(window, "mouseup", state.hurry) | |||
CodeMirror.off(window, "keyup", state.hurry) | |||
} | |||
}); |
@ -0,0 +1,6 @@ | |||
.CodeMirror-fullscreen { | |||
position: fixed; | |||
top: 0; left: 0; right: 0; bottom: 0; | |||
height: auto; | |||
z-index: 9; | |||
} |
@ -0,0 +1,41 @@ | |||
// 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.defineOption("fullScreen", false, function(cm, val, old) { | |||
if (old == CodeMirror.Init) old = false; | |||
if (!old == !val) return; | |||
if (val) setFullscreen(cm); | |||
else setNormal(cm); | |||
}); | |||
function setFullscreen(cm) { | |||
var wrap = cm.getWrapperElement(); | |||
cm.state.fullScreenRestore = {scrollTop: window.pageYOffset, scrollLeft: window.pageXOffset, | |||
width: wrap.style.width, height: wrap.style.height}; | |||
wrap.style.width = ""; | |||
wrap.style.height = "auto"; | |||
wrap.className += " CodeMirror-fullscreen"; | |||
document.documentElement.style.overflow = "hidden"; | |||
cm.refresh(); | |||
} | |||
function setNormal(cm) { | |||
var wrap = cm.getWrapperElement(); | |||
wrap.className = wrap.className.replace(/\s*CodeMirror-fullscreen\b/, ""); | |||
document.documentElement.style.overflow = ""; | |||
var info = cm.state.fullScreenRestore; | |||
wrap.style.width = info.width; wrap.style.height = info.height; | |||
window.scrollTo(info.scrollLeft, info.scrollTop); | |||
cm.refresh(); | |||
} | |||
}); |
@ -0,0 +1,127 @@ | |||
// 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) { | |||
CodeMirror.defineExtension("addPanel", function(node, options) { | |||
options = options || {}; | |||
if (!this.state.panels) initPanels(this); | |||
var info = this.state.panels; | |||
var wrapper = info.wrapper; | |||
var cmWrapper = this.getWrapperElement(); | |||
var replace = options.replace instanceof Panel && !options.replace.cleared; | |||
if (options.after instanceof Panel && !options.after.cleared) { | |||
wrapper.insertBefore(node, options.before.node.nextSibling); | |||
} else if (options.before instanceof Panel && !options.before.cleared) { | |||
wrapper.insertBefore(node, options.before.node); | |||
} else if (replace) { | |||
wrapper.insertBefore(node, options.replace.node); | |||
info.panels++; | |||
options.replace.clear(); | |||
} else if (options.position == "bottom") { | |||
wrapper.appendChild(node); | |||
} else if (options.position == "before-bottom") { | |||
wrapper.insertBefore(node, cmWrapper.nextSibling); | |||
} else if (options.position == "after-top") { | |||
wrapper.insertBefore(node, cmWrapper); | |||
} else { | |||
wrapper.insertBefore(node, wrapper.firstChild); | |||
} | |||
var height = (options && options.height) || node.offsetHeight; | |||
this._setSize(null, info.heightLeft -= height); | |||
if (!replace) { | |||
info.panels++; | |||
} | |||
if (options.stable && isAtTop(this, node)) | |||
this.scrollTo(null, this.getScrollInfo().top + height) | |||
return new Panel(this, node, options, height); | |||
}); | |||
function Panel(cm, node, options, height) { | |||
this.cm = cm; | |||
this.node = node; | |||
this.options = options; | |||
this.height = height; | |||
this.cleared = false; | |||
} | |||
Panel.prototype.clear = function() { | |||
if (this.cleared) return; | |||
this.cleared = true; | |||
var info = this.cm.state.panels; | |||
this.cm._setSize(null, info.heightLeft += this.height); | |||
if (this.options.stable && isAtTop(this.cm, this.node)) | |||
this.cm.scrollTo(null, this.cm.getScrollInfo().top - this.height) | |||
info.wrapper.removeChild(this.node); | |||
if (--info.panels == 0) removePanels(this.cm); | |||
}; | |||
Panel.prototype.changed = function(height) { | |||
var newHeight = height == null ? this.node.offsetHeight : height; | |||
var info = this.cm.state.panels; | |||
this.cm._setSize(null, info.heightLeft -= (newHeight - this.height)); | |||
this.height = newHeight; | |||
}; | |||
function initPanels(cm) { | |||
var wrap = cm.getWrapperElement(); | |||
var style = window.getComputedStyle ? window.getComputedStyle(wrap) : wrap.currentStyle; | |||
var height = parseInt(style.height); | |||
var info = cm.state.panels = { | |||
setHeight: wrap.style.height, | |||
heightLeft: height, | |||
panels: 0, | |||
wrapper: document.createElement("div") | |||
}; | |||
wrap.parentNode.insertBefore(info.wrapper, wrap); | |||
var hasFocus = cm.hasFocus(); | |||
info.wrapper.appendChild(wrap); | |||
if (hasFocus) cm.focus(); | |||
cm._setSize = cm.setSize; | |||
if (height != null) cm.setSize = function(width, newHeight) { | |||
if (newHeight == null) return this._setSize(width, newHeight); | |||
info.setHeight = newHeight; | |||
if (typeof newHeight != "number") { | |||
var px = /^(\d+\.?\d*)px$/.exec(newHeight); | |||
if (px) { | |||
newHeight = Number(px[1]); | |||
} else { | |||
info.wrapper.style.height = newHeight; | |||
newHeight = info.wrapper.offsetHeight; | |||
info.wrapper.style.height = ""; | |||
} | |||
} | |||
cm._setSize(width, info.heightLeft += (newHeight - height)); | |||
height = newHeight; | |||
}; | |||
} | |||
function removePanels(cm) { | |||
var info = cm.state.panels; | |||
cm.state.panels = null; | |||
var wrap = cm.getWrapperElement(); | |||
info.wrapper.parentNode.replaceChild(wrap, info.wrapper); | |||
wrap.style.height = info.setHeight; | |||
cm.setSize = cm._setSize; | |||
cm.setSize(); | |||
} | |||
function isAtTop(cm, dom) { | |||
for (var sibling = dom.nextSibling; sibling; sibling = sibling.nextSibling) | |||
if (sibling == cm.getWrapperElement()) return true | |||
return false | |||
} | |||
}); |
@ -0,0 +1,63 @@ | |||
// 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) { | |||
CodeMirror.defineOption("placeholder", "", function(cm, val, old) { | |||
var prev = old && old != CodeMirror.Init; | |||
if (val && !prev) { | |||
cm.on("blur", onBlur); | |||
cm.on("change", onChange); | |||
cm.on("swapDoc", onChange); | |||
onChange(cm); | |||
} else if (!val && prev) { | |||
cm.off("blur", onBlur); | |||
cm.off("change", onChange); | |||
cm.off("swapDoc", onChange); | |||
clearPlaceholder(cm); | |||
var wrapper = cm.getWrapperElement(); | |||
wrapper.className = wrapper.className.replace(" CodeMirror-empty", ""); | |||
} | |||
if (val && !cm.hasFocus()) onBlur(cm); | |||
}); | |||
function clearPlaceholder(cm) { | |||
if (cm.state.placeholder) { | |||
cm.state.placeholder.parentNode.removeChild(cm.state.placeholder); | |||
cm.state.placeholder = null; | |||
} | |||
} | |||
function setPlaceholder(cm) { | |||
clearPlaceholder(cm); | |||
var elt = cm.state.placeholder = document.createElement("pre"); | |||
elt.style.cssText = "height: 0; overflow: visible"; | |||
elt.style.direction = cm.getOption("direction"); | |||
elt.className = "CodeMirror-placeholder CodeMirror-line-like"; | |||
var placeHolder = cm.getOption("placeholder") | |||
if (typeof placeHolder == "string") placeHolder = document.createTextNode(placeHolder) | |||
elt.appendChild(placeHolder) | |||
cm.display.lineSpace.insertBefore(elt, cm.display.lineSpace.firstChild); | |||
} | |||
function onBlur(cm) { | |||
if (isEmpty(cm)) setPlaceholder(cm); | |||
} | |||
function onChange(cm) { | |||
var wrapper = cm.getWrapperElement(), empty = isEmpty(cm); | |||
wrapper.className = wrapper.className.replace(" CodeMirror-empty", "") + (empty ? " CodeMirror-empty" : ""); | |||
if (empty) setPlaceholder(cm); | |||
else clearPlaceholder(cm); | |||
} | |||
function isEmpty(cm) { | |||
return (cm.lineCount() === 1) && (cm.getLine(0) === ""); | |||
} | |||
}); |
@ -0,0 +1,51 @@ | |||
// 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.defineOption("rulers", false, function(cm, val) { | |||
if (cm.state.rulerDiv) { | |||
cm.state.rulerDiv.parentElement.removeChild(cm.state.rulerDiv) | |||
cm.state.rulerDiv = null | |||
cm.off("refresh", drawRulers) | |||
} | |||
if (val && val.length) { | |||
cm.state.rulerDiv = cm.display.lineSpace.parentElement.insertBefore(document.createElement("div"), cm.display.lineSpace) | |||
cm.state.rulerDiv.className = "CodeMirror-rulers" | |||
drawRulers(cm) | |||
cm.on("refresh", drawRulers) | |||
} | |||
}); | |||
function drawRulers(cm) { | |||
cm.state.rulerDiv.textContent = "" | |||
var val = cm.getOption("rulers"); | |||
var cw = cm.defaultCharWidth(); | |||
var left = cm.charCoords(CodeMirror.Pos(cm.firstLine(), 0), "div").left; | |||
cm.state.rulerDiv.style.minHeight = (cm.display.scroller.offsetHeight + 30) + "px"; | |||
for (var i = 0; i < val.length; i++) { | |||
var elt = document.createElement("div"); | |||
elt.className = "CodeMirror-ruler"; | |||
var col, conf = val[i]; | |||
if (typeof conf == "number") { | |||
col = conf; | |||
} else { | |||
col = conf.column; | |||
if (conf.className) elt.className += " " + conf.className; | |||
if (conf.color) elt.style.borderColor = conf.color; | |||
if (conf.lineStyle) elt.style.borderLeftStyle = conf.lineStyle; | |||
if (conf.width) elt.style.borderLeftWidth = conf.width; | |||
} | |||
elt.style.left = (left + col * cw) + "px"; | |||
cm.state.rulerDiv.appendChild(elt) | |||
} | |||
} | |||
}); |
@ -0,0 +1,191 @@ | |||
// 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) { | |||
var defaults = { | |||
pairs: "()[]{}''\"\"", | |||
closeBefore: ")]}'\":;>", | |||
triples: "", | |||
explode: "[]{}" | |||
}; | |||
var Pos = CodeMirror.Pos; | |||
CodeMirror.defineOption("autoCloseBrackets", false, function(cm, val, old) { | |||
if (old && old != CodeMirror.Init) { | |||
cm.removeKeyMap(keyMap); | |||
cm.state.closeBrackets = null; | |||
} | |||
if (val) { | |||
ensureBound(getOption(val, "pairs")) | |||
cm.state.closeBrackets = val; | |||
cm.addKeyMap(keyMap); | |||
} | |||
}); | |||
function getOption(conf, name) { | |||
if (name == "pairs" && typeof conf == "string") return conf; | |||
if (typeof conf == "object" && conf[name] != null) return conf[name]; | |||
return defaults[name]; | |||
} | |||
var keyMap = {Backspace: handleBackspace, Enter: handleEnter}; | |||
function ensureBound(chars) { | |||
for (var i = 0; i < chars.length; i++) { | |||
var ch = chars.charAt(i), key = "'" + ch + "'" | |||
if (!keyMap[key]) keyMap[key] = handler(ch) | |||
} | |||
} | |||
ensureBound(defaults.pairs + "`") | |||
function handler(ch) { | |||
return function(cm) { return handleChar(cm, ch); }; | |||
} | |||
function getConfig(cm) { | |||
var deflt = cm.state.closeBrackets; | |||
if (!deflt || deflt.override) return deflt; | |||
var mode = cm.getModeAt(cm.getCursor()); | |||
return mode.closeBrackets || deflt; | |||
} | |||
function handleBackspace(cm) { | |||
var conf = getConfig(cm); | |||
if (!conf || cm.getOption("disableInput")) return CodeMirror.Pass; | |||
var pairs = getOption(conf, "pairs"); | |||
var ranges = cm.listSelections(); | |||
for (var i = 0; i < ranges.length; i++) { | |||
if (!ranges[i].empty()) return CodeMirror.Pass; | |||
var around = charsAround(cm, ranges[i].head); | |||
if (!around || pairs.indexOf(around) % 2 != 0) return CodeMirror.Pass; | |||
} | |||
for (var i = ranges.length - 1; i >= 0; i--) { | |||
var cur = ranges[i].head; | |||
cm.replaceRange("", Pos(cur.line, cur.ch - 1), Pos(cur.line, cur.ch + 1), "+delete"); | |||
} | |||
} | |||
function handleEnter(cm) { | |||
var conf = getConfig(cm); | |||
var explode = conf && getOption(conf, "explode"); | |||
if (!explode || cm.getOption("disableInput")) return CodeMirror.Pass; | |||
var ranges = cm.listSelections(); | |||
for (var i = 0; i < ranges.length; i++) { | |||
if (!ranges[i].empty()) return CodeMirror.Pass; | |||
var around = charsAround(cm, ranges[i].head); | |||
if (!around || explode.indexOf(around) % 2 != 0) return CodeMirror.Pass; | |||
} | |||
cm.operation(function() { | |||
var linesep = cm.lineSeparator() || "\n"; | |||
cm.replaceSelection(linesep + linesep, null); | |||
cm.execCommand("goCharLeft"); | |||
ranges = cm.listSelections(); | |||
for (var i = 0; i < ranges.length; i++) { | |||
var line = ranges[i].head.line; | |||
cm.indentLine(line, null, true); | |||
cm.indentLine(line + 1, null, true); | |||
} | |||
}); | |||
} | |||
function contractSelection(sel) { | |||
var inverted = CodeMirror.cmpPos(sel.anchor, sel.head) > 0; | |||
return {anchor: new Pos(sel.anchor.line, sel.anchor.ch + (inverted ? -1 : 1)), | |||
head: new Pos(sel.head.line, sel.head.ch + (inverted ? 1 : -1))}; | |||
} | |||
function handleChar(cm, ch) { | |||
var conf = getConfig(cm); | |||
if (!conf || cm.getOption("disableInput")) return CodeMirror.Pass; | |||
var pairs = getOption(conf, "pairs"); | |||
var pos = pairs.indexOf(ch); | |||
if (pos == -1) return CodeMirror.Pass; | |||
var closeBefore = getOption(conf,"closeBefore"); | |||
var triples = getOption(conf, "triples"); | |||
var identical = pairs.charAt(pos + 1) == ch; | |||
var ranges = cm.listSelections(); | |||
var opening = pos % 2 == 0; | |||
var type; | |||
for (var i = 0; i < ranges.length; i++) { | |||
var range = ranges[i], cur = range.head, curType; | |||
var next = cm.getRange(cur, Pos(cur.line, cur.ch + 1)); | |||
if (opening && !range.empty()) { | |||
curType = "surround"; | |||
} else if ((identical || !opening) && next == ch) { | |||
if (identical && stringStartsAfter(cm, cur)) | |||
curType = "both"; | |||
else if (triples.indexOf(ch) >= 0 && cm.getRange(cur, Pos(cur.line, cur.ch + 3)) == ch + ch + ch) | |||
curType = "skipThree"; | |||
else | |||
curType = "skip"; | |||
} else if (identical && cur.ch > 1 && triples.indexOf(ch) >= 0 && | |||
cm.getRange(Pos(cur.line, cur.ch - 2), cur) == ch + ch) { | |||
if (cur.ch > 2 && /\bstring/.test(cm.getTokenTypeAt(Pos(cur.line, cur.ch - 2)))) return CodeMirror.Pass; | |||
curType = "addFour"; | |||
} else if (identical) { | |||
var prev = cur.ch == 0 ? " " : cm.getRange(Pos(cur.line, cur.ch - 1), cur) | |||
if (!CodeMirror.isWordChar(next) && prev != ch && !CodeMirror.isWordChar(prev)) curType = "both"; | |||
else return CodeMirror.Pass; | |||
} else if (opening && (next.length === 0 || /\s/.test(next) || closeBefore.indexOf(next) > -1)) { | |||
curType = "both"; | |||
} else { | |||
return CodeMirror.Pass; | |||
} | |||
if (!type) type = curType; | |||
else if (type != curType) return CodeMirror.Pass; | |||
} | |||
var left = pos % 2 ? pairs.charAt(pos - 1) : ch; | |||
var right = pos % 2 ? ch : pairs.charAt(pos + 1); | |||
cm.operation(function() { | |||
if (type == "skip") { | |||
cm.execCommand("goCharRight"); | |||
} else if (type == "skipThree") { | |||
for (var i = 0; i < 3; i++) | |||
cm.execCommand("goCharRight"); | |||
} else if (type == "surround") { | |||
var sels = cm.getSelections(); | |||
for (var i = 0; i < sels.length; i++) | |||
sels[i] = left + sels[i] + right; | |||
cm.replaceSelections(sels, "around"); | |||
sels = cm.listSelections().slice(); | |||
for (var i = 0; i < sels.length; i++) | |||
sels[i] = contractSelection(sels[i]); | |||
cm.setSelections(sels); | |||
} else if (type == "both") { | |||
cm.replaceSelection(left + right, null); | |||
cm.triggerElectric(left + right); | |||
cm.execCommand("goCharLeft"); | |||
} else if (type == "addFour") { | |||
cm.replaceSelection(left + left + left + left, "before"); | |||
cm.execCommand("goCharRight"); | |||
} | |||
}); | |||
} | |||
function charsAround(cm, pos) { | |||
var str = cm.getRange(Pos(pos.line, pos.ch - 1), | |||
Pos(pos.line, pos.ch + 1)); | |||
return str.length == 2 ? str : null; | |||
} | |||
function stringStartsAfter(cm, pos) { | |||
var token = cm.getTokenAt(Pos(pos.line, pos.ch + 1)) | |||
return /\bstring/.test(token.type) && token.start == pos.ch && | |||
(pos.ch == 0 || !/\bstring/.test(cm.getTokenTypeAt(pos))) | |||
} | |||
}); |
@ -0,0 +1,184 @@ | |||
// CodeMirror, copyright (c) by Marijn Haverbeke and others | |||
// Distributed under an MIT license: https://codemirror.net/LICENSE | |||
/** | |||
* Tag-closer extension for CodeMirror. | |||
* | |||
* This extension adds an "autoCloseTags" option that can be set to | |||
* either true to get the default behavior, or an object to further | |||
* configure its behavior. | |||
* | |||
* These are supported options: | |||
* | |||
* `whenClosing` (default true) | |||
* Whether to autoclose when the '/' of a closing tag is typed. | |||
* `whenOpening` (default true) | |||
* Whether to autoclose the tag when the final '>' of an opening | |||
* tag is typed. | |||
* `dontCloseTags` (default is empty tags for HTML, none for XML) | |||
* An array of tag names that should not be autoclosed. | |||
* `indentTags` (default is block tags for HTML, none for XML) | |||
* An array of tag names that should, when opened, cause a | |||
* blank line to be added inside the tag, and the blank line and | |||
* closing line to be indented. | |||
* `emptyTags` (default is none) | |||
* An array of XML tag names that should be autoclosed with '/>'. | |||
* | |||
* See demos/closetag.html for a usage example. | |||
*/ | |||
(function(mod) { | |||
if (typeof exports == "object" && typeof module == "object") // CommonJS | |||
mod(require("../../lib/codemirror"), require("../fold/xml-fold")); | |||
else if (typeof define == "function" && define.amd) // AMD | |||
define(["../../lib/codemirror", "../fold/xml-fold"], mod); | |||
else // Plain browser env | |||
mod(CodeMirror); | |||
})(function(CodeMirror) { | |||
CodeMirror.defineOption("autoCloseTags", false, function(cm, val, old) { | |||
if (old != CodeMirror.Init && old) | |||
cm.removeKeyMap("autoCloseTags"); | |||
if (!val) return; | |||
var map = {name: "autoCloseTags"}; | |||
if (typeof val != "object" || val.whenClosing) | |||
map["'/'"] = function(cm) { return autoCloseSlash(cm); }; | |||
if (typeof val != "object" || val.whenOpening) | |||
map["'>'"] = function(cm) { return autoCloseGT(cm); }; | |||
cm.addKeyMap(map); | |||
}); | |||
var htmlDontClose = ["area", "base", "br", "col", "command", "embed", "hr", "img", "input", "keygen", "link", "meta", "param", | |||
"source", "track", "wbr"]; | |||
var htmlIndent = ["applet", "blockquote", "body", "button", "div", "dl", "fieldset", "form", "frameset", "h1", "h2", "h3", "h4", | |||
"h5", "h6", "head", "html", "iframe", "layer", "legend", "object", "ol", "p", "select", "table", "ul"]; | |||
function autoCloseGT(cm) { | |||
if (cm.getOption("disableInput")) return CodeMirror.Pass; | |||
var ranges = cm.listSelections(), replacements = []; | |||
var opt = cm.getOption("autoCloseTags"); | |||
for (var i = 0; i < ranges.length; i++) { | |||
if (!ranges[i].empty()) return CodeMirror.Pass; | |||
var pos = ranges[i].head, tok = cm.getTokenAt(pos); | |||
var inner = CodeMirror.innerMode(cm.getMode(), tok.state), state = inner.state; | |||
var tagInfo = inner.mode.xmlCurrentTag && inner.mode.xmlCurrentTag(state) | |||
var tagName = tagInfo && tagInfo.name | |||
if (!tagName) return CodeMirror.Pass | |||
var html = inner.mode.configuration == "html"; | |||
var dontCloseTags = (typeof opt == "object" && opt.dontCloseTags) || (html && htmlDontClose); | |||
var indentTags = (typeof opt == "object" && opt.indentTags) || (html && htmlIndent); | |||
if (tok.end > pos.ch) tagName = tagName.slice(0, tagName.length - tok.end + pos.ch); | |||
var lowerTagName = tagName.toLowerCase(); | |||
// Don't process the '>' at the end of an end-tag or self-closing tag | |||
if (!tagName || | |||
tok.type == "string" && (tok.end != pos.ch || !/[\"\']/.test(tok.string.charAt(tok.string.length - 1)) || tok.string.length == 1) || | |||
tok.type == "tag" && tagInfo.close || | |||
tok.string.indexOf("/") == (tok.string.length - 1) || // match something like <someTagName /> | |||
dontCloseTags && indexOf(dontCloseTags, lowerTagName) > -1 || | |||
closingTagExists(cm, inner.mode.xmlCurrentContext && inner.mode.xmlCurrentContext(state) || [], tagName, pos, true)) | |||
return CodeMirror.Pass; | |||
var emptyTags = typeof opt == "object" && opt.emptyTags; | |||
if (emptyTags && indexOf(emptyTags, tagName) > -1) { | |||
replacements[i] = { text: "/>", newPos: CodeMirror.Pos(pos.line, pos.ch + 2) }; | |||
continue; | |||
} | |||
var indent = indentTags && indexOf(indentTags, lowerTagName) > -1; | |||
replacements[i] = {indent: indent, | |||
text: ">" + (indent ? "\n\n" : "") + "</" + tagName + ">", | |||
newPos: indent ? CodeMirror.Pos(pos.line + 1, 0) : CodeMirror.Pos(pos.line, pos.ch + 1)}; | |||
} | |||
var dontIndentOnAutoClose = (typeof opt == "object" && opt.dontIndentOnAutoClose); | |||
for (var i = ranges.length - 1; i >= 0; i--) { | |||
var info = replacements[i]; | |||
cm.replaceRange(info.text, ranges[i].head, ranges[i].anchor, "+insert"); | |||
var sel = cm.listSelections().slice(0); | |||
sel[i] = {head: info.newPos, anchor: info.newPos}; | |||
cm.setSelections(sel); | |||
if (!dontIndentOnAutoClose && info.indent) { | |||
cm.indentLine(info.newPos.line, null, true); | |||
cm.indentLine(info.newPos.line + 1, null, true); | |||
} | |||
} | |||
} | |||
function autoCloseCurrent(cm, typingSlash) { | |||
var ranges = cm.listSelections(), replacements = []; | |||
var head = typingSlash ? "/" : "</"; | |||
var opt = cm.getOption("autoCloseTags"); | |||
var dontIndentOnAutoClose = (typeof opt == "object" && opt.dontIndentOnSlash); | |||
for (var i = 0; i < ranges.length; i++) { | |||
if (!ranges[i].empty()) return CodeMirror.Pass; | |||
var pos = ranges[i].head, tok = cm.getTokenAt(pos); | |||
var inner = CodeMirror.innerMode(cm.getMode(), tok.state), state = inner.state; | |||
if (typingSlash && (tok.type == "string" || tok.string.charAt(0) != "<" || | |||
tok.start != pos.ch - 1)) | |||
return CodeMirror.Pass; | |||
// Kludge to get around the fact that we are not in XML mode | |||
// when completing in JS/CSS snippet in htmlmixed mode. Does not | |||
// work for other XML embedded languages (there is no general | |||
// way to go from a mixed mode to its current XML state). | |||
var replacement, mixed = inner.mode.name != "xml" && cm.getMode().name == "htmlmixed" | |||
if (mixed && inner.mode.name == "javascript") { | |||
replacement = head + "script"; | |||
} else if (mixed && inner.mode.name == "css") { | |||
replacement = head + "style"; | |||
} else { | |||
var context = inner.mode.xmlCurrentContext && inner.mode.xmlCurrentContext(state) | |||
if (!context || (context.length && closingTagExists(cm, context, context[context.length - 1], pos))) | |||
return CodeMirror.Pass; | |||
replacement = head + context[context.length - 1] | |||
} | |||
if (cm.getLine(pos.line).charAt(tok.end) != ">") replacement += ">"; | |||
replacements[i] = replacement; | |||
} | |||
cm.replaceSelections(replacements); | |||
ranges = cm.listSelections(); | |||
if (!dontIndentOnAutoClose) { | |||
for (var i = 0; i < ranges.length; i++) | |||
if (i == ranges.length - 1 || ranges[i].head.line < ranges[i + 1].head.line) | |||
cm.indentLine(ranges[i].head.line); | |||
} | |||
} | |||
function autoCloseSlash(cm) { | |||
if (cm.getOption("disableInput")) return CodeMirror.Pass; | |||
return autoCloseCurrent(cm, true); | |||
} | |||
CodeMirror.commands.closeTag = function(cm) { return autoCloseCurrent(cm); }; | |||
function indexOf(collection, elt) { | |||
if (collection.indexOf) return collection.indexOf(elt); | |||
for (var i = 0, e = collection.length; i < e; ++i) | |||
if (collection[i] == elt) return i; | |||
return -1; | |||
} | |||
// If xml-fold is loaded, we use its functionality to try and verify | |||
// whether a given tag is actually unclosed. | |||
function closingTagExists(cm, context, tagName, pos, newTag) { | |||
if (!CodeMirror.scanForClosingTag) return false; | |||
var end = Math.min(cm.lastLine() + 1, pos.line + 500); | |||
var nextClose = CodeMirror.scanForClosingTag(cm, pos, null, end); | |||
if (!nextClose || nextClose.tag != tagName) return false; | |||
// If the immediate wrapping context contains onCx instances of | |||
// the same tag, a closing tag only exists if there are at least | |||
// that many closing tags of that type following. | |||
var onCx = newTag ? 1 : 0 | |||
for (var i = context.length - 1; i >= 0; i--) { | |||
if (context[i] == tagName) ++onCx | |||
else break | |||
} | |||
pos = nextClose.to; | |||
for (var i = 1; i < onCx; i++) { | |||
var next = CodeMirror.scanForClosingTag(cm, pos, null, end); | |||
if (!next || next.tag != tagName) return false; | |||
pos = next.to; | |||
} | |||
return true; | |||
} | |||
}); |
@ -0,0 +1,99 @@ | |||
// 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"; | |||
var listRE = /^(\s*)(>[> ]*|[*+-] \[[x ]\]\s|[*+-]\s|(\d+)([.)]))(\s*)/, | |||
emptyListRE = /^(\s*)(>[> ]*|[*+-] \[[x ]\]|[*+-]|(\d+)[.)])(\s*)$/, | |||
unorderedListRE = /[*+-]\s/; | |||
CodeMirror.commands.newlineAndIndentContinueMarkdownList = function(cm) { | |||
if (cm.getOption("disableInput")) return CodeMirror.Pass; | |||
var ranges = cm.listSelections(), replacements = []; | |||
for (var i = 0; i < ranges.length; i++) { | |||
var pos = ranges[i].head; | |||
// If we're not in Markdown mode, fall back to normal newlineAndIndent | |||
var eolState = cm.getStateAfter(pos.line); | |||
var inner = CodeMirror.innerMode(cm.getMode(), eolState); | |||
if (inner.mode.name !== "markdown") { | |||
cm.execCommand("newlineAndIndent"); | |||
return; | |||
} else { | |||
eolState = inner.state; | |||
} | |||
var inList = eolState.list !== false; | |||
var inQuote = eolState.quote !== 0; | |||
var line = cm.getLine(pos.line), match = listRE.exec(line); | |||
var cursorBeforeBullet = /^\s*$/.test(line.slice(0, pos.ch)); | |||
if (!ranges[i].empty() || (!inList && !inQuote) || !match || cursorBeforeBullet) { | |||
cm.execCommand("newlineAndIndent"); | |||
return; | |||
} | |||
if (emptyListRE.test(line)) { | |||
if (!/>\s*$/.test(line)) cm.replaceRange("", { | |||
line: pos.line, ch: 0 | |||
}, { | |||
line: pos.line, ch: pos.ch + 1 | |||
}); | |||
replacements[i] = "\n"; | |||
} else { | |||
var indent = match[1], after = match[5]; | |||
var numbered = !(unorderedListRE.test(match[2]) || match[2].indexOf(">") >= 0); | |||
var bullet = numbered ? (parseInt(match[3], 10) + 1) + match[4] : match[2].replace("x", " "); | |||
replacements[i] = "\n" + indent + bullet + after; | |||
if (numbered) incrementRemainingMarkdownListNumbers(cm, pos); | |||
} | |||
} | |||
cm.replaceSelections(replacements); | |||
}; | |||
// Auto-updating Markdown list numbers when a new item is added to the | |||
// middle of a list | |||
function incrementRemainingMarkdownListNumbers(cm, pos) { | |||
var startLine = pos.line, lookAhead = 0, skipCount = 0; | |||
var startItem = listRE.exec(cm.getLine(startLine)), startIndent = startItem[1]; | |||
do { | |||
lookAhead += 1; | |||
var nextLineNumber = startLine + lookAhead; | |||
var nextLine = cm.getLine(nextLineNumber), nextItem = listRE.exec(nextLine); | |||
if (nextItem) { | |||
var nextIndent = nextItem[1]; | |||
var newNumber = (parseInt(startItem[3], 10) + lookAhead - skipCount); | |||
var nextNumber = (parseInt(nextItem[3], 10)), itemNumber = nextNumber; | |||
if (startIndent === nextIndent && !isNaN(nextNumber)) { | |||
if (newNumber === nextNumber) itemNumber = nextNumber + 1; | |||
if (newNumber > nextNumber) itemNumber = newNumber + 1; | |||
cm.replaceRange( | |||
nextLine.replace(listRE, nextIndent + itemNumber + nextItem[4] + nextItem[5]), | |||
{ | |||
line: nextLineNumber, ch: 0 | |||
}, { | |||
line: nextLineNumber, ch: nextLine.length | |||
}); | |||
} else { | |||
if (startIndent.length > nextIndent.length) return; | |||
// This doesn't run if the next line immediatley indents, as it is | |||
// not clear of the users intention (new indented item or same level) | |||
if ((startIndent.length < nextIndent.length) && (lookAhead === 1)) return; | |||
skipCount += 1; | |||
} | |||
} | |||
} while (nextItem); | |||
} | |||
}); |
@ -0,0 +1,150 @@ | |||
// 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) { | |||
var ie_lt8 = /MSIE \d/.test(navigator.userAgent) && | |||
(document.documentMode == null || document.documentMode < 8); | |||
var Pos = CodeMirror.Pos; | |||
var matching = {"(": ")>", ")": "(<", "[": "]>", "]": "[<", "{": "}>", "}": "{<", "<": ">>", ">": "<<"}; | |||
function bracketRegex(config) { | |||
return config && config.bracketRegex || /[(){}[\]]/ | |||
} | |||
function findMatchingBracket(cm, where, config) { | |||
var line = cm.getLineHandle(where.line), pos = where.ch - 1; | |||
var afterCursor = config && config.afterCursor | |||
if (afterCursor == null) | |||
afterCursor = /(^| )cm-fat-cursor($| )/.test(cm.getWrapperElement().className) | |||
var re = bracketRegex(config) | |||
// A cursor is defined as between two characters, but in in vim command mode | |||
// (i.e. not insert mode), the cursor is visually represented as a | |||
// highlighted box on top of the 2nd character. Otherwise, we allow matches | |||
// from before or after the cursor. | |||
var match = (!afterCursor && pos >= 0 && re.test(line.text.charAt(pos)) && matching[line.text.charAt(pos)]) || | |||
re.test(line.text.charAt(pos + 1)) && matching[line.text.charAt(++pos)]; | |||
if (!match) return null; | |||
var dir = match.charAt(1) == ">" ? 1 : -1; | |||
if (config && config.strict && (dir > 0) != (pos == where.ch)) return null; | |||
var style = cm.getTokenTypeAt(Pos(where.line, pos + 1)); | |||
var found = scanForBracket(cm, Pos(where.line, pos + (dir > 0 ? 1 : 0)), dir, style || null, config); | |||
if (found == null) return null; | |||
return {from: Pos(where.line, pos), to: found && found.pos, | |||
match: found && found.ch == match.charAt(0), forward: dir > 0}; | |||
} | |||
// bracketRegex is used to specify which type of bracket to scan | |||
// should be a regexp, e.g. /[[\]]/ | |||
// | |||
// Note: If "where" is on an open bracket, then this bracket is ignored. | |||
// | |||
// Returns false when no bracket was found, null when it reached | |||
// maxScanLines and gave up | |||
function scanForBracket(cm, where, dir, style, config) { | |||
var maxScanLen = (config && config.maxScanLineLength) || 10000; | |||
var maxScanLines = (config && config.maxScanLines) || 1000; | |||
var stack = []; | |||
var re = bracketRegex(config) | |||
var lineEnd = dir > 0 ? Math.min(where.line + maxScanLines, cm.lastLine() + 1) | |||
: Math.max(cm.firstLine() - 1, where.line - maxScanLines); | |||
for (var lineNo = where.line; lineNo != lineEnd; lineNo += dir) { | |||
var line = cm.getLine(lineNo); | |||
if (!line) continue; | |||
var pos = dir > 0 ? 0 : line.length - 1, end = dir > 0 ? line.length : -1; | |||
if (line.length > maxScanLen) continue; | |||
if (lineNo == where.line) pos = where.ch - (dir < 0 ? 1 : 0); | |||
for (; pos != end; pos += dir) { | |||
var ch = line.charAt(pos); | |||
if (re.test(ch) && (style === undefined || cm.getTokenTypeAt(Pos(lineNo, pos + 1)) == style)) { | |||
var match = matching[ch]; | |||
if (match && (match.charAt(1) == ">") == (dir > 0)) stack.push(ch); | |||
else if (!stack.length) return {pos: Pos(lineNo, pos), ch: ch}; | |||
else stack.pop(); | |||
} | |||
} | |||
} | |||
return lineNo - dir == (dir > 0 ? cm.lastLine() : cm.firstLine()) ? false : null; | |||
} | |||
function matchBrackets(cm, autoclear, config) { | |||
// Disable brace matching in long lines, since it'll cause hugely slow updates | |||
var maxHighlightLen = cm.state.matchBrackets.maxHighlightLineLength || 1000; | |||
var marks = [], ranges = cm.listSelections(); | |||
for (var i = 0; i < ranges.length; i++) { | |||
var match = ranges[i].empty() && findMatchingBracket(cm, ranges[i].head, config); | |||
if (match && cm.getLine(match.from.line).length <= maxHighlightLen) { | |||
var style = match.match ? "CodeMirror-matchingbracket" : "CodeMirror-nonmatchingbracket"; | |||
marks.push(cm.markText(match.from, Pos(match.from.line, match.from.ch + 1), {className: style})); | |||
if (match.to && cm.getLine(match.to.line).length <= maxHighlightLen) | |||
marks.push(cm.markText(match.to, Pos(match.to.line, match.to.ch + 1), {className: style})); | |||
} | |||
} | |||
if (marks.length) { | |||
// Kludge to work around the IE bug from issue #1193, where text | |||
// input stops going to the textare whever this fires. | |||
if (ie_lt8 && cm.state.focused) cm.focus(); | |||
var clear = function() { | |||
cm.operation(function() { | |||
for (var i = 0; i < marks.length; i++) marks[i].clear(); | |||
}); | |||
}; | |||
if (autoclear) setTimeout(clear, 800); | |||
else return clear; | |||
} | |||
} | |||
function doMatchBrackets(cm) { | |||
cm.operation(function() { | |||
if (cm.state.matchBrackets.currentlyHighlighted) { | |||
cm.state.matchBrackets.currentlyHighlighted(); | |||
cm.state.matchBrackets.currentlyHighlighted = null; | |||
} | |||
cm.state.matchBrackets.currentlyHighlighted = matchBrackets(cm, false, cm.state.matchBrackets); | |||
}); | |||
} | |||
CodeMirror.defineOption("matchBrackets", false, function(cm, val, old) { | |||
if (old && old != CodeMirror.Init) { | |||
cm.off("cursorActivity", doMatchBrackets); | |||
if (cm.state.matchBrackets && cm.state.matchBrackets.currentlyHighlighted) { | |||
cm.state.matchBrackets.currentlyHighlighted(); | |||
cm.state.matchBrackets.currentlyHighlighted = null; | |||
} | |||
} | |||
if (val) { | |||
cm.state.matchBrackets = typeof val == "object" ? val : {}; | |||
cm.on("cursorActivity", doMatchBrackets); | |||
} | |||
}); | |||
CodeMirror.defineExtension("matchBrackets", function() {matchBrackets(this, true);}); | |||
CodeMirror.defineExtension("findMatchingBracket", function(pos, config, oldConfig){ | |||
// Backwards-compatibility kludge | |||
if (oldConfig || typeof config == "boolean") { | |||
if (!oldConfig) { | |||
config = config ? {strict: true} : null | |||
} else { | |||
oldConfig.strict = config | |||
config = oldConfig | |||
} | |||
} | |||
return findMatchingBracket(this, pos, config) | |||
}); | |||
CodeMirror.defineExtension("scanForBracket", function(pos, dir, style, config){ | |||
return scanForBracket(this, pos, dir, style, config); | |||
}); | |||
}); |
@ -0,0 +1,66 @@ | |||
// 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"), require("../fold/xml-fold")); | |||
else if (typeof define == "function" && define.amd) // AMD | |||
define(["../../lib/codemirror", "../fold/xml-fold"], mod); | |||
else // Plain browser env | |||
mod(CodeMirror); | |||
})(function(CodeMirror) { | |||
"use strict"; | |||
CodeMirror.defineOption("matchTags", false, function(cm, val, old) { | |||
if (old && old != CodeMirror.Init) { | |||
cm.off("cursorActivity", doMatchTags); | |||
cm.off("viewportChange", maybeUpdateMatch); | |||
clear(cm); | |||
} | |||
if (val) { | |||
cm.state.matchBothTags = typeof val == "object" && val.bothTags; | |||
cm.on("cursorActivity", doMatchTags); | |||
cm.on("viewportChange", maybeUpdateMatch); | |||
doMatchTags(cm); | |||
} | |||
}); | |||
function clear(cm) { | |||
if (cm.state.tagHit) cm.state.tagHit.clear(); | |||
if (cm.state.tagOther) cm.state.tagOther.clear(); | |||
cm.state.tagHit = cm.state.tagOther = null; | |||
} | |||
function doMatchTags(cm) { | |||
cm.state.failedTagMatch = false; | |||
cm.operation(function() { | |||
clear(cm); | |||
if (cm.somethingSelected()) return; | |||
var cur = cm.getCursor(), range = cm.getViewport(); | |||
range.from = Math.min(range.from, cur.line); range.to = Math.max(cur.line + 1, range.to); | |||
var match = CodeMirror.findMatchingTag(cm, cur, range); | |||
if (!match) return; | |||
if (cm.state.matchBothTags) { | |||
var hit = match.at == "open" ? match.open : match.close; | |||
if (hit) cm.state.tagHit = cm.markText(hit.from, hit.to, {className: "CodeMirror-matchingtag"}); | |||
} | |||
var other = match.at == "close" ? match.open : match.close; | |||
if (other) | |||
cm.state.tagOther = cm.markText(other.from, other.to, {className: "CodeMirror-matchingtag"}); | |||
else | |||
cm.state.failedTagMatch = true; | |||
}); | |||
} | |||
function maybeUpdateMatch(cm) { | |||
if (cm.state.failedTagMatch) doMatchTags(cm); | |||
} | |||
CodeMirror.commands.toMatchingTag = function(cm) { | |||
var found = CodeMirror.findMatchingTag(cm, cm.getCursor()); | |||
if (found) { | |||
var other = found.at == "close" ? found.open : found.close; | |||
if (other) cm.extendSelection(other.to, other.from); | |||
} | |||
}; | |||
}); |
@ -0,0 +1,27 @@ | |||
// 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) { | |||
CodeMirror.defineOption("showTrailingSpace", false, function(cm, val, prev) { | |||
if (prev == CodeMirror.Init) prev = false; | |||
if (prev && !val) | |||
cm.removeOverlay("trailingspace"); | |||
else if (!prev && val) | |||
cm.addOverlay({ | |||
token: function(stream) { | |||
for (var l = stream.string.length, i = l; i && /\s/.test(stream.string.charAt(i - 1)); --i) {} | |||
if (i > stream.pos) { stream.pos = i; return null; } | |||
stream.pos = l; | |||
return "trailingspace"; | |||
}, | |||
name: "trailingspace" | |||
}); | |||
}); | |||
}); |
@ -0,0 +1,105 @@ | |||
// 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.registerHelper("fold", "brace", function(cm, start) { | |||
var line = start.line, lineText = cm.getLine(line); | |||
var tokenType; | |||
function findOpening(openCh) { | |||
for (var at = start.ch, pass = 0;;) { | |||
var found = at <= 0 ? -1 : lineText.lastIndexOf(openCh, at - 1); | |||
if (found == -1) { | |||
if (pass == 1) break; | |||
pass = 1; | |||
at = lineText.length; | |||
continue; | |||
} | |||
if (pass == 1 && found < start.ch) break; | |||
tokenType = cm.getTokenTypeAt(CodeMirror.Pos(line, found + 1)); | |||
if (!/^(comment|string)/.test(tokenType)) return found + 1; | |||
at = found - 1; | |||
} | |||
} | |||
var startToken = "{", endToken = "}", startCh = findOpening("{"); | |||
if (startCh == null) { | |||
startToken = "[", endToken = "]"; | |||
startCh = findOpening("["); | |||
} | |||
if (startCh == null) return; | |||
var count = 1, lastLine = cm.lastLine(), end, endCh; | |||
outer: for (var i = line; i <= lastLine; ++i) { | |||
var text = cm.getLine(i), pos = i == line ? startCh : 0; | |||
for (;;) { | |||
var nextOpen = text.indexOf(startToken, pos), nextClose = text.indexOf(endToken, pos); | |||
if (nextOpen < 0) nextOpen = text.length; | |||
if (nextClose < 0) nextClose = text.length; | |||
pos = Math.min(nextOpen, nextClose); | |||
if (pos == text.length) break; | |||
if (cm.getTokenTypeAt(CodeMirror.Pos(i, pos + 1)) == tokenType) { | |||
if (pos == nextOpen) ++count; | |||
else if (!--count) { end = i; endCh = pos; break outer; } | |||
} | |||
++pos; | |||
} | |||
} | |||
if (end == null || line == end) return; | |||
return {from: CodeMirror.Pos(line, startCh), | |||
to: CodeMirror.Pos(end, endCh)}; | |||
}); | |||
CodeMirror.registerHelper("fold", "import", function(cm, start) { | |||
function hasImport(line) { | |||
if (line < cm.firstLine() || line > cm.lastLine()) return null; | |||
var start = cm.getTokenAt(CodeMirror.Pos(line, 1)); | |||
if (!/\S/.test(start.string)) start = cm.getTokenAt(CodeMirror.Pos(line, start.end + 1)); | |||
if (start.type != "keyword" || start.string != "import") return null; | |||
// Now find closing semicolon, return its position | |||
for (var i = line, e = Math.min(cm.lastLine(), line + 10); i <= e; ++i) { | |||
var text = cm.getLine(i), semi = text.indexOf(";"); | |||
if (semi != -1) return {startCh: start.end, end: CodeMirror.Pos(i, semi)}; | |||
} | |||
} | |||
var startLine = start.line, has = hasImport(startLine), prev; | |||
if (!has || hasImport(startLine - 1) || ((prev = hasImport(startLine - 2)) && prev.end.line == startLine - 1)) | |||
return null; | |||
for (var end = has.end;;) { | |||
var next = hasImport(end.line + 1); | |||
if (next == null) break; | |||
end = next.end; | |||
} | |||
return {from: cm.clipPos(CodeMirror.Pos(startLine, has.startCh + 1)), to: end}; | |||
}); | |||
CodeMirror.registerHelper("fold", "include", function(cm, start) { | |||
function hasInclude(line) { | |||
if (line < cm.firstLine() || line > cm.lastLine()) return null; | |||
var start = cm.getTokenAt(CodeMirror.Pos(line, 1)); | |||
if (!/\S/.test(start.string)) start = cm.getTokenAt(CodeMirror.Pos(line, start.end + 1)); | |||
if (start.type == "meta" && start.string.slice(0, 8) == "#include") return start.start + 8; | |||
} | |||
var startLine = start.line, has = hasInclude(startLine); | |||
if (has == null || hasInclude(startLine - 1) != null) return null; | |||
for (var end = startLine;;) { | |||
var next = hasInclude(end + 1); | |||
if (next == null) break; | |||
++end; | |||
} | |||
return {from: CodeMirror.Pos(startLine, has + 1), | |||
to: cm.clipPos(CodeMirror.Pos(end))}; | |||
}); | |||
}); |
@ -0,0 +1,59 @@ | |||
// 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.registerGlobalHelper("fold", "comment", function(mode) { | |||
return mode.blockCommentStart && mode.blockCommentEnd; | |||
}, function(cm, start) { | |||
var mode = cm.getModeAt(start), startToken = mode.blockCommentStart, endToken = mode.blockCommentEnd; | |||
if (!startToken || !endToken) return; | |||
var line = start.line, lineText = cm.getLine(line); | |||
var startCh; | |||
for (var at = start.ch, pass = 0;;) { | |||
var found = at <= 0 ? -1 : lineText.lastIndexOf(startToken, at - 1); | |||
if (found == -1) { | |||
if (pass == 1) return; | |||
pass = 1; | |||
at = lineText.length; | |||
continue; | |||
} | |||
if (pass == 1 && found < start.ch) return; | |||
if (/comment/.test(cm.getTokenTypeAt(CodeMirror.Pos(line, found + 1))) && | |||
(found == 0 || lineText.slice(found - endToken.length, found) == endToken || | |||
!/comment/.test(cm.getTokenTypeAt(CodeMirror.Pos(line, found))))) { | |||
startCh = found + startToken.length; | |||
break; | |||
} | |||
at = found - 1; | |||
} | |||
var depth = 1, lastLine = cm.lastLine(), end, endCh; | |||
outer: for (var i = line; i <= lastLine; ++i) { | |||
var text = cm.getLine(i), pos = i == line ? startCh : 0; | |||
for (;;) { | |||
var nextOpen = text.indexOf(startToken, pos), nextClose = text.indexOf(endToken, pos); | |||
if (nextOpen < 0) nextOpen = text.length; | |||
if (nextClose < 0) nextClose = text.length; | |||
pos = Math.min(nextOpen, nextClose); | |||
if (pos == text.length) break; | |||
if (pos == nextOpen) ++depth; | |||
else if (!--depth) { end = i; endCh = pos; break outer; } | |||
++pos; | |||
} | |||
} | |||
if (end == null || line == end && endCh == startCh) return; | |||
return {from: CodeMirror.Pos(line, startCh), | |||
to: CodeMirror.Pos(end, endCh)}; | |||
}); | |||
}); |
@ -0,0 +1,152 @@ | |||
// 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"; | |||
function doFold(cm, pos, options, force) { | |||
if (options && options.call) { | |||
var finder = options; | |||
options = null; | |||
} else { | |||
var finder = getOption(cm, options, "rangeFinder"); | |||
} | |||
if (typeof pos == "number") pos = CodeMirror.Pos(pos, 0); | |||
var minSize = getOption(cm, options, "minFoldSize"); | |||
function getRange(allowFolded) { | |||
var range = finder(cm, pos); | |||
if (!range || range.to.line - range.from.line < minSize) return null; | |||
var marks = cm.findMarksAt(range.from); | |||
for (var i = 0; i < marks.length; ++i) { | |||
if (marks[i].__isFold && force !== "fold") { | |||
if (!allowFolded) return null; | |||
range.cleared = true; | |||
marks[i].clear(); | |||
} | |||
} | |||
return range; | |||
} | |||
var range = getRange(true); | |||
if (getOption(cm, options, "scanUp")) while (!range && pos.line > cm.firstLine()) { | |||
pos = CodeMirror.Pos(pos.line - 1, 0); | |||
range = getRange(false); | |||
} | |||
if (!range || range.cleared || force === "unfold") return; | |||
var myWidget = makeWidget(cm, options); | |||
CodeMirror.on(myWidget, "mousedown", function(e) { | |||
myRange.clear(); | |||
CodeMirror.e_preventDefault(e); | |||
}); | |||
var myRange = cm.markText(range.from, range.to, { | |||
replacedWith: myWidget, | |||
clearOnEnter: getOption(cm, options, "clearOnEnter"), | |||
__isFold: true | |||
}); | |||
myRange.on("clear", function(from, to) { | |||
CodeMirror.signal(cm, "unfold", cm, from, to); | |||
}); | |||
CodeMirror.signal(cm, "fold", cm, range.from, range.to); | |||
} | |||
function makeWidget(cm, options) { | |||
var widget = getOption(cm, options, "widget"); | |||
if (typeof widget == "string") { | |||
var text = document.createTextNode(widget); | |||
widget = document.createElement("span"); | |||
widget.appendChild(text); | |||
widget.className = "CodeMirror-foldmarker"; | |||
} else if (widget) { | |||
widget = widget.cloneNode(true) | |||
} | |||
return widget; | |||
} | |||
// Clumsy backwards-compatible interface | |||
CodeMirror.newFoldFunction = function(rangeFinder, widget) { | |||
return function(cm, pos) { doFold(cm, pos, {rangeFinder: rangeFinder, widget: widget}); }; | |||
}; | |||
// New-style interface | |||
CodeMirror.defineExtension("foldCode", function(pos, options, force) { | |||
doFold(this, pos, options, force); | |||
}); | |||
CodeMirror.defineExtension("isFolded", function(pos) { | |||
var marks = this.findMarksAt(pos); | |||
for (var i = 0; i < marks.length; ++i) | |||
if (marks[i].__isFold) return true; | |||
}); | |||
CodeMirror.commands.toggleFold = function(cm) { | |||
cm.foldCode(cm.getCursor()); | |||
}; | |||
CodeMirror.commands.fold = function(cm) { | |||
cm.foldCode(cm.getCursor(), null, "fold"); | |||
}; | |||
CodeMirror.commands.unfold = function(cm) { | |||
cm.foldCode(cm.getCursor(), null, "unfold"); | |||
}; | |||
CodeMirror.commands.foldAll = function(cm) { | |||
cm.operation(function() { | |||
for (var i = cm.firstLine(), e = cm.lastLine(); i <= e; i++) | |||
cm.foldCode(CodeMirror.Pos(i, 0), null, "fold"); | |||
}); | |||
}; | |||
CodeMirror.commands.unfoldAll = function(cm) { | |||
cm.operation(function() { | |||
for (var i = cm.firstLine(), e = cm.lastLine(); i <= e; i++) | |||
cm.foldCode(CodeMirror.Pos(i, 0), null, "unfold"); | |||
}); | |||
}; | |||
CodeMirror.registerHelper("fold", "combine", function() { | |||
var funcs = Array.prototype.slice.call(arguments, 0); | |||
return function(cm, start) { | |||
for (var i = 0; i < funcs.length; ++i) { | |||
var found = funcs[i](cm, start); | |||
if (found) return found; | |||
} | |||
}; | |||
}); | |||
CodeMirror.registerHelper("fold", "auto", function(cm, start) { | |||
var helpers = cm.getHelpers(start, "fold"); | |||
for (var i = 0; i < helpers.length; i++) { | |||
var cur = helpers[i](cm, start); | |||
if (cur) return cur; | |||
} | |||
}); | |||
var defaultOptions = { | |||
rangeFinder: CodeMirror.fold.auto, | |||
widget: "\u2194", | |||
minFoldSize: 0, | |||
scanUp: false, | |||
clearOnEnter: true | |||
}; | |||
CodeMirror.defineOption("foldOptions", null); | |||
function getOption(cm, options, name) { | |||
if (options && options[name] !== undefined) | |||
return options[name]; | |||
var editorOptions = cm.options.foldOptions; | |||
if (editorOptions && editorOptions[name] !== undefined) | |||
return editorOptions[name]; | |||
return defaultOptions[name]; | |||
} | |||
CodeMirror.defineExtension("foldOption", function(options, name) { | |||
return getOption(this, options, name); | |||
}); | |||
}); |
@ -0,0 +1,20 @@ | |||
.CodeMirror-foldmarker { | |||
color: blue; | |||
text-shadow: #b9f 1px 1px 2px, #b9f -1px -1px 2px, #b9f 1px -1px 2px, #b9f -1px 1px 2px; | |||
font-family: arial; | |||
line-height: .3; | |||
cursor: pointer; | |||
} | |||
.CodeMirror-foldgutter { | |||
width: .7em; | |||
} | |||
.CodeMirror-foldgutter-open, | |||
.CodeMirror-foldgutter-folded { | |||
cursor: pointer; | |||
} | |||
.CodeMirror-foldgutter-open:after { | |||
content: "\25BE"; | |||
} | |||
.CodeMirror-foldgutter-folded:after { | |||
content: "\25B8"; | |||
} |
@ -0,0 +1,151 @@ | |||
// 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"), require("./foldcode")); | |||
else if (typeof define == "function" && define.amd) // AMD | |||
define(["../../lib/codemirror", "./foldcode"], mod); | |||
else // Plain browser env | |||
mod(CodeMirror); | |||
})(function(CodeMirror) { | |||
"use strict"; | |||
CodeMirror.defineOption("foldGutter", false, function(cm, val, old) { | |||
if (old && old != CodeMirror.Init) { | |||
cm.clearGutter(cm.state.foldGutter.options.gutter); | |||
cm.state.foldGutter = null; | |||
cm.off("gutterClick", onGutterClick); | |||
cm.off("changes", onChange); | |||
cm.off("viewportChange", onViewportChange); | |||
cm.off("fold", onFold); | |||
cm.off("unfold", onFold); | |||
cm.off("swapDoc", onChange); | |||
} | |||
if (val) { | |||
cm.state.foldGutter = new State(parseOptions(val)); | |||
updateInViewport(cm); | |||
cm.on("gutterClick", onGutterClick); | |||
cm.on("changes", onChange); | |||
cm.on("viewportChange", onViewportChange); | |||
cm.on("fold", onFold); | |||
cm.on("unfold", onFold); | |||
cm.on("swapDoc", onChange); | |||
} | |||
}); | |||
var Pos = CodeMirror.Pos; | |||
function State(options) { | |||
this.options = options; | |||
this.from = this.to = 0; | |||
} | |||
function parseOptions(opts) { | |||
if (opts === true) opts = {}; | |||
if (opts.gutter == null) opts.gutter = "CodeMirror-foldgutter"; | |||
if (opts.indicatorOpen == null) opts.indicatorOpen = "CodeMirror-foldgutter-open"; | |||
if (opts.indicatorFolded == null) opts.indicatorFolded = "CodeMirror-foldgutter-folded"; | |||
return opts; | |||
} | |||
function isFolded(cm, line) { | |||
var marks = cm.findMarks(Pos(line, 0), Pos(line + 1, 0)); | |||
for (var i = 0; i < marks.length; ++i) { | |||
if (marks[i].__isFold) { | |||
var fromPos = marks[i].find(-1); | |||
if (fromPos && fromPos.line === line) | |||
return marks[i]; | |||
} | |||
} | |||
} | |||
function marker(spec) { | |||
if (typeof spec == "string") { | |||
var elt = document.createElement("div"); | |||
elt.className = spec + " CodeMirror-guttermarker-subtle"; | |||
return elt; | |||
} else { | |||
return spec.cloneNode(true); | |||
} | |||
} | |||
function updateFoldInfo(cm, from, to) { | |||
var opts = cm.state.foldGutter.options, cur = from; | |||
var minSize = cm.foldOption(opts, "minFoldSize"); | |||
var func = cm.foldOption(opts, "rangeFinder"); | |||
cm.eachLine(from, to, function(line) { | |||
var mark = null; | |||
if (isFolded(cm, cur)) { | |||
mark = marker(opts.indicatorFolded); | |||
} else { | |||
var pos = Pos(cur, 0); | |||
var range = func && func(cm, pos); | |||
if (range && range.to.line - range.from.line >= minSize) | |||
mark = marker(opts.indicatorOpen); | |||
} | |||
cm.setGutterMarker(line, opts.gutter, mark); | |||
++cur; | |||
}); | |||
} | |||
function updateInViewport(cm) { | |||
var vp = cm.getViewport(), state = cm.state.foldGutter; | |||
if (!state) return; | |||
cm.operation(function() { | |||
updateFoldInfo(cm, vp.from, vp.to); | |||
}); | |||
state.from = vp.from; state.to = vp.to; | |||
} | |||
function onGutterClick(cm, line, gutter) { | |||
var state = cm.state.foldGutter; | |||
if (!state) return; | |||
var opts = state.options; | |||
if (gutter != opts.gutter) return; | |||
var folded = isFolded(cm, line); | |||
if (folded) folded.clear(); | |||
else cm.foldCode(Pos(line, 0), opts); | |||
} | |||
function onChange(cm) { | |||
var state = cm.state.foldGutter; | |||
if (!state) return; | |||
var opts = state.options; | |||
state.from = state.to = 0; | |||
clearTimeout(state.changeUpdate); | |||
state.changeUpdate = setTimeout(function() { updateInViewport(cm); }, opts.foldOnChangeTimeSpan || 600); | |||
} | |||
function onViewportChange(cm) { | |||
var state = cm.state.foldGutter; | |||
if (!state) return; | |||
var opts = state.options; | |||
clearTimeout(state.changeUpdate); | |||
state.changeUpdate = setTimeout(function() { | |||
var vp = cm.getViewport(); | |||
if (state.from == state.to || vp.from - state.to > 20 || state.from - vp.to > 20) { | |||
updateInViewport(cm); | |||
} else { | |||
cm.operation(function() { | |||
if (vp.from < state.from) { | |||
updateFoldInfo(cm, vp.from, state.from); | |||
state.from = vp.from; | |||
} | |||
if (vp.to > state.to) { | |||
updateFoldInfo(cm, state.to, vp.to); | |||
state.to = vp.to; | |||
} | |||
}); | |||
} | |||
}, opts.updateViewportTimeSpan || 400); | |||
} | |||
function onFold(cm, from) { | |||
var state = cm.state.foldGutter; | |||
if (!state) return; | |||
var line = from.line; | |||
if (line >= state.from && line < state.to) | |||
updateFoldInfo(cm, line, line + 1); | |||
} | |||
}); |
@ -0,0 +1,48 @@ | |||
// 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"; | |||
function lineIndent(cm, lineNo) { | |||
var text = cm.getLine(lineNo) | |||
var spaceTo = text.search(/\S/) | |||
if (spaceTo == -1 || /\bcomment\b/.test(cm.getTokenTypeAt(CodeMirror.Pos(lineNo, spaceTo + 1)))) | |||
return -1 | |||
return CodeMirror.countColumn(text, null, cm.getOption("tabSize")) | |||
} | |||
CodeMirror.registerHelper("fold", "indent", function(cm, start) { | |||
var myIndent = lineIndent(cm, start.line) | |||
if (myIndent < 0) return | |||
var lastLineInFold = null | |||
// Go through lines until we find a line that definitely doesn't belong in | |||
// the block we're folding, or to the end. | |||
for (var i = start.line + 1, end = cm.lastLine(); i <= end; ++i) { | |||
var indent = lineIndent(cm, i) | |||
if (indent == -1) { | |||
} else if (indent > myIndent) { | |||
// Lines with a greater indent are considered part of the block. | |||
lastLineInFold = i; | |||
} else { | |||
// If this line has non-space, non-comment content, and is | |||
// indented less or equal to the start line, it is the start of | |||
// another block. | |||
break; | |||
} | |||
} | |||
if (lastLineInFold) return { | |||
from: CodeMirror.Pos(start.line, cm.getLine(start.line).length), | |||
to: CodeMirror.Pos(lastLineInFold, cm.getLine(lastLineInFold).length) | |||
}; | |||
}); | |||
}); |
@ -0,0 +1,49 @@ | |||
// 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.registerHelper("fold", "markdown", function(cm, start) { | |||
var maxDepth = 100; | |||
function isHeader(lineNo) { | |||
var tokentype = cm.getTokenTypeAt(CodeMirror.Pos(lineNo, 0)); | |||
return tokentype && /\bheader\b/.test(tokentype); | |||
} | |||
function headerLevel(lineNo, line, nextLine) { | |||
var match = line && line.match(/^#+/); | |||
if (match && isHeader(lineNo)) return match[0].length; | |||
match = nextLine && nextLine.match(/^[=\-]+\s*$/); | |||
if (match && isHeader(lineNo + 1)) return nextLine[0] == "=" ? 1 : 2; | |||
return maxDepth; | |||
} | |||
var firstLine = cm.getLine(start.line), nextLine = cm.getLine(start.line + 1); | |||
var level = headerLevel(start.line, firstLine, nextLine); | |||
if (level === maxDepth) return undefined; | |||
var lastLineNo = cm.lastLine(); | |||
var end = start.line, nextNextLine = cm.getLine(end + 2); | |||
while (end < lastLineNo) { | |||
if (headerLevel(end + 1, nextLine, nextNextLine) <= level) break; | |||
++end; | |||
nextLine = nextNextLine; | |||
nextNextLine = cm.getLine(end + 2); | |||
} | |||
return { | |||
from: CodeMirror.Pos(start.line, firstLine.length), | |||
to: CodeMirror.Pos(end, cm.getLine(end).length) | |||
}; | |||
}); | |||
}); |
@ -0,0 +1,184 @@ | |||
// 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"; | |||
var Pos = CodeMirror.Pos; | |||
function cmp(a, b) { return a.line - b.line || a.ch - b.ch; } | |||
var nameStartChar = "A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD"; | |||
var nameChar = nameStartChar + "\-\:\.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040"; | |||
var xmlTagStart = new RegExp("<(/?)([" + nameStartChar + "][" + nameChar + "]*)", "g"); | |||
function Iter(cm, line, ch, range) { | |||
this.line = line; this.ch = ch; | |||
this.cm = cm; this.text = cm.getLine(line); | |||
this.min = range ? Math.max(range.from, cm.firstLine()) : cm.firstLine(); | |||
this.max = range ? Math.min(range.to - 1, cm.lastLine()) : cm.lastLine(); | |||
} | |||
function tagAt(iter, ch) { | |||
var type = iter.cm.getTokenTypeAt(Pos(iter.line, ch)); | |||
return type && /\btag\b/.test(type); | |||
} | |||
function nextLine(iter) { | |||
if (iter.line >= iter.max) return; | |||
iter.ch = 0; | |||
iter.text = iter.cm.getLine(++iter.line); | |||
return true; | |||
} | |||
function prevLine(iter) { | |||
if (iter.line <= iter.min) return; | |||
iter.text = iter.cm.getLine(--iter.line); | |||
iter.ch = iter.text.length; | |||
return true; | |||
} | |||
function toTagEnd(iter) { | |||
for (;;) { | |||
var gt = iter.text.indexOf(">", iter.ch); | |||
if (gt == -1) { if (nextLine(iter)) continue; else return; } | |||
if (!tagAt(iter, gt + 1)) { iter.ch = gt + 1; continue; } | |||
var lastSlash = iter.text.lastIndexOf("/", gt); | |||
var selfClose = lastSlash > -1 && !/\S/.test(iter.text.slice(lastSlash + 1, gt)); | |||
iter.ch = gt + 1; | |||
return selfClose ? "selfClose" : "regular"; | |||
} | |||
} | |||
function toTagStart(iter) { | |||
for (;;) { | |||
var lt = iter.ch ? iter.text.lastIndexOf("<", iter.ch - 1) : -1; | |||
if (lt == -1) { if (prevLine(iter)) continue; else return; } | |||
if (!tagAt(iter, lt + 1)) { iter.ch = lt; continue; } | |||
xmlTagStart.lastIndex = lt; | |||
iter.ch = lt; | |||
var match = xmlTagStart.exec(iter.text); | |||
if (match && match.index == lt) return match; | |||
} | |||
} | |||
function toNextTag(iter) { | |||
for (;;) { | |||
xmlTagStart.lastIndex = iter.ch; | |||
var found = xmlTagStart.exec(iter.text); | |||
if (!found) { if (nextLine(iter)) continue; else return; } | |||
if (!tagAt(iter, found.index + 1)) { iter.ch = found.index + 1; continue; } | |||
iter.ch = found.index + found[0].length; | |||
return found; | |||
} | |||
} | |||
function toPrevTag(iter) { | |||
for (;;) { | |||
var gt = iter.ch ? iter.text.lastIndexOf(">", iter.ch - 1) : -1; | |||
if (gt == -1) { if (prevLine(iter)) continue; else return; } | |||
if (!tagAt(iter, gt + 1)) { iter.ch = gt; continue; } | |||
var lastSlash = iter.text.lastIndexOf("/", gt); | |||
var selfClose = lastSlash > -1 && !/\S/.test(iter.text.slice(lastSlash + 1, gt)); | |||
iter.ch = gt + 1; | |||
return selfClose ? "selfClose" : "regular"; | |||
} | |||
} | |||
function findMatchingClose(iter, tag) { | |||
var stack = []; | |||
for (;;) { | |||
var next = toNextTag(iter), end, startLine = iter.line, startCh = iter.ch - (next ? next[0].length : 0); | |||
if (!next || !(end = toTagEnd(iter))) return; | |||
if (end == "selfClose") continue; | |||
if (next[1]) { // closing tag | |||
for (var i = stack.length - 1; i >= 0; --i) if (stack[i] == next[2]) { | |||
stack.length = i; | |||
break; | |||
} | |||
if (i < 0 && (!tag || tag == next[2])) return { | |||
tag: next[2], | |||
from: Pos(startLine, startCh), | |||
to: Pos(iter.line, iter.ch) | |||
}; | |||
} else { // opening tag | |||
stack.push(next[2]); | |||
} | |||
} | |||
} | |||
function findMatchingOpen(iter, tag) { | |||
var stack = []; | |||
for (;;) { | |||
var prev = toPrevTag(iter); | |||
if (!prev) return; | |||
if (prev == "selfClose") { toTagStart(iter); continue; } | |||
var endLine = iter.line, endCh = iter.ch; | |||
var start = toTagStart(iter); | |||
if (!start) return; | |||
if (start[1]) { // closing tag | |||
stack.push(start[2]); | |||
} else { // opening tag | |||
for (var i = stack.length - 1; i >= 0; --i) if (stack[i] == start[2]) { | |||
stack.length = i; | |||
break; | |||
} | |||
if (i < 0 && (!tag || tag == start[2])) return { | |||
tag: start[2], | |||
from: Pos(iter.line, iter.ch), | |||
to: Pos(endLine, endCh) | |||
}; | |||
} | |||
} | |||
} | |||
CodeMirror.registerHelper("fold", "xml", function(cm, start) { | |||
var iter = new Iter(cm, start.line, 0); | |||
for (;;) { | |||
var openTag = toNextTag(iter) | |||
if (!openTag || iter.line != start.line) return | |||
var end = toTagEnd(iter) | |||
if (!end) return | |||
if (!openTag[1] && end != "selfClose") { | |||
var startPos = Pos(iter.line, iter.ch); | |||
var endPos = findMatchingClose(iter, openTag[2]); | |||
return endPos && cmp(endPos.from, startPos) > 0 ? {from: startPos, to: endPos.from} : null | |||
} | |||
} | |||
}); | |||
CodeMirror.findMatchingTag = function(cm, pos, range) { | |||
var iter = new Iter(cm, pos.line, pos.ch, range); | |||
if (iter.text.indexOf(">") == -1 && iter.text.indexOf("<") == -1) return; | |||
var end = toTagEnd(iter), to = end && Pos(iter.line, iter.ch); | |||
var start = end && toTagStart(iter); | |||
if (!end || !start || cmp(iter, pos) > 0) return; | |||
var here = {from: Pos(iter.line, iter.ch), to: to, tag: start[2]}; | |||
if (end == "selfClose") return {open: here, close: null, at: "open"}; | |||
if (start[1]) { // closing tag | |||
return {open: findMatchingOpen(iter, start[2]), close: here, at: "close"}; | |||
} else { // opening tag | |||
iter = new Iter(cm, to.line, to.ch, range); | |||
return {open: here, close: findMatchingClose(iter, start[2]), at: "open"}; | |||
} | |||
}; | |||
CodeMirror.findEnclosingTag = function(cm, pos, range, tag) { | |||
var iter = new Iter(cm, pos.line, pos.ch, range); | |||
for (;;) { | |||
var open = findMatchingOpen(iter, tag); | |||
if (!open) break; | |||
var forward = new Iter(cm, pos.line, pos.ch, range); | |||
var close = findMatchingClose(forward, open.tag); | |||
if (close) return {open: open, close: close}; | |||
} | |||
}; | |||
// Used by addon/edit/closetag.js | |||
CodeMirror.scanForClosingTag = function(cm, pos, name, end) { | |||
var iter = new Iter(cm, pos.line, pos.ch, end ? {from: 0, to: end} : null); | |||
return findMatchingClose(iter, name); | |||
}; | |||
}); |
@ -0,0 +1,41 @@ | |||
// 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"; | |||
var WORD = /[\w$]+/, RANGE = 500; | |||
CodeMirror.registerHelper("hint", "anyword", function(editor, options) { | |||
var word = options && options.word || WORD; | |||
var range = options && options.range || RANGE; | |||
var cur = editor.getCursor(), curLine = editor.getLine(cur.line); | |||
var end = cur.ch, start = end; | |||
while (start && word.test(curLine.charAt(start - 1))) --start; | |||
var curWord = start != end && curLine.slice(start, end); | |||
var list = options && options.list || [], seen = {}; | |||
var re = new RegExp(word.source, "g"); | |||
for (var dir = -1; dir <= 1; dir += 2) { | |||
var line = cur.line, endLine = Math.min(Math.max(line + dir * range, editor.firstLine()), editor.lastLine()) + dir; | |||
for (; line != endLine; line += dir) { | |||
var text = editor.getLine(line), m; | |||
while (m = re.exec(text)) { | |||
if (line == cur.line && m[0] === curWord) continue; | |||
if ((!curWord || m[0].lastIndexOf(curWord, 0) == 0) && !Object.prototype.hasOwnProperty.call(seen, m[0])) { | |||
seen[m[0]] = true; | |||
list.push(m[0]); | |||
} | |||
} | |||
} | |||
} | |||
return {list: list, from: CodeMirror.Pos(cur.line, start), to: CodeMirror.Pos(cur.line, end)}; | |||
}); | |||
}); |
@ -0,0 +1,60 @@ | |||
// 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"), require("../../mode/css/css")); | |||
else if (typeof define == "function" && define.amd) // AMD | |||
define(["../../lib/codemirror", "../../mode/css/css"], mod); | |||
else // Plain browser env | |||
mod(CodeMirror); | |||
})(function(CodeMirror) { | |||
"use strict"; | |||
var pseudoClasses = {link: 1, visited: 1, active: 1, hover: 1, focus: 1, | |||
"first-letter": 1, "first-line": 1, "first-child": 1, | |||
before: 1, after: 1, lang: 1}; | |||
CodeMirror.registerHelper("hint", "css", function(cm) { | |||
var cur = cm.getCursor(), token = cm.getTokenAt(cur); | |||
var inner = CodeMirror.innerMode(cm.getMode(), token.state); | |||
if (inner.mode.name != "css") return; | |||
if (token.type == "keyword" && "!important".indexOf(token.string) == 0) | |||
return {list: ["!important"], from: CodeMirror.Pos(cur.line, token.start), | |||
to: CodeMirror.Pos(cur.line, token.end)}; | |||
var start = token.start, end = cur.ch, word = token.string.slice(0, end - start); | |||
if (/[^\w$_-]/.test(word)) { | |||
word = ""; start = end = cur.ch; | |||
} | |||
var spec = CodeMirror.resolveMode("text/css"); | |||
var result = []; | |||
function add(keywords) { | |||
for (var name in keywords) | |||
if (!word || name.lastIndexOf(word, 0) == 0) | |||
result.push(name); | |||
} | |||
var st = inner.state.state; | |||
if (st == "pseudo" || token.type == "variable-3") { | |||
add(pseudoClasses); | |||
} else if (st == "block" || st == "maybeprop") { | |||
add(spec.propertyKeywords); | |||
} else if (st == "prop" || st == "parens" || st == "at" || st == "params") { | |||
add(spec.valueKeywords); | |||
add(spec.colorKeywords); | |||
} else if (st == "media" || st == "media_parens") { | |||
add(spec.mediaTypes); | |||
add(spec.mediaFeatures); | |||
} | |||
if (result.length) return { | |||
list: result, | |||
from: CodeMirror.Pos(cur.line, start), | |||
to: CodeMirror.Pos(cur.line, end) | |||
}; | |||
}); | |||
}); |
@ -0,0 +1,350 @@ | |||
// 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"), require("./xml-hint")); | |||
else if (typeof define == "function" && define.amd) // AMD | |||
define(["../../lib/codemirror", "./xml-hint"], mod); | |||
else // Plain browser env | |||
mod(CodeMirror); | |||
})(function(CodeMirror) { | |||
"use strict"; | |||
var langs = "ab aa af ak sq am ar an hy as av ae ay az bm ba eu be bn bh bi bs br bg my ca ch ce ny zh cv kw co cr hr cs da dv nl dz en eo et ee fo fj fi fr ff gl ka de el gn gu ht ha he hz hi ho hu ia id ie ga ig ik io is it iu ja jv kl kn kr ks kk km ki rw ky kv kg ko ku kj la lb lg li ln lo lt lu lv gv mk mg ms ml mt mi mr mh mn na nv nb nd ne ng nn no ii nr oc oj cu om or os pa pi fa pl ps pt qu rm rn ro ru sa sc sd se sm sg sr gd sn si sk sl so st es su sw ss sv ta te tg th ti bo tk tl tn to tr ts tt tw ty ug uk ur uz ve vi vo wa cy wo fy xh yi yo za zu".split(" "); | |||
var targets = ["_blank", "_self", "_top", "_parent"]; | |||
var charsets = ["ascii", "utf-8", "utf-16", "latin1", "latin1"]; | |||
var methods = ["get", "post", "put", "delete"]; | |||
var encs = ["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"]; | |||
var media = ["all", "screen", "print", "embossed", "braille", "handheld", "print", "projection", "screen", "tty", "tv", "speech", | |||
"3d-glasses", "resolution [>][<][=] [X]", "device-aspect-ratio: X/Y", "orientation:portrait", | |||
"orientation:landscape", "device-height: [X]", "device-width: [X]"]; | |||
var s = { attrs: {} }; // Simple tag, reused for a whole lot of tags | |||
var data = { | |||
a: { | |||
attrs: { | |||
href: null, ping: null, type: null, | |||
media: media, | |||
target: targets, | |||
hreflang: langs | |||
} | |||
}, | |||
abbr: s, | |||
acronym: s, | |||
address: s, | |||
applet: s, | |||
area: { | |||
attrs: { | |||
alt: null, coords: null, href: null, target: null, ping: null, | |||
media: media, hreflang: langs, type: null, | |||
shape: ["default", "rect", "circle", "poly"] | |||
} | |||
}, | |||
article: s, | |||
aside: s, | |||
audio: { | |||
attrs: { | |||
src: null, mediagroup: null, | |||
crossorigin: ["anonymous", "use-credentials"], | |||
preload: ["none", "metadata", "auto"], | |||
autoplay: ["", "autoplay"], | |||
loop: ["", "loop"], | |||
controls: ["", "controls"] | |||
} | |||
}, | |||
b: s, | |||
base: { attrs: { href: null, target: targets } }, | |||
basefont: s, | |||
bdi: s, | |||
bdo: s, | |||
big: s, | |||
blockquote: { attrs: { cite: null } }, | |||
body: s, | |||
br: s, | |||
button: { | |||
attrs: { | |||
form: null, formaction: null, name: null, value: null, | |||
autofocus: ["", "autofocus"], | |||
disabled: ["", "autofocus"], | |||
formenctype: encs, | |||
formmethod: methods, | |||
formnovalidate: ["", "novalidate"], | |||
formtarget: targets, | |||
type: ["submit", "reset", "button"] | |||
} | |||
}, | |||
canvas: { attrs: { width: null, height: null } }, | |||
caption: s, | |||
center: s, | |||
cite: s, | |||
code: s, | |||
col: { attrs: { span: null } }, | |||
colgroup: { attrs: { span: null } }, | |||
command: { | |||
attrs: { | |||
type: ["command", "checkbox", "radio"], | |||
label: null, icon: null, radiogroup: null, command: null, title: null, | |||
disabled: ["", "disabled"], | |||
checked: ["", "checked"] | |||
} | |||
}, | |||
data: { attrs: { value: null } }, | |||
datagrid: { attrs: { disabled: ["", "disabled"], multiple: ["", "multiple"] } }, | |||
datalist: { attrs: { data: null } }, | |||
dd: s, | |||
del: { attrs: { cite: null, datetime: null } }, | |||
details: { attrs: { open: ["", "open"] } }, | |||
dfn: s, | |||
dir: s, | |||
div: s, | |||
dl: s, | |||
dt: s, | |||
em: s, | |||
embed: { attrs: { src: null, type: null, width: null, height: null } }, | |||
eventsource: { attrs: { src: null } }, | |||
fieldset: { attrs: { disabled: ["", "disabled"], form: null, name: null } }, | |||
figcaption: s, | |||
figure: s, | |||
font: s, | |||
footer: s, | |||
form: { | |||
attrs: { | |||
action: null, name: null, | |||
"accept-charset": charsets, | |||
autocomplete: ["on", "off"], | |||
enctype: encs, | |||
method: methods, | |||
novalidate: ["", "novalidate"], | |||
target: targets | |||
} | |||
}, | |||
frame: s, | |||
frameset: s, | |||
h1: s, h2: s, h3: s, h4: s, h5: s, h6: s, | |||
head: { | |||
attrs: {}, | |||
children: ["title", "base", "link", "style", "meta", "script", "noscript", "command"] | |||
}, | |||
header: s, | |||
hgroup: s, | |||
hr: s, | |||
html: { | |||
attrs: { manifest: null }, | |||
children: ["head", "body"] | |||
}, | |||
i: s, | |||
iframe: { | |||
attrs: { | |||
src: null, srcdoc: null, name: null, width: null, height: null, | |||
sandbox: ["allow-top-navigation", "allow-same-origin", "allow-forms", "allow-scripts"], | |||
seamless: ["", "seamless"] | |||
} | |||
}, | |||
img: { | |||
attrs: { | |||
alt: null, src: null, ismap: null, usemap: null, width: null, height: null, | |||
crossorigin: ["anonymous", "use-credentials"] | |||
} | |||
}, | |||
input: { | |||
attrs: { | |||
alt: null, dirname: null, form: null, formaction: null, | |||
height: null, list: null, max: null, maxlength: null, min: null, | |||
name: null, pattern: null, placeholder: null, size: null, src: null, | |||
step: null, value: null, width: null, | |||
accept: ["audio/*", "video/*", "image/*"], | |||
autocomplete: ["on", "off"], | |||
autofocus: ["", "autofocus"], | |||
checked: ["", "checked"], | |||
disabled: ["", "disabled"], | |||
formenctype: encs, | |||
formmethod: methods, | |||
formnovalidate: ["", "novalidate"], | |||
formtarget: targets, | |||
multiple: ["", "multiple"], | |||
readonly: ["", "readonly"], | |||
required: ["", "required"], | |||
type: ["hidden", "text", "search", "tel", "url", "email", "password", "datetime", "date", "month", | |||
"week", "time", "datetime-local", "number", "range", "color", "checkbox", "radio", | |||
"file", "submit", "image", "reset", "button"] | |||
} | |||
}, | |||
ins: { attrs: { cite: null, datetime: null } }, | |||
kbd: s, | |||
keygen: { | |||
attrs: { | |||
challenge: null, form: null, name: null, | |||
autofocus: ["", "autofocus"], | |||
disabled: ["", "disabled"], | |||
keytype: ["RSA"] | |||
} | |||
}, | |||
label: { attrs: { "for": null, form: null } }, | |||
legend: s, | |||
li: { attrs: { value: null } }, | |||
link: { | |||
attrs: { | |||
href: null, type: null, | |||
hreflang: langs, | |||
media: media, | |||
sizes: ["all", "16x16", "16x16 32x32", "16x16 32x32 64x64"] | |||
} | |||
}, | |||
map: { attrs: { name: null } }, | |||
mark: s, | |||
menu: { attrs: { label: null, type: ["list", "context", "toolbar"] } }, | |||
meta: { | |||
attrs: { | |||
content: null, | |||
charset: charsets, | |||
name: ["viewport", "application-name", "author", "description", "generator", "keywords"], | |||
"http-equiv": ["content-language", "content-type", "default-style", "refresh"] | |||
} | |||
}, | |||
meter: { attrs: { value: null, min: null, low: null, high: null, max: null, optimum: null } }, | |||
nav: s, | |||
noframes: s, | |||
noscript: s, | |||
object: { | |||
attrs: { | |||
data: null, type: null, name: null, usemap: null, form: null, width: null, height: null, | |||
typemustmatch: ["", "typemustmatch"] | |||
} | |||
}, | |||
ol: { attrs: { reversed: ["", "reversed"], start: null, type: ["1", "a", "A", "i", "I"] } }, | |||
optgroup: { attrs: { disabled: ["", "disabled"], label: null } }, | |||
option: { attrs: { disabled: ["", "disabled"], label: null, selected: ["", "selected"], value: null } }, | |||
output: { attrs: { "for": null, form: null, name: null } }, | |||
p: s, | |||
param: { attrs: { name: null, value: null } }, | |||
pre: s, | |||
progress: { attrs: { value: null, max: null } }, | |||
q: { attrs: { cite: null } }, | |||
rp: s, | |||
rt: s, | |||
ruby: s, | |||
s: s, | |||
samp: s, | |||
script: { | |||
attrs: { | |||
type: ["text/javascript"], | |||
src: null, | |||
async: ["", "async"], | |||
defer: ["", "defer"], | |||
charset: charsets | |||
} | |||
}, | |||
section: s, | |||
select: { | |||
attrs: { | |||
form: null, name: null, size: null, | |||
autofocus: ["", "autofocus"], | |||
disabled: ["", "disabled"], | |||
multiple: ["", "multiple"] | |||
} | |||
}, | |||
small: s, | |||
source: { attrs: { src: null, type: null, media: null } }, | |||
span: s, | |||
strike: s, | |||
strong: s, | |||
style: { | |||
attrs: { | |||
type: ["text/css"], | |||
media: media, | |||
scoped: null | |||
} | |||
}, | |||
sub: s, | |||
summary: s, | |||
sup: s, | |||
table: s, | |||
tbody: s, | |||
td: { attrs: { colspan: null, rowspan: null, headers: null } }, | |||
textarea: { | |||
attrs: { | |||
dirname: null, form: null, maxlength: null, name: null, placeholder: null, | |||
rows: null, cols: null, | |||
autofocus: ["", "autofocus"], | |||
disabled: ["", "disabled"], | |||
readonly: ["", "readonly"], | |||
required: ["", "required"], | |||
wrap: ["soft", "hard"] | |||
} | |||
}, | |||
tfoot: s, | |||
th: { attrs: { colspan: null, rowspan: null, headers: null, scope: ["row", "col", "rowgroup", "colgroup"] } }, | |||
thead: s, | |||
time: { attrs: { datetime: null } }, | |||
title: s, | |||
tr: s, | |||
track: { | |||
attrs: { | |||
src: null, label: null, "default": null, | |||
kind: ["subtitles", "captions", "descriptions", "chapters", "metadata"], | |||
srclang: langs | |||
} | |||
}, | |||
tt: s, | |||
u: s, | |||
ul: s, | |||
"var": s, | |||
video: { | |||
attrs: { | |||
src: null, poster: null, width: null, height: null, | |||
crossorigin: ["anonymous", "use-credentials"], | |||
preload: ["auto", "metadata", "none"], | |||
autoplay: ["", "autoplay"], | |||
mediagroup: ["movie"], | |||
muted: ["", "muted"], | |||
controls: ["", "controls"] | |||
} | |||
}, | |||
wbr: s | |||
}; | |||
var globalAttrs = { | |||
accesskey: ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"], | |||
"class": null, | |||
contenteditable: ["true", "false"], | |||
contextmenu: null, | |||
dir: ["ltr", "rtl", "auto"], | |||
draggable: ["true", "false", "auto"], | |||
dropzone: ["copy", "move", "link", "string:", "file:"], | |||
hidden: ["hidden"], | |||
id: null, | |||
inert: ["inert"], | |||
itemid: null, | |||
itemprop: null, | |||
itemref: null, | |||
itemscope: ["itemscope"], | |||
itemtype: null, | |||
lang: ["en", "es"], | |||
spellcheck: ["true", "false"], | |||
autocorrect: ["true", "false"], | |||
autocapitalize: ["true", "false"], | |||
style: null, | |||
tabindex: ["1", "2", "3", "4", "5", "6", "7", "8", "9"], | |||
title: null, | |||
translate: ["yes", "no"], | |||
onclick: null, | |||
rel: ["stylesheet", "alternate", "author", "bookmark", "help", "license", "next", "nofollow", "noreferrer", "prefetch", "prev", "search", "tag"] | |||
}; | |||
function populate(obj) { | |||
for (var attr in globalAttrs) if (globalAttrs.hasOwnProperty(attr)) | |||
obj.attrs[attr] = globalAttrs[attr]; | |||
} | |||
populate(s); | |||
for (var tag in data) if (data.hasOwnProperty(tag) && data[tag] != s) | |||
populate(data[tag]); | |||
CodeMirror.htmlSchema = data; | |||
function htmlHint(cm, options) { | |||
var local = {schemaInfo: data}; | |||
if (options) for (var opt in options) local[opt] = options[opt]; | |||
return CodeMirror.hint.xml(cm, local); | |||
} | |||
CodeMirror.registerHelper("hint", "html", htmlHint); | |||
}); |
@ -0,0 +1,157 @@ | |||
// 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) { | |||
var Pos = CodeMirror.Pos; | |||
function forEach(arr, f) { | |||
for (var i = 0, e = arr.length; i < e; ++i) f(arr[i]); | |||
} | |||
function arrayContains(arr, item) { | |||
if (!Array.prototype.indexOf) { | |||
var i = arr.length; | |||
while (i--) { | |||
if (arr[i] === item) { | |||
return true; | |||
} | |||
} | |||
return false; | |||
} | |||
return arr.indexOf(item) != -1; | |||
} | |||
function scriptHint(editor, keywords, getToken, options) { | |||
// Find the token at the cursor | |||
var cur = editor.getCursor(), token = getToken(editor, cur); | |||
if (/\b(?:string|comment)\b/.test(token.type)) return; | |||
var innerMode = CodeMirror.innerMode(editor.getMode(), token.state); | |||
if (innerMode.mode.helperType === "json") return; | |||
token.state = innerMode.state; | |||
// If it's not a 'word-style' token, ignore the token. | |||
if (!/^[\w$_]*$/.test(token.string)) { | |||
token = {start: cur.ch, end: cur.ch, string: "", state: token.state, | |||
type: token.string == "." ? "property" : null}; | |||
} else if (token.end > cur.ch) { | |||
token.end = cur.ch; | |||
token.string = token.string.slice(0, cur.ch - token.start); | |||
} | |||
var tprop = token; | |||
// If it is a property, find out what it is a property of. | |||
while (tprop.type == "property") { | |||
tprop = getToken(editor, Pos(cur.line, tprop.start)); | |||
if (tprop.string != ".") return; | |||
tprop = getToken(editor, Pos(cur.line, tprop.start)); | |||
if (!context) var context = []; | |||
context.push(tprop); | |||
} | |||
return {list: getCompletions(token, context, keywords, options), | |||
from: Pos(cur.line, token.start), | |||
to: Pos(cur.line, token.end)}; | |||
} | |||
function javascriptHint(editor, options) { | |||
return scriptHint(editor, javascriptKeywords, | |||
function (e, cur) {return e.getTokenAt(cur);}, | |||
options); | |||
}; | |||
CodeMirror.registerHelper("hint", "javascript", javascriptHint); | |||
function getCoffeeScriptToken(editor, cur) { | |||
// This getToken, it is for coffeescript, imitates the behavior of | |||
// getTokenAt method in javascript.js, that is, returning "property" | |||
// type and treat "." as indepenent token. | |||
var token = editor.getTokenAt(cur); | |||
if (cur.ch == token.start + 1 && token.string.charAt(0) == '.') { | |||
token.end = token.start; | |||
token.string = '.'; | |||
token.type = "property"; | |||
} | |||
else if (/^\.[\w$_]*$/.test(token.string)) { | |||
token.type = "property"; | |||
token.start++; | |||
token.string = token.string.replace(/\./, ''); | |||
} | |||
return token; | |||
} | |||
function coffeescriptHint(editor, options) { | |||
return scriptHint(editor, coffeescriptKeywords, getCoffeeScriptToken, options); | |||
} | |||
CodeMirror.registerHelper("hint", "coffeescript", coffeescriptHint); | |||
var stringProps = ("charAt charCodeAt indexOf lastIndexOf substring substr slice trim trimLeft trimRight " + | |||
"toUpperCase toLowerCase split concat match replace search").split(" "); | |||
var arrayProps = ("length concat join splice push pop shift unshift slice reverse sort indexOf " + | |||
"lastIndexOf every some filter forEach map reduce reduceRight ").split(" "); | |||
var funcProps = "prototype apply call bind".split(" "); | |||
var javascriptKeywords = ("break case catch class const continue debugger default delete do else export extends false finally for function " + | |||
"if in import instanceof new null return super switch this throw true try typeof var void while with yield").split(" "); | |||
var coffeescriptKeywords = ("and break catch class continue delete do else extends false finally for " + | |||
"if in instanceof isnt new no not null of off on or return switch then throw true try typeof until void while with yes").split(" "); | |||
function forAllProps(obj, callback) { | |||
if (!Object.getOwnPropertyNames || !Object.getPrototypeOf) { | |||
for (var name in obj) callback(name) | |||
} else { | |||
for (var o = obj; o; o = Object.getPrototypeOf(o)) | |||
Object.getOwnPropertyNames(o).forEach(callback) | |||
} | |||
} | |||
function getCompletions(token, context, keywords, options) { | |||
var found = [], start = token.string, global = options && options.globalScope || window; | |||
function maybeAdd(str) { | |||
if (str.lastIndexOf(start, 0) == 0 && !arrayContains(found, str)) found.push(str); | |||
} | |||
function gatherCompletions(obj) { | |||
if (typeof obj == "string") forEach(stringProps, maybeAdd); | |||
else if (obj instanceof Array) forEach(arrayProps, maybeAdd); | |||
else if (obj instanceof Function) forEach(funcProps, maybeAdd); | |||
forAllProps(obj, maybeAdd) | |||
} | |||
if (context && context.length) { | |||
// If this is a property, see if it belongs to some object we can | |||
// find in the current environment. | |||
var obj = context.pop(), base; | |||
if (obj.type && obj.type.indexOf("variable") === 0) { | |||
if (options && options.additionalContext) | |||
base = options.additionalContext[obj.string]; | |||
if (!options || options.useGlobalScope !== false) | |||
base = base || global[obj.string]; | |||
} else if (obj.type == "string") { | |||
base = ""; | |||
} else if (obj.type == "atom") { | |||
base = 1; | |||
} else if (obj.type == "function") { | |||
if (global.jQuery != null && (obj.string == '$' || obj.string == 'jQuery') && | |||
(typeof global.jQuery == 'function')) | |||
base = global.jQuery(); | |||
else if (global._ != null && (obj.string == '_') && (typeof global._ == 'function')) | |||
base = global._(); | |||
} | |||
while (base != null && context.length) | |||
base = base[context.pop().string]; | |||
if (base != null) gatherCompletions(base); | |||
} else { | |||
// If not, just look in the global object and any local scope | |||
// (reading into JS mode internals to get at the local and global variables) | |||
for (var v = token.state.localVars; v; v = v.next) maybeAdd(v.name); | |||
for (var v = token.state.globalVars; v; v = v.next) maybeAdd(v.name); | |||
if (!options || options.useGlobalScope !== false) | |||
gatherCompletions(global); | |||
forEach(keywords, maybeAdd); | |||
} | |||
return found; | |||
} | |||
}); |
@ -0,0 +1,36 @@ | |||
.CodeMirror-hints { | |||
position: absolute; | |||
z-index: 10; | |||
overflow: hidden; | |||
list-style: none; | |||
margin: 0; | |||
padding: 2px; | |||
-webkit-box-shadow: 2px 3px 5px rgba(0,0,0,.2); | |||
-moz-box-shadow: 2px 3px 5px rgba(0,0,0,.2); | |||
box-shadow: 2px 3px 5px rgba(0,0,0,.2); | |||
border-radius: 3px; | |||
border: 1px solid silver; | |||
background: white; | |||
font-size: 90%; | |||
font-family: monospace; | |||
max-height: 20em; | |||
overflow-y: auto; | |||
} | |||
.CodeMirror-hint { | |||
margin: 0; | |||
padding: 0 4px; | |||
border-radius: 2px; | |||
white-space: pre; | |||
color: black; | |||
cursor: pointer; | |||
} | |||
li.CodeMirror-hint-active { | |||
background: #08f; | |||
color: white; | |||
} |
@ -0,0 +1,460 @@ | |||
// 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"; | |||
var HINT_ELEMENT_CLASS = "CodeMirror-hint"; | |||
var ACTIVE_HINT_ELEMENT_CLASS = "CodeMirror-hint-active"; | |||
// This is the old interface, kept around for now to stay | |||
// backwards-compatible. | |||
CodeMirror.showHint = function(cm, getHints, options) { | |||
if (!getHints) return cm.showHint(options); | |||
if (options && options.async) getHints.async = true; | |||
var newOpts = {hint: getHints}; | |||
if (options) for (var prop in options) newOpts[prop] = options[prop]; | |||
return cm.showHint(newOpts); | |||
}; | |||
CodeMirror.defineExtension("showHint", function(options) { | |||
options = parseOptions(this, this.getCursor("start"), options); | |||
var selections = this.listSelections() | |||
if (selections.length > 1) return; | |||
// By default, don't allow completion when something is selected. | |||
// A hint function can have a `supportsSelection` property to | |||
// indicate that it can handle selections. | |||
if (this.somethingSelected()) { | |||
if (!options.hint.supportsSelection) return; | |||
// Don't try with cross-line selections | |||
for (var i = 0; i < selections.length; i++) | |||
if (selections[i].head.line != selections[i].anchor.line) return; | |||
} | |||
if (this.state.completionActive) this.state.completionActive.close(); | |||
var completion = this.state.completionActive = new Completion(this, options); | |||
if (!completion.options.hint) return; | |||
CodeMirror.signal(this, "startCompletion", this); | |||
completion.update(true); | |||
}); | |||
CodeMirror.defineExtension("closeHint", function() { | |||
if (this.state.completionActive) this.state.completionActive.close() | |||
}) | |||
function Completion(cm, options) { | |||
this.cm = cm; | |||
this.options = options; | |||
this.widget = null; | |||
this.debounce = 0; | |||
this.tick = 0; | |||
this.startPos = this.cm.getCursor("start"); | |||
this.startLen = this.cm.getLine(this.startPos.line).length - this.cm.getSelection().length; | |||
var self = this; | |||
cm.on("cursorActivity", this.activityFunc = function() { self.cursorActivity(); }); | |||
} | |||
var requestAnimationFrame = window.requestAnimationFrame || function(fn) { | |||
return setTimeout(fn, 1000/60); | |||
}; | |||
var cancelAnimationFrame = window.cancelAnimationFrame || clearTimeout; | |||
Completion.prototype = { | |||
close: function() { | |||
if (!this.active()) return; | |||
this.cm.state.completionActive = null; | |||
this.tick = null; | |||
this.cm.off("cursorActivity", this.activityFunc); | |||
if (this.widget && this.data) CodeMirror.signal(this.data, "close"); | |||
if (this.widget) this.widget.close(); | |||
CodeMirror.signal(this.cm, "endCompletion", this.cm); | |||
}, | |||
active: function() { | |||
return this.cm.state.completionActive == this; | |||
}, | |||
pick: function(data, i) { | |||
var completion = data.list[i]; | |||
if (completion.hint) completion.hint(this.cm, data, completion); | |||
else this.cm.replaceRange(getText(completion), completion.from || data.from, | |||
completion.to || data.to, "complete"); | |||
CodeMirror.signal(data, "pick", completion); | |||
this.close(); | |||
}, | |||
cursorActivity: function() { | |||
if (this.debounce) { | |||
cancelAnimationFrame(this.debounce); | |||
this.debounce = 0; | |||
} | |||
var pos = this.cm.getCursor(), line = this.cm.getLine(pos.line); | |||
if (pos.line != this.startPos.line || line.length - pos.ch != this.startLen - this.startPos.ch || | |||
pos.ch < this.startPos.ch || this.cm.somethingSelected() || | |||
(!pos.ch || this.options.closeCharacters.test(line.charAt(pos.ch - 1)))) { | |||
this.close(); | |||
} else { | |||
var self = this; | |||
this.debounce = requestAnimationFrame(function() {self.update();}); | |||
if (this.widget) this.widget.disable(); | |||
} | |||
}, | |||
update: function(first) { | |||
if (this.tick == null) return | |||
var self = this, myTick = ++this.tick | |||
fetchHints(this.options.hint, this.cm, this.options, function(data) { | |||
if (self.tick == myTick) self.finishUpdate(data, first) | |||
}) | |||
}, | |||
finishUpdate: function(data, first) { | |||
if (this.data) CodeMirror.signal(this.data, "update"); | |||
var picked = (this.widget && this.widget.picked) || (first && this.options.completeSingle); | |||
if (this.widget) this.widget.close(); | |||
this.data = data; | |||
if (data && data.list.length) { | |||
if (picked && data.list.length == 1) { | |||
this.pick(data, 0); | |||
} else { | |||
this.widget = new Widget(this, data); | |||
CodeMirror.signal(data, "shown"); | |||
} | |||
} | |||
} | |||
}; | |||
function parseOptions(cm, pos, options) { | |||
var editor = cm.options.hintOptions; | |||
var out = {}; | |||
for (var prop in defaultOptions) out[prop] = defaultOptions[prop]; | |||
if (editor) for (var prop in editor) | |||
if (editor[prop] !== undefined) out[prop] = editor[prop]; | |||
if (options) for (var prop in options) | |||
if (options[prop] !== undefined) out[prop] = options[prop]; | |||
if (out.hint.resolve) out.hint = out.hint.resolve(cm, pos) | |||
return out; | |||
} | |||
function getText(completion) { | |||
if (typeof completion == "string") return completion; | |||
else return completion.text; | |||
} | |||
function buildKeyMap(completion, handle) { | |||
var baseMap = { | |||
Up: function() {handle.moveFocus(-1);}, | |||
Down: function() {handle.moveFocus(1);}, | |||
PageUp: function() {handle.moveFocus(-handle.menuSize() + 1, true);}, | |||
PageDown: function() {handle.moveFocus(handle.menuSize() - 1, true);}, | |||
Home: function() {handle.setFocus(0);}, | |||
End: function() {handle.setFocus(handle.length - 1);}, | |||
Enter: handle.pick, | |||
Tab: handle.pick, | |||
Esc: handle.close | |||
}; | |||
var mac = /Mac/.test(navigator.platform); | |||
if (mac) { | |||
baseMap["Ctrl-P"] = function() {handle.moveFocus(-1);}; | |||
baseMap["Ctrl-N"] = function() {handle.moveFocus(1);}; | |||
} | |||
var custom = completion.options.customKeys; | |||
var ourMap = custom ? {} : baseMap; | |||
function addBinding(key, val) { | |||
var bound; | |||
if (typeof val != "string") | |||
bound = function(cm) { return val(cm, handle); }; | |||
// This mechanism is deprecated | |||
else if (baseMap.hasOwnProperty(val)) | |||
bound = baseMap[val]; | |||
else | |||
bound = val; | |||
ourMap[key] = bound; | |||
} | |||
if (custom) | |||
for (var key in custom) if (custom.hasOwnProperty(key)) | |||
addBinding(key, custom[key]); | |||
var extra = completion.options.extraKeys; | |||
if (extra) | |||
for (var key in extra) if (extra.hasOwnProperty(key)) | |||
addBinding(key, extra[key]); | |||
return ourMap; | |||
} | |||
function getHintElement(hintsElement, el) { | |||
while (el && el != hintsElement) { | |||
if (el.nodeName.toUpperCase() === "LI" && el.parentNode == hintsElement) return el; | |||
el = el.parentNode; | |||
} | |||
} | |||
function Widget(completion, data) { | |||
this.completion = completion; | |||
this.data = data; | |||
this.picked = false; | |||
var widget = this, cm = completion.cm; | |||
var ownerDocument = cm.getInputField().ownerDocument; | |||
var parentWindow = ownerDocument.defaultView || ownerDocument.parentWindow; | |||
var hints = this.hints = ownerDocument.createElement("ul"); | |||
var theme = completion.cm.options.theme; | |||
hints.className = "CodeMirror-hints " + theme; | |||
this.selectedHint = data.selectedHint || 0; | |||
var completions = data.list; | |||
for (var i = 0; i < completions.length; ++i) { | |||
var elt = hints.appendChild(ownerDocument.createElement("li")), cur = completions[i]; | |||
var className = HINT_ELEMENT_CLASS + (i != this.selectedHint ? "" : " " + ACTIVE_HINT_ELEMENT_CLASS); | |||
if (cur.className != null) className = cur.className + " " + className; | |||
elt.className = className; | |||
if (cur.render) cur.render(elt, data, cur); | |||
else elt.appendChild(ownerDocument.createTextNode(cur.displayText || getText(cur))); | |||
elt.hintId = i; | |||
} | |||
var container = completion.options.container || ownerDocument.body; | |||
var pos = cm.cursorCoords(completion.options.alignWithWord ? data.from : null); | |||
var left = pos.left, top = pos.bottom, below = true; | |||
var offsetLeft = 0, offsetTop = 0; | |||
if (container !== ownerDocument.body) { | |||
// We offset the cursor position because left and top are relative to the offsetParent's top left corner. | |||
var isContainerPositioned = ['absolute', 'relative', 'fixed'].indexOf(parentWindow.getComputedStyle(container).position) !== -1; | |||
var offsetParent = isContainerPositioned ? container : container.offsetParent; | |||
var offsetParentPosition = offsetParent.getBoundingClientRect(); | |||
var bodyPosition = ownerDocument.body.getBoundingClientRect(); | |||
offsetLeft = (offsetParentPosition.left - bodyPosition.left - offsetParent.scrollLeft); | |||
offsetTop = (offsetParentPosition.top - bodyPosition.top - offsetParent.scrollTop); | |||
} | |||
hints.style.left = (left - offsetLeft) + "px"; | |||
hints.style.top = (top - offsetTop) + "px"; | |||
// If we're at the edge of the screen, then we want the menu to appear on the left of the cursor. | |||
var winW = parentWindow.innerWidth || Math.max(ownerDocument.body.offsetWidth, ownerDocument.documentElement.offsetWidth); | |||
var winH = parentWindow.innerHeight || Math.max(ownerDocument.body.offsetHeight, ownerDocument.documentElement.offsetHeight); | |||
container.appendChild(hints); | |||
var box = hints.getBoundingClientRect(), overlapY = box.bottom - winH; | |||
var scrolls = hints.scrollHeight > hints.clientHeight + 1 | |||
var startScroll = cm.getScrollInfo(); | |||
if (overlapY > 0) { | |||
var height = box.bottom - box.top, curTop = pos.top - (pos.bottom - box.top); | |||
if (curTop - height > 0) { // Fits above cursor | |||
hints.style.top = (top = pos.top - height - offsetTop) + "px"; | |||
below = false; | |||
} else if (height > winH) { | |||
hints.style.height = (winH - 5) + "px"; | |||
hints.style.top = (top = pos.bottom - box.top - offsetTop) + "px"; | |||
var cursor = cm.getCursor(); | |||
if (data.from.ch != cursor.ch) { | |||
pos = cm.cursorCoords(cursor); | |||
hints.style.left = (left = pos.left - offsetLeft) + "px"; | |||
box = hints.getBoundingClientRect(); | |||
} | |||
} | |||
} | |||
var overlapX = box.right - winW; | |||
if (overlapX > 0) { | |||
if (box.right - box.left > winW) { | |||
hints.style.width = (winW - 5) + "px"; | |||
overlapX -= (box.right - box.left) - winW; | |||
} | |||
hints.style.left = (left = pos.left - overlapX - offsetLeft) + "px"; | |||
} | |||
if (scrolls) for (var node = hints.firstChild; node; node = node.nextSibling) | |||
node.style.paddingRight = cm.display.nativeBarWidth + "px" | |||
cm.addKeyMap(this.keyMap = buildKeyMap(completion, { | |||
moveFocus: function(n, avoidWrap) { widget.changeActive(widget.selectedHint + n, avoidWrap); }, | |||
setFocus: function(n) { widget.changeActive(n); }, | |||
menuSize: function() { return widget.screenAmount(); }, | |||
length: completions.length, | |||
close: function() { completion.close(); }, | |||
pick: function() { widget.pick(); }, | |||
data: data | |||
})); | |||
if (completion.options.closeOnUnfocus) { | |||
var closingOnBlur; | |||
cm.on("blur", this.onBlur = function() { closingOnBlur = setTimeout(function() { completion.close(); }, 100); }); | |||
cm.on("focus", this.onFocus = function() { clearTimeout(closingOnBlur); }); | |||
} | |||
cm.on("scroll", this.onScroll = function() { | |||
var curScroll = cm.getScrollInfo(), editor = cm.getWrapperElement().getBoundingClientRect(); | |||
var newTop = top + startScroll.top - curScroll.top; | |||
var point = newTop - (parentWindow.pageYOffset || (ownerDocument.documentElement || ownerDocument.body).scrollTop); | |||
if (!below) point += hints.offsetHeight; | |||
if (point <= editor.top || point >= editor.bottom) return completion.close(); | |||
hints.style.top = newTop + "px"; | |||
hints.style.left = (left + startScroll.left - curScroll.left) + "px"; | |||
}); | |||
CodeMirror.on(hints, "dblclick", function(e) { | |||
var t = getHintElement(hints, e.target || e.srcElement); | |||
if (t && t.hintId != null) {widget.changeActive(t.hintId); widget.pick();} | |||
}); | |||
CodeMirror.on(hints, "click", function(e) { | |||
var t = getHintElement(hints, e.target || e.srcElement); | |||
if (t && t.hintId != null) { | |||
widget.changeActive(t.hintId); | |||
if (completion.options.completeOnSingleClick) widget.pick(); | |||
} | |||
}); | |||
CodeMirror.on(hints, "mousedown", function() { | |||
setTimeout(function(){cm.focus();}, 20); | |||
}); | |||
CodeMirror.signal(data, "select", completions[this.selectedHint], hints.childNodes[this.selectedHint]); | |||
return true; | |||
} | |||
Widget.prototype = { | |||
close: function() { | |||
if (this.completion.widget != this) return; | |||
this.completion.widget = null; | |||
this.hints.parentNode.removeChild(this.hints); | |||
this.completion.cm.removeKeyMap(this.keyMap); | |||
var cm = this.completion.cm; | |||
if (this.completion.options.closeOnUnfocus) { | |||
cm.off("blur", this.onBlur); | |||
cm.off("focus", this.onFocus); | |||
} | |||
cm.off("scroll", this.onScroll); | |||
}, | |||
disable: function() { | |||
this.completion.cm.removeKeyMap(this.keyMap); | |||
var widget = this; | |||
this.keyMap = {Enter: function() { widget.picked = true; }}; | |||
this.completion.cm.addKeyMap(this.keyMap); | |||
}, | |||
pick: function() { | |||
this.completion.pick(this.data, this.selectedHint); | |||
}, | |||
changeActive: function(i, avoidWrap) { | |||
if (i >= this.data.list.length) | |||
i = avoidWrap ? this.data.list.length - 1 : 0; | |||
else if (i < 0) | |||
i = avoidWrap ? 0 : this.data.list.length - 1; | |||
if (this.selectedHint == i) return; | |||
var node = this.hints.childNodes[this.selectedHint]; | |||
if (node) node.className = node.className.replace(" " + ACTIVE_HINT_ELEMENT_CLASS, ""); | |||
node = this.hints.childNodes[this.selectedHint = i]; | |||
node.className += " " + ACTIVE_HINT_ELEMENT_CLASS; | |||
if (node.offsetTop < this.hints.scrollTop) | |||
this.hints.scrollTop = node.offsetTop - 3; | |||
else if (node.offsetTop + node.offsetHeight > this.hints.scrollTop + this.hints.clientHeight) | |||
this.hints.scrollTop = node.offsetTop + node.offsetHeight - this.hints.clientHeight + 3; | |||
CodeMirror.signal(this.data, "select", this.data.list[this.selectedHint], node); | |||
}, | |||
screenAmount: function() { | |||
return Math.floor(this.hints.clientHeight / this.hints.firstChild.offsetHeight) || 1; | |||
} | |||
}; | |||
function applicableHelpers(cm, helpers) { | |||
if (!cm.somethingSelected()) return helpers | |||
var result = [] | |||
for (var i = 0; i < helpers.length; i++) | |||
if (helpers[i].supportsSelection) result.push(helpers[i]) | |||
return result | |||
} | |||
function fetchHints(hint, cm, options, callback) { | |||
if (hint.async) { | |||
hint(cm, callback, options) | |||
} else { | |||
var result = hint(cm, options) | |||
if (result && result.then) result.then(callback) | |||
else callback(result) | |||
} | |||
} | |||
function resolveAutoHints(cm, pos) { | |||
var helpers = cm.getHelpers(pos, "hint"), words | |||
if (helpers.length) { | |||
var resolved = function(cm, callback, options) { | |||
var app = applicableHelpers(cm, helpers); | |||
function run(i) { | |||
if (i == app.length) return callback(null) | |||
fetchHints(app[i], cm, options, function(result) { | |||
if (result && result.list.length > 0) callback(result) | |||
else run(i + 1) | |||
}) | |||
} | |||
run(0) | |||
} | |||
resolved.async = true | |||
resolved.supportsSelection = true | |||
return resolved | |||
} else if (words = cm.getHelper(cm.getCursor(), "hintWords")) { | |||
return function(cm) { return CodeMirror.hint.fromList(cm, {words: words}) } | |||
} else if (CodeMirror.hint.anyword) { | |||
return function(cm, options) { return CodeMirror.hint.anyword(cm, options) } | |||
} else { | |||
return function() {} | |||
} | |||
} | |||
CodeMirror.registerHelper("hint", "auto", { | |||
resolve: resolveAutoHints | |||
}); | |||
CodeMirror.registerHelper("hint", "fromList", function(cm, options) { | |||
var cur = cm.getCursor(), token = cm.getTokenAt(cur) | |||
var term, from = CodeMirror.Pos(cur.line, token.start), to = cur | |||
if (token.start < cur.ch && /\w/.test(token.string.charAt(cur.ch - token.start - 1))) { | |||
term = token.string.substr(0, cur.ch - token.start) | |||
} else { | |||
term = "" | |||
from = cur | |||
} | |||
var found = []; | |||
for (var i = 0; i < options.words.length; i++) { | |||
var word = options.words[i]; | |||
if (word.slice(0, term.length) == term) | |||
found.push(word); | |||
} | |||
if (found.length) return {list: found, from: from, to: to}; | |||
}); | |||
CodeMirror.commands.autocomplete = CodeMirror.showHint; | |||
var defaultOptions = { | |||
hint: CodeMirror.hint.auto, | |||
completeSingle: true, | |||
alignWithWord: true, | |||
closeCharacters: /[\s()\[\]{};:>,]/, | |||
closeOnUnfocus: true, | |||
completeOnSingleClick: true, | |||
container: null, | |||
customKeys: null, | |||
extraKeys: null | |||
}; | |||
CodeMirror.defineOption("hintOptions", null); | |||
}); |
@ -0,0 +1,304 @@ | |||
// 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"), require("../../mode/sql/sql")); | |||
else if (typeof define == "function" && define.amd) // AMD | |||
define(["../../lib/codemirror", "../../mode/sql/sql"], mod); | |||
else // Plain browser env | |||
mod(CodeMirror); | |||
})(function(CodeMirror) { | |||
"use strict"; | |||
var tables; | |||
var defaultTable; | |||
var keywords; | |||
var identifierQuote; | |||
var CONS = { | |||
QUERY_DIV: ";", | |||
ALIAS_KEYWORD: "AS" | |||
}; | |||
var Pos = CodeMirror.Pos, cmpPos = CodeMirror.cmpPos; | |||
function isArray(val) { return Object.prototype.toString.call(val) == "[object Array]" } | |||
function getKeywords(editor) { | |||
var mode = editor.doc.modeOption; | |||
if (mode === "sql") mode = "text/x-sql"; | |||
return CodeMirror.resolveMode(mode).keywords; | |||
} | |||
function getIdentifierQuote(editor) { | |||
var mode = editor.doc.modeOption; | |||
if (mode === "sql") mode = "text/x-sql"; | |||
return CodeMirror.resolveMode(mode).identifierQuote || "`"; | |||
} | |||
function getText(item) { | |||
return typeof item == "string" ? item : item.text; | |||
} | |||
function wrapTable(name, value) { | |||
if (isArray(value)) value = {columns: value} | |||
if (!value.text) value.text = name | |||
return value | |||
} | |||
function parseTables(input) { | |||
var result = {} | |||
if (isArray(input)) { | |||
for (var i = input.length - 1; i >= 0; i--) { | |||
var item = input[i] | |||
result[getText(item).toUpperCase()] = wrapTable(getText(item), item) | |||
} | |||
} else if (input) { | |||
for (var name in input) | |||
result[name.toUpperCase()] = wrapTable(name, input[name]) | |||
} | |||
return result | |||
} | |||
function getTable(name) { | |||
return tables[name.toUpperCase()] | |||
} | |||
function shallowClone(object) { | |||
var result = {}; | |||
for (var key in object) if (object.hasOwnProperty(key)) | |||
result[key] = object[key]; | |||
return result; | |||
} | |||
function match(string, word) { | |||
var len = string.length; | |||
var sub = getText(word).substr(0, len); | |||
return string.toUpperCase() === sub.toUpperCase(); | |||
} | |||
function addMatches(result, search, wordlist, formatter) { | |||
if (isArray(wordlist)) { | |||
for (var i = 0; i < wordlist.length; i++) | |||
if (match(search, wordlist[i])) result.push(formatter(wordlist[i])) | |||
} else { | |||
for (var word in wordlist) if (wordlist.hasOwnProperty(word)) { | |||
var val = wordlist[word] | |||
if (!val || val === true) | |||
val = word | |||
else | |||
val = val.displayText ? {text: val.text, displayText: val.displayText} : val.text | |||
if (match(search, val)) result.push(formatter(val)) | |||
} | |||
} | |||
} | |||
function cleanName(name) { | |||
// Get rid name from identifierQuote and preceding dot(.) | |||
if (name.charAt(0) == ".") { | |||
name = name.substr(1); | |||
} | |||
// replace doublicated identifierQuotes with single identifierQuotes | |||
// and remove single identifierQuotes | |||
var nameParts = name.split(identifierQuote+identifierQuote); | |||
for (var i = 0; i < nameParts.length; i++) | |||
nameParts[i] = nameParts[i].replace(new RegExp(identifierQuote,"g"), ""); | |||
return nameParts.join(identifierQuote); | |||
} | |||
function insertIdentifierQuotes(name) { | |||
var nameParts = getText(name).split("."); | |||
for (var i = 0; i < nameParts.length; i++) | |||
nameParts[i] = identifierQuote + | |||
// doublicate identifierQuotes | |||
nameParts[i].replace(new RegExp(identifierQuote,"g"), identifierQuote+identifierQuote) + | |||
identifierQuote; | |||
var escaped = nameParts.join("."); | |||
if (typeof name == "string") return escaped; | |||
name = shallowClone(name); | |||
name.text = escaped; | |||
return name; | |||
} | |||
function nameCompletion(cur, token, result, editor) { | |||
// Try to complete table, column names and return start position of completion | |||
var useIdentifierQuotes = false; | |||
var nameParts = []; | |||
var start = token.start; | |||
var cont = true; | |||
while (cont) { | |||
cont = (token.string.charAt(0) == "."); | |||
useIdentifierQuotes = useIdentifierQuotes || (token.string.charAt(0) == identifierQuote); | |||
start = token.start; | |||
nameParts.unshift(cleanName(token.string)); | |||
token = editor.getTokenAt(Pos(cur.line, token.start)); | |||
if (token.string == ".") { | |||
cont = true; | |||
token = editor.getTokenAt(Pos(cur.line, token.start)); | |||
} | |||
} | |||
// Try to complete table names | |||
var string = nameParts.join("."); | |||
addMatches(result, string, tables, function(w) { | |||
return useIdentifierQuotes ? insertIdentifierQuotes(w) : w; | |||
}); | |||
// Try to complete columns from defaultTable | |||
addMatches(result, string, defaultTable, function(w) { | |||
return useIdentifierQuotes ? insertIdentifierQuotes(w) : w; | |||
}); | |||
// Try to complete columns | |||
string = nameParts.pop(); | |||
var table = nameParts.join("."); | |||
var alias = false; | |||
var aliasTable = table; | |||
// Check if table is available. If not, find table by Alias | |||
if (!getTable(table)) { | |||
var oldTable = table; | |||
table = findTableByAlias(table, editor); | |||
if (table !== oldTable) alias = true; | |||
} | |||
var columns = getTable(table); | |||
if (columns && columns.columns) | |||
columns = columns.columns; | |||
if (columns) { | |||
addMatches(result, string, columns, function(w) { | |||
var tableInsert = table; | |||
if (alias == true) tableInsert = aliasTable; | |||
if (typeof w == "string") { | |||
w = tableInsert + "." + w; | |||
} else { | |||
w = shallowClone(w); | |||
w.text = tableInsert + "." + w.text; | |||
} | |||
return useIdentifierQuotes ? insertIdentifierQuotes(w) : w; | |||
}); | |||
} | |||
return start; | |||
} | |||
function eachWord(lineText, f) { | |||
var words = lineText.split(/\s+/) | |||
for (var i = 0; i < words.length; i++) | |||
if (words[i]) f(words[i].replace(/[,;]/g, '')) | |||
} | |||
function findTableByAlias(alias, editor) { | |||
var doc = editor.doc; | |||
var fullQuery = doc.getValue(); | |||
var aliasUpperCase = alias.toUpperCase(); | |||
var previousWord = ""; | |||
var table = ""; | |||
var separator = []; | |||
var validRange = { | |||
start: Pos(0, 0), | |||
end: Pos(editor.lastLine(), editor.getLineHandle(editor.lastLine()).length) | |||
}; | |||
//add separator | |||
var indexOfSeparator = fullQuery.indexOf(CONS.QUERY_DIV); | |||
while(indexOfSeparator != -1) { | |||
separator.push(doc.posFromIndex(indexOfSeparator)); | |||
indexOfSeparator = fullQuery.indexOf(CONS.QUERY_DIV, indexOfSeparator+1); | |||
} | |||
separator.unshift(Pos(0, 0)); | |||
separator.push(Pos(editor.lastLine(), editor.getLineHandle(editor.lastLine()).text.length)); | |||
//find valid range | |||
var prevItem = null; | |||
var current = editor.getCursor() | |||
for (var i = 0; i < separator.length; i++) { | |||
if ((prevItem == null || cmpPos(current, prevItem) > 0) && cmpPos(current, separator[i]) <= 0) { | |||
validRange = {start: prevItem, end: separator[i]}; | |||
break; | |||
} | |||
prevItem = separator[i]; | |||
} | |||
if (validRange.start) { | |||
var query = doc.getRange(validRange.start, validRange.end, false); | |||
for (var i = 0; i < query.length; i++) { | |||
var lineText = query[i]; | |||
eachWord(lineText, function(word) { | |||
var wordUpperCase = word.toUpperCase(); | |||
if (wordUpperCase === aliasUpperCase && getTable(previousWord)) | |||
table = previousWord; | |||
if (wordUpperCase !== CONS.ALIAS_KEYWORD) | |||
previousWord = word; | |||
}); | |||
if (table) break; | |||
} | |||
} | |||
return table; | |||
} | |||
CodeMirror.registerHelper("hint", "sql", function(editor, options) { | |||
tables = parseTables(options && options.tables) | |||
var defaultTableName = options && options.defaultTable; | |||
var disableKeywords = options && options.disableKeywords; | |||
defaultTable = defaultTableName && getTable(defaultTableName); | |||
keywords = getKeywords(editor); | |||
identifierQuote = getIdentifierQuote(editor); | |||
if (defaultTableName && !defaultTable) | |||
defaultTable = findTableByAlias(defaultTableName, editor); | |||
defaultTable = defaultTable || []; | |||
if (defaultTable.columns) | |||
defaultTable = defaultTable.columns; | |||
var cur = editor.getCursor(); | |||
var result = []; | |||
var token = editor.getTokenAt(cur), start, end, search; | |||
if (token.end > cur.ch) { | |||
token.end = cur.ch; | |||
token.string = token.string.slice(0, cur.ch - token.start); | |||
} | |||
if (token.string.match(/^[.`"\w@]\w*$/)) { | |||
search = token.string; | |||
start = token.start; | |||
end = token.end; | |||
} else { | |||
start = end = cur.ch; | |||
search = ""; | |||
} | |||
if (search.charAt(0) == "." || search.charAt(0) == identifierQuote) { | |||
start = nameCompletion(cur, token, result, editor); | |||
} else { | |||
var objectOrClass = function(w, className) { | |||
if (typeof w === "object") { | |||
w.className = className; | |||
} else { | |||
w = { text: w, className: className }; | |||
} | |||
return w; | |||
}; | |||
addMatches(result, search, defaultTable, function(w) { | |||
return objectOrClass(w, "CodeMirror-hint-table CodeMirror-hint-default-table"); | |||
}); | |||
addMatches( | |||
result, | |||
search, | |||
tables, function(w) { | |||
return objectOrClass(w, "CodeMirror-hint-table"); | |||
} | |||
); | |||
if (!disableKeywords) | |||
addMatches(result, search, keywords, function(w) { | |||
return objectOrClass(w.toUpperCase(), "CodeMirror-hint-keyword"); | |||
}); | |||
} | |||
return {list: result, from: Pos(cur.line, start), to: Pos(cur.line, end)}; | |||
}); | |||
}); |
@ -0,0 +1,123 @@ | |||
// 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"; | |||
var Pos = CodeMirror.Pos; | |||
function matches(hint, typed, matchInMiddle) { | |||
if (matchInMiddle) return hint.indexOf(typed) >= 0; | |||
else return hint.lastIndexOf(typed, 0) == 0; | |||
} | |||
function getHints(cm, options) { | |||
var tags = options && options.schemaInfo; | |||
var quote = (options && options.quoteChar) || '"'; | |||
var matchInMiddle = options && options.matchInMiddle; | |||
if (!tags) return; | |||
var cur = cm.getCursor(), token = cm.getTokenAt(cur); | |||
if (token.end > cur.ch) { | |||
token.end = cur.ch; | |||
token.string = token.string.slice(0, cur.ch - token.start); | |||
} | |||
var inner = CodeMirror.innerMode(cm.getMode(), token.state); | |||
if (!inner.mode.xmlCurrentTag) return | |||
var result = [], replaceToken = false, prefix; | |||
var tag = /\btag\b/.test(token.type) && !/>$/.test(token.string); | |||
var tagName = tag && /^\w/.test(token.string), tagStart; | |||
if (tagName) { | |||
var before = cm.getLine(cur.line).slice(Math.max(0, token.start - 2), token.start); | |||
var tagType = /<\/$/.test(before) ? "close" : /<$/.test(before) ? "open" : null; | |||
if (tagType) tagStart = token.start - (tagType == "close" ? 2 : 1); | |||
} else if (tag && token.string == "<") { | |||
tagType = "open"; | |||
} else if (tag && token.string == "</") { | |||
tagType = "close"; | |||
} | |||
var tagInfo = inner.mode.xmlCurrentTag(inner.state) | |||
if (!tag && !tagInfo || tagType) { | |||
if (tagName) | |||
prefix = token.string; | |||
replaceToken = tagType; | |||
var context = inner.mode.xmlCurrentContext ? inner.mode.xmlCurrentContext(inner.state) : [] | |||
var inner = context.length && context[context.length - 1] | |||
var curTag = inner && tags[inner] | |||
var childList = inner ? curTag && curTag.children : tags["!top"]; | |||
if (childList && tagType != "close") { | |||
for (var i = 0; i < childList.length; ++i) if (!prefix || matches(childList[i], prefix, matchInMiddle)) | |||
result.push("<" + childList[i]); | |||
} else if (tagType != "close") { | |||
for (var name in tags) | |||
if (tags.hasOwnProperty(name) && name != "!top" && name != "!attrs" && (!prefix || matches(name, prefix, matchInMiddle))) | |||
result.push("<" + name); | |||
} | |||
if (inner && (!prefix || tagType == "close" && matches(inner, prefix, matchInMiddle))) | |||
result.push("</" + inner + ">"); | |||
} else { | |||
// Attribute completion | |||
var curTag = tagInfo && tags[tagInfo.name], attrs = curTag && curTag.attrs; | |||
var globalAttrs = tags["!attrs"]; | |||
if (!attrs && !globalAttrs) return; | |||
if (!attrs) { | |||
attrs = globalAttrs; | |||
} else if (globalAttrs) { // Combine tag-local and global attributes | |||
var set = {}; | |||
for (var nm in globalAttrs) if (globalAttrs.hasOwnProperty(nm)) set[nm] = globalAttrs[nm]; | |||
for (var nm in attrs) if (attrs.hasOwnProperty(nm)) set[nm] = attrs[nm]; | |||
attrs = set; | |||
} | |||
if (token.type == "string" || token.string == "=") { // A value | |||
var before = cm.getRange(Pos(cur.line, Math.max(0, cur.ch - 60)), | |||
Pos(cur.line, token.type == "string" ? token.start : token.end)); | |||
var atName = before.match(/([^\s\u00a0=<>\"\']+)=$/), atValues; | |||
if (!atName || !attrs.hasOwnProperty(atName[1]) || !(atValues = attrs[atName[1]])) return; | |||
if (typeof atValues == 'function') atValues = atValues.call(this, cm); // Functions can be used to supply values for autocomplete widget | |||
if (token.type == "string") { | |||
prefix = token.string; | |||
var n = 0; | |||
if (/['"]/.test(token.string.charAt(0))) { | |||
quote = token.string.charAt(0); | |||
prefix = token.string.slice(1); | |||
n++; | |||
} | |||
var len = token.string.length; | |||
if (/['"]/.test(token.string.charAt(len - 1))) { | |||
quote = token.string.charAt(len - 1); | |||
prefix = token.string.substr(n, len - 2); | |||
} | |||
if (n) { // an opening quote | |||
var line = cm.getLine(cur.line); | |||
if (line.length > token.end && line.charAt(token.end) == quote) token.end++; // include a closing quote | |||
} | |||
replaceToken = true; | |||
} | |||
for (var i = 0; i < atValues.length; ++i) if (!prefix || matches(atValues[i], prefix, matchInMiddle)) | |||
result.push(quote + atValues[i] + quote); | |||
} else { // An attribute name | |||
if (token.type == "attribute") { | |||
prefix = token.string; | |||
replaceToken = true; | |||
} | |||
for (var attr in attrs) if (attrs.hasOwnProperty(attr) && (!prefix || matches(attr, prefix, matchInMiddle))) | |||
result.push(attr); | |||
} | |||
} | |||
return { | |||
list: result, | |||
from: replaceToken ? Pos(cur.line, tagStart == null ? token.start : tagStart) : cur, | |||
to: replaceToken ? Pos(cur.line, token.end) : cur | |||
}; | |||
} | |||
CodeMirror.registerHelper("hint", "xml", getHints); | |||
}); |
@ -0,0 +1,47 @@ | |||
// CodeMirror, copyright (c) by Marijn Haverbeke and others | |||
// Distributed under an MIT license: https://codemirror.net/LICENSE | |||
// Depends on coffeelint.js from http://www.coffeelint.org/js/coffeelint.js | |||
// declare global: coffeelint | |||
(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.registerHelper("lint", "coffeescript", function(text) { | |||
var found = []; | |||
if (!window.coffeelint) { | |||
if (window.console) { | |||
window.console.error("Error: window.coffeelint not defined, CodeMirror CoffeeScript linting cannot run."); | |||
} | |||
return found; | |||
} | |||
var parseError = function(err) { | |||
var loc = err.lineNumber; | |||
found.push({from: CodeMirror.Pos(loc-1, 0), | |||
to: CodeMirror.Pos(loc, 0), | |||
severity: err.level, | |||
message: err.message}); | |||
}; | |||
try { | |||
var res = coffeelint.lint(text); | |||
for(var i = 0; i < res.length; i++) { | |||
parseError(res[i]); | |||
} | |||
} catch(e) { | |||
found.push({from: CodeMirror.Pos(e.location.first_line, 0), | |||
to: CodeMirror.Pos(e.location.last_line, e.location.last_column), | |||
severity: 'error', | |||
message: e.message}); | |||
} | |||
return found; | |||
}); | |||
}); |
@ -0,0 +1,40 @@ | |||
// CodeMirror, copyright (c) by Marijn Haverbeke and others | |||
// Distributed under an MIT license: https://codemirror.net/LICENSE | |||
// Depends on csslint.js from https://github.com/stubbornella/csslint | |||
// declare global: CSSLint | |||
(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.registerHelper("lint", "css", function(text, options) { | |||
var found = []; | |||
if (!window.CSSLint) { | |||
if (window.console) { | |||
window.console.error("Error: window.CSSLint not defined, CodeMirror CSS linting cannot run."); | |||
} | |||
return found; | |||
} | |||
var results = CSSLint.verify(text, options), messages = results.messages, message = null; | |||
for ( var i = 0; i < messages.length; i++) { | |||
message = messages[i]; | |||
var startLine = message.line -1, endLine = message.line -1, startCol = message.col -1, endCol = message.col; | |||
found.push({ | |||
from: CodeMirror.Pos(startLine, startCol), | |||
to: CodeMirror.Pos(endLine, endCol), | |||
message: message.message, | |||
severity : message.type | |||
}); | |||
} | |||
return found; | |||
}); | |||
}); |
@ -0,0 +1,59 @@ | |||
// CodeMirror, copyright (c) by Marijn Haverbeke and others | |||
// Distributed under an MIT license: https://codemirror.net/LICENSE | |||
// Depends on htmlhint.js from http://htmlhint.com/js/htmlhint.js | |||
// declare global: HTMLHint | |||
(function(mod) { | |||
if (typeof exports == "object" && typeof module == "object") // CommonJS | |||
mod(require("../../lib/codemirror"), require("htmlhint")); | |||
else if (typeof define == "function" && define.amd) // AMD | |||
define(["../../lib/codemirror", "htmlhint"], mod); | |||
else // Plain browser env | |||
mod(CodeMirror, window.HTMLHint); | |||
})(function(CodeMirror, HTMLHint) { | |||
"use strict"; | |||
var defaultRules = { | |||
"tagname-lowercase": true, | |||
"attr-lowercase": true, | |||
"attr-value-double-quotes": true, | |||
"doctype-first": false, | |||
"tag-pair": true, | |||
"spec-char-escape": true, | |||
"id-unique": true, | |||
"src-not-empty": true, | |||
"attr-no-duplication": true | |||
}; | |||
CodeMirror.registerHelper("lint", "html", function(text, options) { | |||
var found = []; | |||
if (HTMLHint && !HTMLHint.verify) { | |||
if(typeof HTMLHint.default !== 'undefined') { | |||
HTMLHint = HTMLHint.default; | |||
} else { | |||
HTMLHint = HTMLHint.HTMLHint; | |||
} | |||
} | |||
if (!HTMLHint) HTMLHint = window.HTMLHint; | |||
if (!HTMLHint) { | |||
if (window.console) { | |||
window.console.error("Error: HTMLHint not found, not defined on window, or not available through define/require, CodeMirror HTML linting cannot run."); | |||
} | |||
return found; | |||
} | |||
var messages = HTMLHint.verify(text, options && options.rules || defaultRules); | |||
for (var i = 0; i < messages.length; i++) { | |||
var message = messages[i]; | |||
var startLine = message.line - 1, endLine = message.line - 1, startCol = message.col - 1, endCol = message.col; | |||
found.push({ | |||
from: CodeMirror.Pos(startLine, startCol), | |||
to: CodeMirror.Pos(endLine, endCol), | |||
message: message.message, | |||
severity : message.type | |||
}); | |||
} | |||
return found; | |||
}); | |||
}); |
@ -0,0 +1,63 @@ | |||
// 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"; | |||
// declare global: JSHINT | |||
function validator(text, options) { | |||
if (!window.JSHINT) { | |||
if (window.console) { | |||
window.console.error("Error: window.JSHINT not defined, CodeMirror JavaScript linting cannot run."); | |||
} | |||
return []; | |||
} | |||
if (!options.indent) // JSHint error.character actually is a column index, this fixes underlining on lines using tabs for indentation | |||
options.indent = 1; // JSHint default value is 4 | |||
JSHINT(text, options, options.globals); | |||
var errors = JSHINT.data().errors, result = []; | |||
if (errors) parseErrors(errors, result); | |||
return result; | |||
} | |||
CodeMirror.registerHelper("lint", "javascript", validator); | |||
function parseErrors(errors, output) { | |||
for ( var i = 0; i < errors.length; i++) { | |||
var error = errors[i]; | |||
if (error) { | |||
if (error.line <= 0) { | |||
if (window.console) { | |||
window.console.warn("Cannot display JSHint error (invalid line " + error.line + ")", error); | |||
} | |||
continue; | |||
} | |||
var start = error.character - 1, end = start + 1; | |||
if (error.evidence) { | |||
var index = error.evidence.substring(start).search(/.\b/); | |||
if (index > -1) { | |||
end += index; | |||
} | |||
} | |||
// Convert to format expected by validation service | |||
var hint = { | |||
message: error.reason, | |||
severity: error.code ? (error.code.startsWith('W') ? "warning" : "error") : "error", | |||
from: CodeMirror.Pos(error.line - 1, start), | |||
to: CodeMirror.Pos(error.line - 1, end) | |||
}; | |||
output.push(hint); | |||
} | |||
} | |||
} | |||
}); |
@ -0,0 +1,40 @@ | |||
// CodeMirror, copyright (c) by Marijn Haverbeke and others | |||
// Distributed under an MIT license: https://codemirror.net/LICENSE | |||
// Depends on jsonlint.js from https://github.com/zaach/jsonlint | |||
// declare global: jsonlint | |||
(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.registerHelper("lint", "json", function(text) { | |||
var found = []; | |||
if (!window.jsonlint) { | |||
if (window.console) { | |||
window.console.error("Error: window.jsonlint not defined, CodeMirror JSON linting cannot run."); | |||
} | |||
return found; | |||
} | |||
// for jsonlint's web dist jsonlint is exported as an object with a single property parser, of which parseError | |||
// is a subproperty | |||
var jsonlint = window.jsonlint.parser || window.jsonlint | |||
jsonlint.parseError = function(str, hash) { | |||
var loc = hash.loc; | |||
found.push({from: CodeMirror.Pos(loc.first_line - 1, loc.first_column), | |||
to: CodeMirror.Pos(loc.last_line - 1, loc.last_column), | |||
message: str}); | |||
}; | |||
try { jsonlint.parse(text); } | |||
catch(e) {} | |||
return found; | |||
}); | |||
}); |
@ -0,0 +1,73 @@ | |||
/* The lint marker gutter */ | |||
.CodeMirror-lint-markers { | |||
width: 16px; | |||
} | |||
.CodeMirror-lint-tooltip { | |||
background-color: #ffd; | |||
border: 1px solid black; | |||
border-radius: 4px 4px 4px 4px; | |||
color: black; | |||
font-family: monospace; | |||
font-size: 10pt; | |||
overflow: hidden; | |||
padding: 2px 5px; | |||
position: fixed; | |||
white-space: pre; | |||
white-space: pre-wrap; | |||
z-index: 100; | |||
max-width: 600px; | |||
opacity: 0; | |||
transition: opacity .4s; | |||
-moz-transition: opacity .4s; | |||
-webkit-transition: opacity .4s; | |||
-o-transition: opacity .4s; | |||
-ms-transition: opacity .4s; | |||
} | |||
.CodeMirror-lint-mark-error, .CodeMirror-lint-mark-warning { | |||
background-position: left bottom; | |||
background-repeat: repeat-x; | |||
} | |||
.CodeMirror-lint-mark-error { | |||
background-image: | |||
url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAADCAYAAAC09K7GAAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9sJDw4cOCW1/KIAAAAZdEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAAHElEQVQI12NggIL/DAz/GdA5/xkY/qPKMDAwAADLZwf5rvm+LQAAAABJRU5ErkJggg==") | |||
; | |||
} | |||
.CodeMirror-lint-mark-warning { | |||
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAADCAYAAAC09K7GAAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9sJFhQXEbhTg7YAAAAZdEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAAMklEQVQI12NkgIIvJ3QXMjAwdDN+OaEbysDA4MPAwNDNwMCwiOHLCd1zX07o6kBVGQEAKBANtobskNMAAAAASUVORK5CYII="); | |||
} | |||
.CodeMirror-lint-marker-error, .CodeMirror-lint-marker-warning { | |||
background-position: center center; | |||
background-repeat: no-repeat; | |||
cursor: pointer; | |||
display: inline-block; | |||
height: 16px; | |||
width: 16px; | |||
vertical-align: middle; | |||
position: relative; | |||
} | |||
.CodeMirror-lint-message-error, .CodeMirror-lint-message-warning { | |||
padding-left: 18px; | |||
background-position: top left; | |||
background-repeat: no-repeat; | |||
} | |||
.CodeMirror-lint-marker-error, .CodeMirror-lint-message-error { | |||
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAHlBMVEW7AAC7AACxAAC7AAC7AAAAAAC4AAC5AAD///+7AAAUdclpAAAABnRSTlMXnORSiwCK0ZKSAAAATUlEQVR42mWPOQ7AQAgDuQLx/z8csYRmPRIFIwRGnosRrpamvkKi0FTIiMASR3hhKW+hAN6/tIWhu9PDWiTGNEkTtIOucA5Oyr9ckPgAWm0GPBog6v4AAAAASUVORK5CYII="); | |||
} | |||
.CodeMirror-lint-marker-warning, .CodeMirror-lint-message-warning { | |||
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAANlBMVEX/uwDvrwD/uwD/uwD/uwD/uwD/uwD/uwD/uwD6twD/uwAAAADurwD2tQD7uAD+ugAAAAD/uwDhmeTRAAAADHRSTlMJ8mN1EYcbmiixgACm7WbuAAAAVklEQVR42n3PUQqAIBBFUU1LLc3u/jdbOJoW1P08DA9Gba8+YWJ6gNJoNYIBzAA2chBth5kLmG9YUoG0NHAUwFXwO9LuBQL1giCQb8gC9Oro2vp5rncCIY8L8uEx5ZkAAAAASUVORK5CYII="); | |||
} | |||
.CodeMirror-lint-marker-multiple { | |||
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAcAAAAHCAMAAADzjKfhAAAACVBMVEUAAAAAAAC/v7914kyHAAAAAXRSTlMAQObYZgAAACNJREFUeNo1ioEJAAAIwmz/H90iFFSGJgFMe3gaLZ0od+9/AQZ0ADosbYraAAAAAElFTkSuQmCC"); | |||
background-repeat: no-repeat; | |||
background-position: right bottom; | |||
width: 100%; height: 100%; | |||
} |
@ -0,0 +1,252 @@ | |||
// 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"; | |||
var GUTTER_ID = "CodeMirror-lint-markers"; | |||
function showTooltip(e, content) { | |||
var tt = document.createElement("div"); | |||
tt.className = "CodeMirror-lint-tooltip"; | |||
tt.appendChild(content.cloneNode(true)); | |||
document.body.appendChild(tt); | |||
function position(e) { | |||
if (!tt.parentNode) return CodeMirror.off(document, "mousemove", position); | |||
tt.style.top = Math.max(0, e.clientY - tt.offsetHeight - 5) + "px"; | |||
tt.style.left = (e.clientX + 5) + "px"; | |||
} | |||
CodeMirror.on(document, "mousemove", position); | |||
position(e); | |||
if (tt.style.opacity != null) tt.style.opacity = 1; | |||
return tt; | |||
} | |||
function rm(elt) { | |||
if (elt.parentNode) elt.parentNode.removeChild(elt); | |||
} | |||
function hideTooltip(tt) { | |||
if (!tt.parentNode) return; | |||
if (tt.style.opacity == null) rm(tt); | |||
tt.style.opacity = 0; | |||
setTimeout(function() { rm(tt); }, 600); | |||
} | |||
function showTooltipFor(e, content, node) { | |||
var tooltip = showTooltip(e, content); | |||
function hide() { | |||
CodeMirror.off(node, "mouseout", hide); | |||
if (tooltip) { hideTooltip(tooltip); tooltip = null; } | |||
} | |||
var poll = setInterval(function() { | |||
if (tooltip) for (var n = node;; n = n.parentNode) { | |||
if (n && n.nodeType == 11) n = n.host; | |||
if (n == document.body) return; | |||
if (!n) { hide(); break; } | |||
} | |||
if (!tooltip) return clearInterval(poll); | |||
}, 400); | |||
CodeMirror.on(node, "mouseout", hide); | |||
} | |||
function LintState(cm, options, hasGutter) { | |||
this.marked = []; | |||
this.options = options; | |||
this.timeout = null; | |||
this.hasGutter = hasGutter; | |||
this.onMouseOver = function(e) { onMouseOver(cm, e); }; | |||
this.waitingFor = 0 | |||
} | |||
function parseOptions(_cm, options) { | |||
if (options instanceof Function) return {getAnnotations: options}; | |||
if (!options || options === true) options = {}; | |||
return options; | |||
} | |||
function clearMarks(cm) { | |||
var state = cm.state.lint; | |||
if (state.hasGutter) cm.clearGutter(GUTTER_ID); | |||
for (var i = 0; i < state.marked.length; ++i) | |||
state.marked[i].clear(); | |||
state.marked.length = 0; | |||
} | |||
function makeMarker(labels, severity, multiple, tooltips) { | |||
var marker = document.createElement("div"), inner = marker; | |||
marker.className = "CodeMirror-lint-marker-" + severity; | |||
if (multiple) { | |||
inner = marker.appendChild(document.createElement("div")); | |||
inner.className = "CodeMirror-lint-marker-multiple"; | |||
} | |||
if (tooltips != false) CodeMirror.on(inner, "mouseover", function(e) { | |||
showTooltipFor(e, labels, inner); | |||
}); | |||
return marker; | |||
} | |||
function getMaxSeverity(a, b) { | |||
if (a == "error") return a; | |||
else return b; | |||
} | |||
function groupByLine(annotations) { | |||
var lines = []; | |||
for (var i = 0; i < annotations.length; ++i) { | |||
var ann = annotations[i], line = ann.from.line; | |||
(lines[line] || (lines[line] = [])).push(ann); | |||
} | |||
return lines; | |||
} | |||
function annotationTooltip(ann) { | |||
var severity = ann.severity; | |||
if (!severity) severity = "error"; | |||
var tip = document.createElement("div"); | |||
tip.className = "CodeMirror-lint-message-" + severity; | |||
if (typeof ann.messageHTML != 'undefined') { | |||
tip.innerHTML = ann.messageHTML; | |||
} else { | |||
tip.appendChild(document.createTextNode(ann.message)); | |||
} | |||
return tip; | |||
} | |||
function lintAsync(cm, getAnnotations, passOptions) { | |||
var state = cm.state.lint | |||
var id = ++state.waitingFor | |||
function abort() { | |||
id = -1 | |||
cm.off("change", abort) | |||
} | |||
cm.on("change", abort) | |||
getAnnotations(cm.getValue(), function(annotations, arg2) { | |||
cm.off("change", abort) | |||
if (state.waitingFor != id) return | |||
if (arg2 && annotations instanceof CodeMirror) annotations = arg2 | |||
cm.operation(function() {updateLinting(cm, annotations)}) | |||
}, passOptions, cm); | |||
} | |||
function startLinting(cm) { | |||
var state = cm.state.lint, options = state.options; | |||
/* | |||
* Passing rules in `options` property prevents JSHint (and other linters) from complaining | |||
* about unrecognized rules like `onUpdateLinting`, `delay`, `lintOnChange`, etc. | |||
*/ | |||
var passOptions = options.options || options; | |||
var getAnnotations = options.getAnnotations || cm.getHelper(CodeMirror.Pos(0, 0), "lint"); | |||
if (!getAnnotations) return; | |||
if (options.async || getAnnotations.async) { | |||
lintAsync(cm, getAnnotations, passOptions) | |||
} else { | |||
var annotations = getAnnotations(cm.getValue(), passOptions, cm); | |||
if (!annotations) return; | |||
if (annotations.then) annotations.then(function(issues) { | |||
cm.operation(function() {updateLinting(cm, issues)}) | |||
}); | |||
else cm.operation(function() {updateLinting(cm, annotations)}) | |||
} | |||
} | |||
function updateLinting(cm, annotationsNotSorted) { | |||
clearMarks(cm); | |||
var state = cm.state.lint, options = state.options; | |||
var annotations = groupByLine(annotationsNotSorted); | |||
for (var line = 0; line < annotations.length; ++line) { | |||
var anns = annotations[line]; | |||
if (!anns) continue; | |||
var maxSeverity = null; | |||
var tipLabel = state.hasGutter && document.createDocumentFragment(); | |||
for (var i = 0; i < anns.length; ++i) { | |||
var ann = anns[i]; | |||
var severity = ann.severity; | |||
if (!severity) severity = "error"; | |||
maxSeverity = getMaxSeverity(maxSeverity, severity); | |||
if (options.formatAnnotation) ann = options.formatAnnotation(ann); | |||
if (state.hasGutter) tipLabel.appendChild(annotationTooltip(ann)); | |||
if (ann.to) state.marked.push(cm.markText(ann.from, ann.to, { | |||
className: "CodeMirror-lint-mark-" + severity, | |||
__annotation: ann | |||
})); | |||
} | |||
if (state.hasGutter) | |||
cm.setGutterMarker(line, GUTTER_ID, makeMarker(tipLabel, maxSeverity, anns.length > 1, | |||
state.options.tooltips)); | |||
} | |||
if (options.onUpdateLinting) options.onUpdateLinting(annotationsNotSorted, annotations, cm); | |||
} | |||
function onChange(cm) { | |||
var state = cm.state.lint; | |||
if (!state) return; | |||
clearTimeout(state.timeout); | |||
state.timeout = setTimeout(function(){startLinting(cm);}, state.options.delay || 500); | |||
} | |||
function popupTooltips(annotations, e) { | |||
var target = e.target || e.srcElement; | |||
var tooltip = document.createDocumentFragment(); | |||
for (var i = 0; i < annotations.length; i++) { | |||
var ann = annotations[i]; | |||
tooltip.appendChild(annotationTooltip(ann)); | |||
} | |||
showTooltipFor(e, tooltip, target); | |||
} | |||
function onMouseOver(cm, e) { | |||
var target = e.target || e.srcElement; | |||
if (!/\bCodeMirror-lint-mark-/.test(target.className)) return; | |||
var box = target.getBoundingClientRect(), x = (box.left + box.right) / 2, y = (box.top + box.bottom) / 2; | |||
var spans = cm.findMarksAt(cm.coordsChar({left: x, top: y}, "client")); | |||
var annotations = []; | |||
for (var i = 0; i < spans.length; ++i) { | |||
var ann = spans[i].__annotation; | |||
if (ann) annotations.push(ann); | |||
} | |||
if (annotations.length) popupTooltips(annotations, e); | |||
} | |||
CodeMirror.defineOption("lint", false, function(cm, val, old) { | |||
if (old && old != CodeMirror.Init) { | |||
clearMarks(cm); | |||
if (cm.state.lint.options.lintOnChange !== false) | |||
cm.off("change", onChange); | |||
CodeMirror.off(cm.getWrapperElement(), "mouseover", cm.state.lint.onMouseOver); | |||
clearTimeout(cm.state.lint.timeout); | |||
delete cm.state.lint; | |||
} | |||
if (val) { | |||
var gutters = cm.getOption("gutters"), hasLintGutter = false; | |||
for (var i = 0; i < gutters.length; ++i) if (gutters[i] == GUTTER_ID) hasLintGutter = true; | |||
var state = cm.state.lint = new LintState(cm, parseOptions(cm, val), hasLintGutter); | |||
if (state.options.lintOnChange !== false) | |||
cm.on("change", onChange); | |||
if (state.options.tooltips != false && state.options.tooltips != "gutter") | |||
CodeMirror.on(cm.getWrapperElement(), "mouseover", state.onMouseOver); | |||
startLinting(cm); | |||
} | |||
}); | |||
CodeMirror.defineExtension("performLint", function() { | |||
if (this.state.lint) startLinting(this); | |||
}); | |||
}); |
@ -0,0 +1,41 @@ | |||
// 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"; | |||
// Depends on js-yaml.js from https://github.com/nodeca/js-yaml | |||
// declare global: jsyaml | |||
CodeMirror.registerHelper("lint", "yaml", function(text) { | |||
var found = []; | |||
if (!window.jsyaml) { | |||
if (window.console) { | |||
window.console.error("Error: window.jsyaml not defined, CodeMirror YAML linting cannot run."); | |||
} | |||
return found; | |||
} | |||
try { jsyaml.loadAll(text); } | |||
catch(e) { | |||
var loc = e.mark, | |||
// js-yaml YAMLException doesn't always provide an accurate lineno | |||
// e.g., when there are multiple yaml docs | |||
// --- | |||
// --- | |||
// foo:bar | |||
from = loc ? CodeMirror.Pos(loc.line, loc.column) : CodeMirror.Pos(0, 0), | |||
to = from; | |||
found.push({ from: from, to: to, message: e.message }); | |||
} | |||
return found; | |||
}); | |||
}); |
@ -0,0 +1,119 @@ | |||
.CodeMirror-merge { | |||
position: relative; | |||
border: 1px solid #ddd; | |||
white-space: pre; | |||
} | |||
.CodeMirror-merge, .CodeMirror-merge .CodeMirror { | |||
height: 350px; | |||
} | |||
.CodeMirror-merge-2pane .CodeMirror-merge-pane { width: 47%; } | |||
.CodeMirror-merge-2pane .CodeMirror-merge-gap { width: 6%; } | |||
.CodeMirror-merge-3pane .CodeMirror-merge-pane { width: 31%; } | |||
.CodeMirror-merge-3pane .CodeMirror-merge-gap { width: 3.5%; } | |||
.CodeMirror-merge-pane { | |||
display: inline-block; | |||
white-space: normal; | |||
vertical-align: top; | |||
} | |||
.CodeMirror-merge-pane-rightmost { | |||
position: absolute; | |||
right: 0px; | |||
z-index: 1; | |||
} | |||
.CodeMirror-merge-gap { | |||
z-index: 2; | |||
display: inline-block; | |||
height: 100%; | |||
-moz-box-sizing: border-box; | |||
box-sizing: border-box; | |||
overflow: hidden; | |||
border-left: 1px solid #ddd; | |||
border-right: 1px solid #ddd; | |||
position: relative; | |||
background: #f8f8f8; | |||
} | |||
.CodeMirror-merge-scrolllock-wrap { | |||
position: absolute; | |||
bottom: 0; left: 50%; | |||
} | |||
.CodeMirror-merge-scrolllock { | |||
position: relative; | |||
left: -50%; | |||
cursor: pointer; | |||
color: #555; | |||
line-height: 1; | |||
} | |||
.CodeMirror-merge-scrolllock:after { | |||
content: "\21db\00a0\00a0\21da"; | |||
} | |||
.CodeMirror-merge-scrolllock.CodeMirror-merge-scrolllock-enabled:after { | |||
content: "\21db\21da"; | |||
} | |||
.CodeMirror-merge-copybuttons-left, .CodeMirror-merge-copybuttons-right { | |||
position: absolute; | |||
left: 0; top: 0; | |||
right: 0; bottom: 0; | |||
line-height: 1; | |||
} | |||
.CodeMirror-merge-copy { | |||
position: absolute; | |||
cursor: pointer; | |||
color: #44c; | |||
z-index: 3; | |||
} | |||
.CodeMirror-merge-copy-reverse { | |||
position: absolute; | |||
cursor: pointer; | |||
color: #44c; | |||
} | |||
.CodeMirror-merge-copybuttons-left .CodeMirror-merge-copy { left: 2px; } | |||
.CodeMirror-merge-copybuttons-right .CodeMirror-merge-copy { right: 2px; } | |||
.CodeMirror-merge-r-inserted, .CodeMirror-merge-l-inserted { | |||
background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAACCAYAAACddGYaAAAAGUlEQVQI12MwuCXy3+CWyH8GBgYGJgYkAABZbAQ9ELXurwAAAABJRU5ErkJggg==); | |||
background-position: bottom left; | |||
background-repeat: repeat-x; | |||
} | |||
.CodeMirror-merge-r-deleted, .CodeMirror-merge-l-deleted { | |||
background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAACCAYAAACddGYaAAAAGUlEQVQI12M4Kyb2/6yY2H8GBgYGJgYkAABURgPz6Ks7wQAAAABJRU5ErkJggg==); | |||
background-position: bottom left; | |||
background-repeat: repeat-x; | |||
} | |||
.CodeMirror-merge-r-chunk { background: #ffffe0; } | |||
.CodeMirror-merge-r-chunk-start { border-top: 1px solid #ee8; } | |||
.CodeMirror-merge-r-chunk-end { border-bottom: 1px solid #ee8; } | |||
.CodeMirror-merge-r-connect { fill: #ffffe0; stroke: #ee8; stroke-width: 1px; } | |||
.CodeMirror-merge-l-chunk { background: #eef; } | |||
.CodeMirror-merge-l-chunk-start { border-top: 1px solid #88e; } | |||
.CodeMirror-merge-l-chunk-end { border-bottom: 1px solid #88e; } | |||
.CodeMirror-merge-l-connect { fill: #eef; stroke: #88e; stroke-width: 1px; } | |||
.CodeMirror-merge-l-chunk.CodeMirror-merge-r-chunk { background: #dfd; } | |||
.CodeMirror-merge-l-chunk-start.CodeMirror-merge-r-chunk-start { border-top: 1px solid #4e4; } | |||
.CodeMirror-merge-l-chunk-end.CodeMirror-merge-r-chunk-end { border-bottom: 1px solid #4e4; } | |||
.CodeMirror-merge-collapsed-widget:before { | |||
content: "(...)"; | |||
} | |||
.CodeMirror-merge-collapsed-widget { | |||
cursor: pointer; | |||
color: #88b; | |||
background: #eef; | |||
border: 1px solid #ddf; | |||
font-size: 90%; | |||
padding: 0 3px; | |||
border-radius: 4px; | |||
} | |||
.CodeMirror-merge-collapsed-line .CodeMirror-gutter-elt { display: none; } |
@ -0,0 +1,40 @@ | |||
// 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"), require("./runmode")); | |||
else if (typeof define == "function" && define.amd) // AMD | |||
define(["../../lib/codemirror", "./runmode"], mod); | |||
else // Plain browser env | |||
mod(CodeMirror); | |||
})(function(CodeMirror) { | |||
"use strict"; | |||
var isBlock = /^(p|li|div|h\\d|pre|blockquote|td)$/; | |||
function textContent(node, out) { | |||
if (node.nodeType == 3) return out.push(node.nodeValue); | |||
for (var ch = node.firstChild; ch; ch = ch.nextSibling) { | |||
textContent(ch, out); | |||
if (isBlock.test(node.nodeType)) out.push("\n"); | |||
} | |||
} | |||
CodeMirror.colorize = function(collection, defaultMode) { | |||
if (!collection) collection = document.body.getElementsByTagName("pre"); | |||
for (var i = 0; i < collection.length; ++i) { | |||
var node = collection[i]; | |||
var mode = node.getAttribute("data-lang") || defaultMode; | |||
if (!mode) continue; | |||
var text = []; | |||
textContent(node, text); | |||
node.innerHTML = ""; | |||
CodeMirror.runMode(text.join(""), mode, node); | |||
node.className += " cm-s-default"; | |||
} | |||
}; | |||
}); |
@ -0,0 +1,158 @@ | |||
// CodeMirror, copyright (c) by Marijn Haverbeke and others | |||
// Distributed under an MIT license: https://codemirror.net/LICENSE | |||
window.CodeMirror = {}; | |||
(function() { | |||
"use strict"; | |||
function splitLines(string){ return string.split(/\r?\n|\r/); }; | |||
function StringStream(string) { | |||
this.pos = this.start = 0; | |||
this.string = string; | |||
this.lineStart = 0; | |||
} | |||
StringStream.prototype = { | |||
eol: function() {return this.pos >= this.string.length;}, | |||
sol: function() {return this.pos == 0;}, | |||
peek: function() {return this.string.charAt(this.pos) || null;}, | |||
next: function() { | |||
if (this.pos < this.string.length) | |||
return this.string.charAt(this.pos++); | |||
}, | |||
eat: function(match) { | |||
var ch = this.string.charAt(this.pos); | |||
if (typeof match == "string") var ok = ch == match; | |||
else var ok = ch && (match.test ? match.test(ch) : match(ch)); | |||
if (ok) {++this.pos; return ch;} | |||
}, | |||
eatWhile: function(match) { | |||
var start = this.pos; | |||
while (this.eat(match)){} | |||
return this.pos > start; | |||
}, | |||
eatSpace: function() { | |||
var start = this.pos; | |||
while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) ++this.pos; | |||
return this.pos > start; | |||
}, | |||
skipToEnd: function() {this.pos = this.string.length;}, | |||
skipTo: function(ch) { | |||
var found = this.string.indexOf(ch, this.pos); | |||
if (found > -1) {this.pos = found; return true;} | |||
}, | |||
backUp: function(n) {this.pos -= n;}, | |||
column: function() {return this.start - this.lineStart;}, | |||
indentation: function() {return 0;}, | |||
match: function(pattern, consume, caseInsensitive) { | |||
if (typeof pattern == "string") { | |||
var cased = function(str) {return caseInsensitive ? str.toLowerCase() : str;}; | |||
var substr = this.string.substr(this.pos, pattern.length); | |||
if (cased(substr) == cased(pattern)) { | |||
if (consume !== false) this.pos += pattern.length; | |||
return true; | |||
} | |||
} else { | |||
var match = this.string.slice(this.pos).match(pattern); | |||
if (match && match.index > 0) return null; | |||
if (match && consume !== false) this.pos += match[0].length; | |||
return match; | |||
} | |||
}, | |||
current: function(){return this.string.slice(this.start, this.pos);}, | |||
hideFirstChars: function(n, inner) { | |||
this.lineStart += n; | |||
try { return inner(); } | |||
finally { this.lineStart -= n; } | |||
}, | |||
lookAhead: function() { return null } | |||
}; | |||
CodeMirror.StringStream = StringStream; | |||
CodeMirror.startState = function (mode, a1, a2) { | |||
return mode.startState ? mode.startState(a1, a2) : true; | |||
}; | |||
var modes = CodeMirror.modes = {}, mimeModes = CodeMirror.mimeModes = {}; | |||
CodeMirror.defineMode = function (name, mode) { | |||
if (arguments.length > 2) | |||
mode.dependencies = Array.prototype.slice.call(arguments, 2); | |||
modes[name] = mode; | |||
}; | |||
CodeMirror.defineMIME = function (mime, spec) { mimeModes[mime] = spec; }; | |||
CodeMirror.resolveMode = function(spec) { | |||
if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) { | |||
spec = mimeModes[spec]; | |||
} else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) { | |||
spec = mimeModes[spec.name]; | |||
} | |||
if (typeof spec == "string") return {name: spec}; | |||
else return spec || {name: "null"}; | |||
}; | |||
CodeMirror.getMode = function (options, spec) { | |||
spec = CodeMirror.resolveMode(spec); | |||
var mfactory = modes[spec.name]; | |||
if (!mfactory) throw new Error("Unknown mode: " + spec); | |||
return mfactory(options, spec); | |||
}; | |||
CodeMirror.registerHelper = CodeMirror.registerGlobalHelper = Math.min; | |||
CodeMirror.defineMode("null", function() { | |||
return {token: function(stream) {stream.skipToEnd();}}; | |||
}); | |||
CodeMirror.defineMIME("text/plain", "null"); | |||
CodeMirror.runMode = function (string, modespec, callback, options) { | |||
var mode = CodeMirror.getMode({ indentUnit: 2 }, modespec); | |||
if (callback.nodeType == 1) { | |||
var tabSize = (options && options.tabSize) || 4; | |||
var node = callback, col = 0; | |||
node.innerHTML = ""; | |||
callback = function (text, style) { | |||
if (text == "\n") { | |||
node.appendChild(document.createElement("br")); | |||
col = 0; | |||
return; | |||
} | |||
var content = ""; | |||
// replace tabs | |||
for (var pos = 0; ;) { | |||
var idx = text.indexOf("\t", pos); | |||
if (idx == -1) { | |||
content += text.slice(pos); | |||
col += text.length - pos; | |||
break; | |||
} else { | |||
col += idx - pos; | |||
content += text.slice(pos, idx); | |||
var size = tabSize - col % tabSize; | |||
col += size; | |||
for (var i = 0; i < size; ++i) content += " "; | |||
pos = idx + 1; | |||
} | |||
} | |||
if (style) { | |||
var sp = node.appendChild(document.createElement("span")); | |||
sp.className = "cm-" + style.replace(/ +/g, " cm-"); | |||
sp.appendChild(document.createTextNode(content)); | |||
} else { | |||
node.appendChild(document.createTextNode(content)); | |||
} | |||
}; | |||
} | |||
var lines = splitLines(string), state = (options && options.state) || CodeMirror.startState(mode); | |||
for (var i = 0, e = lines.length; i < e; ++i) { | |||
if (i) callback("\n"); | |||
var stream = new CodeMirror.StringStream(lines[i]); | |||
if (!stream.string && mode.blankLine) mode.blankLine(state); | |||
while (!stream.eol()) { | |||
var style = mode.token(stream, state); | |||
callback(stream.current(), style, i, stream.start, state); | |||
stream.start = stream.pos; | |||
} | |||
} | |||
}; | |||
})(); |
@ -0,0 +1,72 @@ | |||
// 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.runMode = function(string, modespec, callback, options) { | |||
var mode = CodeMirror.getMode(CodeMirror.defaults, modespec); | |||
var ie = /MSIE \d/.test(navigator.userAgent); | |||
var ie_lt9 = ie && (document.documentMode == null || document.documentMode < 9); | |||
if (callback.appendChild) { | |||
var tabSize = (options && options.tabSize) || CodeMirror.defaults.tabSize; | |||
var node = callback, col = 0; | |||
node.innerHTML = ""; | |||
callback = function(text, style) { | |||
if (text == "\n") { | |||
// Emitting LF or CRLF on IE8 or earlier results in an incorrect display. | |||
// Emitting a carriage return makes everything ok. | |||
node.appendChild(document.createTextNode(ie_lt9 ? '\r' : text)); | |||
col = 0; | |||
return; | |||
} | |||
var content = ""; | |||
// replace tabs | |||
for (var pos = 0;;) { | |||
var idx = text.indexOf("\t", pos); | |||
if (idx == -1) { | |||
content += text.slice(pos); | |||
col += text.length - pos; | |||
break; | |||
} else { | |||
col += idx - pos; | |||
content += text.slice(pos, idx); | |||
var size = tabSize - col % tabSize; | |||
col += size; | |||
for (var i = 0; i < size; ++i) content += " "; | |||
pos = idx + 1; | |||
} | |||
} | |||
if (style) { | |||
var sp = node.appendChild(document.createElement("span")); | |||
sp.className = "cm-" + style.replace(/ +/g, " cm-"); | |||
sp.appendChild(document.createTextNode(content)); | |||
} else { | |||
node.appendChild(document.createTextNode(content)); | |||
} | |||
}; | |||
} | |||
var lines = CodeMirror.splitLines(string), state = (options && options.state) || CodeMirror.startState(mode); | |||
for (var i = 0, e = lines.length; i < e; ++i) { | |||
if (i) callback("\n"); | |||
var stream = new CodeMirror.StringStream(lines[i]); | |||
if (!stream.string && mode.blankLine) mode.blankLine(state); | |||
while (!stream.eol()) { | |||
var style = mode.token(stream, state); | |||
callback(stream.current(), style, i, stream.start, state); | |||
stream.start = stream.pos; | |||
} | |||
} | |||
}; | |||
}); |
@ -0,0 +1,197 @@ | |||
// CodeMirror, copyright (c) by Marijn Haverbeke and others | |||
// Distributed under an MIT license: https://codemirror.net/LICENSE | |||
/* Just enough of CodeMirror to run runMode under node.js */ | |||
function splitLines(string){return string.split(/\r\n?|\n/);}; | |||
// Counts the column offset in a string, taking tabs into account. | |||
// Used mostly to find indentation. | |||
var countColumn = exports.countColumn = function(string, end, tabSize, startIndex, startValue) { | |||
if (end == null) { | |||
end = string.search(/[^\s\u00a0]/); | |||
if (end == -1) end = string.length; | |||
} | |||
for (var i = startIndex || 0, n = startValue || 0;;) { | |||
var nextTab = string.indexOf("\t", i); | |||
if (nextTab < 0 || nextTab >= end) | |||
return n + (end - i); | |||
n += nextTab - i; | |||
n += tabSize - (n % tabSize); | |||
i = nextTab + 1; | |||
} | |||
}; | |||
function StringStream(string, tabSize, context) { | |||
this.pos = this.start = 0; | |||
this.string = string; | |||
this.tabSize = tabSize || 8; | |||
this.lastColumnPos = this.lastColumnValue = 0; | |||
this.lineStart = 0; | |||
this.context = context | |||
}; | |||
StringStream.prototype = { | |||
eol: function() {return this.pos >= this.string.length;}, | |||
sol: function() {return this.pos == this.lineStart;}, | |||
peek: function() {return this.string.charAt(this.pos) || undefined;}, | |||
next: function() { | |||
if (this.pos < this.string.length) | |||
return this.string.charAt(this.pos++); | |||
}, | |||
eat: function(match) { | |||
var ch = this.string.charAt(this.pos); | |||
if (typeof match == "string") var ok = ch == match; | |||
else var ok = ch && (match.test ? match.test(ch) : match(ch)); | |||
if (ok) {++this.pos; return ch;} | |||
}, | |||
eatWhile: function(match) { | |||
var start = this.pos; | |||
while (this.eat(match)){} | |||
return this.pos > start; | |||
}, | |||
eatSpace: function() { | |||
var start = this.pos; | |||
while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) ++this.pos; | |||
return this.pos > start; | |||
}, | |||
skipToEnd: function() {this.pos = this.string.length;}, | |||
skipTo: function(ch) { | |||
var found = this.string.indexOf(ch, this.pos); | |||
if (found > -1) {this.pos = found; return true;} | |||
}, | |||
backUp: function(n) {this.pos -= n;}, | |||
column: function() { | |||
if (this.lastColumnPos < this.start) { | |||
this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue); | |||
this.lastColumnPos = this.start; | |||
} | |||
return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0); | |||
}, | |||
indentation: function() { | |||
return countColumn(this.string, null, this.tabSize) - | |||
(this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0); | |||
}, | |||
match: function(pattern, consume, caseInsensitive) { | |||
if (typeof pattern == "string") { | |||
var cased = function(str) {return caseInsensitive ? str.toLowerCase() : str;}; | |||
var substr = this.string.substr(this.pos, pattern.length); | |||
if (cased(substr) == cased(pattern)) { | |||
if (consume !== false) this.pos += pattern.length; | |||
return true; | |||
} | |||
} else { | |||
var match = this.string.slice(this.pos).match(pattern); | |||
if (match && match.index > 0) return null; | |||
if (match && consume !== false) this.pos += match[0].length; | |||
return match; | |||
} | |||
}, | |||
current: function(){return this.string.slice(this.start, this.pos);}, | |||
hideFirstChars: function(n, inner) { | |||
this.lineStart += n; | |||
try { return inner(); } | |||
finally { this.lineStart -= n; } | |||
}, | |||
lookAhead: function(n) { | |||
var line = this.context.line + n | |||
return line >= this.context.lines.length ? null : this.context.lines[line] | |||
} | |||
}; | |||
exports.StringStream = StringStream; | |||
exports.startState = function(mode, a1, a2) { | |||
return mode.startState ? mode.startState(a1, a2) : true; | |||
}; | |||
var modes = exports.modes = {}, mimeModes = exports.mimeModes = {}; | |||
exports.defineMode = function(name, mode) { | |||
if (arguments.length > 2) | |||
mode.dependencies = Array.prototype.slice.call(arguments, 2); | |||
modes[name] = mode; | |||
}; | |||
exports.defineMIME = function(mime, spec) { mimeModes[mime] = spec; }; | |||
exports.defineMode("null", function() { | |||
return {token: function(stream) {stream.skipToEnd();}}; | |||
}); | |||
exports.defineMIME("text/plain", "null"); | |||
exports.resolveMode = function(spec) { | |||
if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) { | |||
spec = mimeModes[spec]; | |||
} else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) { | |||
spec = mimeModes[spec.name]; | |||
} | |||
if (typeof spec == "string") return {name: spec}; | |||
else return spec || {name: "null"}; | |||
}; | |||
function copyObj(obj, target, overwrite) { | |||
if (!target) target = {}; | |||
for (var prop in obj) | |||
if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop))) | |||
target[prop] = obj[prop]; | |||
return target; | |||
} | |||
// This can be used to attach properties to mode objects from | |||
// outside the actual mode definition. | |||
var modeExtensions = exports.modeExtensions = {}; | |||
exports.extendMode = function(mode, properties) { | |||
var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {}); | |||
copyObj(properties, exts); | |||
}; | |||
exports.getMode = function(options, spec) { | |||
var spec = exports.resolveMode(spec); | |||
var mfactory = modes[spec.name]; | |||
if (!mfactory) return exports.getMode(options, "text/plain"); | |||
var modeObj = mfactory(options, spec); | |||
if (modeExtensions.hasOwnProperty(spec.name)) { | |||
var exts = modeExtensions[spec.name]; | |||
for (var prop in exts) { | |||
if (!exts.hasOwnProperty(prop)) continue; | |||
if (modeObj.hasOwnProperty(prop)) modeObj["_" + prop] = modeObj[prop]; | |||
modeObj[prop] = exts[prop]; | |||
} | |||
} | |||
modeObj.name = spec.name; | |||
if (spec.helperType) modeObj.helperType = spec.helperType; | |||
if (spec.modeProps) for (var prop in spec.modeProps) | |||
modeObj[prop] = spec.modeProps[prop]; | |||
return modeObj; | |||
}; | |||
exports.innerMode = function(mode, state) { | |||
var info; | |||
while (mode.innerMode) { | |||
info = mode.innerMode(state); | |||
if (!info || info.mode == mode) break; | |||
state = info.state; | |||
mode = info.mode; | |||
} | |||
return info || {mode: mode, state: state}; | |||
} | |||
exports.registerHelper = exports.registerGlobalHelper = Math.min; | |||
exports.runMode = function(string, modespec, callback, options) { | |||
var mode = exports.getMode({indentUnit: 2}, modespec); | |||
var lines = splitLines(string), state = (options && options.state) || exports.startState(mode); | |||
var context = {lines: lines, line: 0} | |||
for (var i = 0, e = lines.length; i < e; ++i, ++context.line) { | |||
if (i) callback("\n"); | |||
var stream = new exports.StringStream(lines[i], 4, context); | |||
if (!stream.string && mode.blankLine) mode.blankLine(state); | |||
while (!stream.eol()) { | |||
var style = mode.token(stream, state); | |||
callback(stream.current(), style, i, stream.start, state); | |||
stream.start = stream.pos; | |||
} | |||
} | |||
}; | |||
require.cache[require.resolve("../../lib/codemirror")] = require.cache[require.resolve("./runmode.node")]; | |||
require.cache[require.resolve("../../addon/runmode/runmode")] = require.cache[require.resolve("./runmode.node")]; |
@ -0,0 +1,122 @@ | |||
// 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.defineExtension("annotateScrollbar", function(options) { | |||
if (typeof options == "string") options = {className: options}; | |||
return new Annotation(this, options); | |||
}); | |||
CodeMirror.defineOption("scrollButtonHeight", 0); | |||
function Annotation(cm, options) { | |||
this.cm = cm; | |||
this.options = options; | |||
this.buttonHeight = options.scrollButtonHeight || cm.getOption("scrollButtonHeight"); | |||
this.annotations = []; | |||
this.doRedraw = this.doUpdate = null; | |||
this.div = cm.getWrapperElement().appendChild(document.createElement("div")); | |||
this.div.style.cssText = "position: absolute; right: 0; top: 0; z-index: 7; pointer-events: none"; | |||
this.computeScale(); | |||
function scheduleRedraw(delay) { | |||
clearTimeout(self.doRedraw); | |||
self.doRedraw = setTimeout(function() { self.redraw(); }, delay); | |||
} | |||
var self = this; | |||
cm.on("refresh", this.resizeHandler = function() { | |||
clearTimeout(self.doUpdate); | |||
self.doUpdate = setTimeout(function() { | |||
if (self.computeScale()) scheduleRedraw(20); | |||
}, 100); | |||
}); | |||
cm.on("markerAdded", this.resizeHandler); | |||
cm.on("markerCleared", this.resizeHandler); | |||
if (options.listenForChanges !== false) | |||
cm.on("changes", this.changeHandler = function() { | |||
scheduleRedraw(250); | |||
}); | |||
} | |||
Annotation.prototype.computeScale = function() { | |||
var cm = this.cm; | |||
var hScale = (cm.getWrapperElement().clientHeight - cm.display.barHeight - this.buttonHeight * 2) / | |||
cm.getScrollerElement().scrollHeight | |||
if (hScale != this.hScale) { | |||
this.hScale = hScale; | |||
return true; | |||
} | |||
}; | |||
Annotation.prototype.update = function(annotations) { | |||
this.annotations = annotations; | |||
this.redraw(); | |||
}; | |||
Annotation.prototype.redraw = function(compute) { | |||
if (compute !== false) this.computeScale(); | |||
var cm = this.cm, hScale = this.hScale; | |||
var frag = document.createDocumentFragment(), anns = this.annotations; | |||
var wrapping = cm.getOption("lineWrapping"); | |||
var singleLineH = wrapping && cm.defaultTextHeight() * 1.5; | |||
var curLine = null, curLineObj = null; | |||
function getY(pos, top) { | |||
if (curLine != pos.line) { | |||
curLine = pos.line; | |||
curLineObj = cm.getLineHandle(curLine); | |||
} | |||
if ((curLineObj.widgets && curLineObj.widgets.length) || | |||
(wrapping && curLineObj.height > singleLineH)) | |||
return cm.charCoords(pos, "local")[top ? "top" : "bottom"]; | |||
var topY = cm.heightAtLine(curLineObj, "local"); | |||
return topY + (top ? 0 : curLineObj.height); | |||
} | |||
var lastLine = cm.lastLine() | |||
if (cm.display.barWidth) for (var i = 0, nextTop; i < anns.length; i++) { | |||
var ann = anns[i]; | |||
if (ann.to.line > lastLine) continue; | |||
var top = nextTop || getY(ann.from, true) * hScale; | |||
var bottom = getY(ann.to, false) * hScale; | |||
while (i < anns.length - 1) { | |||
if (anns[i + 1].to.line > lastLine) break; | |||
nextTop = getY(anns[i + 1].from, true) * hScale; | |||
if (nextTop > bottom + .9) break; | |||
ann = anns[++i]; | |||
bottom = getY(ann.to, false) * hScale; | |||
} | |||
if (bottom == top) continue; | |||
var height = Math.max(bottom - top, 3); | |||
var elt = frag.appendChild(document.createElement("div")); | |||
elt.style.cssText = "position: absolute; right: 0px; width: " + Math.max(cm.display.barWidth - 1, 2) + "px; top: " | |||
+ (top + this.buttonHeight) + "px; height: " + height + "px"; | |||
elt.className = this.options.className; | |||
if (ann.id) { | |||
elt.setAttribute("annotation-id", ann.id); | |||
} | |||
} | |||
this.div.textContent = ""; | |||
this.div.appendChild(frag); | |||
}; | |||
Annotation.prototype.clear = function() { | |||
this.cm.off("refresh", this.resizeHandler); | |||
this.cm.off("markerAdded", this.resizeHandler); | |||
this.cm.off("markerCleared", this.resizeHandler); | |||
if (this.changeHandler) this.cm.off("changes", this.changeHandler); | |||
this.div.parentNode.removeChild(this.div); | |||
}; | |||
}); |
@ -0,0 +1,48 @@ | |||
// 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.defineOption("scrollPastEnd", false, function(cm, val, old) { | |||
if (old && old != CodeMirror.Init) { | |||
cm.off("change", onChange); | |||
cm.off("refresh", updateBottomMargin); | |||
cm.display.lineSpace.parentNode.style.paddingBottom = ""; | |||
cm.state.scrollPastEndPadding = null; | |||
} | |||
if (val) { | |||
cm.on("change", onChange); | |||
cm.on("refresh", updateBottomMargin); | |||
updateBottomMargin(cm); | |||
} | |||
}); | |||
function onChange(cm, change) { | |||
if (CodeMirror.changeEnd(change).line == cm.lastLine()) | |||
updateBottomMargin(cm); | |||
} | |||
function updateBottomMargin(cm) { | |||
var padding = ""; | |||
if (cm.lineCount() > 1) { | |||
var totalH = cm.display.scroller.clientHeight - 30, | |||
lastLineH = cm.getLineHandle(cm.lastLine()).height; | |||
padding = (totalH - lastLineH) + "px"; | |||
} | |||
if (cm.state.scrollPastEndPadding != padding) { | |||
cm.state.scrollPastEndPadding = padding; | |||
cm.display.lineSpace.parentNode.style.paddingBottom = padding; | |||
cm.off("refresh", updateBottomMargin); | |||
cm.setSize(); | |||
cm.on("refresh", updateBottomMargin); | |||
} | |||
} | |||
}); |
@ -0,0 +1,66 @@ | |||
.CodeMirror-simplescroll-horizontal div, .CodeMirror-simplescroll-vertical div { | |||
position: absolute; | |||
background: #ccc; | |||
-moz-box-sizing: border-box; | |||
box-sizing: border-box; | |||
border: 1px solid #bbb; | |||
border-radius: 2px; | |||
} | |||
.CodeMirror-simplescroll-horizontal, .CodeMirror-simplescroll-vertical { | |||
position: absolute; | |||
z-index: 6; | |||
background: #eee; | |||
} | |||
.CodeMirror-simplescroll-horizontal { | |||
bottom: 0; left: 0; | |||
height: 8px; | |||
} | |||
.CodeMirror-simplescroll-horizontal div { | |||
bottom: 0; | |||
height: 100%; | |||
} | |||
.CodeMirror-simplescroll-vertical { | |||
right: 0; top: 0; | |||
width: 8px; | |||
} | |||
.CodeMirror-simplescroll-vertical div { | |||
right: 0; | |||
width: 100%; | |||
} | |||
.CodeMirror-overlayscroll .CodeMirror-scrollbar-filler, .CodeMirror-overlayscroll .CodeMirror-gutter-filler { | |||
display: none; | |||
} | |||
.CodeMirror-overlayscroll-horizontal div, .CodeMirror-overlayscroll-vertical div { | |||
position: absolute; | |||
background: #bcd; | |||
border-radius: 3px; | |||
} | |||
.CodeMirror-overlayscroll-horizontal, .CodeMirror-overlayscroll-vertical { | |||
position: absolute; | |||
z-index: 6; | |||
} | |||
.CodeMirror-overlayscroll-horizontal { | |||
bottom: 0; left: 0; | |||
height: 6px; | |||
} | |||
.CodeMirror-overlayscroll-horizontal div { | |||
bottom: 0; | |||
height: 100%; | |||
} | |||
.CodeMirror-overlayscroll-vertical { | |||
right: 0; top: 0; | |||
width: 6px; | |||
} | |||
.CodeMirror-overlayscroll-vertical div { | |||
right: 0; | |||
width: 100%; | |||
} |
@ -0,0 +1,152 @@ | |||
// 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"; | |||
function Bar(cls, orientation, scroll) { | |||
this.orientation = orientation; | |||
this.scroll = scroll; | |||
this.screen = this.total = this.size = 1; | |||
this.pos = 0; | |||
this.node = document.createElement("div"); | |||
this.node.className = cls + "-" + orientation; | |||
this.inner = this.node.appendChild(document.createElement("div")); | |||
var self = this; | |||
CodeMirror.on(this.inner, "mousedown", function(e) { | |||
if (e.which != 1) return; | |||
CodeMirror.e_preventDefault(e); | |||
var axis = self.orientation == "horizontal" ? "pageX" : "pageY"; | |||
var start = e[axis], startpos = self.pos; | |||
function done() { | |||
CodeMirror.off(document, "mousemove", move); | |||
CodeMirror.off(document, "mouseup", done); | |||
} | |||
function move(e) { | |||
if (e.which != 1) return done(); | |||
self.moveTo(startpos + (e[axis] - start) * (self.total / self.size)); | |||
} | |||
CodeMirror.on(document, "mousemove", move); | |||
CodeMirror.on(document, "mouseup", done); | |||
}); | |||
CodeMirror.on(this.node, "click", function(e) { | |||
CodeMirror.e_preventDefault(e); | |||
var innerBox = self.inner.getBoundingClientRect(), where; | |||
if (self.orientation == "horizontal") | |||
where = e.clientX < innerBox.left ? -1 : e.clientX > innerBox.right ? 1 : 0; | |||
else | |||
where = e.clientY < innerBox.top ? -1 : e.clientY > innerBox.bottom ? 1 : 0; | |||
self.moveTo(self.pos + where * self.screen); | |||
}); | |||
function onWheel(e) { | |||
var moved = CodeMirror.wheelEventPixels(e)[self.orientation == "horizontal" ? "x" : "y"]; | |||
var oldPos = self.pos; | |||
self.moveTo(self.pos + moved); | |||
if (self.pos != oldPos) CodeMirror.e_preventDefault(e); | |||
} | |||
CodeMirror.on(this.node, "mousewheel", onWheel); | |||
CodeMirror.on(this.node, "DOMMouseScroll", onWheel); | |||
} | |||
Bar.prototype.setPos = function(pos, force) { | |||
if (pos < 0) pos = 0; | |||
if (pos > this.total - this.screen) pos = this.total - this.screen; | |||
if (!force && pos == this.pos) return false; | |||
this.pos = pos; | |||
this.inner.style[this.orientation == "horizontal" ? "left" : "top"] = | |||
(pos * (this.size / this.total)) + "px"; | |||
return true | |||
}; | |||
Bar.prototype.moveTo = function(pos) { | |||
if (this.setPos(pos)) this.scroll(pos, this.orientation); | |||
} | |||
var minButtonSize = 10; | |||
Bar.prototype.update = function(scrollSize, clientSize, barSize) { | |||
var sizeChanged = this.screen != clientSize || this.total != scrollSize || this.size != barSize | |||
if (sizeChanged) { | |||
this.screen = clientSize; | |||
this.total = scrollSize; | |||
this.size = barSize; | |||
} | |||
var buttonSize = this.screen * (this.size / this.total); | |||
if (buttonSize < minButtonSize) { | |||
this.size -= minButtonSize - buttonSize; | |||
buttonSize = minButtonSize; | |||
} | |||
this.inner.style[this.orientation == "horizontal" ? "width" : "height"] = | |||
buttonSize + "px"; | |||
this.setPos(this.pos, sizeChanged); | |||
}; | |||
function SimpleScrollbars(cls, place, scroll) { | |||
this.addClass = cls; | |||
this.horiz = new Bar(cls, "horizontal", scroll); | |||
place(this.horiz.node); | |||
this.vert = new Bar(cls, "vertical", scroll); | |||
place(this.vert.node); | |||
this.width = null; | |||
} | |||
SimpleScrollbars.prototype.update = function(measure) { | |||
if (this.width == null) { | |||
var style = window.getComputedStyle ? window.getComputedStyle(this.horiz.node) : this.horiz.node.currentStyle; | |||
if (style) this.width = parseInt(style.height); | |||
} | |||
var width = this.width || 0; | |||
var needsH = measure.scrollWidth > measure.clientWidth + 1; | |||
var needsV = measure.scrollHeight > measure.clientHeight + 1; | |||
this.vert.node.style.display = needsV ? "block" : "none"; | |||
this.horiz.node.style.display = needsH ? "block" : "none"; | |||
if (needsV) { | |||
this.vert.update(measure.scrollHeight, measure.clientHeight, | |||
measure.viewHeight - (needsH ? width : 0)); | |||
this.vert.node.style.bottom = needsH ? width + "px" : "0"; | |||
} | |||
if (needsH) { | |||
this.horiz.update(measure.scrollWidth, measure.clientWidth, | |||
measure.viewWidth - (needsV ? width : 0) - measure.barLeft); | |||
this.horiz.node.style.right = needsV ? width + "px" : "0"; | |||
this.horiz.node.style.left = measure.barLeft + "px"; | |||
} | |||
return {right: needsV ? width : 0, bottom: needsH ? width : 0}; | |||
}; | |||
SimpleScrollbars.prototype.setScrollTop = function(pos) { | |||
this.vert.setPos(pos); | |||
}; | |||
SimpleScrollbars.prototype.setScrollLeft = function(pos) { | |||
this.horiz.setPos(pos); | |||
}; | |||
SimpleScrollbars.prototype.clear = function() { | |||
var parent = this.horiz.node.parentNode; | |||
parent.removeChild(this.horiz.node); | |||
parent.removeChild(this.vert.node); | |||
}; | |||
CodeMirror.scrollbarModel.simple = function(place, scroll) { | |||
return new SimpleScrollbars("CodeMirror-simplescroll", place, scroll); | |||
}; | |||
CodeMirror.scrollbarModel.overlay = function(place, scroll) { | |||
return new SimpleScrollbars("CodeMirror-overlayscroll", place, scroll); | |||
}; | |||
}); |
@ -0,0 +1,50 @@ | |||
// CodeMirror, copyright (c) by Marijn Haverbeke and others | |||
// Distributed under an MIT license: https://codemirror.net/LICENSE | |||
// Defines jumpToLine command. Uses dialog.js if present. | |||
(function(mod) { | |||
if (typeof exports == "object" && typeof module == "object") // CommonJS | |||
mod(require("../../lib/codemirror"), require("../dialog/dialog")); | |||
else if (typeof define == "function" && define.amd) // AMD | |||
define(["../../lib/codemirror", "../dialog/dialog"], mod); | |||
else // Plain browser env | |||
mod(CodeMirror); | |||
})(function(CodeMirror) { | |||
"use strict"; | |||
function dialog(cm, text, shortText, deflt, f) { | |||
if (cm.openDialog) cm.openDialog(text, f, {value: deflt, selectValueOnOpen: true}); | |||
else f(prompt(shortText, deflt)); | |||
} | |||
function getJumpDialog(cm) { | |||
return cm.phrase("Jump to line:") + ' <input type="text" style="width: 10em" class="CodeMirror-search-field"/> <span style="color: #888" class="CodeMirror-search-hint">' + cm.phrase("(Use line:column or scroll% syntax)") + '</span>'; | |||
} | |||
function interpretLine(cm, string) { | |||
var num = Number(string) | |||
if (/^[-+]/.test(string)) return cm.getCursor().line + num | |||
else return num - 1 | |||
} | |||
CodeMirror.commands.jumpToLine = function(cm) { | |||
var cur = cm.getCursor(); | |||
dialog(cm, getJumpDialog(cm), cm.phrase("Jump to line:"), (cur.line + 1) + ":" + cur.ch, function(posStr) { | |||
if (!posStr) return; | |||
var match; | |||
if (match = /^\s*([\+\-]?\d+)\s*\:\s*(\d+)\s*$/.exec(posStr)) { | |||
cm.setCursor(interpretLine(cm, match[1]), Number(match[2])) | |||
} else if (match = /^\s*([\+\-]?\d+(\.\d+)?)\%\s*/.exec(posStr)) { | |||
var line = Math.round(cm.lineCount() * Number(match[1]) / 100); | |||
if (/^[-+]/.test(match[1])) line = cur.line + line + 1; | |||
cm.setCursor(line - 1, cur.ch); | |||
} else if (match = /^\s*\:?\s*([\+\-]?\d+)\s*/.exec(posStr)) { | |||
cm.setCursor(interpretLine(cm, match[1]), cur.ch); | |||
} | |||
}); | |||
}; | |||
CodeMirror.keyMap["default"]["Alt-G"] = "jumpToLine"; | |||
}); |
@ -0,0 +1,165 @@ | |||
// CodeMirror, copyright (c) by Marijn Haverbeke and others | |||
// Distributed under an MIT license: https://codemirror.net/LICENSE | |||
// Highlighting text that matches the selection | |||
// | |||
// Defines an option highlightSelectionMatches, which, when enabled, | |||
// will style strings that match the selection throughout the | |||
// document. | |||
// | |||
// The option can be set to true to simply enable it, or to a | |||
// {minChars, style, wordsOnly, showToken, delay} object to explicitly | |||
// configure it. minChars is the minimum amount of characters that should be | |||
// selected for the behavior to occur, and style is the token style to | |||
// apply to the matches. This will be prefixed by "cm-" to create an | |||
// actual CSS class name. If wordsOnly is enabled, the matches will be | |||
// highlighted only if the selected text is a word. showToken, when enabled, | |||
// will cause the current token to be highlighted when nothing is selected. | |||
// delay is used to specify how much time to wait, in milliseconds, before | |||
// highlighting the matches. If annotateScrollbar is enabled, the occurences | |||
// will be highlighted on the scrollbar via the matchesonscrollbar addon. | |||
(function(mod) { | |||
if (typeof exports == "object" && typeof module == "object") // CommonJS | |||
mod(require("../../lib/codemirror"), require("./matchesonscrollbar")); | |||
else if (typeof define == "function" && define.amd) // AMD | |||
define(["../../lib/codemirror", "./matchesonscrollbar"], mod); | |||
else // Plain browser env | |||
mod(CodeMirror); | |||
})(function(CodeMirror) { | |||
"use strict"; | |||
var defaults = { | |||
style: "matchhighlight", | |||
minChars: 2, | |||
delay: 100, | |||
wordsOnly: false, | |||
annotateScrollbar: false, | |||
showToken: false, | |||
trim: true | |||
} | |||
function State(options) { | |||
this.options = {} | |||
for (var name in defaults) | |||
this.options[name] = (options && options.hasOwnProperty(name) ? options : defaults)[name] | |||
this.overlay = this.timeout = null; | |||
this.matchesonscroll = null; | |||
this.active = false; | |||
} | |||
CodeMirror.defineOption("highlightSelectionMatches", false, function(cm, val, old) { | |||
if (old && old != CodeMirror.Init) { | |||
removeOverlay(cm); | |||
clearTimeout(cm.state.matchHighlighter.timeout); | |||
cm.state.matchHighlighter = null; | |||
cm.off("cursorActivity", cursorActivity); | |||
cm.off("focus", onFocus) | |||
} | |||
if (val) { | |||
var state = cm.state.matchHighlighter = new State(val); | |||
if (cm.hasFocus()) { | |||
state.active = true | |||
highlightMatches(cm) | |||
} else { | |||
cm.on("focus", onFocus) | |||
} | |||
cm.on("cursorActivity", cursorActivity); | |||
} | |||
}); | |||
function cursorActivity(cm) { | |||
var state = cm.state.matchHighlighter; | |||
if (state.active || cm.hasFocus()) scheduleHighlight(cm, state) | |||
} | |||
function onFocus(cm) { | |||
var state = cm.state.matchHighlighter | |||
if (!state.active) { | |||
state.active = true | |||
scheduleHighlight(cm, state) | |||
} | |||
} | |||
function scheduleHighlight(cm, state) { | |||
clearTimeout(state.timeout); | |||
state.timeout = setTimeout(function() {highlightMatches(cm);}, state.options.delay); | |||
} | |||
function addOverlay(cm, query, hasBoundary, style) { | |||
var state = cm.state.matchHighlighter; | |||
cm.addOverlay(state.overlay = makeOverlay(query, hasBoundary, style)); | |||
if (state.options.annotateScrollbar && cm.showMatchesOnScrollbar) { | |||
var searchFor = hasBoundary ? new RegExp("\\b" + query.replace(/[\\\[.+*?(){|^$]/g, "\\$&") + "\\b") : query; | |||
state.matchesonscroll = cm.showMatchesOnScrollbar(searchFor, false, | |||
{className: "CodeMirror-selection-highlight-scrollbar"}); | |||
} | |||
} | |||
function removeOverlay(cm) { | |||
var state = cm.state.matchHighlighter; | |||
if (state.overlay) { | |||
cm.removeOverlay(state.overlay); | |||
state.overlay = null; | |||
if (state.matchesonscroll) { | |||
state.matchesonscroll.clear(); | |||
state.matchesonscroll = null; | |||
} | |||
} | |||
} | |||
function highlightMatches(cm) { | |||
cm.operation(function() { | |||
var state = cm.state.matchHighlighter; | |||
removeOverlay(cm); | |||
if (!cm.somethingSelected() && state.options.showToken) { | |||
var re = state.options.showToken === true ? /[\w$]/ : state.options.showToken; | |||
var cur = cm.getCursor(), line = cm.getLine(cur.line), start = cur.ch, end = start; | |||
while (start && re.test(line.charAt(start - 1))) --start; | |||
while (end < line.length && re.test(line.charAt(end))) ++end; | |||
if (start < end) | |||
addOverlay(cm, line.slice(start, end), re, state.options.style); | |||
return; | |||
} | |||
var from = cm.getCursor("from"), to = cm.getCursor("to"); | |||
if (from.line != to.line) return; | |||
if (state.options.wordsOnly && !isWord(cm, from, to)) return; | |||
var selection = cm.getRange(from, to) | |||
if (state.options.trim) selection = selection.replace(/^\s+|\s+$/g, "") | |||
if (selection.length >= state.options.minChars) | |||
addOverlay(cm, selection, false, state.options.style); | |||
}); | |||
} | |||
function isWord(cm, from, to) { | |||
var str = cm.getRange(from, to); | |||
if (str.match(/^\w+$/) !== null) { | |||
if (from.ch > 0) { | |||
var pos = {line: from.line, ch: from.ch - 1}; | |||
var chr = cm.getRange(pos, from); | |||
if (chr.match(/\W/) === null) return false; | |||
} | |||
if (to.ch < cm.getLine(from.line).length) { | |||
var pos = {line: to.line, ch: to.ch + 1}; | |||
var chr = cm.getRange(to, pos); | |||
if (chr.match(/\W/) === null) return false; | |||
} | |||
return true; | |||
} else return false; | |||
} | |||
function boundariesAround(stream, re) { | |||
return (!stream.start || !re.test(stream.string.charAt(stream.start - 1))) && | |||
(stream.pos == stream.string.length || !re.test(stream.string.charAt(stream.pos))); | |||
} | |||
function makeOverlay(query, hasBoundary, style) { | |||
return {token: function(stream) { | |||
if (stream.match(query) && | |||
(!hasBoundary || boundariesAround(stream, hasBoundary))) | |||
return style; | |||
stream.next(); | |||
stream.skipTo(query.charAt(0)) || stream.skipToEnd(); | |||
}}; | |||
} | |||
}); |
@ -0,0 +1,8 @@ | |||
.CodeMirror-search-match { | |||
background: gold; | |||
border-top: 1px solid orange; | |||
border-bottom: 1px solid orange; | |||
-moz-box-sizing: border-box; | |||
box-sizing: border-box; | |||
opacity: .5; | |||
} |
@ -0,0 +1,97 @@ | |||
// 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"), require("./searchcursor"), require("../scroll/annotatescrollbar")); | |||
else if (typeof define == "function" && define.amd) // AMD | |||
define(["../../lib/codemirror", "./searchcursor", "../scroll/annotatescrollbar"], mod); | |||
else // Plain browser env | |||
mod(CodeMirror); | |||
})(function(CodeMirror) { | |||
"use strict"; | |||
CodeMirror.defineExtension("showMatchesOnScrollbar", function(query, caseFold, options) { | |||
if (typeof options == "string") options = {className: options}; | |||
if (!options) options = {}; | |||
return new SearchAnnotation(this, query, caseFold, options); | |||
}); | |||
function SearchAnnotation(cm, query, caseFold, options) { | |||
this.cm = cm; | |||
this.options = options; | |||
var annotateOptions = {listenForChanges: false}; | |||
for (var prop in options) annotateOptions[prop] = options[prop]; | |||
if (!annotateOptions.className) annotateOptions.className = "CodeMirror-search-match"; | |||
this.annotation = cm.annotateScrollbar(annotateOptions); | |||
this.query = query; | |||
this.caseFold = caseFold; | |||
this.gap = {from: cm.firstLine(), to: cm.lastLine() + 1}; | |||
this.matches = []; | |||
this.update = null; | |||
this.findMatches(); | |||
this.annotation.update(this.matches); | |||
var self = this; | |||
cm.on("change", this.changeHandler = function(_cm, change) { self.onChange(change); }); | |||
} | |||
var MAX_MATCHES = 1000; | |||
SearchAnnotation.prototype.findMatches = function() { | |||
if (!this.gap) return; | |||
for (var i = 0; i < this.matches.length; i++) { | |||
var match = this.matches[i]; | |||
if (match.from.line >= this.gap.to) break; | |||
if (match.to.line >= this.gap.from) this.matches.splice(i--, 1); | |||
} | |||
var cursor = this.cm.getSearchCursor(this.query, CodeMirror.Pos(this.gap.from, 0), {caseFold: this.caseFold, multiline: this.options.multiline}); | |||
var maxMatches = this.options && this.options.maxMatches || MAX_MATCHES; | |||
while (cursor.findNext()) { | |||
var match = {from: cursor.from(), to: cursor.to()}; | |||
if (match.from.line >= this.gap.to) break; | |||
this.matches.splice(i++, 0, match); | |||
if (this.matches.length > maxMatches) break; | |||
} | |||
this.gap = null; | |||
}; | |||
function offsetLine(line, changeStart, sizeChange) { | |||
if (line <= changeStart) return line; | |||
return Math.max(changeStart, line + sizeChange); | |||
} | |||
SearchAnnotation.prototype.onChange = function(change) { | |||
var startLine = change.from.line; | |||
var endLine = CodeMirror.changeEnd(change).line; | |||
var sizeChange = endLine - change.to.line; | |||
if (this.gap) { | |||
this.gap.from = Math.min(offsetLine(this.gap.from, startLine, sizeChange), change.from.line); | |||
this.gap.to = Math.max(offsetLine(this.gap.to, startLine, sizeChange), change.from.line); | |||
} else { | |||
this.gap = {from: change.from.line, to: endLine + 1}; | |||
} | |||
if (sizeChange) for (var i = 0; i < this.matches.length; i++) { | |||
var match = this.matches[i]; | |||
var newFrom = offsetLine(match.from.line, startLine, sizeChange); | |||
if (newFrom != match.from.line) match.from = CodeMirror.Pos(newFrom, match.from.ch); | |||
var newTo = offsetLine(match.to.line, startLine, sizeChange); | |||
if (newTo != match.to.line) match.to = CodeMirror.Pos(newTo, match.to.ch); | |||
} | |||
clearTimeout(this.update); | |||
var self = this; | |||
this.update = setTimeout(function() { self.updateAfterChange(); }, 250); | |||
}; | |||
SearchAnnotation.prototype.updateAfterChange = function() { | |||
this.findMatches(); | |||
this.annotation.update(this.matches); | |||
}; | |||
SearchAnnotation.prototype.clear = function() { | |||
this.cm.off("change", this.changeHandler); | |||
this.annotation.clear(); | |||
}; | |||
}); |
@ -0,0 +1,260 @@ | |||
// CodeMirror, copyright (c) by Marijn Haverbeke and others | |||
// Distributed under an MIT license: https://codemirror.net/LICENSE | |||
// Define search commands. Depends on dialog.js or another | |||
// implementation of the openDialog method. | |||
// Replace works a little oddly -- it will do the replace on the next | |||
// Ctrl-G (or whatever is bound to findNext) press. You prevent a | |||
// replace by making sure the match is no longer selected when hitting | |||
// Ctrl-G. | |||
(function(mod) { | |||
if (typeof exports == "object" && typeof module == "object") // CommonJS | |||
mod(require("../../lib/codemirror"), require("./searchcursor"), require("../dialog/dialog")); | |||
else if (typeof define == "function" && define.amd) // AMD | |||
define(["../../lib/codemirror", "./searchcursor", "../dialog/dialog"], mod); | |||
else // Plain browser env | |||
mod(CodeMirror); | |||
})(function(CodeMirror) { | |||
"use strict"; | |||
function searchOverlay(query, caseInsensitive) { | |||
if (typeof query == "string") | |||
query = new RegExp(query.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"), caseInsensitive ? "gi" : "g"); | |||
else if (!query.global) | |||
query = new RegExp(query.source, query.ignoreCase ? "gi" : "g"); | |||
return {token: function(stream) { | |||
query.lastIndex = stream.pos; | |||
var match = query.exec(stream.string); | |||
if (match && match.index == stream.pos) { | |||
stream.pos += match[0].length || 1; | |||
return "searching"; | |||
} else if (match) { | |||
stream.pos = match.index; | |||
} else { | |||
stream.skipToEnd(); | |||
} | |||
}}; | |||
} | |||
function SearchState() { | |||
this.posFrom = this.posTo = this.lastQuery = this.query = null; | |||
this.overlay = null; | |||
} | |||
function getSearchState(cm) { | |||
return cm.state.search || (cm.state.search = new SearchState()); | |||
} | |||
function queryCaseInsensitive(query) { | |||
return typeof query == "string" && query == query.toLowerCase(); | |||
} | |||
function getSearchCursor(cm, query, pos) { | |||
// Heuristic: if the query string is all lowercase, do a case insensitive search. | |||
return cm.getSearchCursor(query, pos, {caseFold: queryCaseInsensitive(query), multiline: true}); | |||
} | |||
function persistentDialog(cm, text, deflt, onEnter, onKeyDown) { | |||
cm.openDialog(text, onEnter, { | |||
value: deflt, | |||
selectValueOnOpen: true, | |||
closeOnEnter: false, | |||
onClose: function() { clearSearch(cm); }, | |||
onKeyDown: onKeyDown | |||
}); | |||
} | |||
function dialog(cm, text, shortText, deflt, f) { | |||
if (cm.openDialog) cm.openDialog(text, f, {value: deflt, selectValueOnOpen: true}); | |||
else f(prompt(shortText, deflt)); | |||
} | |||
function confirmDialog(cm, text, shortText, fs) { | |||
if (cm.openConfirm) cm.openConfirm(text, fs); | |||
else if (confirm(shortText)) fs[0](); | |||
} | |||
function parseString(string) { | |||
return string.replace(/\\([nrt\\])/g, function(match, ch) { | |||
if (ch == "n") return "\n" | |||
if (ch == "r") return "\r" | |||
if (ch == "t") return "\t" | |||
if (ch == "\\") return "\\" | |||
return match | |||
}) | |||
} | |||
function parseQuery(query) { | |||
var isRE = query.match(/^\/(.*)\/([a-z]*)$/); | |||
if (isRE) { | |||
try { query = new RegExp(isRE[1], isRE[2].indexOf("i") == -1 ? "" : "i"); } | |||
catch(e) {} // Not a regular expression after all, do a string search | |||
} else { | |||
query = parseString(query) | |||
} | |||
if (typeof query == "string" ? query == "" : query.test("")) | |||
query = /x^/; | |||
return query; | |||
} | |||
function startSearch(cm, state, query) { | |||
state.queryText = query; | |||
state.query = parseQuery(query); | |||
cm.removeOverlay(state.overlay, queryCaseInsensitive(state.query)); | |||
state.overlay = searchOverlay(state.query, queryCaseInsensitive(state.query)); | |||
cm.addOverlay(state.overlay); | |||
if (cm.showMatchesOnScrollbar) { | |||
if (state.annotate) { state.annotate.clear(); state.annotate = null; } | |||
state.annotate = cm.showMatchesOnScrollbar(state.query, queryCaseInsensitive(state.query)); | |||
} | |||
} | |||
function doSearch(cm, rev, persistent, immediate) { | |||
var state = getSearchState(cm); | |||
if (state.query) return findNext(cm, rev); | |||
var q = cm.getSelection() || state.lastQuery; | |||
if (q instanceof RegExp && q.source == "x^") q = null | |||
if (persistent && cm.openDialog) { | |||
var hiding = null | |||
var searchNext = function(query, event) { | |||
CodeMirror.e_stop(event); | |||
if (!query) return; | |||
if (query != state.queryText) { | |||
startSearch(cm, state, query); | |||
state.posFrom = state.posTo = cm.getCursor(); | |||
} | |||
if (hiding) hiding.style.opacity = 1 | |||
findNext(cm, event.shiftKey, function(_, to) { | |||
var dialog | |||
if (to.line < 3 && document.querySelector && | |||
(dialog = cm.display.wrapper.querySelector(".CodeMirror-dialog")) && | |||
dialog.getBoundingClientRect().bottom - 4 > cm.cursorCoords(to, "window").top) | |||
(hiding = dialog).style.opacity = .4 | |||
}) | |||
}; | |||
persistentDialog(cm, getQueryDialog(cm), q, searchNext, function(event, query) { | |||
var keyName = CodeMirror.keyName(event) | |||
var extra = cm.getOption('extraKeys'), cmd = (extra && extra[keyName]) || CodeMirror.keyMap[cm.getOption("keyMap")][keyName] | |||
if (cmd == "findNext" || cmd == "findPrev" || | |||
cmd == "findPersistentNext" || cmd == "findPersistentPrev") { | |||
CodeMirror.e_stop(event); | |||
startSearch(cm, getSearchState(cm), query); | |||
cm.execCommand(cmd); | |||
} else if (cmd == "find" || cmd == "findPersistent") { | |||
CodeMirror.e_stop(event); | |||
searchNext(query, event); | |||
} | |||
}); | |||
if (immediate && q) { | |||
startSearch(cm, state, q); | |||
findNext(cm, rev); | |||
} | |||
} else { | |||
dialog(cm, getQueryDialog(cm), "Search for:", q, function(query) { | |||
if (query && !state.query) cm.operation(function() { | |||
startSearch(cm, state, query); | |||
state.posFrom = state.posTo = cm.getCursor(); | |||
findNext(cm, rev); | |||
}); | |||
}); | |||
} | |||
} | |||
function findNext(cm, rev, callback) {cm.operation(function() { | |||
var state = getSearchState(cm); | |||
var cursor = getSearchCursor(cm, state.query, rev ? state.posFrom : state.posTo); | |||
if (!cursor.find(rev)) { | |||
cursor = getSearchCursor(cm, state.query, rev ? CodeMirror.Pos(cm.lastLine()) : CodeMirror.Pos(cm.firstLine(), 0)); | |||
if (!cursor.find(rev)) return; | |||
} | |||
cm.setSelection(cursor.from(), cursor.to()); | |||
cm.scrollIntoView({from: cursor.from(), to: cursor.to()}, 20); | |||
state.posFrom = cursor.from(); state.posTo = cursor.to(); | |||
if (callback) callback(cursor.from(), cursor.to()) | |||
});} | |||
function clearSearch(cm) {cm.operation(function() { | |||
var state = getSearchState(cm); | |||
state.lastQuery = state.query; | |||
if (!state.query) return; | |||
state.query = state.queryText = null; | |||
cm.removeOverlay(state.overlay); | |||
if (state.annotate) { state.annotate.clear(); state.annotate = null; } | |||
});} | |||
function getQueryDialog(cm) { | |||
return '<span class="CodeMirror-search-label">' + cm.phrase("Search:") + '</span> <input type="text" style="width: 10em" class="CodeMirror-search-field"/> <span style="color: #888" class="CodeMirror-search-hint">' + cm.phrase("(Use /re/ syntax for regexp search)") + '</span>'; | |||
} | |||
function getReplaceQueryDialog(cm) { | |||
return ' <input type="text" style="width: 10em" class="CodeMirror-search-field"/> <span style="color: #888" class="CodeMirror-search-hint">' + cm.phrase("(Use /re/ syntax for regexp search)") + '</span>'; | |||
} | |||
function getReplacementQueryDialog(cm) { | |||
return '<span class="CodeMirror-search-label">' + cm.phrase("With:") + '</span> <input type="text" style="width: 10em" class="CodeMirror-search-field"/>'; | |||
} | |||
function getDoReplaceConfirm(cm) { | |||
return '<span class="CodeMirror-search-label">' + cm.phrase("Replace?") + '</span> <button>' + cm.phrase("Yes") + '</button> <button>' + cm.phrase("No") + '</button> <button>' + cm.phrase("All") + '</button> <button>' + cm.phrase("Stop") + '</button> '; | |||
} | |||
function replaceAll(cm, query, text) { | |||
cm.operation(function() { | |||
for (var cursor = getSearchCursor(cm, query); cursor.findNext();) { | |||
if (typeof query != "string") { | |||
var match = cm.getRange(cursor.from(), cursor.to()).match(query); | |||
cursor.replace(text.replace(/\$(\d)/g, function(_, i) {return match[i];})); | |||
} else cursor.replace(text); | |||
} | |||
}); | |||
} | |||
function replace(cm, all) { | |||
if (cm.getOption("readOnly")) return; | |||
var query = cm.getSelection() || getSearchState(cm).lastQuery; | |||
var dialogText = '<span class="CodeMirror-search-label">' + (all ? cm.phrase("Replace all:") : cm.phrase("Replace:")) + '</span>'; | |||
dialog(cm, dialogText + getReplaceQueryDialog(cm), dialogText, query, function(query) { | |||
if (!query) return; | |||
query = parseQuery(query); | |||
dialog(cm, getReplacementQueryDialog(cm), cm.phrase("Replace with:"), "", function(text) { | |||
text = parseString(text) | |||
if (all) { | |||
replaceAll(cm, query, text) | |||
} else { | |||
clearSearch(cm); | |||
var cursor = getSearchCursor(cm, query, cm.getCursor("from")); | |||
var advance = function() { | |||
var start = cursor.from(), match; | |||
if (!(match = cursor.findNext())) { | |||
cursor = getSearchCursor(cm, query); | |||
if (!(match = cursor.findNext()) || | |||
(start && cursor.from().line == start.line && cursor.from().ch == start.ch)) return; | |||
} | |||
cm.setSelection(cursor.from(), cursor.to()); | |||
cm.scrollIntoView({from: cursor.from(), to: cursor.to()}); | |||
confirmDialog(cm, getDoReplaceConfirm(cm), cm.phrase("Replace?"), | |||
[function() {doReplace(match);}, advance, | |||
function() {replaceAll(cm, query, text)}]); | |||
}; | |||
var doReplace = function(match) { | |||
cursor.replace(typeof query == "string" ? text : | |||
text.replace(/\$(\d)/g, function(_, i) {return match[i];})); | |||
advance(); | |||
}; | |||
advance(); | |||
} | |||
}); | |||
}); | |||
} | |||
CodeMirror.commands.find = function(cm) {clearSearch(cm); doSearch(cm);}; | |||
CodeMirror.commands.findPersistent = function(cm) {clearSearch(cm); doSearch(cm, false, true);}; | |||
CodeMirror.commands.findPersistentNext = function(cm) {doSearch(cm, false, true, true);}; | |||
CodeMirror.commands.findPersistentPrev = function(cm) {doSearch(cm, true, true, true);}; | |||
CodeMirror.commands.findNext = doSearch; | |||
CodeMirror.commands.findPrev = function(cm) {doSearch(cm, true);}; | |||
CodeMirror.commands.clearSearch = clearSearch; | |||
CodeMirror.commands.replace = replace; | |||
CodeMirror.commands.replaceAll = function(cm) {replace(cm, true);}; | |||
}); |
@ -0,0 +1,293 @@ | |||
// 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" | |||
var Pos = CodeMirror.Pos | |||
function regexpFlags(regexp) { | |||
var flags = regexp.flags | |||
return flags != null ? flags : (regexp.ignoreCase ? "i" : "") | |||
+ (regexp.global ? "g" : "") | |||
+ (regexp.multiline ? "m" : "") | |||
} | |||
function ensureFlags(regexp, flags) { | |||
var current = regexpFlags(regexp), target = current | |||
for (var i = 0; i < flags.length; i++) if (target.indexOf(flags.charAt(i)) == -1) | |||
target += flags.charAt(i) | |||
return current == target ? regexp : new RegExp(regexp.source, target) | |||
} | |||
function maybeMultiline(regexp) { | |||
return /\\s|\\n|\n|\\W|\\D|\[\^/.test(regexp.source) | |||
} | |||
function searchRegexpForward(doc, regexp, start) { | |||
regexp = ensureFlags(regexp, "g") | |||
for (var line = start.line, ch = start.ch, last = doc.lastLine(); line <= last; line++, ch = 0) { | |||
regexp.lastIndex = ch | |||
var string = doc.getLine(line), match = regexp.exec(string) | |||
if (match) | |||
return {from: Pos(line, match.index), | |||
to: Pos(line, match.index + match[0].length), | |||
match: match} | |||
} | |||
} | |||
function searchRegexpForwardMultiline(doc, regexp, start) { | |||
if (!maybeMultiline(regexp)) return searchRegexpForward(doc, regexp, start) | |||
regexp = ensureFlags(regexp, "gm") | |||
var string, chunk = 1 | |||
for (var line = start.line, last = doc.lastLine(); line <= last;) { | |||
// This grows the search buffer in exponentially-sized chunks | |||
// between matches, so that nearby matches are fast and don't | |||
// require concatenating the whole document (in case we're | |||
// searching for something that has tons of matches), but at the | |||
// same time, the amount of retries is limited. | |||
for (var i = 0; i < chunk; i++) { | |||
if (line > last) break | |||
var curLine = doc.getLine(line++) | |||
string = string == null ? curLine : string + "\n" + curLine | |||
} | |||
chunk = chunk * 2 | |||
regexp.lastIndex = start.ch | |||
var match = regexp.exec(string) | |||
if (match) { | |||
var before = string.slice(0, match.index).split("\n"), inside = match[0].split("\n") | |||
var startLine = start.line + before.length - 1, startCh = before[before.length - 1].length | |||
return {from: Pos(startLine, startCh), | |||
to: Pos(startLine + inside.length - 1, | |||
inside.length == 1 ? startCh + inside[0].length : inside[inside.length - 1].length), | |||
match: match} | |||
} | |||
} | |||
} | |||
function lastMatchIn(string, regexp) { | |||
var cutOff = 0, match | |||
for (;;) { | |||
regexp.lastIndex = cutOff | |||
var newMatch = regexp.exec(string) | |||
if (!newMatch) return match | |||
match = newMatch | |||
cutOff = match.index + (match[0].length || 1) | |||
if (cutOff == string.length) return match | |||
} | |||
} | |||
function searchRegexpBackward(doc, regexp, start) { | |||
regexp = ensureFlags(regexp, "g") | |||
for (var line = start.line, ch = start.ch, first = doc.firstLine(); line >= first; line--, ch = -1) { | |||
var string = doc.getLine(line) | |||
if (ch > -1) string = string.slice(0, ch) | |||
var match = lastMatchIn(string, regexp) | |||
if (match) | |||
return {from: Pos(line, match.index), | |||
to: Pos(line, match.index + match[0].length), | |||
match: match} | |||
} | |||
} | |||
function searchRegexpBackwardMultiline(doc, regexp, start) { | |||
regexp = ensureFlags(regexp, "gm") | |||
var string, chunk = 1 | |||
for (var line = start.line, first = doc.firstLine(); line >= first;) { | |||
for (var i = 0; i < chunk; i++) { | |||
var curLine = doc.getLine(line--) | |||
string = string == null ? curLine.slice(0, start.ch) : curLine + "\n" + string | |||
} | |||
chunk *= 2 | |||
var match = lastMatchIn(string, regexp) | |||
if (match) { | |||
var before = string.slice(0, match.index).split("\n"), inside = match[0].split("\n") | |||
var startLine = line + before.length, startCh = before[before.length - 1].length | |||
return {from: Pos(startLine, startCh), | |||
to: Pos(startLine + inside.length - 1, | |||
inside.length == 1 ? startCh + inside[0].length : inside[inside.length - 1].length), | |||
match: match} | |||
} | |||
} | |||
} | |||
var doFold, noFold | |||
if (String.prototype.normalize) { | |||
doFold = function(str) { return str.normalize("NFD").toLowerCase() } | |||
noFold = function(str) { return str.normalize("NFD") } | |||
} else { | |||
doFold = function(str) { return str.toLowerCase() } | |||
noFold = function(str) { return str } | |||
} | |||
// Maps a position in a case-folded line back to a position in the original line | |||
// (compensating for codepoints increasing in number during folding) | |||
function adjustPos(orig, folded, pos, foldFunc) { | |||
if (orig.length == folded.length) return pos | |||
for (var min = 0, max = pos + Math.max(0, orig.length - folded.length);;) { | |||
if (min == max) return min | |||
var mid = (min + max) >> 1 | |||
var len = foldFunc(orig.slice(0, mid)).length | |||
if (len == pos) return mid | |||
else if (len > pos) max = mid | |||
else min = mid + 1 | |||
} | |||
} | |||
function searchStringForward(doc, query, start, caseFold) { | |||
// Empty string would match anything and never progress, so we | |||
// define it to match nothing instead. | |||
if (!query.length) return null | |||
var fold = caseFold ? doFold : noFold | |||
var lines = fold(query).split(/\r|\n\r?/) | |||
search: for (var line = start.line, ch = start.ch, last = doc.lastLine() + 1 - lines.length; line <= last; line++, ch = 0) { | |||
var orig = doc.getLine(line).slice(ch), string = fold(orig) | |||
if (lines.length == 1) { | |||
var found = string.indexOf(lines[0]) | |||
if (found == -1) continue search | |||
var start = adjustPos(orig, string, found, fold) + ch | |||
return {from: Pos(line, adjustPos(orig, string, found, fold) + ch), | |||
to: Pos(line, adjustPos(orig, string, found + lines[0].length, fold) + ch)} | |||
} else { | |||
var cutFrom = string.length - lines[0].length | |||
if (string.slice(cutFrom) != lines[0]) continue search | |||
for (var i = 1; i < lines.length - 1; i++) | |||
if (fold(doc.getLine(line + i)) != lines[i]) continue search | |||
var end = doc.getLine(line + lines.length - 1), endString = fold(end), lastLine = lines[lines.length - 1] | |||
if (endString.slice(0, lastLine.length) != lastLine) continue search | |||
return {from: Pos(line, adjustPos(orig, string, cutFrom, fold) + ch), | |||
to: Pos(line + lines.length - 1, adjustPos(end, endString, lastLine.length, fold))} | |||
} | |||
} | |||
} | |||
function searchStringBackward(doc, query, start, caseFold) { | |||
if (!query.length) return null | |||
var fold = caseFold ? doFold : noFold | |||
var lines = fold(query).split(/\r|\n\r?/) | |||
search: for (var line = start.line, ch = start.ch, first = doc.firstLine() - 1 + lines.length; line >= first; line--, ch = -1) { | |||
var orig = doc.getLine(line) | |||
if (ch > -1) orig = orig.slice(0, ch) | |||
var string = fold(orig) | |||
if (lines.length == 1) { | |||
var found = string.lastIndexOf(lines[0]) | |||
if (found == -1) continue search | |||
return {from: Pos(line, adjustPos(orig, string, found, fold)), | |||
to: Pos(line, adjustPos(orig, string, found + lines[0].length, fold))} | |||
} else { | |||
var lastLine = lines[lines.length - 1] | |||
if (string.slice(0, lastLine.length) != lastLine) continue search | |||
for (var i = 1, start = line - lines.length + 1; i < lines.length - 1; i++) | |||
if (fold(doc.getLine(start + i)) != lines[i]) continue search | |||
var top = doc.getLine(line + 1 - lines.length), topString = fold(top) | |||
if (topString.slice(topString.length - lines[0].length) != lines[0]) continue search | |||
return {from: Pos(line + 1 - lines.length, adjustPos(top, topString, top.length - lines[0].length, fold)), | |||
to: Pos(line, adjustPos(orig, string, lastLine.length, fold))} | |||
} | |||
} | |||
} | |||
function SearchCursor(doc, query, pos, options) { | |||
this.atOccurrence = false | |||
this.doc = doc | |||
pos = pos ? doc.clipPos(pos) : Pos(0, 0) | |||
this.pos = {from: pos, to: pos} | |||
var caseFold | |||
if (typeof options == "object") { | |||
caseFold = options.caseFold | |||
} else { // Backwards compat for when caseFold was the 4th argument | |||
caseFold = options | |||
options = null | |||
} | |||
if (typeof query == "string") { | |||
if (caseFold == null) caseFold = false | |||
this.matches = function(reverse, pos) { | |||
return (reverse ? searchStringBackward : searchStringForward)(doc, query, pos, caseFold) | |||
} | |||
} else { | |||
query = ensureFlags(query, "gm") | |||
if (!options || options.multiline !== false) | |||
this.matches = function(reverse, pos) { | |||
return (reverse ? searchRegexpBackwardMultiline : searchRegexpForwardMultiline)(doc, query, pos) | |||
} | |||
else | |||
this.matches = function(reverse, pos) { | |||
return (reverse ? searchRegexpBackward : searchRegexpForward)(doc, query, pos) | |||
} | |||
} | |||
} | |||
SearchCursor.prototype = { | |||
findNext: function() {return this.find(false)}, | |||
findPrevious: function() {return this.find(true)}, | |||
find: function(reverse) { | |||
var result = this.matches(reverse, this.doc.clipPos(reverse ? this.pos.from : this.pos.to)) | |||
// Implements weird auto-growing behavior on null-matches for | |||
// backwards-compatiblity with the vim code (unfortunately) | |||
while (result && CodeMirror.cmpPos(result.from, result.to) == 0) { | |||
if (reverse) { | |||
if (result.from.ch) result.from = Pos(result.from.line, result.from.ch - 1) | |||
else if (result.from.line == this.doc.firstLine()) result = null | |||
else result = this.matches(reverse, this.doc.clipPos(Pos(result.from.line - 1))) | |||
} else { | |||
if (result.to.ch < this.doc.getLine(result.to.line).length) result.to = Pos(result.to.line, result.to.ch + 1) | |||
else if (result.to.line == this.doc.lastLine()) result = null | |||
else result = this.matches(reverse, Pos(result.to.line + 1, 0)) | |||
} | |||
} | |||
if (result) { | |||
this.pos = result | |||
this.atOccurrence = true | |||
return this.pos.match || true | |||
} else { | |||
var end = Pos(reverse ? this.doc.firstLine() : this.doc.lastLine() + 1, 0) | |||
this.pos = {from: end, to: end} | |||
return this.atOccurrence = false | |||
} | |||
}, | |||
from: function() {if (this.atOccurrence) return this.pos.from}, | |||
to: function() {if (this.atOccurrence) return this.pos.to}, | |||
replace: function(newText, origin) { | |||
if (!this.atOccurrence) return | |||
var lines = CodeMirror.splitLines(newText) | |||
this.doc.replaceRange(lines, this.pos.from, this.pos.to, origin) | |||
this.pos.to = Pos(this.pos.from.line + lines.length - 1, | |||
lines[lines.length - 1].length + (lines.length == 1 ? this.pos.from.ch : 0)) | |||
} | |||
} | |||
CodeMirror.defineExtension("getSearchCursor", function(query, pos, caseFold) { | |||
return new SearchCursor(this.doc, query, pos, caseFold) | |||
}) | |||
CodeMirror.defineDocExtension("getSearchCursor", function(query, pos, caseFold) { | |||
return new SearchCursor(this, query, pos, caseFold) | |||
}) | |||
CodeMirror.defineExtension("selectMatches", function(query, caseFold) { | |||
var ranges = [] | |||
var cur = this.getSearchCursor(query, this.getCursor("from"), caseFold) | |||
while (cur.findNext()) { | |||
if (CodeMirror.cmpPos(cur.to(), this.getCursor("to")) > 0) break | |||
ranges.push({anchor: cur.from(), head: cur.to()}) | |||
} | |||
if (ranges.length) | |||
this.setSelections(ranges, 0) | |||
}) | |||
}); |
@ -0,0 +1,72 @@ | |||
// 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"; | |||
var WRAP_CLASS = "CodeMirror-activeline"; | |||
var BACK_CLASS = "CodeMirror-activeline-background"; | |||
var GUTT_CLASS = "CodeMirror-activeline-gutter"; | |||
CodeMirror.defineOption("styleActiveLine", false, function(cm, val, old) { | |||
var prev = old == CodeMirror.Init ? false : old; | |||
if (val == prev) return | |||
if (prev) { | |||
cm.off("beforeSelectionChange", selectionChange); | |||
clearActiveLines(cm); | |||
delete cm.state.activeLines; | |||
} | |||
if (val) { | |||
cm.state.activeLines = []; | |||
updateActiveLines(cm, cm.listSelections()); | |||
cm.on("beforeSelectionChange", selectionChange); | |||
} | |||
}); | |||
function clearActiveLines(cm) { | |||
for (var i = 0; i < cm.state.activeLines.length; i++) { | |||
cm.removeLineClass(cm.state.activeLines[i], "wrap", WRAP_CLASS); | |||
cm.removeLineClass(cm.state.activeLines[i], "background", BACK_CLASS); | |||
cm.removeLineClass(cm.state.activeLines[i], "gutter", GUTT_CLASS); | |||
} | |||
} | |||
function sameArray(a, b) { | |||
if (a.length != b.length) return false; | |||
for (var i = 0; i < a.length; i++) | |||
if (a[i] != b[i]) return false; | |||
return true; | |||
} | |||
function updateActiveLines(cm, ranges) { | |||
var active = []; | |||
for (var i = 0; i < ranges.length; i++) { | |||
var range = ranges[i]; | |||
var option = cm.getOption("styleActiveLine"); | |||
if (typeof option == "object" && option.nonEmpty ? range.anchor.line != range.head.line : !range.empty()) | |||
continue | |||
var line = cm.getLineHandleVisualStart(range.head.line); | |||
if (active[active.length - 1] != line) active.push(line); | |||
} | |||
if (sameArray(cm.state.activeLines, active)) return; | |||
cm.operation(function() { | |||
clearActiveLines(cm); | |||
for (var i = 0; i < active.length; i++) { | |||
cm.addLineClass(active[i], "wrap", WRAP_CLASS); | |||
cm.addLineClass(active[i], "background", BACK_CLASS); | |||
cm.addLineClass(active[i], "gutter", GUTT_CLASS); | |||
} | |||
cm.state.activeLines = active; | |||
}); | |||
} | |||
function selectionChange(cm, sel) { | |||
updateActiveLines(cm, sel.ranges); | |||
} | |||
}); |
@ -0,0 +1,119 @@ | |||
// CodeMirror, copyright (c) by Marijn Haverbeke and others | |||
// Distributed under an MIT license: https://codemirror.net/LICENSE | |||
// Because sometimes you need to mark the selected *text*. | |||
// | |||
// Adds an option 'styleSelectedText' which, when enabled, gives | |||
// selected text the CSS class given as option value, or | |||
// "CodeMirror-selectedtext" when the value is not a string. | |||
(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.defineOption("styleSelectedText", false, function(cm, val, old) { | |||
var prev = old && old != CodeMirror.Init; | |||
if (val && !prev) { | |||
cm.state.markedSelection = []; | |||
cm.state.markedSelectionStyle = typeof val == "string" ? val : "CodeMirror-selectedtext"; | |||
reset(cm); | |||
cm.on("cursorActivity", onCursorActivity); | |||
cm.on("change", onChange); | |||
} else if (!val && prev) { | |||
cm.off("cursorActivity", onCursorActivity); | |||
cm.off("change", onChange); | |||
clear(cm); | |||
cm.state.markedSelection = cm.state.markedSelectionStyle = null; | |||
} | |||
}); | |||
function onCursorActivity(cm) { | |||
if (cm.state.markedSelection) | |||
cm.operation(function() { update(cm); }); | |||
} | |||
function onChange(cm) { | |||
if (cm.state.markedSelection && cm.state.markedSelection.length) | |||
cm.operation(function() { clear(cm); }); | |||
} | |||
var CHUNK_SIZE = 8; | |||
var Pos = CodeMirror.Pos; | |||
var cmp = CodeMirror.cmpPos; | |||
function coverRange(cm, from, to, addAt) { | |||
if (cmp(from, to) == 0) return; | |||
var array = cm.state.markedSelection; | |||
var cls = cm.state.markedSelectionStyle; | |||
for (var line = from.line;;) { | |||
var start = line == from.line ? from : Pos(line, 0); | |||
var endLine = line + CHUNK_SIZE, atEnd = endLine >= to.line; | |||
var end = atEnd ? to : Pos(endLine, 0); | |||
var mark = cm.markText(start, end, {className: cls}); | |||
if (addAt == null) array.push(mark); | |||
else array.splice(addAt++, 0, mark); | |||
if (atEnd) break; | |||
line = endLine; | |||
} | |||
} | |||
function clear(cm) { | |||
var array = cm.state.markedSelection; | |||
for (var i = 0; i < array.length; ++i) array[i].clear(); | |||
array.length = 0; | |||
} | |||
function reset(cm) { | |||
clear(cm); | |||
var ranges = cm.listSelections(); | |||
for (var i = 0; i < ranges.length; i++) | |||
coverRange(cm, ranges[i].from(), ranges[i].to()); | |||
} | |||
function update(cm) { | |||
if (!cm.somethingSelected()) return clear(cm); | |||
if (cm.listSelections().length > 1) return reset(cm); | |||
var from = cm.getCursor("start"), to = cm.getCursor("end"); | |||
var array = cm.state.markedSelection; | |||
if (!array.length) return coverRange(cm, from, to); | |||
var coverStart = array[0].find(), coverEnd = array[array.length - 1].find(); | |||
if (!coverStart || !coverEnd || to.line - from.line <= CHUNK_SIZE || | |||
cmp(from, coverEnd.to) >= 0 || cmp(to, coverStart.from) <= 0) | |||
return reset(cm); | |||
while (cmp(from, coverStart.from) > 0) { | |||
array.shift().clear(); | |||
coverStart = array[0].find(); | |||
} | |||
if (cmp(from, coverStart.from) < 0) { | |||
if (coverStart.to.line - from.line < CHUNK_SIZE) { | |||
array.shift().clear(); | |||
coverRange(cm, from, coverStart.to, 0); | |||
} else { | |||
coverRange(cm, from, coverStart.from, 0); | |||
} | |||
} | |||
while (cmp(to, coverEnd.to) < 0) { | |||
array.pop().clear(); | |||
coverEnd = array[array.length - 1].find(); | |||
} | |||
if (cmp(to, coverEnd.to) > 0) { | |||
if (to.line - coverEnd.from.line < CHUNK_SIZE) { | |||
array.pop().clear(); | |||
coverRange(cm, coverEnd.from, to); | |||
} else { | |||
coverRange(cm, coverEnd.to, to); | |||
} | |||
} | |||
} | |||
}); |
@ -0,0 +1,98 @@ | |||
// 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.defineOption("selectionPointer", false, function(cm, val) { | |||
var data = cm.state.selectionPointer; | |||
if (data) { | |||
CodeMirror.off(cm.getWrapperElement(), "mousemove", data.mousemove); | |||
CodeMirror.off(cm.getWrapperElement(), "mouseout", data.mouseout); | |||
CodeMirror.off(window, "scroll", data.windowScroll); | |||
cm.off("cursorActivity", reset); | |||
cm.off("scroll", reset); | |||
cm.state.selectionPointer = null; | |||
cm.display.lineDiv.style.cursor = ""; | |||
} | |||
if (val) { | |||
data = cm.state.selectionPointer = { | |||
value: typeof val == "string" ? val : "default", | |||
mousemove: function(event) { mousemove(cm, event); }, | |||
mouseout: function(event) { mouseout(cm, event); }, | |||
windowScroll: function() { reset(cm); }, | |||
rects: null, | |||
mouseX: null, mouseY: null, | |||
willUpdate: false | |||
}; | |||
CodeMirror.on(cm.getWrapperElement(), "mousemove", data.mousemove); | |||
CodeMirror.on(cm.getWrapperElement(), "mouseout", data.mouseout); | |||
CodeMirror.on(window, "scroll", data.windowScroll); | |||
cm.on("cursorActivity", reset); | |||
cm.on("scroll", reset); | |||
} | |||
}); | |||
function mousemove(cm, event) { | |||
var data = cm.state.selectionPointer; | |||
if (event.buttons == null ? event.which : event.buttons) { | |||
data.mouseX = data.mouseY = null; | |||
} else { | |||
data.mouseX = event.clientX; | |||
data.mouseY = event.clientY; | |||
} | |||
scheduleUpdate(cm); | |||
} | |||
function mouseout(cm, event) { | |||
if (!cm.getWrapperElement().contains(event.relatedTarget)) { | |||
var data = cm.state.selectionPointer; | |||
data.mouseX = data.mouseY = null; | |||
scheduleUpdate(cm); | |||
} | |||
} | |||
function reset(cm) { | |||
cm.state.selectionPointer.rects = null; | |||
scheduleUpdate(cm); | |||
} | |||
function scheduleUpdate(cm) { | |||
if (!cm.state.selectionPointer.willUpdate) { | |||
cm.state.selectionPointer.willUpdate = true; | |||
setTimeout(function() { | |||
update(cm); | |||
cm.state.selectionPointer.willUpdate = false; | |||
}, 50); | |||
} | |||
} | |||
function update(cm) { | |||
var data = cm.state.selectionPointer; | |||
if (!data) return; | |||
if (data.rects == null && data.mouseX != null) { | |||
data.rects = []; | |||
if (cm.somethingSelected()) { | |||
for (var sel = cm.display.selectionDiv.firstChild; sel; sel = sel.nextSibling) | |||
data.rects.push(sel.getBoundingClientRect()); | |||
} | |||
} | |||
var inside = false; | |||
if (data.mouseX != null) for (var i = 0; i < data.rects.length; i++) { | |||
var rect = data.rects[i]; | |||
if (rect.left <= data.mouseX && rect.right >= data.mouseX && | |||
rect.top <= data.mouseY && rect.bottom >= data.mouseY) | |||
inside = true; | |||
} | |||
var cursor = inside ? data.value : ""; | |||
if (cm.display.lineDiv.style.cursor != cursor) | |||
cm.display.lineDiv.style.cursor = cursor; | |||
} | |||
}); |
@ -0,0 +1,87 @@ | |||
.CodeMirror-Tern-completion { | |||
padding-left: 22px; | |||
position: relative; | |||
line-height: 1.5; | |||
} | |||
.CodeMirror-Tern-completion:before { | |||
position: absolute; | |||
left: 2px; | |||
bottom: 2px; | |||
border-radius: 50%; | |||
font-size: 12px; | |||
font-weight: bold; | |||
height: 15px; | |||
width: 15px; | |||
line-height: 16px; | |||
text-align: center; | |||
color: white; | |||
-moz-box-sizing: border-box; | |||
box-sizing: border-box; | |||
} | |||
.CodeMirror-Tern-completion-unknown:before { | |||
content: "?"; | |||
background: #4bb; | |||
} | |||
.CodeMirror-Tern-completion-object:before { | |||
content: "O"; | |||
background: #77c; | |||
} | |||
.CodeMirror-Tern-completion-fn:before { | |||
content: "F"; | |||
background: #7c7; | |||
} | |||
.CodeMirror-Tern-completion-array:before { | |||
content: "A"; | |||
background: #c66; | |||
} | |||
.CodeMirror-Tern-completion-number:before { | |||
content: "1"; | |||
background: #999; | |||
} | |||
.CodeMirror-Tern-completion-string:before { | |||
content: "S"; | |||
background: #999; | |||
} | |||
.CodeMirror-Tern-completion-bool:before { | |||
content: "B"; | |||
background: #999; | |||
} | |||
.CodeMirror-Tern-completion-guess { | |||
color: #999; | |||
} | |||
.CodeMirror-Tern-tooltip { | |||
border: 1px solid silver; | |||
border-radius: 3px; | |||
color: #444; | |||
padding: 2px 5px; | |||
font-size: 90%; | |||
font-family: monospace; | |||
background-color: white; | |||
white-space: pre-wrap; | |||
max-width: 40em; | |||
position: absolute; | |||
z-index: 10; | |||
-webkit-box-shadow: 2px 3px 5px rgba(0,0,0,.2); | |||
-moz-box-shadow: 2px 3px 5px rgba(0,0,0,.2); | |||
box-shadow: 2px 3px 5px rgba(0,0,0,.2); | |||
transition: opacity 1s; | |||
-moz-transition: opacity 1s; | |||
-webkit-transition: opacity 1s; | |||
-o-transition: opacity 1s; | |||
-ms-transition: opacity 1s; | |||
} | |||
.CodeMirror-Tern-hint-doc { | |||
max-width: 25em; | |||
margin-top: -3px; | |||
} | |||
.CodeMirror-Tern-fname { color: black; } | |||
.CodeMirror-Tern-farg { color: #70a; } | |||
.CodeMirror-Tern-farg-current { text-decoration: underline; } | |||
.CodeMirror-Tern-type { color: #07c; } | |||
.CodeMirror-Tern-fhint-guess { opacity: .7; } |
@ -0,0 +1,718 @@ | |||
// CodeMirror, copyright (c) by Marijn Haverbeke and others | |||
// Distributed under an MIT license: https://codemirror.net/LICENSE | |||
// Glue code between CodeMirror and Tern. | |||
// | |||
// Create a CodeMirror.TernServer to wrap an actual Tern server, | |||
// register open documents (CodeMirror.Doc instances) with it, and | |||
// call its methods to activate the assisting functions that Tern | |||
// provides. | |||
// | |||
// Options supported (all optional): | |||
// * defs: An array of JSON definition data structures. | |||
// * plugins: An object mapping plugin names to configuration | |||
// options. | |||
// * getFile: A function(name, c) that can be used to access files in | |||
// the project that haven't been loaded yet. Simply do c(null) to | |||
// indicate that a file is not available. | |||
// * fileFilter: A function(value, docName, doc) that will be applied | |||
// to documents before passing them on to Tern. | |||
// * switchToDoc: A function(name, doc) that should, when providing a | |||
// multi-file view, switch the view or focus to the named file. | |||
// * showError: A function(editor, message) that can be used to | |||
// override the way errors are displayed. | |||
// * completionTip: Customize the content in tooltips for completions. | |||
// Is passed a single argument—the completion's data as returned by | |||
// Tern—and may return a string, DOM node, or null to indicate that | |||
// no tip should be shown. By default the docstring is shown. | |||
// * typeTip: Like completionTip, but for the tooltips shown for type | |||
// queries. | |||
// * responseFilter: A function(doc, query, request, error, data) that | |||
// will be applied to the Tern responses before treating them | |||
// | |||
// | |||
// It is possible to run the Tern server in a web worker by specifying | |||
// these additional options: | |||
// * useWorker: Set to true to enable web worker mode. You'll probably | |||
// want to feature detect the actual value you use here, for example | |||
// !!window.Worker. | |||
// * workerScript: The main script of the worker. Point this to | |||
// wherever you are hosting worker.js from this directory. | |||
// * workerDeps: An array of paths pointing (relative to workerScript) | |||
// to the Acorn and Tern libraries and any Tern plugins you want to | |||
// load. Or, if you minified those into a single script and included | |||
// them in the workerScript, simply leave this undefined. | |||
(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"; | |||
// declare global: tern | |||
CodeMirror.TernServer = function(options) { | |||
var self = this; | |||
this.options = options || {}; | |||
var plugins = this.options.plugins || (this.options.plugins = {}); | |||
if (!plugins.doc_comment) plugins.doc_comment = true; | |||
this.docs = Object.create(null); | |||
if (this.options.useWorker) { | |||
this.server = new WorkerServer(this); | |||
} else { | |||
this.server = new tern.Server({ | |||
getFile: function(name, c) { return getFile(self, name, c); }, | |||
async: true, | |||
defs: this.options.defs || [], | |||
plugins: plugins | |||
}); | |||
} | |||
this.trackChange = function(doc, change) { trackChange(self, doc, change); }; | |||
this.cachedArgHints = null; | |||
this.activeArgHints = null; | |||
this.jumpStack = []; | |||
this.getHint = function(cm, c) { return hint(self, cm, c); }; | |||
this.getHint.async = true; | |||
}; | |||
CodeMirror.TernServer.prototype = { | |||
addDoc: function(name, doc) { | |||
var data = {doc: doc, name: name, changed: null}; | |||
this.server.addFile(name, docValue(this, data)); | |||
CodeMirror.on(doc, "change", this.trackChange); | |||
return this.docs[name] = data; | |||
}, | |||
delDoc: function(id) { | |||
var found = resolveDoc(this, id); | |||
if (!found) return; | |||
CodeMirror.off(found.doc, "change", this.trackChange); | |||
delete this.docs[found.name]; | |||
this.server.delFile(found.name); | |||
}, | |||
hideDoc: function(id) { | |||
closeArgHints(this); | |||
var found = resolveDoc(this, id); | |||
if (found && found.changed) sendDoc(this, found); | |||
}, | |||
complete: function(cm) { | |||
cm.showHint({hint: this.getHint}); | |||
}, | |||
showType: function(cm, pos, c) { showContextInfo(this, cm, pos, "type", c); }, | |||
showDocs: function(cm, pos, c) { showContextInfo(this, cm, pos, "documentation", c); }, | |||
updateArgHints: function(cm) { updateArgHints(this, cm); }, | |||
jumpToDef: function(cm) { jumpToDef(this, cm); }, | |||
jumpBack: function(cm) { jumpBack(this, cm); }, | |||
rename: function(cm) { rename(this, cm); }, | |||
selectName: function(cm) { selectName(this, cm); }, | |||
request: function (cm, query, c, pos) { | |||
var self = this; | |||
var doc = findDoc(this, cm.getDoc()); | |||
var request = buildRequest(this, doc, query, pos); | |||
var extraOptions = request.query && this.options.queryOptions && this.options.queryOptions[request.query.type] | |||
if (extraOptions) for (var prop in extraOptions) request.query[prop] = extraOptions[prop]; | |||
this.server.request(request, function (error, data) { | |||
if (!error && self.options.responseFilter) | |||
data = self.options.responseFilter(doc, query, request, error, data); | |||
c(error, data); | |||
}); | |||
}, | |||
destroy: function () { | |||
closeArgHints(this) | |||
if (this.worker) { | |||
this.worker.terminate(); | |||
this.worker = null; | |||
} | |||
} | |||
}; | |||
var Pos = CodeMirror.Pos; | |||
var cls = "CodeMirror-Tern-"; | |||
var bigDoc = 250; | |||
function getFile(ts, name, c) { | |||
var buf = ts.docs[name]; | |||
if (buf) | |||
c(docValue(ts, buf)); | |||
else if (ts.options.getFile) | |||
ts.options.getFile(name, c); | |||
else | |||
c(null); | |||
} | |||
function findDoc(ts, doc, name) { | |||
for (var n in ts.docs) { | |||
var cur = ts.docs[n]; | |||
if (cur.doc == doc) return cur; | |||
} | |||
if (!name) for (var i = 0;; ++i) { | |||
n = "[doc" + (i || "") + "]"; | |||
if (!ts.docs[n]) { name = n; break; } | |||
} | |||
return ts.addDoc(name, doc); | |||
} | |||
function resolveDoc(ts, id) { | |||
if (typeof id == "string") return ts.docs[id]; | |||
if (id instanceof CodeMirror) id = id.getDoc(); | |||
if (id instanceof CodeMirror.Doc) return findDoc(ts, id); | |||
} | |||
function trackChange(ts, doc, change) { | |||
var data = findDoc(ts, doc); | |||
var argHints = ts.cachedArgHints; | |||
if (argHints && argHints.doc == doc && cmpPos(argHints.start, change.to) >= 0) | |||
ts.cachedArgHints = null; | |||
var changed = data.changed; | |||
if (changed == null) | |||
data.changed = changed = {from: change.from.line, to: change.from.line}; | |||
var end = change.from.line + (change.text.length - 1); | |||
if (change.from.line < changed.to) changed.to = changed.to - (change.to.line - end); | |||
if (end >= changed.to) changed.to = end + 1; | |||
if (changed.from > change.from.line) changed.from = change.from.line; | |||
if (doc.lineCount() > bigDoc && change.to - changed.from > 100) setTimeout(function() { | |||
if (data.changed && data.changed.to - data.changed.from > 100) sendDoc(ts, data); | |||
}, 200); | |||
} | |||
function sendDoc(ts, doc) { | |||
ts.server.request({files: [{type: "full", name: doc.name, text: docValue(ts, doc)}]}, function(error) { | |||
if (error) window.console.error(error); | |||
else doc.changed = null; | |||
}); | |||
} | |||
// Completion | |||
function hint(ts, cm, c) { | |||
ts.request(cm, {type: "completions", types: true, docs: true, urls: true}, function(error, data) { | |||
if (error) return showError(ts, cm, error); | |||
var completions = [], after = ""; | |||
var from = data.start, to = data.end; | |||
if (cm.getRange(Pos(from.line, from.ch - 2), from) == "[\"" && | |||
cm.getRange(to, Pos(to.line, to.ch + 2)) != "\"]") | |||
after = "\"]"; | |||
for (var i = 0; i < data.completions.length; ++i) { | |||
var completion = data.completions[i], className = typeToIcon(completion.type); | |||
if (data.guess) className += " " + cls + "guess"; | |||
completions.push({text: completion.name + after, | |||
displayText: completion.displayName || completion.name, | |||
className: className, | |||
data: completion}); | |||
} | |||
var obj = {from: from, to: to, list: completions}; | |||
var tooltip = null; | |||
CodeMirror.on(obj, "close", function() { remove(tooltip); }); | |||
CodeMirror.on(obj, "update", function() { remove(tooltip); }); | |||
CodeMirror.on(obj, "select", function(cur, node) { | |||
remove(tooltip); | |||
var content = ts.options.completionTip ? ts.options.completionTip(cur.data) : cur.data.doc; | |||
if (content) { | |||
tooltip = makeTooltip(node.parentNode.getBoundingClientRect().right + window.pageXOffset, | |||
node.getBoundingClientRect().top + window.pageYOffset, content); | |||
tooltip.className += " " + cls + "hint-doc"; | |||
} | |||
}); | |||
c(obj); | |||
}); | |||
} | |||
function typeToIcon(type) { | |||
var suffix; | |||
if (type == "?") suffix = "unknown"; | |||
else if (type == "number" || type == "string" || type == "bool") suffix = type; | |||
else if (/^fn\(/.test(type)) suffix = "fn"; | |||
else if (/^\[/.test(type)) suffix = "array"; | |||
else suffix = "object"; | |||
return cls + "completion " + cls + "completion-" + suffix; | |||
} | |||
// Type queries | |||
function showContextInfo(ts, cm, pos, queryName, c) { | |||
ts.request(cm, queryName, function(error, data) { | |||
if (error) return showError(ts, cm, error); | |||
if (ts.options.typeTip) { | |||
var tip = ts.options.typeTip(data); | |||
} else { | |||
var tip = elt("span", null, elt("strong", null, data.type || "not found")); | |||
if (data.doc) | |||
tip.appendChild(document.createTextNode(" — " + data.doc)); | |||
if (data.url) { | |||
tip.appendChild(document.createTextNode(" ")); | |||
var child = tip.appendChild(elt("a", null, "[docs]")); | |||
child.href = data.url; | |||
child.target = "_blank"; | |||
} | |||
} | |||
tempTooltip(cm, tip, ts); | |||
if (c) c(); | |||
}, pos); | |||
} | |||
// Maintaining argument hints | |||
function updateArgHints(ts, cm) { | |||
closeArgHints(ts); | |||
if (cm.somethingSelected()) return; | |||
var state = cm.getTokenAt(cm.getCursor()).state; | |||
var inner = CodeMirror.innerMode(cm.getMode(), state); | |||
if (inner.mode.name != "javascript") return; | |||
var lex = inner.state.lexical; | |||
if (lex.info != "call") return; | |||
var ch, argPos = lex.pos || 0, tabSize = cm.getOption("tabSize"); | |||
for (var line = cm.getCursor().line, e = Math.max(0, line - 9), found = false; line >= e; --line) { | |||
var str = cm.getLine(line), extra = 0; | |||
for (var pos = 0;;) { | |||
var tab = str.indexOf("\t", pos); | |||
if (tab == -1) break; | |||
extra += tabSize - (tab + extra) % tabSize - 1; | |||
pos = tab + 1; | |||
} | |||
ch = lex.column - extra; | |||
if (str.charAt(ch) == "(") {found = true; break;} | |||
} | |||
if (!found) return; | |||
var start = Pos(line, ch); | |||
var cache = ts.cachedArgHints; | |||
if (cache && cache.doc == cm.getDoc() && cmpPos(start, cache.start) == 0) | |||
return showArgHints(ts, cm, argPos); | |||
ts.request(cm, {type: "type", preferFunction: true, end: start}, function(error, data) { | |||
if (error || !data.type || !(/^fn\(/).test(data.type)) return; | |||
ts.cachedArgHints = { | |||
start: start, | |||
type: parseFnType(data.type), | |||
name: data.exprName || data.name || "fn", | |||
guess: data.guess, | |||
doc: cm.getDoc() | |||
}; | |||
showArgHints(ts, cm, argPos); | |||
}); | |||
} | |||
function showArgHints(ts, cm, pos) { | |||
closeArgHints(ts); | |||
var cache = ts.cachedArgHints, tp = cache.type; | |||
var tip = elt("span", cache.guess ? cls + "fhint-guess" : null, | |||
elt("span", cls + "fname", cache.name), "("); | |||
for (var i = 0; i < tp.args.length; ++i) { | |||
if (i) tip.appendChild(document.createTextNode(", ")); | |||
var arg = tp.args[i]; | |||
tip.appendChild(elt("span", cls + "farg" + (i == pos ? " " + cls + "farg-current" : ""), arg.name || "?")); | |||
if (arg.type != "?") { | |||
tip.appendChild(document.createTextNode(":\u00a0")); | |||
tip.appendChild(elt("span", cls + "type", arg.type)); | |||
} | |||
} | |||
tip.appendChild(document.createTextNode(tp.rettype ? ") ->\u00a0" : ")")); | |||
if (tp.rettype) tip.appendChild(elt("span", cls + "type", tp.rettype)); | |||
var place = cm.cursorCoords(null, "page"); | |||
var tooltip = ts.activeArgHints = makeTooltip(place.right + 1, place.bottom, tip) | |||
setTimeout(function() { | |||
tooltip.clear = onEditorActivity(cm, function() { | |||
if (ts.activeArgHints == tooltip) closeArgHints(ts) }) | |||
}, 20) | |||
} | |||
function parseFnType(text) { | |||
var args = [], pos = 3; | |||
function skipMatching(upto) { | |||
var depth = 0, start = pos; | |||
for (;;) { | |||
var next = text.charAt(pos); | |||
if (upto.test(next) && !depth) return text.slice(start, pos); | |||
if (/[{\[\(]/.test(next)) ++depth; | |||
else if (/[}\]\)]/.test(next)) --depth; | |||
++pos; | |||
} | |||
} | |||
// Parse arguments | |||
if (text.charAt(pos) != ")") for (;;) { | |||
var name = text.slice(pos).match(/^([^, \(\[\{]+): /); | |||
if (name) { | |||
pos += name[0].length; | |||
name = name[1]; | |||
} | |||
args.push({name: name, type: skipMatching(/[\),]/)}); | |||
if (text.charAt(pos) == ")") break; | |||
pos += 2; | |||
} | |||
var rettype = text.slice(pos).match(/^\) -> (.*)$/); | |||
return {args: args, rettype: rettype && rettype[1]}; | |||
} | |||
// Moving to the definition of something | |||
function jumpToDef(ts, cm) { | |||
function inner(varName) { | |||
var req = {type: "definition", variable: varName || null}; | |||
var doc = findDoc(ts, cm.getDoc()); | |||
ts.server.request(buildRequest(ts, doc, req), function(error, data) { | |||
if (error) return showError(ts, cm, error); | |||
if (!data.file && data.url) { window.open(data.url); return; } | |||
if (data.file) { | |||
var localDoc = ts.docs[data.file], found; | |||
if (localDoc && (found = findContext(localDoc.doc, data))) { | |||
ts.jumpStack.push({file: doc.name, | |||
start: cm.getCursor("from"), | |||
end: cm.getCursor("to")}); | |||
moveTo(ts, doc, localDoc, found.start, found.end); | |||
return; | |||
} | |||
} | |||
showError(ts, cm, "Could not find a definition."); | |||
}); | |||
} | |||
if (!atInterestingExpression(cm)) | |||
dialog(cm, "Jump to variable", function(name) { if (name) inner(name); }); | |||
else | |||
inner(); | |||
} | |||
function jumpBack(ts, cm) { | |||
var pos = ts.jumpStack.pop(), doc = pos && ts.docs[pos.file]; | |||
if (!doc) return; | |||
moveTo(ts, findDoc(ts, cm.getDoc()), doc, pos.start, pos.end); | |||
} | |||
function moveTo(ts, curDoc, doc, start, end) { | |||
doc.doc.setSelection(start, end); | |||
if (curDoc != doc && ts.options.switchToDoc) { | |||
closeArgHints(ts); | |||
ts.options.switchToDoc(doc.name, doc.doc); | |||
} | |||
} | |||
// The {line,ch} representation of positions makes this rather awkward. | |||
function findContext(doc, data) { | |||
var before = data.context.slice(0, data.contextOffset).split("\n"); | |||
var startLine = data.start.line - (before.length - 1); | |||
var start = Pos(startLine, (before.length == 1 ? data.start.ch : doc.getLine(startLine).length) - before[0].length); | |||
var text = doc.getLine(startLine).slice(start.ch); | |||
for (var cur = startLine + 1; cur < doc.lineCount() && text.length < data.context.length; ++cur) | |||
text += "\n" + doc.getLine(cur); | |||
if (text.slice(0, data.context.length) == data.context) return data; | |||
var cursor = doc.getSearchCursor(data.context, 0, false); | |||
var nearest, nearestDist = Infinity; | |||
while (cursor.findNext()) { | |||
var from = cursor.from(), dist = Math.abs(from.line - start.line) * 10000; | |||
if (!dist) dist = Math.abs(from.ch - start.ch); | |||
if (dist < nearestDist) { nearest = from; nearestDist = dist; } | |||
} | |||
if (!nearest) return null; | |||
if (before.length == 1) | |||
nearest.ch += before[0].length; | |||
else | |||
nearest = Pos(nearest.line + (before.length - 1), before[before.length - 1].length); | |||
if (data.start.line == data.end.line) | |||
var end = Pos(nearest.line, nearest.ch + (data.end.ch - data.start.ch)); | |||
else | |||
var end = Pos(nearest.line + (data.end.line - data.start.line), data.end.ch); | |||
return {start: nearest, end: end}; | |||
} | |||
function atInterestingExpression(cm) { | |||
var pos = cm.getCursor("end"), tok = cm.getTokenAt(pos); | |||
if (tok.start < pos.ch && tok.type == "comment") return false; | |||
return /[\w)\]]/.test(cm.getLine(pos.line).slice(Math.max(pos.ch - 1, 0), pos.ch + 1)); | |||
} | |||
// Variable renaming | |||
function rename(ts, cm) { | |||
var token = cm.getTokenAt(cm.getCursor()); | |||
if (!/\w/.test(token.string)) return showError(ts, cm, "Not at a variable"); | |||
dialog(cm, "New name for " + token.string, function(newName) { | |||
ts.request(cm, {type: "rename", newName: newName, fullDocs: true}, function(error, data) { | |||
if (error) return showError(ts, cm, error); | |||
applyChanges(ts, data.changes); | |||
}); | |||
}); | |||
} | |||
function selectName(ts, cm) { | |||
var name = findDoc(ts, cm.doc).name; | |||
ts.request(cm, {type: "refs"}, function(error, data) { | |||
if (error) return showError(ts, cm, error); | |||
var ranges = [], cur = 0; | |||
var curPos = cm.getCursor(); | |||
for (var i = 0; i < data.refs.length; i++) { | |||
var ref = data.refs[i]; | |||
if (ref.file == name) { | |||
ranges.push({anchor: ref.start, head: ref.end}); | |||
if (cmpPos(curPos, ref.start) >= 0 && cmpPos(curPos, ref.end) <= 0) | |||
cur = ranges.length - 1; | |||
} | |||
} | |||
cm.setSelections(ranges, cur); | |||
}); | |||
} | |||
var nextChangeOrig = 0; | |||
function applyChanges(ts, changes) { | |||
var perFile = Object.create(null); | |||
for (var i = 0; i < changes.length; ++i) { | |||
var ch = changes[i]; | |||
(perFile[ch.file] || (perFile[ch.file] = [])).push(ch); | |||
} | |||
for (var file in perFile) { | |||
var known = ts.docs[file], chs = perFile[file];; | |||
if (!known) continue; | |||
chs.sort(function(a, b) { return cmpPos(b.start, a.start); }); | |||
var origin = "*rename" + (++nextChangeOrig); | |||
for (var i = 0; i < chs.length; ++i) { | |||
var ch = chs[i]; | |||
known.doc.replaceRange(ch.text, ch.start, ch.end, origin); | |||
} | |||
} | |||
} | |||
// Generic request-building helper | |||
function buildRequest(ts, doc, query, pos) { | |||
var files = [], offsetLines = 0, allowFragments = !query.fullDocs; | |||
if (!allowFragments) delete query.fullDocs; | |||
if (typeof query == "string") query = {type: query}; | |||
query.lineCharPositions = true; | |||
if (query.end == null) { | |||
query.end = pos || doc.doc.getCursor("end"); | |||
if (doc.doc.somethingSelected()) | |||
query.start = doc.doc.getCursor("start"); | |||
} | |||
var startPos = query.start || query.end; | |||
if (doc.changed) { | |||
if (doc.doc.lineCount() > bigDoc && allowFragments !== false && | |||
doc.changed.to - doc.changed.from < 100 && | |||
doc.changed.from <= startPos.line && doc.changed.to > query.end.line) { | |||
files.push(getFragmentAround(doc, startPos, query.end)); | |||
query.file = "#0"; | |||
var offsetLines = files[0].offsetLines; | |||
if (query.start != null) query.start = Pos(query.start.line - -offsetLines, query.start.ch); | |||
query.end = Pos(query.end.line - offsetLines, query.end.ch); | |||
} else { | |||
files.push({type: "full", | |||
name: doc.name, | |||
text: docValue(ts, doc)}); | |||
query.file = doc.name; | |||
doc.changed = null; | |||
} | |||
} else { | |||
query.file = doc.name; | |||
} | |||
for (var name in ts.docs) { | |||
var cur = ts.docs[name]; | |||
if (cur.changed && cur != doc) { | |||
files.push({type: "full", name: cur.name, text: docValue(ts, cur)}); | |||
cur.changed = null; | |||
} | |||
} | |||
return {query: query, files: files}; | |||
} | |||
function getFragmentAround(data, start, end) { | |||
var doc = data.doc; | |||
var minIndent = null, minLine = null, endLine, tabSize = 4; | |||
for (var p = start.line - 1, min = Math.max(0, p - 50); p >= min; --p) { | |||
var line = doc.getLine(p), fn = line.search(/\bfunction\b/); | |||
if (fn < 0) continue; | |||
var indent = CodeMirror.countColumn(line, null, tabSize); | |||
if (minIndent != null && minIndent <= indent) continue; | |||
minIndent = indent; | |||
minLine = p; | |||
} | |||
if (minLine == null) minLine = min; | |||
var max = Math.min(doc.lastLine(), end.line + 20); | |||
if (minIndent == null || minIndent == CodeMirror.countColumn(doc.getLine(start.line), null, tabSize)) | |||
endLine = max; | |||
else for (endLine = end.line + 1; endLine < max; ++endLine) { | |||
var indent = CodeMirror.countColumn(doc.getLine(endLine), null, tabSize); | |||
if (indent <= minIndent) break; | |||
} | |||
var from = Pos(minLine, 0); | |||
return {type: "part", | |||
name: data.name, | |||
offsetLines: from.line, | |||
text: doc.getRange(from, Pos(endLine, end.line == endLine ? null : 0))}; | |||
} | |||
// Generic utilities | |||
var cmpPos = CodeMirror.cmpPos; | |||
function elt(tagname, cls /*, ... elts*/) { | |||
var e = document.createElement(tagname); | |||
if (cls) e.className = cls; | |||
for (var i = 2; i < arguments.length; ++i) { | |||
var elt = arguments[i]; | |||
if (typeof elt == "string") elt = document.createTextNode(elt); | |||
e.appendChild(elt); | |||
} | |||
return e; | |||
} | |||
function dialog(cm, text, f) { | |||
if (cm.openDialog) | |||
cm.openDialog(text + ": <input type=text>", f); | |||
else | |||
f(prompt(text, "")); | |||
} | |||
// Tooltips | |||
function tempTooltip(cm, content, ts) { | |||
if (cm.state.ternTooltip) remove(cm.state.ternTooltip); | |||
var where = cm.cursorCoords(); | |||
var tip = cm.state.ternTooltip = makeTooltip(where.right + 1, where.bottom, content); | |||
function maybeClear() { | |||
old = true; | |||
if (!mouseOnTip) clear(); | |||
} | |||
function clear() { | |||
cm.state.ternTooltip = null; | |||
if (tip.parentNode) fadeOut(tip) | |||
clearActivity() | |||
} | |||
var mouseOnTip = false, old = false; | |||
CodeMirror.on(tip, "mousemove", function() { mouseOnTip = true; }); | |||
CodeMirror.on(tip, "mouseout", function(e) { | |||
var related = e.relatedTarget || e.toElement | |||
if (!related || !CodeMirror.contains(tip, related)) { | |||
if (old) clear(); | |||
else mouseOnTip = false; | |||
} | |||
}); | |||
setTimeout(maybeClear, ts.options.hintDelay ? ts.options.hintDelay : 1700); | |||
var clearActivity = onEditorActivity(cm, clear) | |||
} | |||
function onEditorActivity(cm, f) { | |||
cm.on("cursorActivity", f) | |||
cm.on("blur", f) | |||
cm.on("scroll", f) | |||
cm.on("setDoc", f) | |||
return function() { | |||
cm.off("cursorActivity", f) | |||
cm.off("blur", f) | |||
cm.off("scroll", f) | |||
cm.off("setDoc", f) | |||
} | |||
} | |||
function makeTooltip(x, y, content) { | |||
var node = elt("div", cls + "tooltip", content); | |||
node.style.left = x + "px"; | |||
node.style.top = y + "px"; | |||
document.body.appendChild(node); | |||
return node; | |||
} | |||
function remove(node) { | |||
var p = node && node.parentNode; | |||
if (p) p.removeChild(node); | |||
} | |||
function fadeOut(tooltip) { | |||
tooltip.style.opacity = "0"; | |||
setTimeout(function() { remove(tooltip); }, 1100); | |||
} | |||
function showError(ts, cm, msg) { | |||
if (ts.options.showError) | |||
ts.options.showError(cm, msg); | |||
else | |||
tempTooltip(cm, String(msg), ts); | |||
} | |||
function closeArgHints(ts) { | |||
if (ts.activeArgHints) { | |||
if (ts.activeArgHints.clear) ts.activeArgHints.clear() | |||
remove(ts.activeArgHints) | |||
ts.activeArgHints = null | |||
} | |||
} | |||
function docValue(ts, doc) { | |||
var val = doc.doc.getValue(); | |||
if (ts.options.fileFilter) val = ts.options.fileFilter(val, doc.name, doc.doc); | |||
return val; | |||
} | |||
// Worker wrapper | |||
function WorkerServer(ts) { | |||
var worker = ts.worker = new Worker(ts.options.workerScript); | |||
worker.postMessage({type: "init", | |||
defs: ts.options.defs, | |||
plugins: ts.options.plugins, | |||
scripts: ts.options.workerDeps}); | |||
var msgId = 0, pending = {}; | |||
function send(data, c) { | |||
if (c) { | |||
data.id = ++msgId; | |||
pending[msgId] = c; | |||
} | |||
worker.postMessage(data); | |||
} | |||
worker.onmessage = function(e) { | |||
var data = e.data; | |||
if (data.type == "getFile") { | |||
getFile(ts, data.name, function(err, text) { | |||
send({type: "getFile", err: String(err), text: text, id: data.id}); | |||
}); | |||
} else if (data.type == "debug") { | |||
window.console.log(data.message); | |||
} else if (data.id && pending[data.id]) { | |||
pending[data.id](data.err, data.body); | |||
delete pending[data.id]; | |||
} | |||
}; | |||
worker.onerror = function(e) { | |||
for (var id in pending) pending[id](e); | |||
pending = {}; | |||
}; | |||
this.addFile = function(name, text) { send({type: "add", name: name, text: text}); }; | |||
this.delFile = function(name) { send({type: "del", name: name}); }; | |||
this.request = function(body, c) { send({type: "req", body: body}, c); }; | |||
} | |||
}); |
@ -0,0 +1,44 @@ | |||
// CodeMirror, copyright (c) by Marijn Haverbeke and others | |||
// Distributed under an MIT license: https://codemirror.net/LICENSE | |||
// declare global: tern, server | |||
var server; | |||
this.onmessage = function(e) { | |||
var data = e.data; | |||
switch (data.type) { | |||
case "init": return startServer(data.defs, data.plugins, data.scripts); | |||
case "add": return server.addFile(data.name, data.text); | |||
case "del": return server.delFile(data.name); | |||
case "req": return server.request(data.body, function(err, reqData) { | |||
postMessage({id: data.id, body: reqData, err: err && String(err)}); | |||
}); | |||
case "getFile": | |||
var c = pending[data.id]; | |||
delete pending[data.id]; | |||
return c(data.err, data.text); | |||
default: throw new Error("Unknown message type: " + data.type); | |||
} | |||
}; | |||
var nextId = 0, pending = {}; | |||
function getFile(file, c) { | |||
postMessage({type: "getFile", name: file, id: ++nextId}); | |||
pending[nextId] = c; | |||
} | |||
function startServer(defs, plugins, scripts) { | |||
if (scripts) importScripts.apply(null, scripts); | |||
server = new tern.Server({ | |||
getFile: getFile, | |||
async: true, | |||
defs: defs, | |||
plugins: plugins | |||
}); | |||
} | |||
this.console = { | |||
log: function(v) { postMessage({type: "debug", message: v}); } | |||
}; |
@ -0,0 +1,145 @@ | |||
// 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"; | |||
var Pos = CodeMirror.Pos; | |||
function findParagraph(cm, pos, options) { | |||
var startRE = options.paragraphStart || cm.getHelper(pos, "paragraphStart"); | |||
for (var start = pos.line, first = cm.firstLine(); start > first; --start) { | |||
var line = cm.getLine(start); | |||
if (startRE && startRE.test(line)) break; | |||
if (!/\S/.test(line)) { ++start; break; } | |||
} | |||
var endRE = options.paragraphEnd || cm.getHelper(pos, "paragraphEnd"); | |||
for (var end = pos.line + 1, last = cm.lastLine(); end <= last; ++end) { | |||
var line = cm.getLine(end); | |||
if (endRE && endRE.test(line)) { ++end; break; } | |||
if (!/\S/.test(line)) break; | |||
} | |||
return {from: start, to: end}; | |||
} | |||
function findBreakPoint(text, column, wrapOn, killTrailingSpace) { | |||
var at = column | |||
while (at < text.length && text.charAt(at) == " ") at++ | |||
for (; at > 0; --at) | |||
if (wrapOn.test(text.slice(at - 1, at + 1))) break; | |||
for (var first = true;; first = false) { | |||
var endOfText = at; | |||
if (killTrailingSpace) | |||
while (text.charAt(endOfText - 1) == " ") --endOfText; | |||
if (endOfText == 0 && first) at = column; | |||
else return {from: endOfText, to: at}; | |||
} | |||
} | |||
function wrapRange(cm, from, to, options) { | |||
from = cm.clipPos(from); to = cm.clipPos(to); | |||
var column = options.column || 80; | |||
var wrapOn = options.wrapOn || /\s\S|-[^\.\d]/; | |||
var killTrailing = options.killTrailingSpace !== false; | |||
var changes = [], curLine = "", curNo = from.line; | |||
var lines = cm.getRange(from, to, false); | |||
if (!lines.length) return null; | |||
var leadingSpace = lines[0].match(/^[ \t]*/)[0]; | |||
if (leadingSpace.length >= column) column = leadingSpace.length + 1 | |||
for (var i = 0; i < lines.length; ++i) { | |||
var text = lines[i], oldLen = curLine.length, spaceInserted = 0; | |||
if (curLine && text && !wrapOn.test(curLine.charAt(curLine.length - 1) + text.charAt(0))) { | |||
curLine += " "; | |||
spaceInserted = 1; | |||
} | |||
var spaceTrimmed = ""; | |||
if (i) { | |||
spaceTrimmed = text.match(/^\s*/)[0]; | |||
text = text.slice(spaceTrimmed.length); | |||
} | |||
curLine += text; | |||
if (i) { | |||
var firstBreak = curLine.length > column && leadingSpace == spaceTrimmed && | |||
findBreakPoint(curLine, column, wrapOn, killTrailing); | |||
// If this isn't broken, or is broken at a different point, remove old break | |||
if (!firstBreak || firstBreak.from != oldLen || firstBreak.to != oldLen + spaceInserted) { | |||
changes.push({text: [spaceInserted ? " " : ""], | |||
from: Pos(curNo, oldLen), | |||
to: Pos(curNo + 1, spaceTrimmed.length)}); | |||
} else { | |||
curLine = leadingSpace + text; | |||
++curNo; | |||
} | |||
} | |||
while (curLine.length > column) { | |||
var bp = findBreakPoint(curLine, column, wrapOn, killTrailing); | |||
changes.push({text: ["", leadingSpace], | |||
from: Pos(curNo, bp.from), | |||
to: Pos(curNo, bp.to)}); | |||
curLine = leadingSpace + curLine.slice(bp.to); | |||
++curNo; | |||
} | |||
} | |||
if (changes.length) cm.operation(function() { | |||
for (var i = 0; i < changes.length; ++i) { | |||
var change = changes[i]; | |||
if (change.text || CodeMirror.cmpPos(change.from, change.to)) | |||
cm.replaceRange(change.text, change.from, change.to); | |||
} | |||
}); | |||
return changes.length ? {from: changes[0].from, to: CodeMirror.changeEnd(changes[changes.length - 1])} : null; | |||
} | |||
CodeMirror.defineExtension("wrapParagraph", function(pos, options) { | |||
options = options || {}; | |||
if (!pos) pos = this.getCursor(); | |||
var para = findParagraph(this, pos, options); | |||
return wrapRange(this, Pos(para.from, 0), Pos(para.to - 1), options); | |||
}); | |||
CodeMirror.commands.wrapLines = function(cm) { | |||
cm.operation(function() { | |||
var ranges = cm.listSelections(), at = cm.lastLine() + 1; | |||
for (var i = ranges.length - 1; i >= 0; i--) { | |||
var range = ranges[i], span; | |||
if (range.empty()) { | |||
var para = findParagraph(cm, range.head, {}); | |||
span = {from: Pos(para.from, 0), to: Pos(para.to - 1)}; | |||
} else { | |||
span = {from: range.from(), to: range.to()}; | |||
} | |||
if (span.to.line >= at) continue; | |||
at = span.from.line; | |||
wrapRange(cm, span.from, span.to, {}); | |||
} | |||
}); | |||
}; | |||
CodeMirror.defineExtension("wrapRange", function(from, to, options) { | |||
return wrapRange(this, from, to, options || {}); | |||
}); | |||
CodeMirror.defineExtension("wrapParagraphsInRange", function(from, to, options) { | |||
options = options || {}; | |||
var cm = this, paras = []; | |||
for (var line = from.line; line <= to.line;) { | |||
var para = findParagraph(cm, Pos(line, 0), options); | |||
paras.push(para); | |||
line = para.to; | |||
} | |||
var madeChange = false; | |||
if (paras.length) cm.operation(function() { | |||
for (var i = paras.length - 1; i >= 0; --i) | |||
madeChange = madeChange || wrapRange(cm, Pos(paras[i].from, 0), Pos(paras[i].to - 1), options); | |||
}); | |||
return madeChange; | |||
}); | |||
}); |
@ -0,0 +1,384 @@ | |||
// CodeMirror, copyright (c) by Marijn Haverbeke and others | |||
// Distributed under an MIT license: https://codemirror.net/LICENSE | |||
(function () { | |||
var mode = CodeMirror.getMode({indentUnit: 2}, "clojure"); | |||
function MT(name) { | |||
test.mode(name, mode, Array.prototype.slice.call(arguments, 1)); | |||
} | |||
MT("atoms", | |||
"[atom false]", | |||
"[atom nil]", | |||
"[atom true]" | |||
); | |||
MT("keywords", | |||
"[atom :foo]", | |||
"[atom ::bar]", | |||
"[atom :foo/bar]", | |||
"[atom :foo.bar/baz]" | |||
); | |||
MT("numbers", | |||
"[number 42] [number +42] [number -421]", | |||
"[number 42N] [number +42N] [number -42N]", | |||
"[number 0.42] [number +0.42] [number -0.42]", | |||
"[number 42M] [number +42M] [number -42M]", | |||
"[number 42.42M] [number +42.42M] [number -42.42M]", | |||
"[number 1/42] [number +1/42] [number -1/42]", | |||
"[number 0x42af] [number +0x42af] [number -0x42af]", | |||
"[number 0x42AF] [number +0x42AF] [number -0x42AF]", | |||
"[number 1e2] [number 1e+2] [number 1e-2]", | |||
"[number +1e2] [number +1e+2] [number +1e-2]", | |||
"[number -1e2] [number -1e+2] [number -1e-2]", | |||
"[number -1.0e2] [number -0.1e+2] [number -1.01e-2]", | |||
"[number 1E2] [number 1E+2] [number 1E-2]", | |||
"[number +1E2] [number +1E+2] [number +1E-2]", | |||
"[number -1E2] [number -1E+2] [number -1E-2]", | |||
"[number -1.0E2] [number -0.1E+2] [number -1.01E-2]", | |||
"[number 2r101010] [number +2r101010] [number -2r101010]", | |||
"[number 2r101010] [number +2r101010] [number -2r101010]", | |||
"[number 8r52] [number +8r52] [number -8r52]", | |||
"[number 36rhello] [number +36rhello] [number -36rhello]", | |||
"[number 36rz] [number +36rz] [number -36rz]", | |||
"[number 36rZ] [number +36rZ] [number -36rZ]", | |||
// invalid numbers | |||
"[error 42foo]", | |||
"[error 42Nfoo]", | |||
"[error 42Mfoo]", | |||
"[error 42.42Mfoo]", | |||
"[error 42.42M!]", | |||
"[error 42!]", | |||
"[error 0x42afm]" | |||
); | |||
MT("characters", | |||
"[string-2 \\1]", | |||
"[string-2 \\a]", | |||
"[string-2 \\a\\b\\c]", | |||
"[string-2 \\#]", | |||
"[string-2 \\\\]", | |||
"[string-2 \\\"]", | |||
"[string-2 \\(]", | |||
"[string-2 \\A]", | |||
"[string-2 \\backspace]", | |||
"[string-2 \\formfeed]", | |||
"[string-2 \\newline]", | |||
"[string-2 \\space]", | |||
"[string-2 \\return]", | |||
"[string-2 \\tab]", | |||
"[string-2 \\u1000]", | |||
"[string-2 \\uAaAa]", | |||
"[string-2 \\u9F9F]", | |||
"[string-2 \\o123]", | |||
"[string-2 \\符]", | |||
"[string-2 \\シ]", | |||
"[string-2 \\ۇ]", | |||
// FIXME | |||
// "[string-2 \\🙂]", | |||
// invalid character literals | |||
"[error \\abc]", | |||
"[error \\a123]", | |||
"[error \\a!]", | |||
"[error \\newlines]", | |||
"[error \\NEWLINE]", | |||
"[error \\u9F9FF]", | |||
"[error \\o1234]" | |||
); | |||
MT("strings", | |||
"[string \"I'm a teapot.\"]", | |||
"[string \"I'm a \\\"teapot\\\".\"]", | |||
"[string \"I'm]", // this is | |||
"[string a]", // a multi-line | |||
"[string teapot.\"]" // string | |||
// TODO unterminated (multi-line) strings? | |||
); | |||
MT("comments", | |||
"[comment ; this is an in-line comment.]", | |||
"[comment ;; this is a line comment.]", | |||
"[keyword comment]", | |||
"[bracket (][comment comment (foo 1 2 3)][bracket )]" | |||
); | |||
MT("reader macro characters", | |||
"[meta #][variable _]", | |||
"[meta #][variable -Inf]", | |||
"[meta ##][variable Inf]", | |||
"[meta ##][variable NaN]", | |||
"[meta @][variable x]", | |||
"[meta ^][bracket {][atom :tag] [variable String][bracket }]", | |||
"[meta `][bracket (][builtin f] [variable x][bracket )]", | |||
"[meta ~][variable foo#]", | |||
"[meta '][number 1]", | |||
"[meta '][atom :foo]", | |||
"[meta '][string \"foo\"]", | |||
"[meta '][variable x]", | |||
"[meta '][bracket (][builtin a] [variable b] [variable c][bracket )]", | |||
"[meta '][bracket [[][variable a] [variable b] [variable c][bracket ]]]", | |||
"[meta '][bracket {][variable a] [number 1] [atom :foo] [number 2] [variable c] [number 3][bracket }]", | |||
"[meta '#][bracket {][variable a] [number 1] [atom :foo][bracket }]" | |||
); | |||
MT("symbols", | |||
"[variable foo!]", | |||
"[variable foo#]", | |||
"[variable foo$]", | |||
"[variable foo&]", | |||
"[variable foo']", | |||
"[variable foo*]", | |||
"[variable foo+]", | |||
"[variable foo-]", | |||
"[variable foo.]", | |||
"[variable foo/bar]", | |||
"[variable foo:bar]", | |||
"[variable foo<]", | |||
"[variable foo=]", | |||
"[variable foo>]", | |||
"[variable foo?]", | |||
"[variable foo_]", | |||
"[variable foo|]", | |||
"[variable foobarBaz]", | |||
"[variable foo¡]", | |||
"[variable 符号]", | |||
"[variable シンボル]", | |||
"[variable ئۇيغۇر]", | |||
"[variable 🙂❤🇺🇸]", | |||
// invalid symbols | |||
"[error 3foo]", | |||
"[error 3+]", | |||
"[error 3|]", | |||
"[error 3_]" | |||
); | |||
MT("numbers and other forms", | |||
"[number 42][bracket (][builtin foo][bracket )]", | |||
"[number 42][bracket [[][variable foo][bracket ]]]", | |||
"[number 42][meta #][bracket {][variable foo][bracket }]", | |||
"[number 42][bracket {][atom :foo] [variable bar][bracket }]", | |||
"[number 42][meta `][variable foo]", | |||
"[number 42][meta ~][variable foo]", | |||
"[number 42][meta #][variable foo]" | |||
); | |||
var specialForms = [".", "catch", "def", "do", "if", "monitor-enter", | |||
"monitor-exit", "new", "quote", "recur", "set!", "throw", "try", "var"]; | |||
MT("should highlight special forms as keywords", | |||
typeTokenPairs("keyword", specialForms) | |||
); | |||
var coreSymbols1 = [ | |||
"*", "*'", "*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"]; | |||
var coreSymbols2 = [ | |||
"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" | |||
]; | |||
MT("should highlight core symbols as keywords (part 1/2)", | |||
typeTokenPairs("keyword", coreSymbols1) | |||
); | |||
MT("should highlight core symbols as keywords (part 2/2)", | |||
typeTokenPairs("keyword", coreSymbols2) | |||
); | |||
MT("should properly indent forms in list literals", | |||
"[bracket (][builtin foo] [atom :a] [number 1] [atom true] [atom nil][bracket )]", | |||
"", | |||
"[bracket (][builtin foo] [atom :a]", | |||
" [number 1]", | |||
" [atom true]", | |||
" [atom nil][bracket )]", | |||
"", | |||
"[bracket (][builtin foo] [atom :a] [number 1]", | |||
" [atom true]", | |||
" [atom nil][bracket )]", | |||
"", | |||
"[bracket (]", | |||
" [builtin foo]", | |||
" [atom :a]", | |||
" [number 1]", | |||
" [atom true]", | |||
" [atom nil][bracket )]", | |||
"", | |||
"[bracket (][builtin foo] [bracket [[][atom :a][bracket ]]]", | |||
" [number 1]", | |||
" [atom true]", | |||
" [atom nil][bracket )]" | |||
); | |||
MT("should properly indent forms in vector literals", | |||
"[bracket [[][atom :a] [number 1] [atom true] [atom nil][bracket ]]]", | |||
"", | |||
"[bracket [[][atom :a]", | |||
" [number 1]", | |||
" [atom true]", | |||
" [atom nil][bracket ]]]", | |||
"", | |||
"[bracket [[][atom :a] [number 1]", | |||
" [atom true]", | |||
" [atom nil][bracket ]]]", | |||
"", | |||
"[bracket [[]", | |||
" [variable foo]", | |||
" [atom :a]", | |||
" [number 1]", | |||
" [atom true]", | |||
" [atom nil][bracket ]]]" | |||
); | |||
MT("should properly indent forms in map literals", | |||
"[bracket {][atom :a] [atom :a] [atom :b] [number 1] [atom :c] [atom true] [atom :d] [atom nil] [bracket }]", | |||
"", | |||
"[bracket {][atom :a] [atom :a]", | |||
" [atom :b] [number 1]", | |||
" [atom :c] [atom true]", | |||
" [atom :d] [atom nil][bracket }]", | |||
"", | |||
"[bracket {][atom :a]", | |||
" [atom :a]", | |||
" [atom :b]", | |||
" [number 1]", | |||
" [atom :c]", | |||
" [atom true]", | |||
" [atom :d]", | |||
" [atom nil][bracket }]", | |||
"", | |||
"[bracket {]", | |||
" [atom :a] [atom :a]", | |||
" [atom :b] [number 1]", | |||
" [atom :c] [atom true]", | |||
" [atom :d] [atom nil][bracket }]" | |||
); | |||
MT("should properly indent forms in set literals", | |||
"[meta #][bracket {][atom :a] [number 1] [atom true] [atom nil] [bracket }]", | |||
"", | |||
"[meta #][bracket {][atom :a]", | |||
" [number 1]", | |||
" [atom true]", | |||
" [atom nil][bracket }]", | |||
"", | |||
"[meta #][bracket {]", | |||
" [atom :a]", | |||
" [number 1]", | |||
" [atom true]", | |||
" [atom nil][bracket }]" | |||
); | |||
var haveBodyParameter = [ | |||
"->", "->>", "as->", "binding", "bound-fn", "case", "catch", "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", "some->", "some->>", | |||
"struct-map", "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"]; | |||
function testFormsThatHaveBodyParameter(forms) { | |||
for (var i = 0; i < forms.length; i++) { | |||
MT("should indent body argument of `" + forms[i] + "` by `options.indentUnit` spaces", | |||
"[bracket (][keyword " + forms[i] + "] [variable foo] [variable bar]", | |||
" [variable baz]", | |||
" [variable qux][bracket )]" | |||
); | |||
} | |||
} | |||
testFormsThatHaveBodyParameter(haveBodyParameter); | |||
MT("should indent body argument of `comment` by `options.indentUnit` spaces", | |||
"[bracket (][comment comment foo bar]", | |||
"[comment baz]", | |||
"[comment qux][bracket )]" | |||
); | |||
function typeTokenPairs(type, tokens) { | |||
return "[" + type + " " + tokens.join("] [" + type + " ") + "]"; | |||
} | |||
})(); |