gnuside-aloha-rails 0.23.3

data/vendor/assets/javascripts/aloha/lib/text.js

@@ -0,0 +1,288 @@
+/**
+ * @license RequireJS text 1.0.6+ Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+/*jslint regexp: false, nomen: false, plusplus: false, strict: false */
+/*global require: false, XMLHttpRequest: false, ActiveXObject: false,
+  define: false, window: false, process: false, Packages: false,
+  java: false, location: false */
+
+(function () {
+    var progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'],
+        xmlRegExp = /^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im,
+        bodyRegExp = /<body[^>]*>\s*([\s\S]+)\s*<\/body>/im,
+        hasLocation = typeof location !== 'undefined' && location.href,
+        defaultProtocol = hasLocation && location.protocol && location.protocol.replace(/\:/, ''),
+        defaultHostName = hasLocation && location.hostname,
+        defaultPort = hasLocation && (location.port || undefined),
+        buildMap = [];
+
+    define(function () {
+        var text, get, fs;
+
+        if (typeof window !== "undefined" && window.navigator && window.document) {
+            get = function (url, callback) {
+                var xhr = text.createXhr();
+                xhr.open('GET', url, true);
+                xhr.onreadystatechange = function (evt) {
+                    //Do not explicitly handle errors, those should be
+                    //visible via console output in the browser.
+                    if (xhr.readyState === 4) {
+                        callback(xhr.responseText);
+                    }
+                };
+                xhr.send(null);
+            };
+        } else if (typeof process !== "undefined" &&
+                 process.versions &&
+                 !!process.versions.node) {
+            //Using special require.nodeRequire, something added by r.js.
+            fs = require.nodeRequire('fs');
+
+            get = function (url, callback) {
+                var file = fs.readFileSync(url, 'utf8');
+                //Remove BOM (Byte Mark Order) from utf8 files if it is there.
+                if (file.indexOf('\uFEFF') === 0) {
+                    file = file.substring(1);
+                }
+                callback(file);
+            };
+        } else if (typeof Packages !== 'undefined') {
+            //Why Java, why is this so awkward?
+            get = function (url, callback) {
+                var encoding = "utf-8",
+                    file = new java.io.File(url),
+                    lineSeparator = java.lang.System.getProperty("line.separator"),
+                    input = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(file), encoding)),
+                    stringBuffer, line,
+                    content = '';
+                try {
+                    stringBuffer = new java.lang.StringBuffer();
+                    line = input.readLine();
+
+                    // Byte Order Mark (BOM) - The Unicode Standard, version 3.0, page 324
+                    // http://www.unicode.org/faq/utf_bom.html
+
+                    // Note that when we use utf-8, the BOM should appear as "EF BB BF", but it doesn't due to this bug in the JDK:
+                    // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4508058
+                    if (line && line.length() && line.charAt(0) === 0xfeff) {
+                        // Eat the BOM, since we've already found the encoding on this file,
+                        // and we plan to concatenating this buffer with others; the BOM should
+                        // only appear at the top of a file.
+                        line = line.substring(1);
+                    }
+
+                    stringBuffer.append(line);
+
+                    while ((line = input.readLine()) !== null) {
+                        stringBuffer.append(lineSeparator);
+                        stringBuffer.append(line);
+                    }
+                    //Make sure we return a JavaScript string and not a Java string.
+                    content = String(stringBuffer.toString()); //String
+                } finally {
+                    input.close();
+                }
+                callback(content);
+            };
+        }
+
+        text = {
+            version: '1.0.6+',
+
+            strip: function (content) {
+                //Strips <?xml ...?> declarations so that external SVG and XML
+                //documents can be added to a document without worry. Also, if the string
+                //is an HTML document, only the part inside the body tag is returned.
+                if (content) {
+                    content = content.replace(xmlRegExp, "");
+                    var matches = content.match(bodyRegExp);
+                    if (matches) {
+                        content = matches[1];
+                    }
+                } else {
+                    content = "";
+                }
+                return content;
+            },
+
+            jsEscape: function (content) {
+                return content.replace(/(['\\])/g, '\\$1')
+                    .replace(/[\f]/g, "\\f")
+                    .replace(/[\b]/g, "\\b")
+                    .replace(/[\n]/g, "\\n")
+                    .replace(/[\t]/g, "\\t")
+                    .replace(/[\r]/g, "\\r");
+            },
+
+            createXhr: function () {
+                //Would love to dump the ActiveX crap in here. Need IE 6 to die first.
+                var xhr, i, progId;
+                if (typeof XMLHttpRequest !== "undefined") {
+                    return new XMLHttpRequest();
+                } else {
+                    for (i = 0; i < 3; i++) {
+                        progId = progIds[i];
+                        try {
+                            xhr = new ActiveXObject(progId);
+                        } catch (e) {}
+
+                        if (xhr) {
+                            progIds = [progId];  // so faster next time
+                            break;
+                        }
+                    }
+                }
+
+                if (!xhr) {
+                    throw new Error("createXhr(): XMLHttpRequest not available");
+                }
+
+                return xhr;
+            },
+
+            get: get,
+
+            /**
+             * Parses a resource name into its component parts. Resource names
+             * look like: module/name.ext!strip, where the !strip part is
+             * optional.
+             * @param {String} name the resource name
+             * @returns {Object} with properties "moduleName", "ext" and "strip"
+             * where strip is a boolean.
+             */
+            parseName: function (name) {
+                var strip = false, index = name.indexOf("."),
+                    modName = name.substring(0, index),
+                    ext = name.substring(index + 1, name.length);
+
+                index = ext.indexOf("!");
+                if (index !== -1) {
+                    //Pull off the strip arg.
+                    strip = ext.substring(index + 1, ext.length);
+                    strip = strip === "strip";
+                    ext = ext.substring(0, index);
+                }
+
+                return {
+                    moduleName: modName,
+                    ext: ext,
+                    strip: strip
+                };
+            },
+
+            xdRegExp: /^((\w+)\:)?\/\/([^\/\\]+)/,
+
+            /**
+             * Is an URL on another domain. Only works for browser use, returns
+             * false in non-browser environments. Only used to know if an
+             * optimized .js version of a text resource should be loaded
+             * instead.
+             * @param {String} url
+             * @returns Boolean
+             */
+            useXhr: function (url, protocol, hostname, port) {
+                var match = text.xdRegExp.exec(url),
+                    uProtocol, uHostName, uPort;
+                if (!match) {
+                    return true;
+                }
+                uProtocol = match[2];
+                uHostName = match[3];
+
+                uHostName = uHostName.split(':');
+                uPort = uHostName[1];
+                uHostName = uHostName[0];
+
+                return (!uProtocol || uProtocol === protocol) &&
+                       (!uHostName || uHostName === hostname) &&
+                       ((!uPort && !uHostName) || uPort === port);
+            },
+
+            finishLoad: function (name, strip, content, onLoad, config) {
+                content = strip ? text.strip(content) : content;
+                if (config.isBuild) {
+                    buildMap[name] = content;
+                }
+                onLoad(content);
+            },
+
+            load: function (name, req, onLoad, config) {
+                //Name has format: some.module.filext!strip
+                //The strip part is optional.
+                //if strip is present, then that means only get the string contents
+                //inside a body tag in an HTML string. For XML/SVG content it means
+                //removing the <?xml ...?> declarations so the content can be inserted
+                //into the current doc without problems.
+
+                // Do not bother with the work if a build and text will
+                // not be inlined.
+                if (config.isBuild && !config.inlineText) {
+                    onLoad();
+                    return;
+                }
+
+                var parsed = text.parseName(name),
+                    nonStripName = parsed.moduleName + '.' + parsed.ext,
+                    url = req.toUrl(nonStripName),
+                    useXhr = (config && config.text && config.text.useXhr) ||
+                             text.useXhr;
+
+                //Load the text. Use XHR if possible and in a browser.
+                if (!hasLocation || useXhr(url, defaultProtocol, defaultHostName, defaultPort)) {
+                    text.get(url, function (content) {
+                        text.finishLoad(name, parsed.strip, content, onLoad, config);
+                    });
+                } else {
+                    //Need to fetch the resource across domains. Assume
+                    //the resource has been optimized into a JS module. Fetch
+                    //by the module name + extension, but do not include the
+                    //!strip part to avoid file system issues.
+                    req([nonStripName], function (content) {
+                        text.finishLoad(parsed.moduleName + '.' + parsed.ext,
+                                        parsed.strip, content, onLoad, config);
+                    });
+                }
+            },
+
+            write: function (pluginName, moduleName, write, config) {
+                if (moduleName in buildMap) {
+                    var content = text.jsEscape(buildMap[moduleName]);
+                    write.asModule(pluginName + "!" + moduleName,
+                                   "define(function () { return '" +
+                                       content +
+                                   "';});\n");
+                }
+            },
+
+            writeFile: function (pluginName, moduleName, req, write, config) {
+                var parsed = text.parseName(moduleName),
+                    nonStripName = parsed.moduleName + '.' + parsed.ext,
+                    //Use a '.js' file name so that it indicates it is a
+                    //script that can be loaded across domains.
+                    fileName = req.toUrl(parsed.moduleName + '.' +
+                                         parsed.ext) + '.js';
+
+                //Leverage own load() method to load plugin value, but only
+                //write out values that do not have the strip argument,
+                //to avoid any potential issues with ! in file names.
+                text.load(nonStripName, req, function (value) {
+                    //Use own write() method to construct full module value.
+                    //But need to create shell that translates writeFile's
+                    //write() to the right interface.
+                    var textWrite = function (contents) {
+                        return write(fileName, contents);
+                    };
+                    textWrite.asModule = function (moduleName, contents) {
+                        return write.asModule(moduleName, fileName, contents);
+                    };
+
+                    text.write(pluginName, nonStripName, textWrite, config);
+                }, config);
+            }
+        };
+
+        return text;
+    });
+}());

data/vendor/assets/javascripts/aloha/lib/util/arrays.js

@@ -0,0 +1,287 @@
+/* arrays.js is part of Aloha Editor project http://aloha-editor.org
+ *
+ * Aloha Editor is a WYSIWYG HTML5 inline editing library and editor. 
+ * Copyright (c) 2010-2012 Gentics Software GmbH, Vienna, Austria.
+ * Contributors http://aloha-editor.org/contribution.php 
+ * 
+ * Aloha Editor is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or any later version.
+ *
+ * Aloha Editor is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * 
+ * As an additional permission to the GNU GPL version 2, you may distribute
+ * non-source (e.g., minimized or compacted) forms of the Aloha-Editor
+ * source code without the copy of the GNU GPL normally required,
+ * provided you include this license notice and a URL through which
+ * recipients can access the Corresponding Source.
+ */
+define(['util/functions'], function (Fn) {
+	'use strict';
+
+	/**
+	 * Implements unique() using the browser's sort().
+	 *
+	 * @param a
+	 *        The array to sort and strip of duplicate values.
+	 *        Warning: this array will be modified in-place.
+	 * @param compFn
+	 *        A custom comparison function that accepts two values a and
+	 *        b from the given array and returns -1, 0, 1 depending on
+	 *        whether a < b, a == b, a > b respectively.
+	 *
+	 *        If no compFn is provided, the algorithm will use the
+	 *        browsers default sort behaviour and loose comparison to
+	 *        detect duplicates.
+	 * @return
+	 *        The given array.
+	 */
+	function sortUnique(a, compFn) {
+		var i;
+		if (compFn) {
+			a.sort(compFn);
+			for (i = 1; i < a.length; i++) {
+				if (0 === compFn(a[i], a[i - 1])) {
+					a.splice(i--, 1);
+				}
+			}
+		} else {
+			a.sort();
+			for (i = 1; i < a.length; i++) {
+				// Use loosely typed comparsion if no compFn is given
+				// to avoid sortUnique([6, "6", 6]) => [6, "6", 6]
+				if (a[i] == a[i - 1]) {
+					a.splice(i--, 1);
+				}
+			}
+		}
+		return a;
+	}
+
+	/**
+	 * Shallow comparison of two arrays.
+	 *
+	 * @param a, b
+	 *        The arrays to compare.
+	 * @param equalFn
+	 *        A custom comparison function that accepts two values a and
+	 *        b from the given arrays and returns true or false for
+	 *        equal and not equal respectively.
+	 *
+	 *        If no equalFn is provided, the algorithm will use the strict
+	 *        equals operator.
+	 * @return
+	 *        True if all items in a and b are equal, false if not.
+	 */
+	function equal(a, b, equalFn) {
+		var i,
+			len = a.length;
+		if (len !== b.length) {
+			return false;
+		}
+		if (equalFn) {
+			for (i = 0; i < len; i++) {
+				if (!equalFn(a[i], b[i])) {
+					return false;
+				}
+			}
+		} else {
+			for (i = 0; i < len; i++) {
+				if (a[i] !== b[i]) {
+					return false;
+				}
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Emulates ECMAScript edition 5 Arrays.map
+	 * See https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/map
+	 * And http://es5.github.com/#x15.4.4.19
+	 * It's not exactly according to standard, but it does what one expects.
+	 */
+	function map(a, fn) {
+		var i, len, result = [];
+		for (i = 0, len = a.length; i < len; i++) {
+			result.push(fn(a[i]));
+		}
+		return result;
+	}
+
+	function mapNative(a, fn) {
+		// Call map directly on the object instead of going through
+		// Array.prototype.map. This avoids the problem that we may get
+		// passed an array-like object (NodeList) which may cause an
+		// error if the implementation of Array.prototype.map can only
+		// deal with arrays (Array.prototype.map may be native or
+		// provided by a javscript framework).
+		return a.map(fn);
+	}
+
+	/**
+	 * Returns a new array that contains all values in the given a for
+	 * which pred returns true.
+	 */
+	function filter(a, pred) {
+		var i,
+		    len,
+		    value,
+		    result = [];
+		for (i = 0, len = a.length; i < len; i++) {
+			value = a[i];
+			if (pred(value)) {
+				result.push(value);
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * Finds a value in the given array.
+	 * Strict comparison is used to find the value.
+	 * Returns the index of the first occurrence of the given value in
+	 * the given a, or -1 if a contains no such value.
+	 */
+	function indexOf(a, value) {
+		var i,
+		    len;
+		for (i = 0, len = a.length; i < len; i++) {
+			if (value === a[i]) {
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	/**
+	 * Reduces an array of values to a single value.
+	 *
+	 * For example:
+	 * Arrays.reduce([2, 3, 4], 1, function (a, b) { return a + b; });
+	 * returns the result of (((1 + 2) + 3) + 4)
+	 *
+	 * Emulates ECMAScript edition 5 Array.reduce.
+	 *
+	 * @param a
+	 *        An array of values.
+	 * @param init
+	 *        An initial value.
+	 * @param fn
+	 *        A function that takes two values and returns the reduction
+	 *        of both.
+	 */
+	function reduce(a, init, fn) {
+		var i,
+		    len;
+		for (i = 0, len = a.length; i < len; i++) {
+			init = fn(init, a[i]);
+		}
+		return init;
+	}
+
+	/**
+	 * Returns true if the given xs contains the given x.
+	 */
+	function contains(xs, x) {
+		return -1 !== indexOf(xs, x);
+	}
+
+	/**
+	 * Applies the given value to the given function unless the value is
+	 * null, in which case just returns null.
+	 *
+	 * This is a utility function to be used with reduce().
+	 */
+	function applyNotNull(value, fn) {
+		return value == null ? null : fn(value);
+	}
+
+	/**
+	 * For each item in xs, call cb(item, index, xs).
+	 *
+	 * Emulates ECMAScript edition 5 Array.forEach.
+	 */
+	function forEach(xs, cb) {
+		var i,
+		    len;
+		for (i = 0, len = xs.length; i < len; i++) {
+			cb(xs[i], i, xs);
+		}
+	}
+
+	/**
+	 * Returns true if the given predicate function returns true for at
+	 * least one item.
+	 *
+	 * Emulates ECMAScript edition 5 Array.some.
+	 */
+	function some(xs, pred) {
+		var i,
+		    len;
+		for (i = 0, len = xs.length; i < len; i++) {
+			if (pred(xs[i])) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Returns true if the given predicate function returns true for all
+	 * items in xs.
+	 *
+	 * Emulates ECMAScript edition 5 Array.every.
+	 */
+	function every(xs, pred) {
+		return !some(xs, Fn.complement(pred));
+	}
+
+	/**
+	 * Returns all items in xs that are also contained in zs.
+	 */
+	function intersect(xs, zs) {
+		return filter(xs, function (x) {
+			return contains(zs, x);
+		});
+	}
+
+	/**
+	 * Returns the last item in xs or null.
+	 */
+	function last(xs) {
+		return xs.length ? xs[xs.length - 1] : null;
+	}
+
+	/**
+	 * Returns the second item in xs.
+	 */
+	function second(xs) {
+		return xs[1];
+	}
+
+	return {
+		filter: filter,
+		indexOf: indexOf,
+		reduce: reduce,
+		forEach: forEach,
+		some: some,
+		every: every,
+		map: Array.prototype.map ? mapNative : map,
+		contains: contains,
+		equal: equal,
+		applyNotNull: applyNotNull,
+		sortUnique: sortUnique,
+		intersect: intersect,
+		second: second,
+		last: last
+	};
+});