locomotive-aloha-rails 0.23.2.1 → 0.23.2.2

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

@@ -72,6 +72,7 @@ define([
 	'util/dom2',
 	'util/functions',
 	'util/misc',
+	'util/browser',
 	'PubSub'
 ], function (
 	$,
@@ -84,6 +85,7 @@ define([
 	Dom,
 	Functions,
 	Misc,
+	Browser,
 	PubSub
 ) {
 	'use strict';
@@ -325,7 +327,12 @@ define([
 		var data = $elem.attr('data-aloha-ephemera-attr');
 		var i;
 		var attrs;
-		$elem.removeAttr('data-aloha-ephemera-attr');
+		// Because IE7 crashes if we remove this attribute. If the
+		// dom-to-xhtml plugin is turned on, it will handle the removal
+		// of this attribute during serialization.
+		if (!Browser.ie7) {
+			$elem.removeAttr('data-aloha-ephemera-attr');
+		}
 		if (typeof data === 'string') {
 			attrs = Strings.words(data);
 			for (i = 0; i < attrs.length; i++) {

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

@@ -27,6 +27,7 @@
 define([
 	'aloha/core',
 	'util/class',
+	'util/html',
 	'jquery',
 	'aloha/ecma5shims',
 	'aloha/console',
@@ -34,6 +35,7 @@ define([
 ], function (
 	Aloha,
 	Class,
+	Html,
 	jQuery,
 	shims,
 	console,
@@ -384,14 +386,13 @@ define([
 
 			// ENTER
 			if (event.keyCode === 13) {
-				if (event.shiftKey) {
+				if (event.shiftKey || !Html.allowNestedParagraph(Aloha.activeEditable)) {
 					Aloha.execCommand('insertlinebreak', false);
 					return false;
 				}
 				Aloha.execCommand('insertparagraph', false);
 				return false;
 			}
-
 			return true;
 		},
 

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

@@ -80,6 +80,12 @@ define([
 	 *                            successfully initialized.
 	 */
 	function initializePlugins(plugins, callback) {
+		if (0 === plugins.length) {
+			if (callback) {
+				callback();
+			}
+			return;
+		}
 		var numToEnable = plugins.length;
 		var onInit = function () {
 			if (0 === --numToEnable && callback) {
@@ -102,6 +108,8 @@ define([
 				} else {
 					onInit();
 				}
+			} else {
+				onInit();
 			}
 		}
 	}

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

@@ -910,7 +910,7 @@ define([
 			var that = this;
 			this.element.addClass('collapsed');
 			this.content.stop().animate(
-				{ height: 5 },
+				{ height: 3 },
 				250,
 				'easeOutExpo',
 				function () {

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

@@ -27,42 +27,38 @@
 define([
 	'aloha/core',
 	'jquery',
-	'aloha/selection',
 	'aloha/command',
 	'util/dom2',
+	'util/maps',
+	'util/range',
 	'PubSub'
 ], function (
 	Aloha,
 	jQuery,
-	Selection,
 	Command,
 	Dom,
+	Maps,
+	RangeObject,
 	PubSub
 ) {
 	'use strict';
 
-	var enabled = Aloha.settings.stateOverride;
+	// Because we want to provide an easy way to disable the state-override feature.
+	var enabled = Aloha.settings.stateOverride !== false;
+	var overrides = null;
+	var overrideRange = null;
 
-	// 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 rangeObjectFromRange(range) {
+		return new RangeObject(range);
+	}
+
+	function clear() {
+		overrideRange = null;
+		overrides = null;
+	}
 
 	function keyPressHandler(event) {
-		if (!enabled) {
+		if (!overrides) {
 			return;
 		}
 		if (event.altKey || event.ctrlKey || !event.which) {
@@ -74,32 +70,37 @@ define([
 		}
 		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);
+		Dom.insertSelectText(text, range);
+		Maps.forEach(overrides, function (formatFn, command) {
+			formatFn(command, range);
+		});
+		Dom.collapseToEnd(range);
+		selection.removeAllRanges();
+		selection.addRange(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 set(command, range, formatFn) {
+		if (!enabled) {
+			return;
+		}
+		overrideRange = range;
+		overrides = overrides || {};
+		overrides[command] = formatFn;
 	}
 
-	function setWithRangeObject(command, state, rangeObject) {
+	function setWithRangeObject(command, rangeObject, formatFn) {
 		if (!enabled) {
 			return;
 		}
-		var range = rangeFromRangeObject(rangeObject);
-		Command.setStateOverride(command, state, range);
+		set(command, Dom.rangeFromRangeObject(rangeObject), function (command, range) {
+			var rangeObject = rangeObjectFromRange(range);
+			formatFn(command, rangeObject);
+			Dom.setRangeFromRef(range, rangeObject);
+		});
 		// Because without doing rangeObject.select(), the
 		// next insertText command (see editable.js) will
 		// not be reached and instead the browsers default
@@ -117,9 +118,30 @@ define([
 		return enabled;
 	}
 
+	// 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 (overrideRange && !Dom.areRangesEq(overrideRange, range)) {
+			clear();
+			// 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
+			});
+		}
+	});
+
 	return {
 		enabled: enabledAccessor,
 		keyPressHandler: keyPressHandler,
-		setWithRangeObject: setWithRangeObject
+		setWithRangeObject: setWithRangeObject,
+		set: set,
+		clear: clear
 	};
 });

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

@@ -24,7 +24,7 @@
  * provided you include this license notice and a URL through which
  * recipients can access the Corresponding Source.
  */
-define([], function () {
+define(['util/functions'], function (Fn) {
 	'use strict';
 
 	/**
@@ -104,10 +104,10 @@ define([], function () {
 	}
 
 	/**
-	 * ECMAScript map replacement
+	 * 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 exactly what one expects.
+	 * It's not exactly according to standard, but it does what one expects.
 	 */
 	function map(a, fn) {
 		var i, len, result = [];
@@ -169,7 +169,7 @@ define([], function () {
 	 * Arrays.reduce([2, 3, 4], 1, function (a, b) { return a + b; });
 	 * returns the result of (((1 + 2) + 3) + 4)
 	 *
-	 * Emulates ECMA5 Array.reduce.
+	 * Emulates ECMAScript edition 5 Array.reduce.
 	 *
 	 * @param a
 	 *        An array of values.
@@ -206,7 +206,9 @@ define([], function () {
 	}
 
 	/**
-	 * Emulates ECMA5 Array.forEach.
+	 * For each item in xs, call cb(item, index, xs).
+	 *
+	 * Emulates ECMAScript edition 5 Array.forEach.
 	 */
 	function forEach(xs, cb) {
 		var i,
@@ -216,6 +218,33 @@ define([], function () {
 		}
 	}
 
+	/**
+	 * 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.
 	 */
@@ -225,16 +254,34 @@ define([], function () {
 		});
 	}
 
+	/**
+	 * 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
+		intersect: intersect,
+		second: second,
+		last: last
 	};
 });

data/vendor/assets/javascripts/aloha/lib/util/boundary-markers.js

@@ -0,0 +1,86 @@
+define(['util/dom2', 'util/arrays', 'util/strings'], function (Dom, Arrays, Strings) {
+	'use strict';
+
+	function insert(range) {
+		var leftMarkerChar  = (3 === range.startContainer.nodeType ? '[' : '{');
+		var rightMarkerChar = (3 === range.endContainer.nodeType   ? ']' : '}');
+		Dom.splitTextContainers(range);
+		var leftMarker = document.createTextNode(leftMarkerChar);
+		var rightMarker = document.createTextNode(rightMarkerChar);
+		var start = Dom.cursorFromBoundaryPoint(range.startContainer, range.startOffset);
+		var end = Dom.cursorFromBoundaryPoint(range.endContainer, range.endOffset);
+		start.insert(leftMarker);
+		end.insert(rightMarker);
+	}
+
+	function extract(rootElem, range) {
+		var markers = ['[', '{', '}', ']'];
+		var markersFound = 0;
+		function setBoundaryPoint(marker, node) {
+			var setFn;
+			if (0 === markersFound) {
+				setFn = 'setStart';
+				if (marker !== '[' && marker !== '{') {
+					throw "end marker before start marker";
+				}
+			} else if (1 === markersFound) {
+				setFn = 'setEnd';
+				if (marker !== ']' && marker !== '}') {
+					throw "start marker before end marker";
+				}
+			} else {
+				throw "Too many markers";
+			}
+			markersFound += 1;
+			if (marker === '[' || marker === ']') {
+				var previousSibling = node.previousSibling;
+				if (!previousSibling || 3 !== previousSibling.nodeType) {
+					previousSibling = document.createTextNode('');
+					node.parentNode.insertBefore(previousSibling, node);
+				}
+				range[setFn].call(range, previousSibling, previousSibling.length);
+				// Because we have set a text offset.
+				return false;
+			} else { // marker === '{' || marker === '}'
+				range[setFn].call(range, node.parentNode, Dom.nodeIndex(node));
+				// Because we have set a non-text offset.
+				return true;
+			}
+		}
+		function extractMarkers(node) {
+			if (3 !== node.nodeType) {
+				return;
+			}
+			var text = node.nodeValue;
+			var parts = Strings.splitIncl(text, /[\[\{\}\]]/g);
+			// Because modifying every text node when there can be
+			// only two markers seems like too much overhead.
+			if (!Arrays.contains(markers, parts[0]) && parts.length < 2) {
+				return;
+			}
+			// Because non-text boundary positions must not be joined again.
+			var forceNextSplit = false;
+			Arrays.forEach(parts, function (part, i) {
+				// Because we don't want to join text nodes we haven't split.
+				forceNextSplit = forceNextSplit || (i === 0);
+				if (Arrays.contains(markers, part)) {
+					forceNextSplit = setBoundaryPoint(part, node);
+				} else if (!forceNextSplit && node.previousSibling && 3 === node.previousSibling.nodeType) {
+					node.previousSibling.insertData(node.previousSibling.length, part);
+				} else {
+					node.parentNode.insertBefore(document.createTextNode(part), node);
+				}
+			});
+			node.parentNode.removeChild(node);
+		}
+		Dom.walkRec(rootElem, extractMarkers);
+		if (2 !== markersFound) {
+			throw "Missing one or both markers";
+		}
+	}
+
+	return {
+		insert: insert,
+		extract: extract
+	};
+});

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

@@ -25,19 +25,25 @@
  * recipients can access the Corresponding Source.
  */
 define([
+	'aloha/core',
 	'jquery',
 	'util/functions',
 	'util/maps',
 	'util/arrays',
 	'util/strings',
-	'util/browser'
+	'util/browser',
+	'util/dom',
+	'util/range'
 ], function (
+	Aloha,
 	$,
 	Fn,
 	Maps,
 	Arrays,
 	Strings,
-	Browser
+	Browser,
+	Dom1,
+	RangeObject
 ) {
 	'use strict';
 
@@ -293,7 +299,6 @@ define([
 		return index;
 	}
 
-
 	function nodeIndex(node) {
 		var ret = 0;
 		while (node.previousSibling) {
@@ -304,6 +309,7 @@ define([
 	}
 
 	/**
+	 * Can't use elem.childNodes.length because
 	 * http://www.quirksmode.org/dom/w3c_core.html
 	 * "IE up to 8 does not count empty text nodes."
 	 */
@@ -347,7 +353,7 @@ define([
 		return node;
 	}
 
-	function shallowRemove(node) {
+	function removeShallow(node) {
 		var parent = node.parentNode;
 		moveNextAll(parent, node.firstChild, node);
 		parent.removeChild(node);
@@ -506,6 +512,24 @@ define([
 		});
 	}
 
+	function next(node, until, arg) {
+		while (node && !until(node, arg)) {
+			node = node.nextSibling;
+		}
+		return node;
+	}
+
+	function parent(node, until, arg) {
+		while (node && !until(node, arg)) {
+			node = node.parentNode;
+		}
+		return node;
+	}
+
+	function isTextNode(node) {
+		return 3 === node.nodeType;
+	}
+
 	function splitTextNode(node, offset) {
 		// Because node.splitText() is buggy on IE, split it manually.
 		// http://www.quirksmode.org/dom/w3c_core.html
@@ -543,10 +567,26 @@ define([
 		range[setProp].call(range, container, offset);
 	}
 
-	function splitNodeAdjustRange(splitNode, splitOffset, sc, so, ec, eo, range) {
+	/**
+	 * Splits the given text node at the given offset and, if the given
+	 * range happens to have start or end containers equal to the given
+	 * text node, adjusts it such that start and end position will point
+	 * at the same position in the new text nodes.
+	 *
+	 * It is guaranteed that an adjusted boundary point will not point
+	 * to the end of a text node. Instead, it will point to the next
+	 * node. This guarantee often happens to be useful.
+	 *
+	 * If splitNode is not a text node, does nothing.
+	 */
+	function splitTextNodeAdjustRange(splitNode, splitOffset, range) {
 		if (3 !== splitNode.nodeType) {
 			return;
 		}
+		var sc = range.startContainer;
+		var so = range.startOffset;
+		var ec = range.endContainer;
+		var eo = range.endOffset;
 		var newNodeBeforeSplit = splitTextNode(splitNode, splitOffset);
 		adjustRangeAfterSplit(range, sc, so, 'setStart', splitNode, newNodeBeforeSplit);
 		adjustRangeAfterSplit(range, ec, eo, 'setEnd', splitNode, newNodeBeforeSplit);
@@ -555,44 +595,47 @@ define([
 	function splitTextContainers(range) {
 		var sc = range.startContainer;
 		var so = range.startOffset;
+		splitTextNodeAdjustRange(sc, so, range);
+		// Because the range may have been adjusted.
 		var ec = range.endContainer;
 		var eo = range.endOffset;
-		splitNodeAdjustRange(sc, so, sc, so, ec, eo, range);
-		// Because the range may have been adjusted.
-		sc = range.startContainer;
-		so = range.startOffset;
-		ec = range.endContainer;
-		eo = range.endOffset;
-		splitNodeAdjustRange(ec, eo, sc, so, ec, eo, range);
+		splitTextNodeAdjustRange(ec, eo, range);
 	}
 
 	function walkUntil(node, fn, until, arg) {
 		while (node && !until(node, arg)) {
-			node = fn(node, arg);
+			var next = node.nextSibling;
+			fn(node, arg);
+			node = next;
 		}
-		return node;
 	}
 
 	function walk(node, fn, arg) {
 		walkUntil(node, fn, Fn.returnFalse, arg);
 	}
 
+	/**
+	 * Depth-first postwalk of the given DOM node.
+	 */
 	function walkRec(node, fn, arg) {
 		if (1 === node.nodeType) {
 			walk(node.firstChild, function (node) {
-				return walkRec(node, fn, arg);
+				walkRec(node, fn, arg);
 			});
 		}
-		return fn(node, arg);
+		fn(node, arg);
 	}
 
 	function walkUntilNode(node, fn, untilNode, arg) {
-		return walkUntil(node, fn, function (nextNode) {
+		walkUntil(node, fn, function (nextNode) {
 			return nextNode === untilNode;
 		}, arg);
 	}
 
 	function StableRange(range) {
+		if (!range) {
+			return;
+		}
 		this.startContainer = range.startContainer;
 		this.startOffset = range.startOffset;
 		this.endContainer = range.endContainer;
@@ -710,6 +753,109 @@ define([
 		});
 	}
 
+	function areRangesEq(a, b) {
+		return a.startContainer === b.startContainer
+			&& a.startOffset    === b.startOffset
+			&& a.endContainer   === b.endContainer
+			&& a.endOffset      === b.endOffset;
+	}
+
+	function insertSelectText(text, range) {
+		// Because empty text nodes are generally not nice and even
+		// cause problems with IE8 (elem.childNodes).
+		if (!text.length) {
+			return;
+		}
+		splitTextNodeAdjustRange(range.startContainer, range.startOffset, range);
+		var node = nodeAtOffset(range.startContainer, range.startOffset);
+		var atEnd = isAtEnd(range.startContainer, range.startOffset);
+		// Because if the node following the insert position is already
+		// a text node we can just reuse it.
+		if (!atEnd && 3 === node.nodeType) {
+			node.insertData(0, text);
+			range.setStart(node, 0);
+			range.setEnd(node, text.length);
+			return;
+		}
+		// Because if the node preceding the insert position is already
+		// a text node we can just reuse it.
+		var prev;
+		if (!atEnd) {
+			prev = node.previousSibling;
+		} else {
+			prev = node.lastChild;
+		}
+		if (prev && 3 === prev.nodeType) {
+			prev.insertData(prev.length, text);
+			range.setStart(prev, prev.length - text.length);
+			range.setEnd(prev, prev.length);
+			return;
+		}
+		// Because if we can't reuse any text nodes, we have to insert a
+		// new one.
+		var textNode = document.createTextNode(text);
+		insert(textNode, node, atEnd);
+		range.setStart(textNode, 0);
+		range.setEnd(textNode, textNode.length);
+	}
+
+	function collapseToEnd(range) {
+		range.setStart(range.endContainer, range.endOffset);
+	}
+
+	function rangeFromRangeObject(alohaRange) {
+		var range = Aloha.createRange();
+		range.setStart(alohaRange.startContainer, alohaRange.startOffset);
+		range.setEnd(alohaRange.endContainer, alohaRange.endOffset);
+		return range;
+	}
+
+	function extendToWord(range) {
+		var rangeObject = new RangeObject(range);
+		Dom1.extendToWord(rangeObject);
+		setRangeFromRef(range, rangeObject);
+	}
+
+	function cloneShallow(node) {
+		return node.cloneNode(false);
+	}
+
+	/**
+	 * Sets a style on the given element by modifying it's style attribute.
+	 */
+	function setStyle(node, name, value) {
+		// Because only the empty string removes a style.
+		$(node).css(name, null == value ? '' : value);
+	}
+
+	/**
+	 * Gets a style from the given element's style attribute.
+	 * Note that this is different from the computed/inherited style.
+	 */
+	function getStyle(node, name) {
+		// Because IE7 needs dashesToCamelCase().
+		name = Strings.dashesToCamelCase(name);
+		return node.nodeType === 1 ? node.style[name] : null;
+	}
+
+	/**
+	 * Gets the computed/inherited style of the given node.
+	 * @param node may be a text node.
+	 */
+	function getComputedStyle(node, name) {
+		if (node.currentStyle) {
+			return node.currentStyle[name];
+		}
+		var doc = node.ownerDocument;
+		if (doc.defaultView && doc.defaultView.getComputedStyle) {
+			var styles = doc.defaultView.getComputedStyle(node, null);
+			if (styles) {
+				return styles[name] || styles.getPropertyValue(name);
+			}
+		}
+		return null;
+	}
+
 	return {
 		moveNextAll: moveNextAll,
 		attrNames: attrNames,
@@ -718,7 +864,7 @@ define([
 		indexByName: indexByName,
 		indexByClassHaveList: indexByClassHaveList,
 		outerHtml: outerHtml,
-		shallowRemove: shallowRemove,
+		removeShallow: removeShallow,
 		wrap: wrap,
 		insert: insert,
 		cursor: cursor,
@@ -731,6 +877,9 @@ define([
 		childAndParentsUntilIncl: childAndParentsUntilIncl,
 		childAndParentsUntilNode: childAndParentsUntilNode,
 		childAndParentsUntilInclNode: childAndParentsUntilInclNode,
+		next: next,
+		parent: parent,
+		isTextNode: isTextNode,
 		nodeIndex: nodeIndex,
 		splitTextNode: splitTextNode,
 		splitTextContainers: splitTextContainers,
@@ -743,6 +892,16 @@ define([
 		trimRangeClosingOpening: trimRangeClosingOpening,
 		setRangeFromRef: setRangeFromRef,
 		setRangeStartFromCursor: setRangeStartFromCursor,
-		setRangeEndFromCursor: setRangeEndFromCursor
+		setRangeEndFromCursor: setRangeEndFromCursor,
+		splitTextNodeAdjustRange: splitTextNodeAdjustRange,
+		insertSelectText: insertSelectText,
+		areRangesEq: areRangesEq,
+		collapseToEnd: collapseToEnd,
+		extendToWord: extendToWord,
+		rangeFromRangeObject: rangeFromRangeObject,
+		cloneShallow: cloneShallow,
+		setStyle: setStyle,
+		getStyle: getStyle,
+		getComputedStyle: getComputedStyle
 	};
 });