condo 0.0.1

data/app/assets/javascripts/condo/rackspace.js

@@ -0,0 +1,340 @@
+/**
+*	CoTag Condo Rackspace Cloud Files Strategy
+*	Direct to cloud resumable uploads for Amazon S3
+*	
+*   Copyright (c) 2012 CoTag Media.
+*	
+*	@author 	Stephen von Takach <steve@cotag.me>
+* 	@copyright  2012 cotag.me
+* 
+* 	
+* 	References:
+* 		* https://github.com/umdjs/umd
+* 		* https://github.com/addyosmani/jquery-plugin-patterns
+*		* 
+*
+**/
+
+(function (factory) {
+	if (typeof define === 'function' && define.amd) {
+		// AMD
+		define(['jquery', 'spark-md5', 'condo_uploader'], factory);
+	} else {
+		// Browser globals
+		factory(jQuery, window.SparkMD5, window.CondoUploader);
+	}
+}(function ($, MD5, uploads, undefined) {
+	'use strict';
+	
+	//
+	// TODO:: Create an Amazon, google factory etc
+	//	We should split all these into different files too (controller and factories separate from directives and views)
+	//	So we can have different views for the same controller
+	//
+	uploads.factory('Condo.RackspaceCloudFiles', ['$rootScope', '$q', function($rootScope, $q) {
+		var PENDING = 0,
+			STARTED = 1,
+			PAUSED = 2,
+			UPLOADING = 3,
+			COMPLETED = 4,
+			ABORTED = 5,
+		
+		
+		Rackspace = function (api, file) {
+			var self = this,
+				strategy = null,
+				part_size = 2097152,			// Multi-part uploads should be bigger then this
+				defaultError = function(reason) {
+					self.pause(reason);
+				},
+
+			restart = function() {
+				strategy = null;
+			},
+
+
+			completeUpload = function() {
+				api.update().then(function(data) {
+						self.state = COMPLETED;
+				}, defaultError);
+			},
+			
+			
+			//
+			// We need to sign our uploads so rackspace can confirm they are valid for us
+			//	TODO:: use http://updates.html5rocks.com/2011/12/Transferable-Objects-Lightning-Fast
+			//		where available :)
+			//
+			build_request = function(part_number) {
+				var result = $q.defer(),
+					reader = new FileReader(),
+					fail = function(){
+						result.reject('file read failed');
+					},
+					current_part;
+				
+				if (file.size > part_size) {		// If file bigger then 5mb we expect a chunked upload
+					var endbyte = part_number * part_size;
+					if (endbyte > file.size)
+						endbyte = file.size;
+					current_part = file.slice((part_number - 1) * part_size, endbyte);
+				} else {
+					current_part = file;
+				}
+				
+				reader.onload = function(e) {
+					result.resolve({
+						data: current_part,
+						data_id: MD5.hashBinary(e.target.result),
+						part_number: part_number
+					});
+					
+					
+					if(!$rootScope.$$phase) {
+						$rootScope.$apply();					// This triggers the promise response if required
+					}
+				};
+				reader.onerror = fail;
+				reader.onabort = fail;
+				reader.readAsBinaryString(current_part);
+				
+				return result.promise;
+			},
+
+			//
+			// Direct file upload strategy
+			//
+			RackspaceDirect = function(data) {
+				//
+				// resume
+				// abort
+				// pause
+				//
+				var $this = this,
+					finalising = false;
+					
+				//
+				// Update the parent
+				//
+				self.state = UPLOADING;
+	
+				
+				//
+				// This will only be called when the upload has finished and we need to inform the application
+				//
+				this.resume = function() {
+					self.state = UPLOADING;
+					completeUpload();
+				}
+				
+				this.pause = function() {
+					api.abort();
+					
+					if(!finalising) {
+						restart();		// Should occur before events triggered
+						self.progress = 0;
+					}
+				};
+				
+				
+				//
+				// AJAX for upload goes here
+				//
+				data['data'] = file;
+				api.process_request(data, function(progress) {
+					self.progress = progress;
+				}).then(function(result) {
+					finalising = true;
+		        	$this.resume();				// Resume informs the application that the upload is complete
+				}, function(reason) {
+					self.progress = 0;
+					defaultError(reason);
+				});
+			}, // END DIRECT
+
+
+			//
+			// Chunked upload strategy--------------------------------------------------
+			//
+			RackspaceChunked = function (data, first_chunk) {
+				//
+				// resume
+				// abort
+				// pause
+				//
+				var last_part = 0,
+				
+				//
+				// Get the next part signature
+				//
+				next_part = function(part_number) {
+					//
+					// Check if we are past the end of the file
+					//
+					if ((part_number - 1) * part_size < file.size) {
+						build_request(part_number).then(function(result) {
+							if (self.state != UPLOADING)
+								return;						// upload was paused or aborted as we were reading the file
+							
+							api.update({
+								resumable_id: part_number,
+								file_id: result.data_id,
+								part: part_number
+							}).then(function(data) {
+								set_part(data, result);
+							}, defaultError);
+						
+						}, function(reason){
+							self.pause(reason);
+						});	// END BUILD_REQUEST
+						
+					} else {
+						//
+						// We're after the final commit
+						//
+						api.edit('finish').
+							then(function(request) {
+								api.process_request(request).then(completeUpload, defaultError);
+							}, defaultError);
+					}
+				},
+				
+					
+				//
+				// Send a part to amazon
+				//
+				set_part = function(request, part_info) {
+					request['data'] = part_info.data;
+					api.process_request(request, function(progress) {
+						self.progress = (part_info.part_number - 1) * part_size + progress;
+					}).then(function(result) {
+			        	last_part = part_info.part_number;
+			        	next_part(last_part + 1);
+					}, function(reason) {
+						self.progress = (part_info.part_number - 1) * part_size;
+						defaultError(reason);
+					});
+				};
+					
+
+				self.state = UPLOADING;
+	
+				this.resume = function() {
+					self.state = UPLOADING;
+					next_part(last_part + 1);
+				};
+				
+				this.pause = function() {
+					api.abort();
+				};
+				
+				
+				//
+				// We need to check if we are resuming or starting an upload
+				//
+				if(data.type == 'parts') {
+					next_part(data.current_part);
+				} else {
+					set_part(data, first_chunk);
+				}
+			}; // END CHUNKED
+			
+			
+			//
+			// Variables required for all drivers
+			//
+			this.state = PENDING;
+			this.progress = 0;
+			this.message = 'pending';
+			this.name = file.name;
+			this.size = file.size;
+			
+			
+			//
+			// Support file slicing
+			//	
+			if (typeof(file.slice) != 'function')
+				file.slice = file.webkitSlice || file.mozSlice;
+			
+			
+			this.start = function(){
+				if(strategy == null) {	// We need to create the upload
+					
+					this.message = null;
+					this.state = STARTED;
+					strategy = {};			// This function shouldn't be called twice so we need a state (TODO:: fix this)
+					
+					build_request(1).then(function(result) {
+						if (self.state != STARTED)
+							return;						// upload was paused or aborted as we were reading the file
+						
+						api.create({file_id: result.data_id}).
+							then(function(data) {
+								if(data.type == 'direct_upload') {
+									strategy = new RackspaceDirect(data);
+								} else {
+									strategy = new RackspaceChunked(data, result);
+								}
+							}, defaultError);
+						
+					}, function(reason){
+						self.pause(reason);
+					});	// END BUILD_REQUEST
+					
+					
+				} else if (this.state == PAUSED) {				// We need to resume the upload if it is paused
+					this.message = null;
+					strategy.resume();
+				}
+			};
+			
+			this.pause = function(reason) {
+				if(strategy != null && this.state == UPLOADING) {	// Check if the upload is uploading
+					this.state = PAUSED;
+					strategy.pause();
+				} else if (this.state <= STARTED) {
+					this.state = PAUSED;
+					restart();
+				}
+				if(this.state == PAUSED)
+					this.message = reason;
+			};
+			
+			this.abort = function(reason) {
+				if(strategy != null && this.state < COMPLETED) {	// Check the upload has not finished
+					var old_state = this.state;
+					
+					this.state = ABORTED;
+					api.abort();
+					
+					
+					//
+					// As we may not have successfully deleted the upload
+					//	or we aborted before we received a response from create
+					//
+					restart();	// nullifies strategy
+					
+					
+					//
+					// if we have an upload_id then we should destroy the upload
+					//	we won't worry if this fails as it should be automatically cleaned up by the back end
+					//
+					if(old_state > STARTED) {
+						api.destroy();
+					}
+					
+					this.message = reason;
+				}
+			};
+		}; // END AMAZON
+		
+		
+		return {
+			new_upload: function(api, file) {
+				return new Rackspace(api, file);
+			}
+		};
+		
+	}]);
+	
+}));

data/app/assets/javascripts/condo/spark-md5.js

@@ -0,0 +1,470 @@
+/*jslint bitwise: true, nomen: true */
+/*global unescape*/
+
+/**
+ * SparkMD5 is a fast md5 implementation of the MD5 algorithm.
+ * This script is based in the JKM md5 library which is the
+ * fastest algorithm around (see: http://jsperf.com/md5-shootout/7).
+ *
+ * NOTE: Please disable Firebug while testing this script!
+ *       Firebug consumes a lot of memory and CPU and slows down by a great margin.
+ *       Opera Dragonfly also slows down by a great margin.
+ *       Safari/Chrome developer tools seems not to slow it down.
+ *
+ * Improvements over the JKM md5 library:
+ *
+ * - Functionality wrapped in a closure
+ * - Object oriented library
+ * - Incremental md5 (see bellow)
+ * - Validates using jslint
+ *
+ * Incremental md5 performs a lot better for hashing large ammounts of data, such as
+ * files. One could read files in chunks, using the FileReader & Blob's, and append
+ * each chunk for md5 hashing while keeping memory usage low. See example bellow.
+ *
+ * @example
+ *
+ * Normal usage:
+ *
+ *    var hexHash = SparkMD5.hash('Hi there');       // hex hash
+ *    var rawHash = SparkMD5.hash('Hi there', true); // raw hash
+ *
+ * Incremental usage:
+ *
+ *    var spark = new SparkMD5();
+ *    spark.append('Hi');
+ *    spark.append(' there');
+ *    var hexHash = spark.end();                    // hex hash
+ *    var rawHash = spark.end(true);                // raw hash
+ *
+ * Hash a file incrementally:
+ *
+ *   NOTE: If you test the code bellow using the file:// protocol in chrome you must start the browser with -allow-file-access-from-files argument.
+ *         Please see: http://code.google.com/p/chromium/issues/detail?id=60889
+ *
+ *   document.getElementById("file").addEventListener("change", function() {
+ *
+ *       var fileReader = new FileReader(),
+ *           blobSlice = File.prototype.mozSlice || File.prototype.webkitSlice || File.prototype.slice,
+ *           file = document.getElementById("file").files[0],
+ *           chunkSize = 2097152,                           // read in chunks of 2MB
+ *           chunks = Math.ceil(file.size / chunkSize),
+ *           currentChunk = 0,
+ *           spark = new SparkMD5();
+ *
+ *       fileReader.onload = function(e) {
+ *           console.log("read chunk nr", currentChunk + 1, "of", chunks);
+ *           spark.appendBinary(e.target.result);           // append binary string
+ *           currentChunk++;
+ *
+ *           if (currentChunk < chunks) {
+ *               loadNext();
+ *           }
+ *           else {
+ *              console.log("finished loading");
+ *              console.info("computed hash", spark.end()); // compute hash
+ *           }
+ *       };
+ *
+ *       function loadNext() {
+ *           var start = currentChunk * chunkSize,
+ *               end = start + chunkSize >= file.size ? file.size : start + chunkSize;
+ *
+ *           fileReader.readAsBinaryString(blobSlice.call(file, start, end));
+ *       };
+ *
+ *       loadNext();
+ *   });
+ *
+ * @TODO: Add support for byteArrays.
+ * @TODO: Add support for HMAC.
+ * @TODO: Add native support for reading files? Maybe add it as an extension?
+ */
+(function (factory) {
+	if (typeof exports === 'object') {
+		// Node/CommonJS
+		exports.SparkMD5 = factory();
+	} else if (typeof define === 'function' && define.amd) {
+        // AMD
+        define('spark-md5', factory);
+    } else {
+        // Browser globals
+        window.SparkMD5 = factory();
+    }
+}(function (undefined) {
+
+    "use strict";
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    /*
+     * Fastest md5 implementation around (JKM md5)
+     * Credits: Joseph Myers
+     *
+     * @see http://www.myersdaily.org/joseph/javascript/md5-text.html
+     * @see http://jsperf.com/md5-shootout/7
+     */
+
+    /* this function is much faster,
+      so if possible we use it. Some IEs
+      are the only ones I know of that
+      need the idiotic second function,
+      generated by an if clause.  */
+    var add32 = function (a, b) {
+        return (a + b) & 0xFFFFFFFF;
+    };
+
+    function cmn(q, a, b, x, s, t) {
+        a = add32(add32(a, q), add32(x, t));
+        return add32((a << s) | (a >>> (32 - s)), b);
+    }
+
+    function ff(a, b, c, d, x, s, t) {
+        return cmn((b & c) | ((~b) & d), a, b, x, s, t);
+    }
+
+    function gg(a, b, c, d, x, s, t) {
+        return cmn((b & d) | (c & (~d)), a, b, x, s, t);
+    }
+
+    function hh(a, b, c, d, x, s, t) {
+        return cmn(b ^ c ^ d, a, b, x, s, t);
+    }
+
+    function ii(a, b, c, d, x, s, t) {
+        return cmn(c ^ (b | (~d)), a, b, x, s, t);
+    }
+
+    function md5cycle(x, k) {
+        var a = x[0],
+            b = x[1],
+            c = x[2],
+            d = x[3];
+
+        a = ff(a, b, c, d, k[0], 7, -680876936);
+        d = ff(d, a, b, c, k[1], 12, -389564586);
+        c = ff(c, d, a, b, k[2], 17, 606105819);
+        b = ff(b, c, d, a, k[3], 22, -1044525330);
+        a = ff(a, b, c, d, k[4], 7, -176418897);
+        d = ff(d, a, b, c, k[5], 12, 1200080426);
+        c = ff(c, d, a, b, k[6], 17, -1473231341);
+        b = ff(b, c, d, a, k[7], 22, -45705983);
+        a = ff(a, b, c, d, k[8], 7, 1770035416);
+        d = ff(d, a, b, c, k[9], 12, -1958414417);
+        c = ff(c, d, a, b, k[10], 17, -42063);
+        b = ff(b, c, d, a, k[11], 22, -1990404162);
+        a = ff(a, b, c, d, k[12], 7, 1804603682);
+        d = ff(d, a, b, c, k[13], 12, -40341101);
+        c = ff(c, d, a, b, k[14], 17, -1502002290);
+        b = ff(b, c, d, a, k[15], 22, 1236535329);
+
+        a = gg(a, b, c, d, k[1], 5, -165796510);
+        d = gg(d, a, b, c, k[6], 9, -1069501632);
+        c = gg(c, d, a, b, k[11], 14, 643717713);
+        b = gg(b, c, d, a, k[0], 20, -373897302);
+        a = gg(a, b, c, d, k[5], 5, -701558691);
+        d = gg(d, a, b, c, k[10], 9, 38016083);
+        c = gg(c, d, a, b, k[15], 14, -660478335);
+        b = gg(b, c, d, a, k[4], 20, -405537848);
+        a = gg(a, b, c, d, k[9], 5, 568446438);
+        d = gg(d, a, b, c, k[14], 9, -1019803690);
+        c = gg(c, d, a, b, k[3], 14, -187363961);
+        b = gg(b, c, d, a, k[8], 20, 1163531501);
+        a = gg(a, b, c, d, k[13], 5, -1444681467);
+        d = gg(d, a, b, c, k[2], 9, -51403784);
+        c = gg(c, d, a, b, k[7], 14, 1735328473);
+        b = gg(b, c, d, a, k[12], 20, -1926607734);
+
+        a = hh(a, b, c, d, k[5], 4, -378558);
+        d = hh(d, a, b, c, k[8], 11, -2022574463);
+        c = hh(c, d, a, b, k[11], 16, 1839030562);
+        b = hh(b, c, d, a, k[14], 23, -35309556);
+        a = hh(a, b, c, d, k[1], 4, -1530992060);
+        d = hh(d, a, b, c, k[4], 11, 1272893353);
+        c = hh(c, d, a, b, k[7], 16, -155497632);
+        b = hh(b, c, d, a, k[10], 23, -1094730640);
+        a = hh(a, b, c, d, k[13], 4, 681279174);
+        d = hh(d, a, b, c, k[0], 11, -358537222);
+        c = hh(c, d, a, b, k[3], 16, -722521979);
+        b = hh(b, c, d, a, k[6], 23, 76029189);
+        a = hh(a, b, c, d, k[9], 4, -640364487);
+        d = hh(d, a, b, c, k[12], 11, -421815835);
+        c = hh(c, d, a, b, k[15], 16, 530742520);
+        b = hh(b, c, d, a, k[2], 23, -995338651);
+
+        a = ii(a, b, c, d, k[0], 6, -198630844);
+        d = ii(d, a, b, c, k[7], 10, 1126891415);
+        c = ii(c, d, a, b, k[14], 15, -1416354905);
+        b = ii(b, c, d, a, k[5], 21, -57434055);
+        a = ii(a, b, c, d, k[12], 6, 1700485571);
+        d = ii(d, a, b, c, k[3], 10, -1894986606);
+        c = ii(c, d, a, b, k[10], 15, -1051523);
+        b = ii(b, c, d, a, k[1], 21, -2054922799);
+        a = ii(a, b, c, d, k[8], 6, 1873313359);
+        d = ii(d, a, b, c, k[15], 10, -30611744);
+        c = ii(c, d, a, b, k[6], 15, -1560198380);
+        b = ii(b, c, d, a, k[13], 21, 1309151649);
+        a = ii(a, b, c, d, k[4], 6, -145523070);
+        d = ii(d, a, b, c, k[11], 10, -1120210379);
+        c = ii(c, d, a, b, k[2], 15, 718787259);
+        b = ii(b, c, d, a, k[9], 21, -343485551);
+
+        x[0] = add32(a, x[0]);
+        x[1] = add32(b, x[1]);
+        x[2] = add32(c, x[2]);
+        x[3] = add32(d, x[3]);
+
+    }
+
+    /* there needs to be support for Unicode here,
+       * unless we pretend that we can redefine the MD-5
+       * algorithm for multi-byte characters (perhaps
+       * by adding every four 16-bit characters and
+       * shortening the sum to 32 bits). Otherwise
+       * I suggest performing MD-5 as if every character
+       * was two bytes--e.g., 0040 0025 = @%--but then
+       * how will an ordinary MD-5 sum be matched?
+       * There is no way to standardize text to something
+       * like UTF-8 before transformation; speed cost is
+       * utterly prohibitive. The JavaScript standard
+       * itself needs to look at this: it should start
+       * providing access to strings as preformed UTF-8
+       * 8-bit unsigned value arrays.
+       */
+    function md5blk(s) { /* I figured global was faster.   */
+        var md5blks = [],
+            i; /* Andy King said do it this way. */
+        for (i = 0; i < 64; i += 4) {
+            md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+        }
+        return md5blks;
+    }
+
+    function md51(s) {
+        var n = s.length,
+            state = [1732584193, -271733879, -1732584194, 271733878],
+            i,
+            length,
+            tail;
+        for (i = 64; i <= n; i += 64) {
+            md5cycle(state, md5blk(s.substring(i - 64, i)));
+        }
+        s = s.substring(i - 64);
+        length = s.length;
+        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
+        }
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(state, tail);
+            for (i = 0; i < 16; i += 1) {
+                tail[i] = 0;
+            }
+        }
+        tail[14] = n * 8;
+        md5cycle(state, tail);
+        return state;
+    }
+
+    /*jslint vars: true*/
+    var hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
+    /*jslint vars: false*/
+
+    function rhex(n) {
+        var s = '',
+            j;
+        for (j = 0; j < 4; j += 1) {
+            s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];
+        }
+        return s;
+    }
+
+    function hex(x) {
+        var i;
+        for (i = 0; i < x.length; i += 1) {
+            x[i] = rhex(x[i]);
+        }
+        return x.join('');
+    }
+
+    function md5(s) {
+        return hex(md51(s));
+    }
+
+    if (md5('hello') !== '5d41402abc4b2a76b9719d911017c592') {
+        add32 = function (x, y) {
+            var lsw = (x & 0xFFFF) + (y & 0xFFFF),
+                msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+            return (msw << 16) | (lsw & 0xFFFF);
+        };
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * SparkMD5 OOP implementation.
+     *
+     * Use this class to perform an incremental md5, otherwise use the
+     * static methods instead.
+     */
+    /*jslint vars: true*/
+    var SparkMD5 = function () {
+        /*jslint vars: false*/
+        // call reset to init the instance
+        this.reset();
+    };
+
+    /**
+     * Appends a string.
+     * A conversion will be applied if an utf8 string is detected.
+     *
+     * @param {String} str The string to be appended
+     *
+     * @return {SparkMD5} The instance itself
+     */
+    SparkMD5.prototype.append = function (str) {
+        // converts the string to utf8 bytes if necessary
+        if (/[\u0080-\uFFFF]/.test(str)) {
+            str = unescape(encodeURIComponent(str));
+        }
+
+        // then append as binary
+        this.appendBinary(str);
+
+        return this;
+    };
+
+    /**
+     * Appends a binary string.
+     *
+     * @param {String} contents The binary string to be appended
+     *
+     * @return {SparkMD5} The instance itself
+     */
+    SparkMD5.prototype.appendBinary = function (contents) {
+        // add to the buffer and increment string total length
+        var offset = 64 - this._buff.length,
+            sub = this._buff + contents.substr(0, offset),
+            length = contents.length,
+            total;
+
+        this._length += length;
+
+        if (sub.length >= 64) { // if there is 64 bytes accumulated
+
+            md5cycle(this._state, md5blk(sub));
+
+            total = contents.length - 64;
+
+            // while we got bytes to process
+            while (offset <= total) {
+                sub = contents.substr(offset, 64);
+                md5cycle(this._state, md5blk(sub));
+                offset += 64;
+            }
+
+            this._buff = contents.substr(offset, 64);
+
+        } else {
+            this._buff = sub;
+        }
+
+        return this;
+    };
+
+    /**
+     * Finishes the incremental computation, reseting the internal state and
+     * returning the result.
+     * Use the raw parameter to obtain the raw result instead of the hex one.
+     *
+     * @param {Boolean} raw True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.prototype.end = function (raw) {
+        var buff = this._buff,
+            length = buff.length,
+            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            i,
+            ret;
+
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);
+        }
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(this._state, tail);
+            for (i = 0; i < 16; i += 1) {
+                tail[i] = 0;
+            }
+        }
+        tail[14] = this._length * 8;
+        md5cycle(this._state, tail);
+
+        ret = !!raw ? this._state : hex(this._state);
+
+        this.reset();
+
+        return ret;
+    };
+
+    /**
+     * Resets the internal state of the computation.
+     *
+     * @return {SparkMD5} The instance itself
+     */
+    SparkMD5.prototype.reset = function () {
+        this._buff = "";
+        this._length = 0;
+        this._state = [1732584193, -271733879, -1732584194, 271733878];
+
+        return this;
+    };
+
+    /**
+     * Releases memory used by the incremental buffer and other aditional
+     * resources. If you plan to use the instance again, use reset instead.
+     */
+    SparkMD5.prototype.destroy = function () {
+        delete this._state;
+        delete this._buff;
+        delete this._length;
+    };
+
+    /**
+     * Performs the md5 hash on a string.
+     * A conversion will be applied if utf8 string is detected.
+     *
+     * @param {String}  str The string
+     * @param {Boolean} raw True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.hash = function (str, raw) {
+        // converts the string to utf8 bytes if necessary
+        if (/[\u0080-\uFFFF]/.test(str)) {
+            str = unescape(encodeURIComponent(str));
+        }
+
+        var hash = md51(str);
+
+        return !!raw ? hash : hex(hash);
+    };
+
+    /**
+     * Performs the md5 hash on a binary string.
+     *
+     * @param {String}  content The binary string
+     * @param {Boolean} raw     True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.hashBinary = function (content, raw) {
+        var hash = md51(content);
+
+        return !!raw ? hash : hex(hash);
+    };
+
+    return SparkMD5;
+}));