spiderfw 0.6.38 → 0.6.39

data/apps/core/components/public/js/tinymce/classes/util/Tools.js

@@ -0,0 +1,442 @@
+/**
+ * Tools.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class contains various utlity functions. These are also exposed
+ * directly on the tinymce namespace.
+ *
+ * @class tinymce.util.Tools
+ */
+define("tinymce/util/Tools", [
+	"tinymce/Env",
+	"tinymce/util/Arr"
+], function(Env, Arr) {
+	/**
+	 * Removes whitespace from the beginning and end of a string.
+	 *
+	 * @method trim
+	 * @param {String} s String to remove whitespace from.
+	 * @return {String} New string with removed whitespace.
+	 */
+	var whiteSpaceRegExp = /^\s*|\s*$/g;
+
+	function trim(str) {
+		return (str === null || str === undefined) ? '' : ("" + str).replace(whiteSpaceRegExp, '');
+	}
+
+	/**
+	 * Checks if a object is of a specific type for example an array.
+	 *
+	 * @method is
+	 * @param {Object} obj Object to check type of.
+	 * @param {string} type Optional type to check for.
+	 * @return {Boolean} true/false if the object is of the specified type.
+	 */
+	function is(obj, type) {
+		if (!type) {
+			return obj !== undefined;
+		}
+
+		if (type == 'array' && Arr.isArray(obj)) {
+			return true;
+		}
+
+		return typeof obj == type;
+	}
+
+	/**
+	 * Makes a name/object map out of an array with names.
+	 *
+	 * @method makeMap
+	 * @param {Array/String} items Items to make map out of.
+	 * @param {String} delim Optional delimiter to split string by.
+	 * @param {Object} map Optional map to add items to.
+	 * @return {Object} Name/value map of items.
+	 */
+	function makeMap(items, delim, map) {
+		var i;
+
+		items = items || [];
+		delim = delim || ',';
+
+		if (typeof items == "string") {
+			items = items.split(delim);
+		}
+
+		map = map || {};
+
+		i = items.length;
+		while (i--) {
+			map[items[i]] = {};
+		}
+
+		return map;
+	}
+
+	/**
+	 * Creates a class, subclass or static singleton.
+	 * More details on this method can be found in the Wiki.
+	 *
+	 * @method create
+	 * @param {String} s Class name, inheritance and prefix.
+	 * @param {Object} p Collection of methods to add to the class.
+	 * @param {Object} root Optional root object defaults to the global window object.
+	 * @example
+	 * // Creates a basic class
+	 * tinymce.create('tinymce.somepackage.SomeClass', {
+	 *     SomeClass: function() {
+	 *         // Class constructor
+	 *     },
+	 *
+	 *     method: function() {
+	 *         // Some method
+	 *     }
+	 * });
+	 *
+	 * // Creates a basic subclass class
+	 * tinymce.create('tinymce.somepackage.SomeSubClass:tinymce.somepackage.SomeClass', {
+	 *     SomeSubClass: function() {
+	 *         // Class constructor
+	 *         this.parent(); // Call parent constructor
+	 *     },
+	 *
+	 *     method: function() {
+	 *         // Some method
+	 *         this.parent(); // Call parent method
+	 *     },
+	 *
+	 *     'static': {
+	 *         staticMethod: function() {
+	 *             // Static method
+	 *         }
+	 *     }
+	 * });
+	 *
+	 * // Creates a singleton/static class
+	 * tinymce.create('static tinymce.somepackage.SomeSingletonClass', {
+	 *     method: function() {
+	 *         // Some method
+	 *     }
+	 * });
+	 */
+	function create(s, p, root) {
+		var self = this, sp, ns, cn, scn, c, de = 0;
+
+		// Parse : <prefix> <class>:<super class>
+		s = /^((static) )?([\w.]+)(:([\w.]+))?/.exec(s);
+		cn = s[3].match(/(^|\.)(\w+)$/i)[2]; // Class name
+
+		// Create namespace for new class
+		ns = self.createNS(s[3].replace(/\.\w+$/, ''), root);
+
+		// Class already exists
+		if (ns[cn]) {
+			return;
+		}
+
+		// Make pure static class
+		if (s[2] == 'static') {
+			ns[cn] = p;
+
+			if (this.onCreate) {
+				this.onCreate(s[2], s[3], ns[cn]);
+			}
+
+			return;
+		}
+
+		// Create default constructor
+		if (!p[cn]) {
+			p[cn] = function() {};
+			de = 1;
+		}
+
+		// Add constructor and methods
+		ns[cn] = p[cn];
+		self.extend(ns[cn].prototype, p);
+
+		// Extend
+		if (s[5]) {
+			sp = self.resolve(s[5]).prototype;
+			scn = s[5].match(/\.(\w+)$/i)[1]; // Class name
+
+			// Extend constructor
+			c = ns[cn];
+			if (de) {
+				// Add passthrough constructor
+				ns[cn] = function() {
+					return sp[scn].apply(this, arguments);
+				};
+			} else {
+				// Add inherit constructor
+				ns[cn] = function() {
+					this.parent = sp[scn];
+					return c.apply(this, arguments);
+				};
+			}
+			ns[cn].prototype[cn] = ns[cn];
+
+			// Add super methods
+			self.each(sp, function(f, n) {
+				ns[cn].prototype[n] = sp[n];
+			});
+
+			// Add overridden methods
+			self.each(p, function(f, n) {
+				// Extend methods if needed
+				if (sp[n]) {
+					ns[cn].prototype[n] = function() {
+						this.parent = sp[n];
+						return f.apply(this, arguments);
+					};
+				} else {
+					if (n != cn) {
+						ns[cn].prototype[n] = f;
+					}
+				}
+			});
+		}
+
+		// Add static methods
+		/*jshint sub:true*/
+		/*eslint dot-notation:0*/
+		self.each(p['static'], function(f, n) {
+			ns[cn][n] = f;
+		});
+	}
+
+	function extend(obj, ext) {
+		var i, l, name, args = arguments, value;
+
+		for (i = 1, l = args.length; i < l; i++) {
+			ext = args[i];
+			for (name in ext) {
+				if (ext.hasOwnProperty(name)) {
+					value = ext[name];
+
+					if (value !== undefined) {
+						obj[name] = value;
+					}
+				}
+			}
+		}
+
+		return obj;
+	}
+
+	/**
+	 * Executed the specified function for each item in a object tree.
+	 *
+	 * @method walk
+	 * @param {Object} o Object tree to walk though.
+	 * @param {function} f Function to call for each item.
+	 * @param {String} n Optional name of collection inside the objects to walk for example childNodes.
+	 * @param {String} s Optional scope to execute the function in.
+	 */
+	function walk(o, f, n, s) {
+		s = s || this;
+
+		if (o) {
+			if (n) {
+				o = o[n];
+			}
+
+			Arr.each(o, function(o, i) {
+				if (f.call(s, o, i, n) === false) {
+					return false;
+				}
+
+				walk(o, f, n, s);
+			});
+		}
+	}
+
+	/**
+	 * Creates a namespace on a specific object.
+	 *
+	 * @method createNS
+	 * @param {String} n Namespace to create for example a.b.c.d.
+	 * @param {Object} o Optional object to add namespace to, defaults to window.
+	 * @return {Object} New namespace object the last item in path.
+	 * @example
+	 * // Create some namespace
+	 * tinymce.createNS('tinymce.somepackage.subpackage');
+	 *
+	 * // Add a singleton
+	 * var tinymce.somepackage.subpackage.SomeSingleton = {
+	 *     method: function() {
+	 *         // Some method
+	 *     }
+	 * };
+	 */
+	function createNS(n, o) {
+		var i, v;
+
+		o = o || window;
+
+		n = n.split('.');
+		for (i = 0; i < n.length; i++) {
+			v = n[i];
+
+			if (!o[v]) {
+				o[v] = {};
+			}
+
+			o = o[v];
+		}
+
+		return o;
+	}
+
+	/**
+	 * Resolves a string and returns the object from a specific structure.
+	 *
+	 * @method resolve
+	 * @param {String} n Path to resolve for example a.b.c.d.
+	 * @param {Object} o Optional object to search though, defaults to window.
+	 * @return {Object} Last object in path or null if it couldn't be resolved.
+	 * @example
+	 * // Resolve a path into an object reference
+	 * var obj = tinymce.resolve('a.b.c.d');
+	 */
+	function resolve(n, o) {
+		var i, l;
+
+		o = o || window;
+
+		n = n.split('.');
+		for (i = 0, l = n.length; i < l; i++) {
+			o = o[n[i]];
+
+			if (!o) {
+				break;
+			}
+		}
+
+		return o;
+	}
+
+	/**
+	 * Splits a string but removes the whitespace before and after each value.
+	 *
+	 * @method explode
+	 * @param {string} s String to split.
+	 * @param {string} d Delimiter to split by.
+	 * @example
+	 * // Split a string into an array with a,b,c
+	 * var arr = tinymce.explode('a, b,   c');
+	 */
+	function explode(s, d) {
+		if (!s || is(s, 'array')) {
+			return s;
+		}
+
+		return Arr.map(s.split(d || ','), trim);
+	}
+
+	function _addCacheSuffix(url) {
+		var cacheSuffix = Env.cacheSuffix;
+
+		if (cacheSuffix) {
+			url += (url.indexOf('?') === -1 ? '?' : '&') + cacheSuffix;
+		}
+
+		return url;
+	}
+
+	return {
+		trim: trim,
+
+		/**
+		 * Returns true/false if the object is an array or not.
+		 *
+		 * @method isArray
+		 * @param {Object} obj Object to check.
+		 * @return {boolean} true/false state if the object is an array or not.
+		 */
+		isArray: Arr.isArray,
+
+		is: is,
+
+		/**
+		 * Converts the specified object into a real JavaScript array.
+		 *
+		 * @method toArray
+		 * @param {Object} obj Object to convert into array.
+		 * @return {Array} Array object based in input.
+		 */
+		toArray: Arr.toArray,
+		makeMap: makeMap,
+
+		/**
+		 * Performs an iteration of all items in a collection such as an object or array. This method will execure the
+		 * callback function for each item in the collection, if the callback returns false the iteration will terminate.
+		 * The callback has the following format: cb(value, key_or_index).
+		 *
+		 * @method each
+		 * @param {Object} o Collection to iterate.
+		 * @param {function} cb Callback function to execute for each item.
+		 * @param {Object} s Optional scope to execute the callback in.
+		 * @example
+		 * // Iterate an array
+		 * tinymce.each([1,2,3], function(v, i) {
+		 *     console.debug("Value: " + v + ", Index: " + i);
+		 * });
+		 *
+		 * // Iterate an object
+		 * tinymce.each({a: 1, b: 2, c: 3], function(v, k) {
+		 *     console.debug("Value: " + v + ", Key: " + k);
+		 * });
+		 */
+		each: Arr.each,
+
+		/**
+		 * Creates a new array by the return value of each iteration function call. This enables you to convert
+		 * one array list into another.
+		 *
+		 * @method map
+		 * @param {Array} array Array of items to iterate.
+		 * @param {function} callback Function to call for each item. It's return value will be the new value.
+		 * @return {Array} Array with new values based on function return values.
+		 */
+		map: Arr.map,
+
+		/**
+		 * Filters out items from the input array by calling the specified function for each item.
+		 * If the function returns false the item will be excluded if it returns true it will be included.
+		 *
+		 * @method grep
+		 * @param {Array} a Array of items to loop though.
+		 * @param {function} f Function to call for each item. Include/exclude depends on it's return value.
+		 * @return {Array} New array with values imported and filtered based in input.
+		 * @example
+		 * // Filter out some items, this will return an array with 4 and 5
+		 * var items = tinymce.grep([1,2,3,4,5], function(v) {return v > 3;});
+		 */
+		grep: Arr.filter,
+
+		/**
+		 * Returns true/false if the object is an array or not.
+		 *
+		 * @method isArray
+		 * @param {Object} obj Object to check.
+		 * @return {boolean} true/false state if the object is an array or not.
+		 */
+		inArray: Arr.indexOf,
+
+		extend: extend,
+		create: create,
+		walk: walk,
+		createNS: createNS,
+		resolve: resolve,
+		explode: explode,
+		_addCacheSuffix: _addCacheSuffix
+	};
+});

data/apps/core/components/public/js/tinymce/classes/util/URI.js

@@ -0,0 +1,411 @@
+/**
+ * URI.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class handles parsing, modification and serialization of URI/URL strings.
+ * @class tinymce.util.URI
+ */
+define("tinymce/util/URI", [
+	"tinymce/util/Tools"
+], function(Tools) {
+	var each = Tools.each, trim = Tools.trim;
+	var queryParts = "source protocol authority userInfo user password host port relative path directory file query anchor".split(' ');
+	var DEFAULT_PORTS = {
+		'ftp': 21,
+		'http': 80,
+		'https': 443,
+		'mailto': 25
+	};
+
+	/**
+	 * Constructs a new URI instance.
+	 *
+	 * @constructor
+	 * @method URI
+	 * @param {String} url URI string to parse.
+	 * @param {Object} settings Optional settings object.
+	 */
+	function URI(url, settings) {
+		var self = this, baseUri, base_url;
+
+		url = trim(url);
+		settings = self.settings = settings || {};
+		baseUri = settings.base_uri;
+
+		// Strange app protocol that isn't http/https or local anchor
+		// For example: mailto,skype,tel etc.
+		if (/^([\w\-]+):([^\/]{2})/i.test(url) || /^\s*#/.test(url)) {
+			self.source = url;
+			return;
+		}
+
+		var isProtocolRelative = url.indexOf('//') === 0;
+
+		// Absolute path with no host, fake host and protocol
+		if (url.indexOf('/') === 0 && !isProtocolRelative) {
+			url = (baseUri ? baseUri.protocol || 'http' : 'http') + '://mce_host' + url;
+		}
+
+		// Relative path http:// or protocol relative //path
+		if (!/^[\w\-]*:?\/\//.test(url)) {
+			base_url = settings.base_uri ? settings.base_uri.path : new URI(location.href).directory;
+			if (settings.base_uri.protocol === "") {
+				url = '//mce_host' + self.toAbsPath(base_url, url);
+			} else {
+				url = /([^#?]*)([#?]?.*)/.exec(url);
+				url = ((baseUri && baseUri.protocol) || 'http') + '://mce_host' + self.toAbsPath(base_url, url[1]) + url[2];
+			}
+		}
+
+		// Parse URL (Credits goes to Steave, http://blog.stevenlevithan.com/archives/parseuri)
+		url = url.replace(/@@/g, '(mce_at)'); // Zope 3 workaround, they use @@something
+
+		/*jshint maxlen: 255 */
+		/*eslint max-len: 0 */
+		url = /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@\/]*):?([^:@\/]*))?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/.exec(url);
+
+		each(queryParts, function(v, i) {
+			var part = url[i];
+
+			// Zope 3 workaround, they use @@something
+			if (part) {
+				part = part.replace(/\(mce_at\)/g, '@@');
+			}
+
+			self[v] = part;
+		});
+
+		if (baseUri) {
+			if (!self.protocol) {
+				self.protocol = baseUri.protocol;
+			}
+
+			if (!self.userInfo) {
+				self.userInfo = baseUri.userInfo;
+			}
+
+			if (!self.port && self.host === 'mce_host') {
+				self.port = baseUri.port;
+			}
+
+			if (!self.host || self.host === 'mce_host') {
+				self.host = baseUri.host;
+			}
+
+			self.source = '';
+		}
+
+		if (isProtocolRelative) {
+			self.protocol = '';
+		}
+
+		//t.path = t.path || '/';
+	}
+
+	URI.prototype = {
+		/**
+		 * Sets the internal path part of the URI.
+		 *
+		 * @method setPath
+		 * @param {string} path Path string to set.
+		 */
+		setPath: function(path) {
+			var self = this;
+
+			path = /^(.*?)\/?(\w+)?$/.exec(path);
+
+			// Update path parts
+			self.path = path[0];
+			self.directory = path[1];
+			self.file = path[2];
+
+			// Rebuild source
+			self.source = '';
+			self.getURI();
+		},
+
+		/**
+		 * Converts the specified URI into a relative URI based on the current URI instance location.
+		 *
+		 * @method toRelative
+		 * @param {String} uri URI to convert into a relative path/URI.
+		 * @return {String} Relative URI from the point specified in the current URI instance.
+		 * @example
+		 * // Converts an absolute URL to an relative URL url will be somedir/somefile.htm
+		 * var url = new tinymce.util.URI('http://www.site.com/dir/').toRelative('http://www.site.com/dir/somedir/somefile.htm');
+		 */
+		toRelative: function(uri) {
+			var self = this, output;
+
+			if (uri === "./") {
+				return uri;
+			}
+
+			uri = new URI(uri, {base_uri: self});
+
+			// Not on same domain/port or protocol
+			if ((uri.host != 'mce_host' && self.host != uri.host && uri.host) || self.port != uri.port ||
+				(self.protocol != uri.protocol && uri.protocol !== "")) {
+				return uri.getURI();
+			}
+
+			var tu = self.getURI(), uu = uri.getURI();
+
+			// Allow usage of the base_uri when relative_urls = true
+			if (tu == uu || (tu.charAt(tu.length - 1) == "/" && tu.substr(0, tu.length - 1) == uu)) {
+				return tu;
+			}
+
+			output = self.toRelPath(self.path, uri.path);
+
+			// Add query
+			if (uri.query) {
+				output += '?' + uri.query;
+			}
+
+			// Add anchor
+			if (uri.anchor) {
+				output += '#' + uri.anchor;
+			}
+
+			return output;
+		},
+
+		/**
+		 * Converts the specified URI into a absolute URI based on the current URI instance location.
+		 *
+		 * @method toAbsolute
+		 * @param {String} uri URI to convert into a relative path/URI.
+		 * @param {Boolean} noHost No host and protocol prefix.
+		 * @return {String} Absolute URI from the point specified in the current URI instance.
+		 * @example
+		 * // Converts an relative URL to an absolute URL url will be http://www.site.com/dir/somedir/somefile.htm
+		 * var url = new tinymce.util.URI('http://www.site.com/dir/').toAbsolute('somedir/somefile.htm');
+		 */
+		toAbsolute: function(uri, noHost) {
+			uri = new URI(uri, {base_uri: this});
+
+			return uri.getURI(noHost && this.isSameOrigin(uri));
+		},
+
+		/**
+		 * Determine whether the given URI has the same origin as this URI.  Based on RFC-6454.
+		 * Supports default ports for protocols listed in DEFAULT_PORTS.  Unsupported protocols will fail safe: they
+		 * won't match, if the port specifications differ.
+		 *
+		 * @method isSameOrigin
+		 * @param {tinymce.util.URI} uri Uri instance to compare.
+		 * @returns {Boolean} True if the origins are the same.
+		 */
+		isSameOrigin: function(uri) {
+			if (this.host == uri.host && this.protocol == uri.protocol) {
+				if (this.port == uri.port) {
+					return true;
+				}
+
+				var defaultPort = DEFAULT_PORTS[this.protocol];
+				if (defaultPort && ((this.port || defaultPort) == (uri.port || defaultPort))) {
+					return true;
+				}
+			}
+
+			return false;
+		},
+
+		/**
+		 * Converts a absolute path into a relative path.
+		 *
+		 * @method toRelPath
+		 * @param {String} base Base point to convert the path from.
+		 * @param {String} path Absolute path to convert into a relative path.
+		 */
+		toRelPath: function(base, path) {
+			var items, breakPoint = 0, out = '', i, l;
+
+			// Split the paths
+			base = base.substring(0, base.lastIndexOf('/'));
+			base = base.split('/');
+			items = path.split('/');
+
+			if (base.length >= items.length) {
+				for (i = 0, l = base.length; i < l; i++) {
+					if (i >= items.length || base[i] != items[i]) {
+						breakPoint = i + 1;
+						break;
+					}
+				}
+			}
+
+			if (base.length < items.length) {
+				for (i = 0, l = items.length; i < l; i++) {
+					if (i >= base.length || base[i] != items[i]) {
+						breakPoint = i + 1;
+						break;
+					}
+				}
+			}
+
+			if (breakPoint === 1) {
+				return path;
+			}
+
+			for (i = 0, l = base.length - (breakPoint - 1); i < l; i++) {
+				out += "../";
+			}
+
+			for (i = breakPoint - 1, l = items.length; i < l; i++) {
+				if (i != breakPoint - 1) {
+					out += "/" + items[i];
+				} else {
+					out += items[i];
+				}
+			}
+
+			return out;
+		},
+
+		/**
+		 * Converts a relative path into a absolute path.
+		 *
+		 * @method toAbsPath
+		 * @param {String} base Base point to convert the path from.
+		 * @param {String} path Relative path to convert into an absolute path.
+		 */
+		toAbsPath: function(base, path) {
+			var i, nb = 0, o = [], tr, outPath;
+
+			// Split paths
+			tr = /\/$/.test(path) ? '/' : '';
+			base = base.split('/');
+			path = path.split('/');
+
+			// Remove empty chunks
+			each(base, function(k) {
+				if (k) {
+					o.push(k);
+				}
+			});
+
+			base = o;
+
+			// Merge relURLParts chunks
+			for (i = path.length - 1, o = []; i >= 0; i--) {
+				// Ignore empty or .
+				if (path[i].length === 0 || path[i] === ".") {
+					continue;
+				}
+
+				// Is parent
+				if (path[i] === '..') {
+					nb++;
+					continue;
+				}
+
+				// Move up
+				if (nb > 0) {
+					nb--;
+					continue;
+				}
+
+				o.push(path[i]);
+			}
+
+			i = base.length - nb;
+
+			// If /a/b/c or /
+			if (i <= 0) {
+				outPath = o.reverse().join('/');
+			} else {
+				outPath = base.slice(0, i).join('/') + '/' + o.reverse().join('/');
+			}
+
+			// Add front / if it's needed
+			if (outPath.indexOf('/') !== 0) {
+				outPath = '/' + outPath;
+			}
+
+			// Add traling / if it's needed
+			if (tr && outPath.lastIndexOf('/') !== outPath.length - 1) {
+				outPath += tr;
+			}
+
+			return outPath;
+		},
+
+		/**
+		 * Returns the full URI of the internal structure.
+		 *
+		 * @method getURI
+		 * @param {Boolean} noProtoHost Optional no host and protocol part. Defaults to false.
+		 */
+		getURI: function(noProtoHost) {
+			var s, self = this;
+
+			// Rebuild source
+			if (!self.source || noProtoHost) {
+				s = '';
+
+				if (!noProtoHost) {
+					if (self.protocol) {
+						s += self.protocol + '://';
+					} else {
+						s += '//';
+					}
+
+					if (self.userInfo) {
+						s += self.userInfo + '@';
+					}
+
+					if (self.host) {
+						s += self.host;
+					}
+
+					if (self.port) {
+						s += ':' + self.port;
+					}
+				}
+
+				if (self.path) {
+					s += self.path;
+				}
+
+				if (self.query) {
+					s += '?' + self.query;
+				}
+
+				if (self.anchor) {
+					s += '#' + self.anchor;
+				}
+
+				self.source = s;
+			}
+
+			return self.source;
+		}
+	};
+
+	URI.parseDataUri = function(uri) {
+		var type, matches;
+
+		uri = decodeURIComponent(uri).split(',');
+
+		matches = /data:([^;]+)/.exec(uri[0]);
+		if (matches) {
+			type = matches[1];
+		}
+
+		return {
+			type: type,
+			data: uri[1]
+		};
+	};
+
+	return URI;
+});