prism-rails 1.6.0.3 → 1.19.0

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

@@ -3,7 +3,11 @@
 		return;
 	}
 
-	self.Prism.fileHighlight = function() {
+	/**
+	 * @param {Element} [container=document]
+	 */
+	self.Prism.fileHighlight = function(container) {
+		container = container || document;
 
 		var Extensions = {
 			'js': 'javascript',
@@ -17,61 +21,69 @@
 			'tex': 'latex'
 		};
 
-		if(Array.prototype.forEach) { // Check to prevent error in IE8
-			Array.prototype.slice.call(document.querySelectorAll('pre[data-src]')).forEach(function (pre) {
-				var src = pre.getAttribute('data-src');
+		Array.prototype.slice.call(container.querySelectorAll('pre[data-src]')).forEach(function (pre) {
+			// ignore if already loaded
+			if (pre.hasAttribute('data-src-loaded')) {
+				return;
+			}
 
-				var language, parent = pre;
-				var lang = /\blang(?:uage)?-(?!\*)(\w+)\b/i;
-				while (parent && !lang.test(parent.className)) {
-					parent = parent.parentNode;
-				}
+			// load current
+			var src = pre.getAttribute('data-src');
 
-				if (parent) {
-					language = (pre.className.match(lang) || [, ''])[1];
-				}
+			var language, parent = pre;
+			var lang = /\blang(?:uage)?-([\w-]+)\b/i;
+			while (parent && !lang.test(parent.className)) {
+				parent = parent.parentNode;
+			}
 
-				if (!language) {
-					var extension = (src.match(/\.(\w+)$/) || [, ''])[1];
-					language = Extensions[extension] || extension;
-				}
+			if (parent) {
+				language = (pre.className.match(lang) || [, ''])[1];
+			}
 
-				var code = document.createElement('code');
-				code.className = 'language-' + language;
+			if (!language) {
+				var extension = (src.match(/\.(\w+)$/) || [, ''])[1];
+				language = Extensions[extension] || extension;
+			}
 
-				pre.textContent = '';
+			var code = document.createElement('code');
+			code.className = 'language-' + language;
 
-				code.textContent = 'Loading…';
+			pre.textContent = '';
 
-				pre.appendChild(code);
+			code.textContent = 'Loading…';
 
-				var xhr = new XMLHttpRequest();
+			pre.appendChild(code);
 
-				xhr.open('GET', src, true);
+			var xhr = new XMLHttpRequest();
 
-				xhr.onreadystatechange = function () {
-					if (xhr.readyState == 4) {
+			xhr.open('GET', src, true);
 
-						if (xhr.status < 400 && xhr.responseText) {
-							code.textContent = xhr.responseText;
+			xhr.onreadystatechange = function () {
+				if (xhr.readyState == 4) {
 
-							Prism.highlightElement(code);
-						}
-						else if (xhr.status >= 400) {
-							code.textContent = '✖ Error ' + xhr.status + ' while fetching file: ' + xhr.statusText;
-						}
-						else {
-							code.textContent = '✖ Error: File does not exist or is empty';
-						}
-					}
-				};
+					if (xhr.status < 400 && xhr.responseText) {
+						code.textContent = xhr.responseText;
 
-				xhr.send(null);
-			});
-		}
+						Prism.highlightElement(code);
+						// mark as loaded
+						pre.setAttribute('data-src-loaded', '');
+					}
+					else if (xhr.status >= 400) {
+						code.textContent = '✖ Error ' + xhr.status + ' while fetching file: ' + xhr.statusText;
+					}
+					else {
+						code.textContent = '✖ Error: File does not exist or is empty';
+					}
+				}
+			};
 
+			xhr.send(null);
+		});
 	};
 
-	document.addEventListener('DOMContentLoaded', self.Prism.fileHighlight);
+	document.addEventListener('DOMContentLoaded', function () {
+		// execute inside handler, for dropping Event as argument
+		self.Prism.fileHighlight();
+	});
 
 })();

data/vendor/assets/javascripts/prism-plugin/prism-filter-highlight-all.js

@@ -0,0 +1,125 @@
+(function () {
+
+	if (typeof self !== 'undefined' && !self.Prism) {
+		return;
+	}
+
+	// https://developer.mozilla.org/en-US/docs/Web/API/Element/matches#Polyfill
+	if (!Element.prototype.matches) {
+		Element.prototype.matches = Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
+	}
+
+	var script = Prism.util.currentScript();
+
+
+	/**
+	 * @type {Array<(element: HTMLElement) => boolean>}
+	 */
+	var filters = [];
+
+	var config = Prism.plugins.filterHighlightAll = {
+
+		/**
+		 * Adds a new filter for the elements of `highlightAll` and `highlightAllUnder` such that only elements for
+		 * which the given function returns `true` will be highlighted.
+		 *
+		 * @param {(value: { element: HTMLElement, language: string }) => boolean} condition
+		 */
+		add: function (condition) {
+			filters.push(function (element) {
+				return condition({
+					element: element,
+					language: Prism.util.getLanguage(element)
+				});
+			});
+		},
+
+		/**
+		 * Adds a new filter for the elements of `highlightAll` and `highlightAllUnder` such that only elements that
+		 * match the given CSS selection will be highlighted.
+		 *
+		 * @param {string} selector
+		 */
+		addSelector: function (selector) {
+			filters.push(function (element) {
+				return element.matches(selector);
+			});
+		},
+
+		reject: {
+
+			/**
+			 * Adds a new filter for the elements of `highlightAll` and `highlightAllUnder` such that only elements for
+			 * which the given function returns `false` will be highlighted.
+			 *
+			 * @param {(value: { element: HTMLElement, language: string }) => boolean} condition
+			 */
+			add: function (condition) {
+				filters.push(function (element) {
+					return !condition({
+						element: element,
+						language: Prism.util.getLanguage(element)
+					});
+				});
+			},
+
+			/**
+			 * Adds a new filter for the elements of `highlightAll` and `highlightAllUnder` such that only elements that do
+			 * not match the given CSS selection will be highlighted.
+			 *
+			 * @param {string} selector
+			 */
+			addSelector: function (selector) {
+				filters.push(function (element) {
+					return !element.matches(selector);
+				});
+			},
+
+		},
+
+		/**
+		 * Filters the elements of `highlightAll` and `highlightAllUnder` such that only elements with a known language
+		 * will be highlighted. All elements with an unset or unknown language will be ignored.
+		 *
+		 * __Note:__ This will effectively disable the AutoLoader plugin.
+		 *
+		 * @type {boolean}
+		 */
+		filterKnown: !!script && script.hasAttribute('data-filter-known')
+	};
+
+	config.add(function filterKnown(env) {
+		return !config.filterKnown || typeof Prism.languages[env.language] === 'object';
+	});
+
+	if (script) {
+		var attr;
+		if (attr = script.getAttribute('data-filter-selector')) {
+			config.addSelector(attr);
+		}
+		if (attr = script.getAttribute('data-reject-selector')) {
+			config.reject.addSelector(attr);
+		}
+	}
+
+	/**
+	 * Applies all filters to the given element and returns true if and only if every filter returned true on the
+	 * given element.
+	 *
+	 * @param {HTMLElement} element
+	 * @returns {boolean}
+	 */
+	function combinedFilter(element) {
+		for (var i = 0, l = filters.length; i < l; i++) {
+			if (!filters[i](element)) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	Prism.hooks.add('before-all-elements-highlight', function (env) {
+		env.elements = env.elements.filter(combinedFilter);
+	});
+
+}());

data/vendor/assets/javascripts/prism-plugin/prism-inline-color.js

@@ -0,0 +1,88 @@
+(function () {
+
+	if (typeof self === 'undefined' || typeof Prism === 'undefined' || typeof document === 'undefined') {
+		return;
+	}
+
+	// Copied from the markup language definition
+	var HTML_TAG = /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/g;
+
+	// the regex explained: In first lookahead we check whether the string is valid and then we use the
+	// capturing groups to split the string into its components.
+	var HEX_COLOR = /^#?(?=(?:[\da-f]{1,2}){3,4}$)([\da-f][\da-f]?)([\da-f][\da-f]?)([\da-f][\da-f]?)([\da-f][\da-f]?)?$/i;
+
+	/**
+	 * Parses the given hexadecimal representation and returns the parsed RGBA color.
+	 *
+	 * If the format of the given string is invalid, `undefined` will be returned.
+	 * Valid formats are: `RGB`, `RGBA`, `RRGGBB`, and `RRGGBBAA`.
+	 *
+	 * @param {string} hex
+	 * @returns {string | undefined}
+	 */
+	function parseHexColor(hex) {
+		var match = HEX_COLOR.exec(hex);
+		if (!match) {
+			return undefined;
+		}
+
+		// This is used to scale normalize 4bit and 8bit values
+		var scale = hex.length <= 4 ? 1 / 15 : 1 / 255;
+
+		var rgb = match.slice(1, 4).map(function (c) {
+			return String(Math.round(parseInt(c, 16) * scale * 255));
+		}).join(',');
+
+		var alpha = match[4] === undefined ? '1' : (parseInt(match[4], 16) * scale).toFixed(3);
+
+		return 'rgba(' + rgb + ',' + alpha + ')';
+	}
+
+	/**
+	 * Validates the given Color using the current browser's internal implementation.
+	 *
+	 * @param {string} color
+	 * @returns {string | undefined}
+	 */
+	function validateColor(color) {
+		var s = new Option().style;
+		s.color = color;
+		return s.color ? color : undefined;
+	}
+
+	/**
+	 * An array of function which parse a given string representation of a color.
+	 *
+	 * These parser serve as validators and as a layer of compatibility to support color formats which the browser
+	 * might not support natively.
+	 *
+	 * @type {((value: string) => (string|undefined))[]}
+	 */
+	var parsers = [
+		parseHexColor,
+		validateColor
+	];
+
+
+	Prism.hooks.add('wrap', function (env) {
+		if (env.type === 'color' || env.type === 'hexcode') {
+			var content = env.content;
+
+			// remove all HTML tags inside
+			var rawText = content.split(HTML_TAG).join('');
+
+			var color;
+			for (var i = 0, l = parsers.length; i < l && !color; i++) {
+				color = parsers[i](rawText);
+			}
+
+			if (!color) {
+				return;
+			}
+
+			var previewElement = '<span class="inline-color" style="background-color:' + color + ';"></span>';
+			env.content = previewElement + content;
+		}
+	});
+
+}());

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

@@ -1,136 +1,185 @@
-(function() {
-	if ( !self.Prism || !self.document || !document.querySelectorAll || ![].filter) return;
+(function () {
+	if (!self.Prism || !self.document || !document.querySelectorAll || ![].filter) return;
 
+	/**
+	 * @callback Adapter
+	 * @param {any} response
+	 * @param {HTMLPreElement} [pre]
+	 * @returns {string}
+	 */
+
+	/**
+	 * 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];
+			for (var i = 0, item; item = adapters[i++];) {
+				if (item.adapter.valueOf() === adapter.valueOf()) {
+					return item.adapter;
+				}
+			}
 		}
-		else if (typeof adapter === "string" && adapter.length > 0) {
-			return adapters.filter(function(fn) { return fn.name === adapter})[0];
+		else if (typeof adapter === "string") {
+			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);
+			var index = adapters.map(function (item) { return item.adapter; }).indexOf(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 );
+		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"
+			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, el) {
-		return rsp && rsp.node && typeof(rsp.data) === "string"
-			? rsp.data
-			: null;
-	});
+		if (rsp && rsp.node && typeof (rsp.data) === "string") {
+			return rsp.data;
+		}
+		return null;
+	}, 'bitbucket');
 
 	var jsonpcb = 0,
-	    loadstr = "Loading…";
+		loadMsg = "Loading\u2026";
 
+	/**
+	 * 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.
+	 */
 	function highlight() {
-		Array.prototype.slice.call(document.querySelectorAll("pre[data-jsonp]")).forEach(function(pre) {
+		Array.prototype.slice.call(document.querySelectorAll("pre[data-jsonp]")).forEach(function (pre) {
 			pre.textContent = "";
 
 			var code = document.createElement("code");
-			code.textContent = loadstr;
+			code.textContent = loadMsg;
 			pre.appendChild(code);
 
-			var adapterfn = pre.getAttribute("data-adapter");
+			var adapterName = pre.getAttribute("data-adapter");
 			var adapter = null;
-			if ( adapterfn ) {
-				if ( typeof(window[adapterfn]) === "function" ) {
-					adapter = window[adapterfn];
+			if (adapterName) {
+				if (typeof window[adapterName] === "function") {
+					adapter = window[adapterName];
 				}
 				else {
-					code.textContent = "JSONP adapter function '" + adapterfn + "' doesn't exist";
+					code.textContent = "JSONP adapter function '" + adapterName + "' doesn't exist";
 					return;
 				}
 			}
 
-			var cb = "prismjsonp" + ( jsonpcb++ );
-			
+			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;
+			uri.href += (uri.search ? "&" : "?") + (pre.getAttribute("data-callback") || "callback") + "=" + cb;
 
-			var timeout = setTimeout(function() {
+			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 )
+				if (code.textContent === loadMsg) {
 					code.textContent = "Timeout loading '" + src + "'";
+				}
 			}, 5000);
-			
+
 			var script = document.createElement("script");
 			script.src = uri.href;
 
-			window[cb] = function(rsp) {
+			window[cb] = function (rsp) {
 				document.head.removeChild(script);
 				clearTimeout(timeout);
 				delete window[cb];
 
 				var data = "";
-				
-				if ( adapter ) {
+
+				if (adapter) {
 					data = adapter(rsp, pre);
 				}
 				else {
-					for ( var p in adapters ) {
-						data = adapters[p](rsp, pre);
-						if ( data !== null ) break;
+					for (var p in adapters) {
+						data = adapters[p].adapter(rsp, pre);
+						if (data !== null) {
+							break;
+						}
 					}
 				}
 
@@ -147,5 +196,11 @@
 		});
 	}
 
+	Prism.plugins.jsonphighlight = {
+		registerAdapter: registerAdapter,
+		removeAdapter: removeAdapter,
+		highlight: highlight
+	};
+
 	highlight();
-})();
+})();