tinymce-rails 4.3.13 → 4.4.0

data/vendor/assets/javascripts/tinymce/themes/inlite/src/main/js/tinymce/inlite/ui/Toolbar.js

@@ -0,0 +1,126 @@
+/**
+ * Toolbar.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2016 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+define('tinymce/inlite/ui/Toolbar', [
+	'global!tinymce.util.Tools',
+	'global!tinymce.ui.Factory'
+], function (Tools, Factory) {
+	var setActiveItem = function (item, name) {
+		return function(state, args) {
+			var nodeName, i = args.parents.length;
+
+			while (i--) {
+				nodeName = args.parents[i].nodeName;
+				if (nodeName == 'OL' || nodeName == 'UL') {
+					break;
+				}
+			}
+
+			item.active(state && nodeName == name);
+		};
+	};
+
+	var getSelectorStateResult = function (itemName, item) {
+		var result = function (selector, handler) {
+			return {
+				selector: selector,
+				handler: handler
+			};
+		};
+
+		var activeHandler = function(state) {
+			item.active(state);
+		};
+
+		var disabledHandler = function (state) {
+			item.disabled(state);
+		};
+
+		if (itemName == 'bullist') {
+			return result('ul > li', setActiveItem(item, 'UL'));
+		}
+
+		if (itemName == 'numlist') {
+			return result('ol > li', setActiveItem(item, 'OL'));
+		}
+
+		if (item.settings.stateSelector) {
+			return result(item.settings.stateSelector, activeHandler);
+		}
+
+		if (item.settings.disabledStateSelector) {
+			return result(item.settings.disabledStateSelector, disabledHandler);
+		}
+
+		return null;
+	};
+
+	var bindSelectorChanged = function (editor, itemName, item) {
+		return function () {
+			var result = getSelectorStateResult(itemName, item);
+			if (result !== null) {
+				editor.selection.selectorChanged(result.selector, result.handler);
+			}
+		};
+	};
+
+	var create = function (editor, name, items) {
+		var toolbarItems = [], buttonGroup;
+
+		if (!items) {
+			return;
+		}
+
+		Tools.each(items.split(/[ ,]/), function(item) {
+			var itemName;
+
+			if (item == '|') {
+				buttonGroup = null;
+			} else {
+				if (Factory.has(item)) {
+					item = {type: item};
+					toolbarItems.push(item);
+					buttonGroup = null;
+				} else {
+					if (!buttonGroup) {
+						buttonGroup = {type: 'buttongroup', items: []};
+						toolbarItems.push(buttonGroup);
+					}
+
+					if (editor.buttons[item]) {
+						itemName = item;
+						item = editor.buttons[itemName];
+
+						if (typeof item == 'function') {
+							item = item();
+						}
+
+						item.type = item.type || 'button';
+
+						item = Factory.create(item);
+						item.on('postRender', bindSelectorChanged(editor, itemName, item));
+						buttonGroup.items.push(item);
+					}
+				}
+			}
+		});
+
+		return Factory.create({
+			type: 'toolbar',
+			layout: 'flow',
+			name: name,
+			items: toolbarItems
+		});
+	};
+
+	return {
+		create: create
+	};
+});

data/vendor/assets/javascripts/tinymce/themes/inlite/src/test/js/atomic/alien/ArrTest.js

@@ -0,0 +1,9 @@
+test('atomic/alien/ArrTest', [
+	'tinymce/inlite/alien/Arr'
+], function (Arr) {
+	var testFlatten = function () {
+		assert.eq(Arr.flatten([1, 2, [3, 4, [5, 6]], [7, 8], 9]), [1, 2, 3, 4, 5, 6, 7, 8, 9]);
+	};
+
+	testFlatten();
+});

data/vendor/assets/javascripts/tinymce/themes/inlite/src/test/js/atomic/alien/UuidTest.js

@@ -0,0 +1,10 @@
+test('atomic/alien/UuidTest', [
+	'tinymce/inlite/alien/Uuid'
+], function (Uuid) {
+	var testUuid = function () {
+		assert.eq(Uuid.uuid('mce').indexOf('mce'), 0);
+		assert.eq(Uuid.uuid('mce') !== Uuid.uuid('mce'), true);
+	};
+
+	testUuid();
+});

data/vendor/assets/javascripts/tinymce/themes/inlite/src/test/js/atomic/core/ConvertTest.js

@@ -0,0 +1,12 @@
+test('atomic/core/ConvertTest', [
+	'tinymce/inlite/core/Convert'
+], function (Convert) {
+	var testConvert = function () {
+		assert.eq({x: 1, y: 2, w: 3, h: 4}, Convert.fromClientRect({left: 1, top: 2, width: 3, height: 4}));
+		assert.eq({x: 2, y: 3, w: 4, h: 5}, Convert.fromClientRect({left: 2, top: 3, width: 4, height: 5}));
+		assert.eq({left: 1, top: 2, width: 3, height: 4, bottom: 2 + 4, right: 1 + 3}, Convert.toClientRect({x: 1, y: 2, w: 3, h: 4}));
+		assert.eq({left: 2, top: 3, width: 4, height: 5, bottom: 3 + 5, right: 2 + 4}, Convert.toClientRect({x: 2, y: 3, w: 4, h: 5}));
+	};
+
+	testConvert();
+});

data/vendor/assets/javascripts/tinymce/themes/inlite/src/test/js/atomic/core/MatcherTest.js

@@ -0,0 +1,51 @@
+test('browser/atomic/MatcherTest', [
+	'tinymce/inlite/core/Matcher'
+], function (Matcher) {
+	var testMatch = function (mockEditor, matches, expectedResult) {
+		var result;
+
+		result = Matcher.match(mockEditor, matches);
+		assert.eq(expectedResult, result);
+	};
+
+	var match = function (key) {
+		return function (editor) {
+			return editor[key];
+		};
+	};
+
+	var testMatcher = function () {
+		var mockEditor = {
+			success1: 'success1',
+			success2: 'success2',
+			failure: null
+		};
+
+		testMatch(mockEditor, [
+			match('success1')
+		], 'success1');
+
+		testMatch(mockEditor, [
+			match(null),
+			match('success2')
+		], 'success2');
+
+		testMatch(mockEditor, [
+			match('success1'),
+			match('success2')
+		], 'success1');
+
+		testMatch(mockEditor, [
+			match(null)
+		], null);
+
+		testMatch(mockEditor, [
+			match(null),
+			match(null)
+		], null);
+
+		testMatch(mockEditor, [], null);
+	};
+
+	testMatcher();
+});

data/vendor/assets/javascripts/tinymce/themes/inlite/src/test/js/atomic/core/UrlTypeTest.js

@@ -0,0 +1,25 @@
+test('atomic/core/UrlTypeTest', [
+	'tinymce/inlite/core/UrlType'
+], function (UrlType) {
+	var testIsDomainLike = function () {
+		var mostUsedTopLevelDomains = [
+			'com', 'org', 'edu', 'gov', 'uk', 'net', 'ca', 'de', 'jp',
+			'fr', 'au', 'us', 'ru', 'ch', 'it', 'nl', 'se', 'no', 'es', 'mil'
+		];
+
+		assert.eq(UrlType.isDomainLike('www.site.com'), true);
+		assert.eq(UrlType.isDomainLike('www.site.xyz'), true);
+		assert.eq(UrlType.isDomainLike('   www.site.xyz'), true);
+		assert.eq(UrlType.isDomainLike('site.xyz'), false);
+
+		mostUsedTopLevelDomains.forEach(function (tld) {
+			assert.eq(UrlType.isDomainLike('site.' + tld), true);
+			assert.eq(UrlType.isDomainLike('  site.' + tld), true);
+			assert.eq(UrlType.isDomainLike('site.' + tld + '  '), true);
+		});
+
+		assert.eq(UrlType.isDomainLike('/a/b'), false);
+	};
+
+	testIsDomainLike();
+});

data/vendor/assets/javascripts/tinymce/themes/inlite/src/test/js/browser/ThemeTest.js

@@ -0,0 +1,202 @@
+asynctest('browser/core/ThemeTest', [
+	'ephox.mcagar.api.TinyLoader',
+	'ephox.mcagar.api.TinyApis',
+	'ephox.mcagar.api.TinyActions',
+	'ephox.mcagar.api.TinyDom',
+	'tinymce/inlite/Theme',
+	'ephox.agar.api.Pipeline',
+	'ephox.agar.api.Chain',
+	'ephox.agar.api.UiFinder',
+	'ephox.agar.api.Mouse',
+	'ephox.agar.api.GeneralSteps',
+	'ephox.agar.api.UiControls',
+	'ephox.agar.api.FocusTools'
+], function (TinyLoader, TinyApis, TinyActions, TinyDom, Theme, Pipeline, Chain, UiFinder, Mouse, GeneralSteps, UiControls, FocusTools) {
+	var success = arguments[arguments.length - 2];
+	var failure = arguments[arguments.length - 1];
+	var dialogRoot = TinyDom.fromDom(document.body);
+
+	var cWaitForContextToolbar = Chain.fromChainsWith(dialogRoot, [
+		UiFinder.cWaitForState('label', '.mce-tinymce-inline', function (elm) {
+			return elm.dom().style.display === "";
+		})
+	]);
+
+	var cClickToolbarButton = function (ariaLabel) {
+		return Chain.fromChains([
+			UiFinder.cFindIn('div[aria-label="' + ariaLabel + '"]'),
+			Mouse.cTrueClick
+		]);
+	};
+
+	var sClickFocusedButton = Chain.asStep(TinyDom.fromDom(document), [
+		FocusTools.cGetFocused,
+		Mouse.cTrueClick
+	]);
+
+	var sClickContextButton = function (ariaLabel) {
+		return Chain.asStep({}, [
+			cWaitForContextToolbar,
+			cClickToolbarButton(ariaLabel)
+		]);
+	};
+
+	var sWaitForToolbar = function () {
+		return Chain.asStep({}, [
+			cWaitForContextToolbar
+		]);
+	};
+
+	var sBoldTests = function (tinyApis) {
+		return GeneralSteps.sequence([
+			tinyApis.sSetContent('<p>a</p>'),
+			tinyApis.sSetSelection([0, 0], 0, [0, 0], 1),
+			sClickContextButton('Bold'),
+			tinyApis.sAssertContent('<p><strong>a</strong></p>')
+		]);
+	};
+
+	var sH2Tests = function (tinyApis) {
+		return GeneralSteps.sequence([
+			tinyApis.sSetContent('<p>a</p>'),
+			tinyApis.sSetSelection([0, 0], 0, [0, 0], 1),
+			sClickContextButton('Heading 2'),
+			tinyApis.sAssertContent('<h2>a</h2>')
+		]);
+	};
+
+	var sInsertLink = function (url) {
+		return Chain.asStep({}, [
+			cWaitForContextToolbar,
+			cClickToolbarButton('Insert/Edit link'),
+			cWaitForContextToolbar,
+			UiFinder.cFindIn('input'),
+			UiControls.cSetValue(url),
+			cWaitForContextToolbar,
+			cClickToolbarButton('Ok')
+		]);
+	};
+
+	var cWaitForConfirmDialog = Chain.fromChainsWith(dialogRoot, [
+		UiFinder.cWaitForState('window element', '.mce-window', function () {
+			return true;
+		})
+	]);
+
+	var cClickButton = function (btnText) {
+		return Chain.fromChains([
+			UiFinder.cFindIn('button:contains("' + btnText + '")'),
+			Mouse.cTrueClick
+		]);
+	};
+
+	var sClickConfirmButton = function (btnText) {
+		return Chain.asStep({}, [
+			cWaitForConfirmDialog,
+			cClickButton(btnText)
+		]);
+	};
+
+	var sInsertLinkConfirmPrefix = function (url, btnText) {
+		return GeneralSteps.sequence([
+			sInsertLink(url),
+			sClickConfirmButton(btnText)
+		]);
+	};
+
+	var sUnlink = Chain.asStep({}, [
+		cWaitForContextToolbar,
+		cClickToolbarButton('Insert/Edit link'),
+		cWaitForContextToolbar,
+		cClickToolbarButton('Remove link')
+	]);
+
+	var sLinkTests = function (tinyApis) {
+		var sContentActionTest = function (inputHtml, spath, soffset, fpath, foffset, expectedHtml, sAction) {
+			return GeneralSteps.sequence([
+				tinyApis.sSetContent(inputHtml),
+				tinyApis.sSetSelection(spath, soffset, fpath, foffset),
+				sAction,
+				tinyApis.sAssertContent(expectedHtml)
+			]);
+		};
+
+		var sLinkTest = function (inputHtml, spath, soffset, fpath, foffset, url, expectedHtml) {
+			return sContentActionTest(inputHtml, spath, soffset, fpath, foffset, expectedHtml, sInsertLink(url));
+		};
+
+		var sUnlinkTest = function (inputHtml, spath, soffset, fpath, foffset, expectedHtml) {
+			return sContentActionTest(inputHtml, spath, soffset, fpath, foffset, expectedHtml, sUnlink);
+		};
+
+		var sLinkWithConfirmOkTest = function (inputHtml, spath, soffset, fpath, foffset, url, expectedHtml) {
+			return sContentActionTest(inputHtml, spath, soffset, fpath, foffset, expectedHtml, sInsertLinkConfirmPrefix(url, 'Ok'));
+		};
+
+		var sLinkWithConfirmCancelTest = function (inputHtml, spath, soffset, fpath, foffset, url, expectedHtml) {
+			return sContentActionTest(inputHtml, spath, soffset, fpath, foffset, expectedHtml, sInsertLinkConfirmPrefix(url, 'Cancel'));
+		};
+
+		return GeneralSteps.sequence([
+			sLinkWithConfirmOkTest('<p>a</p>', [0, 0], 0, [0, 0], 1, 'www.site.com', '<p><a href="http://www.site.com">a</a></p>'),
+			sLinkWithConfirmCancelTest('<p>a</p>', [0, 0], 0, [0, 0], 1, 'www.site.com', '<p><a href="www.site.com">a</a></p>'),
+			sLinkTest('<p>a</p>', [0, 0], 0, [0, 0], 1, '#1', '<p><a href="#1">a</a></p>'),
+			sLinkTest('<p><a id="x" href="#1">a</a></p>', [0, 0, 0], 0, [0, 0, 0], 1, '#2', '<p><a id="x" href="#2">a</a></p>'),
+			sLinkTest('<p><a href="#3">a</a></p>', [0, 0, 0], 0, [0, 0, 0], 1, '', '<p>a</p>'),
+			sUnlinkTest('<p><a id="x" href="#1">a</a></p>', [0, 0, 0], 0, [0, 0, 0], 1, '<p>a</p>')
+		]);
+	};
+
+	var sInsertTableTests = function (tinyApis) {
+		return GeneralSteps.sequence([
+			tinyApis.sSetContent('<p><br></p><p>b</p>'),
+			tinyApis.sSetCursor([0], 0),
+			sClickContextButton('Insert table'),
+			tinyApis.sAssertContent([
+					'<table style="width: 100%;">',
+						'<tbody>',
+							'<tr>',
+								'<td>&nbsp;</td>',
+								'<td>&nbsp;</td>',
+							'</tr>',
+							'<tr>',
+								'<td>&nbsp;</td>',
+								'<td>&nbsp;</td>',
+							'</tr>',
+						'</tbody>',
+					'</table>',
+					'<p>b</p>'
+				].join('\n')
+			)
+		]);
+	};
+
+	var sAriaTests = function (tinyApis, tinyActions) {
+		return GeneralSteps.sequence([
+			tinyApis.sSetContent('<p>a</p>'),
+			tinyApis.sSetSelection([0, 0], 0, [0, 0], 1),
+			sWaitForToolbar(),
+			tinyActions.sContentKeydown(121, {alt: true}),
+			sClickFocusedButton,
+			tinyApis.sAssertContent('<p><strong>a</strong></p>')
+		]);
+	};
+
+	TinyLoader.setup(function (editor, onSuccess, onFailure) {
+		var tinyApis = TinyApis(editor), tinyActions = TinyActions(editor);
+
+		Pipeline.async({}, [
+			sBoldTests(tinyApis),
+			sH2Tests(tinyApis),
+			sLinkTests(tinyApis),
+			sInsertTableTests(tinyApis),
+			sAriaTests(tinyApis, tinyActions)
+		], onSuccess, onFailure);
+	}, {
+		theme: 'inlite',
+		plugins: 'image table link paste contextmenu textpattern',
+		insert_toolbar: 'quickimage media quicktable',
+		selection_toolbar: 'bold italic | quicklink h1 h2 blockquote',
+		inline: true
+	}, success, failure);
+});

data/vendor/assets/javascripts/tinymce/themes/inlite/src/test/js/browser/alien/BookmarkTest.js

@@ -0,0 +1,65 @@
+asynctest('browser/alien/BookmarkTest', [
+	'ephox/tinymce',
+	'ephox.agar.api.Pipeline',
+	'ephox.agar.api.Chain',
+	'ephox.agar.api.Cursors',
+	'ephox.agar.api.Assertions',
+	'ephox.mcagar.api.TinyDom',
+	'tinymce/inlite/alien/Bookmark'
+], function (tinymce, Pipeline, Chain, Cursors, Assertions, TinyDom, Bookmark) {
+	var success = arguments[arguments.length - 2];
+	var failure = arguments[arguments.length - 1];
+
+	var toNativeRange = function (range) {
+		var domRange = document.createRange();
+		domRange.setStart(range.start().dom(), range.soffset());
+		domRange.setEnd(range.finish().dom(), range.foffset());
+		return domRange;
+	};
+
+	var rangeToBookmark = function (dom) {
+		return function (range) {
+			return Bookmark.create(dom, range);
+		};
+	};
+
+	var bookmarkToRange = function (dom) {
+		return function (bookmark) {
+			return Bookmark.resolve(dom, bookmark);
+		};
+	};
+
+	var cAssertRangeEq = function (expected) {
+		return Chain.op(function (actual) {
+			Assertions.assertEq(expected.start().dom(), actual.startContainer, 'Not equal startContainer');
+			Assertions.assertEq(expected.soffset(), actual.startOffset, 'Not equal startOffset');
+			Assertions.assertEq(expected.finish().dom(), actual.endContainer, 'Not equal endContainer');
+			Assertions.assertEq(expected.foffset(), actual.endOffset, 'Not equal endOffset');
+		});
+	};
+
+	var sTestBookmark = function (html, path) {
+		var dom = tinymce.DOM;
+		var elm = TinyDom.fromDom(dom.create('div', {}, html));
+
+		return Chain.asStep(elm, [
+			Cursors.cFollowPath(Cursors.pathFrom(path)),
+			Chain.mapper(toNativeRange),
+			Chain.mapper(rangeToBookmark(dom)),
+			Chain.mapper(bookmarkToRange(dom)),
+			cAssertRangeEq(Cursors.calculate(elm, Cursors.pathFrom(path)))
+		]);
+	};
+
+	Pipeline.async({}, [
+		sTestBookmark('abc', {element: [0], offset: 0}),
+		sTestBookmark('abc', {element: [0], offset: 1}),
+		sTestBookmark('abc', {start: {element: [0], offset: 0}, finish: {element: [0], offset: 1}}),
+		sTestBookmark('<b>a</b>', {element: [0, 0], offset: 0}),
+		sTestBookmark('<b>a</b>', {element: [0, 0], offset: 0}),
+		sTestBookmark('<b>a</b>', {start: {element: [0, 0], offset: 0}, finish: {element: [0, 0], offset: 1}}),
+		sTestBookmark('<b>a</b><b>b</b>', {start: {element: [0, 0], offset: 0}, finish: {element: [1, 0], offset: 1}})
+	], function () {
+		success();
+	}, failure);
+});