locomotive-aloha-rails 0.20.1

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

@@ -0,0 +1,267 @@
+/**
+ * Copyright (c) 2010 by Gabriel Birke
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the 'Software'), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+function Sanitize(){
+  var i, e, options;
+  options = arguments[0] || {}
+  this.config = {}
+  this.config.elements = options.elements ? options.elements : [];
+  this.config.attributes = options.attributes ? options.attributes : {};
+  this.config.attributes[Sanitize.ALL] = this.config.attributes[Sanitize.ALL] ? this.config.attributes[Sanitize.ALL] : [];
+  this.config.allow_comments = options.allow_comments ? options.allow_comments : false;
+  this.allowed_elements = {};
+  this.config.protocols = options.protocols ? options.protocols : {};
+  this.config.add_attributes = options.add_attributes ? options.add_attributes  : {};
+  this.dom = options.dom ? options.dom : document;
+  for(i=0;i<this.config.elements.length;i++) {
+    this.allowed_elements[this.config.elements[i]] = true;
+  }
+  this.config.remove_element_contents = {};
+  this.config.remove_all_contents = false;
+  if(options.remove_contents) {
+    
+    if(options.remove_contents instanceof Array) {
+      for(i=0;i<options.remove_contents.length;i++) {
+        this.config.remove_element_contents[options.remove_contents[i]] = true;
+      }
+    }
+    else {
+      this.config.remove_all_contents = true;
+    }
+  }
+  this.transformers = options.transformers ? options.transformers : [];
+
+  // filters might let the sanitizer stop clean elements (and their children)
+  this.filters = options.filters ? options.filters : [];
+}
+
+Sanitize.REGEX_PROTOCOL = /^([A-Za-z0-9\+\-\.\&\;\*\s]*?)(?:\:|&*0*58|&*x0*3a)/i
+Sanitize.RELATIVE = '__relative__'; // emulate Ruby symbol with string constant
+
+Sanitize.prototype.clean_node = function(container) {
+  var fragment = this.dom.createDocumentFragment();
+  this.current_element = fragment;
+  this.whitelist_nodes = [];
+
+  
+
+  /**
+   * Utility function to check if an element exists in an array
+   */
+  function _array_index(needle, haystack) {
+    var i;
+    for(i=0; i < haystack.length; i++) {
+      if(haystack[i] == needle) 
+        return i;
+    }
+    return -1;
+  }
+  
+  function _merge_arrays_uniq() {
+    var result = [];
+    var uniq_hash = {}
+    var i,j;
+    for(i=0;i<arguments.length;i++) {
+      if(!arguments[i] || !arguments[i].length)
+        continue;
+      for(j=0;j<arguments[i].length;j++) {
+        if(uniq_hash[arguments[i][j]])
+          continue;
+        uniq_hash[arguments[i][j]] = true;
+        result.push(arguments[i][j]);
+      }
+    }
+    return result;
+  }
+  
+  /**
+   * Clean function that checks the different node types and cleans them up accordingly
+   * @param elem DOM Node to clean
+   */
+  function _clean(elem) {
+    var clone;
+
+    // check whether the elem passes all of the filters
+    for ( var i=0; i < this.filters.length; i++ ) {
+    	if (!this.filters[i](elem)) {
+    		clone = elem.cloneNode(true);
+            this.current_element.appendChild(clone);
+    		return;
+    	}
+    }
+
+    switch(elem.nodeType) {
+      // Element
+      case 1:
+        _clean_element.call(this, elem)
+        break;
+      // Text
+      case 3:
+        var clone = elem.cloneNode(false);
+        this.current_element.appendChild(clone);
+        break;
+      // Entity-Reference (normally not used)
+      case 5:
+        var clone = elem.cloneNode(false);
+        this.current_element.appendChild(clone);
+        break;
+      // Comment
+      case 8:
+        if(this.config.allow_comments) {
+          var clone = elem.cloneNode(false);
+          this.current_element.appendChild(clone);
+        }
+      default:
+        //console.log("unknown node type", elem.nodeType) 
+    }
+ 
+  }
+  
+  function _clean_element(elem) {
+    var i, j, clone, parent_element, name, allowed_attributes, attr, attr_name, attr_node, protocols, del, attr_ok;
+    var transform = _transform_element.call(this, elem);
+    
+    elem = transform.node;
+    name = elem.nodeName.toLowerCase();
+    
+    // check if element itself is allowed
+    parent_element = this.current_element;
+    if(this.allowed_elements[name] || transform.whitelist) {
+        this.current_element = this.dom.createElement(elem.nodeName);
+        parent_element.appendChild(this.current_element);
+        
+      // clean attributes
+      allowed_attributes = _merge_arrays_uniq(
+        this.config.attributes[name],
+        this.config.attributes['__ALL__'],
+        transform.attr_whitelist
+      );
+      for(i=0;i<allowed_attributes.length;i++) {
+        attr_name = allowed_attributes[i];
+        attr = elem.attributes[attr_name];
+        if(attr) {
+            attr_ok = true;
+            // Check protocol attributes for valid protocol
+            if(this.config.protocols[name] && this.config.protocols[name][attr_name]) {
+              protocols = this.config.protocols[name][attr_name];
+              del = attr.nodeValue.toLowerCase().match(Sanitize.REGEX_PROTOCOL);
+              if(del) {
+                attr_ok = (_array_index(del[1], protocols) != -1);
+              }
+              else {
+                attr_ok = (_array_index(Sanitize.RELATIVE, protocols) != -1);
+              }
+            }
+            if(attr_ok) {
+              attr_node = document.createAttribute(attr_name);
+              attr_node.value = attr.nodeValue;
+              this.current_element.setAttributeNode(attr_node);
+            }
+        }
+      }
+      
+      // Add attributes
+      if(this.config.add_attributes[name]) {
+        for(attr_name in this.config.add_attributes[name]) {
+          attr_node = document.createAttribute(attr_name);
+          attr_node.value = this.config.add_attributes[name][attr_name];
+          this.current_element.setAttributeNode(attr_node);
+        }
+      }
+    } // End checking if element is allowed
+    // If this node is in the dynamic whitelist array (built at runtime by
+    // transformers), let it live with all of its attributes intact.
+    else if(_array_index(elem, this.whitelist_nodes) != -1) {
+      this.current_element = elem.cloneNode(true);
+      // Remove child nodes, they will be sanitiazied and added by other code
+      while(this.current_element.childNodes.length > 0) {
+        this.current_element.removeChild(this.current_element.firstChild);
+      }
+      parent_element.appendChild(this.current_element);
+    }
+
+    // iterate over child nodes
+    if(!this.config.remove_all_contents && !this.config.remove_element_contents[name]) {
+      for(i=0;i<elem.childNodes.length;i++) {
+        _clean.call(this, elem.childNodes[i]);
+      }
+    }
+    
+    // some versions of IE don't support normalize.
+    if(this.current_element.normalize) {
+      this.current_element.normalize();
+    }
+    this.current_element = parent_element;
+  } // END clean_element function
+  
+  function _transform_element(node) {
+    var output = {
+      attr_whitelist:[],
+      node: node,
+      whitelist: false
+    }
+    var i, j, transform;
+    for(i=0;i<this.transformers.length;i++) {
+      transform = this.transformers[i]({
+        allowed_elements: this.allowed_elements,
+        config: this.config,
+        node: node,
+        node_name: node.nodeName.toLowerCase(),
+        whitelist_nodes: this.whitelist_nodes,
+        dom: this.dom
+      });
+      if(transform == null) 
+        continue;
+      else if(typeof transform == 'object') {
+        if(transform.whitelist_nodes && transform.whitelist_nodes instanceof Array) {
+          for(j=0;j<transform.whitelist_nodes.length;j++) {
+            if(_array_index(transform.whitelist_nodes[j], this.whitelist_nodes) == -1) {
+              this.whitelist_nodes.push(transform.whitelist_nodes[j]);
+            }
+          }
+        }
+        output.whitelist = transform.whitelist ? true : false;
+        if(transform.attr_whitelist) {
+          output.attr_whitelist = _merge_arrays_uniq(output.attr_whitelist, transform.attr_whitelist);
+        }
+        output.node = transform.node ? transform.node : output.node;
+      }
+      else {
+        throw new Error("transformer output must be an object or null");
+      }
+    }
+    return output;
+  }
+  
+  
+  
+  for(i=0;i<container.childNodes.length;i++) {
+    _clean.call(this, container.childNodes[i]);
+  }
+  
+  if(fragment.normalize) {
+    fragment.normalize();
+  }
+  
+  return fragment;
+  
+}

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

@@ -0,0 +1,293 @@
+/*!
+* 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/plugin',
+	'aloha/floatingmenu',
+	'i18n!abbr/nls/i18n',
+	'i18n!aloha/nls/i18n'
+], function ( Aloha, jQuery, Plugin, FloatingMenu, i18n, i18nCore ) {
+	
+	
+	var GENTICS = window.GENTICS;
+
+	/**
+	 * register the plugin with unique name
+	 */
+	return Plugin.create( 'abbr', {
+		/**
+		 * Configure the available languages
+		 */
+		languages: [ 'en', 'de' ],
+
+		/**
+		 * default button configuration
+		 */
+		config: [ 'abbr' ],
+
+		/**
+		 * Initialize the plugin and set initialize flag on true
+		 */
+		init: function () {
+			this.createButtons();
+		    this.subscribeEvents();
+		    this.bindInteractions();
+		},
+
+		/**
+		 * Initialize the buttons
+		 */
+		createButtons: function () {
+		    var me = this;
+
+		    // format Abbr Button
+		    // this button behaves like a formatting button like (bold, italics, etc)
+		    this.formatAbbrButton = new Aloha.ui.Button( {
+		    	'name' : 'abbr',
+		        'iconClass' : 'aloha-button aloha-button-abbr',
+		        'size' : 'small',
+		        'onclick' : function () { me.formatAbbr(); },
+		        'tooltip' : i18n.t( 'button.abbr.tooltip' ),
+		        'toggle' : true
+		    } );
+		    FloatingMenu.addButton(
+		        'Aloha.continuoustext',
+		        this.formatAbbrButton,
+		        i18nCore.t( 'floatingmenu.tab.format' ),
+		        1
+		    );
+
+		    // insert Abbr
+		    // always inserts a new abbr
+		    this.insertAbbrButton = new Aloha.ui.Button( {
+		    	'name' : 'insertAbbr',
+		    	'iconClass' : 'aloha-button aloha-button-abbr',
+		        'size' : 'small',
+		        'onclick' : function () { me.insertAbbr( false ); },
+		        'tooltip' : i18n.t( 'button.addabbr.tooltip' ),
+		        'toggle' : false
+		    } );
+			FloatingMenu.addButton(
+		        'Aloha.continuoustext',
+		        this.insertAbbrButton,
+		        i18nCore.t( 'floatingmenu.tab.insert' ),
+		        1
+		    );
+
+		    // add the new scope for abbr
+		    FloatingMenu.createScope( 'abbr', 'Aloha.continuoustext' );
+
+		    this.abbrField = new Aloha.ui.AttributeField( {
+		    	'width': 320,
+		    	'name': 'abbrText'
+		    } );
+		    // add the input field for abbr
+		    FloatingMenu.addButton(
+		        'abbr',
+		        this.abbrField,
+		        i18n.t( 'floatingmenu.tab.abbr' ),
+		        1
+		    );
+		},
+
+		/**
+		 * Parse a all editables for abbreviations
+		 * Add the abbr shortcut to all edtiables
+		 */
+		bindInteractions: function () {
+			var me = this;
+			
+		    // on blur check if abbr title is empty. If so remove the a tag
+		    this.abbrField.addListener( 'blur', function ( obj, event ) {
+		        if ( this.getValue() == '' ) {
+		            me.removeAbbr();
+		        }
+		    } );
+
+		    // add to all editables the abbr shortcut
+		    for ( var i = 0; i < Aloha.editables.length; i++ ) {
+		        // CTRL+G
+		        Aloha.editables[ i ].obj.keydown( function ( e ) {
+		    		if ( e.metaKey && e.which == 71 ) {
+				        if ( me.findAbbrMarkup() ) {
+				        	FloatingMenu.activateTabOfButton( 'abbrText' );
+				            me.abbrField.focus();
+				        } else {
+				        	me.insertAbbr();
+				        }
+						
+				        // prevent from further handling
+			            // on a MAC Safari cursor would jump to location bar. Use ESC then META+L
+				        e.stopPropagation();
+				        e.preventDefault();
+						
+			            return false;
+		    		}
+		        } );
+		    }
+		},
+
+		/**
+		 * Subscribe for events
+		 */
+		subscribeEvents: function () {
+			var me = this;
+
+		    // add the event handler for selection change
+			Aloha.bind( 'aloha-selection-changed', function ( event, rangeObject ) {
+		        if ( Aloha.activeEditable ) {
+		        	// show/hide the button according to the configuration
+		        	var config = me.getEditableConfig( Aloha.activeEditable.obj );
+
+		        	if ( jQuery.inArray( 'abbr', config ) != -1 ) {
+		        		me.formatAbbrButton.show();
+		        		me.insertAbbrButton.show();
+		        	} else {
+		        		me.formatAbbrButton.hide();
+		        		me.insertAbbrButton.hide();
+			        	// TODO this should not be necessary here!
+			        	// FloatingMenu.doLayout();
+		        		// leave if a is not allowed
+		        		return;
+		        	}
+
+		//        if ( !Aloha.Selection.mayInsertTag('abbr') ) {
+		//        	me.insertAbbrButton.hide();
+		//        }
+
+		        	var foundMarkup = me.findAbbrMarkup( rangeObject );
+		        	if ( foundMarkup ) {
+		        		// abbr found
+		        		me.insertAbbrButton.hide();
+		        		me.formatAbbrButton.setPressed( true );
+		        		FloatingMenu.setScope( 'abbr' );
+		        		me.abbrField.setTargetObject( foundMarkup, 'title' );
+		        	} else {
+		        		// no abbr found
+		        		me.formatAbbrButton.setPressed( false );
+		        		me.abbrField.setTargetObject( null );
+		        	}
+		        	// TODO this should not be necessary here!
+		        	// FloatingMenu.doLayout();
+		        }
+		    });
+		},
+
+		/**
+		 * Check whether inside a abbr tag
+		 * @param {GENTICS.Utils.RangeObject} range range where to insert the object (at start or end)
+		 * @return markup
+		 * @hide
+		 */
+		findAbbrMarkup: function ( range ) {
+			if ( typeof range == 'undefined' ) {
+		        var range = Aloha.Selection.getRangeObject();
+		    }
+			
+			if ( Aloha.activeEditable ) {
+			    return range.findMarkup( function() {
+			        return this.nodeName.toLowerCase() == 'abbr';
+			    }, Aloha.activeEditable.obj );
+			} else {
+				return null;
+			}
+		},
+
+		/**
+		 * Format the current selection or if collapsed the current word as abbr.
+		 * If inside a abbr tag the abbr is removed.
+		 */
+		formatAbbr: function () {
+			var range = Aloha.Selection.getRangeObject();
+
+		    if ( Aloha.activeEditable ) {
+		        if ( this.findAbbrMarkup( range ) ) {
+		            this.removeAbbr();
+		        } else {
+		            this.insertAbbr();
+		        }
+		    }
+		},
+
+		/**
+		 * Insert a new abbr at the current selection. When the selection is collapsed,
+		 * the abbr will have a default abbr text, otherwise the selected text will be
+		 * the abbr text.
+		 */
+		insertAbbr: function ( extendToWord ) {
+		    // current selection or cursor position
+		    var range = Aloha.Selection.getRangeObject();
+
+		    // do not insert a abbr in a abbr
+		    if ( this.findAbbrMarkup( range ) ) {
+		        return;
+		    }
+
+		    // activate floating menu tab
+		    FloatingMenu.activateTabOfButton('abbrText');
+
+		    // if selection is collapsed then extend to the word.
+		    if ( range.isCollapsed() && extendToWord != false ) {
+		        GENTICS.Utils.Dom.extendToWord( range );
+		    }
+			
+		    if ( range.isCollapsed() ) {
+		        // insert a abbr with text here
+		        var abbrText = i18n.t( 'newabbr.defaulttext' );
+		        var newAbbr = jQuery( '<abbr title="">' + abbrText + '</abbr>' );
+		        GENTICS.Utils.Dom.insertIntoDOM( newAbbr, range, jQuery( Aloha.activeEditable.obj ) );
+		        range.startContainer = range.endContainer = newAbbr.contents().get( 0 );
+		        range.startOffset = 0;
+		        range.endOffset = abbrText.length;
+		    } else {
+		        var newAbbr = jQuery( '<abbr title=""></abbr>' );
+		        GENTICS.Utils.Dom.addMarkup( range, newAbbr, false );
+		    }
+			
+		    range.select();
+			
+		    this.abbrField.focus();
+		//	this.abbrChange();
+		},
+
+		/**
+		 * Remove an a tag.
+		 */
+		removeAbbr: function () {
+		    var range = Aloha.Selection.getRangeObject();
+		    var foundMarkup = this.findAbbrMarkup();
+		    if ( foundMarkup ) {
+		        // remove the abbr
+		        GENTICS.Utils.Dom.removeFromDOM( foundMarkup, range, true );
+		        // select the (possibly modified) range
+		        range.select();
+		    }
+		},
+
+		/**
+		 * Make the given jQuery object (representing an editable) clean for saving
+		 * Find all abbrs and remove editing objects
+		 * @param obj jQuery object to make clean
+		 * @return void
+		 */
+		makeClean: function ( obj ) {
+			// nothing to do...
+		},
+
+		/**
+		* toString method
+		* @return string
+		*/
+		toString: function () {
+			return 'abbr';
+		}
+
+	} );
+	
+} );