prism-rails 1.19.0 → 1.29.0

data/vendor/assets/javascripts/prism-plugin/prism-jsonp-highlight.js

@@ -1,17 +1,20 @@
 (function () {
-	if (!self.Prism || !self.document || !document.querySelectorAll || ![].filter) return;
+
+	if (typeof Prism === 'undefined' || typeof document === 'undefined') {
+		return;
+	}
 
 	/**
 	 * @callback Adapter
 	 * @param {any} response
 	 * @param {HTMLPreElement} [pre]
-	 * @returns {string}
+	 * @returns {string | null}
 	 */
 
 	/**
 	 * The list of adapter which will be used if `data-adapter` is not specified.
 	 *
-	 * @type {Array.<{adapter: Adapter, name: string}>}
+	 * @type {Array<{adapter: Adapter, name: string}>}
 	 */
 	var adapters = [];
 
@@ -26,7 +29,7 @@
 	 */
 	function registerAdapter(adapter, name) {
 		name = name || adapter.name;
-		if (typeof adapter === "function" && !getAdapter(adapter) && !getAdapter(name)) {
+		if (typeof adapter === 'function' && !getAdapter(adapter) && !getAdapter(name)) {
 			adapters.push({ adapter: adapter, name: name });
 		}
 	}
@@ -39,15 +42,15 @@
 	 * @returns {Adapter} A registered adapter or `null`.
 	 */
 	function getAdapter(adapter) {
-		if (typeof adapter === "function") {
-			for (var i = 0, item; item = adapters[i++];) {
+		if (typeof adapter === 'function') {
+			for (var i = 0, item; (item = adapters[i++]);) {
 				if (item.adapter.valueOf() === adapter.valueOf()) {
 					return item.adapter;
 				}
 			}
-		}
-		else if (typeof adapter === "string") {
-			for (var i = 0, item; item = adapters[i++];) {
+		} else if (typeof adapter === 'string') {
+			// eslint-disable-next-line no-redeclare
+			for (var i = 0, item; (item = adapters[i++]);) {
 				if (item.name === adapter) {
 					return item.adapter;
 				}
@@ -62,26 +65,27 @@
 	 * @param {string|Function} adapter The adapter itself or the name of an adapter.
 	 */
 	function removeAdapter(adapter) {
-		if (typeof adapter === "string") {
+		if (typeof adapter === 'string') {
 			adapter = getAdapter(adapter);
 		}
-		if (typeof adapter === "function") {
-			var index = adapters.map(function (item) { return item.adapter; }).indexOf(adapter);
+		if (typeof adapter === 'function') {
+			var index = adapters.findIndex(function (item) {
+				return item.adapter === adapter;
+			});
 			if (index >= 0) {
 				adapters.splice(index, 1);
 			}
 		}
 	}
 
-	registerAdapter(function github(rsp, el) {
+	registerAdapter(function github(rsp) {
 		if (rsp && rsp.meta && rsp.data) {
 			if (rsp.meta.status && rsp.meta.status >= 400) {
-				return "Error: " + (rsp.data.message || rsp.meta.status);
-			}
-			else if (typeof (rsp.data.content) === "string") {
-				return typeof (atob) === "function"
-					? atob(rsp.data.content.replace(/\s/g, ""))
-					: "Your browser cannot decode base64";
+				return 'Error: ' + (rsp.data.message || rsp.meta.status);
+			} else if (typeof (rsp.data.content) === 'string') {
+				return typeof (atob) === 'function'
+					? atob(rsp.data.content.replace(/\s/g, ''))
+					: 'Your browser cannot decode base64';
 			}
 		}
 		return null;
@@ -89,11 +93,11 @@
 	registerAdapter(function gist(rsp, el) {
 		if (rsp && rsp.meta && rsp.data && rsp.data.files) {
 			if (rsp.meta.status && rsp.meta.status >= 400) {
-				return "Error: " + (rsp.data.message || rsp.meta.status);
+				return 'Error: ' + (rsp.data.message || rsp.meta.status);
 			}
 
 			var files = rsp.data.files;
-			var filename = el.getAttribute("data-filename");
+			var filename = el.getAttribute('data-filename');
 			if (filename == null) {
 				// Maybe in the future we can somehow render all files
 				// But the standard <script> include for gists does that nicely already,
@@ -109,98 +113,191 @@
 			if (files[filename] !== undefined) {
 				return files[filename].content;
 			}
-			return "Error: unknown or missing gist file " + filename;
+			return 'Error: unknown or missing gist file ' + filename;
 		}
 		return null;
 	}, 'gist');
-	registerAdapter(function bitbucket(rsp, el) {
-		if (rsp && rsp.node && typeof (rsp.data) === "string") {
+	registerAdapter(function bitbucket(rsp) {
+		if (rsp && rsp.node && typeof (rsp.data) === 'string') {
 			return rsp.data;
 		}
 		return null;
 	}, 'bitbucket');
 
-	var jsonpcb = 0,
-		loadMsg = "Loading\u2026";
 
+	var jsonpCallbackCounter = 0;
 	/**
-	 * Highlights all `pre` elements with an `data-jsonp` by requesting the specified JSON and using the specified adapter
-	 * or a registered adapter to extract the code to highlight from the response. The highlighted code will be inserted
-	 * into the `pre` element.
+	 * Makes a JSONP request.
+	 *
+	 * @param {string} src The URL of the resource to request.
+	 * @param {string | undefined | null} callbackParameter The name of the callback parameter. If falsy, `"callback"`
+	 * will be used.
+	 * @param {(data: unknown) => void} onSuccess
+	 * @param {(reason: "timeout" | "network") => void} onError
+	 * @returns {void}
 	 */
-	function highlight() {
-		Array.prototype.slice.call(document.querySelectorAll("pre[data-jsonp]")).forEach(function (pre) {
-			pre.textContent = "";
+	function jsonp(src, callbackParameter, onSuccess, onError) {
+		var callbackName = 'prismjsonp' + jsonpCallbackCounter++;
+
+		var uri = document.createElement('a');
+		uri.href = src;
+		uri.href += (uri.search ? '&' : '?') + (callbackParameter || 'callback') + '=' + callbackName;
+
+		var script = document.createElement('script');
+		script.src = uri.href;
+		script.onerror = function () {
+			cleanup();
+			onError('network');
+		};
+
+		var timeoutId = setTimeout(function () {
+			cleanup();
+			onError('timeout');
+		}, Prism.plugins.jsonphighlight.timeout);
+
+		function cleanup() {
+			clearTimeout(timeoutId);
+			document.head.removeChild(script);
+			delete window[callbackName];
+		}
+
+		// the JSONP callback function
+		window[callbackName] = function (response) {
+			cleanup();
+			onSuccess(response);
+		};
+
+		document.head.appendChild(script);
+	}
+
+	var LOADING_MESSAGE = 'Loading…';
+	var MISSING_ADAPTER_MESSAGE = function (name) {
+		return '✖ Error: JSONP adapter function "' + name + '" doesn\'t exist';
+	};
+	var TIMEOUT_MESSAGE = function (url) {
+		return '✖ Error: Timeout loading ' + url;
+	};
+	var UNKNOWN_FAILURE_MESSAGE = '✖ Error: Cannot parse response (perhaps you need an adapter function?)';
+
+	var STATUS_ATTR = 'data-jsonp-status';
+	var STATUS_LOADING = 'loading';
+	var STATUS_LOADED = 'loaded';
+	var STATUS_FAILED = 'failed';
+
+	var SELECTOR = 'pre[data-jsonp]:not([' + STATUS_ATTR + '="' + STATUS_LOADED + '"])'
+		+ ':not([' + STATUS_ATTR + '="' + STATUS_LOADING + '"])';
+
+
+	Prism.hooks.add('before-highlightall', function (env) {
+		env.selector += ', ' + SELECTOR;
+	});
+
+	Prism.hooks.add('before-sanity-check', function (env) {
+		var pre = /** @type {HTMLPreElement} */ (env.element);
+		if (pre.matches(SELECTOR)) {
+			env.code = ''; // fast-path the whole thing and go to complete
 
-			var code = document.createElement("code");
-			code.textContent = loadMsg;
-			pre.appendChild(code);
+			// mark as loading
+			pre.setAttribute(STATUS_ATTR, STATUS_LOADING);
 
-			var adapterName = pre.getAttribute("data-adapter");
+			// add code element with loading message
+			var code = pre.appendChild(document.createElement('CODE'));
+			code.textContent = LOADING_MESSAGE;
+
+			// set language
+			var language = env.language;
+			code.className = 'language-' + language;
+
+			// preload the language
+			var autoloader = Prism.plugins.autoloader;
+			if (autoloader) {
+				autoloader.loadLanguages(language);
+			}
+
+			var adapterName = pre.getAttribute('data-adapter');
 			var adapter = null;
 			if (adapterName) {
-				if (typeof window[adapterName] === "function") {
+				if (typeof window[adapterName] === 'function') {
 					adapter = window[adapterName];
-				}
-				else {
-					code.textContent = "JSONP adapter function '" + adapterName + "' doesn't exist";
+				} else {
+					// mark as failed
+					pre.setAttribute(STATUS_ATTR, STATUS_FAILED);
+
+					code.textContent = MISSING_ADAPTER_MESSAGE(adapterName);
 					return;
 				}
 			}
 
-			var cb = "prismjsonp" + jsonpcb++;
+			var src = pre.getAttribute('data-jsonp');
 
-			var uri = document.createElement("a");
-			var src = uri.href = pre.getAttribute("data-jsonp");
-			uri.href += (uri.search ? "&" : "?") + (pre.getAttribute("data-callback") || "callback") + "=" + cb;
-
-			var timeout = setTimeout(function () {
-				// we could clean up window[cb], but if the request finally succeeds, keeping it around is a good thing
-				if (code.textContent === loadMsg) {
-					code.textContent = "Timeout loading '" + src + "'";
-				}
-			}, 5000);
-
-			var script = document.createElement("script");
-			script.src = uri.href;
+			jsonp(
+				src,
+				pre.getAttribute('data-callback'),
+				function (response) {
+					// interpret the received data using the adapter(s)
+					var data = null;
+					if (adapter) {
+						data = adapter(response, pre);
+					} else {
+						for (var i = 0, l = adapters.length; i < l; i++) {
+							data = adapters[i].adapter(response, pre);
+							if (data !== null) {
+								break;
+							}
+						}
+					}
 
-			window[cb] = function (rsp) {
-				document.head.removeChild(script);
-				clearTimeout(timeout);
-				delete window[cb];
+					if (data === null) {
+						// mark as failed
+						pre.setAttribute(STATUS_ATTR, STATUS_FAILED);
 
-				var data = "";
+						code.textContent = UNKNOWN_FAILURE_MESSAGE;
+					} else {
+						// mark as loaded
+						pre.setAttribute(STATUS_ATTR, STATUS_LOADED);
 
-				if (adapter) {
-					data = adapter(rsp, pre);
-				}
-				else {
-					for (var p in adapters) {
-						data = adapters[p].adapter(rsp, pre);
-						if (data !== null) {
-							break;
-						}
+						code.textContent = data;
+						Prism.highlightElement(code);
 					}
-				}
+				},
+				function () {
+					// mark as failed
+					pre.setAttribute(STATUS_ATTR, STATUS_FAILED);
 
-				if (data === null) {
-					code.textContent = "Cannot parse response (perhaps you need an adapter function?)";
+					code.textContent = TIMEOUT_MESSAGE(src);
 				}
-				else {
-					code.textContent = data;
-					Prism.highlightElement(code);
-				}
-			};
+			);
+		}
+	});
 
-			document.head.appendChild(script);
-		});
-	}
 
 	Prism.plugins.jsonphighlight = {
+		/**
+		 * The timeout after which an error message will be displayed.
+		 *
+		 * __Note:__ If the request succeeds after the timeout, it will still be processed and will override any
+		 * displayed error messages.
+		 */
+		timeout: 5000,
 		registerAdapter: registerAdapter,
 		removeAdapter: removeAdapter,
-		highlight: highlight
+
+		/**
+		 * Highlights all `pre` elements under the given container with a `data-jsonp` attribute by requesting the
+		 * specified JSON and using the specified adapter or a registered adapter to extract the code to highlight
+		 * from the response. The highlighted code will be inserted into the `pre` element.
+		 *
+		 * Note: Elements which are already loaded or currently loading will not be touched by this method.
+		 *
+		 * @param {Element | Document} [container=document]
+		 */
+		highlight: function (container) {
+			var elements = (container || document).querySelectorAll(SELECTOR);
+
+			for (var i = 0, element; (element = elements[i++]);) {
+				Prism.highlightElement(element);
+			}
+		}
 	};
 
-	highlight();
-})();
+}());

data/vendor/assets/javascripts/prism-plugin/prism-keep-markup.js

@@ -1,6 +1,6 @@
-(function (self, document) {
+(function () {
 
-	if (typeof self === 'undefined' || !self.Prism || !self.document || !document.createRange) {
+	if (typeof Prism === 'undefined' || typeof document === 'undefined' || !document.createRange) {
 		return;
 	}
 
@@ -11,38 +11,64 @@
 			return;
 		}
 
+		if (!Prism.util.isActive(env.element, 'keep-markup', true)) {
+			return;
+		}
+
+		var dropTokens = Prism.util.isActive(env.element, 'drop-tokens', false);
+		/**
+		 * Returns whether the given element should be kept.
+		 *
+		 * @param {HTMLElement} element
+		 * @returns {boolean}
+		 */
+		function shouldKeep(element) {
+			if (dropTokens && element.nodeName.toLowerCase() === 'span' && element.classList.contains('token')) {
+				return false;
+			}
+			return true;
+		}
+
 		var pos = 0;
 		var data = [];
-		var f = function (elt, baseNode) {
-			var o = {};
-			if (!baseNode) {
-				// Clone the original tag to keep all attributes
-				o.clone = elt.cloneNode(false);
-				o.posOpen = pos;
-				data.push(o);
+		function processElement(element) {
+			if (!shouldKeep(element)) {
+				// don't keep this element and just process its children
+				processChildren(element);
+				return;
 			}
-			for (var i = 0, l = elt.childNodes.length; i < l; i++) {
-				var child = elt.childNodes[i];
+
+			var o = {
+				// Store original element so we can restore it after highlighting
+				element: element,
+				posOpen: pos
+			};
+			data.push(o);
+
+			processChildren(element);
+
+			o.posClose = pos;
+		}
+		function processChildren(element) {
+			for (var i = 0, l = element.childNodes.length; i < l; i++) {
+				var child = element.childNodes[i];
 				if (child.nodeType === 1) { // element
-					f(child);
-				} else if(child.nodeType === 3) { // text
+					processElement(child);
+				} else if (child.nodeType === 3) { // text
 					pos += child.data.length;
 				}
 			}
-			if (!baseNode) {
-				o.posClose = pos;
-			}
-		};
-		f(env.element, true);
+		}
+		processChildren(env.element);
 
-		if (data && data.length) {
+		if (data.length) {
 			// data is an array of all existing tags
 			env.keepMarkup = data;
 		}
 	});
 
 	Prism.hooks.add('after-highlight', function (env) {
-		if(env.keepMarkup && env.keepMarkup.length) {
+		if (env.keepMarkup && env.keepMarkup.length) {
 
 			var walk = function (elt, nodeState) {
 				for (var i = 0, l = elt.childNodes.length; i < l; i++) {
@@ -55,12 +81,12 @@
 						}
 
 					} else if (child.nodeType === 3) { // text
-						if(!nodeState.nodeStart && nodeState.pos + child.data.length > nodeState.node.posOpen) {
+						if (!nodeState.nodeStart && nodeState.pos + child.data.length > nodeState.node.posOpen) {
 							// We found the start position
 							nodeState.nodeStart = child;
 							nodeState.nodeStartPos = nodeState.node.posOpen - nodeState.pos;
 						}
-						if(nodeState.nodeStart && nodeState.pos + child.data.length >= nodeState.node.posClose) {
+						if (nodeState.nodeStart && nodeState.pos + child.data.length >= nodeState.node.posClose) {
 							// We found the end position
 							nodeState.nodeEnd = child;
 							nodeState.nodeEndPos = nodeState.node.posClose - nodeState.pos;
@@ -70,12 +96,13 @@
 					}
 
 					if (nodeState.nodeStart && nodeState.nodeEnd) {
-						// Select the range and wrap it with the clone
+						// Select the range and wrap it with the element
 						var range = document.createRange();
 						range.setStart(nodeState.nodeStart, nodeState.nodeStartPos);
 						range.setEnd(nodeState.nodeEnd, nodeState.nodeEndPos);
-						nodeState.node.clone.appendChild(range.extractContents());
-						range.insertNode(nodeState.node.clone);
+						nodeState.node.element.innerHTML = '';
+						nodeState.node.element.appendChild(range.extractContents());
+						range.insertNode(nodeState.node.element);
 						range.detach();
 
 						// Process is over
@@ -96,4 +123,4 @@
 			env.highlightedCode = env.element.innerHTML;
 		}
 	});
-}(self, document));
+}());