mail_engine 0.0.1 → 0.1.0

data/test/dummy/public/javascripts/mail_engine/jquery.iframe-auto-height.plugin.js

@@ -0,0 +1,50 @@
+/* 	
+    Plugin: iframe autoheight jQuery Plugin 
+    Author: original code by NATHAN SMITH; converted to plugin by Jesse House
+    File: jquery.iframe-auto-height.plugin.js
+    Description: when the page loads set the height of an iframe based on the height of its contents
+    Remarks: original code from http://sonspring.com/journal/jquery-iframe-sizing    
+    Version: 1.0.0 - see README: http://github.com/house9/jquery-iframe-auto-height
+*/
+(function ($) {
+    $.fn.iframeAutoHeight = function (options) {
+        // set default option values
+        var options = $.extend({
+            heightOffset: 0
+        }, options);
+
+        // iterate over the matched elements passed to the plugin
+        $(this).each(function () {
+            // Check if browser is Opera or Safari(Webkit so Chrome as well)
+            if ($.browser.safari || $.browser.opera) {
+                // Start timer when loaded.
+                $(this).load(function () {
+                    var iframe = this;
+                    var delayedResize = function () {
+                        resizeHeight(iframe);
+                    };
+                    setTimeout(delayedResize, 0);
+                });
+
+                // Safari and Opera need a kick-start.
+                var source = $(this).attr('src');
+                $(this).attr('src', '');
+                $(this).attr('src', source);
+            }
+            else {
+                // For other browsers.
+                $(this).load(function () {
+                    resizeHeight(this);
+                });
+            }
+
+            // resizeHeight
+            function resizeHeight(iframe) {
+                // Set inline style to equal the body height of the iframed content plus a little
+                var newHeight = iframe.contentWindow.document.body.offsetHeight + options.heightOffset;
+                iframe.style.height = newHeight + 'px';
+            }
+
+        }); // end
+    }
+})(jQuery);

data/test/dummy/public/javascripts/mail_engine/jquery.string.js

@@ -0,0 +1,425 @@
+/**
+ * jquery.string - Prototype string functions for jQuery
+ * (c) 2008 David E. Still (http://stilldesigning.com)
+ * Original Prototype extensions (c) 2005-2008 Sam Stephenson (http://prototypejs.org)
+ */
+
+jQuery.extend({
+	__stringPrototype: {
+		/**
+		 * ScriptFragmet, specialChar, and JSONFilter borrowed from Prototype 1.6.0.2
+		 */
+	 	JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,
+		ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',
+		specialChar: {
+			'\b': '\\b',
+			'\t': '\\t',
+			'\n': '\\n',
+			'\f': '\\f',
+			'\r': '\\r',
+			'\\': '\\\\'
+		},
+	
+		/**
+		 * Check if the string is blank (white-space only or empty).
+		 * @param {String} s string to be evaluated
+		 * @return {Boolean} boolean of result
+		 */
+		blank: function(s) {
+			return /^\s*$/.test(this.s(s) || ' ');
+		},
+		/**
+		 * Converts a string separated by dashes into a camelCase equivalent.
+		 * For instance, 'foo-bar' would be converted to 'fooBar'.
+		 * @param {String} s string to be evaluated
+		 * @return {Boolean} boolean of result
+		 */
+		camelize: function(s) {
+			var a = this.s(s).split('-'), i;
+			s = [a[0]];
+			for (i=1; i<a.length; i++){
+				s.push(a[i].charAt(0).toUpperCase() + a[i].substring(1));
+			}
+			s = s.join('');
+			return this.r(arguments,0,s);
+		},
+		/**
+		 * Capitalizes the first letter of a string and downcases all the others.
+		 * @param {String} s string to be evaluated
+		 * @return {Boolean} boolean of result
+		 */
+		capitalize: function(s) {
+			s = this.s(s);
+			s = s.charAt(0).toUpperCase() + s.substring(1).toLowerCase();
+			return this.r(arguments,0,s);
+		},
+		/**
+		 * Replaces every instance of the underscore character ("_") by a dash ("-").
+		 * @param {String} s string to be evaluated
+		 * @return {Boolean} boolean of result
+		 */
+		dasherize: function(s) {
+			s = this.s(s).split('_').join('-');
+			return this.r(arguments,0,s);
+		},
+		/**
+		 * Check if the string is empty.
+		 * @param {String} s string to be evaluated
+		 * @return {Boolean} boolean of result
+		 */
+		empty: function(s) {
+			return this.s(s) === '';
+		},
+		/**
+		 * Tests whether the end of a string matches pattern.
+		 * @param {Object} pattern
+		 * @param {String} s string to be evaluated
+		 * @return {Boolean} boolean of result
+		 */
+		endsWith: function(pattern, s) {
+			s = this.s(s);
+			var d = s.length - pattern.length;
+			return d >= 0 && s.lastIndexOf(pattern) === d;
+		},
+		/**
+		 * escapeHTML from Prototype-1.6.0.2 -- If it's good enough for Webkit and IE, it's good enough for Gecko!
+		 * Converts HTML special characters to their entity equivalents.
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 */
+		escapeHTML: function(s) {
+			s = this.s(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
+			return this.r(arguments,0,s);
+		},
+		/**
+		 * evalJSON from Prototype-1.6.0.2
+		 * Evaluates the JSON in the string and returns the resulting object. If the optional sanitize parameter
+		 * is set to true, the string is checked for possible malicious attempts and eval is not called if one
+		 * is detected.
+		 * @param {String} s string to be evaluated
+		 * @return {Object} evaluated JSON result
+		 */
+		evalJSON: function(sanitize, s) {
+			s = this.s(s);
+			var json = this.unfilterJSON(false, s);
+			try {
+				if (!sanitize || this.isJSON(json)) { return eval('(' + json + ')'); }
+			} catch (e) { }
+			throw new SyntaxError('Badly formed JSON string: ' + s);
+		},
+		/**
+		 * evalScripts from Prototype-1.6.0.2
+		 * Evaluates the content of any script block present in the string. Returns an array containing
+		 * the value returned by each script.
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 */
+		evalScripts: function(s) {
+			var scriptTags = this.extractScripts(this.s(s)), results = [];
+			if (scriptTags.length > 0) {
+				for (var i = 0; i < scriptTags.length; i++) {
+					results.push(eval(scriptTags[i]));
+				}
+			}
+			return results;
+		},
+		/**
+		 * extractScripts from Prototype-1.6.0.2
+		 * Extracts the content of any script block present in the string and returns them as an array of strings.
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 */
+		extractScripts: function(s) {
+			var matchAll = new RegExp(this.ScriptFragment, 'img'), matchOne = new RegExp(this.ScriptFragment, 'im'), scriptMatches = this.s(s).match(matchAll) || [], scriptTags = [];
+			if (scriptMatches.length > 0) {
+				for (var i = 0; i < scriptMatches.length; i++) {
+					scriptTags.push(scriptMatches[i].match(matchOne)[1] || '');
+				}
+			}
+			return scriptTags;
+		},
+		/**
+		 * Returns a string with all occurances of pattern replaced by either a regular string
+		 * or the returned value of a function.  Calls sub internally.
+		 * @param {Object} pattern RegEx pattern or string to replace
+		 * @param {Object} replacement string or function to replace matched patterns
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 * @see sub
+		 */
+		gsub: function(pattern, replacement, s) {
+			s = this.s(s);
+			if (jQuery.isFunction(replacement)) { s = this.sub(pattern, replacement, -1, s); }
+			/* if replacement is not a function, do this the easy way; it's quicker */
+			else { s = s.split(pattern).join(replacement); }
+			return this.r(arguments,2,s);
+		},
+		/**
+		 * Check if the string contains a substring.
+		 * @param {Object} pattern RegEx pattern or string to find
+		 * @param {String} s string to be evaluated
+		 * @return {Boolean} boolean result
+		 */
+		include: function(pattern, s) {
+			return this.s(s).indexOf(pattern) > -1;
+		},
+		/**
+		 * Returns a debug-oriented version of the string (i.e. wrapped in single or double quotes,
+		 * with backslashes and quotes escaped).
+		 * @param {Object} useDoubleQuotes escape double-quotes instead of single-quotes
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 */
+		inspect: function(useDoubleQuotes, s) {
+			s = this.s(s);
+			var escapedString;
+			try {
+				escapedString = this.sub(/[\x00-\x1f\\]/, function(match) {
+					var character = jQuery.__stringPrototype.specialChar[match[0]];
+					return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);
+			    }, -1, s);
+			} catch(e) { escapedString = s; }
+			s = (useDoubleQuotes) ? '"' + escapedString.replace(/"/g, '\\"') + '"' : "'" + escapedString.replace(/'/g, '\\\'') + "'";
+			return this.r(arguments,1,s);
+		},
+		/**
+		 * Treats the string as a Prototype-style Template and fills it with objectÕs properties.
+		 * @param {Object} obj object of values to replace in string
+		 * @param {Object} pattern RegEx pattern for template replacement (default matches Ruby-style '#{attribute}')
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 */
+		interpolate: function(obj, pattern, s) {
+			s = this.s(s);
+			if (!pattern) { pattern = /(\#\{\s*(\w+)\s*\})/; }
+			var gpattern = new RegExp(pattern.source, "g");
+			var matches = s.match(gpattern), i;
+			for (i=0; i<matches.length; i++) {
+				s = s.replace(matches[i], obj[matches[i].match(pattern)[2]]);
+			}
+			return this.r(arguments,2,s);
+		},
+		/**
+		 * isJSON from Prototype-1.6.0.2
+		 * Check if the string is valid JSON by the use of regular expressions. This security method is called internally.
+		 * @param {String} s string to be evaluated
+		 * @return {Boolean} boolean result
+		 */
+		isJSON: function(s) {
+			s = this.s(s);
+			if (this.blank(s)) { return false; }
+			s = s.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');
+			return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(s);
+		},
+		/**
+		 * Evaluates replacement for each match of pattern in string and returns the original string.
+		 * Calls sub internally.
+		 * @param {Object} pattern RegEx pattern or string to replace
+		 * @param {Object} replacement string or function to replace matched patterns
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 * @see sub
+		 */
+		scan: function(pattern, replacement, s) {
+			s = this.s(s);
+			this.sub(pattern, replacement, -1, s);
+			return this.r(arguments,2,s);
+		},
+		/**
+		 * Tests whether the beginning of a string matches pattern.
+		 * @param {Object} pattern
+		 * @param {String} s string to be evaluated
+		 * @return {Boolean} boolean of result
+		 */
+		startsWith: function(pattern, s) {
+			return this.s(s).indexOf(pattern) === 0;
+		},
+		/**
+		 * Trims white space from the beginning and end of a string.
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 */
+		strip: function(s) {
+			s = jQuery.trim(this.s(s));
+			return this.r(arguments,0,s);
+		},
+		/**
+		 * Strips a string of anything that looks like an HTML script block.
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 */
+		stripScripts: function(s) {
+			s = this.s(s).replace(new RegExp(this.ScriptFragment, 'img'), '');
+			return this.r(arguments,0,s);
+		},
+		/**
+		 * Strips a string of any HTML tags.
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 */
+		stripTags: function(s) {
+			s = this.s(s).replace(/<\/?[^>]+>/gi, '');
+			return this.r(arguments,0,s);
+		},
+		/**
+		 * Returns a string with the first count occurances of pattern replaced by either a regular string
+		 * or the returned value of a function.
+		 * @param {Object} pattern RegEx pattern or string to replace
+		 * @param {Object} replacement string or function to replace matched patterns
+		 * @param {Integer} count number of (default = 1, -1 replaces all)
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 */
+		sub: function(pattern, replacement, count, s) {
+			s = this.s(s);
+			if (pattern.source && !pattern.global) {
+				var patternMods = (pattern.ignoreCase)?"ig":"g";
+				patternMods += (pattern.multiline)?"m":"";
+				pattern = new RegExp(pattern.source, patternMods);
+			}
+			var sarray = s.split(pattern), matches = s.match(pattern);
+			if (jQuery.browser.msie) {
+				if (s.indexOf(matches[0]) == 0) sarray.unshift("");
+				if (s.lastIndexOf(matches[matches.length-1]) == s.length - matches[matches.length-1].length) sarray.push("");
+			}
+			count = (count < 0)?(sarray.length-1):count || 1;
+			s = sarray[0];
+			for (var i=1; i<sarray.length; i++) {
+				if (i <= count) {
+					if (jQuery.isFunction(replacement)) {
+						s += replacement(matches[i-1] || matches) + sarray[i];
+					} else { s += replacement + sarray[i]; }
+				} else { s += (matches[i-1] || matches) + sarray[i]; }
+			}
+			return this.r(arguments,3,s);
+		},
+		/**
+		 * 
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 */
+		succ: function(s) {
+			s = this.s(s);
+			s = s.slice(0, s.length - 1) + String.fromCharCode(s.charCodeAt(s.length - 1) + 1);
+			return this.r(arguments,0,s);
+		},
+		/**
+		 * Concatenate count number of copies of s together and return result.
+		 * @param {Integer} count Number of times to repeat s
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 */
+		times: function(count, s) {
+			s = this.s(s);
+			var newS = "";
+			for (var i=0; i<count; i++) {
+				newS += s;
+			}
+			return this.r(arguments,1,newS);
+		},
+		/**
+		 * Returns a JSON string
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 */
+		toJSON: function(s) {
+			return this.r(arguments,0,this.inspect(true, this.s(s)));
+		},
+		/**
+		 * Parses a URI-like query string and returns an object composed of parameter/value pairs.
+		 * This method is mainly targeted at parsing query strings (hence the default value of '&'
+		 * for the seperator argument). For this reason, it does not consider anything that is either
+		 * before a question mark (which signals the beginning of a query string) or beyond the hash 
+		 * symbol ("#"), and runs decodeURIComponent() on each parameter/value pair.
+		 * @param {Object} separator string to separate parameters (default = '&')
+		 * @param {Object} s
+		 * @return {Object} object
+		 */
+		toQueryParams: function(separator, s) {
+			s = this.s(s);
+			var paramsList = s.substring(s.indexOf('?')+1).split('#')[0].split(separator || '&'), params = {}, i, key, value, pair;
+			for (i=0; i<paramsList.length; i++) {
+				pair = paramsList[i].split('=');
+				key = decodeURIComponent(pair[0]);
+				value = (pair[1])?decodeURIComponent(pair[1]):undefined;
+				if (params[key]) {
+					if (typeof params[key] == "string") { params[key] = [params[key]]; }
+					params[key].push(value);
+				} else { params[key] = value; }
+			}
+			return params;
+		},
+		/**
+		 * truncate from Prototype-1.6.0.2
+		 * Truncates a string to the given length and appends a suffix to it (indicating that it is only an excerpt).
+		 * @param {Object} length length of string to truncate to
+		 * @param {Object} truncation string to concatenate onto truncated string (default = '...')
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 */
+		truncate: function(length, truncation, s) {
+			s = this.s(s);
+			length = length || 30;
+			truncation = (!truncation) ? '...' : truncation;
+			s = (s.length > length) ? s.slice(0, length - truncation.length) + truncation : String(s);
+			return this.r(arguments,2,s);
+		},
+		/**
+		 * Converts a camelized string into a series of words separated by an underscore ("_").
+		 * e.g. $.string('borderBottomWidth').underscore().str = 'border_bottom_width'
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 */
+		underscore: function(s) {
+			s = this.sub(/[A-Z]/, function(c) { return "_"+c.toLowerCase(); }, -1, this.s(s));
+			if (s.charAt(0) == "_") s = s.substring(1);
+			return this.r(arguments,0,s);
+		},
+		/**
+		 * unescapeHTML from Prototype-1.6.0.2 -- If it's good enough for Webkit and IE, it's good enough for Gecko!
+		 * Strips tags and converts the entity forms of special HTML characters to their normal form.
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 */
+		unescapeHTML: function(s) {
+			s = this.stripTags(this.s(s)).replace(/&amp;/g,'&').replace(/&lt;/g,'<').replace(/&gt;/g,'>');
+			return this.r(arguments,0,s);
+		},
+		/**
+		 * unfilterJSON from Prototype-1.6.0.2.
+		 * @param {Function} filter
+		 * @param {String} s string to be evaluated
+		 * @return {Object} .string object (or string if internal)
+		 */
+		unfilterJSON: function(filter, s) {
+			s = this.s(s);
+			filter = filter || this.JSONFilter;
+			var filtered = s.match(filter);
+			s = (filtered !== null)?filtered[1]:s;
+			return this.r(arguments,1,jQuery.trim(s));
+		},
+	
+		/**
+		 * Sets .str property and returns $.string object.
+		 * @param {String} s string to be evaluated
+		 */
+		r: function(args, size, s) {
+			if (args.length > size || this.str === undefined) {
+				return s;
+			} else {
+				this.str = ''+s;
+				return this;
+			};
+		},
+		s: function(s) {
+			if (s === '' || s) { return s; }
+			if (this.str === '' || this.str) { return this.str; }
+			return this;
+		}
+	},
+	string: function(str) {
+		if (str === String.prototype) { jQuery.extend(String.prototype, jQuery.__stringPrototype); }
+		else { return jQuery.extend({ str: str }, jQuery.__stringPrototype); }
+	}
+});
+jQuery.__stringPrototype.parseQuery = jQuery.__stringPrototype.toQueryParams;