utils.js
847 lines
| 28.6 KiB
| application/javascript
|
JavascriptLexer
|
r16580 | // Copyright (c) IPython Development Team. | ||
// Distributed under the terms of the Modified BSD License. | ||||
|
r4349 | |||
|
r17188 | define([ | ||
'base/js/namespace', | ||||
|
r17200 | 'jquery', | ||
|
r18280 | 'codemirror/lib/codemirror', | ||
|
r18907 | ], function(IPython, $, CodeMirror){ | ||
|
r12103 | "use strict"; | ||
|
r15228 | |||
IPython.load_extensions = function () { | ||||
// load one or more IPython notebook extensions with requirejs | ||||
var extensions = []; | ||||
var extension_names = arguments; | ||||
for (var i = 0; i < extension_names.length; i++) { | ||||
extensions.push("nbextensions/" + arguments[i]); | ||||
} | ||||
require(extensions, | ||||
function () { | ||||
for (var i = 0; i < arguments.length; i++) { | ||||
var ext = arguments[i]; | ||||
var ext_name = extension_names[i]; | ||||
// success callback | ||||
console.log("Loaded extension: " + ext_name); | ||||
if (ext && ext.load_ipython_extension !== undefined) { | ||||
ext.load_ipython_extension(); | ||||
} | ||||
} | ||||
}, | ||||
function (err) { | ||||
// failure callback | ||||
console.log("Failed to load extension(s):", err.requireModules, err); | ||||
} | ||||
); | ||||
}; | ||||
|
r4352 | |||
|
r8565 | //============================================================================ | ||
// Cross-browser RegEx Split | ||||
//============================================================================ | ||||
// This code has been MODIFIED from the code licensed below to not replace the | ||||
// default browser split. The license is reproduced here. | ||||
// see http://blog.stevenlevithan.com/archives/cross-browser-split for more info: | ||||
/*! | ||||
* Cross-Browser Split 1.1.1 | ||||
* Copyright 2007-2012 Steven Levithan <stevenlevithan.com> | ||||
* Available under the MIT License | ||||
* ECMAScript compliant, uniform cross-browser split method | ||||
*/ | ||||
/** | ||||
* Splits a string into an array of strings using a regex or string | ||||
* separator. Matches of the separator are not included in the result array. | ||||
* However, if `separator` is a regex that contains capturing groups, | ||||
* backreferences are spliced into the result each time `separator` is | ||||
* matched. Fixes browser bugs compared to the native | ||||
* `String.prototype.split` and can be used reliably cross-browser. | ||||
* @param {String} str String to split. | ||||
* @param {RegExp|String} separator Regex or string to use for separating | ||||
* the string. | ||||
* @param {Number} [limit] Maximum number of items to include in the result | ||||
* array. | ||||
* @returns {Array} Array of substrings. | ||||
* @example | ||||
* | ||||
* // Basic use | ||||
* regex_split('a b c d', ' '); | ||||
* // -> ['a', 'b', 'c', 'd'] | ||||
* | ||||
* // With limit | ||||
* regex_split('a b c d', ' ', 2); | ||||
* // -> ['a', 'b'] | ||||
* | ||||
* // Backreferences in result array | ||||
* regex_split('..word1 word2..', /([a-z]+)(\d+)/i); | ||||
* // -> ['..', 'word', '1', ' ', 'word', '2', '..'] | ||||
*/ | ||||
var regex_split = function (str, separator, limit) { | ||||
|
r19177 | // If `separator` is not a regex, use `split` | ||
|
r8565 | if (Object.prototype.toString.call(separator) !== "[object RegExp]") { | ||
return split.call(str, separator, limit); | ||||
} | ||||
var output = [], | ||||
flags = (separator.ignoreCase ? "i" : "") + | ||||
(separator.multiline ? "m" : "") + | ||||
(separator.extended ? "x" : "") + // Proposed for ES6 | ||||
(separator.sticky ? "y" : ""), // Firefox 3+ | ||||
lastLastIndex = 0, | ||||
// Make `global` and avoid `lastIndex` issues by working with a copy | ||||
separator = new RegExp(separator.source, flags + "g"), | ||||
separator2, match, lastIndex, lastLength; | ||||
str += ""; // Type-convert | ||||
|
r11307 | var compliantExecNpcg = typeof(/()??/.exec("")[1]) === "undefined"; | ||
|
r8565 | if (!compliantExecNpcg) { | ||
// Doesn't need flags gy, but they don't hurt | ||||
separator2 = new RegExp("^" + separator.source + "$(?!\\s)", flags); | ||||
} | ||||
/* Values for `limit`, per the spec: | ||||
* If undefined: 4294967295 // Math.pow(2, 32) - 1 | ||||
* If 0, Infinity, or NaN: 0 | ||||
* If positive number: limit = Math.floor(limit); if (limit > 4294967295) limit -= 4294967296; | ||||
* If negative number: 4294967296 - Math.floor(Math.abs(limit)) | ||||
* If other: Type-convert, then use the above rules | ||||
*/ | ||||
limit = typeof(limit) === "undefined" ? | ||||
-1 >>> 0 : // Math.pow(2, 32) - 1 | ||||
limit >>> 0; // ToUint32(limit) | ||||
while (match = separator.exec(str)) { | ||||
// `separator.lastIndex` is not reliable cross-browser | ||||
lastIndex = match.index + match[0].length; | ||||
if (lastIndex > lastLastIndex) { | ||||
output.push(str.slice(lastLastIndex, match.index)); | ||||
// Fix browsers whose `exec` methods don't consistently return `undefined` for | ||||
// nonparticipating capturing groups | ||||
if (!compliantExecNpcg && match.length > 1) { | ||||
match[0].replace(separator2, function () { | ||||
for (var i = 1; i < arguments.length - 2; i++) { | ||||
if (typeof(arguments[i]) === "undefined") { | ||||
match[i] = undefined; | ||||
} | ||||
} | ||||
}); | ||||
} | ||||
if (match.length > 1 && match.index < str.length) { | ||||
Array.prototype.push.apply(output, match.slice(1)); | ||||
} | ||||
lastLength = match[0].length; | ||||
lastLastIndex = lastIndex; | ||||
if (output.length >= limit) { | ||||
break; | ||||
} | ||||
} | ||||
if (separator.lastIndex === match.index) { | ||||
separator.lastIndex++; // Avoid an infinite loop | ||||
} | ||||
} | ||||
if (lastLastIndex === str.length) { | ||||
if (lastLength || !separator.test("")) { | ||||
output.push(""); | ||||
} | ||||
} else { | ||||
output.push(str.slice(lastLastIndex)); | ||||
} | ||||
return output.length > limit ? output.slice(0, limit) : output; | ||||
}; | ||||
//============================================================================ | ||||
// End contributed Cross-browser RegEx Split | ||||
//============================================================================ | ||||
|
r4352 | var uuid = function () { | ||
|
r19176 | /** | ||
* http://www.ietf.org/rfc/rfc4122.txt | ||||
*/ | ||||
|
r4352 | var s = []; | ||
var hexDigits = "0123456789ABCDEF"; | ||||
for (var i = 0; i < 32; i++) { | ||||
s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1); | ||||
} | ||||
s[12] = "4"; // bits 12-15 of the time_hi_and_version field to 0010 | ||||
s[16] = hexDigits.substr((s[16] & 0x3) | 0x8, 1); // bits 6-7 of the clock_seq_hi_and_reserved to 01 | ||||
var uuid = s.join(""); | ||||
return uuid; | ||||
}; | ||||
//Fix raw text to parse correctly in crazy XML | ||||
function xmlencode(string) { | ||||
return string.replace(/\&/g,'&'+'amp;') | ||||
.replace(/</g,'&'+'lt;') | ||||
.replace(/>/g,'&'+'gt;') | ||||
.replace(/\'/g,'&'+'apos;') | ||||
.replace(/\"/g,'&'+'quot;') | ||||
|
r5479 | .replace(/`/g,'&'+'#96;'); | ||
|
r4349 | } | ||
|
r4352 | |||
|
r4361 | |||
|
r4352 | //Map from terminal commands to CSS classes | ||
|
r8839 | var ansi_colormap = { | ||
|
r10250 | "01":"ansibold", | ||
|
r11313 | |||
|
r10250 | "30":"ansiblack", | ||
"31":"ansired", | ||||
"32":"ansigreen", | ||||
"33":"ansiyellow", | ||||
"34":"ansiblue", | ||||
"35":"ansipurple", | ||||
"36":"ansicyan", | ||||
|
r11312 | "37":"ansigray", | ||
|
r11313 | |||
|
r11312 | "40":"ansibgblack", | ||
"41":"ansibgred", | ||||
"42":"ansibggreen", | ||||
|
r12095 | "43":"ansibgyellow", | ||
|
r11312 | "44":"ansibgblue", | ||
"45":"ansibgpurple", | ||||
"46":"ansibgcyan", | ||||
"47":"ansibggray" | ||||
|
r5479 | }; | ||
|
r11307 | |||
function _process_numbers(attrs, numbers) { | ||||
// process ansi escapes | ||||
var n = numbers.shift(); | ||||
if (ansi_colormap[n]) { | ||||
if ( ! attrs["class"] ) { | ||||
attrs["class"] = ansi_colormap[n]; | ||||
} else { | ||||
attrs["class"] += " " + ansi_colormap[n]; | ||||
} | ||||
} else if (n == "38" || n == "48") { | ||||
|
r11314 | // VT100 256 color or 24 bit RGB | ||
|
r11307 | if (numbers.length < 2) { | ||
|
r11314 | console.log("Not enough fields for VT100 color", numbers); | ||
|
r11307 | return; | ||
} | ||||
var index_or_rgb = numbers.shift(); | ||||
var r,g,b; | ||||
if (index_or_rgb == "5") { | ||||
|
r11314 | // 256 color | ||
|
r11307 | var idx = parseInt(numbers.shift()); | ||
if (idx < 16) { | ||||
|
r11313 | // indexed ANSI | ||
// ignore bright / non-bright distinction | ||||
idx = idx % 8; | ||||
var ansiclass = ansi_colormap[n[0] + (idx % 8).toString()]; | ||||
if ( ! attrs["class"] ) { | ||||
attrs["class"] = ansiclass; | ||||
} else { | ||||
attrs["class"] += " " + ansiclass; | ||||
} | ||||
return; | ||||
|
r11307 | } else if (idx < 232) { | ||
|
r11313 | // 216 color 6x6x6 RGB | ||
|
r11307 | idx = idx - 16; | ||
b = idx % 6; | ||||
g = Math.floor(idx / 6) % 6; | ||||
r = Math.floor(idx / 36) % 6; | ||||
// convert to rgb | ||||
r = (r * 51); | ||||
g = (g * 51); | ||||
b = (b * 51); | ||||
} else { | ||||
// grayscale | ||||
idx = idx - 231; | ||||
// it's 1-24 and should *not* include black or white, | ||||
// so a 26 point scale | ||||
|
r11313 | r = g = b = Math.floor(idx * 256 / 26); | ||
|
r11307 | } | ||
} else if (index_or_rgb == "2") { | ||||
|
r11313 | // Simple 24 bit RGB | ||
|
r11307 | if (numbers.length > 3) { | ||
console.log("Not enough fields for RGB", numbers); | ||||
return; | ||||
} | ||||
r = numbers.shift(); | ||||
g = numbers.shift(); | ||||
b = numbers.shift(); | ||||
} else { | ||||
console.log("unrecognized control", numbers); | ||||
return; | ||||
} | ||||
if (r !== undefined) { | ||||
// apply the rgb color | ||||
var line; | ||||
if (n == "38") { | ||||
line = "color: "; | ||||
} else { | ||||
line = "background-color: "; | ||||
} | ||||
|
r18752 | line = line + "rgb(" + r + "," + g + "," + b + ");"; | ||
if ( !attrs.style ) { | ||||
attrs.style = line; | ||||
|
r11307 | } else { | ||
|
r18752 | attrs.style += " " + line; | ||
|
r11307 | } | ||
} | ||||
} | ||||
} | ||||
|
r4352 | |||
|
r10250 | function ansispan(str) { | ||
// ansispan function adapted from github.com/mmalecki/ansispan (MIT License) | ||||
|
r11307 | // regular ansi escapes (using the table above) | ||
|
r18752 | var is_open = false; | ||
|
r11307 | return str.replace(/\033\[(0?[01]|22|39)?([;\d]+)?m/g, function(match, prefix, pattern) { | ||
if (!pattern) { | ||||
// [(01|22|39|)m close spans | ||||
|
r18191 | if (is_open) { | ||
is_open = false; | ||||
return "</span>"; | ||||
} else { | ||||
return ""; | ||||
} | ||||
} else { | ||||
is_open = true; | ||||
// consume sequence of color escapes | ||||
var numbers = pattern.match(/\d+/g); | ||||
var attrs = {}; | ||||
while (numbers.length > 0) { | ||||
_process_numbers(attrs, numbers); | ||||
} | ||||
var span = "<span "; | ||||
for (var attr in attrs) { | ||||
var value = attrs[attr]; | ||||
span = span + " " + attr + '="' + attrs[attr] + '"'; | ||||
} | ||||
return span + ">"; | ||||
|
r11307 | } | ||
|
r10250 | }); | ||
|
r18752 | } | ||
|
r18191 | |||
|
r7339 | // Transform ANSI color escape codes into HTML <span> tags with css | ||
|
r4383 | // classes listed in the above ansi_colormap object. The actual color used | ||
// are set in the css file. | ||||
|
r4352 | function fixConsole(txt) { | ||
|
r5479 | txt = xmlencode(txt); | ||
|
r6423 | var re = /\033\[([\dA-Fa-f;]*?)m/; | ||
|
r5479 | var opened = false; | ||
var cmds = []; | ||||
var opener = ""; | ||||
var closer = ""; | ||||
|
r10140 | |||
// Strip all ANSI codes that are not color related. Matches | ||||
// all ANSI codes that do not end with "m". | ||||
var ignored_re = /(?=(\033\[[\d;=]*[a-ln-zA-Z]{1}))\1(?!m)/g; | ||||
txt = txt.replace(ignored_re, ""); | ||||
|
r10250 | |||
// color ansi codes | ||||
txt = ansispan(txt); | ||||
|
r5479 | return txt; | ||
|
r4352 | } | ||
|
r7338 | // Remove chunks that should be overridden by the effect of | ||
// carriage return characters | ||||
function fixCarriageReturn(txt) { | ||||
|
r8839 | var tmp = txt; | ||
|
r7338 | do { | ||
txt = tmp; | ||||
|
r8702 | tmp = txt.replace(/\r+\n/gm, '\n'); // \r followed by \n --> newline | ||
tmp = tmp.replace(/^.*\r+/gm, ''); // Other \r --> clear line | ||||
|
r7338 | } while (tmp.length < txt.length); | ||
return txt; | ||||
} | ||||
|
r4361 | |||
|
r10045 | // Locate any URLs and convert them to a anchor tag | ||
|
r8528 | function autoLinkUrls(txt) { | ||
|
r10045 | return txt.replace(/(^|\s)(https?|ftp)(:[^'">\s]+)/gi, | ||
"$1<a target=\"_blank\" href=\"$2$3\">$2$3</a>"); | ||||
|
r8528 | } | ||
|
r8839 | var points_to_pixels = function (points) { | ||
|
r19176 | /** | ||
* A reasonably good way of converting between points and pixels. | ||||
*/ | ||||
|
r7353 | var test = $('<div style="display: none; width: 10000pt; padding:0; border:0;"></div>'); | ||
$(body).append(test); | ||||
var pixel_per_point = test.width()/10000; | ||||
test.remove(); | ||||
return Math.floor(points*pixel_per_point); | ||||
|
r8839 | }; | ||
|
r13206 | |||
var always_new = function (constructor) { | ||||
|
r19176 | /** | ||
* wrapper around contructor to avoid requiring `var a = new constructor()` | ||||
* useful for passing constructors as callbacks, | ||||
* not for programmer laziness. | ||||
* from http://programmers.stackexchange.com/questions/118798 | ||||
*/ | ||||
|
r13206 | return function () { | ||
var obj = Object.create(constructor.prototype); | ||||
constructor.apply(obj, arguments); | ||||
return obj; | ||||
}; | ||||
}; | ||||
|
r7353 | |||
|
r13063 | var url_path_join = function () { | ||
|
r19176 | /** | ||
* join a sequence of url components with '/' | ||||
*/ | ||||
|
r13063 | var url = ''; | ||
for (var i = 0; i < arguments.length; i++) { | ||||
|
r13080 | if (arguments[i] === '') { | ||
continue; | ||||
} | ||||
|
r13063 | if (url.length > 0 && url[url.length-1] != '/') { | ||
url = url + '/' + arguments[i]; | ||||
} else { | ||||
url = url + arguments[i]; | ||||
} | ||||
} | ||||
|
r15241 | url = url.replace(/\/\/+/, '/'); | ||
|
r13063 | return url; | ||
}; | ||||
|
r13686 | |||
|
r18752 | var url_path_split = function (path) { | ||
|
r19176 | /** | ||
* Like os.path.split for URLs. | ||||
* Always returns two strings, the directory path and the base filename | ||||
*/ | ||||
|
r18752 | |||
var idx = path.lastIndexOf('/'); | ||||
if (idx === -1) { | ||||
return ['', path]; | ||||
} else { | ||||
return [ path.slice(0, idx), path.slice(idx + 1) ]; | ||||
} | ||||
}; | ||||
|
r15241 | var parse_url = function (url) { | ||
|
r19176 | /** | ||
* an `a` element with an href allows attr-access to the parsed segments of a URL | ||||
* a = parse_url("http://localhost:8888/path/name#hash") | ||||
* a.protocol = "http:" | ||||
* a.host = "localhost:8888" | ||||
* a.hostname = "localhost" | ||||
* a.port = 8888 | ||||
* a.pathname = "/path/name" | ||||
* a.hash = "#hash" | ||||
*/ | ||||
|
r15241 | var a = document.createElement("a"); | ||
a.href = url; | ||||
return a; | ||||
}; | ||||
|
r13686 | |||
var encode_uri_components = function (uri) { | ||||
|
r19176 | /** | ||
* encode just the components of a multi-segment uri, | ||||
* leaving '/' separators | ||||
*/ | ||||
|
r13686 | return uri.split('/').map(encodeURIComponent).join('/'); | ||
|
r15241 | }; | ||
|
r13686 | |||
var url_join_encode = function () { | ||||
|
r19176 | /** | ||
* join a sequence of url components with '/', | ||||
* encoding each component with encodeURIComponent | ||||
*/ | ||||
|
r13686 | return encode_uri_components(url_path_join.apply(null, arguments)); | ||
}; | ||||
|
r13063 | |||
|
r13120 | var splitext = function (filename) { | ||
|
r19176 | /** | ||
* mimic Python os.path.splitext | ||||
* Returns ['base', '.ext'] | ||||
*/ | ||||
|
r13120 | var idx = filename.lastIndexOf('.'); | ||
if (idx > 0) { | ||||
return [filename.slice(0, idx), filename.slice(idx)]; | ||||
} else { | ||||
return [filename, '']; | ||||
} | ||||
|
r15233 | }; | ||
|
r15331 | var escape_html = function (text) { | ||
|
r19176 | /** | ||
* escape text to HTML | ||||
*/ | ||||
|
r15331 | return $("<div/>").text(text).html(); | ||
|
r16580 | }; | ||
|
r15331 | |||
|
r15240 | var get_body_data = function(key) { | ||
|
r19176 | /** | ||
* get a url-encoded item from body.data and decode it | ||||
* we should never have any encoded URLs anywhere else in code | ||||
* until we are building an actual request | ||||
*/ | ||||
|
r15233 | return decodeURIComponent($('body').data(key)); | ||
}; | ||||
|
r16580 | |||
|
r16588 | var to_absolute_cursor_pos = function (cm, cursor) { | ||
|
r19176 | /** | ||
* get the absolute cursor position from CodeMirror's col, ch | ||||
*/ | ||||
|
r16580 | if (!cursor) { | ||
cursor = cm.getCursor(); | ||||
} | ||||
var cursor_pos = cursor.ch; | ||||
for (var i = 0; i < cursor.line; i++) { | ||||
cursor_pos += cm.getLine(i).length + 1; | ||||
} | ||||
return cursor_pos; | ||||
}; | ||||
|
r16588 | var from_absolute_cursor_pos = function (cm, cursor_pos) { | ||
|
r19176 | /** | ||
* turn absolute cursor postion into CodeMirror col, ch cursor | ||||
*/ | ||||
|
r16588 | var i, line; | ||
var offset = 0; | ||||
for (i = 0, line=cm.getLine(i); line !== undefined; i++, line=cm.getLine(i)) { | ||||
if (offset + line.length < cursor_pos) { | ||||
offset += line.length + 1; | ||||
} else { | ||||
return { | ||||
line : i, | ||||
ch : cursor_pos - offset, | ||||
}; | ||||
} | ||||
} | ||||
// reached end, return endpoint | ||||
return { | ||||
ch : line.length - 1, | ||||
line : i - 1, | ||||
}; | ||||
}; | ||||
|
r9227 | // http://stackoverflow.com/questions/2400935/browser-detection-in-javascript | ||
|
r12103 | var browser = (function() { | ||
|
r14205 | if (typeof navigator === 'undefined') { | ||
// navigator undefined in node | ||||
return 'None'; | ||||
} | ||||
|
r9227 | var N= navigator.appName, ua= navigator.userAgent, tem; | ||
var M= ua.match(/(opera|chrome|safari|firefox|msie)\/?\s*(\.?\d+(\.\d+)*)/i); | ||||
|
r16588 | if (M && (tem= ua.match(/version\/([\.\d]+)/i)) !== null) M[2]= tem[1]; | ||
|
r9227 | M= M? [M[1], M[2]]: [N, navigator.appVersion,'-?']; | ||
return M; | ||||
})(); | ||||
|
r14816 | // http://stackoverflow.com/questions/11219582/how-to-detect-my-browser-version-and-operating-system-using-javascript | ||
var platform = (function () { | ||||
|
r14826 | if (typeof navigator === 'undefined') { | ||
// navigator undefined in node | ||||
return 'None'; | ||||
} | ||||
var OSName="None"; | ||||
|
r14816 | if (navigator.appVersion.indexOf("Win")!=-1) OSName="Windows"; | ||
if (navigator.appVersion.indexOf("Mac")!=-1) OSName="MacOS"; | ||||
if (navigator.appVersion.indexOf("X11")!=-1) OSName="UNIX"; | ||||
if (navigator.appVersion.indexOf("Linux")!=-1) OSName="Linux"; | ||||
|
r16580 | return OSName; | ||
|
r14816 | })(); | ||
|
r19256 | |||
var get_url_param = function (name) { | ||||
// get a URL parameter. I cannot believe we actually need this. | ||||
// Based on http://stackoverflow.com/a/25359264/938949 | ||||
var match = new RegExp('[\?&]' + name + '=([^&]*)').exec(window.location.search); | ||||
if (match){ | ||||
return decodeURIComponent(match[1] || ''); | ||||
} | ||||
}; | ||||
|
r14033 | var is_or_has = function (a, b) { | ||
|
r19176 | /** | ||
* Is b a child of a or a itself? | ||||
*/ | ||||
|
r14033 | return a.has(b).length !==0 || a.is(b); | ||
|
r16580 | }; | ||
|
r14033 | |||
var is_focused = function (e) { | ||||
|
r19176 | /** | ||
* Is element e, or one of its children focused? | ||||
*/ | ||||
|
r14033 | e = $(e); | ||
var target = $(document.activeElement); | ||||
if (target.length > 0) { | ||||
if (is_or_has(e, target)) { | ||||
return true; | ||||
} else { | ||||
return false; | ||||
} | ||||
} else { | ||||
return false; | ||||
} | ||||
|
r16580 | }; | ||
|
r16445 | |||
|
r17764 | var mergeopt = function(_class, options, overwrite){ | ||
options = options || {}; | ||||
overwrite = overwrite || {}; | ||||
return $.extend(true, {}, _class.options_default, options, overwrite); | ||||
}; | ||||
|
r17642 | var ajax_error_msg = function (jqXHR) { | ||
|
r19176 | /** | ||
* Return a JSON error message if there is one, | ||||
* otherwise the basic HTTP status text. | ||||
*/ | ||||
|
r18214 | if (jqXHR.responseJSON && jqXHR.responseJSON.traceback) { | ||
return jqXHR.responseJSON.traceback; | ||||
} else if (jqXHR.responseJSON && jqXHR.responseJSON.message) { | ||||
|
r17642 | return jqXHR.responseJSON.message; | ||
} else { | ||||
return jqXHR.statusText; | ||||
} | ||||
|
r18214 | }; | ||
|
r16445 | var log_ajax_error = function (jqXHR, status, error) { | ||
|
r19176 | /** | ||
* log ajax failures with informative messages | ||||
*/ | ||||
|
r16445 | var msg = "API request failed (" + jqXHR.status + "): "; | ||
console.log(jqXHR); | ||||
|
r17642 | msg += ajax_error_msg(jqXHR); | ||
|
r16445 | console.log(msg); | ||
}; | ||||
|
r18286 | |||
var requireCodeMirrorMode = function (mode, callback, errback) { | ||||
|
r19176 | /** | ||
* load a mode with requirejs | ||||
*/ | ||||
|
r18286 | if (typeof mode != "string") mode = mode.name; | ||
if (CodeMirror.modes.hasOwnProperty(mode)) { | ||||
callback(CodeMirror.modes.mode); | ||||
return; | ||||
} | ||||
require([ | ||||
|
r18288 | // might want to use CodeMirror.modeURL here | ||
|
r18286 | ['codemirror/mode', mode, mode].join('/'), | ||
], callback, errback | ||||
); | ||||
}; | ||||
|
r18329 | |||
|
r18661 | /** Error type for wrapped XHR errors. */ | ||
var XHR_ERROR = 'XhrError'; | ||||
/** | ||||
* Wraps an AJAX error as an Error object. | ||||
*/ | ||||
var wrap_ajax_error = function (jqXHR, status, error) { | ||||
var wrapped_error = new Error(ajax_error_msg(jqXHR)); | ||||
wrapped_error.name = XHR_ERROR; | ||||
// provide xhr response | ||||
wrapped_error.xhr = jqXHR; | ||||
wrapped_error.xhr_status = status; | ||||
wrapped_error.xhr_error = error; | ||||
return wrapped_error; | ||||
|
r18752 | }; | ||
|
r18661 | |||
|
r18826 | var promising_ajax = function(url, settings) { | ||
|
r19176 | /** | ||
* Like $.ajax, but returning an ES6 promise. success and error settings | ||||
* will be ignored. | ||||
*/ | ||||
|
r19259 | settings = settings || {}; | ||
|
r18826 | return new Promise(function(resolve, reject) { | ||
settings.success = function(data, status, jqXHR) { | ||||
resolve(data); | ||||
|
r18834 | }; | ||
|
r18826 | settings.error = function(jqXHR, status, error) { | ||
log_ajax_error(jqXHR, status, error); | ||||
reject(wrap_ajax_error(jqXHR, status, error)); | ||||
|
r18834 | }; | ||
|
r18826 | $.ajax(url, settings); | ||
}); | ||||
}; | ||||
|
r18882 | |||
|
r18897 | var WrappedError = function(message, error){ | ||
|
r19176 | /** | ||
* Wrappable Error class | ||||
* | ||||
* The Error class doesn't actually act on `this`. Instead it always | ||||
* returns a new instance of Error. Here we capture that instance so we | ||||
* can apply it's properties to `this`. | ||||
*/ | ||||
|
r18897 | var tmp = Error.apply(this, [message]); | ||
// Copy the properties of the error over to this. | ||||
var properties = Object.getOwnPropertyNames(tmp); | ||||
for (var i = 0; i < properties.length; i++) { | ||||
this[properties[i]] = tmp[properties[i]]; | ||||
} | ||||
// Keep a stack of the original error messages. | ||||
if (error instanceof WrappedError) { | ||||
this.error_stack = error.error_stack; | ||||
} else { | ||||
this.error_stack = [error]; | ||||
} | ||||
this.error_stack.push(tmp); | ||||
return this; | ||||
}; | ||||
WrappedError.prototype = Object.create(Error.prototype, {}); | ||||
|
r18895 | var load_class = function(class_name, module_name, registry) { | ||
|
r19176 | /** | ||
* Tries to load a class | ||||
* | ||||
* Tries to load a class from a module using require.js, if a module | ||||
* is specified, otherwise tries to load a class from the global | ||||
* registry, if the global registry is provided. | ||||
*/ | ||||
|
r18907 | return new Promise(function(resolve, reject) { | ||
|
r18882 | |||
// Try loading the view module using require.js | ||||
if (module_name) { | ||||
require([module_name], function(module) { | ||||
if (module[class_name] === undefined) { | ||||
|
r18895 | reject(new Error('Class '+class_name+' not found in module '+module_name)); | ||
|
r18882 | } else { | ||
resolve(module[class_name]); | ||||
} | ||||
}, reject); | ||||
} else { | ||||
if (registry && registry[class_name]) { | ||||
resolve(registry[class_name]); | ||||
} else { | ||||
|
r18902 | reject(new Error('Class '+class_name+' not found in registry ')); | ||
|
r18882 | } | ||
} | ||||
}); | ||||
}; | ||||
|
r18887 | |||
|
r18935 | var resolve_promises_dict = function(d) { | ||
|
r19176 | /** | ||
* Resolve a promiseful dictionary. | ||||
* Returns a single Promise. | ||||
*/ | ||||
|
r18888 | var keys = Object.keys(d); | ||
var values = []; | ||||
keys.forEach(function(key) { | ||||
|
r18891 | values.push(d[key]); | ||
|
r18888 | }); | ||
|
r18907 | return Promise.all(values).then(function(v) { | ||
|
r18888 | d = {}; | ||
for(var i=0; i<keys.length; i++) { | ||||
d[keys[i]] = v[i]; | ||||
} | ||||
return d; | ||||
}); | ||||
}; | ||||
|
r18895 | var WrappedError = function(message, error){ | ||
|
r19176 | /** | ||
* Wrappable Error class | ||||
* | ||||
* The Error class doesn't actually act on `this`. Instead it always | ||||
* returns a new instance of Error. Here we capture that instance so we | ||||
* can apply it's properties to `this`. | ||||
*/ | ||||
|
r18895 | var tmp = Error.apply(this, [message]); | ||
// Copy the properties of the error over to this. | ||||
var properties = Object.getOwnPropertyNames(tmp); | ||||
for (var i = 0; i < properties.length; i++) { | ||||
this[properties[i]] = tmp[properties[i]]; | ||||
} | ||||
// Keep a stack of the original error messages. | ||||
if (error instanceof WrappedError) { | ||||
this.error_stack = error.error_stack; | ||||
} else { | ||||
this.error_stack = [error]; | ||||
} | ||||
this.error_stack.push(tmp); | ||||
return this; | ||||
}; | ||||
WrappedError.prototype = Object.create(Error.prototype, {}); | ||||
var reject = function(message, log) { | ||||
|
r19176 | /** | ||
* Creates a wrappable Promise rejection function. | ||||
* | ||||
* Creates a function that returns a Promise.reject with a new WrappedError | ||||
* that has the provided message and wraps the original error that | ||||
* caused the promise to reject. | ||||
*/ | ||||
|
r18895 | return function(error) { | ||
var wrapped_error = new WrappedError(message, error); | ||||
if (log) console.error(wrapped_error); | ||||
|
r18907 | return Promise.reject(wrapped_error); | ||
|
r18895 | }; | ||
}; | ||||
|
r19235 | var typeset = function(element, text) { | ||
/** | ||||
* Apply MathJax rendering to an element, and optionally set its text | ||||
* | ||||
* If MathJax is not available, make no changes. | ||||
* | ||||
* Returns the output any number of typeset elements, or undefined if | ||||
* MathJax was not available. | ||||
* | ||||
* Parameters | ||||
* ---------- | ||||
* element: Node, NodeList, or jQuery selection | ||||
* text: option string | ||||
*/ | ||||
if(!window.MathJax){ | ||||
return; | ||||
} | ||||
var $el = element.jquery ? element : $(element); | ||||
if(arguments.length > 1){ | ||||
$el.text(text); | ||||
} | ||||
return $el.map(function(){ | ||||
// MathJax takes a DOM node: $.map makes `this` the context | ||||
return MathJax.Hub.Queue(["Typeset", MathJax.Hub, this]); | ||||
}); | ||||
}; | ||||
|
r17204 | var utils = { | ||
|
r8565 | regex_split : regex_split, | ||
|
r4352 | uuid : uuid, | ||
|
r4361 | fixConsole : fixConsole, | ||
|
r7357 | fixCarriageReturn : fixCarriageReturn, | ||
|
r8528 | autoLinkUrls : autoLinkUrls, | ||
|
r9227 | points_to_pixels : points_to_pixels, | ||
|
r15240 | get_body_data : get_body_data, | ||
|
r15241 | parse_url : parse_url, | ||
|
r18752 | url_path_split : url_path_split, | ||
|
r13063 | url_path_join : url_path_join, | ||
|
r13686 | url_join_encode : url_join_encode, | ||
encode_uri_components : encode_uri_components, | ||||
|
r13120 | splitext : splitext, | ||
|
r15331 | escape_html : escape_html, | ||
|
r13206 | always_new : always_new, | ||
|
r16588 | to_absolute_cursor_pos : to_absolute_cursor_pos, | ||
from_absolute_cursor_pos : from_absolute_cursor_pos, | ||||
|
r14033 | browser : browser, | ||
|
r14816 | platform: platform, | ||
|
r19256 | get_url_param: get_url_param, | ||
|
r14033 | is_or_has : is_or_has, | ||
|
r16445 | is_focused : is_focused, | ||
|
r17764 | mergeopt: mergeopt, | ||
|
r17642 | ajax_error_msg : ajax_error_msg, | ||
|
r16445 | log_ajax_error : log_ajax_error, | ||
|
r18286 | requireCodeMirrorMode : requireCodeMirrorMode, | ||
|
r18661 | XHR_ERROR : XHR_ERROR, | ||
|
r18826 | wrap_ajax_error : wrap_ajax_error, | ||
promising_ajax : promising_ajax, | ||||
|
r18897 | WrappedError: WrappedError, | ||
|
r18895 | load_class: load_class, | ||
|
r18935 | resolve_promises_dict: resolve_promises_dict, | ||
|
r18895 | reject: reject, | ||
|
r19235 | typeset: typeset, | ||
|
r5479 | }; | ||
|
r4352 | |||
|
r17196 | // Backwards compatability. | ||
|
r17214 | IPython.utils = utils; | ||
|
r17196 | |||
|
r17204 | return utils; | ||
|
r17188 | }); | ||