prism-rails 1.6.0.3 → 1.29.0

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

@@ -1,151 +1,303 @@
-(function() {
-	if ( !self.Prism || !self.document || !document.querySelectorAll || ![].filter) return;
+(function () {
 
+	if (typeof Prism === 'undefined' || typeof document === 'undefined') {
+		return;
+	}
+
+	/**
+	 * @callback Adapter
+	 * @param {any} response
+	 * @param {HTMLPreElement} [pre]
+	 * @returns {string | null}
+	 */
+
+	/**
+	 * The list of adapter which will be used if `data-adapter` is not specified.
+	 *
+	 * @type {Array<{adapter: Adapter, name: string}>}
+	 */
 	var adapters = [];
-	function registerAdapter(adapter) {
-		if (typeof adapter === "function" && !getAdapter(adapter)) {
-			adapters.push(adapter);
+
+	/**
+	 * Adds a new function to the list of adapters.
+	 *
+	 * If the given adapter is already registered or not a function or there is an adapter with the given name already,
+	 * nothing will happen.
+	 *
+	 * @param {Adapter} adapter The adapter to be registered.
+	 * @param {string} [name] The name of the adapter. Defaults to the function name of `adapter`.
+	 */
+	function registerAdapter(adapter, name) {
+		name = name || adapter.name;
+		if (typeof adapter === 'function' && !getAdapter(adapter) && !getAdapter(name)) {
+			adapters.push({ adapter: adapter, name: name });
 		}
 	}
+	/**
+	 * Returns the given adapter itself, if registered, or a registered adapter with the given name.
+	 *
+	 * If no fitting adapter is registered, `null` will be returned.
+	 *
+	 * @param {string|Function} adapter The adapter itself or the name of an adapter.
+	 * @returns {Adapter} A registered adapter or `null`.
+	 */
 	function getAdapter(adapter) {
-		if (typeof adapter === "function") {
-			return adapters.filter(function(fn) { return fn.valueOf() === adapter.valueOf()})[0];
-		}
-		else if (typeof adapter === "string" && adapter.length > 0) {
-			return adapters.filter(function(fn) { return fn.name === adapter})[0];
+		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') {
+			// eslint-disable-next-line no-redeclare
+			for (var i = 0, item; (item = adapters[i++]);) {
+				if (item.name === adapter) {
+					return item.adapter;
+				}
+			}
 		}
 		return null;
 	}
+	/**
+	 * Remove the given adapter or the first registered adapter with the given name from the list of
+	 * registered adapters.
+	 *
+	 * @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.indexOf(adapter);
-			if (index >=0) {
-				adapters.splice(index,1);
+		}
+		if (typeof adapter === 'function') {
+			var index = adapters.findIndex(function (item) {
+				return item.adapter === adapter;
+			});
+			if (index >= 0) {
+				adapters.splice(index, 1);
 			}
 		}
 	}
 
-	Prism.plugins.jsonphighlight = {
-		registerAdapter: registerAdapter,
-		removeAdapter: removeAdapter,
-		highlight: highlight
-	};
-	registerAdapter(function github(rsp, el) {
-		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";
+	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 null;
-	});
+	}, 'github');
 	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 );
+		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);
 			}
-			else {
-				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,
-					// so that might be getting beyond the scope of this plugin
-					for (var key in rsp.data.files) {
-						if (rsp.data.files.hasOwnProperty(key)) {
-							filename = key;
-							break;
-						}
+
+			var files = rsp.data.files;
+			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,
+				// so that might be getting beyond the scope of this plugin
+				for (var key in files) {
+					if (files.hasOwnProperty(key)) {
+						filename = key;
+						break;
 					}
 				}
-				if (rsp.data.files[filename] !== undefined) {
-					return rsp.data.files[filename].content;
-				}
-				else {
-					return "Error: unknown or missing gist file " + filename;
-				}
 			}
+
+			if (files[filename] !== undefined) {
+				return files[filename].content;
+			}
+			return 'Error: unknown or missing gist file ' + filename;
 		}
 		return null;
+	}, 'gist');
+	registerAdapter(function bitbucket(rsp) {
+		if (rsp && rsp.node && typeof (rsp.data) === 'string') {
+			return rsp.data;
+		}
+		return null;
+	}, 'bitbucket');
+
+
+	var jsonpCallbackCounter = 0;
+	/**
+	 * 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 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;
 	});
-	registerAdapter(function bitbucket(rsp, el) {
-		return rsp && rsp.node && typeof(rsp.data) === "string"
-			? rsp.data
-			: null;
-	});
 
-	var jsonpcb = 0,
-	    loadstr = "Loading…";
+	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
+
+			// mark as loading
+			pre.setAttribute(STATUS_ATTR, STATUS_LOADING);
 
-	function highlight() {
-		Array.prototype.slice.call(document.querySelectorAll("pre[data-jsonp]")).forEach(function(pre) {
-			pre.textContent = "";
+			// add code element with loading message
+			var code = pre.appendChild(document.createElement('CODE'));
+			code.textContent = LOADING_MESSAGE;
 
-			var code = document.createElement("code");
-			code.textContent = loadstr;
-			pre.appendChild(code);
+			// set language
+			var language = env.language;
+			code.className = 'language-' + language;
 
-			var adapterfn = pre.getAttribute("data-adapter");
+			// preload the language
+			var autoloader = Prism.plugins.autoloader;
+			if (autoloader) {
+				autoloader.loadLanguages(language);
+			}
+
+			var adapterName = pre.getAttribute('data-adapter');
 			var adapter = null;
-			if ( adapterfn ) {
-				if ( typeof(window[adapterfn]) === "function" ) {
-					adapter = window[adapterfn];
-				}
-				else {
-					code.textContent = "JSONP adapter function '" + adapterfn + "' doesn't exist";
+			if (adapterName) {
+				if (typeof window[adapterName] === 'function') {
+					adapter = window[adapterName];
+				} else {
+					// mark as failed
+					pre.setAttribute(STATUS_ATTR, STATUS_FAILED);
+
+					code.textContent = MISSING_ADAPTER_MESSAGE(adapterName);
 					return;
 				}
 			}
 
-			var cb = "prismjsonp" + ( jsonpcb++ );
-			
-			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 === loadstr )
-					code.textContent = "Timeout loading '" + src + "'";
-			}, 5000);
-			
-			var script = document.createElement("script");
-			script.src = uri.href;
-
-			window[cb] = function(rsp) {
-				document.head.removeChild(script);
-				clearTimeout(timeout);
-				delete window[cb];
-
-				var data = "";
-				
-				if ( adapter ) {
-					data = adapter(rsp, pre);
-				}
-				else {
-					for ( var p in adapters ) {
-						data = adapters[p](rsp, pre);
-						if ( data !== null ) break;
+			var src = pre.getAttribute('data-jsonp');
+
+			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;
+							}
+						}
 					}
-				}
 
-				if (data === null) {
-					code.textContent = "Cannot parse response (perhaps you need an adapter function?)";
-				}
-				else {
-					code.textContent = data;
-					Prism.highlightElement(code);
+					if (data === null) {
+						// mark as failed
+						pre.setAttribute(STATUS_ATTR, STATUS_FAILED);
+
+						code.textContent = UNKNOWN_FAILURE_MESSAGE;
+					} else {
+						// mark as loaded
+						pre.setAttribute(STATUS_ATTR, STATUS_LOADED);
+
+						code.textContent = data;
+						Prism.highlightElement(code);
+					}
+				},
+				function () {
+					// mark as failed
+					pre.setAttribute(STATUS_ATTR, STATUS_FAILED);
+
+					code.textContent = TIMEOUT_MESSAGE(src);
 				}
-			};
+			);
+		}
+	});
 
-			document.head.appendChild(script);
-		});
-	}
 
-	highlight();
-})();
+	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,
+
+		/**
+		 * 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);
+			}
+		}
+	};
+
+}());

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

@@ -1,6 +1,6 @@
 (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
@@ -92,6 +119,8 @@
 					pos: 0
 				});
 			});
+			// Store new highlightedCode for later hooks calls
+			env.highlightedCode = env.element.innerHTML;
 		}
 	});
 }());