condo 1.0.4 → 1.0.6

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

@@ -0,0 +1,184 @@
+/**
+*	CoTag Condo
+*	Direct to cloud resumable uploads
+*	
+*   Copyright (c) 2012 CoTag Media.
+*	
+*	@author 	Stephen von Takach <steve@cotag.me>
+* 	@copyright  2012 cotag.me
+* 
+* 	
+* 	References:
+*		* http://ericterpstra.com/2012/09/angular-cats-part-3-communicating-with-broadcast/
+*		* http://docs.angularjs.org/api/ng.$rootScope.Scope#$watch
+*
+**/
+
+
+(function (angular, undefined) {
+	'use strict';
+	
+	//
+	// Create a controller for managing the upload states
+	//
+	angular.module('Condo', ['Core']).
+		controller('Condo.Controller', ['$scope', 'Condo.Api', 'Condo.Broadcast', 'Condo.Config', function($scope, api, broadcaster, config) {
+		
+			$scope.uploads = [];
+			$scope.upload_count = 0;
+			
+			
+			//
+			// See Condo.Config for configuration options
+			//
+			$scope.endpoint = config.endpoint;
+			$scope.autostart = config.autostart;
+			$scope.ignore_errors = config.ignore_errors;			// Continue to autostart after an error?
+			$scope.parallelism = config.parallelism;				// number of uploads at once
+			
+			
+			$scope.add = function(files) {
+				var length = files.length,
+					i = 0,
+					ret = 0,		// We only want to check for auto-start after the files have been added
+					file;
+				
+				for (; i < length; i += 1) {
+					file = files[i];
+					
+					if(file.size <= 0 || file.type == '')
+						continue;
+						
+					//
+					// check file size is acceptable
+					//
+					if(!config.file_checker(file) || (config.size_limit != undefined && file.size > config.size_limit)) {
+						broadcaster.publish('coNotice', {
+							type: 'warn',
+							number: 0,
+							file: file
+						});
+						continue;
+					}
+					
+					$scope.upload_count += 1;
+					
+					api.check_provider($scope.endpoint, files[i]).then(function(upload){
+						ret += 1;
+						$scope.uploads.push(upload);
+						if(ret == length)
+							$scope.check_autostart();
+					}, function(failure) {
+						
+						$scope.upload_count -= 1;
+						
+						ret += 1;
+						if(ret == length)
+							$scope.check_autostart();
+							
+						//
+						// broadcast this so it can be handled by a directive
+						//
+						broadcaster.publish('coNotice', failure);
+					});
+				}
+			};
+			
+			
+			$scope.abort = function(upload) {
+				upload.abort();
+				$scope.check_autostart();
+			};
+			
+			
+			$scope.remove = function(upload) {
+				//
+				// Splice(upload, 1) was unreliable. This is better
+				//
+				for (var i = 0, length = $scope.uploads.length; i < length; i += 1) {
+					if($scope.uploads[i] === upload) {
+						$scope.uploads.splice(i, 1);
+						$scope.upload_count -= 1;
+						break;
+					}
+				}
+			};
+			
+			
+			$scope.playpause = function(upload) {
+				if (upload.state == 3)					// Uploading
+					upload.pause();
+				else
+					upload.start();
+			};
+			
+			
+			//
+			// Watch autostart and trigger a check when it is changed
+			//
+			$scope.$watch('autostart', function(newValue, oldValue) {
+				if (newValue === true)
+					$scope.check_autostart();
+			});
+			
+			
+			//
+			// Autostart more uploads as this is bumped up
+			//
+			$scope.$watch('parallelism', function(newValue, oldValue) {
+				if(newValue > oldValue)
+					$scope.check_autostart();
+			});
+			
+			
+			$scope.check_autostart = function() {
+				//
+				// Check if any uploads have been started already
+				//	If there are no active uploads we'll auto-start
+				//
+				// PENDING = 0,
+				// STARTED = 1,
+				// PAUSED = 2,
+				// UPLOADING = 3,
+				// COMPLETED = 4,
+				// ABORTED = 5
+				//
+				if ($scope.autostart) {
+					var shouldStart = true,
+						state, i, length, started = 0;
+						
+					for (i = 0, length = $scope.uploads.length; i < length; i += 1) {
+						state = $scope.uploads[i].state;
+						
+						//
+						// Count started uploads (that don't have errors if we are ignoring errors)
+						//	Up until we've reached our parallel limit, then stop
+						//
+						if (state > 0 && state < 4 && !($scope.uploads[i].error && $scope.ignore_errors)) {
+							started += 1;
+							if(started >= $scope.parallelism) {
+								shouldStart = false;
+								break;
+							}
+						}
+					}
+					
+					if (shouldStart) {
+						started = $scope.parallelism - started;		// How many can we start
+						
+						for (i = 0; i < length; i += 1) {
+							if ($scope.uploads[i].state == 0) {
+								$scope.uploads[i].start();
+								
+								started -= 1;
+								if(started <= 0)	// Break if we can't start anymore
+									break;
+							}
+						}
+					}
+				}
+			};
+			
+		}]);
+	
+})(angular);

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

@@ -1,80 +1,69 @@
-/**
-*	CoTag Condo
-*	Direct to cloud resumable uploads
-*	
-*   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
-* 		* http://docs.angularjs.org/api/AUTO.$provide
-*		* http://jsfiddle.net/pkozlowski_opensource/PxdSP/14/
-*
-**/
-
-(function (factory) {
-	if (typeof define === 'function' && define.amd) {
-		// AMD
-		define('condo-config', ['jquery', 'condo-uploader'], factory);
-	} else {
-		// Browser globals
-		factory(jQuery, window.CondoUploader);
-	}
-}(function ($, uploads, undefined) {
-	'use strict';
-	
-
-
-	//
-	// Create a provider for defining the configuration
-	//
-	uploads.provider('Condo.Config', function() {
-		
-		//
-		// Controller options
-		//
-		this.endpoint = '/uploads';		// Default endpoint path
-		this.autostart = true;			// Start uploading as soon as the file is added?
-		this.ignore_errors = true;		// Continue to autostart after an error?
-		this.parallelism = 1;			// number of autostarted uploads at once
-		this.size_limit = undefined;	// defaults to unlimited
-		this.file_checker = function(file) {		// client side filtering of files
-				return true;
-		};
-		
-		//
-		// Directive options (specifically for the condo default interface)
-		//
-		this.delegate = undefined;			// defaults to the condo interface container
-		this.drop_targets = undefined;		// defaults to the condo interface container
-		this.hover_class = 'drag-hover';	// for styling the interface
-		this.supress_notifications = false;	// this prevents js alerts about warnings and errors if you are observing these yourself (Condo.Broadcast)
-		
-		
-		
-		this.$get = function() {
-			var self = this;
-			
-			return {
-				endpoint: self.endpoint,
-				autostart: self.autostart,
-				ignore_errors: self.ignore_errors,
-				parallelism: self.parallelism,
-				file_checker: self.file_checker,
-				size_limit: self.size_limit,
-				
-				delegate: self.delegate,
-				drop_targets: self.drop_targets,
-				hover_class: self.hover_class,
-				supress_notifications: self.supress_notifications
-			};
-		};
-	});
-	
-	
-	
-}));
+/**
+*	CoTag Condo
+*	Direct to cloud resumable uploads
+*	
+*   Copyright (c) 2012 CoTag Media.
+*	
+*	@author 	Stephen von Takach <steve@cotag.me>
+* 	@copyright  2012 cotag.me
+* 
+* 	
+* 	References:
+* 		* http://docs.angularjs.org/api/AUTO.$provide
+*		* http://jsfiddle.net/pkozlowski_opensource/PxdSP/14/
+*
+**/
+
+
+(function (angular, undefined) {
+	'use strict';
+	
+	
+	//
+	// Create a provider for defining the configuration
+	//
+	angular.module('Condo').
+		provider('Condo.Config', function() {
+			
+			//
+			// Controller options
+			//
+			this.endpoint = '/uploads';		// Default endpoint path
+			this.autostart = true;			// Start uploading as soon as the file is added?
+			this.ignore_errors = true;		// Continue to autostart after an error?
+			this.parallelism = 1;			// number of autostarted uploads at once
+			this.size_limit = undefined;	// defaults to unlimited
+			this.file_checker = function(file) {		// client side filtering of files
+					return true;
+			};
+			
+			//
+			// Directive options (specifically for the condo default interface)
+			//
+			this.delegate = undefined;			// defaults to the condo interface container
+			this.drop_targets = undefined;		// defaults to the condo interface container
+			this.hover_class = 'drag-hover';	// for styling the interface
+			this.supress_notifications = false;	// this prevents js alerts about warnings and errors if you are observing these yourself (Condo.Broadcast)
+			
+			
+			
+			this.$get = function() {
+				var self = this;
+				
+				return {
+					endpoint: self.endpoint,
+					autostart: self.autostart,
+					ignore_errors: self.ignore_errors,
+					parallelism: self.parallelism,
+					file_checker: self.file_checker,
+					size_limit: self.size_limit,
+					
+					delegate: self.delegate,
+					drop_targets: self.drop_targets,
+					hover_class: self.hover_class,
+					supress_notifications: self.supress_notifications
+				};
+			};
+		});
+	
+})(angular);

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

@@ -1,255 +1,338 @@
-/**
-*	CoTag Condo Amazon S3 Strategy
-*	Direct to cloud resumable uploads for Google Cloud Storage
-*	
-*   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', 'base64', 'condo-uploader'], factory);
-	} else {
-		// Browser globals
-		factory(jQuery, window.base64);
-	}
-}(function ($, base64) {
-	'use strict';
-	
-	angular.module('CondoGoogleProvider', ['CondoUploader', 'CondoAbstractMd5']).run(['$q', 'Condo.Registrar', 'Condo.Md5', function($q, registrar, md5) {
-		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;
-		},
-		
-		
-		GoogleCloudStorage = function (api, file) {
-			var self = this,
-				strategy = null,
-				part_size = 1048576,	// This is the amount of the file we read into memory as we are building the hash (1mb)
-				pausing = false,
-				defaultError = function(reason) {
-					self.error = !pausing;
-					pausing = false;
-					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 Google can confirm they are valid for us
-			//
-			build_request = function() {
-				return md5.hash(file).then(function(val) {
-					return {
-						data: file,
-						data_id: base64.encode(hexToBin(val))
-					}
-				}, function(reason){
-					return $q.reject(reason);
-				});
-			},
-
-			//
-			// Direct file upload strategy
-			//
-			GoogleDirect = 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
-
-
-			//
-			// Resumable upload strategy--------------------------------------------------
-			//
-			GoogleResumable = function (data, first_chunk) {
-				
-			}; // END RESUMABLE
-			
-			
-			//
-			// Variables required for all drivers
-			//
-			this.state = PENDING;
-			this.progress = 0;
-			this.message = 'pending';
-			this.name = file.name;
-			this.size = file.size;
-			this.error = false;
-			
-			
-			//
-			// 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.error = false;
-					pausing = false;
-					this.message = null;
-					this.state = STARTED;
-					strategy = {};			// This function shouldn't be called twice so we need a state
-					
-					build_request().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 GoogleDirect(data);
-								} else {
-									strategy = new GoogleResumable(data, result);
-								}
-							}, defaultError);
-						
-					}, defaultError);	// END BUILD_REQUEST
-					
-					
-				} else if (this.state == PAUSED) {				// We need to resume the upload if it is paused
-					this.error = false;
-					pausing = false;
-					this.message = null;
-					strategy.resume();
-				}
-			};
-			
-			this.pause = function(reason) {
-				if(strategy != null && this.state == UPLOADING) {	// Check if the upload is uploading
-					this.state = PAUSED;
-					pausing = true;
-					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 GOOGLE
-		
-		
-		//
-		// Register the residence with the API
-		//	Dependency injection succeeded
-		//
-		registrar.register('GoogleCloudStorage', {
-			new_upload: function(api, file) {
-				return new GoogleCloudStorage(api, file);
-			}
-		});
-	}]);
-	
-}));
+/**
+*	CoTag Condo Google Strategy
+*	Direct to cloud resumable uploads for Google Cloud Storage
+*	
+*   Copyright (c) 2012 CoTag Media.
+*	
+*	@author 	Stephen von Takach <steve@cotag.me>
+* 	@copyright  2012 cotag.me
+* 
+* 	
+* 	References:
+*		* 
+*
+**/
+
+
+(function(angular, base64, undefined) {
+	'use strict';
+	
+	angular.module('Condo').
+	
+	factory('Condo.Google', ['$q', 'Condo.Md5', function($q, md5) {
+		var PENDING = 0,
+			STARTED = 1,
+			PAUSED = 2,
+			UPLOADING = 3,
+			COMPLETED = 4,
+			ABORTED = 5,
+		
+		
+		
+		hexToBin = function(input) {
+			var result = "", i, length;
+			
+			if ((input.length % 2) > 0) {
+				input = '0' + input;
+			}
+			
+			for (i = 0, length = input.length; i < length; i += 2) {
+				result += String.fromCharCode(parseInt(input.slice(i, i + 2), 16));
+			}
+			
+			return result;
+		},
+		
+		
+		GoogleCloudStorage = function (api, file) {
+			var self = this,
+				strategy = null,
+				pausing = false,
+				defaultError = function(reason) {
+					self.error = !pausing;
+					pausing = false;
+					self.pause(reason);
+				},
+
+			restart = function() {
+				strategy = null;
+			},
+
+
+			completeUpload = function() {
+				api.update().then(function() {
+					self.progress = self.size;	// Update to 100%
+					self.state = COMPLETED;
+				}, defaultError);
+			},
+			
+			
+			//
+			// We need to sign our uploads so Google can confirm they are valid for us
+			//
+			build_request = function(chunk) {
+				return md5.hash(chunk).then(function(val) {
+					return {
+						data: chunk,
+						data_id: base64.encode(hexToBin(val))
+					};
+				}, function(reason){
+					return $q.reject(reason);
+				});
+			},
+
+			//
+			// Direct file upload strategy
+			//
+			GoogleDirect = 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() {
+					finalising = true;
+		        	$this.resume();				// Resume informs the application that the upload is complete
+				}, function(reason) {
+					self.progress = 0;
+					defaultError(reason);
+				});
+			}, // END DIRECT
+
+
+			//
+			// Resumable upload strategy--------------------------------------------------
+			//
+			GoogleResumable = function (data, file_hash, finalising) {
+				var getQueryParams = function(qs) {
+						qs = qs.split("+").join(" ");
+
+						var params = {}, tokens,
+						re = /[?&]?([^=]+)=([^&]*)/g;
+
+						while (tokens = re.exec(qs)) {	// NOTE:: we expect the assignment here
+							params[decodeURIComponent(tokens[1])] = decodeURIComponent(tokens[2]);
+						}
+
+						return params;
+					},
+
+
+					resume_upload = function(request, file_hash, range_start) {
+						request.data = file_hash.data;
+						api.process_request(request, function(progress) {
+							self.progress = range_start + progress;
+						}).then(function(result) {
+							finalising = true;
+							completeUpload();
+						}, function(reason) {
+							defaultError(reason);
+						});
+					};
+
+				
+
+
+				self.state = UPLOADING;
+	
+				this.resume = function() {
+					self.state = UPLOADING;
+					if (finalising == true) {
+						completeUpload();
+					} else {
+						api.create({file_id: file_hash.data_id}).
+						then(function(data) {
+							if(data.type == 'direct_upload') {
+								strategy = new GoogleDirect(data);
+							} else {
+								strategy = new GoogleResumable(data, file_hash);
+							}
+						}, defaultError);
+					}
+				};
+				
+				this.pause = function() {
+					api.abort();
+				};
+
+
+				
+				api.process_request(data).then(function(response) {
+					//
+					// Check if we were grabbing a parts list or creating an upload
+					//
+					if(data.type == 'status') {	// the request was for the byte we are up to
+						// Get the byte we were up to here and update the application
+						var range_start = parseInt(response[1].getResponseHeader('Range').split('-')[1], 10) + 1;
+
+						build_request(file.slice(range_start)).then(function(result) {
+							if (self.state != UPLOADING) {
+								return;						// upload was paused or aborted as we were reading the file
+							}
+							
+							api.edit(range_start, result.data_id).
+								then(function(data) {
+									resume_upload(data, result, range_start);
+								}, defaultError);
+						
+						}, defaultError);	// END BUILD_REQUEST
+					} else {
+						//
+	        			// We've created the upload - we need to update our application with the upload id.
+	        			//	This will also return the request for uploading the file which we've already prepared
+	        			//
+						api.update({
+							resumable_id: getQueryParams(response[1].getResponseHeader('Location').split('?')[1]).upload_id,	// grab the upload_id from the Location header
+							file_id: file_hash.data_id,
+							part: 0						// part for google === the byte we are up to
+						}).then(function(data) {
+							resume_upload(data, file_hash, 0);	// As this is the first upload attempt we want to upload from byte 0
+						}, 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 RESUMABLE
+			
+			
+			//
+			// Variables required for all drivers
+			//
+			this.state = PENDING;
+			this.progress = 0;
+			this.message = 'pending';
+			this.name = file.name;
+			this.size = file.size;
+			this.error = false;
+			
+			
+			//
+			// 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.error = false;
+					pausing = false;
+					this.message = null;
+					this.state = STARTED;
+					strategy = {};			// This function shouldn't be called twice so we need a state
+					
+					build_request(file).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 GoogleDirect(data);
+								} else {
+									strategy = new GoogleResumable(data, result);
+								}
+							}, defaultError);
+						
+					}, defaultError);	// END BUILD_REQUEST
+					
+					
+				} else if (this.state == PAUSED) {				// We need to resume the upload if it is paused
+					this.error = false;
+					pausing = false;
+					this.message = null;
+					strategy.resume();
+				}
+			};
+			
+			this.pause = function(reason) {
+				if(strategy != null && this.state == UPLOADING) {	// Check if the upload is uploading
+					this.state = PAUSED;
+					pausing = true;
+					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 GOOGLE
+		
+		
+		return {
+			new_upload: function(api, file) {
+				return new GoogleCloudStorage(api, file);
+			}
+		};
+	}]).
+
+	config(['Condo.ApiProvider', function (ApiProvider) {
+		ApiProvider.register('GoogleCloudStorage', 'Condo.Google');
+	}]);
+	
+})(angular, window.base64);