condo 0.0.1

data/LGPL3-LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README.textile

@@ -0,0 +1,20 @@
+h1. Condominios
+
+A Rails plugin that makes direct uploads to multiple cloud storage providers easy.
+Only supports "XMLHttpRequest Level 2":http://en.wikipedia.org/wiki/XMLHttpRequest capable browsers and cloud providers that have a "RESTful API":http://en.wikipedia.org/wiki/Representational_state_transfer with "CORS":http://en.wikipedia.org/wiki/Cross-origin_resource_sharing support.
+
+Why compromise?
+
+Get started now: @gem install condo@
+
+
+h2. License
+
+GNU Lesser General Public License v3 (LGPL version 3)
+
+
+h2. Usage
+
+Coming Soon!
+
+

data/Rakefile

@@ -0,0 +1,40 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Condo'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/app/assets/javascripts/condo.js

@@ -0,0 +1,7 @@
+//= require condo/spark-md5
+//= require condo/base64
+//= require condo/uploader
+//= require condo/amazon
+//= require condo/rackspace
+//= require condo/google
+//= require condo/controller

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

@@ -0,0 +1,409 @@
+/**
+*	CoTag Condo Amazon S3 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', 'base64', 'condo_uploader'], factory);
+	} else {
+		// Browser globals
+		factory(jQuery, window.SparkMD5, window.base64, window.CondoUploader);
+	}
+}(function ($, MD5, base64, 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.AmazonS3', ['$rootScope', '$q', function($rootScope, $q) {
+		var PENDING = 0,
+			STARTED = 1,
+			PAUSED = 2,
+			UPLOADING = 3,
+			COMPLETED = 4,
+			ABORTED = 5,
+		
+		
+		
+		hexToBin = function(input) {
+			var result = "";
+			
+			if ((input.length % 2) > 0) {
+				input = '0' + input;
+			}
+			
+			for (var i = 0, length = input.length; i < length; i += 2) {
+				result += String.fromCharCode(parseInt(input.slice(i, i + 2), 16));
+			}
+			
+			return result;
+		},
+		
+		
+		Amazon = function (api, file) {
+			var self = this,
+				strategy = null,
+				part_size = 5242880,			// 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 amazon can confirm they are valid for us
+			//	Part numbers can be any number from 1 to 10,000 - inclusive
+			//	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
+			//
+			AmazonDirect = 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--------------------------------------------------
+			//
+			AmazonChunked = function (data, first_chunk) {
+				//
+				// resume
+				// abort
+				// pause
+				//
+				var part_ids = [],
+					last_part = 0,
+				
+				
+				generatePartManifest = function() {
+					var list = '<CompleteMultipartUpload>';
+					
+					for (var i = 0, length = part_ids.length; i < length; i += 1) {
+						list += '<Part><PartNumber>' + (i + 1) + '</PartNumber><ETag>"' + part_ids[i] + '"</ETag></Part>';
+					}
+					list += '</CompleteMultipartUpload>';
+					return list;
+				},
+				
+				//
+				// 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.edit(part_number, base64.encode(hexToBin(result.data_id))).
+								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) {
+								request['data'] = generatePartManifest();
+								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) {
+						part_ids.push(part_info.data_id);	// We need to record the list of part IDs for completion
+			        		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 grabbing a parts list or creating an upload
+				//
+				api.process_request(data).then(function(response) {
+					if(data.type == 'parts') {	// was the original request for a list of parts
+		        			//
+		        			// NextPartNumberMarker == the final part in the current request
+		        			//	TODO:: if IsTruncated is set then we need to keep getting parts
+		        			//
+		        			response = $(response);
+		        			var next = parseInt(response.find('NextPartNumberMarker').eq(0).text()),
+		        				etags = response.find('ETag');
+		        			
+		        			etags.each(function(index) {
+		        				part_ids.push($(this).text().replace(/"{1}/gi,''));	// Removes " from strings
+		        			});
+		        			
+		        			last_part = next;		// So we can resume
+		        			next_part(next + 1);	// As NextPartNumberMarker is just the last part uploaded
+		        		} else {
+		        			//
+		        			// We've created the upload - we need to update the application with the upload id.
+		        			//	This will also return the request for uploading the first part which we've already prepared
+		        			//
+							api.update({
+								resumable_id: $(response).find('UploadId').eq(0).text(),
+								file_id: base64.encode(hexToBin(first_chunk.data_id)),
+								part: 1
+							}).then(function(data) {
+								set_part(data, first_chunk);		// Parts start at 1
+							}, function(reason) {
+								defaultError(reason);
+								restart();				// Easier to start from the beginning
+							});
+		        		}
+				}, function(reason) {
+					defaultError(reason);
+					restart();		// We need to get a new request signature
+				});
+			}; // 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
+					//
+					// Update part size if required
+					//
+					if((part_size * 9999) < file.size)	{
+						part_size = file.size / 9999;
+						if(part_size > (5 * 1024 * 1024 * 1024)) {		// 5GB limit on part sizes
+							this.abort('file too big');
+							return;
+						}
+					}
+					
+					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: base64.encode(hexToBin(result.data_id))}).
+							then(function(data) {
+								if(data.type == 'direct_upload') {
+									strategy = new AmazonDirect(data);
+								} else {
+									strategy = new AmazonChunked(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 Amazon(api, file);
+			}
+		};
+		
+	}]);
+	
+}));