inline_forms 0.9.17 → 0.9.18

data/public/javascripts/ckeditor/_source/core/htmlparser/cdata.js

@@ -0,0 +1,43 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+
+	/**
+	 * A lightweight representation of HTML text.
+	 * @constructor
+	 * @example
+	 */
+	CKEDITOR.htmlParser.cdata = function( value )
+	{
+		/**
+		 * The CDATA value.
+		 * @type String
+		 * @example
+		 */
+		this.value = value;
+	};
+
+	CKEDITOR.htmlParser.cdata.prototype =
+	{
+		/**
+		 * CDATA has the same type as {@link CKEDITOR.htmlParser.text} This is
+		 * a constant value set to {@link CKEDITOR.NODE_TEXT}.
+		 * @type Number
+		 * @example
+		 */
+		type : CKEDITOR.NODE_TEXT,
+
+		/**
+		 * Writes write the CDATA with no special manipulations.
+		 * @param {CKEDITOR.htmlWriter} writer The writer to which write the HTML.
+		 */
+		writeHtml : function( writer )
+		{
+			writer.write( this.value );
+		}
+	};
+})();

data/public/javascripts/ckeditor/_source/core/htmlparser/comment.js

@@ -0,0 +1,60 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * A lightweight representation of an HTML comment.
+ * @constructor
+ * @example
+ */
+CKEDITOR.htmlParser.comment = function( value )
+{
+	/**
+	 * The comment text.
+	 * @type String
+	 * @example
+	 */
+	this.value = value;
+
+	/** @private */
+	this._ =
+	{
+		isBlockLike : false
+	};
+};
+
+CKEDITOR.htmlParser.comment.prototype =
+{
+	/**
+	 * The node type. This is a constant value set to {@link CKEDITOR.NODE_COMMENT}.
+	 * @type Number
+	 * @example
+	 */
+	type : CKEDITOR.NODE_COMMENT,
+
+	/**
+	 * Writes the HTML representation of this comment to a CKEDITOR.htmlWriter.
+	 * @param {CKEDITOR.htmlWriter} writer The writer to which write the HTML.
+	 * @example
+	 */
+	writeHtml : function( writer, filter )
+	{
+		var comment = this.value;
+
+		if ( filter )
+		{
+			if ( !( comment = filter.onComment( comment, this ) ) )
+				return;
+
+			if ( typeof comment != 'string' )
+			{
+				comment.parent = this.parent;
+				comment.writeHtml( writer, filter );
+				return;
+			}
+		}
+
+		writer.comment( comment );
+	}
+};

data/public/javascripts/ckeditor/_source/core/htmlparser/element.js

@@ -0,0 +1,249 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+/**
+ * A lightweight representation of an HTML element.
+ * @param {String} name The element name.
+ * @param {Object} attributes And object holding all attributes defined for
+ *		this element.
+ * @constructor
+ * @example
+ */
+CKEDITOR.htmlParser.element = function( name, attributes )
+{
+	/**
+	 * The element name.
+	 * @type String
+	 * @example
+	 */
+	this.name = name;
+
+	/**
+	 * Holds the attributes defined for this element.
+	 * @type Object
+	 * @example
+	 */
+	this.attributes = attributes || ( attributes = {} );
+
+	/**
+	 * The nodes that are direct children of this element.
+	 * @type Array
+	 * @example
+	 */
+	this.children = [];
+
+	var tagName = attributes[ 'data-cke-real-element-type' ] || name || '';
+
+	// Reveal the real semantic of our internal custom tag name (#6639).
+	var internalTag = tagName.match( /^cke:(.*)/ );
+  	internalTag && ( tagName = internalTag[ 1 ] );
+
+	var dtd			= CKEDITOR.dtd,
+		isBlockLike	= !!( dtd.$nonBodyContent[ tagName ]
+				|| dtd.$block[ tagName ]
+				|| dtd.$listItem[ tagName ]
+				|| dtd.$tableContent[ tagName ]
+				|| dtd.$nonEditable[ tagName ]
+				|| tagName == 'br' ),
+		isEmpty = !!dtd.$empty[ name ];
+
+	this.isEmpty	= isEmpty;
+	this.isUnknown	= !dtd[ name ];
+
+	/** @private */
+	this._ =
+	{
+		isBlockLike : isBlockLike,
+		hasInlineStarted : isEmpty || !isBlockLike
+	};
+};
+
+(function()
+{
+	// Used to sort attribute entries in an array, where the first element of
+	// each object is the attribute name.
+	var sortAttribs = function( a, b )
+	{
+		a = a[0];
+		b = b[0];
+		return a < b ? -1 : a > b ? 1 : 0;
+	};
+
+	CKEDITOR.htmlParser.element.prototype =
+	{
+		/**
+		 * The node type. This is a constant value set to {@link CKEDITOR.NODE_ELEMENT}.
+		 * @type Number
+		 * @example
+		 */
+		type : CKEDITOR.NODE_ELEMENT,
+
+		/**
+		 * Adds a node to the element children list.
+		 * @param {Object} node The node to be added. It can be any of of the
+		 *		following types: {@link CKEDITOR.htmlParser.element},
+		 *		{@link CKEDITOR.htmlParser.text} and
+		 *		{@link CKEDITOR.htmlParser.comment}.
+		 * @function
+		 * @example
+		 */
+		add : CKEDITOR.htmlParser.fragment.prototype.add,
+
+		/**
+		 * Clone this element.
+		 * @returns {CKEDITOR.htmlParser.element} The element clone.
+		 * @example
+		 */
+		clone : function()
+		{
+			return new CKEDITOR.htmlParser.element( this.name, this.attributes );
+		},
+
+		/**
+		 * Writes the element HTML to a CKEDITOR.htmlWriter.
+		 * @param {CKEDITOR.htmlWriter} writer The writer to which write the HTML.
+		 * @example
+		 */
+		writeHtml : function( writer, filter )
+		{
+			var attributes = this.attributes;
+
+			// Ignore cke: prefixes when writing HTML.
+			var element = this,
+				writeName = element.name,
+				a, newAttrName, value;
+
+			var isChildrenFiltered;
+
+			/**
+			 * Providing an option for bottom-up filtering order ( element
+			 * children to be pre-filtered before the element itself ).
+			 */
+			element.filterChildren = function()
+			{
+				if ( !isChildrenFiltered )
+				{
+					var writer = new CKEDITOR.htmlParser.basicWriter();
+					CKEDITOR.htmlParser.fragment.prototype.writeChildrenHtml.call( element, writer, filter );
+					element.children = new CKEDITOR.htmlParser.fragment.fromHtml( writer.getHtml(), 0, element.clone() ).children;
+					isChildrenFiltered = 1;
+				}
+			};
+
+			if ( filter )
+			{
+				while ( true )
+				{
+					if ( !( writeName = filter.onElementName( writeName ) ) )
+						return;
+
+					element.name = writeName;
+
+					if ( !( element = filter.onElement( element ) ) )
+						return;
+
+					element.parent = this.parent;
+
+					if ( element.name == writeName )
+						break;
+
+					// If the element has been replaced with something of a
+					// different type, then make the replacement write itself.
+					if ( element.type != CKEDITOR.NODE_ELEMENT )
+					{
+						element.writeHtml( writer, filter );
+						return;
+					}
+
+					writeName = element.name;
+
+					// This indicate that the element has been dropped by
+					// filter but not the children.
+					if ( !writeName )
+					{
+						this.writeChildrenHtml.call( element, writer, isChildrenFiltered ? null : filter );
+						return;
+					}
+				}
+
+				// The element may have been changed, so update the local
+				// references.
+				attributes = element.attributes;
+			}
+
+			// Open element tag.
+			writer.openTag( writeName, attributes );
+
+			// Copy all attributes to an array.
+			var attribsArray = [];
+			// Iterate over the attributes twice since filters may alter
+			// other attributes.
+			for ( var i = 0 ; i < 2; i++ )
+			{
+				for ( a in attributes )
+				{
+					newAttrName = a;
+					value = attributes[ a ];
+					if ( i == 1 )
+						attribsArray.push( [ a, value ] );
+					else if ( filter )
+					{
+						while ( true )
+						{
+							if ( !( newAttrName = filter.onAttributeName( a ) ) )
+							{
+								delete attributes[ a ];
+								break;
+							}
+							else if ( newAttrName != a )
+							{
+								delete attributes[ a ];
+								a = newAttrName;
+								continue;
+							}
+							else
+								break;
+						}
+						if ( newAttrName )
+						{
+							if ( ( value = filter.onAttribute( element, newAttrName, value ) ) === false )
+								delete attributes[ newAttrName ];
+							else
+								attributes [ newAttrName ] = value;
+						}
+					}
+				}
+			}
+			// Sort the attributes by name.
+			if ( writer.sortAttributes )
+				attribsArray.sort( sortAttribs );
+
+			// Send the attributes.
+			var len = attribsArray.length;
+			for ( i = 0 ; i < len ; i++ )
+			{
+				var attrib = attribsArray[ i ];
+				writer.attribute( attrib[0], attrib[1] );
+			}
+
+			// Close the tag.
+			writer.openTagClose( writeName, element.isEmpty );
+
+			if ( !element.isEmpty )
+			{
+				this.writeChildrenHtml.call( element, writer, isChildrenFiltered ? null : filter );
+				// Close the element.
+				writer.closeTag( writeName );
+			}
+		},
+
+		writeChildrenHtml : function( writer, filter )
+		{
+			// Send children.
+			CKEDITOR.htmlParser.fragment.prototype.writeChildrenHtml.apply( this, arguments );
+
+		}
+	};
+})();

data/public/javascripts/ckeditor/_source/core/htmlparser/filter.js

@@ -0,0 +1,288 @@
+/*
+Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
+For licensing, see LICENSE.html or http://ckeditor.com/license
+*/
+
+(function()
+{
+	CKEDITOR.htmlParser.filter = CKEDITOR.tools.createClass(
+	{
+		$ : function( rules )
+		{
+			this._ =
+			{
+				elementNames : [],
+				attributeNames : [],
+				elements : { $length : 0 },
+				attributes : { $length : 0 }
+			};
+
+			if ( rules )
+				this.addRules( rules, 10 );
+		},
+
+		proto :
+		{
+			addRules : function( rules, priority )
+			{
+				if ( typeof priority != 'number' )
+					priority = 10;
+
+				// Add the elementNames.
+				addItemsToList( this._.elementNames, rules.elementNames, priority );
+
+				// Add the attributeNames.
+				addItemsToList( this._.attributeNames, rules.attributeNames, priority );
+
+				// Add the elements.
+				addNamedItems( this._.elements, rules.elements, priority );
+
+				// Add the attributes.
+				addNamedItems( this._.attributes, rules.attributes, priority );
+
+				// Add the text.
+				this._.text = transformNamedItem( this._.text, rules.text, priority ) || this._.text;
+
+				// Add the comment.
+				this._.comment = transformNamedItem( this._.comment, rules.comment, priority ) || this._.comment;
+
+				// Add root fragment.
+				this._.root = transformNamedItem( this._.root, rules.root, priority ) || this._.root;
+			},
+
+			onElementName : function( name )
+			{
+				return filterName( name, this._.elementNames );
+			},
+
+			onAttributeName : function( name )
+			{
+				return filterName( name, this._.attributeNames );
+			},
+
+			onText : function( text )
+			{
+				var textFilter = this._.text;
+				return textFilter ? textFilter.filter( text ) : text;
+			},
+
+			onComment : function( commentText, comment )
+			{
+				var textFilter = this._.comment;
+				return textFilter ? textFilter.filter( commentText, comment ) : commentText;
+			},
+
+			onFragment : function( element )
+			{
+				var rootFilter = this._.root;
+				return rootFilter ? rootFilter.filter( element ) : element;
+			},
+
+			onElement : function( element )
+			{
+				// We must apply filters set to the specific element name as
+				// well as those set to the generic $ name. So, add both to an
+				// array and process them in a small loop.
+				var filters = [ this._.elements[ '^' ], this._.elements[ element.name ], this._.elements.$ ],
+					filter, ret;
+
+				for ( var i = 0 ; i < 3 ; i++ )
+				{
+					filter = filters[ i ];
+					if ( filter )
+					{
+						ret = filter.filter( element, this );
+
+						if ( ret === false )
+							return null;
+
+						if ( ret && ret != element )
+							return this.onNode( ret );
+
+						// The non-root element has been dismissed by one of the filters.
+						if ( element.parent && !element.name )
+							break;
+					}
+				}
+
+				return element;
+			},
+
+			onNode : function( node )
+			{
+				var type = node.type;
+
+				return type == CKEDITOR.NODE_ELEMENT ? this.onElement( node ) :
+					type == CKEDITOR.NODE_TEXT ? new CKEDITOR.htmlParser.text( this.onText( node.value ) ) :
+					type == CKEDITOR.NODE_COMMENT ? new CKEDITOR.htmlParser.comment( this.onComment( node.value ) ):
+					null;
+			},
+
+			onAttribute : function( element, name, value )
+			{
+				var filter = this._.attributes[ name ];
+
+				if ( filter )
+				{
+					var ret = filter.filter( value, element, this );
+
+					if ( ret === false )
+						return false;
+
+					if ( typeof ret != 'undefined' )
+						return ret;
+				}
+
+				return value;
+			}
+		}
+	});
+
+	function filterName( name, filters )
+	{
+		for ( var i = 0 ; name && i < filters.length ; i++ )
+		{
+			var filter = filters[ i ];
+			name = name.replace( filter[ 0 ], filter[ 1 ] );
+		}
+		return name;
+	}
+
+	function addItemsToList( list, items, priority )
+	{
+		if ( typeof items == 'function' )
+			items = [ items ];
+
+		var i, j,
+			listLength = list.length,
+			itemsLength = items && items.length;
+
+		if ( itemsLength )
+		{
+			// Find the index to insert the items at.
+			for ( i = 0 ; i < listLength && list[ i ].pri < priority ; i++ )
+			{ /*jsl:pass*/ }
+
+			// Add all new items to the list at the specific index.
+			for ( j = itemsLength - 1 ; j >= 0 ; j-- )
+			{
+				var item = items[ j ];
+				if ( item )
+				{
+					item.pri = priority;
+					list.splice( i, 0, item );
+				}
+			}
+		}
+	}
+
+	function addNamedItems( hashTable, items, priority )
+	{
+		if ( items )
+		{
+			for ( var name in items )
+			{
+				var current = hashTable[ name ];
+
+				hashTable[ name ] =
+					transformNamedItem(
+						current,
+						items[ name ],
+						priority );
+
+				if ( !current )
+					hashTable.$length++;
+			}
+		}
+	}
+
+	function transformNamedItem( current, item, priority )
+	{
+		if ( item )
+		{
+			item.pri = priority;
+
+			if ( current )
+			{
+				// If the current item is not an Array, transform it.
+				if ( !current.splice )
+				{
+					if ( current.pri > priority )
+						current = [ item, current ];
+					else
+						current = [ current, item ];
+
+					current.filter = callItems;
+				}
+				else
+					addItemsToList( current, item, priority );
+
+				return current;
+			}
+			else
+			{
+				item.filter = item;
+				return item;
+			}
+		}
+	}
+
+	// Invoke filters sequentially on the array, break the iteration
+	// when it doesn't make sense to continue anymore.
+	function callItems( currentEntry )
+	{
+		var isNode = currentEntry.type
+			|| currentEntry instanceof CKEDITOR.htmlParser.fragment;
+
+		for ( var i = 0 ; i < this.length ; i++ )
+		{
+			// Backup the node info before filtering.
+			if ( isNode )
+			{
+				var orgType = currentEntry.type,
+						orgName = currentEntry.name;
+			}
+
+			var item = this[ i ],
+				ret = item.apply( window, arguments );
+
+			if ( ret === false )
+				return ret;
+
+			// We're filtering node (element/fragment).
+			if ( isNode )
+			{
+				// No further filtering if it's not anymore
+				// fitable for the subsequent filters.
+				if ( ret && ( ret.name != orgName
+					|| ret.type != orgType ) )
+				{
+					return ret;
+				}
+			}
+			// Filtering value (nodeName/textValue/attrValue).
+			else
+			{
+				// No further filtering if it's not
+				// any more values.
+				if ( typeof ret != 'string' )
+					return ret;
+			}
+
+			ret != undefined && ( currentEntry = ret );
+		}
+
+		return currentEntry;
+	}
+})();
+
+// "entities" plugin
+/*
+{
+	text : function( text )
+	{
+		// TODO : Process entities.
+		return text.toUpperCase();
+	}
+};
+*/