aloha-rails 0.0.1

data/vendor/assets/javascripts/aloha/plugins/common/commands/lib/commands-plugin.js

@@ -0,0 +1,15 @@
+/*!
+* Aloha Editor
+* Author & Copyright (c) 2010 Gentics Software GmbH
+* aloha-sales@gentics.com
+* Licensed unter the terms of http://www.aloha-editor.com/license.html
+*/
+
+
+define(
+['aloha/command', './inserthtml'],
+function( command, commands ) {
+	
+
+		
+});

data/vendor/assets/javascripts/aloha/plugins/common/commands/lib/inserthtml.js

@@ -0,0 +1,107 @@
+/*!
+* Aloha Editor
+* Author & Copyright (c) 2010 Gentics Software GmbH
+* aloha-sales@gentics.com
+* Licensed unter the terms of http://www.aloha-editor.com/license.html
+*/
+
+define(
+['aloha/core', 'aloha/jquery', 'aloha/command', 'aloha/selection', 'util/dom', 'aloha/contenthandlermanager', 'aloha/console'],
+function(Aloha, jQuery, command, selection, dom, ContentHandlerManager, console) {
+	
+
+	// Exported commands
+	command.register( 'inserthtml', {
+		action: function(value, range) {
+			var 
+				$editable = jQuery(dom.getEditingHostOf(range.startContainer)),
+				cac = range.commonAncestorContainer,
+				i,
+				selectedRange,
+				domNodes = [];
+			
+			/**
+			 * Paste the given object into the current selection.
+			 * If inserting fails (because the object is not allowed to be inserted), unwrap the contents and try with that.
+			 * @param object object to be pasted
+			 */
+			function pasteElement(object) {
+				var $object = jQuery(object),
+					contents;
+
+				// try to insert the element into the DOM with limit the editable host
+				// this fails when an element is not allowed to be inserted
+				if (!dom.insertIntoDOM($object, range, $editable, false)) {
+					
+					// if that is not possible, we unwrap the content and insert every child element
+					 contents = $object.contents();
+
+					// when a block level element was unwrapped, we at least insert a break
+					if (dom.isBlockLevelElement(object) || dom.isListElement(object)) {
+						pasteElement(jQuery('<br/>').get(0));
+					}
+
+					// and now all children (starting from the back)
+					for ( i = contents.length - 1; i >= 0; --i) {
+						pasteElement(contents[i]);
+					}
+				}
+			};
+
+			// apply content handler to cleanup inserted data
+			//if (typeof Aloha.settings.contentHandler.insertHtml === 'undefined') {
+			// just use all registerd content handler or specity Aloha.defaults.contentHandler.insertHtml manually?
+			//	Aloha.settings.contentHandler.insertHtml = Aloha.defaults.contentHandler.insertHtml;
+			//}
+			value = ContentHandlerManager.handleContent( value, { contenthandler: Aloha.settings.contentHandler.insertHtml } );
+
+			// allowed values are string or jQuery objects
+			// add value to a container div
+			if ( typeof value === 'string' ){
+				value = jQuery( '<div>' + value + '</div>' );
+			} else if ( value instanceof jQuery ) {
+				value = jQuery( '<div>' ).append(value);
+			} else {
+				throw "INVALID_VALUE_ERR";
+			}
+			
+			// get contents of container div
+			domNodes = value.contents();
+			
+			// check if range starts an ends in same editable host
+//			if ( !(dom.inSameEditingHost(range.startContainer, range.endContainer)) ) {
+//				throw "INVALID_RANGE_ERR";
+//			}
+			
+			// delete currently selected contents
+			dom.removeRange(range);
+			
+			for ( i = domNodes.length - 1; i >= 0; --i) {
+				// insert the elements
+				pasteElement(domNodes[i]);
+			}
+
+			// Call collapse() on the context object's Selection,
+			// with last child's parent as the first argument and one plus its index as the second.
+			if (domNodes.length > 0) {
+				range = dom.setCursorAfter(domNodes.get(domNodes.length - 1));
+			} else {
+				// if nothing was pasted, just reselect the old range
+				range.select();
+			}
+
+			dom.doCleanup({merge:true, removeempty: true}, range, cac);
+			//In some cases selecting the range does not work properly 
+			//e.g. when pasting from word in an h2 after the first character in IE
+			//in these cases we should fail gracefully.
+			//TODO check why the selection is failing
+			try {
+				range.select();
+			} catch (e) {
+				console.warn('Error:',e);
+			}
+
+		}
+	});
+
+});

data/vendor/assets/javascripts/aloha/plugins/common/commands/package.json

@@ -0,0 +1 @@
+{}

data/vendor/assets/javascripts/aloha/plugins/common/contenthandler/lib/contenthandler-plugin.js

@@ -0,0 +1,54 @@
+/*!
+* Aloha Editor
+* Author & Copyright (c) 2010 Gentics Software GmbH
+* aloha-sales@gentics.com
+* Licensed unter the terms of http://www.aloha-editor.com/license.html
+*/
+
+/**
+ * @name contenthandler
+ * @namespace Content handler plugin
+ */
+define( [
+	'aloha',
+	'aloha/plugin',
+	'aloha/jquery',
+	'aloha/contenthandlermanager',
+	'contenthandler/wordcontenthandler',
+	'contenthandler/genericcontenthandler',
+	'contenthandler/oembedcontenthandler',
+	'contenthandler/sanitizecontenthandler'
+], function( Aloha,
+			 Plugin,
+			 jQuery,
+			 ContentHandlerManager,
+			 WordContentHandler,
+			 GenericContentHandler, 
+			 OembedContentHandler,
+			 SanitizeContentHandler ) {
+	
+
+	/**
+	 * Register the plugin with unique name
+	 */
+	var ContentHandlerPlugin = Plugin.create( 'contenthandler', {
+		settings : {},
+		dependencies : [],
+		init : function () {
+			var that = this,
+				handler, cc,
+				contentHandler = [ 'word', 'generic', 'sanitize' ], //  'oembed' deactivated
+				i, j = contentHandler.length;
+
+			// Register available content handler
+			for ( i = 0; i < j; i++ ) {
+				handler = contentHandler[ i ];
+				cc = handler.charAt( 0 ).toUpperCase() + handler.slice( 1 );
+				ContentHandlerManager
+					.register( handler, eval( cc + 'ContentHandler' ) );
+			}
+		}
+	} );
+
+	return ContentHandlerPlugin;
+});

data/vendor/assets/javascripts/aloha/plugins/common/contenthandler/lib/genericcontenthandler.js

@@ -0,0 +1,255 @@
+/*!
+* Aloha Editor
+* Author & Copyright (c) 2010 Gentics Software GmbH
+* aloha-sales@gentics.com
+* Licensed unter the terms of http://www.aloha-editor.com/license.html
+*/
+define(
+['aloha', 'aloha/jquery', 'aloha/contenthandlermanager'],
+function(Aloha, jQuery, ContentHandlerManager) {
+	
+
+	var
+		GENTICS = window.GENTICS;
+
+	/**
+	 * Register the generic content handler
+	 */
+	var GenericContentHandler = ContentHandlerManager.createHandler({
+		/**
+		 * Handle the pasting. Remove all unwanted stuff.
+		 * @param content
+		 */
+		handleContent: function( content ) {
+			if ( typeof content === 'string' ){
+				content = jQuery( '<div>' + content + '</div>' );
+			} else if ( content instanceof jQuery ) {
+				content = jQuery( '<div>' ).append(content);
+			}
+
+			// If we find an aloha-block inside the pasted content,
+			// we do not modify the pasted stuff, as it most probably
+			// comes from Aloha and not from other sources, and does
+			// not need to be cleaned up.
+			if (content.find('.aloha-block').length > 0) {
+				return;
+			}
+
+			// clean lists
+			this.cleanLists(content);
+
+			// transform tables
+			this.transformTables(content);
+
+			// remove comments
+			this.removeComments(content);
+
+			// unwrap font and span tags
+			this.unwrapTags(content);
+
+			// remove styles
+			this.removeStyles(content);
+
+			// remove namespaced elements
+			this.removeNamespacedElements(content);
+
+			// transform formattings
+			this.transformFormattings(content);
+
+			// transform links
+			//this.transformLinks(content);
+
+			return content.html();
+		},
+
+		/**
+		 * Clean lists: The only allowed children of ol or ul elements are li's. Everything else will be removed
+		 * @param content
+		 */
+		cleanLists: function(content) {
+			content.find('ul,ol').each(function() {
+				var $list = jQuery(this);
+				$list.contents(':not(li,ul,ol)').each(function() {
+					jQuery(this).remove();
+				});
+				// for all li's, trim the text contents
+				$list.children('li').each(function() {
+					var $li = jQuery(this);
+					$li.contents().each(function() {
+						if (this.nodeType === 3) {
+							this.data = jQuery.trim(this.data);
+						}
+					});
+				});
+			});
+		},
+
+		/**
+		 * Transform tables which were pasted
+		 * @param content
+		 */
+		transformTables: function(content) {
+			// remove border, cellspacing, cellpadding from all tables
+			// @todo what about width, height?
+			content.find('table').each(function() {
+				jQuery(this).removeAttr('border').removeAttr('cellspacing').removeAttr('cellpadding');
+			});
+			
+			// remove unwanted attributes and cleanup single empty p-tags
+			content.find('td').each(function() {
+				// remove width, height and valign from all table cells
+				jQuery(this).removeAttr('width').removeAttr('height').removeAttr('valign');
+				
+				if ( this.innerHTML.replace(/[\s\xA0]+/g,'') === '<p><br></p>' ) {
+					this.innerHTML = '&nbsp;';
+				}
+				
+				if ( jQuery(this).find('p').length == 1) {
+					jQuery(this).find('p').contents().unwrap();
+				}
+			});
+			
+			// remove unwanted attributes from tr also? (tested with paste from open/libre office)
+			// @todo or do this all via sanitize.js 
+			content.find('tr').each(function() {
+				// remove width, height and valign from all table cells
+				jQuery(this).removeAttr('width').removeAttr('height').removeAttr('valign');
+			});
+			
+			// completely colgroup tags
+			// @TODO should we remove colgroup? use sanitize for that?
+			content.find('colgroup').remove();
+		},
+
+		/**
+		 * Transform formattings
+		 * @param content
+		 */
+		transformFormattings: function( content ) {
+			// find all formattings we will transform
+			content.find('strong,em,s,u').each(function() {
+				if (this.nodeName.toLowerCase() == 'strong') {
+					// transform strong to b
+					Aloha.Markup.transformDomObject(jQuery(this), 'b');
+				} else if (this.nodeName.toLowerCase() == 'em') {
+					// transform em to i
+					Aloha.Markup.transformDomObject(jQuery(this), 'i');
+				} else if (this.nodeName.toLowerCase() == 's') {
+					// transform s to del
+					Aloha.Markup.transformDomObject(jQuery(this), 'del');
+				} else if (this.nodeName.toLowerCase() == 'u') {
+					// transform u?
+					jQuery(this).contents().unwrap();
+				}
+			});
+		},
+
+		/**
+		 * Transform links
+		 * @param content
+		 */
+		transformLinks: function( content ) {
+			// find all links and remove the links without href (will be destination anchors from word table of contents)
+			// aloha is not supporting anchors at the moment -- maybe rewrite anchors in headings to "invisible"
+			// in the test document there are anchors for whole paragraphs --> the whole P appear as link
+			content.find('a').each(function() {
+				if ( typeof jQuery(this).attr('href') === 'undefined' ) {
+					jQuery(this).contents().unwrap();
+				}
+			});
+		},
+
+		/**
+		 * Remove all comments
+		 * @param content
+		 */
+		removeComments: function( content ) {
+			var that = this;
+
+			// ok, remove all comments
+			content.contents().each(function() {
+				if (this.nodeType == 8) {
+					jQuery(this).remove();
+				} else {
+					// do recursion
+					that.removeComments(jQuery(this));
+				}
+			});
+		},
+
+		/**
+		 * Remove some unwanted tags from content pasted
+		 * @param content
+		 */
+		unwrapTags: function( content ) {
+			var that = this;
+
+			content.children('span,font,div').filter(function() {
+				return this.contentEditable != 'false';
+			}).each(function() {
+				if (this.nodeName == 'DIV') {
+					// safari and chrome cleanup for plain text paste with working linebreaks
+					if (this.innerHTML == '<br>') {
+						jQuery(this).contents().unwrap();
+					} else {
+						jQuery( Aloha.Markup.transformDomObject(jQuery(this), 'p').append('<br>') ).contents().unwrap();
+					}
+				} else {
+					jQuery(this).contents().unwrap();
+				}
+
+				that.unwrapTags(jQuery(this));
+			});
+		},
+
+		/**
+		 * Remove styles
+		 * @param content
+		 */
+		removeStyles: function( content ) {
+			var that = this;
+
+			// completely remove style tags
+			content.children('style').filter(function() {
+				return this.contentEditable != 'false';
+			}).remove();
+
+			// remove style attributes and classes
+			content.children().filter(function() {
+				return this.contentEditable != 'false';
+			}).each(function() {
+				jQuery(this).removeAttr('style').removeClass();
+				that.removeStyles(jQuery(this));
+			});
+		},
+
+		/**
+		 * Remove all elements which are in different namespaces
+		 * @param content
+		 */
+		removeNamespacedElements: function( content ) {
+			// get all elements
+			content.find('*').each(function() {
+				// try to determine the namespace prefix ('prefix' works for W3C
+				// compliant browsers, 'scopeName' for IE)
+
+				var nsPrefix = this.prefix ? this.prefix
+						: (this.scopeName ? this.scopeName : undefined);
+				// when the prefix is set (and different from 'HTML'), we remove the
+				// element
+				if ((nsPrefix && nsPrefix != 'HTML') || this.nodeName.indexOf(':') >= 0 ) {
+					var $this = jQuery(this), $contents = $this.contents();
+					if ($contents.length) {
+						// the element has contents, so unwrap the contents
+						$contents.unwrap();
+					} else {
+						// the element is empty, so remove it
+						$this.remove();
+					}
+				}
+			});
+		}
+	});
+
+	return GenericContentHandler;
+});

data/vendor/assets/javascripts/aloha/plugins/common/contenthandler/lib/oembedcontenthandler.js

@@ -0,0 +1,276 @@
+/*!
+* Aloha Editor
+* Author & Copyright (c) 2010 Gentics Software GmbH
+* aloha-sales@gentics.com
+* Licensed unter the terms of http://www.aloha-editor.com/license.html
+* Uses jquery-oEmbed
+* Made by Thomas Lété for Aloha Editor
+*/
+define(
+['aloha', 'aloha/jquery', 'aloha/contenthandlermanager'],
+function(Aloha, jQuery, ContentHandlerManager) {
+	
+
+	var
+		GENTICS = window.GENTICS,
+		escape = window.escape,
+		providers, getOEmbedProvider, getNormalizedParams, OEmbedProvider;
+
+
+	/* Private Methods */
+	getOEmbedProvider = function(url) {
+		for (var i = 0; i < providers.length; i++) {
+			if (providers[i].matches(url))
+				return providers[i];
+		}
+		return null;
+	};
+	
+	getNormalizedParams = function (params) {
+		var normalizedParams = {}, key;
+		if (params == null)
+			return null;
+		for ( key in params) {
+			if (key != null)
+				normalizedParams[key.toLowerCase()] = params[key];
+		}
+		return normalizedParams;
+	};
+
+	OEmbedProvider = function(name, urlPattern, oEmbedUrl, callbackparameter) {
+		this.name = name;
+		this.urlPattern = urlPattern;
+		this.oEmbedUrl = (oEmbedUrl != null) ? oEmbedUrl : "http://oohembed.com/oohembed/";
+		this.callbackparameter = (callbackparameter != null) ? callbackparameter : "callback";
+		this.maxWidth = 500;
+		this.maxHeight = 400;
+
+		this.matches = function(externalUrl) {
+			// TODO: Convert to Regex
+			return externalUrl.indexOf(this.urlPattern) >= 0;
+		};
+
+		this.getRequestUrl = function(externalUrl) {
+
+			var url = this.oEmbedUrl, qs = "", i;
+
+			if (url.indexOf("?") <= 0)
+				url = url + "?";
+			else
+				url = url + "&";
+
+			if (this.maxWidth != null && this.params.maxwidth == null)
+				this.params.maxwidth = this.maxWidth;				
+				
+			if (this.maxHeight != null && this.params.maxheight == null)
+				this.params.maxheight = this.maxHeight;
+
+			for ( i in this.params) {
+				// We don't want them to jack everything up by changing the callback parameter
+				if (i == this.callbackparameter)
+				  continue;
+				
+				// allows the options to be set to null, don't send null values to the server as parameters
+				if (this.params[i] != null)
+					qs += "&" + escape(i) + "=" + this.params[i];
+			}		   
+			
+				
+			url += "format=json&url=" + escape(externalUrl) +		   
+					qs + 
+					"&" + this.callbackparameter + "=?";
+					
+			return url;
+		};
+
+		this.embedCode = function(container, externalUrl, callback) {
+
+			var request = this.getRequestUrl(externalUrl);
+
+			jQuery.getJSON(request, function(data) {
+
+				var oembed = data,
+                    code, type = data.type;
+
+				switch (type) {
+					case "photo":
+						oembed.code = jQuery.fn.oembed.getPhotoCode(externalUrl, data);
+						break;
+					case "video":
+						oembed.code = jQuery.fn.oembed.getVideoCode(externalUrl, data);
+						break;
+					case "rich":
+						oembed.code = jQuery.fn.oembed.getRichCode(externalUrl, data);
+						break;
+					default:
+						oembed.code = jQuery.fn.oembed.getGenericCode(externalUrl, data);
+						break;
+				}
+
+				callback(container, oembed);
+			});
+		};
+	};
+
+    providers = [
+        new OEmbedProvider("fivemin", "5min.com"),
+        new OEmbedProvider("amazon", "amazon.com"),
+        new OEmbedProvider("flickr", "flickr", "http://flickr.com/services/oembed", "jsoncallback"),    
+        new OEmbedProvider("googlevideo", "video.google."),
+        new OEmbedProvider("hulu", "hulu.com"),
+        new OEmbedProvider("imdb", "imdb.com"),
+        new OEmbedProvider("metacafe", "metacafe.com"),
+        new OEmbedProvider("qik", "qik.com"),
+        new OEmbedProvider("revision3", "revision3.com"),
+        new OEmbedProvider("slideshare", "slideshare.net"),
+        new OEmbedProvider("twitpic", "twitpic.com"),
+        new OEmbedProvider("viddler", "viddler.com"),
+        new OEmbedProvider("vimeo", "vimeo.com", "http://vimeo.com/api/oembed.json"),
+        new OEmbedProvider("wikipedia", "wikipedia.org"),
+        new OEmbedProvider("wordpress", "wordpress.com"),
+        new OEmbedProvider("youtube", "youtube.com"),
+        new OEmbedProvider("vids.myspace.com", "vids.myspace.com", "http://vids.myspace.com/index.cfm?fuseaction=oembed"),
+        new OEmbedProvider("screenr", "screenr.com", "http://screenr.com/api/oembed.json")
+    ];
+
+
+	jQuery.fn.oembed = function(url, options, callback) {
+
+		options = jQuery.extend(true, jQuery.fn.oembed.defaults, options);
+
+		return this.each(function() {
+
+			var container = jQuery(this),
+				resourceURL = (url != null) ? url : container.attr("href"),
+				provider;
+
+			if (!callback) callback = function(container, oembed) {			
+				 jQuery.fn.oembed.insertCode(container, options.embedMethod, oembed);
+			};
+
+			if (resourceURL != null) {
+				provider = getOEmbedProvider(resourceURL);
+
+				if (provider != null) {						
+					provider.params = getNormalizedParams(options[provider.name]) || {};
+					provider.maxWidth = options.maxWidth;
+					provider.maxHeight = options.maxHeight;										
+					provider.embedCode(container, resourceURL, callback);
+					return;
+				}
+			}
+
+			callback(container, null);
+		});
+	};
+
+	// Plugin defaults
+	jQuery.fn.oembed.defaults = {
+		maxWidth: null,
+		maxHeight: null,
+		embedMethod: "fill" // "auto", "append", "fill"
+	};
+	
+	jQuery.fn.oembed.insertCode = function(container, embedMethod, oembed) {
+		if (oembed == null)
+			return;
+		switch(embedMethod)
+		{
+			case "auto":				
+				if (container.attr("href") != null) {
+					jQuery.fn.oembed.insertCode(container, "append", oembed);
+				}
+				else {
+					jQuery.fn.oembed.insertCode(container, "replace", oembed);
+				}
+				break;
+			case "replace":	
+				container.replaceWith(oembed.code);
+				break;
+			case "fill":
+				container.html(oembed.code);
+				break;
+			case "append":
+				var oembedContainer = container.next();
+				if (oembedContainer == null || !oembedContainer.hasClass("oembed-container")) {
+					oembedContainer = container
+						.after('<div class="oembed-container"></div>')
+						.next(".oembed-container");
+					if (oembed != null && oembed.provider_name != null)
+						oembedContainer.toggleClass("oembed-container-" + oembed.provider_name);		
+				}
+				oembedContainer.html(oembed.code);				
+				break;			
+		}
+	};
+
+	jQuery.fn.oembed.getPhotoCode = function(url, data) {
+		var alt = data.title ? data.title : '',
+            code;
+		alt += data.author_name ? ' - ' + data.author_name : '';
+		alt += data.provider_name ? ' - ' +data.provider_name : '';
+		code = '<div><a href="' + url + '" target="_blank"><img src="' + data.url + '" alt="' + alt + '"/></a></div>';
+		if (data.html)
+			code += "<div>" + data.html + "</div>";
+		return code;
+	};
+
+	jQuery.fn.oembed.getVideoCode = function(url, data) {
+		var code = data.html;
+		return code;
+	};
+
+	jQuery.fn.oembed.getRichCode = function(url, data) {
+		var code = data.html;
+		return code;
+	};
+
+	jQuery.fn.oembed.getGenericCode = function(url, data) {
+		var title = (data.title != null) ? data.title : url,
+			code = '<a href="' + url + '">' + title + '</a>';
+		if (data.html)
+			code += "<div>" + data.html + "</div>";
+		return code;
+	};
+
+	jQuery.fn.oembed.isAvailable = function(url) {
+		var provider = getOEmbedProvider(url);
+		return (provider != null);
+	};
+
+	/**
+	 * Register the word paste handler
+	 */
+	var OEmbedContentHandler = ContentHandlerManager.createHandler({
+		/**
+		 * Handle the pasting. Try to detect content pasted from word and transform to clean html
+		 * @param content
+		 */
+		handleContent: function( content ) {
+			if ( typeof content === 'string' ){
+				content = jQuery( '<div>' + content + '</div>' );
+			} else if ( content instanceof jQuery ) {
+				content = jQuery( '<div>' ).append(content);
+			}
+
+			this.replaceoEmbedContent( content );
+
+			return content.html();
+		},
+
+		/**
+		 * Check whether the content of the given jQuery object is assumed to be pasted from word.
+		 * @param content
+		 * @return true for content pasted from word, false for other content
+		 */
+		replaceoEmbedContent: function( content ) {
+			// check every element which was pasted.
+			content.contents().each(function() {
+				var container = jQuery(this);
+				container.oembed( container.text() );
+			});
+		}
+	});
+	
+	return OEmbedContentHandler;
+});