free_text 0.0.2 → 0.0.3

data/app/assets/javascripts/aloha-0.10.0/lib/css.js

@@ -0,0 +1,313 @@
+/**
+ * Copyright (c) 2010 unscriptable.com
+ */
+
+/*jslint browser:true, on:true, sub:true */
+
+(function (doc) {
+
+
+/*
+ * RequireJS css! plugin
+ * This plugin will load and wait for css files.  This could be handy when
+ * loading css files as part of a layer or as a way to apply a run-time theme.
+ * Most browsers do not support the load event handler of the link element.
+ * Therefore, we have to use other means to detect when a css file loads.
+ * (The HTML5 spec states that the LINK element should have a load event, but
+ * not even Chrome 8 or FF4b7 have it, yet.
+ * http://www.w3.org/TR/html5/semantics.html#the-link-element)
+ *
+ * This plugin tries to use the load event and a universal work-around when
+ * it is invoked the first time.  If the load event works, it is used on
+ * every successive load.  Therefore, browsers that support the load event will
+ * just work (i.e. no need for hacks!).  FYI, Feature-detecting the load
+ * event is tricky since most browsers have a non-functional onload property.
+ *
+ * The universal work-around watches a stylesheet until its rules are
+ * available (not null or undefined).  There are nuances, of course, between
+ * the various browsers.  The isLinkReady function accounts for these.
+ *
+ * Note: it appears that all browsers load @import'ed stylesheets before
+ * fully processing the rest of the importing stylesheet. Therefore, we
+ * don't need to find and wait for any @import rules explicitly.
+ *
+ * Note #2: for Opera compatibility, stylesheets must have at least one rule.
+ * AFAIK, there's no way to tell the difference between an empty sheet and
+ * one that isn't finished loading in Opera (XD or same-domain).
+ *
+ * Options:
+ *      !nowait - does not wait for the stylesheet to be parsed, just loads it
+ *
+ * Global configuration options:
+ *
+ * cssDeferLoad: Boolean. You can also instruct this plugin to not wait
+ * for css resources. They'll get loaded asap, but other code won't wait
+ * for them. This is just like using the !nowait option on every css file.
+ *
+ * cssWatchPeriod: if direct load-detection techniques fail, this option
+ * determines the msec to wait between brute-force checks for rules. The
+ * default is 50 msec.
+ *
+ * You may specify an alternate file extension:
+ *      require('css!myproj/component.less') // --> myproj/component.less
+ *      require('css!myproj/component.scss') // --> myproj/component.scss
+ *
+ * When using alternative file extensions, be sure to serve the files from
+ * the server with the correct mime type (text/css) or some browsers won't
+ * parse them, causing an error in the plugin.
+ *
+ * usage:
+ *      require(['css!myproj/comp']); // load and wait for myproj/comp.css
+ *      define(['css!some/folder/file'], {}); // wait for some/folder/file.css
+ *      require(['css!myWidget!nowait']);
+ *
+ * Tested in:
+ *      Firefox 1.5, 2.0, 3.0, 3.5, 3.6, and 4.0b6
+ *      Safari 3.0.4, 3.2.1, 5.0
+ *      Chrome 7 (8+ is partly b0rked)
+ *      Opera 9.52, 10.63, and Opera 11.00
+ *      IE 6, 7, and 8
+ *      Netscape 7.2 (WTF? SRSLY!)
+ * Does not work in Safari 2.x :(
+ * In Chrome 8+, there's no way to wait for cross-domain (XD) stylesheets.
+ * See comments in the code below.
+ * TODO: figure out how to be forward-compatible when browsers support HTML5's
+ *  load handler without breaking IE and Opera
+*/
+
+
+var
+	// compressibility shortcuts
+		onreadystatechange = 'onreadystatechange',
+		onload = 'onload',
+		createElement = 'createElement',
+		// failed is true if RequireJS threw an exception
+		failed = false,
+		undef,
+		insertedSheets = {},
+		features = {
+			// true if the onload event handler works
+			// "event-link-onload" : false
+		},
+		// find the head element and set it to it's standard property if nec.
+		head = doc.head || (doc.head = doc.getElementsByTagName('head')[0]);
+
+	function has (feature) {
+		return features[feature];
+	}
+
+	// failure detection
+	// we need to watch for onError when using RequireJS so we can shut off
+	// our setTimeouts when it encounters an error.
+	if (require['onError']) {
+		require['onError'] = (function (orig) {
+		return function () {
+			failed = true;
+			orig.apply(this, arguments);
+		}
+		})(require['onError']);
+}
+
+/***** load-detection functions *****/
+
+function loadHandler (params, cb) {
+	// We're using 'readystatechange' because IE and Opera happily support both
+	var link = params.link;
+		link[onreadystatechange] = link[onload] = function () {
+		if (!link.readyState || link.readyState == 'complete') {
+				features["event-link-onload"] = true;
+			cleanup(params);
+			cb();
+		}
+	};
+}
+
+function nameWithExt (name, defaultExt) {
+	return name.lastIndexOf('.') <= name.lastIndexOf('/') ?
+		name + '.' + defaultExt : name;
+}
+
+function parseSuffixes (name) {
+	// creates a dual-structure: both an array and a hashmap
+	// suffixes[0] is the actual name
+	var parts = name.split('!'),
+		suf, i = 1, pair;
+	while ((suf = parts[i++])) { // double-parens to avoid jslint griping
+		pair = suf.split('=', 2);
+		parts[pair[0]] = pair.length == 2 ? pair[1] : true;
+	}
+	return parts;
+}
+
+function createLink (doc, optHref) {
+		var link = doc[createElement]('link');
+	link.rel = "stylesheet";
+	link.type = "text/css";
+	if (optHref) {
+		link.href = optHref;
+	}
+	return link;
+}
+
+// Chrome 8 hax0rs!
+// This is an ugly hack needed by Chrome 8+ which no longer waits for rules
+// to be applied to the document before exposing them to javascript.
+// Unfortunately, this routine will never fire for XD stylsheets since
+// Chrome will also throw an exception if attempting to access the rules
+// of an XD stylesheet.  Therefore, there's no way to detect the load
+// event of XD stylesheets until Google fixes this, preferably with a
+// functional load event!  As a work-around, use ready() before rendering
+// widgets / components that need the css to be ready.
+var testEl;
+function styleIsApplied () {
+	if (!testEl) {
+			testEl = doc[createElement]('div');
+		testEl.id = '_cssx_load_test';
+		testEl.style.cssText = 'position:absolute;top:-999px;left:-999px;';
+		doc.body.appendChild(testEl);
+	}
+	return doc.defaultView.getComputedStyle(testEl, null).marginTop == '-5px';
+}
+
+function isLinkReady (link) {
+    // This routine is a bit fragile: browser vendors seem oblivious to
+	// the need to know precisely when stylesheets load.  Therefore, we need
+	// to continually test beta browsers until they all support the LINK load
+	// event like IE and Opera.
+    var sheet, rules, ready = false;
+    try {
+        // webkit's and IE's sheet is null until the sheet is loaded
+        sheet = link.sheet || link.styleSheet;
+        // mozilla's sheet throws an exception if trying to access xd rules
+        rules = sheet.cssRules || sheet.rules;
+        // webkit's xd sheet returns rules == null
+        // opera's sheet always returns rules, but length is zero until loaded
+        // friggin IE doesn't count @import rules as rules, but IE should
+	    // never hit this routine anyways.
+        ready = rules ?
+            rules.length > 0 : // || (sheet.imports && sheet.imports.length > 0) :
+            rules !== undef;
+	    // thanks, Chrome 8, for this lovely hack
+	    if (ready && navigator.userAgent.indexOf('Chrome') >= 0) {
+		    sheet.insertRule('#_cssx_load_test{margin-top:-5px;}', 0);
+		    ready = styleIsApplied();
+		    sheet.deleteRule(0);
+	    }
+    }
+    catch (ex) {
+        // 1000 means FF loaded an xd stylesheet
+        // other browsers just throw a security error here (IE uses the phrase 'Access is denied')
+        ready = (ex.code == 1000) || (ex.message.match(/security|denied/i));
+    }
+    return ready;
+}
+
+function ssWatcher (params, cb) {
+    // watches a stylesheet for loading signs.
+    if (isLinkReady(params.link)) {
+		cleanup(params);
+        cb();
+    }
+    else if (!failed) {
+        window.setTimeout(function () { ssWatcher(params, cb); }, params.wait);
+    }
+}
+
+function loadDetector (params, cb) {
+	// It would be nice to use onload everywhere, but the onload handler
+	// only works in IE and Opera.
+	// Detecting it cross-browser is completely impossible, too, since
+	// THE BROWSERS ARE LIARS! DON'T TELL ME YOU HAVE AN ONLOAD PROPERTY
+	// IF IT DOESN'T DO ANYTHING!
+	var loaded;
+	function cbOnce () {
+		if (!loaded) {
+			loaded = true;
+			cb();
+		}
+	}
+	loadHandler(params, cbOnce);
+		if (!has("event-link-onload")) ssWatcher(params, cbOnce);
+}
+
+function cleanup (params) {
+	var link = params.link;
+		link[onreadystatechange] = link[onload] = null;
+}
+
+/***** finally! the actual plugin *****/
+
+var plugin = {
+
+		//prefix: 'css',
+
+		'load': function (resourceDef, require, callback, config) {
+				var resources = resourceDef.split(","),
+					loadingCount = resources.length;
+
+			// all detector functions must ensure that this function only gets
+			// called once per stylesheet!
+			function loaded () {
+				// load/error handler may have executed before stylesheet is
+				// fully parsed / processed in Opera, so use setTimeout.
+				// Opera will process before the it next enters the event loop
+				// (so 0 msec is enough time).
+				if(--loadingCount == 0){
+					// TODO: move this setTimeout to loadHandler
+					window.setTimeout(function () { callback(link); }, 0);
+				}
+			}
+
+			// after will become truthy once the loop executes a second time
+			for (var i = resources.length - 1, after; i >= 0; i--, after = url) {
+
+				resourceDef = resources[i];
+
+				var
+					// TODO: this is a bit weird: find a better way to extract name?
+					opts = parseSuffixes(resourceDef),
+					name = opts.shift(),
+					url = require['toUrl'](nameWithExt(name, 'css')),
+					link = createLink(doc),
+					nowait = 'nowait' in opts ? opts['nowait'] != 'false' : !!config['cssDeferLoad'],
+					params = {
+						link: link,
+						url: url,
+						wait: config['cssWatchPeriod'] || 50
+					};
+
+				if (nowait) {
+					callback(link);
+				}
+				else {
+					// hook up load detector(s)
+					loadDetector(params, loaded);
+				}
+
+				// go!
+				link.href = url;
+
+				if (after) {
+					head.insertBefore(link, insertedSheets[after].previousSibling);
+				}
+				else {
+					head.appendChild(link);
+				}
+				insertedSheets[url] = link;
+			}
+
+		},
+
+		/* the following methods are public in case they're useful to other plugins */
+
+			'nameWithExt': nameWithExt,
+
+			'parseSuffixes': parseSuffixes,
+
+			'createLink': createLink
+
+	};
+
+define(plugin);
+
+})(document);

data/app/assets/javascripts/aloha-0.10.0/lib/i18n.js

@@ -0,0 +1,153 @@
+/**
+ * @license RequireJS i18n 0.24.0 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, navigator: false, define: false */
+
+/**
+ * This plugin handles i18n! prefixed modules. It does the following:
+ *
+ * 1) A regular module can have a dependency on an i18n bundle, but the regular
+ * module does not want to specify what locale to load. So it just specifies
+ * the top-level bundle, like "i18n!nls/colors".
+ *
+ * This plugin will load the i18n bundle at nls/colors, see that it is a root/master
+ * bundle since it does not have a locale in its name. It will then try to find
+ * the best match locale available in that master bundle, then request all the
+ * locale pieces for that best match locale. For instance, if the locale is "en-us",
+ * then the plugin will ask for the "en-us", "en" and "root" bundles to be loaded
+ * (but only if they are specified on the master bundle).
+ *
+ * Once all the bundles for the locale pieces load, then it mixes in all those
+ * locale pieces into each other, then finally sets the context.defined value
+ * for the nls/colors bundle to be that mixed in locale.
+ *
+ * 2) A regular module specifies a specific locale to load. For instance,
+ * i18n!nls/fr-fr/colors. In this case, the plugin needs to load the master bundle
+ * first, at nls/colors, then figure out what the best match locale is for fr-fr,
+ * since maybe only fr or just root is defined for that locale. Once that best
+ * fit is found, all of its locale pieces need to have their bundles loaded.
+ *
+ * Once all the bundles for the locale pieces load, then it mixes in all those
+ * locale pieces into each other, then finally sets the context.defined value
+ * for the nls/fr-fr/colors bundle to be that mixed in locale.
+ */
+(function () {
+    //regexp for reconstructing the master bundle name from parts of the regexp match
+    //nlsRegExp.exec("foo/bar/baz/nls/en-ca/foo") gives:
+    //["foo/bar/baz/nls/en-ca/foo", "foo/bar/baz/nls/", "/", "/", "en-ca", "foo"]
+    //nlsRegExp.exec("foo/bar/baz/nls/foo") gives:
+    //["foo/bar/baz/nls/foo", "foo/bar/baz/nls/", "/", "/", "foo", ""]
+    //so, if match[5] is blank, it means this is the top bundle definition.
+    var nlsRegExp = /(^.*(^|\/)nls(\/|$))([^\/]*)\/?([^\/]*)/;
+
+    //Helper function to avoid repeating code. Lots of arguments in the
+    //desire to stay functional and support RequireJS contexts without having
+    //to know about the RequireJS contexts.
+    function addPart(locale, master, needed, toLoad, prefix, suffix) {
+        if (master[locale]) {
+            needed.push(locale);
+            if (master[locale] === true || master[locale] === 1) {
+                toLoad.push(prefix + locale + '/' + suffix);
+            }
+        }
+    }
+
+    function addIfExists(req, locale, toLoad, prefix, suffix) {
+        var fullName = prefix + locale + '/' + suffix;
+        if (require._fileExists(req.nameToUrl(fullName, null))) {
+            toLoad.push(fullName);
+        }
+    }
+
+    define({
+        version: '0.24.0',
+        /**
+         * Called when a dependency needs to be loaded.
+         */
+        load: function (name, req, onLoad, config) {
+            config = config || {};
+
+            var masterName,
+                match = nlsRegExp.exec(name),
+                prefix = match[1],
+                locale = match[4],
+                suffix = match[5],
+                parts = locale.split("-"),
+                toLoad = [],
+                value = {},
+                i, part, current = "";
+
+            //If match[5] is blank, it means this is the top bundle definition,
+            //so it does not have to be handled. Locale-specific requests
+            //will have a match[4] value but no match[5]
+            if (match[5]) {
+                //locale-specific bundle
+                prefix = match[1];
+                masterName = prefix + suffix;
+            } else {
+                //Top-level bundle.
+                masterName = name;
+                suffix = match[4];
+                locale = config.locale || (config.locale =
+                        typeof navigator === "undefined" ? "root" :
+                        (navigator.language ||
+                         navigator.userLanguage || "root").toLowerCase());
+                parts = locale.split("-");
+            }
+
+            if (config.isBuild) {
+                //Check for existence of all locale possible files and
+                //require them if exist.
+                toLoad.push(masterName);
+                addIfExists(req, "root", toLoad, prefix, suffix);
+                for (i = 0; (part = parts[i]); i++) {
+                    current += (current ? "-" : "") + part;
+                    addIfExists(req, current, toLoad, prefix, suffix);
+                }
+                req(toLoad);
+                onLoad();
+            } else {
+                //First, fetch the master bundle, it knows what locales are available.
+                req([masterName], function (master) {
+                    //Figure out the best fit
+                    var needed = [];
+
+                    //Always allow for root, then do the rest of the locale parts.
+                    addPart("root", master, needed, toLoad, prefix, suffix);
+                    for (i = 0; (part = parts[i]); i++) {
+                        current += (current ? "-" : "") + part;
+                        addPart(current, master, needed, toLoad, prefix, suffix);
+                    }
+
+                    //Load all the parts missing.
+                    req(toLoad, function () {
+                        var i, partBundle;
+                        for (i = needed.length - 1; i > -1 && (part = needed[i]); i--) {
+                            partBundle = master[part];
+                            if (partBundle === true || partBundle === 1) {
+                                partBundle = req(prefix + part + '/' + suffix);
+                            }
+                            require.mixin(value, partBundle);
+                        }
+						
+						// MODIFICATION FROM ALOHA START: add a t() function
+						value.t = function(key) {
+							if (this[key]) {
+								return this[key];
+							} else {
+								return key;
+							}
+						}
+						// END OF ALOHA MODIFICATION
+
+						//All done, notify the loader.
+                        onLoad(value);
+                    });
+                });
+            }
+        }
+    });
+}());

data/app/assets/javascripts/aloha-0.10.0/lib/jquery-plugin.js

@@ -0,0 +1,49 @@
+/*global define: true */
+/*!
+* This file is part of Aloha Editor Project http://aloha-editor.org
+* Copyright © 2010-2011 Gentics Software GmbH, aloha@gentics.com
+* Contributors http://aloha-editor.org/contribution.php 
+* Licensed unter the terms of http://www.aloha-editor.org/license.html
+*//*
+* Aloha Editor is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Affero General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) 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 Affero General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+(function () {
+	/**
+	 * This requirejs module loader loads jquery plugins and wraps them 
+	 */
+	define({
+		load: function (name, require, load, config) {
+			var url = require.toUrl(name + '.js');
+
+			require(['aloha/jquery'], function (value) {
+				var $ = value;
+				$.ajax({
+					type: 'GET',
+					url: url,
+					cache: true,
+					dataType: 'text',
+					success: function (plugin) {
+//						plugin = '(function(jQuery) { var $ = jQuery;\n' + plugin + '}(window.alohaQuery));';
+						plugin = 'define([\'aloha/jquery\'], function(jQuery) { var $ = jQuery;\n' + plugin + '});';
+						load.fromText(name, plugin);
+						require([name], function (value) {
+							load(value);
+						});
+					}
+				});
+			});
+		}
+	});
+}());

data/app/assets/javascripts/aloha-0.10.0/lib/order.js

@@ -0,0 +1,140 @@
+/**
+ * @license RequireJS order 0.26.0 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 nomen: false, plusplus: false, strict: false */
+/*global require: false, define: false, window: false, document: false,
+  setTimeout: false */
+
+(function () {
+    //Sadly necessary browser inference due to differences in the way
+    //that browsers load and execute dynamically inserted javascript
+    //and whether the script/cache method works.
+    //Currently, Gecko and Opera do not load/fire onload for scripts with
+    //type="script/cache" but they execute injected scripts in order
+    //unless the 'async' flag is present.
+    //However, this is all changing in latest browsers implementing HTML5
+    //spec. Firefox nightly supports using the .async true by default, and
+    //if false, then it will execute in order. Favor that test first for forward
+    //compatibility. However, it is unclear if webkit/IE will follow suit.
+    //Latest webkit breaks the script/cache trick.
+    //Test for document and window so that this file can be loaded in
+    //a web worker/non-browser env. It will not make sense to use this
+    //plugin in a non-browser env, but the file should not error out if included
+    //in a file, then loaded in a non-browser env.
+    var supportsInOrderExecution = typeof document !== "undefined" &&
+                                   typeof window !== "undefined" &&
+                                   (document.createElement("script").async ||
+                               (window.opera && Object.prototype.toString.call(window.opera) === "[object Opera]") ||
+                               //If Firefox 2 does not have to be supported, then
+                               //a better check may be:
+                               //('mozIsLocallyAvailable' in window.navigator)
+                               ("MozAppearance" in document.documentElement.style)),
+        readyRegExp = /^(complete|loaded)$/,
+        waiting = [],
+        cached = {};
+
+    function loadResource(name, req, onLoad) {
+        req([name], function (value) {
+            //The value may be a real defined module. Wrap
+            //it in a function call, because this function is used
+            //as the factory function for this ordered dependency.
+            onLoad(function () {
+                return value;
+            });
+        });
+    }
+
+    //Callback used by the type="script/cache" callback that indicates a script
+    //has finished downloading.
+    function scriptCacheCallback(evt) {
+        var node = evt.currentTarget || evt.srcElement, i,
+            moduleName, resource;
+
+        if (evt.type === "load" || readyRegExp.test(node.readyState)) {
+            //Pull out the name of the module and the context.
+            moduleName = node.getAttribute("data-requiremodule");
+
+            //Mark this cache request as loaded
+            cached[moduleName] = true;
+
+            //Find out how many ordered modules have loaded
+            for (i = 0; (resource = waiting[i]); i++) {
+                if (cached[resource.name]) {
+                    loadResource(resource.name, resource.req, resource.onLoad);
+                } else {
+                    //Something in the ordered list is not loaded,
+                    //so wait.
+                    break;
+                }
+            }
+
+            //If just loaded some items, remove them from waiting.
+            if (i > 0) {
+                waiting.splice(0, i);
+            }
+
+            //Remove this script tag from the DOM
+            //Use a setTimeout for cleanup because some older IE versions vomit
+            //if removing a script node while it is being evaluated.
+            setTimeout(function () {
+                node.parentNode.removeChild(node);
+            }, 15);
+        }
+    }
+
+    define({
+        version: '0.26.0',
+
+        load: function (name, req, onLoad, config) {
+            var url = req.nameToUrl(name, null);
+
+            //If a build, just load the module as usual.
+            if (config.isBuild) {
+                loadResource(name, req, onLoad);
+                return;
+            }
+
+            //Make sure the async attribute is not set for any pathway involving
+            //this script.
+            require.s.skipAsync[url] = true;
+            if (supportsInOrderExecution) {
+                //Just a normal script tag append, but without async attribute
+                //on the script.
+                req([name], function (value) {
+                    //The value may be a real defined module. Wrap
+                    //it in a function call, because this function is used
+                    //as the factory function for this ordered dependency.
+                    onLoad(function () {
+                        return value;
+                    });
+                });
+            } else {
+                //Credit to LABjs author Kyle Simpson for finding that scripts
+                //with type="script/cache" allow scripts to be downloaded into
+                //browser cache but not executed. Use that
+                //so that subsequent addition of a real type="text/javascript"
+                //tag will cause the scripts to be executed immediately in the
+                //correct order.
+                if (req.specified(name)) {
+                    req([name], function (value) {
+                        //The value may be a real defined module. Wrap
+                        //it in a function call, because this function is used
+                        //as the factory function for this ordered dependency.
+                        onLoad(function () {
+                            return value;
+                        });
+                    });
+                } else {
+                    waiting.push({
+                        name: name,
+                        req: req,
+                        onLoad: onLoad
+                    });
+                    require.attach(url, null, name, scriptCacheCallback, "script/cache");
+                }
+            }
+        }
+    });
+}());