locomotive-aloha-rails 0.20.1.5 → 0.23.2.1

data/vendor/assets/javascripts/aloha/lib/aloha/state-override.js

@@ -0,0 +1,125 @@
+/* state-override.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([
+	'aloha/core',
+	'jquery',
+	'aloha/selection',
+	'aloha/command',
+	'util/dom2',
+	'PubSub'
+], function (
+	Aloha,
+	jQuery,
+	Selection,
+	Command,
+	Dom,
+	PubSub
+) {
+	'use strict';
+
+	var enabled = Aloha.settings.stateOverride;
+
+	// https://dvcs.w3.org/hg/editing/raw-file/tip/editing.html#state-override
+	// "Whenever the number of ranges in the selection changes to
+	// something different, and whenever a boundary point of the range
+	// at a given index in the selection changes to something different,
+	// the state override and value override must be unset for every
+	// command."
+	Aloha.bind('aloha-selection-changed', function (event, range) {
+		if (Command.resetOverrides(range)) {
+			// Because the UI may reflect the any potentially state
+			// overrides that are now no longer in effect, we must
+			// redraw the UI according to the current selection.
+			PubSub.pub('aloha.selection.context-change', {
+				range: range,
+				event: event
+			});
+		}
+	});
+
+	function keyPressHandler(event) {
+		if (!enabled) {
+			return;
+		}
+		if (event.altKey || event.ctrlKey || !event.which) {
+			return;
+		}
+		var selection = Aloha.getSelection();
+		if (!selection.getRangeCount()) {
+			return;
+		}
+		var text = String.fromCharCode(event.which);
+		var range = selection.getRangeAt(0);
+		// Because execCommand may invoke for example the bold command,
+		// which selects the inserted text to make it bold, and by doing
+		// so fires a selection-changed event. This is unnecessary and
+		// causes a flicker in the UI where the bold state of the button
+		// switches from bold to unbold and to bold again.
+		Aloha.Selection.preventSelectionChanged();
+		Command.execCommand('insertText', null, text, range);
+		// Because we handled the character insert ourselves via
+		// insertText we must not let the browser's default action
+		// insert the character a second time.
+		event.preventDefault();
+	}
+
+	function rangeFromRangeObject(alohaRange) {
+		var range = Aloha.createRange();
+		range.setStart(alohaRange.startContainer, alohaRange.startOffset);
+		range.setEnd(alohaRange.endContainer, alohaRange.endOffset);
+		return range;
+	}
+
+	function setWithRangeObject(command, state, rangeObject) {
+		if (!enabled) {
+			return;
+		}
+		var range = rangeFromRangeObject(rangeObject);
+		Command.setStateOverride(command, state, range);
+		// Because without doing rangeObject.select(), the
+		// next insertText command (see editable.js) will
+		// not be reached and instead the browsers default
+		// insert behaviour will be applied (which doesn't
+		// know anything about state overrides). I don't
+		// know the exact reasons why; probably some
+		// stopPropagation somewhere by some plugin.
+		rangeObject.select();
+	}
+
+	function enabledAccessor(trueFalse) {
+		if (null != trueFalse) {
+			enabled = trueFalse;
+		}
+		return enabled;
+	}
+
+	return {
+		enabled: enabledAccessor,
+		keyPressHandler: keyPressHandler,
+		setWithRangeObject: setWithRangeObject
+	};
+});

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

@@ -1,14 +1,18 @@
+/** MIT License (c) copyright B Cavalier & J Hann */
+
 /**
- * Copyright (c) 2010 unscriptable.com
+ * curl css! plugin
+ *
+ * Licensed under the MIT License at:
+ * 		http://www.opensource.org/licenses/mit-license.php
+ *
  */
 
-/*jslint browser:true, on:true, sub:true */
-
-(function (doc) {
-
+(function (global) {
+"use strict";
 
 /*
- * RequireJS css! plugin
+ * AMD 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.
@@ -76,8 +80,8 @@
 */
 
 
-var
-	// compressibility shortcuts
+	var
+		// compressibility shortcuts
 		onreadystatechange = 'onreadystatechange',
 		onload = 'onload',
 		createElement = 'createElement',
@@ -89,161 +93,282 @@ var
 			// true if the onload event handler works
 			// "event-link-onload" : false
 		},
+		// this actually tests for absolute urls and root-relative urls
+		// they're both non-relative
+		nonRelUrlRe = /^\/|^[^:]*:\/\//,
+		// Note: this will fail if there are parentheses in the url
+		findUrlRx = /url\s*\(['"]?([^'"\)]*)['"]?\)/g,
+		// doc will be undefined during a build
+		doc = global.document,
 		// 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];
-	}
+		head,
+		// collection of modules that have been written to the built file
+		built = {};
+			
+		if (doc) {
+			head = doc.head || (doc.head = doc.getElementsByTagName('head')[0]);
+		}
 
-	// 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);
+		function has (feature) {
+			return features[feature];
 		}
-		})(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 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;
 		}
-	};
-}
-
-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;
 	}
-	return parts;
-}
 
-function createLink (doc, optHref) {
+	var collectorSheet;
+	function createLink (doc, optHref) {
+		// detect if we need to avoid 31-sheet limit in IE (how to detect this for realz?)
+		if (document.createStyleSheet) {
+			if (!collectorSheet) {
+				collectorSheet = document.createStyleSheet();
+			}
+			if (document.styleSheets.length >= 30) {
+				moveLinksToCollector();
+			}
+		}
 		var link = doc[createElement]('link');
-	link.rel = "stylesheet";
-	link.type = "text/css";
-	if (optHref) {
-		link.href = optHref;
+		link.rel = "stylesheet";
+		link.type = "text/css";
+		link.setAttribute('_curl_movable', true);
+		if (optHref) {
+			link.href = optHref;
+		}
+		return link;
 	}
-	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);
+
+	var testEl;
+	function styleIsApplied () {
+		// 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 stylesheets 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 domReady() before
+		// rendering widgets / components that need the css to be ready.
+		if (!testEl) {
+				testEl = doc[createElement]('div');
+			testEl.id = '_cssx_load_test';
+			head.appendChild(testEl);
+		}
+		return doc.defaultView.getComputedStyle(testEl, null).marginTop == '-5px';
 	}
-	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) {
-        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;
+
+	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. TODO: find a better way
+			if (ready && {}.toString.call(window.chrome) == '[object Chrome]') {
+				// fwiw, we'll never get this far if this is an XD stylesheet
+				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) {
+			setTimeout(function () { ssWatcher(params, cb); }, params.wait);
+		}
 	}
-	loadHandler(params, cbOnce);
-		if (!has("event-link-onload")) ssWatcher(params, cbOnce);
-}
 
-function cleanup (params) {
-	var link = params.link;
+	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;
-}
+	}
+
+	function moveLinksToCollector () {
+		// IE 6-8 fails when over 31 sheets, so we collect them.
+		// Note: this hack relies on proper cache headers.
+		var link, links, collector, pos = 0;
+		collector = collectorSheet;
+		collectorSheet = null; // so a new one will be created
+		links = document.getElementsByTagName('link');
+		while ((link = links[pos])) {
+			if (link.getAttribute('_curl_movable')) {
+				// move to the collectorSheet (note: bad cache directive will cause a re-download)
+				collector.addImport(link.href);
+				// remove from document
+				link.parentNode && link.parentNode.removeChild(link);
+			}
+			else {
+				// skip this sheet
+				pos++;
+			}
+		}
+	}
+
+	/***** style element functions *****/
+	
+	var currentStyle;
+
+	function translateUrls (cssText, baseUrl) {
+		return cssText.replace(findUrlRx, function (all, url) {
+			return 'url("' + translateUrl(url, baseUrl) + '")';
+		});
+	}
+
+	function translateUrl (url, parentPath) {
+		// if this is a relative url
+		if (!nonRelUrlRe.test(url)) {
+			// append path onto it
+			url = parentPath + url;
+		}
+		return url;
+	}
+
+	function createStyle (cssText) {
+		clearTimeout(createStyle.debouncer);
+		if (createStyle.accum) {
+			createStyle.accum.push(cssText);
+		}
+		else {
+			createStyle.accum = [cssText];
+			currentStyle = doc.createStyleSheet ? doc.createStyleSheet() :
+				head.appendChild(doc.createElement('style'));
+		}
+
+		createStyle.debouncer = setTimeout(function () {
+			// Note: IE 6-8 won't accept the W3C method for inserting css text
+			var style, allCssText;
+
+			style = currentStyle;
+			currentStyle = undef;
+
+			allCssText = createStyle.accum.join('\n');
+			createStyle.accum = undef;
+
+			// for safari which chokes on @charset "UTF-8";
+			allCssText = allCssText.replace(/.+charset[^;]+;/g, '');
+
+			// TODO: hoist all @imports to the top of the file to follow w3c spec
+
+			'cssText' in style ? style.cssText = allCssText :
+				style.appendChild(doc.createTextNode(allCssText));
+				
+		}, 0);
+		
+		return currentStyle;
+	}
+
+	function createSheetProxy (sheet) {
+		return {
+			cssRules: function () {
+				return sheet.cssRules || sheet.rules;
+			},
+			insertRule: sheet.insertRule || function (text, index) {
+				var parts = text.split(/\{|\}/g);
+				sheet.addRule(parts[0], parts[1], index);
+				return index;
+			},
+			deleteRule: sheet.deleteRule || function (index) {
+				sheet.removeRule(index);
+				return index;
+			},
+			sheet: function () {
+				return sheet;
+			}
+		};
+	}
 
 /***** finally! the actual plugin *****/
 
-var plugin = {
+	define(/*=='css',==*/ {
+
+		'normalize': function (resourceId, normalize) {
+			var resources, normalized;
+
+			if (!resourceId) return resourceId;
 
-		//prefix: 'css',
+			resources = resourceId.split(",");
+			normalized = [];
+
+			for (var i = 0, len = resources.length; i < len; i++) {
+				normalized.push(normalize(resources[i]));
+			}
+
+			return normalized.join(',');
+		},
 
-		'load': function (resourceDef, require, callback, config) {
-				var resources = resourceDef.split(","),
-					loadingCount = resources.length;
+		'load': function (resourceId, require, callback, config) {
+			var resources = (resourceId || '').split(","),
+				loadingCount = resources.length;
 
 			// all detector functions must ensure that this function only gets
 			// called once per stylesheet!
@@ -254,60 +379,77 @@ var plugin = {
 				// (so 0 msec is enough time).
 				if(--loadingCount == 0){
 					// TODO: move this setTimeout to loadHandler
-					setTimeout(function () { callback(link); }, 0);
+					setTimeout(function () { callback(createSheetProxy(link.sheet || link.styleSheet)); }, 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);
+			if (!resourceId) {
+				// return the run-time API
+				callback({
+					'translateUrls': function (cssText, baseId) {
+						var baseUrl;
+						baseUrl = require['toUrl'](baseId);
+						baseUrl = baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1);
+						return translateUrls(cssText, baseUrl);
+					},
+					'injectStyle': function (cssText) {
+						return createStyle(cssText);
+					},
+
+					'proxySheet': function (sheet) {
+						// for W3C, `sheet` is a reference to a <style> node so we need to
+						// return the sheet property.
+						if (sheet.sheet /* instanceof CSSStyleSheet */) sheet = sheet.sheet;
+						return createSheetProxy(sheet);
+					}
+				});
+			}
+			else {
+
+				// `after` will become truthy once the loop executes a second time
+				for (var i = resources.length - 1, after; i >= 0; i--, after = true) {
+
+					resourceId = resources[i];
+
+					var
+						// TODO: this is a bit weird: find a better way to extract name?
+						opts = parseSuffixes(resourceId),
+						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(createSheetProxy(link.sheet || link.styleSheet));
+					}
+					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;
 				}
 
-				// 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
-
-	};
+		'plugin-builder': './builder/css'
 
-define(plugin);
+	});
 
-})(document);
+})(this);